ftnchek - En ligne dans le Cloud

PROGRAMME:

Nom

ftnchek - Vérificateur de programme Fortran 77

SYNOPSIS

ftnchek [ -arguments[=liste] ] [ -déployer[=liste] ]
[ -[aucune]bref ] [ -arbre d'appel[=liste] ] [ -[aucune]vérifier ]
[ -Colonnes[=num] ] [ -commun[=liste] ]
[ -[aucune]référence croisée[=liste] ] [ -[aucune]déclarer ]
[ -[aucune]division ] [ -les erreurs[=num] ] [ -[aucune]externe ]
[ -[aucune]f77[=liste] ] [ -[aucune]f90[=liste] ]
[ -[aucune]f95[=liste] ] [ -[aucune]aider ]
[ -[aucune]identifiant-chars[=liste] ] [ -inclure=str ]
[ -intrinsèque[=liste] ] [ -[aucune]bibliothèque ] [ -[aucune]liste ]
[ -makedcls[=liste] ] [ -mkhtml[=liste] ]
[ -[aucune]novice ] [ -sortie=str ]
[ -taille du pointeur[=num] ] [ -[aucune]portabilité[=liste] ]
[ -[aucune]assez[=liste] ] [ -projet[=liste] ]
[ -[aucune]pur ] [ -[aucune]calme ] [ -[aucune]référence ]
[ -[aucune]ressources ] [ -[aucune]sixcar ] [ -[aucune]sort ]
[ -source[=liste] ] [ De style[=liste] ] [ -[aucune]tabulation symbolique ]
[ -[aucune]troncature[=liste] ] [ -usage[=liste] ]
[ -[aucune]VCG ] [ -[aucune]version ] [ -[aucune]volatile ]
[ -taille de mot[=num] ] [ -envelopper[=num] ] [ fichiers ]

DESCRIPTION

ftnchek (abréviation de Fortran checker) est conçu pour détecter certaines erreurs dans un Fortran
programme qu'un compilateur ne fait généralement pas. ftnchek n'est pas principalement destiné à détecter
erreurs de syntaxe. Son but est d'aider l'utilisateur à trouver des erreurs sémantiques. Sémantique
les erreurs sont légales dans la langue Fortran mais sont inutiles ou peuvent causer des erreurs
opération. Par exemple, des variables qui ne sont jamais utilisées peuvent indiquer une omission dans le
programme; les variables non initialisées contiennent des ordures qui peuvent entraîner des résultats incorrects
calculé; et les variables qui ne sont pas déclarées peuvent ne pas avoir le type prévu. ftnchek
est destiné à assister les utilisateurs dans le débogage de leur programme Fortran. Ce n'est pas prévu
pour détecter toutes les erreurs de syntaxe. C'est la fonction du compilateur. Avant d'utiliser
ftnchek, l'utilisateur doit vérifier que le programme se compile correctement.

Ce document résume d'abord comment invoquer ftnchek. Cette section doit être lue avant
commencer à utiliser ftnchek. Les sections suivantes décrivent ftnchekles options de plus en détail, donnez
un exemple de son utilisation et expliquez comment interpréter le résultat. Les dernières sections
mentionner les limitations et les bogues connus dans ftnchek.

INVOQUER FTNCHEK

ftnchek est invoqué via une commande de la forme :

$ ftnchek [-option -option ...] nom de fichier [nom de fichier ...]

Les parenthèses indiquent quelque chose qui est facultatif. Les crochets eux-mêmes ne sont pas
effectivement tapé. Ici, les options sont des commutateurs ou des paramètres de ligne de commande, qui contrôlent le
fonctionnement du programme et la quantité d'informations qui seront imprimées. Sinon
est spécifiée, l'action par défaut consiste à imprimer les messages d'erreur, les avertissements et
messages d'information, mais pas la liste des programmes ou les tables de symboles.

Chaque option commence par le caractère '-'. (Sur les systèmes VAX/VMS ou MS-DOS, vous pouvez utiliser
soit '/' soit '-'.) Par souci de conformité avec une convention de plus en plus courante,
les options peuvent également commencer par '--'. Les options sont décrites plus en détail dans le prochain
.

ftnchek les options se répartissent en deux catégories : les commutateurs, qui sont soit vrais soit faux, et
paramètres, qui ont une valeur numérique ou de chaîne. Le nom d'un commutateur est préfixé par « non »
ou 'non-' pour le désactiver : par exemple -pas pur désactiverait les avertissements concernant les fonctions impures.
Le préfixe « non » peut également être utilisé avec des paramètres numériques, ce qui a pour effet de désactiver
les avertissements correspondants. Les paramètres qui contrôlent les listes d'avertissements ont une syntaxe spéciale
discuté ci-dessous. Seuls les 3 premiers caractères d'un nom d'option (sans compter le '-')
besoin d'être fourni. Un deux-points peut être utilisé à la place d'un signe égal pour un nombre ou une chaîne
définir les affectations ; cependant, nous ne montrons que la forme du signe égal ci-dessous.

Les commutateurs et les réglages qui ftnchek reconnaît actuellement sont répertoriés ci-dessous. Pour chaque
option, la valeur par défaut est la valeur utilisée si l'option n'est pas explicitement spécifiée, tandis que le
turn-on est la valeur utilisée si l'option est donnée sans lui affecter de valeur.

-arguments=liste
Contrôlez les avertissements concernant le type de sous-programme et les incohérences d'arguments. Par défaut = activer
= tout.

-tableau=liste
Contrôlez les avertissements lors de la vérification des arguments de tableau des sous-programmes. Par défaut = activer =
tout.

-bref Utilisez un format plus court pour certains messages d'erreur. Par défaut = non.

-arbre d'appel=liste
Produire une hiérarchie d'appels de sous-programme dans l'un des 3 formats : arbre d'appels texte, qui appelle-
qui et VCG. Par défaut = aucun, activer = arbre, tailler, trier.

Si la -mkhtml l'option est invoquée et tree est l'option calltree appliquée, un fichier
nommé CallTree.html, sera produit représentant l'arbre au format HTML.

-vérifier Effectuez la vérification. Par défaut = oui.

-colonnes=num
Définir la longueur de ligne maximale sur num Colonnes. (Au-delà, ceci est ignoré.) Allumage = max =
132. Par défaut = 72.

-commun=liste
Définir le degré de rigueur dans la vérification des blocs COMMON. Par défaut = activer = tout.

-référence croisée=liste
Imprimer la liste des références croisées des appels de sous-programme, l'utilisation des étiquettes et/ou le bloc COMMUN
utilisation. Par défaut = aucun.

-déclarer
Affiche une liste de tous les identifiants dont le type de données n'est pas explicitement déclaré. Défaut
= non.

-division
Avertir chaque fois que la division est effectuée (sauf division par une constante). Par défaut = non.

-erreurs=num
Définissez le nombre maximum de messages d'erreur par cascade. Par défaut = allumer = 3.

-externe
Avertir si les sous-programmes externes qui sont appelés ne sont jamais définis. Par défaut = oui.

-f77=liste
Contrôlez les avertissements spécifiques concernant les extensions prises en charge par la norme Fortran 77.
Par défaut = aucun, activer = tous.

-f90=liste
Contrôler les avertissements spécifiques sur les extensions prises en charge à la norme Fortran 77
qui n'ont pas été adoptés dans le cadre de la norme Fortran 90. Par défaut = aucun, activer
= tout.

-f95=liste
Contrôler les avertissements spécifiques concernant les fonctionnalités Fortran 77 standard qui ont été supprimées de
la norme Fortran 95. Par défaut = aucun, activer = tous.

-Aide Imprimer le résumé de la commande. Par défaut = non.

-identifiant-chars=liste
Définissez des caractères non alphanumériques pouvant être utilisés dans les identifiants. Par défaut =
allumer = signe dollar et trait de soulignement.

-inclure=chemin
Définir un répertoire pour rechercher les fichiers INCLUDE avant de rechercher dans l'ensemble du système
annuaire. Cumulatif. Par défaut = activer = aucun.

-intrinsèque=liste
Contrôler le traitement des fonctions intrinsèques non standard. Par défaut = tout sauf etc. en
Version Unix, tous sauf unix pour la version VMS, tous sauf unix et etc. Pour les autres
versions. Allumer = tout.

-bibliothèque
Commencer le mode bibliothèque : ne pas avertir des sous-programmes dans le fichier qui sont définis mais
jamais utilisé. Par défaut = non.

-liste Imprimer la liste des sources du programme. Par défaut = non.

-makedcls=liste
Préparer un dossier de déclarations. Les liste spécifie les options pour le format de ce
déposer. Par défaut = aucun, activation = déclarations.

-mkhtml=liste
Créez des fichiers de document HTML individuels à partir de l'analyse ftnchek et des commentaires de code.
Habituellement, vous voudrez également spécifier -call=arbre pour créer le fichier HTML racine
CallTree.html. Par défaut = aucun, activer = documents.

-novice
Donne une sortie adaptée aux utilisateurs novices. Par défaut = oui.

-sortie=nom de fichier
Envoie la sortie vers le fichier donné. La valeur par défaut et l'activation envoient la sortie à l'écran.
(L'extension de nom de fichier par défaut est .lis).

-taille du pointeur=num
Définissez la taille des variables ``Cray pointer'' sur num octets. Min = 1, max = 16.
Par défaut = allumer = 4

-portabilité=liste
Avertir des utilisations non portables. Par défaut = aucun, activer = tous.

-jolie=liste
Donner des avertissements pour une apparence potentiellement trompeuse du code source. Par défaut = tour-
sur = tout.

-projet=liste
Créez un fichier de projet (voir explication ci-dessous). Par défaut = non.

-pur Supposons que les fonctions sont pures, c'est-à-dire qu'elles n'ont pas d'effets secondaires. Par défaut = oui.

-silencieux Produisez une sortie moins verbeuse. Par défaut = non.

-référence
Imprimer le tableau des sous-programmes référencés par chaque sous-programme. Par défaut = non.

-Ressources
Imprimer la quantité de ressources utilisées pour analyser le programme. Par défaut = non.

-six caractères
Répertoriez tous les noms de variables qui entrent en conflit avec une longueur de 6 caractères. Par défaut = non.

-sorte Imprimer la liste des sous-programmes triés dans l'ordre des prérequis. Par défaut = non.

-source=liste
Sélectionnez les options de formatage de la source : forme fixe ou libre, formaté par onglet DEC Fortran
lignes, instruction INCLUDE de style VMS, séquences d'échappement de barre oblique inverse de style UNIX et
typage implicite des paramètres. Par défaut = aucun, activer = tous.

-style=liste
Produire des avertissements très pointilleux sur la programmation obsolète ou démodée
constructions. Par défaut = aucun, activer = tous.

-symtab
Imprimer la table des symboles et la table des étiquettes pour chaque sous-programme. Par défaut = non.

-troncation=liste
Vérifiez une éventuelle perte de précision par troncature. Par défaut = activer = tout.

-utilisation=liste
Contrôlez les avertissements concernant les variables inutilisées ou non initialisées, les blocs communs, etc.
Par défaut = activer = tout.

-vcg Produire le format VCG du graphique d'appel.

-version
Imprimer le numéro de version. Par défaut = non.

-volatil
Supposons que les blocs COMMON perdent leur définition entre les activations. Par défaut = non. (Obsolète.
Utilisez -commun=volatil au lieu.)

-mots=num
Définissez la taille de mot par défaut pour les quantités numériques sur num octets. Par défaut = activer =
4 octets.

-envelopper=num
Définir la colonne de sortie à laquelle encapsuler les longs messages d'erreur et les avertissements au suivant
ligne. S'il est défini sur 0, désactivez l'emballage. Par défaut = allumer = 79.

Lorsque plusieurs options sont utilisées, elles doivent être séparées par un espace, sauf sur
des systèmes tels que VMS où les options commencent par une barre oblique ( / ). Aucun espace vide ne peut être placé
autour du signe égal ( = ) dans un cadre. ftnchek "?" produira un résumé de la commande
répertoriant toutes les options et tous les paramètres.

Pour les paramètres qui prennent une liste de mots-clés, à savoir -arguments, -déployer, -arbre d'appel, -commun,
-référence croisée, -f77, -f90, -f95, -intrinsèque, -makedcls, -mkhtml, -portabilité, -joli,
-projet, -source, De style, -troncatureet -usage, la liste se compose de mots-clés
séparés par des virgules ou des deux points. Si la liste de mots-clés est omise, l'effet est de définir
l'option à sa valeur d'activation (identique à ``all'' dans la plupart des cas). De plus, si la liste est
omis, le nom du paramètre peut être préfixé par aucune or no- pour désactiver toutes les options
les contrôles. Par exemple, -f77 active tous les avertissements concernant les constructions non standard, tandis que
-nof77 les éteint tous. Trois mots-clés spéciaux sont :

aider Imprimez tous les mots-clés d'option contrôlés par le réglage, avec un bref
explication de leur signification. Ce mot-clé ne peut pas être donné dans une liste avec d'autres
mots clés.

TOUTE Définissez toutes les options. Cela active toutes les options contrôlées par le paramètre.

aucun Effacez toutes les options. Cela désactive toutes les options contrôlées par le paramètre.

Ces trois mots-clés spéciaux doivent être donnés en entier. Pour tous les autres mots clés, autant
les lettres du mot-clé qui sont nécessaires pour l'identifier sans ambiguïté doivent être données, ou un
le modèle de caractère générique peut être utilisé. L'inclusion d'un mot-clé dans la liste transforme le
option activée. Par exemple, -f77=intrinsèque activerait uniquement les avertissements concernant l'utilisation de
fonctions intrinsèques non standard. Préfixer un mot-clé par no- désactive son option. Pour
Par exemple, -pretty=pas de ligne longue désactive les avertissements concernant les lignes dépassant 72 colonnes dans
longueur tout en laissant en vigueur tous les autres avertissements concernant les apparences trompeuses. Si un
le paramètre a la valeur par défaut aucun, vous pouvez activer toutes les options sauf une ou deux en utilisant TOUTE
premier. Par exemple, -f77=tout, non inclus active les avertissements sur toutes les extensions non standard
à l'exception des instructions INCLUDE. Si un paramètre a par défaut TOUTE, vous pouvez désactiver tous les avertissements
sauf un ou deux en utilisant aucun premier. Par exemple, -troncation=aucune,rétrogradation tournerait
de tous les avertissements liés à la précision, à l'exception des rétrogradations. Les modèles génériques contiennent un
astérisque pour toute chaîne de caractères. Si un modèle générique est utilisé, tous les
les avertissements qui lui correspondent sont affectés. Si no- est préfixé au motif, toutes les correspondances
les avertissements sont désactivés, sinon ils sont tous activés. La longueur minimale sans ambiguïté
La règle ne s'applique pas à la correspondance générique. Par exemple, utilisez -usage=non-*var* éteindre
tous les avertissements relatifs à l'utilisation variable (à la fois locale et commune). (Les utilisateurs d'Unix peuvent avoir besoin de
citer toutes les options contenant des caractères génériques afin d'empêcher le shell d'essayer de
les développer.) Les caractères génériques ne sont reconnus que dans les listes de mots-clés d'avertissement, pas dans les
options de niveau elles-mêmes.

Quand ftnchek démarre, il recherche des variables d'environnement et aussi des préférences
déposer. Toutes les options définies dans l'environnement ou dans le fichier de préférences sont utilisées comme
valeurs par défaut à la place des valeurs par défaut intégrées. Ils sont remplacés par n'importe quelle ligne de commande
option. Voir la section sur la modification des valeurs par défaut pour plus de détails sur l'environnement
options et le fichier de préférences.

Lorsque vous donnez un nom à un fichier d'entrée, l'extension est facultative. Si aucune extension n'est donnée,
ftnchek recherchera d'abord un fichier de projet avec l'extension .prj, et l'utilisera s'il
existe. Si non, alors ftnchek recherchera un fichier source Fortran avec l'extension .pour
pour les systèmes VMS, .f pour les systèmes UNIX. Plus d'un nom de fichier peut être attribué à ftnchek,
et il traitera les modules dans tous les fichiers comme s'ils étaient dans un seul fichier.

Les caractères génériques sont autorisés dans la spécification des noms de fichiers sur la ligne de commande pour le VMS
et MS-DOS, comme aussi bien sûr sous UNIX et tout autre système qui exécute
extension de caractères génériques dans le processeur de commandes.

Si aucun nom de fichier n'est donné, ftnchek lira l'entrée à partir de l'entrée standard.

OPTIONS

Cette section fournit une discussion plus détaillée de ftnchek options de ligne de commande. Options
et les noms de fichiers peuvent être intercalés sur une ligne de commande. La plupart des options sont positionnelles : chacune
l'option reste en vigueur à partir du moment où elle est rencontrée jusqu'à ce qu'elle soit remplacée par un
changement ultérieur. Ainsi par exemple, le listing peut être supprimé pour certains fichiers et non pour
autres. Les exceptions sont : le -intrinsèque, -taille du pointeuret -taille de mot paramètres, qui
ne peut pas être modifié une fois que le traitement des fichiers d'entrée a commencé ; les -arguments, -déployer,
-arbre d'appel, -commun, -référence croisée, -externe, -référence, -Ressources, -sorte, -vcget -volatil
options, où l'action ne dépend que de la valeur de l'option après le traitement des
les fichiers d'entrée sont terminés ; et le -comprendre réglage, qui est cumulatif.

Les noms d'options dans la liste suivante sont classés par ordre alphabétique.

-arguments=liste
Contrôle les avertissements concernant les discordances entre les arguments de sous-programme réels et factices,
et aussi sur les discordances entre le type de sous-programme attendu et réel. (Un réel
argument est un argument passé au sous-programme par l'appelant ; un argument fictif est
un argument reçu par le sous-programme.) Par défaut, tous les avertissements sont activés.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Puisque tous ces
les avertissements sont activés par défaut, incluez un mot-clé préfixé par no- pour désactiver un
avertissement particulier. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
avertissements sur les arguments, aucun pour les éteindre tous, et aider pour imprimer la liste des
tous les mots-clés avec une brève explication de chacun. Si liste est omis, -arguments
équivaut à -arguments=touset -pas d'arguments équivaut à -arguments=aucun.
Les mots-clés d'avertissement avec leur signification sont les suivants :

l'arrangement:
avertir de l'utilisation incohérente d'arguments qui sont des tableaux. Ces avertissements peuvent
être en outre contrôlé par le -déployer option.

type:
avertir des arguments factices d'un type de données différent des arguments réels.

type de fonction:
avertir si l'invocation suppose que la valeur de retour de la fonction est d'un type différent
qu'il ne l'est en réalité. Avertit également si une fonction est appelée en tant que sous-programme, ou
inversement.

nombre:
avertir de l'invocation d'un sous-programme avec un nombre d'arguments différent du
le sous-programme attend.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce
le réglage est également accepté : le liste est remplacé par un nombre de 0 à 3. Une valeur de
0 désactive tous les avertissements, 1 active uniquement nombre, 2 s'allume tous sauf nombre,
et 3 active tous les avertissements.

Ce paramètre ne s'applique pas à la vérification des appels de fonctions intrinsèques ou
fonctions d'instruction, qui ne peuvent être désactivées que par le -pas de contrôle option.

Voir aussi: -déployer, -bibliothèque, -usage.

-tableau=liste
Contrôle le degré de rigueur dans la vérification de l'accord entre réel et fictif
arguments de sous-programme qui sont des tableaux. Les avertissements contrôlés par ce paramètre sont
pour les constructions qui pourraient légitimement être utilisées par un programmeur averti,
mais cela indique souvent des erreurs de programmation. Par défaut, tous les avertissements sont activés
sur.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Puisque tous ces
les avertissements sont activés par défaut, incluez un mot-clé préfixé par no- pour désactiver un
avertissement particulier. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
avertissements sur les arguments de tableau, aucun pour les éteindre tous, et aider pour imprimer le
liste de tous les mots-clés avec une brève explication de chacun. Si liste est omis,
-déployer équivaut à -tableau=toutet -noarray équivaut à -array=aucunL’
les mots-clés d'avertissement avec leur signification sont les suivants :

dimensions:
avertir si les arguments diffèrent dans leur nombre de dimensions, ou si le réel
argument est un élément de tableau tandis que l'argument factice est un tableau entier.

taille:
avertir si les deux arguments sont des tableaux, mais qu'ils diffèrent par le nombre d'éléments.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce
le réglage est également accepté : le liste est remplacé par un nombre de 0 à 3. Une valeur de
0 désactive tous les avertissements, 1 active uniquement dimensions, 2 s'allume seulement tailleet
3 active tous les avertissements.

Remarque : un avertissement est toujours donné quel que soit ce paramètre si l'argument réel
est un tableau tandis que l'argument factice est une variable scalaire, ou si le réel
l'argument est une variable ou une expression scalaire tandis que l'argument factice est un tableau.
Ces cas sont rarement intentionnels. (Pour désactiver même ces avertissements, utilisez
-arguments=pas de tableau.) Aucun avertissement n'est jamais donné si l'argument réel est un
élément de tableau tandis que l'argument factice est une variable scalaire. à dimension variable
les tableaux et les tableaux dimensionnés avec 1 ou un astérisque correspondent à n'importe quel nombre de tableau
éléments. Il n'y a pas de vérification de la concordance de la taille des tableaux multidimensionnels
de chaque dimension séparément.

Voir aussi: -arguments, -bibliothèque, -usage.

-bref
Sélectionne un format plus court pour certains messages d'avertissement. À l'heure actuelle, les seuls avertissements
contrôlés par ce drapeau sont ceux qui sont imprimés à la fin du traitement chaque
sous-programme. Ceux-ci incluent des avertissements sur les variables qui sont définies mais non utilisées ou
utilisé avant set, noms de variables non conformes à la norme Fortran 77,
etc. (Ces avertissements peuvent être entièrement supprimés en fonction d'autres indicateurs, tels que
le -usage or -f77 flags.) Dans le format par défaut, chaque variable est répertoriée sur un
ligne séparée, ainsi que le numéro de la ligne où la variable est déclarée, définie ou
utilisé, selon la nature de l'avertissement. Le format le plus bref répertorie simplement tous
variables auxquelles s'applique l'avertissement, avec jusqu'à 4 variables par ligne.

Voir aussi: -silencieux.

-arbre d'appel=liste
Causes ftnchek pour imprimer la structure d'appel du programme complet.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il y a deux spéciaux
Mots-clés: aucun pour désactiver toutes les options, et aider pour imprimer la liste de tous les
mots-clés avec une brève explication de chacun. (Le mot-clé TOUTE allume tous les
options, mais ne devrait normalement pas être utilisé car un seul format devrait être
spécifié.) Si liste est omis, -arbre d'appel équivaut à -calltree=arbreet
-nocalltree équivaut à -calltree=aucun. Par défaut, aucun graphique d'appel n'est imprimé.

Si l'option -mkhtml est invoquée et tree est l'option calltree appliquée, un fichier
nommé CallTree.html, sera également produit représentant l'arbre au format HTML. Cette
est utile comme point de départ pour parcourir les fichiers HTML décrivant chaque
composante du programme.

Les mots-clés qui contrôlent le format utilisé sont les suivants :

arbre:
produire le graphique des appels sous forme d'arbre.

référence:
produire le graphique des appels au format who-calls-who (identique à -référence changer).

VCG:
produire le graphique des appels au format VCG (identique à -vcg changer).

Un seul des formats arbre, référenceou VCG peut être précisé.

Les mots-clés suivants contrôlent les options affectant la sortie :

pruneau:
élaguer les sous-arbres répétés (applicable uniquement avec arbre). C'est la valeur par défaut.

sort:
trier les enfants de chaque routine par ordre alphabétique. C'est la valeur par défaut.

Voir la discussion sur le -référence et -vcg drapeaux pour plus de détails sur ces
formats.

Pour arbre format, Le graphique des appels est imprimé à partir du programme principal,
qui est répertorié sur la première ligne dans la marge de gauche. Puis sur les lignes suivantes,
chaque routine appelée par le programme principal est listée, indentée de quelques espaces, suivie
par le sous-arbre commençant à cette routine.

Dans le mode par défaut, si une routine est appelée par plusieurs autres routines, son
le sous-arbre d'appel n'est imprimé que la première fois qu'il est rencontré Les appels ultérieurs ne donnent que
le nom de la routine et la mention ``(voir ci-dessus)''. Pour imprimer le sous-arbre pour
chaque occurrence de la routine, utilisez l'option pas de pruneau.

Notez que l'arbre d'appel sera incomplet si l'un des fichiers d'entrée est un projet
fichiers contenant plus d'un module qui ont été créés dans -bibliothèque mode. Voir le
discussion des dossiers de projet ci-dessous.

Points techniques : Chaque liste de routines appelées par une routine donnée est imprimée dans
ordre alphabétique à moins que le pas de tri option est donnée. Si plusieurs programmes principaux
sont trouvés, l'arbre des appels de chacun est imprimé séparément. Si aucun programme principal n'est
trouvé, un rapport à cet effet est imprimé, et les arborescences d'appels de tout niveau supérieur
les routines hors bibliothèque sont imprimées. Ce drapeau contrôle uniquement l'impression de l'appel
arbre: ftnchek construit l'arbre d'appel dans tous les cas car il est utilisé pour déterminer
quels modules de bibliothèque seront recoupés. Voir la discussion sur le -bibliothèque
drapeau.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce
le réglage est également accepté : le liste est remplacé par un nombre de 0 à 15. Ce
nombre est formé à partir de 1 pour arbre format, 2 pour référence format, ou 3 pour VCG
format, plus 4 pour pas de pruneauet 8 pour pas de tri.

Voir aussi: -référence croisée, -bibliothèque, -référence, -sorte, -symtab, -vcg.

-vérifier
Ce commutateur est prévu pour que les erreurs et les messages d'avertissement puissent être désactivés lorsque
ftnchek est utilisé à des fins autres que la recherche de bogues, comme faire des déclarations
ou l'impression de l'arborescence des appels. Il est positionnel, donc après avoir désactivé toutes les vérifications,
les vérifications sélectionnées peuvent être réactivées. L'effet de -pas de contrôle est de mettre tout
commutateurs, paramètres numériques et paramètres contrôlant les listes d'avertissements à leur
valeurs de désactivation, comme si elles avaient toutes été spécifiées avec le préfixe -no. Commutateurs
et des paramètres qui spécifient les options et les modes de fonctionnement, plutôt que de contrôler
avertissements, ne sont pas affectés. Ceux-ci sont -Colonnes, -référence croisée, -comprendre, -intrinsèque,
-bibliothèque, -liste, -makedcls, -novice, -sortir, -taille du pointeur, -projet, -silencieux,
-référence, -Ressources, -sorte, -source, -symtab, -vcg, -version, -taille de motet
-envelopper. Par défaut = oui.

Les erreurs d'analyse (erreurs de syntaxe dues à des instructions non reconnues ou mal formées) ne sont pas
supprimé par ce commutateur, car les résultats peuvent être incorrects si ftnchek N'a pas
correctement analysé le programme.

Il existe diverses erreurs et messages d'avertissement qui ne sont pas contrôlés par
tout autre interrupteur, et ne peut donc être désactivé que par cet interrupteur. Notez qu'en utilisant
-vérifier Abonnement -pas de contrôle n'a pour effet que de transformer ces avertissements spéciaux
et ne restaure pas toutes les vérifications qu'il a désactivées. Ces avertissements sont :

o Le module ne contient aucune instruction exécutable.

o Sous forme de source libre, l'espace manquant là où l'espace est requis (par exemple entre un
mot-clé et un identifiant) ou un espace présent où aucun n'est autorisé (par exemple dans
un identifiant).

o Spécification de longueur nulle ou négative dans une déclaration de type de données de la forme
tapez*len.

o Opérande(s) invalide(s) dans une expression.

o Tableau affecté au scalaire.

o Incompatibilité de type entre l'index DO et les limites.

o Bloc commun non défini déclaré dans l'instruction SAVE.

o Fonction intrinsèque explicitement déclarée avec un type incompatible.

o Fonction intrinsèque inconnue explicitement déclarée dans une instruction INTRINSIC.

o La fonction intrinsèque passée en argument de sous-programme n'est pas déclarée dans un
Déclaration INTRINSÈQUE.

o Fonction intrinsèque ou fonction d'instruction invoquée de manière incorrecte.

o La fonction ne définit pas la valeur de retour avant l'instruction RETURN.

o Valeur constante du paramètre non évaluée (c'est ftnchekc'est la faute, et c'est juste
vous en informant).

o Le point d'entrée d'un sous-programme est ensuite utilisé comme nom de sous-programme différent.

o Mot clé inconnu utilisé dans une instruction d'E/S.

o Référence d'étiquette illégale (par exemple, GOTO fait référence à une instruction non exécutable ; I/O
l'instruction fait référence à une instruction non formatée).

Voir aussi: -les erreurs.

-colonnes=num
Définir la longueur maximale de l'instruction sur num Colonnes. (Au-delà, ceci est ignoré.)
paramètre est fourni pour permettre la vérification des programmes qui peuvent violer le Fortran
limite standard de 72 colonnes pour la longueur d'une instruction. Selon le
standard, tous les caractères après la colonne 72 sont ignorés. Si ce paramètre est utilisé lorsque
le -f77=longue ligne est en vigueur, un avertissement sera donné pour toutes les lignes de
quels caractères après la colonne 72 sont traités. Activation = max = 132. Par défaut = 72.

Ce paramètre ne supprime pas les avertissements concernant la présence de caractères au-delà
colonne 72. Pour traiter le code avec un texte de programme significatif au-delà de la colonne 72, utilisez cette
réglage et assurez-vous que le -f77 longue ligne l'option est désactivée. Pour traiter le code avec
numéros de séquence dans les colonnes 73 à 80, laissez le paramètre de colonnes par défaut
valoriser et utiliser le -pretty=pas de ligne longue drapeau.

Voir aussi: -f77, -joli.

-commun=liste
Ce paramètre contrôle la rigueur de la vérification des blocs COMMON. Par défaut, tout
avertissements sauf volatile sont allumés.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Étant donné que la plupart de ces
les avertissements sont activés par défaut, incluez un mot-clé préfixé par no- pour désactiver un
avertissement particulier. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
mises en garde, aucun pour les éteindre tous, et aider pour imprimer la liste de tous les mots-clés
avec une brève explication de chacun. Si liste est omis, -commun équivaut à
-common=dimensions,exacte,longueur,typeet -pas commun équivaut à -commun=aucun.
Les mots-clés d'avertissement avec leur signification sont les suivants :

dimensions:
les tableaux correspondants dans chaque déclaration d'un bloc doivent correspondre en taille et
nombre de dimensions. Cette option n'a d'effet que lorsqu'elle est utilisée avec
exacte.

exacte:
la comparaison de deux blocs se fait variable par variable plutôt que simplement
nécessitant un accord entre les emplacements de stockage correspondants. Utilisez ceci si tout
les déclarations d'un bloc COMMON donné sont supposées être identiques, ce qui est un
bonne pratique de programmation.

longueur:
avertir si différentes déclarations du même bloc ne sont pas égales en longueur totale.
La norme Fortran 77 requiert chaque bloc commun nommé, mais pas le commun vide,
avoir la même longueur dans tous les modules du programme.

type:
dans chaque déclaration d'un bloc COMMON donné, les emplacements mémoire correspondants
(mots ou octets) doivent correspondre dans le type de données. Si utilisé avec exacte, Ce
exigera que les variables correspondantes concordent dans le type de données.

volatile:
Supposons que les blocs COMMON soient volatiles.

De nombreux programmeurs Fortran supposent que les variables, qu'elles soient locales ou en COMMUN, sont
statique, c'est-à-dire qu'une fois une valeur attribuée, ils la conservent de façon permanente jusqu'à ce que
attribué une valeur différente par le programme. Cependant, en fait, le Fortran 77
La norme n'exige pas que ce soit le cas. Les variables locales peuvent devenir
indéfinies entre les activations d'un module dans lequel elles sont déclarées. De la même manière,
Les blocs COMMON peuvent devenir indéfinis si aucun module dans lequel ils sont déclarés n'est
actif. (Le terme technique pour les entités avec ce comportement est ``automatique'', mais
ftnchek utilise le mot « volatile » car il est plus clair pour le non-spécialiste.) Seulement
blocs COMMON déclarés dans une instruction SAVE, ou déclarés dans le programme principal ou dans un
Le sous-programme de données de bloc reste défini tant que le programme est en cours d'exécution. Variables
et les blocs COMMON qui peuvent devenir indéfinis à un moment donné sont appelés volatiles.

Si la -commun=volatil le drapeau est allumé, ftnchek vous avertira s'il trouve un
bloc COMMON volatile. Si, en même temps, le -usage=com-bloc-volatile option
est activé (ce qui est la valeur par défaut), ftnchek va essayer de vérifier si un tel bloc
peut perdre son statut défini entre les activations des modules où il est
déclaré. ftnchek ne fait pas très bien cela : la règle utilisée est de voir
si le bloc est déclaré dans deux sous-arbres séparés de l'arbre des appels. Pour
exemple, ce serait le cas si deux modules, tous deux appelés depuis le programme principal,
partagé un bloc COMMON volatile. Un bloc peut aussi devenir indéfini entre deux
appels successifs du même sous-programme, mais ftnchek n'est pas assez intelligent pour dire
si un sous-programme peut être appelé plusieurs fois, ce cas n'est donc pas vérifié.

La -commun=volatil le drapeau n'affecte pas le chemin ftnchek vérifie l'utilisation du local
variables.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce
le réglage est également accepté : le liste est remplacé par un nombre de 0 à 3. Une valeur de
0 désactive tous les avertissements, 1 ou plus active type, 2 ou plus s'allume
longueur, et 3 s'allume dimensions et exacte aussi. La forme numérique ne peut pas s'allumer
le volatile option.

Voir aussi: -bibliothèque, -usage.

-référence croisée=liste
Imprime les tableaux de références croisées. Par défaut = aucun.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Les mots-clés avec
leurs significations sont les suivantes :

en cours:
table répertorie chaque sous-programme suivi d'une liste de routines qui l'appellent.
Cette liste omet les modules de bibliothèque qui ne sont pas dans l'arborescence des appels du principal
programme. La liste est alphabétique.

commun:
table répertorie chaque bloc COMMON suivi d'une liste des routines qui accèdent
ce. Ces routines répertoriées sont celles dans lesquelles certaines variables du COMMON
bloc sont accédés, pas simplement ces routines qui déclarent le bloc. (À
savoir quelles routines déclarent un bloc COMMON mais ne l'utilisent pas, voir le
-usage drapeau.)

qui:
Le tableau répertorie chaque étiquette suivie d'une liste de toutes les références à celle-ci. Une marque
la référence est indiquée par le numéro de ligne et le type de déclaration de la référence
déclaration. La liste des étiquettes est dans l'ordre séquentiel. Les références sont
répertoriés dans l'ordre où ils sont rencontrés dans le programme.

Voir aussi: -arbre d'appel, -référence, -sorte, -symtab, -vcg.

-déclarer
Si ce flag est positionné, tous les identifiants dont le type de données n'est pas déclaré dans chaque module
sera répertorié. Ce drapeau est utile pour aider à trouver des noms de variables mal orthographiés,
etc. La même liste sera donnée si le module contient un IMPLICIT NONE
déclaration. Par défaut = non.

Voir aussi: -six caractères, -usage.

-division
Ce commutateur est fourni pour aider les utilisateurs à repérer la division potentielle par zéro problème. Si
ce commutateur est sélectionné, chaque division sauf par une constante sera signalée. (Ce
est supposé que l'utilisateur est suffisamment intelligent pour ne pas diviser par une constante qui est
égal à zéro !) Par défaut = non.

Voir aussi: -portabilité, -troncature.

-erreurs=num
Définit le nombre maximum de messages d'erreur dans une ``cascade''. Lors de la vérification de
accord des arguments de sous-programme, des déclarations de blocs communs, etc.
parfois, un seul cas génère une longue chaîne d'avertissements. Souvent cela simplement
indique une autre cause qu'une véritable inadéquation article par article, comme pour
exemple une variable manquante dans une liste. Alors dans de tels cas ftnchek arrête l'impression
les avertissements après que la limite de cascade est atteinte, et la remorque ``etc...'' est
imprimé pour indiquer qu'il y avait plus d'erreurs non imprimées. Si vous pensez que
ces avertissements sont susceptibles d'être authentiques, utilisez ce paramètre pour en voir plus.
Activation = par défaut = 3, max = 999. Une valeur de 0 signifie aucune limite.

Ce paramètre ne fixe pas de limite globale sur le nombre de messages d'erreur imprimés,
seulement le nombre imprimé dans une cascade. La plupart des types d'avertissements et d'erreurs
les messages ne sont pas soumis à l'effet de cascade et ne sont donc pas affectés par cet effet
réglage. Pour désactiver les avertissements en général, utilisez le contrôle d'avertissement individuel
options ou les -pas de contrôle option.

Voir aussi: -vérifier.

-externe
Causes ftnchek pour signaler si des sous-programmes invoqués par le programme ne sont jamais
défini. Normalement, si ftnchek est exécuté sur un programme complet, chaque
un sous-programme autre que les fonctions intrinsèques doit être défini quelque part. Tourner
désactiver ce commutateur si vous voulez juste vérifier un sous-ensemble de fichiers qui font partie d'un
programme complet plus vaste. Les arguments du sous-programme seront toujours vérifiés
justesse. Par défaut = oui.

La -externe le drapeau est maintenant remplacé par le -usage=ext-indéfini option. Pour le
par souci de commodité, le -externe drapeau est conservé, de sorte que -noextern est équivalent
à -usage=no-ext-indéfini option. La -externe le commutateur peut être retiré par la suite.

Voir aussi: -bibliothèque.

-f77=liste
Utilisez ce paramètre pour intercepter les extensions de langue qui violent le Fortran 77
Standard. De telles extensions peuvent empêcher votre programme d'être portable. Exemples
inclure l'utilisation de traits de soulignement dans les noms de variables ; noms de variables supérieurs à six
personnages; lignes d'instruction de plus de 72 caractères ; et les déclarations non standard
comme la structure DO ... ENDDO. ftnchek ne rend pas compte de l'utilisation de
minuscules. Par défaut, tous les avertissements sont désactivés.

Ce paramètre fournit un contrôle détaillé sur les avertissements concernant les extensions prises en charge
à la norme Fortran 77. (Des détails supplémentaires sur les extensions elles-mêmes sont
ci-dessous dans la section sur les extensions.) Le liste se compose de mots-clés séparés
par des virgules ou des deux points. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
avertissements concernant les extensions non standard, aucun pour les éteindre tous, et aider imprimer
la liste de tous les mots-clés avec une brève explication de chacun. Si liste est omis,
-f77 équivaut à -f77=touset -nof77 équivaut à -f77=aucun. L'avertissement
les mots-clés avec leur signification sont les suivants :

accepter-type:
Instructions ACCEPT et TYPE I/O.

limites de tableau:
Expressions définissant des limites de tableau qui contiennent des éléments de tableau ou une fonction
les références.

affectation-stmt:
Instructions d'affectation impliquant des tableaux. En Fortran 90, un tableau peut être
attribué à un autre tableau de forme compatible, ou un scalaire peut être attribué à
un tableau. Aucune de ces affectations n'est autorisée dans Fortran 77.

Un avertissement associé se produit lorsqu'un tableau est affecté à un scalaire. Depuis cela
est illégal également en Fortran 90, il est toujours averti quel que soit le
-f77 réglage (à moins que toutes les vérifications ne soient désactivées avec le -pas de contrôle drapeau).

attribut-based-decl:
Les déclarations de type dans le nouveau style basé sur les attributs Fortran 90. Ce style de
déclaration se distingue par l'utilisation d'un double deux-points (::) entre le
liste des attributs et la liste des variables déclarées. Cette option aussi
contrôle les avertissements pour l'utilisation des spécificateurs de longueur ou de type Fortran 90 dans le type
déclarations. (Bien que ces spécificateurs puissent être utilisés dans des
déclarations, elles sont contrôlées par cette option pour éviter la prolifération des
-f77 choix.)

tableau-automatique:
Tableaux locaux (non factices) qui ont une taille variable. Ceux-ci correspondraient à
des baies dont le stockage devrait être alloué dynamiquement au moment de l'exécution.

barre oblique inverse:
Echappement de la barre oblique inverse Unix dans les chaînes. Cet avertissement ne sera donné que si le
-source=unix-barre oblique inverse le paramètre est spécifié pour provoquer l'échappement
interprétation de la barre oblique inverse.

octet: déclaration du type de données BYTE.

cas-construire:
La construction SELECT CASE.

caractère:
Extensions de la norme Fortran 77 concernant les données de caractères. Maintenant,
cela ne contrôle que les avertissements sur les variables de caractère déclarées avec zéro ou
longueur négative. En Fortran 77, toutes les variables de caractères doivent être positives
longueur. En Fortran 90, ils peuvent être de longueur nulle et les déclarations qui
spécifier que les longueurs négatives sont autorisées, devenant zéro pour le
longueur. Remarque : parce que les spécificateurs de longueur négatifs peuvent indiquer une programmation
erreur, l'avertissement à leur sujet est donné même si cette option est désactivée, et
n'est supprimé que par le -pas de contrôle drapeau.

nom-sous-prog-commun:
Bloc et sous-programme communs ayant le même nom.

nom_construction:
Utilisation d'un nom de construction pour étiqueter une instruction de contrôle.

continuation:
Plus de 19 lignes de continuation successives.

cpp: directives du préprocesseur Unix C dans le code source.

Cray-pointer:
Syntaxe du ``pointeur Cray''.

cycle-sortie:
Les instructions CYCLE et EXIT.

d-commentaire:
Commentaires de débogage commençant par D dans le code source.

onglet déc.:
Code source sous forme de tabulation de style DEC Fortran. Cet avertissement ne sera donné que
si le -source=déc-onglet le paramètre est spécifié pour provoquer l'interprétation des onglets
dans ce style.

faire-enddo:
Extensions de boucle DO : étiquette d'instruction de terminal omise, END DO et WHILE.

double-complexe:
Type de données complexe à double précision.

format-signe-dollar:
Code de contrôle du signe dollar dans les instructions FORMAT.

format-modifier-descr:
Descripteurs d'édition non standard dans les instructions FORMAT.

fonction-noparen:
Définition de la fonction sans parenthèses.

implicite-aucun:
Déclaration IMPLICITE AUCUN.

comprendre:
instruction INCLUDE.

commentaire-en-ligne:
Commentaires en ligne commençant par un point d'exclamation.

liste-interne-io:
E/S dirigées par liste vers ou depuis un fichier interne.

intrinsèque:
Fonctions intrinsèques non standard.

io-mots-clés
Mots-clés non standard utilisés dans les instructions d'E/S. Ceux-ci se répartissent en trois groupes.
Le premier groupe comprend les mots-clés acceptés en Fortran 90 :

ACTION PAD LECTURE
TAILLE DE POSITION AVANCÉE
DELIM LIRE ÉCRIRE
Récupération améliorée du pétrole
Le deuxième groupe comprend les mots-clés VMS Fortran suivants :

BLOCKSIZE EXTENDSIZE LECTURE SEULE
BUFFERCOUNT INITIALSIZE RECORDSIZE
CARRIAGECONTROL MAXREC RECORDTYPE
NOM DU FICHIER PAR DÉFAUT (en OUVERT) PARTAGÉ
TYPE DE BLOC D'AFFICHAGE
ORGANISATION D'ÉLIMINATION
(Le mot clé NAME est standard uniquement dans l'instruction INQUIRE.) Le troisième
Le groupe se compose du mot clé IBM/MVS suivant :

NUM
Ce drapeau contrôle également un avertissement concernant l'utilisation de ACCESS='APPEND', qui est
accepté par certains compilateurs. La valeur de 'APPEND' n'est valide pour aucune E/S
spécificateur dans la norme Fortran 77, et dans Fortran 90 'APPEND' doit être utilisé
comme valeur du spécificateur POSITION, pas ACCESS.

longue ligne:
Instructions avec un code significatif au-delà de 72 colonnes. Cet avertissement est donné uniquement
si le -Colonnes a été utilisé pour augmenter la largeur du champ de l'instruction.

nom long:
Identifiants de plus de 6 caractères.

mixte-commun:
Données mixtes de caractères et de non-caractères dans le bloc COMMON.

expression-mixte:
Combinaisons de types non standard dans les expressions, par exemple DOUBLE PRECISION
avec COMPLEX, affectation de hollerith à un entier, opérations logiques sur des entiers.

nom-dollarsign:
Signe dollar utilisé comme caractère dans les identifiants.

nom-souligné:
Soulignement utilisé comme caractère dans les identificateurs.

liste de nom:
Déclaration NAMELIST.

param-implicite-type:
Typage implicite d'un paramètre par le type de données de la valeur affectée. Cette
l'avertissement ne peut se produire que si la saisie de paramètre implicite a été activée par le
-source=param-type-implicite option, ou si l'instruction PARAMETER est du
forme non standard sans parenthèses. Si cette option est activée, tout
les cas où un typage de paramètre implicite se produit seront avertis. Si
vous souhaitez être averti uniquement dans les cas où le type de données implicite
diffère du type par défaut, utilisez -portability=param-type-implicite à la place.
Selon la norme Fortran 77, le type de données d'un paramètre est donné
par les mêmes règles que pour une variable, et si nécessaire une conversion de type est
fait lorsque la valeur est attribuée.

param-intrinsèque:
Fonction intrinsèque ou exponentiation par un réel utilisée pour définir la valeur d'un
Définition du PARAMÈTRE.

param-noparen:
Instruction PARAMETER sans parenthèses. L'utilisateur doit être conscient que le
la sémantique de cette forme de déclaration diffère de celle de la norme
forme : sous cette forme, le paramètre prend son type de données de la valeur
attribué, plutôt que d'avoir son type de données par défaut basé sur la première lettre
du nom du paramètre. (Cette forme de l'instruction PARAMETER a été introduite
par DEC avant la définition de la norme Fortran 77, et devrait être évitée.)

aiguille:
Syntaxe standard de pointeur Fortran 90, y compris POINTER, TARGET et
déclarations de type ALLOCATABLE, instructions ALLOCATE, DEALLOCATE et NULLIFY,
et l'affectation du pointeur en utilisant =>.

quad-constante:
Constantes réelles de précision quadruple, par exemple de la forme 1.23Q4.

guillemet:
Chaînes délimitées par des guillemets plutôt que par des apostrophes.

relops:
Opérateurs relationnels (de comparaison) composés de ponctuation, à savoir : < <= == /=
> >=.

point-virgule:
Point-virgule utilisé comme séparateur d'instructions.

instruction-ordre:
Énoncés sortant de l'ordre prescrit par la norme. Le permis
La séquence est illustrée dans le tableau 1 de la section Interprétation de la sortie.

constante sans type:
Constantes sans type, par exemple Z'19AF'.

type-taille:
Déclarations de type spécifiant une taille, par exemple REAL*8.

format-variable:
Spécification de répétition variable ou taille de champ dans FORMAT. Ceux-ci sont de la forme
< expr >.

vms-io:
Obsolète. A maintenant le même sens que le io-mots-clés mot-clé.

Voir aussi: -f90, -f95, -portabilité, -joli, De style, -taille de mot.

-f90=liste
Ce paramètre fournit un contrôle détaillé sur les avertissements concernant les extensions prises en charge
au Standard Fortran 77 qui n'ont pas été adoptés dans le cadre du Fortran 90
Standard. Noter que ftnchek ne prend pas en charge le langage Fortran 90 complet.
Cependant, il prend en charge certaines extensions courantes de Fortran 77 qui étaient répandues
avant que Fortran 90 ne soit défini. Certaines de ces extensions ont été intégrées au Fortran
90 Standard, mais pas d'autres. Les -f90 le réglage n'avertit que de ce dernier.
C'est-à-dire que ce drapeau couvre les choses qui ne sont ni légales Fortran 77 ni légales
Fortran 90. Par conséquent, les avertissements contrôlés par ce drapeau sont essentiellement un sous-ensemble
des avertissements contrôlés par -f77. Il existe quelques cas, décrits ci-dessous, où
les circonstances dans lesquelles l'avertissement est donné sont légèrement différentes pour les deux
drapeaux.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il ya trois
mots-clés spéciaux : TOUTE pour activer tous les avertissements concernant les extensions non standard,
aucun pour les éteindre tous, et aider pour imprimer la liste de tous les mots-clés avec un
brève explication de chacun. Si liste est omis, -f90 équivaut à -f90=touset
-nof90 équivaut à -f90=aucun.

Les mots-clés suivants ont la même signification pour -f90 pour ce qui est de -f77. Le lecteur est
renvoyé aux explications sous -f77.

accepter-type double-complexe param-noparen
barre oblique inverse format-signe-dollar Cray-pointer
octet format-modifier-descr quad-constante
cpp fonction-noparen type-taille
d-commentaire nom-dollarsign format-variable
onglet déc. param-implicite-type vms-io

Les mots-clés qui diffèrent quelque peu des correspondants -f77 les mots-clés sont comme
suit.

continuation:
La limite du nombre de lignes de continuation pour une instruction en source fixe
la forme est la même, à savoir 19, en Fortran 90 comme en Fortran 77. Pour source libre
forme la limite est de 39 lignes de continuation, et une ligne contenant une continuation
mark ne peut pas être vide ou ne contenir qu'un commentaire.

intrinsèque:
C'est la même chose que pour -f77 sauf pour les fonctions intrinsèques définies dans
MIL-STD 1753, qui sont tous inclus dans Fortran 90, et ne sont donc pas avertis
À propos. (Voir -intrinsèque pour une liste.)

io-mots-clés:
C'est la même chose que pour -f77 sauf qu'aucun avertissement n'est donné pour les E/S
mots-clés qui sont standard dans Fortran 90.

longue ligne:
Bien que la norme Fortran 90 autorise les lignes de plus de 72 caractères dans
forme source libre, cette restriction s'applique toujours à la forme source fixe. Dans
source libre forme la limite de longueur de ligne est de 132 caractères, et contrairement à fixe
forme, ftnchek ne permet pas d'augmenter cette limite.

expression-mixte:
C'est la même chose que pour -f77 sauf pour les expressions mélangeant une précision étendue
real avec des types de données complexes, qui sont autorisés dans Fortran 90.

instruction-ordre:
Ceci est similaire au correspondant -f77 avertissement, mais applique quelque peu
des restrictions plus souples sur l'ordre des déclarations de la norme Fortran 90. Dans
en particulier, Fortran 90 autorise les instructions DATA et la fonction instruction
définitions à mélanger avec les déclarations de spécifications.

constante sans type:
En Fortran 90, constantes binaires, octales et hexadécimales de la forme B'ddd',
O'ddd' et Z'ddd', respectivement, sont autorisés. Ici 'ddd' représente un
chaîne de chiffres. ftnchek reconnaît ces formes, ainsi qu'une variante de
la forme X'ddd' pour une constante hexadécimale, et d'autres variantes dans lesquelles le
l'indicateur de base B, O, Z ou X suit la chaîne de chiffres. Ces variantes étaient
pas adopté dans Fortran 90, donc seulement ils sont avertis du moment où ce drapeau est
allumé.

Voir aussi: -f77, -f95, -portabilité, -joli, De style, -taille de mot.

-f95=liste
Ce paramètre fournit un contrôle détaillé sur les avertissements concernant la norme Fortran 77
fonctionnalités qui ont été supprimées de la norme Fortran 95. Contrairement au -f77 et -f90
paramètres, ces avertissements s'appliquent à la syntaxe qui est légale Fortran 77. Cependant, puisque
ces fonctionnalités ont été supprimées du Standard, il est possible que les programmes
les contenant sera inacceptable pour certains compilateurs plus récents.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il ya trois
mots-clés spéciaux : TOUTE pour activer tous les avertissements concernant les extensions non standard,
aucun pour les éteindre tous, et aider pour imprimer la liste de tous les mots-clés avec un
brève explication de chacun. Si liste est omis, -f95 équivaut à -f95=touset
-nof95 équivaut à -f95=aucun. Les mots-clés d'avertissement avec leurs significations sont les suivants
suit.

vraiment faire:
Une variable DO de tout type numérique réel.

pause:
L'instruction PAUSE.

assigner:
L'instruction ASSIGN, le GOTO affecté ou le format affecté.

h-éditer:
Le descripteur d'édition H dans un format.

Il existe une autre fonctionnalité de syntaxe Fortran 77 qui a été supprimée dans Fortran 95, à savoir
branchement à un ENDIF depuis l'extérieur du bloc IF. Cependant, ftnchek est incapable de
analyser le flux du programme, et donc il ne fournit pas d'avertissement pour cela.

Voir aussi: -f77, -f90, -portabilité, -joli, De style, -taille de mot.

-Aide
Imprime une liste de toutes les options de ligne de commande avec une brève description de chacune
avec sa valeur par défaut. Cette commande est identique en fonction à la ``?''
argument, et est fourni à titre de commodité pour les systèmes dans lesquels la question
mark a une signification particulière pour l'interpréteur de commandes. Par défaut = non.

La liste d'aide imprime également le numéro de version et le niveau de correctif de ftnchek et
Copyright.

Remarque : les valeurs par défaut imprimées entre crochets dans la liste d'aide sont :
à proprement parler, pas les valeurs par défaut intégrées mais les valeurs actuelles après tout
les options d'environnement et toutes les options de ligne de commande précédant le -Aide option ont
été traité.

Voir aussi: -novice, -versionet aider option de tous les paramètres qui prennent une liste de
mots clés.

-identifiant-chars=liste
Définissez des caractères non alphanumériques pouvant être utilisés dans les identifiants. Par défaut,
ftnchek accepte uniquement le signe dollar et le soulignement en tant que caractères non alphanumériques
dans les noms d'identifiants. Les personnages dans le liste remplacer n'importe quel ensemble d'accepté
caractères non alphanumériques était auparavant en vigueur. Ainsi, si le signe dollar ou
les soulignés ne sont pas inclus dans la liste, ils perdent leur statut d'acceptable
caractères.

Cette option est fournie pour activer ftnchek pour gérer les fichiers source contenant des
les noms d'identificateurs standard qui peuvent être nécessaires, par exemple, pour accéder à certains
services du système d'exploitation. Voir la section Limitations et extensions pour le
traitement des identifiants contenant ces caractères en typage implicite.

En utilisant -noidentifer-chars désactive l'acceptation des caractères non alphanumériques
entièrement.

Voir aussi: -source.

-inclure=chemin
Spécifie un répertoire dans lequel rechercher les fichiers spécifiés par les instructions INCLUDE.
Contrairement aux autres options de ligne de commande, ce paramètre est cumulatif ; c'est-à-dire si c'est
donné plus d'une fois sur la ligne de commande, tous les répertoires ainsi spécifiés sont
placés sur une liste qui sera recherchée dans le même ordre qu'ils sont donnés. Les
ordre dans lequel ftnchek recherche un fichier à inclure est : le
annuaire; le répertoire spécifié par la variable d'environnement FTNCHEK_INCLUDE le cas échéant ;
les répertoires spécifiés par tout -comprendre options; le répertoire spécifié par
variable d'environnement INCLUDE ; et enfin dans un répertoire standard à l'échelle du système
(/ usr / include pour UNIX, SYS$LIBRARY pour VMS et \include pour MSDOS).

Voir aussi: -f77, -source.

-intrinsèque=liste
Contrôle si ftnchek reconnaît certaines fonctions intrinsèques non standard comme
intrinsèque. Les liste se compose de mots-clés séparés par des virgules ou des deux-points. Une partie de
les mots-clés contrôlent s'il faut reconnaître certains groupes de fonctions, et d'autres
les mots-clés contrôlent la syntaxe attendue pour invoquer certains intrinsèques non standard.
Incluez un mot-clé pour activer la reconnaissance de l'ensemble correspondant d'intrinsèques ou
pour autoriser la syntaxe correspondante. Inclure un mot-clé préfixé par no- éteindre
cette reconnaissance.

Il y a trois mots-clés spéciaux : TOUTE active la reconnaissance de tous les non standard
intrinsèques (énumérés ci-dessous) et accepte l'une ou l'autre syntaxe pour ceux qui ont des variations.
Utilisez aucun pour désactiver la reconnaissance de tous les intrinsèques non standard, à l'exception de ceux notés
au dessous de. Utilisation aider pour imprimer la liste de tous les mots-clés avec une brève explication de
chaque. Si liste est omis, -intrinsèque équivaut à -intrinsèque=touset
-non intrinsèque équivaut à -intrinsèque=aucun.

Les fonctions intrinsèques non standard nécessaires pour prendre en charge les fonctions étendues non standard
les types de données de précision (double complexe et quad précision) sont toujours reconnus.
Les valeurs intrinsèques du type de données double complexe sont :

CDABS CDSQRT DREAL ZLOG
CDCOS DCMPLX IMAG ZSIN
CDEXP DCONJG ZABS ZSQRT
CDLOG DIMAG ZEXP ZCOS
CDSIN
Les valeurs intrinsèques des types quad précision et quad complexe sont :

CQABS QARCOS QEXT QNINT
CQCOS QARSIN QEXTD QPROD
CQEXP QATAN QFLOAT QREAL
CQLOG QATAN2 QIMAG QSIGN
CQSIN QCMPLX QINT QSIN
CQSQRT QCONJG QLOG QSINH
DBLEQ QCOS QLOG10 QSQRT
IQINT QCOSH QMAX1 QTAN
IQNINT QDIM QMIN1 QTANH
QABS QEXP QMOD SNGLQ
Les mots-clés contrôlant la reconnaissance d'autres fonctions intrinsèques non standard sont
comme suit:

supplémentaire:
reconnaître les intrinsèques non standard couramment disponibles suivants (tous sauf
EXIT et LOC sont définis dans MIL-STD 1753) :

BTEST IBCLR IEOR ISHFTC
SORTIE IBITS IOR LOC
IAND IBSET ISHFT NON

unix: reconnaissent ces fonctions intrinsèques communes à Unix :

ABANDONNER GMTIME LTIME SRAND
ET IARGC OU SYSTEME
GETARG IRAND RAND TEMPS
GETENV LSHIFT RSHIFT XOR

etc.: reconnaissent ces fonctions intrinsèques communes spécifiques au VMS :

DATE IDATE SECN. HEURE

ERRSNS RAN TAILLE DE

iargc-pas-argument:
spécifier que l'IARGC peut être invoqué sans arguments.

iargc-un-argument:
spécifier que l'IARGC peut être invoqué avec un seul argument.

rand-pas-argument:
spécifier que RAND et IRAND peuvent être invoqués sans arguments.

rand-un-argument:
spécifier que RAND et IRAND peuvent être invoqués avec un seul argument.

La sans argument et un argument les mots-clés fonctionnent comme suit : activer l'option
les causes ftnchek d'accepter la syntaxe correspondante pour l'invocation de la fonction,
sans exclure la possibilité de la syntaxe alternative. Tourner l'option
off entraîne la non-acceptation de la syntaxe correspondante. Si les deux options sont activées
on à la fois (par défaut), alors l'une ou l'autre syntaxe est acceptée. Désactiver les deux options
à la fois n'aurait pas de sens. Ces options sont sans effet si la comptabilisation de
Les intrinsèques Unix ont été désactivés.

Notez que ce paramètre ne contrôle pas si des avertissements non standard sont émis
sur ces fonctions. Il contrôle si les fonctions sont supposées être
intrinsèques ou non, qui déterminent la manière dont leur utilisation est vérifiée. Lorsque les fonctions en
l'un de ces ensembles est inclus, leurs invocations seront vérifiées en fonction de la
règles pour les fonctions intrinsèques; sinon ils seront vérifiés normalement (utilisateur-
écrit) fonctions externes. Les avertissements non standard sont contrôlés par le
-f77=intrinsèque option.

La valeur par défaut de ce paramètre est équivalente à -intrinsèque=tous suivie par
-intrinsèque = pas de machine virtuelle pour la version Unix, -intrinsic=non-unix pour la version VMS, et
-intrinsic=no-unix, no-vms pour les autres versions.

Remarque : dans les versions de ftnchek avant le 2.10, le -intrinsèque le drapeau a pris un nombre
argument au lieu d'une liste d'options. Pour le bien des utilisateurs qui ont peut-être écrit
scripts invoquant ftnchek de cette façon, la forme numérique est toujours acceptée. Les
la forme numérique du réglage se compose de trois chiffres. Le chiffre des unités sélectionne le
ensemble de fonctions intrinsèques à prendre en charge. Le chiffre 0 sélectionne uniquement Fortran 77
intrinsèques standard plus ceux nécessaires pour prendre en charge la précision étendue non standard
Types de données. Le chiffre 1 équivaut à supplémentaire, 2 équivaut à supplémentaire, unixet
3 équivaut à supplémentaire, vms. Le chiffre des dizaines de ce paramètre contrôle la syntaxe
de la fonction intrinsèque RAND, et le chiffre des centaines contrôle la syntaxe du
Fonction IARGC. Pour ces chiffres, spécifiez 0 pour exiger un appel sans
argument, 1 pour exiger un argument et 2 pour autoriser l'une ou l'autre forme.

Voir aussi: -f77.

-bibliothèque
Ce commutateur est utilisé lorsqu'un certain nombre de sous-programmes sont contenus dans un fichier, mais pas
tous sont utilisés par l'application. Normalement, ftnchek vous prévient le cas échéant
les sous-programmes sont définis mais jamais utilisés. Ce commutateur supprimera ces avertissements.
Par défaut = non.

Ce commutateur contrôle également les appels de sous-programme et les déclarations de bloc COMMON
vérifié. Si un fichier est lu avec le -bibliothèque flag en vigueur, le sous-programme appelle
et les déclarations COMMON contenues dans une routine de ce fichier ne seront vérifiées que si
cette routine se trouve dans l'arborescence des appels du programme principal. D'autre part, si le
-bibliothèque l'interrupteur est éteint, puis ftnchek vérifie les appels de chaque routine en
toutes les autres routines, peu importe si ces routines pourraient un jour être
invoqué au moment de l'exécution, et de même toutes les déclarations de bloc COMMON sont comparées pour
accord.

La différence entre ce commutateur et le -usage=no-ext-inutilisé possibilité pour
sous-programmes est que ce dernier supprime uniquement l'avertissement concernant les routines en cours
déclaré mais non utilisé. Les -bibliothèque le commutateur va plus loin et exclut les inutilisés
routines traitées pendant qu'il est en vigueur de tous les recoupements d'arguments et
Les déclarations de bloc COMMON également.

(S'il n'y a aucun programme principal dans l'ensemble de fichiers qui ftnchek a lu, donc
qu'il n'y a pas d'arbre d'appels, alors ftnchek recherchera toutes les routines non-bibliothèque
qui ne sont appelées par aucune autre routine, et les utilisent comme substituts de la
programme pour construire l'arbre d'appels et décider ce qu'il faut vérifier. S'il n'y a pas de tel haut-
les routines de niveau non-bibliothèque sont trouvées, puis tous les appels inter-modules et tous les COMMON
les déclarations seront vérifiées.)

Voir aussi: -arguments, -arbre d'appel, -commun, -externe, -usage.

-liste
Spécifie qu'une liste du programme Fortran doit être imprimée avec la ligne
Nombres. Si ftnchek détecte une erreur, le message d'erreur suit la ligne du programme
avec un caret ( ^ ) spécifiant l'emplacement de l'erreur. Si aucune liste de sources n'a été
demandé, ftnchek imprimera toujours toute ligne contenant une erreur, pour aider le
l'utilisateur pour déterminer où l'erreur s'est produite. Par défaut = non.

Voir aussi: -sortir, \fB-symtab, fB-silencieux.

-makedcls=liste
Préparez un fichier soigneusement formaté de déclarations de variables, de blocs communs et
listes de listes de noms, pour une éventuelle fusion dans le code source. Les déclarations sont
stocké dans un fichier du même nom que le code source, mais avec l'extension
changé en .dcl. Si aucune déclaration n'est écrite dans le fichier, il est supprimé pour
réduire l'encombrement des fichiers vides.

Si l'entrée provient d'une entrée standard, au lieu d'un fichier nommé, alors les déclarations sont
écrit sur la sortie standard.

Les variables sont déclarées par ordre alphabétique dans chaque classe de déclaration et
type, avec des variables entières d'abord, en raison de leur utilisation ultérieure possible dans un tableau
dimensions.

Les instructions PARAMETER sont une exception à la règle de l'ordre alphabétique, car le
La norme Fortran 77 exige que les expressions définissant les valeurs des paramètres se réfèrent
uniquement aux constantes et aux noms de paramètres déjà définis. Cela force l'original
l'ordre du fichier source de ces instructions à conserver dans les fichiers de déclaration.

Déclaration explicite de TOUTE les variables sont considérées comme une bonne programmation moderne
s'entraîner. En utilisant les options du compilateur pour rejeter les variables non déclarées, mal orthographiées
les noms de variables (ou les noms s'étendant au-delà de la colonne 72) peuvent être interceptés au moment de la compilation.
Les déclarations explicites facilitent également grandement le changement de précision en virgule flottante
avec des filtres tels que dtoq(1L), dtos(1L), fd2s(1L), fs2d(1L), qtod(1L), et
arrangé(1L). Ces programmes sont capables de changer les types de virgule flottante explicite
déclarations de type, fonctions intrinsèques et constantes, mais parce qu'elles ne
effectuer une analyse lexicale et grammaticale rigoureuse du code source Fortran,
ils ne peuvent pas fournir de déclarations de type modifiées pour les variables non déclarées. Défaut
réglage = 0, mise en marche = 1.

Différentes options de forme du fichier de déclarations sont contrôlées par le liste,
qui se compose de mots-clés séparés par des virgules ou des deux-points. Il y a trois spéciaux
Mots-clés: TOUTE pour activer toutes les options, aucun pour les éteindre tous, et aider à
imprimez la liste de tous les mots-clés avec une brève explication de chacun. Si liste is
omis, -makedcls équivaut à -makedcls=déclarations (c'est-à-dire produire le
fichier de déclarations en utilisant les options par défaut), et -nomadecls équivaut à
-makedcls=aucun.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce paramètre
est également accepté : le liste est remplacé par un nombre qui est la somme des nombres
entre parenthèses à côté des mots-clés dans la liste suivante. Les mots-clés d'avertissement
avec leurs significations sont les suivantes :

déclarations (1):
Ecrire un fichier de déclaration. (Ceci est impliqué par l'une des autres options, et
peut être omis si d'autres options sont données.)

non déclaré uniquement (2):
Par défaut, toutes les variables sont incluses dans le fichier de déclaration. Avec ça
option, inclure seulement non déclaré variables. Ce paramètre est utile si vous
voulez vérifier les variables non déclarées, car les fichiers source Fortran avec tous
les variables correctement déclarées n'entraîneront pas un .dcl déposer. Avec ça
option, les blocs communs et les listes de noms ne seront pas inclus dans le
dossier de déclaration, car de par leur nature, ils ne peuvent pas être non déclarés.

compact (4):
Les déclarations sont normalement assez imprimées pour s'aligner parfaitement en commun
colonnes, comme dans les fichiers de déclaration issus du vérificateur PFORT étendu,
fort(1L). Cette valeur d'option sélectionne à la place une sortie compacte, sans colonne
alignement.

utiliser-lignes-de-continuation (8):
Provoque l'utilisation de lignes de continuation là où cela est autorisé. La valeur par défaut est de
commencer une nouvelle déclaration sur chaque ligne. Cette option est appropriée à utiliser
avec compact.

mots-clés-minuscules (16):
Affichez les mots-clés Fortran en minuscules au lieu des majuscules par défaut.

vars-et-consts-minuscules (32):
Variables et constantes de sortie en minuscules, au lieu de la valeur par défaut
majuscule. Les constantes de chaîne de caractères ne sont pas affectées par cette option.

exclure-sftran3 (64):
Omettre les déclarations de variables entières internes produites par le SFTRAN3
préprocesseur, xsf3(1L), dans le cadre de la traduction du Fortran structuré
déclarations au Fortran ordinaire. Ces variables ont des noms à six caractères de
la forme NPRddd, NXdddd, N2ddddet N3dddd, Où d est un chiffre décimal.
Parce qu'ils sont invisibles dans le code source SFTRAN3, et changeront si le
Le code SFTRAN3 est modifié, de telles variables ne doivent pas être explicitement déclarées.
Au lieu de cela, ils devraient simplement supposer le type de données Fortran INTEGER par défaut basé sur
sur leur lettre initiale, N.

astérisque-commentaire (128):
Utilisez un astérisque comme caractère de commentaire ; la valeur par défaut est sinon « C ».

commentaire-char-minuscule (256):
Utilisez 'c' au lieu de 'C' ou '*' comme caractère de commentaire.

supprimer-dimensions-tableau (512):
Supprimer le dimensionnement des tableaux dans les déclarations générées. Cette option
est à utiliser avec du code sans déclaration de type, pour permettre la déclaration
fichiers à insérer sans modification dans le code. Puisque le code aura
instructions de dimension déjà, dimensionnement des variables de tableau dans le type
instructions du fichier de déclaration est redondante. Cette option doit être utilisée
uniquement en conjonction avec l'option 2 = non déclaré uniquement, car sinon tout
les tableaux qui ont été dimensionnés dans une instruction de type perdront leur
dimensionnement.

de forme libre (1024):
Produire des déclarations sous forme de source libre. Ce mode est automatiquement utilisé si
la source d'entrée est de forme libre. Utilisez cette option pour produire des déclarations dans
forme libre même si l'entrée est sous forme fixe. Les déclarations sous forme libre sont
en retrait seulement 2 colonnes au lieu de 6, utilisez le point d'exclamation comme commentaire
caractère, et indiquez les lignes de continuation par une esperluette à la fin du
ligne à suivre.

Les fichiers de déclaration contiennent des commentaires distinctifs qui marquent le début et la fin de
déclarations pour chaque unité de programme, pour faciliter l'utilisation des macros de l'éditeur de texte pour
fusionner les déclarations dans le code source.

La ftnchek la distribution comprend un programme, dcl2inc, qui traite la déclaration
fichiers pour produire des fichiers contenant les déclarations de tous les blocs COMMUNS, sous une forme
approprié pour une utilisation en tant que fichiers INCLUDE. Voir le dcl2inc(1L) page de manuel pour les détails de
Son usage.

Voir aussi: -mkhtml.

-mkhtml=liste
Produire une documentation HTML à partir de la source. Crée des fichiers HTML individuels à partir de ftnchek
analyse et commentaires de code. Tous les commentaires précédant et suivant immédiatement le
la définition de fonction ou de sous-routine est capturée dans le fichier HTML. Pas de reformatage de
les commentaires source sont effectués à part la suppression des caractères de commentaire FORTRAN.
De plus, le fichier HTML liste les variables locales déclarées, bloc commun
variables utilisées, fonctions et sous-programmes appelés, utilisation des unités d'E/S et autres
informations sur chaque sous-programme. Habituellement, vous voudrez également spécifier
-call=arbre pour créer le fichier HTML racine CallTree.html. (Peut-être que ce fichier devrait
être nommé index.html.)

Diverses options pour la forme des fichiers HTML sont contrôlées par le liste, Qui
se compose de mots-clés séparés par des virgules ou des deux-points. Il y a trois spéciaux
Mots-clés: TOUTE pour activer toutes les options, aucun pour les éteindre tous, et aider à
imprimez la liste de tous les mots-clés avec une brève explication de chacun. Si liste is
omis, -mkhtml équivaut à -mkhtml=documents (c'est-à-dire produire le document HTML
fichiers en utilisant les options par défaut), et -nomkhtmls équivaut à -mkhtml=aucun.

Par souci de simplicité, les options de -mkhtml sont les mêmes que ceux pour
-makedcls sauf ceux qui sont inapplicables. De même, une forme numérique de
ce paramètre peut être utilisé, formé comme la somme des nombres entre parenthèses dans le
la liste qui suit. Les mots-clés d'avertissement avec leur signification sont les suivants :

documents (1):
Créez les documents HTML. (Ceci est impliqué par l'une des autres options, et
peut être omis si d'autres options sont données.)

compact (4):
Les déclarations sont normalement assez imprimées pour s'aligner parfaitement en commun
Colonnes. Cette valeur d'option sélectionne à la place une sortie compacte, sans colonne
alignement.

utiliser-lignes-de-continuation (8):
Provoque l'utilisation de lignes de continuation au lieu de commencer une nouvelle déclaration
sur chaque ligne. Cette option est appropriée à utiliser avec compact.

mots-clés-minuscules (16):
Affichez les mots-clés Fortran en minuscules au lieu des majuscules par défaut.

vars-et-consts-minuscules (32):
Variables et constantes de sortie en minuscules, au lieu de la valeur par défaut
majuscule. Les constantes de chaîne de caractères ne sont pas affectées par cette option.

exclure-sftran3 (64):
Omettre les déclarations de variables entières internes produites par le SFTRAN3
préprocesseur, xsf3(1L). (Voir -makedcls pour discuter.)

supprimer-dimensions-tableau (512):
Supprimer le dimensionnement des tableaux dans les déclarations générées. C'est
normalement indésirable, mais est disponible si, pour une raison quelconque, vous ne voulez pas
dimensions du tableau à apparaître dans le code HTML.

de forme libre (1024):
Produisez des déclarations de variables sous forme de source libre. Ce mode est
automatiquement utilisé si la source d'entrée est de forme libre. Cela affecte principalement le
forme de lignes de continuation si elles sont utilisées.

Voir aussi: -arbre d'appel, -makedcls.

-novice
Ce drapeau est destiné à fournir une sortie plus utile pour les débutants. Il a deux
effets:

(a) fournit un message supplémentaire indiquant qu'une fonction qui est utilisée mais pas
défini n'importe où peut être un tableau que l'utilisateur a oublié de déclarer dans un
instruction DIMENSION (puisque la syntaxe d'une référence de tableau est la même que celle
d'une référence de fonction).

(b) modifie la forme des messages d'erreur et des avertissements. Si le drapeau est tourné
hors de -nonvice, ces messages sont imprimés dans un style plus proche d'UNIX
peluche.

Par défaut = oui.

-sortie=nom de fichier
Ce paramètre est fourni pour plus de commodité sur les systèmes qui ne permettent pas un
redirection de la sortie des programmes. Lorsque ce réglage est donné, la sortie qui
apparaît normalement à l'écran sera envoyé au fichier nommé. Noter,
cependant, que les erreurs opérationnelles de ftnchek lui-même (par exemple manque d'espace ou ne peut pas
fichier ouvert) sera toujours envoyé à l'écran. L'extension du nom de fichier est
facultative, et si aucune extension n'est donnée, l'extension .lis sera utilisé.

-taille du pointeur=num
Spécifie la taille d'une variable ``Cray pointeur'' à être num octets. Par défaut = tour-
activé = 4 octets.

La taille du pointeur est utilisée pour informer les avertissements de non-concordance de précision impliquant le pointeur
variables, par exemple lorsqu'un pointeur reçoit une valeur d'une allocation
routine, ou passé en tant que paramètre de sous-programme.

Voir aussi: -f77, -portabilité, -troncature, -taille de mot.

-portabilité=liste
ftnchek donnera des avertissements pour une variété d'utilisations non portables. Les exemples comprennent
l'utilisation des tabulations sauf dans les commentaires ou à l'intérieur des chaînes, l'utilisation de Hollerith
constantes et l'équivalence de variables de différents types de données. Cette option
ne produit pas d'avertissements pour les extensions prises en charge à la norme Fortran 77,
ce qui peut également causer des problèmes de portabilité. Pour les attraper, utilisez le -f77 réglage.
Par défaut, tous les avertissements sont désactivés.

Ce paramètre fournit un contrôle détaillé sur les avertissements concernant la portabilité possible
problèmes. Le liste se compose de mots-clés séparés par des virgules ou des deux-points. Il y a
trois mots-clés spéciaux : TOUTE pour activer tous les avertissements concernant les usages non portables,
aucun pour les éteindre tous, et aider pour imprimer la liste de tous les mots-clés avec un
brève explication de chacun. Si liste est omis, -portabilité équivaut à
-portabilité=touset -pas de portabilité équivaut à -portabilité=aucuneL’
les mots-clés d'avertissement avec leur signification sont les suivants :

barre oblique inverse:
Barre oblique inverse dans les chaînes. Étant donné que certains compilateurs traitent la barre oblique inverse comme
un caractère d'échappement, sa présence peut poser problème même s'il est utilisé
d'une manière conforme aux normes.

alignement commun:
Variables de bloc COMMON pas dans l'ordre décroissant de la taille de stockage. Quelques
les compilateurs nécessitent cet ordre en raison des exigences d'alignement du stockage.

Hollerith:
Constantes de Hollerith (autres que dans les spécifications FORMAT). Le Hollerith
le type de données est une fonctionnalité de Fortran IV qui a été supprimée dans le Fortran 77
la norme. Il est remplacé par le type de données caractère. Stocker Hollerith
les données dans les variables d'un type de données numérique ou logique ne sont pas portables en raison de
tailles de mots différentes.

longue chaîne:
Constantes de chaîne, variables ou expressions de plus de 255 caractères.

équivalence mixte:
Variables de différents types de données équivalentes.

taille mixte:
Variables déclarées avec une précision par défaut utilisées avec des variables rendues explicites
précision, dans des expressions, des affectations ou en tant qu'arguments. Par exemple, si un
La variable déclarée comme REAL*8 est traitée comme équivalente à DOUBLE PRECISION.

vraiment faire:
Index et limites de boucle DO non entiers. Ceux-ci peuvent faire en sorte que les résultats d'un programme
dépendent des caractéristiques matérielles de l'ordinateur particulier utilisé.

param-implicite-type:
Typage implicite d'un paramètre par le type de données de la valeur affectée, s'il
diffère du type par défaut. Cet avertissement ne peut se produire que si implicite
la saisie des paramètres a été activée par le -source=param-type-implicite
option, ou si l'instruction PARAMETER est de la forme non standard sans
parenthèses. Si cette option est activée, alors toutes les instances où implicite
le typage des paramètres se produit et lorsque le type implicite est différent du type
type par défaut basé sur la première lettre du nom du paramètre, sera averti
sur. La saisie de paramètres implicites peut modifier la sémantique des instructions
où le paramètre est utilisé, provoquant des problèmes de portabilité.

languette: Onglets dans le code source. Les onglets sont interprétés différemment par différents
compilateurs. Cet avertissement ne sera donné qu'une seule fois, à la fin du fichier.

Voir aussi: -f77, -f90, -f95, -joli, De style, -taille de mot.

-jolie=liste
Contrôle certains messages liés à l'apparence du code source. Ceux-ci avertissent
sur des choses qui pourraient rendre un programme moins lisible ou tromper le lecteur.
Par défaut, tous les avertissements sont activés.

Ce paramètre fournit un contrôle détaillé sur les avertissements concernant l'apparence. le
liste se compose de mots-clés séparés par des virgules ou des deux-points. Étant donné que tous les avertissements sont activés
par défaut, incluez un mot-clé préfixé par no- pour désactiver un avertissement particulier.
Il y a trois mots-clés spéciaux : TOUTE pour activer tous les avertissements concernant les erreurs
les apparences, aucun pour les éteindre tous, et aider pour imprimer la liste de tous les
mots-clés avec une brève explication de chacun. Si liste est omis, -joli is
équivalente à -jolie=toutet -pas joli équivaut à -joli=aucunL’
les mots-clés d'avertissement avec leur signification sont les suivants :

retour alternatif:
Une instruction RETURN a une constante spécifiant un autre point de retour qui
n'est pas compris entre 0 et le nombre d'arguments fictifs qui sont des étiquettes. C'est
légal, et a le même effet qu'un RETOUR sans retour alternatif
expression, mais suggère que le programmeur avait l'intention d'utiliser une autre
étiquette de retour non fournie.

espace-embarqué:
Espace intégré dans les noms de variables ou dans les opérateurs multi-caractères tels que **.

continuation:
Marque de continuation après une ligne de commentaire.

longue ligne:
Lignes (sauf commentaires) sur 72 colonnes de largeur (au-delà de 72 est normalement
ignoré par le compilateur).

manque de place:
Manque d'espace entre la variable et un mot-clé précédent.

multiple-commun:
Bloc COMMON déclaré dans plusieurs instructions. Aucun avertissement n'est donné si le
les instructions sont consécutives à l'exception des lignes de commentaires.

liste de noms multiples:
NAMELIST déclaré dans plusieurs instructions. Aucun avertissement n'est donné si le
les instructions sont consécutives à l'exception des lignes de commentaires.

parenthèses:
Parenthèses autour d'une variable en elle-même. En tant qu'argument de sous-programme, ce
fait de l'argument une expression, non modifiable par le sous-programme.

Notez que sous forme de source libre, l'espace supplémentaire et l'espace manquant sont interdits par le
Fortran 90 Standard, et ne sont pas de simples violations de style. Dans ce cas, les avertissements
sont remplacés par des messages d'erreur de syntaxe et ne peuvent être désactivés qu'en utilisant
-pas de contrôle.

Voir aussi: -f77, -portabilité, De style.

-projet=liste
ftnchek créera un fichier de projet à partir de chaque fichier source entré pendant que cette
l'option est activée. Le fichier de projet portera le même nom que l'entrée
fichier, mais avec l'extension .f or .pour remplacé par .prj. (Si l'entrée provient de
entrée standard, le fichier de projet est nommé ftnchek.prj.) Par défaut = aucun.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il ya trois
mots-clés spéciaux : TOUTE pour activer toutes les options, aucun pour les éteindre tous, et
aider pour imprimer la liste de tous les mots-clés avec une brève explication de chacun. Si
liste est omis, -projet équivaut à -projet=touset -pas de projet is
équivalente à -project=aucun. Les mots-clés avec leur signification sont les suivants :

engendrent:
Produire un dossier de projet. La valeur par défaut est de ne pas produire de fichier de projet. Si
cette option n'est pas activée, les autres options n'ont aucun effet.

coupe-appels:
Coupez la quantité d'informations stockées dans le fichier de projet sur le sous-programme
déclarations et appels. C'est la valeur par défaut. Désactivez cette option uniquement dans
situations rares. (Voir la discussion ci-dessous.) La quantité de rognage varie
en fonction de la -bibliothèque drapeau. Plus d'informations sont coupées si ce drapeau est
allumé.

garniture-commun:
Réduisez le nombre de déclarations de bloc communes stockées dans le fichier de projet.
C'est la valeur par défaut. Désactivez cette option uniquement dans de rares situations. (Voir
discussion ci-dessous.) Cette option n'a aucun effet si le -bibliothèque le drapeau est tourné
off : lorsqu'il n'est pas en mode bibliothèque, aucun rognage des déclarations de blocs communs n'est
fait indépendamment de cette option.

Un fichier de projet contient un résumé des informations du fichier source, à utiliser dans
vérifier l'accord entre les utilisations FUNCTION, SUBROUTINE et COMMON dans d'autres fichiers.
Il permet une vérification incrémentielle, ce qui permet de gagner du temps chaque fois que vous disposez d'un grand nombre de
fichiers contenant des sous-programmes partagés, dont la plupart changent rarement. Tu peux courir
ftnchek une fois sur chaque fichier avec le -projet jeu d'indicateurs, créant les fichiers de projet.
Habituellement, vous définissez également le -bibliothèque et -noextern drapeaux à ce moment, pour
supprimer les messages relatifs à la cohérence avec d'autres fichiers. Seuls les messages d'erreur
se rapportant à chaque fichier en lui-même sera imprimé à ce moment. Ensuite, exécutez
ftnchek sans ces drapeaux sur tous les fichiers du projet ensemble, pour vérifier la cohérence
parmi les différents fichiers. Tous les messages internes aux fichiers individuels seront désormais
être omis. Ce n'est que lorsqu'un fichier est modifié qu'un nouveau fichier de projet doit être créé
pour elle.

Naturellement, lorsque le -projet l'option est activée, ftnchek ne lira pas le projet
fichiers en entrée.

Normalement, les options de rognage doivent être laissées activées lorsque vous avez l'intention de créer un projet
fichiers pour une entrée future dans ftnchek. Étant donné que le rognage est activé par défaut, cela signifie
que simplement donner la commande -projet sans liste d'options est le recommandé
mode. Les options de garniture sont fournies uniquement à titre de commodité pour ceux qui souhaitent
utiliser des fichiers de projet à des fins autres que la vérification du programme avec
ftnchek. Pour utiliser les fichiers de projet aux fins prévues, les options de rognage doivent
ne pas être éteint.

Les fichiers de projet contiennent uniquement les informations nécessaires pour vérifier l'accord entre les fichiers.
Cela signifie qu'un fichier de projet n'est d'aucune utilité si tous les modules du programme complet
sont contenus dans un seul fichier.

Une discussion plus détaillée est donnée dans la section sur l'utilisation des fichiers de projet.

-pur
Supposons que les fonctions sont « pures », c'est-à-dire qu'elles n'auront pas d'effets secondaires en modifiant
leurs arguments ou variables dans un bloc COMMON. Lorsque ce drapeau est en vigueur,
ftnchek basera sa détermination du statut défini et utilisé des arguments réels
en supposant que les arguments passés à une fonction ne sont pas modifiés. Ce sera
émet également un avertissement si une fonction modifie l'un de ses arguments ou
Variables COMMUNES. Par défaut = oui.

Lorsque ce drapeau est désactivé, les arguments réels passés aux fonctions seront traités
de la même manière que les arguments réels passés aux sous-programmes. Cela signifie que ftnchek
supposera que les arguments peuvent être modifiés par les fonctions. Aucun avertissement ne sera
donné si une fonction s'avère avoir des effets secondaires. Parce qu'un contrôle plus strict est
possible si les fonctions sont supposées pures, vous ne devez désactiver cet indicateur que si
votre programme utilise en fait des fonctions avec des effets secondaires.

-silencieux
Cette option réduit la quantité de sortie relative au fonctionnement normal, de sorte que
les messages d'erreur sont plus apparents. Cette option est fournie pour la commodité de
les utilisateurs qui vérifient de grandes suites de fichiers. La production éliminée comprend le
les noms des fichiers de projet et le message signalant qu'aucune erreur de syntaxe n'a été trouvée.
Il élimine également certaines lignes vides qui sont normalement incluses pour plus de clarté. (Quelques
de cette sortie est réactivée par le -liste et -symtab options.) Par défaut = non.

Remarque : la façon de se souvenir de la différence entre le -silencieux et -bref que
-silencieux ne supprime aucune information liée aux avertissements, alors que -bref t.

Voir aussi: -bref.

-référence
Spécifie qu'une table qui appelle qui soit imprimée. Ce tableau répertorie chaque sous-programme
suivi d'une liste des routines qu'il appelle. Ce commutateur équivaut à
-calltree=référence. Par défaut = non.

La liste de référence omet les routines appelées par les modules de bibliothèque inutilisés. Ainsi il
contient les mêmes informations que pour le format d'arbre d'appel, à savoir la hiérarchie des
appels de sous-programme, mais imprimés d'une manière différente. Cela imprime une largeur d'abord
parcours de l'arbre d'appel alors que -calltree=arbre imprime une profondeur d'abord
traversée.

Voir aussi: -arbre d'appel, -référence croisée, -bibliothèque, -sorte, -symtab, -vcg.

-Ressources
Imprime la quantité de ressources utilisées par ftnchek dans le traitement du programme. Cette
la liste peut être utile pour analyser la taille et la complexité d'un programme. Ça peut
également aider à choisir des tailles plus grandes pour ftnchekles tables internes si elles le sont aussi
petit pour analyser un programme particulier. Par défaut = non.

Dans cette liste, le terme ``taille de morceau'' est la taille des blocs de mémoire
alloué pour stocker l'article en question, en unités de la taille d'un article, non
nécessairement en octets. Lorsque l'espace initialement alloué est rempli, plus de mémoire
est alloué en morceaux de cette taille. Ce qui suit est une explication des éléments
imprimé:

Identifier lignes traité:
Nombre total de lignes de code, avec des totaux séparés pour les lignes de relevé et
lignes de commentaires. Les lignes de commentaires incluent également les lignes avec 'C' ou '*' dans la colonne 1
sous forme de lignes vierges et de lignes contenant uniquement un commentaire en ligne. Lignes de relevé
sont toutes les autres lignes, y compris les lignes qui ont un commentaire en ligne après certains
code. Les lignes de continuation sont comptées comme des lignes séparées. Les lignes incluses
les fichiers sont comptés à chaque fois que le fichier est inclus.

Total exécutable déclarations:
Nombre d'instructions dans le programme, autres que la spécification, les données, l'instruction-
fonctions, FORMAT, ENTRY et END.

Total nombre of modules:
Un module est tout sous-programme externe, y compris le programme principal, les sous-programmes,
fonctions et blocs de données. Ce nombre est de modules définis dans le
source, pas les modules référencés. Les fonctions d'instruction ne sont pas incluses. UNE
sous-programme avec plusieurs points d'entrée n'est compté qu'une seule fois.

Total déclaration qui défini
Nombre d'étiquettes attachées aux déclarations (souvent appelées numéros de déclaration). le
le nombre total d'étiquettes pour l'ensemble du programme est donné, ainsi que le maximum
numéro dans un seul sous-programme.

Max identifiant prénom caractères :
Nombre de caractères utilisés pour stocker les noms d'identifiant. Un identifiant est un
variable, sous-programme ou nom de bloc commun. Les noms locaux sont ceux des
variables dans un sous-programme, alors que les noms globaux font référence au sous-programme et aux
les noms de blocs, ainsi que les noms d'arguments factices et les noms de variables communs. Réel
le texte de l'argument (jusqu'à 15 caractères pour chaque argument) est également inclus ici.
L'espace utilisé pour les noms locaux n'est pas récupéré à la fin de chaque module, donc
ce nombre, comme l'espace global, croît jusqu'à ce que l'ensemble du programme soit analysé.
Malheureusement, ce chiffre peut inclure du texte stocké plus d'une fois,
bien qu'une heuristique soit utilisée qui évitera les doublons dans de nombreux cas.

Max jeton texte caractères :
Un jeton est la plus petite unité syntaxique du langage FORTRAN au-dessus du niveau
de caractères individuels. Par exemple, un jeton peut être un nom de variable, un
constante numérique, une chaîne de texte entre guillemets ou un caractère de ponctuation. Jeton
le texte est stocké pendant qu'un module est en cours de traitement. Pour des raisons techniques,
les jetons à un seul caractère ne sont pas inclus dans ce total. Les articles qui ne sont pas
représentés dans la table des symboles peuvent être dupliqués. L'espace pour le texte symbolique est
récupéré à la fin de chaque module, ce chiffre représente donc le maximum pour
n'importe quel module.

Max locales symboles:
Il s'agit du plus grand nombre d'entrées dans la table des symboles locaux pour n'importe quel module.
Les entrées de la table des symboles locaux incluent toutes les variables et tous les paramètres, le bloc commun
noms, fonctions d'instruction, sous-programmes externes et fonctions intrinsèques
référencé par le module. Les constantes littérales ne sont pas stockées dans le symbole local
tableau.

Max de défis symboles:
Il s'agit du nombre d'entrées dans la table des mnémoniques globale à la fin de
En traitement. Les entrées globales de la table des symboles incluent le sous-programme externe et les
noms de blocs. Les fonctions intrinsèques et les fonctions d'instruction ne sont pas incluses.

Max nombre of listes de jetons :
Une liste de jetons est une séquence de jetons représentant l'argument réel ou fictif
liste d'un sous-programme, ou la liste des variables dans un bloc commun ou une liste de noms.
Par conséquent, ce nombre représente la plus grande somme de COMMON, CALL, NAMELIST et
Instructions ENTRY et appels de fonction pour n'importe quel module. L'espace est
récupéré à la fin de chaque module.

Max jeton liste/arbre espacer:
Il s'agit du plus grand nombre de jetons dans toutes les listes de jetons et arborescences de jetons de
n'importe quel module. Un arbre à jetons est formé lors de l'analyse d'une expression : chaque
l'opérande est une feuille de l'arbre et les opérateurs sont les nœuds. C'est pourquoi ce
nombre est une mesure de la complexité maximale d'un module individuel. Pour
exemple, un module avec de nombreuses expressions arithmétiques longues aura une valeur élevée
numéro. Notez que contrairement au texte de jeton décrit ci-dessus, le nombre de jetons est
indépendamment de la longueur des noms de variables ou des constantes littérales dans le
expressions.

Numéro of sous-programme appels :
C'est la somme sur tous les modules du nombre d'instructions et de fonctions CALL
appels (à l'exception des fonctions intrinsèques et des fonctions d'instruction).

Numéro of commun bloc déclarations :
Il s'agit de la somme sur tous les modules du nombre de déclarations de blocs communes.
C'est-à-dire que chaque déclaration d'un bloc dans un module différent est comptée
séparément. (La norme autorise plusieurs déclarations d'un bloc dans le
même module ; ceux-ci sont comptés comme une seule déclaration puisqu'ils sont
équivalent à une seule longue déclaration.)

Numéro of tableau dim & arrêter pts :
C'est la somme sur tous les modules du nombre de dimension et de paramètre du tableau
chaînes de texte de définition enregistrées pour être utilisées par le -makedcls option. La longueur de
les chaînes de texte ne sont pas comptées. Chaque dimension d'un tableau multidimensionnel est
compté séparément.

Ces nombres ne sont évidemment pas les mêmes lorsque des fichiers de projet sont utilisés à la place de
le code source d'origine. Même les nombres pour les entités globales peuvent être différents,
car certaines informations redondantes sont éliminées dans les fichiers de projet.

-six caractères
L'un des objectifs de la ftnchek programme est d'aider les utilisateurs à écrire du Fortran portable
programmes. Une source potentielle de non-portabilité est l'utilisation de noms de variables qui
font plus de six caractères. Certains compilateurs ignorent simplement les caractères supplémentaires.
Ce comportement pourrait potentiellement conduire à considérer deux variables différentes comme
le même. Par exemple, les variables nommées AVERAGECOST et AVERAGEPRICE sont les mêmes
dans les six premiers caractères. Si vous souhaitez détecter de tels conflits possibles, utilisez
ce drapeau. Par défaut = non.

Utilisez l'option -f77=noms-longs si vous voulez lister TOUTE variables de plus de six
caractères, pas seulement ces paires qui sont les mêmes dans les six premiers.

Voir aussi: -f77, -portabilité.

-sorte
Spécifie qu'une liste triée de tous les modules utilisés dans le programme soit imprimée. Cette
liste est dans l'ordre des ``prérequis'', c'est-à-dire que chaque module n'est imprimé qu'après tous les
les modules à partir desquels il est appelé ont été imprimés. C'est ce qu'on appelle aussi un
``tri topologique'' de l'arbre d'appels. Chaque module n'est répertorié qu'une seule fois. Routines
qui ne sont pas dans l'arbre d'appels du programme principal sont omis. S'il y en a
cycles dans le graphe d'appels (illégal en Fortran standard) ils seront détectés et
diagnostiqué. Par défaut = non.

Voir aussi: -arbre d'appel, -référence croisée, -référence, -symtab, -vcg.

-source=liste
Ce paramètre contrôle certaines options concernant la forme du code source Fortran.
La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il ya trois
mots-clés spéciaux : TOUTE pour activer toutes les options, aucun pour les éteindre tous, et
aider pour imprimer la liste de tous les mots-clés avec une brève explication de chacun. Si
liste est omis, -source équivaut à -source=toutet -Aucune source est équivalent
à -source=aucun.

Pour la compatibilité avec les versions précédentes de ftnchek, une forme numérique de ce paramètre
est également accepté : le liste est remplacé par un nombre qui est la somme des nombres
entre parenthèses à côté des mots-clés dans la liste suivante. (Le fixé et faim
n'ont pas de valeurs numériques.) Les mots-clés d'avertissement avec leurs significations sont
comme suit:

fixé:
Interprétez la source comme une forme fixe (avec des extensions prises en charge telles que
point d'exclamation pour les commentaires). Les déclarations doivent être dans les colonnes 7 à 72
(à moins que le -cols a été utilisé pour changer cela), et les blancs ne sont pas
contexte de caractère extérieur significatif (mais mis en garde sous le -joli
option). C'est le mode par défaut sauf si l'extension du fichier source est .f90
or .F90. cette option ne peut pas être donnée avec -source=gratuit.

faim: Interpréter la source sous forme libre. Les déclarations peuvent être n'importe où dans les colonnes 1
à 132, les commentaires ne peuvent commencer que par un point d'exclamation et les blancs sont
requis à certains endroits comme entre les identifiants et les mots-clés. C'est
le mode par défaut si l'extension du fichier source est .f90 or .F90. Cette option
ne peut pas être donné avec -source=fixe or -source=déc-onglet

onglet déc. (1):
Acceptez la source formatée par tabulation de style DEC. Une ligne commençant par une tabulation initiale
sera traité comme une nouvelle ligne d'instruction à moins que le caractère après la tabulation ne soit
un chiffre différent de zéro, auquel cas il est traité comme une ligne de continuation. le
la colonne suivante après la tabulation ou la marque de continuation est considérée comme la colonne 7. A
un avertissement sera donné dans le cas où la ligne est une continuation, si
-f77=déc-tabulation est en vigueur.

vms-inclure (2):
Acceptez les instructions INCLUDE de style VMS. Ceux-ci suivent la syntaxe normale, mais
avec les fonctionnalités supplémentaires suivantes : (1) l'extension de fichier, si elle n'est pas indiquée,
par défaut la même extension qu'une extension de fichier source normale ; et (2) l'option
/LIST ou /NOLIST peuvent être ajoutés au nom du fichier d'inclusion, pour contrôler la liste
de son contenu.

barre oblique inverse unix (4):
Gère les échappements antislash de style UNIX dans les chaînes de caractères. L'évasion
la séquence suivant la barre oblique inverse sera évaluée selon l'ANSI
standard pour les chaînes en C : jusqu'à trois chiffres signifient une valeur octale, un x
signifie le début d'une constante hexadécimale, l'une des lettres abfnrt
signifient des codes de contrôle spéciaux et tout autre caractère (y compris une nouvelle ligne)
signifie le personnage lui-même. Lorsque cette option de code source est en vigueur, un
un avertissement sera donné si le -f77=barre oblique inverse le réglage est spécifié.

Le comportement par défaut est de traiter la barre oblique inverse comme n'importe quelle autre normale
caractère, mais un avertissement concernant la portabilité sera généré si le
-portabilité le drapeau est défini. Du fait que certains compilateurs traitent les
barre oblique inverse d'une manière non standard, il est possible pour les normes conformes
les programmes ne sont pas portables s'ils utilisent la barre oblique inverse dans les chaînes.

Depuis que ftnchek ne fait pas grand chose avec la chaîne interprétée, c'est rarement
nécessaire d'utiliser cette option. Il est nécessaire pour éviter les faux
avertissements uniquement si (a) le programme en cours de vérification utilise une barre oblique inverse pour intégrer un
apostrophe ou guillemet dans une chaîne au lieu d'utiliser le mécanisme standard
de doubler le délimiteur ; (b) la barre oblique inverse est utilisée pour échapper à la fin de
line afin de continuer une chaîne sur plusieurs lignes source ; ou (c) un
La définition de PARAMETER utilise une fonction de chaîne intrinsèque telle que LEN avec un tel
une chaîne comme argument, et cette valeur est ensuite utilisée pour définir le tableau
dimension, etc...

param-implicite-type (8):
Typage implicite d'un paramètre par le type de données de la valeur affectée. Quelques
les compilateurs non standard peuvent autoriser le type de données de la valeur à remplacer le
Fortran 77 type par défaut d'un paramètre basé sur la première lettre de
le nom du paramètre. Cette option ne s'applique qu'aux instructions PARAMETER du
forme standard qui a des parenthèses. Un paramètre qui a été explicitement
déclaré dans une instruction de type avant l'instruction PARAMETER n'est pas affecté
par cette option. Un avertissement sera donné sous le -f77=param-type-implicite
or -portability=param-type-implicite option.

Notez que ce typage implicite est traité comme équivalent à un type explicite
déclaration pour le paramètre. Par conséquent, si vous utilisez
-makedcls=non déclaré uniquement générer uniquement des déclarations de non déclarés
variables, ces paramètres seront ne sauraient être compris.

dec-param-type-standard (16):
Suivez la règle Fortran 77 pour la saisie des données des paramètres de style DEC Fortran.
Ceux-ci sont déclarés à l'aide d'une forme non standard de l'instruction PARAMETER qui
manque de parenthèses. Selon DEC Fortran, les paramètres définis par ce formulaire
de l'instruction ont leur type de données donné par le type de données de la valeur
attribué. Utilisez cette option pour dire ftnchek de ne pas suivre cette règle mais
au lieu d'utiliser la même règle que pour les instructions PARAMETER standard. Cette
L'option ne s'applique pas aux instructions PARAMETER de la forme standard.

Par défaut, toutes ces options de code source sont désactivées, à l'exception de la
vms-inclure option, qui est activée par défaut dans la version VMS.

Voir aussi: -f77, -comprendre, -portabilité.

-style=liste
Fournit des avertissements très pointilleux sur la programmation obsolète ou démodée
constructions. Cette option est utile pour les efforts visant à suivre une programmation moderne
style. (La plupart des plaintes concernant cette option sont interdites dans le
F sous-ensemble Langue.) By défaut TOUTE avertissements tourné de.

La liste se compose de mots-clés séparés par des virgules ou des deux-points. Il ya trois
mots-clés spéciaux : TOUTE pour activer toutes les options, aucun pour les éteindre tous, et
aider pour imprimer la liste de tous les mots-clés avec une brève explication de chacun. Si
liste est omis, De style équivaut à -style=toutet -pas de style équivaut à
-style=aucun. Les mots-clés d'avertissement avec leur signification sont les suivants :

bloquer-si:
Se plaindre de l'instruction IF arithmétique. Acceptez le SI de bloc ou le SI logique (qui
contrôle une seule instruction).

nom_construction:
Se plaindre des constructions de blocs sans nom : IF, DO et SELECT CASE. Noter que
si un nom de construction est présent dans l'instruction d'ouverture d'une construction, alors
il doit être présent sur toutes les autres instructions de composant (ELSE, END IF,
etc.) de la construction. Dans ce cas, un nom de construction manquant sur ces
instructions génère une erreur de syntaxe quelle que soit cette option. Le but
de cette option est d'avertir si la construction manque complètement de l'optionnel
nom.

distinct-faire:
Se plaindre si deux boucles DO partagent une instruction de terminaison commune.

faire-construire:
Se plaindre si le terminateur d'une boucle DO est autre chose qu'un END DO ou
instruction CONTINUER. C'est l'exigence pour que la boucle réponde
la définition Fortran 90 d'un do-construit.

faire-enddo:
Se plaindre si le terminateur d'une boucle DO est autre chose qu'un END DO
déclaration. (Cette option remplace le faire-construire option, étant même
plus strict.)

nom de fin:
Se plaindre de l'absence du nom du sous-programme sur la FIN structurée
Déclarations.

format-stmt:
Se plaindre de la présence d'instructions FORMAT. Seules les instructions FORMAT
eux-mêmes sont marqués, pas les références à eux dans les listes d'E/S.

goto: Se plaindre de la présence de GOTO inconditionnel, calculé ou assigné
déclarations. Se plaindre également des retours alternatifs (mais pas des étiquettes car
arguments du sous-programme).

étiqueté-stmt:
Se plaindre de la présence d'étiquettes (chiffres) sur des déclarations autres que
instructions FORMAT. (Étant donné que les instructions FORMAT sont sans doute pratiques et non
facilement abusés, les plaintes à leur sujet sont contrôlées par le
format-stmt mot-clé.)

programme-stmt:
Se plaindre de l'absence d'instruction PROGRAM en tête de
.

fin-structuré:
Se plaindre de l'utilisation d'une simple instruction END pour terminer un sous-programme, plutôt
qu'une instruction END structurée (END PROGRAM, END SUBROUTINE, END FUNCTION,
ou END BLOCK DATA).

Voir aussi: -f77, -f90, -f95, -joli, -portabilité.

-symtab
Une table des symboles sera imprimée pour chaque module, répertoriant tous les identifiants
mentionné dans le module. Ce tableau donne le nom de chaque variable, son type de données,
et le nombre de dimensions des tableaux. Un astérisque (*) indique que le
la variable a été typée implicitement, plutôt que d'être nommée dans un type explicite
énoncé de déclaration. Le tableau répertorie également tous les sous-programmes invoqués par le module,
tous les blocs COMMON déclarés, etc. Par défaut = non.

Aussi, pour chaque module, un tableau d'étiquettes sera imprimé. Le tableau répertorie chaque étiquette
défini dans le module ; la ligne sur laquelle ladite étiquette d'instruction est définie ; et le
type d'instruction (exécutable, format ou spécification). Les étiquettes sont répertoriées dans
ordre séquentiel.

Un tableau décrivant les unités d'E/S utilisées par le module, ainsi que
informations sur leur utilisation : quelles opérations sont effectuées, si le
l'accès est séquentiel ou direct, et si l'E/S est formatée ou non formatée.

Voir aussi: -arbre d'appel, -référence croisée, -liste, -référence, -sorte, -vcg.

-troncation=liste
Avertir d'éventuelles erreurs de troncature (ou d'arrondi). La plupart d'entre eux sont liés à
arithmétique entière. Par défaut, tous les avertissements sont activés.

Ce paramètre fournit un contrôle détaillé sur les avertissements concernant une éventuelle troncature
les erreurs. le liste se compose de mots-clés séparés par des virgules ou des deux-points. Puisque toutes
les avertissements sont activés par défaut, incluez un mot-clé préfixé par no- pour désactiver un
avertissement particulier. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
avertissements concernant la troncature, aucun pour les éteindre tous, et aider pour imprimer la liste des
tous les mots-clés avec une brève explication de chacun. Si liste est omis, -troncature
équivaut à -troncation=toutet -pas de troncature équivaut à
-troncation=aucune. Les mots-clés d'avertissement avec leur signification sont les suivants :

int-div-exposant:
utilisation du résultat de la division entière comme exposant. Cela suggère qu'un
le quotient réel est prévu. Un exemple serait d'écrire X**(1/3) pour évaluer
la racine cubique de X. L'expression correcte est X**(1./3.).

int-div-réel:
Conversion d'une expression impliquant une division entière en réel. Cette
suggère qu'un quotient réel est prévu.

int-div-zéro:
division dans une expression constante entière qui donne un résultat de zéro.

puissance-int-neg:
exponentiation d'un entier par un entier négatif (qui donne zéro à moins que
l'entier de base est de 1 en grandeur). Cela suggère qu'une base réelle est
prévu.

promotion:
conversion automatique d'une quantité de précision inférieure en une quantité supérieure
précision. La perte de précision pour les variables réelles dans ce processus est
comparable à la rétrogradation correspondante. Aucun avertissement n'est donné pour la promotion
des quantités entières au réel puisque c'est habituellement exact.

index réel:
utilisation d'un index DO non entier dans une boucle avec des bornes entières. Un entier DO
index avec des limites réelles est toujours averti quel que soit ce paramètre.

indice réel:
utilisation d'un indice de tableau non entier.

chiffres-significatifs:
surspécifier une constante de précision unique. Cela peut indiquer qu'un double
constante de précision était prévue.

rétrogradation de taille:
conversion automatique d'une quantité de précision supérieure en une quantité de précision inférieure
du même genre. Cet avertissement se produit uniquement lorsqu'une taille explicite est utilisée dans
déclarer le type d'un ou des deux opérandes dans une affectation. Par exemple, un
un avertissement sera émis lorsqu'une variable REAL*8 est affectée à une variable REAL,
si la taille de mots par défaut de 4 est en vigueur. Un avertissement est également émis si un
un entier long est affecté à un plus court, par exemple, si un INTEGER
expression est affectée à une variable INTEGER*2. Il y a une exception à
ce dernier cas, à savoir si le côté droit de l'affectation est un petit
constante littérale (inférieure à 128). rétrogradation de type: conversion automatique d'un
quantité de précision supérieure à une précision inférieure de type différent. Cette
l'avertissement inclut la conversion de quantités réelles en nombres entiers, double précision
à simple précision réel, et affectation d'une chaîne de caractères plus longue à un
un plus court.

Les avertissements concernant la promotion et la rétrogradation s'appliquent également aux constantes complexes,
considérant que la précision est celle de la partie réelle ou imaginaire. Avertissements sur
les promotions et rétrogradations ne sont accordées que lorsque la conversion se fait automatiquement,
par exemple dans des expressions de précision mixte ou dans une instruction d'affectation. Si intrinsèque
des fonctions telles que INT sont utilisées pour effectuer la conversion, aucun avertissement n'est donné.

Voir aussi: -portabilité, -taille de mot.

-utilisation=liste
Avertir des variables non utilisées ou possibles non initialisées, des blocs communs non utilisés,
étiquettes d'instructions non définies ou non utilisées et sous-programmes non utilisés ou non définis. Par
par défaut, tous les avertissements sont activés.

Ce paramètre fournit un contrôle détaillé sur les avertissements concernant une utilisation possible
les erreurs. le liste se compose de mots-clés séparés par des virgules ou des deux-points. Puisque toutes
les avertissements sont activés par défaut, incluez un mot-clé préfixé par no- pour désactiver un
avertissement particulier. Il y a trois mots-clés spéciaux : TOUTE pour allumer tous les
avertissements sur l'utilisation, aucun pour les éteindre tous, et aider pour imprimer la liste de tous
les mots-clés avec une brève explication de chacun. Si liste est omis, -usage is
équivalente à -usage=toutet -Pas d'utilisation équivaut à -usage=aucun. Ces
les avertissements couvrent quatre catégories principales d'objets : arguments factices de sous-programme,
blocs et variables, sous-programmes et fonctions, et variables locales. Mises en garde
inclure les éléments non définis, multiplier les éléments définis, les éléments inutilisés, etc. L'avertissement
les mots-clés avec leur signification sont les suivants :

arg-alias:
un argument factice scalaire est en fait le même qu'un autre et est (ou peut être)
modifié. La norme Fortran 77 (section 15.9.3.6) interdit de modifier un
argument qui est alias à un autre.

arg-array-alias:
un argument factice qui est un tableau ou un élément de tableau est dans le même tableau que
un autre et est modifié. Ce drapeau est similaire à arg-alias mais fournit
contrôle séparé sur les arguments du tableau. Il est plus difficile de dire si l'alias est
se produisant dans le cas des tableaux, donc si ftnchek donne trop de faux avertissements,
ce drapeau permet à ceux liés au tableau d'être désactivés sans supprimer
les avertissements pour les scalaires.

arg-alias-commun:
un argument factice scalaire est le même qu'une variable commune dans le sous-programme,
et l'un ou l'autre est modifié. Ceci est également interdit par la norme Fortran 77.
Si la vérification commune n'est pas exacte (voir le -commun réglage), il est plus difficile de
dire si un alias se produit, donc l'avertissement est donné si la variable est
n'importe où dans un bloc commun déclaré par le sous-programme.

arg-common-array-alias:
un argument factice qui est un tableau ou un élément de tableau est dans le même tableau qu'un
variable commune, et l'une ou l'autre est modifiée. Si la vérification commune n'est pas exacte,
la variable peut être n'importe où dans un bloc commun qui est déclaré par le
sous-programme.

arg-const-modifié:
un sous-programme modifie un argument qui est une constante ou une expression. Tel
une action pourrait provoquer un comportement anormal du programme.

arg-inutilisé:
un argument factice est déclaré mais jamais utilisé. Ceci est similaire au
var-inutilisé mot-clé décrit ci-dessous, mais ne s'applique qu'aux arguments.

com-block-inutilisé:
un bloc commun est déclaré mais aucune des variables qu'il contient n'est utilisée par aucun
sous-programme. Cet avertissement est supprimé si le paramètre de rigueur commun est
0.

com-bloc-volatil:
un bloc commun peut perdre la définition de son contenu si des blocs communs sont
volatil. Cette option n'a d'effet que si le -commun=volatil le drapeau est dans
effet. Voir la discussion sur le -commun réglage ci-dessus.

com-var-set-inutilisé:
une variable commune se voit attribuer une valeur, mais sa valeur n'est utilisée par aucun
sous-programme. Cet avertissement est supprimé si le paramètre de rigueur commun est
0.

com-var-non-initialisé:
la valeur d'une variable commune est utilisée dans certains sous-programmes, mais n'est pas définie
partout. Malheureusement, ftnchek ne fait pas une analyse suffisamment approfondie de
la séquence d'appel pour savoir quelles routines sont appelées avant les autres. Alors
des avertissements sur ce type d'erreur ne seront donnés que dans les cas où un
La variable est utilisée dans certaines routines mais n'est définie dans aucune autre routine. Vérification
des variables COMMUNES individuelles n'est effectué que si le -commun le réglage est 3
(variable par accord variable). Cet avertissement est supprimé si le
le paramètre de rigueur est 0.

com-var-inutilisé:
une variable commune est déclarée mais n'est utilisée par aucun sous-programme. Cet avertissement
est supprimée si le paramètre de rigueur commun est 0.

do-index-modifié:
une variable qui est l'index d'une boucle DO est modifiée par une instruction
dans la plage de la boucle. La norme permet à une variable DO active de
être modifié uniquement par le mécanisme d'incrémentation de l'instruction DO.

ext-multiplier-défini:
un externe (un sous-programme ou une fonction) est défini plus d'une fois. Définition
d'un moyen externe fournissant le corps de son code source.

poste-déclaré-seulement:
un nom est déclaré dans une instruction EXTERNAL dans un module, mais n'est pas
défini ou utilisé n'importe où.

poste indéfini:
un externe est utilisé (invoqué) mais n'est défini nulle part. Cette option est
équivalent à la -externe drapeau. Si le sous-programme est invoqué plus de
une fois, ces invocations seront toujours vérifiées pour la cohérence.

poste inutilisé:
un externe est défini (son corps de sous-programme est présent) mais il n'est pas utilisé.
Un sous-programme est considéré comme inutilisé même s'il est invoqué par un autre
sous-programme, s'il ne peut être appelé à partir d'aucun thread d'exécution commençant par
le programme principal. L'accord des arguments du sous-programme avec ses
appels est toujours vérifié même si cet avertissement est désactivé. S'il y a
pas de programme principal, cet avertissement n'est émis que si le sous-programme n'est pas
invoqué n'importe où. Cet avertissement est supprimé en mode bibliothèque, mais la bibliothèque
mode a pour effet supplémentaire de supprimer la vérification des arguments pour les inutilisés
routines.

étiquette-indéfini:
une déclaration fait référence à une étiquette qui n'a pas été définie.

étiquette-inutilisé:
une étiquette d'instruction est définie, mais jamais référencée.

var-ensemble-inutilisé:
une variable locale reçoit une valeur, mais cette valeur n'est pas utilisée.

var-non-initialisé:
la valeur d'une variable locale peut être utilisée avant qu'elle ne soit affectée. Parfois
ftnchek fait une erreur dans les avertissements concernant l'utilisation des variables locales. D'habitude
il se trompe en donnant un avertissement là où aucun problème n'existe, mais dans de rares cas
cas, il peut ne pas avertir lorsque le problème existe. Voir la section sur
Bugs pour exemples. Si les variables sont équivalentes, la règle utilisée par ftnchek
est qu'une référence à n'importe quelle variable implique la même référence à tous
variables auxquelles il est équivalent. Pour les tableaux, la règle est qu'une référence à
tout élément du tableau est traité comme une référence à tous les éléments du tableau.

var-inutilisé:
une variable locale est déclarée (par exemple, dans une déclaration de type) mais n'est pas
utilisé dans le module. Ne s'applique pas aux arguments factices : avertissements à leur sujet
sont contrôlés par le mot-clé arg-inutilisé décrit ci-dessus.

Remarque : dans les versions de ftnchek avant le 2.10, le -usage flag a pris un argument numérique
au lieu d'une liste d'options. Pour le bien des utilisateurs qui peuvent avoir écrit des scripts
invoquer ftnchek de cette façon, la forme numérique est toujours acceptée. Le numérique
réglage est composé de trois chiffres. Le premier chiffre (des centaines) contrôle
avertissements sur les sous-programmes (fonctions et sous-programmes), le deuxième chiffre (des dizaines
place) des avertissements sur les blocs communs et les variables communes, et le troisième chiffre
(les uns placent) des avertissements sur les variables locales. Chaque chiffre contrôle les avertissements
selon la convention qu'un 1 signifie avertir des éléments et des variables non définis
qui sont utilisés avant le réglage, un 2 signifie avertir des éléments qui ne sont pas utilisés, et un 3 signifie
avertir des deux types. Ces nombres sont maintenant convertis en valeurs appropriées
pour les mots-clés listés ci-dessus, à l'exception de com-bloc-volatil, qui n'est pas affecté
par l'argument numérique.

Voir aussi: -commun, -déclarer, -externe, -bibliothèque.

-vcg
Produire le graphe d'appel sous la forme d'une description de graphe VCG. Cette description est
écrit dans un fichier séparé, avec la même racine que le fichier contenant le
programme et suffixe .vcg. Ce fichier peut être remis directement à xvcg(1L) à
visualiser le graphique des appels. (Si l'entrée provient de l'entrée standard, le graphique
description est envoyée à la sortie standard.) Ce commutateur est équivalent à
-calltree=vcg. Par défaut = non.

La description du VCG telle qu'elle a été créée est plus complexe qu'elle ne devrait l'être. VCG permet des graphiques
et sous-graphes imbriqués : chaque sous-programme est créé comme un sous-graphe imbriqué dans son
routines d'appel. Cela vous permet d'afficher de manière interactive des sous-graphes ou de résumer
Eux.

La -vcg possibilité pour ftnchek a été écrit par le Dr Philip Rubini de Cranfield
Université, Royaume-Uni.

xvcg est un outil de visualisation graphique qui fonctionne sous le système X windows. Il est
disponible gratuitement sur ftp.cs.uni-sb.de. Il a été écrit par G. Sander du
Université de la Sarre, Allemagne.

Voir aussi: -arbre d'appel, -référence croisée, -référence, -sorte.

-version
Cette option provoque ftnchek pour imprimer une ligne donnant le numéro de version, la date de sortie,
et le niveau de correctif du programme. Si aucun fichier n'est fourni, il se ferme. Si des fichiers
sont donnés, l'effet de cette option est d'inclure le niveau de patch (normalement
omis) dans les informations de version imprimées au début du traitement. Par défaut =
no.

Voir aussi: -Aide.

-volatil
Supposons que les blocs COMMON soient volatiles. Par défaut = non.

Ce drapeau est remplacé par -commun=volatil, et ne doit plus être utilisé. Cela pourrait
être éliminé dans une future version de ftnchek.

Voir aussi: -commun, -usage.

-mots=num
Spécifie la taille de mot par défaut à num octets. C'est la taille de la logique et
variables numériques simple précision qui ne reçoivent pas de précisions explicites.
(Les précisions explicites pour les variables non-caractères sont une extension du Fortran 77
Standard, et sont donnés par des déclarations de type telles que REAL*8 X.) Double précision
et les variables complexes seront deux fois cette valeur, et les variables doubles complexes quatre
fois. Les constantes de précision quad et les résultats des fonctions intrinsèques seront quatre fois
cette valeur. Notez que les variables déclarées comme REAL*16 seront considérées comme quad
précision uniquement si la taille du mot est de 4 octets. Par défaut = activation = 4 octets.

La valeur de la taille du mot n'a pas d'importance pour vérifier les programmes conformes aux normes qui
ne déclarez pas de précisions explicites pour les variables non-caractères ou stockez Hollerith
données en variables. Ce paramètre n'affecte pas non plus la taille par défaut du caractère
variables, qui est toujours de 1 octet. Les constantes de Hollerith sont également supposées occuper
1 octet par caractère.

La taille du mot est utilisée pour déterminer si la troncature se produit dans l'affectation
instructions et pour détecter les incohérences de précision dans les listes d'arguments de sous-programme et
listes de blocage communes. Les avertissements exacts qui sont émis dépendront de l'état
d'autres drapeaux. Sous les deux -portabilité=taille mixte et par -pas de taille de mot drapeau,
tout mélange d'objets explicites et de précision par défaut (expressions de caractères non
inclus) est mis en garde. Ceci s'applique aux expressions arithmétiques contenant à la fois
types d'objets, et aux arguments de sous-programme et variables COMMUNES. Sous contrôle
des -troncation=rétrogradation et promotion options, un avertissement est donné pour
affectation d'une expression à une variable plus courte du même type, ou pour
promotion d'une valeur de précision inférieure à une précision plus élevée dans une arithmétique
expression ou une instruction d'affectation.

Donner une taille de mot de 0, ou de manière équivalente, en utilisant -pas de taille de mot signifie qu'aucun défaut
valeur sera supposée. Cela équivaut à spécifier -portabilité=taille mixte.
Utilisez-le pour trouver des cas de mélange de précision par défaut et explicite, par exemple pour signaler
endroits où REAL*8 est traité comme équivalent à DOUBLE PRECISION.

Voir aussi: -taille du pointeur, -portabilité, -troncature.

-envelopper=avec
Contrôle l'encapsulation des messages d'erreur. Messages d'erreur longs qui passeraient
la colonne spécifiée sera divisée en lignes séparées entre les mots du
message pour une meilleure lisibilité. Si éteint avec -maintenant, chaque erreur distincte
message sera imprimé sur une ligne, laissant à l'écran le soin d'envelopper le
message ou le tronquer. Par défaut = allumer = 79.

EN CHANGEANT LES DEFAUTS

ftnchek inclut deux mécanismes pour changer les valeurs par défaut de toutes les options : par
en définissant des variables d'environnement ou en créant un fichier de préférences. Lorsque ftnchek commence,
il recherche dans son environnement toutes les variables dont les noms sont composés en préfixant le
chaîne FTNCHEK_ sur la version en majuscules du nom de l'option. Si une telle variable est
trouvé, sa valeur est utilisée pour spécifier la valeur par défaut du commutateur ou du paramètre correspondant.
Dans le cas des réglages (par exemple, le -commun réglage de la sévérité) la valeur du
La variable d'environnement est lue comme valeur de paramètre par défaut. Dans le cas des commutateurs, le
le commutateur par défaut sera considéré comme vrai ou oui à moins que la variable d'environnement n'ait la valeur
0 ou NON.

Notez que le nom de la variable d'environnement doit être construit avec l'option pleine longueur
nom, qui doit être en majuscule. Par exemple, pour faire ftnchek imprimer une liste de sources par
par défaut, définissez la variable d'environnement FTNCHEK_LIST sur 1 ou YES ou autre chose que 0 ou
NON. Les noms FTNCHEK_LIS (pas le nom complet de l'option) ou ftnchek_list (minuscule)
pas être reconnu.

Voici quelques exemples de la façon de définir des variables d'environnement sur divers systèmes. Pour
simplicité, tous les exemples définissent la valeur par défaut -liste passer à OUI.

1. UNIX, shell Bourne : $ FTNCHEK_LIST=YES
$ exporter FTNCHEK_LIST

2. UNIX, shell C : % setenv FTNCHEK_LIST OUI

3. VAX/VMS : $ DEFINE FTNCHEK_LIST OUI

4. MSDOS : $ SET FTNCHEK_LIST=YES

Après avoir traité toutes les variables d'environnement, ftnchek recherche un fichier de préférences
contenant des options et des paramètres. Il recherchera dans l'ordre suivant, en utilisant uniquement le
premier fichier trouvé : (1) .ftnchekrc dans le répertoire courant, (2) ftnchek.ini dans l'actuel
annuaire, (3) .ftnchekrc dans le répertoire personnel de l'utilisateur, (4) ftnchek.ini à la maison
annuaire. Si un tel fichier est trouvé, les options qui y sont définies sont utilisées par défaut dans
place des valeurs par défaut intégrées et outrepassant toutes les valeurs par défaut définies dans l'environnement.

Chaque option ou paramètre du fichier de préférences doit figurer sur une ligne distincte. Ils sont donnés
sous la même forme que sur la ligne de commande, sauf sans le tiret initial. Les préférences
fichier peut contenir des lignes vides et des commentaires. Les commentaires sont introduits à n'importe quel point d'une ligne
par un espace (blanc ou tabulation) ou le caractère '#', et se terminent par la fin de
la ligne.

Les options de la ligne de commande remplacent les valeurs par défaut définies dans l'environnement ou dans les préférences
fichier, de la même manière qu'ils remplacent les valeurs par défaut intégrées.

EN UTILISANT PROJET DES DOSSIERS

Cette section contient des informations détaillées sur la façon d'utiliser les fichiers de projet plus efficacement,
et comment éviter certains pièges.

On peut diviser les chèques ftnchek fait en deux catégories, local et global. Local
la vérification est limitée à une seule routine et détecte des éléments tels que non initialisés
variables, perte involontaire de précision dans les expressions arithmétiques, etc.
la vérification peut être effectuée sur chaque sous-programme indépendamment. De plus, la vérification locale d'un
le sous-programme n'a pas besoin d'être répété lorsqu'un autre sous-programme est modifié. Global
la vérification attrape des choses comme l'appel d'un sous-programme avec les mauvais types d'arguments, ou
désaccord dans les déclarations de blocs communs. Cela nécessite d'examiner l'ensemble des
sous-programmes interagissant les uns avec les autres.

Le but des fichiers de projet est de permettre aux étapes de vérification locale et de vérification globale de
être séparé. En supposant que chaque sous-programme se trouve dans son propre fichier source, vous pouvez exécuter
ftnchek une fois sur chacun pour effectuer une vérification locale tout en supprimant la vérification globale. Puis
ftnchek peut être exécuté une fois sur tous les fichiers du projet ensemble pour effectuer la vérification globale. le
l'exemple de makefile ci-dessous montre comment automatiser cette tâche. La cible ``.f.prj'' met à jour un
projet pour un fichier particulier à chaque fois que le fichier source change. L'information
nécessaire à la vérification globale est enregistré dans le fichier de projet. La cible ``check'' fait le
vérification globale combinée. Typiquement ``make check'' répéterait le ``ftnchek -project''
étape uniquement sur les fichiers source modifiés, puis effectuez la vérification globale. C'est évidemment un gros
avantage pour les grands programmes, lorsque de nombreux sous-programmes changent rarement, voire jamais.

Il est préférable, lors de l'utilisation de fichiers de projet, de placer chaque sous-programme dans un fichier source distinct.
Si chaque fichier source peut contenir plus d'un sous-programme, cela complique la définition
de vérification ``locale'' et ``globale'' car il y a une certaine vérification inter-module qui est
contenu dans un fichier. ftnchek essaie de faire ce qu'il faut dans ce cas, mais il y a
certaines complications (décrites ci-dessous) dues au compromis entre éviter de refaire
vérifie et conserve les informations sur la structure du programme.

Normalement, pour effectuer le moins de vérifications, les fichiers de projet doivent être créés avec
le -bibliothèque drapeau en vigueur et rognage activé. Dans ce mode, les informations enregistrées
dans le fichier de projet se compose de toutes les déclarations de sous-programme, toutes les invocations de sous-programme
non résolu par des déclarations dans le même fichier, et une instance de chaque bloc COMMON
déclaration. Il s'agit de la quantité minimale d'informations nécessaires pour vérifier l'accord entre
fichiers.

Si le fichier source contient plus d'une routine, il y a des problèmes possibles qui
peut provenir de la création du fichier projet en mode bibliothèque, car la hiérarchie d'appel
parmi les routines définies dans le fichier est perdue. De plus, si les routines du fichier font
l'utilisation de blocs COMMUNS qui sont partagés avec des routines dans d'autres fichiers, il n'y aura pas
suffisamment d'informations enregistrées pour la vérification correcte de l'état défini et utilisé des blocs COMMUNS
et les variables COMMUNES selon le -usage réglage. Par conséquent, si vous prévoyez d'utiliser
fichiers de projet lorsque -usage la vérification est activée (ce qui est la situation par défaut), et si
plusieurs routines dans un fichier de projet partagent des blocs COMMUNS avec des routines dans d'autres fichiers,
les fichiers de projet doivent être créés avec le -bibliothèque drapeau éteint. Dans ce mode,
ftnchek enregistre, outre les informations énumérées ci-dessus, une invocation de chaque sous-programme par
tout autre sous-programme dans le même fichier et toutes les déclarations de bloc COMMON. Cela signifie que
le fichier de projet sera plus volumineux que nécessaire, et que lorsqu'il sera lu, ftnchek Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès.
répéter quelques vérifications inter-modules qu'il a déjà effectuées lors de la création du fichier de projet. Si
chaque fichier de projet ne contient qu'un seul module, il n'y a pas de perte d'informations lors de la création
les fichiers du projet en mode bibliothèque.

En raison de la perte possible d'informations entraînée par la création d'un fichier de projet avec le
-bibliothèque flag en vigueur, chaque fois que ce fichier de projet est lu plus tard, il sera traité
en tant que fichier de bibliothèque quel que soit le réglage actuel du -bibliothèque drapeau. De l'autre
part, un fichier de projet créé avec le mode bibliothèque désactivé peut être lu plus tard dans l'un ou l'autre
mode.

La discussion qui précède suppose que les options de rognage du -projet réglage sont
activé lorsque le fichier de projet est créé. C'est la situation normale. le pas de coupe
options du -projet les paramètres sont fournis au cas où l'on voudrait utiliser les fichiers du projet
à des fins autres que la vérification du programme avec ftnchek. Par exemple, on pourrait écrire
un script Perl pour analyser les fichiers du projet afin d'obtenir des informations sur la façon dont les différents
les sous-programmes sont appelés. Vous ne devez pas utiliser le pas de coupe options pour faire face aux problèmes de
la perte d'informations discutée ci-dessus, car ils provoquent plus d'informations que nécessaire à être
stockée. Cela rend les fichiers de projet plus gros et provoque ftnchek faire plus de travail plus tard quand
il les lit pour vérifier votre programme complet. Normalement, vous devez utiliser le -bibliothèque
option pour contrôler la quantité d'informations à stocker pour une utilisation ultérieure par ftnchek en vérifiant votre
.

Voici un exemple d'utilisation d'UNIX faire utilitaire pour créer automatiquement un nouveau
projet chaque fois que le fichier source correspondant est modifié, et de vérifier l'ensemble des
fichiers pour plus de cohérence. Ajoutez ces lignes à votre makefile. L'exemple suppose qu'un
la macro OBJS a été définie qui répertorie tous les noms de fichiers objets à lier
ensemble pour former le programme exécutable complet. (Dans ce makefile, les lignes en retrait
doit commencer par une tabulation et non par des blancs.) Si un fichier source contient plusieurs routines
qui partagent des blocs communs entre eux, alors l'option no-com-\* doit être supprimée
de NOGLOBAL, et/ou supprimez l'indicateur -library.
# indique à make quel est le suffixe d'un fichier de projet
.SUFFIXES : .prj

# ces options suppriment les contrôles globaux.
NOGLOBAL=-usage=no-ext-undefined,no-com-\*

# indique à make comment créer un fichier .prj à partir d'un fichier .f
.f.prj :
ftnchek -projet $(NOGLOBAL) -bibliothèque $

# configurer la macro PRJS contenant les noms de fichiers du projet
PRJS= $(OBJS:.o=.prj)

# "make check" vérifiera tout ce qui a été modifié.
chèque : $(PRJS)
$ (PRJS)

Lorsqu'un programme utilise de nombreuses routines définies dans un grand nombre de fichiers sources différents dans
différents répertoires, il peut être fastidieux de spécifier tous les différents fichiers de projet
nécessaire pour vérifier le programme correctement. Pour faire face à de tels cas, ftnchek permet de projeter
fichiers à concaténer en un seul gros fichier. Ce fichier unique peut alors être remis à
ftnchek fournir les informations permettant de vérifier l'utilisation de tout ou partie des routines
définis dans les fichiers de projet combinés. Lors de l'utilisation d'un tel fichier de projet ``bibliothèque'', vous
peut vouloir ftnchekdes rapports d'erreur pour documenter précisément le nom du fichier où le
fonction spécifique est définie. Si les différents fichiers sources sont dans plusieurs répertoires, un
rapport d'erreur qui ne donne que le nom du fichier peut être ambigu et devrait plutôt inclure le
chemin d'accès au fichier. La solution consiste à créer chacun des fichiers de projet individuels en
donnant le chemin complet du fichier source. Ensuite, ce chemin complet apparaîtra dans le
rapports d'erreurs. Par exemple, supposons que tous les fichiers source du sous-programme de bibliothèque soient
dans les sous-répertoires d'un répertoire nommé /util/lib. Ensuite, les fichiers de projet individuels pourraient
d'abord être créé par une commande telle que
find /util/lib -name '*.f' -exec ftnchek -project '{}' ';'
(Il est possible que d'autres options soient proposées pour ftnchek tel que discuté plus haut. Aussi, cette étape
pourrait être géré à la place par une règle de makefile révisée qui fournirait la source complète
chemin du fichier au lieu du nom local lors de l'appel ftnchek.) Ensuite, concaténez tous les
ces fichiers de projet manuellement.
find /util/lib -name '*.prj' -exec cat '{}' ';' > ourlib.prj
Ensuite, un fichier source de programme peut être vérifié en utilisant la commande
ftnchek prog.f ... -lib ourlib.prj
et un message d'erreur lié à toute routine de bibliothèque inclura le chemin complet vers le
le fichier source de la routine.

À l'heure actuelle, il n'y a pas d'utilitaire d'archivage comme ar pour gérer le contenu d'un concaténé
fichier de projet comme celui de l'illustration ci-dessus. Si des modifications sont apportées à l'un des
routines de bibliothèque, le seul moyen de mettre à jour le fichier de projet combiné est de concaténer tous
à nouveau les fichiers de projet individuels. Un tel utilitaire serait assez facile à écrire.
Quelqu'un devrait le faire et contribuer à la ftnchek effort.

AN EXEMPLE

Le programme Fortran simple suivant illustre les messages donnés par ftnchekL’
programme est destiné à accepter un tableau de résultats de tests, puis à calculer la moyenne pour le
série.

C AUTEURS : MIKE MYERS ET LUCIA SPAGNUOLO
C DATE : 8 MAI 1989

Variables C :
C SCORE -> un tableau de résultats de tests
C SUM -> somme des résultats des tests
C COUNT -> compteur de scores lus
CI -> compteur de boucle

COMPAV DE FONCTION RÉELLE (SCORE, COUNT)
ENTIER SOMME,COMPTE,J,SCORE(5)

FAIRE 30 I = 1, COMPTER
SOMME = SOMME + SCORE(I)
30 CONTINUER
COMPAV = SOMME/COMPTE
FIN

PROGRAMME AVENUM
C
C PROGRAMME PRINCIPAL
C
C AUTEUR : LOIS BIGBIE
C DATE : 15 MAI 1990
C
Variables C :
C MAXNOS -> nombre maximum de valeurs d'entrée
C NUMS -> un tableau de nombres
C COUNT -> nombre exact de valeurs d'entrée
C AVG -> moyenne renvoyée par COMPAV
CI -> compteur de boucle
C

PARAMÈTRE(MAXNOS=5)
ENTIER I, COMPTE
NOMBRE RÉEL (MAXNOS), AVG
COMPTE = 0
FAIRE 80 I = 1,MAXNOS
LIRE (5,*,FIN=100) NUMS(I)
COMPTE = COMPTE + 1
80 CONTINUER
100 MOYENNE = COMPAV(NOMBRE, COMPTE)
FIN

Le compilateur ne donne aucun message d'erreur lorsque ce programme est compilé. Voici pourtant ce que
se passe quand il est exécuté:

$ exécuté en moyenne
70
90
85

$

Que s'est-il passé? Pourquoi le programme n'a-t-il rien fait ? Ce qui suit est la sortie de
ftnchek lorsqu'il est utilisé pour déboguer le programme ci-dessus :

$ ftnchek -list -symtab moyenne

FTNCHEK Version 3.3 Novembre 2004

Fichier moyenne.f :

1 C AUTEURS : MIKE MYERS ET LUCIA SPAGNUOLO
2 C DATE : 8 MAI 1989
3
4 variables C :
5 C SCORE -> un tableau de résultats de tests
6 C SUM -> somme des notes des tests
7 C COUNT -> compteur de scores lus
8 CI -> compteur de boucle
9
10 COMPAV DE FONCTIONS RÉELLES (SCORE, COUNT)
11 ENTIER SOMME,COMPTE,J,SCORE(5)
12
13 DO 30 I = 1, COMPTE
14 SOMME = SOMME + SCORE(I)
15 30 CONTINUER
16 COMPAV = SOMME/COMPTE
^
Avertissement près de la ligne 16 col 20 : quotient entier expr SUM/COUNT converti en
réal
17 END

Module COMPAV : func : réel

Variables:

Nom Type Dims Nom Type Dims Nom Type Dims Nom Type Dims
COMPAV réel COUNT entier I entier* J entier
SCORE entier 1 SUM entier

* Variable non déclarée. Le type a été défini implicitement.

Avertissement dans le module COMPAV : Variables déclarées mais jamais référencées :
J déclaré à la ligne 11

Avertissement dans le module COMPAV : des variables peuvent être utilisées avant de définir :
SOMME utilisé à la ligne 14
SOMME fixé à la ligne 14

Étiquettes d'instruction définies :

Libellé Ligne StmtType
<30> 15 executeurs

18
19
20 PROGRAMME AVENUM
21 C
22 C PROGRAMME PRINCIPAL
23 C
24 C AUTEUR : LOIS BIGBIE
25 C DATE : 15 MAI 1990
26 C
27 variables C :
28 C MAXNOS -> nombre maximum de valeurs d'entrée
29 C NUMS -> un tableau de nombres
30 C COUNT -> nombre exact de valeurs d'entrée
31 C AVG -> moyenne retournée par COMPAV
32 CI -> compteur de boucle
33 C
34
35 PARAMÈTRE(MAXNOS=5)
36 ENTIER I, COMPTE
37 NOMBRE RÉELS (MAXNOS), AVG
38 COMPTE = 0
39 FAIRE 80 I = 1,MAXNOS
40 LIRE (5,*,FIN=100) NUMS(I)
41 COMPTE = COMPTE + 1
42 80 CONTINUER
43 100 MOYENNE = COMPAV(NOMBRE, COMPTE)
44 END

Module AVENUM : prog

Sous-programmes externes référencés :

COMPAV : réel*

Variables:

Nom Type Dims Nom Type Dims Nom Type Dims Nom Type Dims
AVG réel COUNT entier I entier MAXNOS entier*
NUMS réel 1

* Variable non déclarée. Le type a été défini implicitement.

Avertissement dans le module AVENUM : Variables définies mais jamais utilisées :
AVG fixé à la ligne 43

Opérations d'E/S :

ID d'unité N° d'unité Formulaire d'accès Ligne d'opération
5 SEQ FMTD LIRE 40

Étiquettes d'instruction définies :

Libellé Ligne StmtType Libellé Ligne StmtType
<80> 42 exec <100> 43 exec

0 erreurs de syntaxe détectées dans le fichier average.f
6 avertissements émis dans le fichier average.f

Avertissement : non-concordance du type de données de l'argument COMPAV du sous-programme à la position 1 :
Dummy arg SCORE dans le module COMPAV ligne 10 fichier average.f est de type intg
L'argument réel NUMS dans le module AVENUM, ligne 43, fichier average.f est de type réel

Selon ftnchek, le programme contient des variables qui peuvent être utilisées avant qu'elles ne soient
une valeur initiale et des variables qui ne sont pas nécessaires. ftnchek met également en garde le
utilisateur qu'un quotient entier a été converti en un réel. Cela peut aider l'utilisateur à
attraper une erreur d'arrondi involontaire. Depuis le -symtab drapeau a été donné, ftnchek impressions
une table contenant les identifiants du module local et leur type de données correspondant
et le nombre de dimensions. Enfin, ftnchek avertit que la fonction COMPAV n'est pas utilisée
avec le bon type d'arguments.

Avec ftnchekde l'aide, nous pouvons déboguer le programme. Nous pouvons voir qu'il y avait ce qui suit
erreur:

1. SUM et COUNT auraient dû être convertis en réels avant de faire la division.

2. SUM doit avoir été initialisé à 0 avant d'entrer dans la boucle.

3. AVG n'a jamais été imprimé après avoir été calculé.

4. NUMS aurait dû être déclaré INTEGER au lieu de REAL.

On voit aussi que I, et non J, aurait dû être déclaré INTEGER dans la fonction COMPAV. Aussi,
MAXNOS n'a pas été déclaré comme INTEGER, ni COMPAV comme REAL, dans le programme AVENUM. Ce ne sont pas
erreurs, mais elles peuvent indiquer une négligence. En l'occurrence, le type par défaut de ces
variables coïncidaient avec le type prévu.

Voici le programme corrigé et sa sortie lorsqu'il est exécuté :

C AUTEURS : MIKE MYERS ET LUCIA SPAGNUOLO
C DATE : 8 MAI 1989
C
Variables C :
C SCORE -> un tableau de résultats de tests
C SUM -> somme des résultats des tests
C COUNT -> compteur de scores lus
CI -> compteur de boucle
C
COMPAV DE FONCTION RÉELLE (SCORE, COUNT)
ENTIER SOMME,COMPTE,I,SCORE(5)
C
SOMME = 0
FAIRE 30 I = 1, COMPTER
SOMME = SOMME + SCORE(I)
30 CONTINUER
COMPAV = FLOAT(SOMME)/FLOAT(COUNT)
FIN
C
C
PROGRAMME AVENUM
C
C PROGRAMME PRINCIPAL
C
C AUTEUR : LOIS BIGBIE
C DATE : 15 MAI 1990
C
Variables C :
C MAXNOS -> nombre maximum de valeurs d'entrée
C NUMS -> un tableau de nombres
C COUNT -> nombre exact de valeurs d'entrée
C AVG -> moyenne renvoyée par COMPAV
CI -> compteur de boucle
C
C
ENTIER MAXNOS
PARAMÈTRE(MAXNOS=5)
ENTIER I, NUMS(MAXNOS), COUNT
VRAI MOYEN, COMPAV
COMPTE = 0
FAIRE 80 I = 1,MAXNOS
LIRE (5,*,FIN=100) NUMS(I)
COMPTE = COMPTE + 1
80 CONTINUER
100 MOYENNE = COMPAV(NOMBRE, COMPTE)
ECRIRE(6,*) 'MOYEN =',MOY
FIN
$ exécuté en moyenne
70
90
85

MOYENNE = 81.66666
$

Avec ftnchek, notre programme est un succès !

INTERPRÉTATION LES SORTIE

Les messages donnés par ftnchek inclure non seulement des erreurs de syntaxe mais aussi des avertissements et
des messages d'information sur des choses qui sont légales en Fortran mais qui peuvent indiquer des erreurs ou
négligence. La plupart de ces messages peuvent être désactivés par des options de ligne de commande. Qui
L'option contrôle chaque message en fonction de la nature de la condition signalée.
Voir les descriptions des indicateurs de ligne de commande dans les sections précédentes, et des
messages ci-dessous. Chaque message est précédé d'un mot ou d'une phrase indiquant la nature de
l'état et sa gravité.

``Error'' signifie une erreur de syntaxe. Les erreurs de syntaxe les plus simples sont typographiques
des erreurs, par exemple des parenthèses déséquilibrées ou une faute d'orthographe d'un mot-clé. Ce type de
l'erreur est détectée par l'analyseur et apparaît avec la description ``erreur d'analyse'' ou ``syntaxe
error'' (selon la version du générateur d'analyseur et s'il s'agit de GNU bison or
UNIX yacc). Ce type de message d'erreur ne peut pas être supprimé. Sachez que ce type de
erreur signifie souvent que ftnchek n'a pas correctement interprété l'énoncé où l'erreur
se produit, de sorte que ses opérations de vérification ultérieures seront compromises. Tu devrais
éliminer toutes les erreurs de syntaxe avant de procéder à l'interprétation des autres messages ftnchek
donne.

``Avertissement : syntaxe non standard'' indique une extension de Fortran qui ftnchek supports
mais ce n'est pas selon la norme Fortran 77. Les extensions qui ftnchek accepte
sont décrits dans la section sur les extensions ci-dessous. Un exemple est le DO ... ENDDO
construction. Si un programme utilise ces extensions, des avertissements seront donnés selon
spécifications en vertu de la -f77 réglage. Le comportement par défaut est de ne donner aucun avertissement.

« Avertissement » dans d'autres cas signifie une condition qui est suspecte mais qui peut ou non être
une erreur de programmation. Souvent, ces conditions sont légales en vertu de la norme. Certains sont
illégales mais ne relèvent pas de la catégorie des erreurs de syntaxe. Les erreurs d'utilisation en sont un exemple.
Celles-ci font référence à la possibilité qu'une variable puisse être utilisée avant qu'on lui ait attribué un
valeur (généralement une erreur), ou qu'une variable est déclarée mais jamais utilisée (inoffensive mais
peut indiquer une négligence). La quantité de vérification des erreurs d'utilisation est contrôlée par le
-usage flag, qui spécifie la quantité maximale de vérification par défaut.

Les avertissements de troncature couvrent les situations dans lesquelles la précision peut être perdue par inadvertance, par exemple
exemple lorsqu'une valeur en double précision est affectée à une variable réelle. Ces avertissements sont
contrôlé par le -troncature paramètre, qui est activé par défaut.

``Utilisation non portable'' met en garde contre certaines fonctionnalités qui peuvent ne pas être acceptées par certains compilateurs
même si cela n'est pas contraire à la norme Fortran 77, ou que le programme
pour fonctionner différemment sur différentes plates-formes. Par exemple, l'équivalence réelle et
variables entières est généralement une pratique non portable. L'utilisation d'extensions de
le langage standard est, bien sûr, une autre source de non-portabilité, mais cela est traité comme
un cas distinct. Pour vérifier la véritable portabilité d'un programme, le -portabilité et par
-f77 les drapeaux doivent être utilisés. Ils sont tous les deux désactivés par défaut. le -taille de mot le réglage est
fourni pour vérifier uniquement les usages non portables qui dépendent d'une machine particulière
taille de mot.

« apparence potentiellement trompeuse » est utilisée pour des constructions juridiques qui peuvent ne pas signifier ce que
ils semblent vouloir dire à première vue. Par exemple, Fortran est insensible aux espaces vides,
donc l'espace étranger dans les noms de variables ou le manque d'espace entre un mot-clé et un
variable peut donner une mauvaise impression au lecteur. Ces messages peuvent être supprimés
en désactivant le -joli flag, qui est activé par défaut.

D'autres messages qui sont donnés après le traitement de tous les fichiers, et ayant à voir avec
accord entre les modules, n'utilisez pas le mot « avertissement » mais tombez généralement dans ce
Catégorie. Les exemples incluent les incompatibilités de type entre les variables correspondantes dans différents
déclarations de bloc COMMON, ou entre les arguments factices et réels d'un sous-programme. Ces
les avertissements sont contrôlés par le -commun et -arguments paramètres respectivement. Par défaut
les deux sont définis pour une sévérité maximale de la vérification.

Un autre groupe d'avertissements concernant des affections souvent inoffensives fait référence à des cas où
les propriétés du tableau d'une variable passée en argument de sous-programme diffèrent entre les deux
routines. Par exemple, un élément de tableau peut être passé à un sous-programme qui attend un
tableau entier. Il s'agit d'une technique couramment utilisée pour traiter des lignes ou des colonnes
tableaux à deux dimensions. Cependant, cela peut également indiquer une erreur de programmation. le -déployer
Le réglage permet à l'utilisateur d'ajuster le degré de rigueur à utiliser pour vérifier ce
type d'accord entre les arguments de tableau réels et factices. Par défaut, la rigueur est
maximum.

``Oups'' indique un problème technique, ce qui signifie soit un bogue dans ftnchek ou que son
les ressources ont été dépassées.

Les messages d'erreur de syntaxe et les avertissements incluent le nom du fichier ainsi que le numéro de ligne et
numéro de colonne. ftnchek a deux options différentes pour l'apparition de ces erreurs
messages. Si -novice est en vigueur, ce qui est la valeur par défaut, les messages sont dans un style
se rapprochant de l'anglais normal. (Dans le style par défaut, le nom du fichier n'est pas imprimé dans les messages
dans le corps du programme si -liste est en vigueur.) L'autre style de messages d'erreur
est sélectionné par le -nonvice option. Dans ce style, l'apparence des messages est
similaire à celui d'UNIX peluche .

ftnchek est toujours aveugle à certains types d'erreurs de syntaxe. Les deux plus importants sont
vérification détaillée des instructions FORMAT, et presque tout ce qui concerne le contrôle de
flux d'exécution au moyen d'instructions IF, DO et GOTO : à savoir l'imbrication correcte du contrôle
structures, correspondance des instructions d'ouverture telles que IF ... THEN avec des instructions de fermeture
tels que ENDIF, et l'utilisation appropriée des étiquettes d'instruction (nombres). La plupart des compilateurs
attraper ces erreurs. Voir la section Limitations pour une discussion plus détaillée.

If ftnchek vous donne un message d'erreur de syntaxe lorsque le compilateur ne le fait pas, c'est peut-être parce que
votre programme contient une extension au standard Fortran qui est acceptée par le compilateur
mais pas par ftnchek. (Voir la section sur les extensions.) Sur un système VAX/VMS, vous pouvez utiliser
l'option du compilateur /STANDARD pour que le compilateur n'accepte que le Fortran standard. Au
la plupart des systèmes UNIX ou de type UNIX, cela peut être accompli en définissant l'indicateur -ansi.

De nombreux messages transmis par ftnchek sont explicites. Ceux qui en ont besoin
des explications supplémentaires sont répertoriées ci-dessous par ordre alphabétique.

Commun bloc NOM: données type décalage at position n
La n-ème variable dans le bloc COMMON diffère dans le type de données dans deux différents
déclarations du bloc COMMON. Par défaut (-commun niveau de rigueur 3), ftnchek
est très pointilleux sur les blocs COMMON : les variables qui y sont répertoriées doivent correspondre exactement
par type de données et dimensions du tableau. C'est-à-dire que la paire légale de déclarations dans
différents modules :
COMMUN /COM1/ A,B
et
COMMUN /COM1/ A(2)
provoquera ftnchek donner des avertissements au niveau de rigueur 3. Ces deux déclarations
sont légales en Fortran puisqu'elles déclarent toutes les deux deux variables réelles. À la rigueur
niveau 1 ou 2, aucun avertissement ne serait donné dans cet exemple, mais l'avertissement serait
donné s'il y avait une incompatibilité de type de données, par exemple, si B était déclaré INTEGER.
Controlé par -commun réglage.

Commun bloc Nom a Long données type Abonnement court données type
Certains compilateurs nécessitent l'alignement des éléments multi-octets afin que chaque élément commence à un
adresse qui est un multiple de la taille de l'article. Ainsi, si un court (par exemple single-
l'élément de précision réel) est suivi d'un élément long (par exemple, double précision réel), le
ce dernier peut ne pas être aligné correctement. Controlé par -portabilité=alignement commun
option.

Commun bloc Nom a mixte caractère et non-personnage les variables
La norme ANSI exige que si une variable dans un bloc COMMON est de type
CHARACTER, alors toutes les autres variables du même bloc COMMON doivent également être de type
PERSONNAGE. Controlé par -f77=mixte-commun option.

Commun bloc NOM: variant longueur
Pour -commun réglage niveau 2, ce message signifie qu'un bloc COMMON est déclaré à
avoir des nombres de mots différents dans deux sous-programmes différents. Un mot est le montant
de stockage occupé par un entier ou une variable réelle. Pour -commun réglage niveau 3,
cela signifie que les deux déclarations ont des nombres de variables différents, où un
un tableau de n'importe quelle taille est considéré comme une variable. Ce n'est pas forcément une erreur,
mais cela peut indiquer qu'une variable est manquante dans l'une des listes. Noter que
selon la norme Fortran 77, il s'agit d'une erreur pour les blocs COMMON nommés (mais
pas vide COMMUN) pour différer en nombre de mots dans les déclarations dans différents
modules. Donné pour -commun réglage 2 ou 3.

Erreur: Mal formé logique/relationnel opérateur or constant

Erreur: Mal formé réal constant
L'analyseur de syntaxe a trouvé le début de l'un des mots spéciaux qui commencent et
se termine par un point (par exemple .EQ.), ou le début d'une constante numérique, mais n'a pas
réussir à trouver un article complet de ce genre.

Erreur: ne peut pas be réglable et taille in module Nom
Une variable caractère ne peut pas être déclarée avec une taille qui est un astérisque dans
entre parenthèses sauf s'il s'agit d'un argument factice, d'un paramètre ou du nom de la fonction
défini dans le module.

Erreur: ne peut pas be a déclaré in SAUVEGARDER déclaration in module Nom
Seules les variables locales et les blocs communs peuvent être déclarés dans une instruction SAVE.

Erreur: Non chemin à this déclaration
ftnchek détectera les instructions qui sont ignorées ou contournées car il n'y a pas
voie prévisible vers la déclaration. Par exemple, un énoncé non numéroté (un
instruction sans étiquette d'instruction), apparaissant immédiatement après une instruction GOTO,
ne peut pas être exécuté.

Erreur: Parse erreur
Cela signifie que l'analyseur, qui analyse le programme Fortran en expressions,
déclarations, etc., a été incapable de trouver une interprétation valide pour une partie
d'une déclaration dans le programme. Si votre compilateur ne signale pas d'erreur de syntaxe à
au même endroit, les explications les plus courantes sont : (1) l'utilisation d'une extension à ANSI
Fortran standard qui n'est pas reconnu par ftnchek, ou (2) la déclaration exige
plus d'anticipation que ftnchek utilise (voir la section sur les bogues).

REMARQUE : ce message signifie que l'instruction affectée n'est pas interprétée.
Par conséquent, il est possible que ftnchekle traitement ultérieur de sera erroné, si
cela dépend de tout élément affecté par cette instruction (déclarations de type, etc.).

Erreur: Syntaxe erreur
C'est la même chose que ``Erreur : erreur d'analyse'' (voir ci-dessus). Il est généré si votre
version de ftnchek a été construit sous UNIX yacc générateur d'analyseur plutôt que GNU
bison.

Identifiants qui ne sauraient unique in premier six caractères
Avertit que deux identifiants de plus de 6 caractères ne diffèrent pas dans le
6 premiers caractères. C'est pour la portabilité : ils ne peuvent pas être considérés comme distincts
par certains compilateurs. Controlé par -six caractères option.

Non portable usage: argument avec précision Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. ne sauraient be correct en intrinsèque fonction
La précision d'un argument passé à une fonction intrinsèque peut être incorrecte sur
certains ordinateurs. Émis lorsqu'une variable numérique déclarée avec une précision explicite
(par exemple REAL*8 X) est passé à une fonction intrinsèque spécifique (par exemple DSQRT(X)).
Controlé par -portabilité=taille mixte et -taille de mot.

Non portable usage: caractère constante/variable longueur dépasse 255
Certains compilateurs ne prennent pas en charge les chaînes de caractères de plus de 255 caractères.
Controlé par -portability=chaîne longue.

Non portable usage: Déposez votre dernière attestation contient onglets
ftnchek développe les tabulations pour être équivalentes aux espaces jusqu'à la colonne suivante qui est un
multiple de 8. Certains compilateurs traitent les onglets différemment, et il est également possible que
les fichiers envoyés par courrier électronique verront les onglets convertis en blancs d'une manière ou d'une autre.
Par conséquent, les fichiers contenant des onglets peuvent ne pas être compilés correctement après avoir été
transféré. ftnchek ne donne pas ce message si les tabulations n'apparaissent que dans les commentaires
ou des constantes de caractères. Controlé par -portabilité=onglet.

Non portable usage: non-entier DO boucle bornes
Cet avertissement n'est donné que lorsque l'index DO et les limites ne sont pas des entiers. Utilisation de
des quantités non entières dans une instruction DO peuvent provoquer des erreurs inattendues ou différentes
résultats sur différentes machines, en raison des effets d'arrondi. Controlé par
-portabilité=réel.

Peut-être it is an tableau qui était ne sauraient a déclaré
Ce message est annexé aux avertissements liés à une invocation de fonction ou à une
non-concordance de type d'argument, pour laquelle il est possible que ce qui semble être un
la fonction est en fait censée être un tableau. Si le programmeur a oublié de dimensionner
un tableau, les références au tableau seront interprétées comme des appels de fonction.
Ce message sera supprimé si le nom en question apparaît dans un EXTERNE ou
Déclaration INTRINSÈQUE. Contrôlé par le -novice option.

Peut-être trompeur apparence: caractères passé 72 colonnes
Le programme est en cours de traitement avec la largeur du champ d'instruction à sa valeur standard
de 72, et certains caractères non vides ont été trouvés après la colonne 72. Dans ce cas,
ftnchek ne traite pas les caractères au-delà de la colonne 72 et informe l'utilisateur
que la déclaration n'a peut-être pas le sens qu'elle semble avoir. Ces
les caractères peuvent être voulus par le programmeur pour être significatifs, mais ils seront
ignoré par le compilateur. Controlé par -pretty=longue ligne.

Peut-être trompeur apparence: Commun bloc a déclaré in PLUS que UN déclaration
Ces déclarations multiples sont légales et ont le même effet qu'une continuation de
la déclaration originale du bloc. Cet avertissement n'est donné que si les deux
les déclarations sont séparées par une ou plusieurs déclarations intermédiaires. Controlé par
-pretty=multiple-commun.

Peut-être trompeur apparence: Continuation suit commentaire or vide en ligne
ftnchek émet ce message d'avertissement pour alerter l'utilisateur qu'une poursuite d'un
déclaration est entrecoupée de commentaires, ce qui la rend facile à ignorer. Controlé par
-jolie=suite.

Peut-être trompeur apparence: Étranger parenthèses
Avertit des parenthèses entourant une variable en elle-même dans une expression. Lorsqu'un
variable entre parenthèses est passée en argument à un sous-programme, elle est traitée comme
une expression, pas comme une variable dont la valeur peut être modifiée par la routine appelée.
Controlé par -jolie=parenthèses.

Sous-programme NOM: argument données type décalage at position n
Le sous-programme n-ième argument réel (dans le CALL ou l'utilisation d'une fonction)
diffère en type de données ou en précision de la n-ième argument fictif (dans le SOUS-ROUTINE ou
déclaration de FONCTION). Par exemple, si l'utilisateur définit un sous-programme en
SOUS-ROUTINE SUBA(X)
VRAI X
et ailleurs invoque SUBA par
NOUS CONTACTEZ SUBA(2)
ftnchek détectera l'erreur. La raison ici est que le nombre 2 est entier,
pas vrai. L'utilisateur doit avoir écrit
APPELEZ SUBA(2.0)

Lors de la vérification d'un argument qui est un sous-programme, ftnchek doit pouvoir déterminer
qu'il s'agisse d'une fonction ou d'un sous-programme. Les règles utilisées par ftnchek pour ce faire sont
comme suit : Si le sous-programme, en plus d'être passé comme argument réel, est également
invoqué directement ailleurs dans le même module, alors son type est déterminé par ce
usage. Si non, alors si le nom du sous-programme n'apparaît pas dans un
déclaration de type, il est supposé être un sous-programme ; s'il est explicitement tapé, c'est
pris comme une fonction. Par conséquent, les sous-routines passées en tant qu'arguments réels n'ont besoin que
être déclarée par une instruction EXTERNAL dans le module appelant, alors que les fonctions doivent
également être explicitement tapé afin d'éviter de générer ce message d'erreur.
Controlé par -arguments réglage.

Sous-programme NOM: argument l'arrangement décalage at position n
Similaire à la situation précédente, mais l'argument factice du sous-programme diffère de
l'argument réel correspondant dans son nombre de dimensions ou nombre de
éléments. Controlé par -déployer avec -arguments paramètres.

Sous-programme NOM: argument décalage at position n
Un argument fictif de caractère est plus grand que l'argument réel correspondant, ou un
L'argument fictif Hollerith est plus grand que l'argument réel correspondant.
Controlé par -arguments réglage.

Sous-programme NOM: argument usage décalage
ftnchek détecte un conflit possible entre la façon dont un sous-programme utilise un argument
et la manière dont l'argument est fourni au sous-programme. Le conflit peut
être de l'un des deux types, comme indiqué ci-dessous.

le leurre pour headstage arg is modifié, Réel arg is const or expr
Un argument factice est un argument tel que nommé dans une instruction SUBROUTINE ou FUNCTION et
utilisé dans le sous-programme. Un argument réel est un argument tel qu'il est passé à un
sous-routine ou fonction par l'appelant. ftnchek dit qu'un argument fictif est
modifié par le sous-programme, ce qui implique que sa valeur est modifiée dans l'appel
module. L'argument réel correspondant ne doit pas être une constante ou une expression,
mais plutôt une variable ou un élément de tableau auquel on peut légitimement attribuer.
Contrôlé par le -usage=arg-const-modifié option.

le leurre pour headstage arg d'utiliser before ensemble, Réel arg ne sauraient set
Ici, un argument factice peut être utilisé dans le sous-programme avant d'avoir une valeur affectée
par le sous-programme. L'argument réel correspondant doit avoir une valeur
attribué par l'appelant avant d'appeler le sous-programme. Contrôlé par le
-usage=var-non initialisé option.

Cet avertissement n'est pas affecté par le -arguments réglage.

Sous-programme Nom invoqué de façon incohérente
Ici, l'incompatibilité se situe entre le type de données du sous-programme lui-même tel qu'il est utilisé et tel que
défini. Par exemple, si l'utilisateur déclare
ENTIER FONCTION COMPTE(A)
et appelle COUNT dans un autre module comme
N = COMPTE(A)
sans déclarer son type de données, il sera par défaut de type réel, basé sur le premier
lettre de son nom. Le module appelant aurait dû inclure la déclaration
ENTIER COMPTE

Donné pour -arguments réglage 2 ou 3.

Sous-programme NOM: variant longueur argument listes:
Une incohérence a été trouvée entre le nombre d'arguments factices (paramètres)
un sous-programme a et le nombre d'arguments réels qui lui sont donnés dans une invocation.
ftnchek garde une trace de toutes les invocations de sous-programmes (instructions CALL et
expressions utilisant des fonctions) et les compare avec les définitions des
sous-programmes ailleurs dans le code source. Le compilateur Fortran ne
attraper ce type d'erreur. Donné pour -arguments réglage 1 ou 3.

Variable ne sauraient déclaré. Type a était implicitement défini
Lors de l'impression de la table des mnémoniques d'un module, ftnchek signalera avec un astérisque tout
identifiants qui ne sont pas explicitement typés et afficheront le type de données qui a été
attribué par typage implicite. Cela fournit une assistance aux utilisateurs qui souhaitent
déclarer toutes les variables comme requis en Pascal ou dans d'autres langages. Cette
message n'apparaît que lorsque le -symtab l'option est en vigueur. Alternativement, utilisez le
-déclarer flag si vous voulez obtenir une liste de toutes les variables non déclarées.

Variables a déclaré mais n'allons jamais référencé
Détecte les identifiants qui ont été déclarés dans votre programme mais n'ont jamais été utilisés,
soit pour se voir attribuer une valeur, soit pour accéder à leur valeur. Variables en COMMUN
sont exclus. Contrôlé par le -usage=var-inutilisé option.

Variables set mais n'allons jamais d'utiliser
ftnchek avertira l'utilisateur lorsqu'une variable a reçu une valeur, mais le
La variable n'est pas utilisée autrement dans le programme. Cela résulte généralement d'un
surveillance. Contrôlé par le -usage=var-set-inutilisé option.

Variables d'utiliser before set
Ce message indique qu'un identifiant est utilisé pour calculer une valeur avant sa
initialisation. Une telle utilisation peut entraîner le calcul d'une valeur incorrecte, car
sa valeur initiale n'est pas contrôlée. Contrôlé par le -usage=var-non initialisé
option.

Variables Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. be d'utiliser before set
Similaire à utilisé avant le réglage sauf que ftnchek n'est pas en mesure de déterminer son statut
avec certitude. ftnchek suppose qu'une variable peut être utilisée avant d'être définie si le premier
l'utilisation de la variable se produit avant son affectation dans le texte du programme.
Contrôlé par le -usage=var-non initialisé option.

Mise en garde: DO indice is ne sauraient entier
Cet avertissement n'est donné que lorsque les limites DO sont entières, mais pas l'index DO.
Cela peut indiquer un échec de la déclaration de l'index comme entier. Controlé par
-truncation=réel-faire option.

Mise en garde: entier quotient expr converti à réal
Le quotient de deux entiers donne un résultat de type entier, dans lequel le
la partie fractionnaire est supprimée. Si une telle expression entière impliquant une division est
converti plus tard en un type de données réel, il se peut qu'une division de type réel ait été
destiné. Controlé par -truncation=int-div-réel option.

Mise en garde: Entier quotient expr d'utiliser in exposant
Le quotient de deux entiers donne un résultat de type entier, dans lequel le
la partie fractionnaire est supprimée. Si une telle expression entière est utilisée comme exposant,
il est fort probable qu'une véritable division de type était prévue. Controlé par
-truncation=int-div-exposant option.

Mise en garde: Nom ne sauraient set quand RETOUR rencontré
La façon dont les fonctions en Fortran renvoient une valeur consiste à affecter la valeur au
nom de la fonction. Ce message indique que la fonction n'a pas reçu de
valeur avant le point où une instruction RETURN a été trouvée. Il est donc
possible que la fonction renvoie une valeur indéfinie.

Mise en garde: Non standard syntaxe: réglable et taille ne peut pas be concaténé ici
La norme Fortran 77 (sec. 6.2.2) interdit la concaténation de variables de caractères
dont la taille est un astérisque entre parenthèses, sauf dans une instruction d'affectation.
Controlé par -f77=expression-mixte.

Mise en garde: Non standard syntaxe : significative caractères passé 72 colonnes
Cet avertissement est donné sous le -f77=longue ligne réglage si le -Colonnes le réglage a
été utilisé pour augmenter la largeur du champ de l'instruction, et une instruction a un sens
le texte du programme au-delà de la colonne 72. Le Fortran standard ignore tout le texte de ces colonnes,
mais certains compilateurs ne le font pas. Ainsi, le programme peut être traité différemment par
différents compilateurs.

Mise en garde: Non standard syntaxe : Déclaration ande of ordre.
ftnchek détectera les instructions qui ne sont pas dans la séquence spécifiée pour ANSI
standard Fortran 77. Le tableau 1 illustre la séquence d'instructions autorisée dans le
langue fortran. Les déclarations irrecevables sont néanmoins interprétées par
ftnchek, pour éviter les ``cascades'' de messages d'erreur. Le compteur de séquence est également
annulé pour empêcher la répétition du message d'erreur pour un bloc de
déclarations. Contrôlé par le -f77=ordre-instruction option.

Peut être teinte, et coiffer comme vous le désirez.
| | implicite
| paramètre |---------------------
| | autre spécification
format |----------------|---------------------
et | | fonction-instruction
entrée | données |---------------------
| | exécutable
Peut être teinte, et coiffer comme vous le désirez.

Tableau 1

Mise en garde: Possible division by zéro
Ce message est imprimé partout où la division est effectuée (sauf division par un
constant). Utilisez-le pour vous aider à localiser une division d'exécution par zéro problème. Contrôlé
by -division option.

Mise en garde: réal tronqué à entier
ftnchek a détecté une instruction d'affectation qui a une expression réelle sur le
à droite, mais une variable entière à gauche. La partie fractionnaire de la valeur réelle
sera perdu. Si vous convertissez explicitement l'expression réelle en nombre entier à l'aide de la
Fonction intrinsèque INT ou NINT, aucun avertissement ne sera imprimé. Un message similaire est
imprimé si une expression en double précision est affectée à une simple précision
variable, etc. Contrôlé par -troncation=rétrogradation option.

Mise en garde: indice is ne sauraient entier
Étant donné que les indices de tableau sont normalement des quantités entières, l'utilisation d'un nombre non entier
expression ici peut signaler une erreur. Controlé par -truncation=réel-indice
option.

Mise en garde: Inconnu intrinsèque fonction
Ce message avertit l'utilisateur qu'un nom déclaré dans une instruction INTRINSIC est
inconnu de ftnchek. C'est probablement une fonction intrinsèque non standard, et donc le
le programme ne sera pas portable. La fonction sera traitée par ftnchek en tant qu'utilisateur-
fonction définie. Cet avertissement n'est supprimé par aucune option, car il affecte
ftnchekl'analyse du programme. Cependant, si la fonction intrinsèque est dans l'un des
les ensembles pris en charge d'intrinsèques non standard, vous pouvez utiliser le -intrinsèque la mise à
causer ftnchek de le reconnaître.

LIMITATIONS ET EXTENSIONS

ftnchek accepte les programmes Fortran-77 standard ANSI avec quelques limitations mineures et de nombreux
prolongements communs.

Limites:
Les arguments factices dans les fonctions d'instruction sont traités comme des variables ordinaires de
le programme. C'est-à-dire que leur portée est l'ensemble du sous-programme, pas seulement l'instruction
définition de la fonction.

La vérification des instructions FORMAT est laxiste, tolérant les séparateurs manquants (virgule,
etc.) entre les descripteurs de format aux endroits où la norme les exige, et
permettant .d des champs sur des descripteurs qui ne devraient pas en avoir. Il avertit sous
-f77=format-éditer-descr sur les types de descripteurs non standard (comme O) et pris en charge
Extensions.

Il existe des extensions syntaxiques et des éléments Fortran 90 qui ftnchek accepte
mais fait très peu de vérifications. Par exemple, l'utilisation du pointeur (que le
syntaxe Cray non standard ou la syntaxe Fortran 90) n'est vérifiée que pour set
et le statut utilisé. On espère qu'un jour un contrôle plus approfondi sera
implémenté, mais pour l'instant l'utilisateur doit considérer l'acceptation de ces
fonctionnalités simplement comme une commodité pour permettre la vérification d'autres aspects du code qui
les contient. Voir la section Extensions pour plus de détails sur les fonctionnalités
accepté mais pas entièrement vérifié.

Si un sous-programme fourni par l'utilisateur a le même nom qu'un des programmes intrinsèques non standard
fonctions reconnues par ftnchek, il doit être déclaré dans une instruction EXTERNAL dans
toute routine qui l'invoque. Sinon il sera soumis à la vérification normalement
donnée à la fonction intrinsèque. Étant donné que les intrinsèques non standard ne sont pas
standard, cette instruction EXTERNE n'est pas requise par la norme Fortran 77.
Le -intrinsèque=aucun réglage, reconnaissance de la plupart des valeurs intrinsèques non standard
(à l'exception de ceux nécessaires à la prise en charge du type de données double complexe) peuvent être activés
désactivé. Consultez les listes des fonctions intrinsèques non standard prises en charge sous le
discussion de la -intrinsèque réglage ci-dessus.

Extensions:
Toutes ces extensions (à l'exception des caractères minuscules) généreront des avertissements si
le pertinent -f77 l'option est définie. Certaines des extensions répertoriées ci-dessous font partie de
la norme Fortran-90. Ceux-ci sont indiqués par la notation (F90).

Les tabulations sont autorisées et traduites en blancs équivalents qui correspondent à la tabulation
s'arrête toutes les 8 colonnes. La norme ne reconnaît pas les onglets. Notez que certains
les compilateurs autorisent les onglets, mais les traitent différemment. Le traitement défini pour le DEC
FORTRAN peut être obtenu en utilisant le -source=déc-onglet réglage.

Les chaînes peuvent être délimitées par des guillemets ou des apostrophes. Une séquence de deux
les caractères délimiteurs sont interprétés comme un seul caractère délimiteur incorporé.
(F90)

Les chaînes peuvent contenir des séquences d'échappement de barre oblique inverse de style UNIX. Ils seront
interprété comme tel si le -source=unix-barre oblique inverse le réglage est donné. Sinon le
La barre oblique inverse sera traitée comme un caractère d'impression normal.

Le code source peut être au format libre Fortran 90 ou au format fixe traditionnel.
(F90)

Un point-virgule est autorisé comme séparateur d'instructions. (F90)

Les caractères minuscules sont autorisés et sont convertis en interne en majuscules
sauf dans les chaînes de caractères. La norme spécifie uniquement les majuscules, sauf dans
commentaires et chaînes. (F90)

Les constantes de Hollerith sont autorisées, conformément à la norme Fortran 77,
annexe C. Ils ne doivent pas être utilisés dans des expressions, ou confondus avec le type de données
PERSONNAGE.

La lettre « D » (majuscule ou minuscule) dans la colonne 1 est considérée comme le début d'un
commenter. Il n'y a pas d'option pour traiter ces lignes comme des déclarations au lieu de commentaires.

Les déclarations peuvent dépasser 72 colonnes à condition que le paramètre -Colonnes était
utilisé pour augmenter la limite. Selon la norme, tout le texte des colonnes 73
jusqu'à 80 est ignoré et aucune ligne ne peut dépasser 80 colonnes.

Les noms de variables peuvent comporter plus de six caractères. La norme spécifie six comme
le maximum. ftnchek autorise les noms jusqu'à 31 caractères (F90).

Les noms de variables peuvent contenir des traits de soulignement et des signes dollar (ou d'autres
caractères spécifiés par le -identifiant-chars option). Ces personnages sont
traités de la même manière que les lettres alphabétiques. Le type par défaut pour les variables commençant
avec ces caractères est RÉEL. Dans les instructions de type IMPLICIT spécifiant une plage de
caractères, le signe dollar suit Z et est suivi d'un trait de soulignement. (Tout autre
les caractères définis par l'utilisateur sont traités de la même manière que le signe dollar.) Fortran 90
autorise les traits de soulignement dans les noms de variables.

La version UNIX tolère la présence de directives de préprocesseur, à savoir des lignes
commençant par le signe dièse (#). Ceux-ci sont traités comme des commentaires, à l'exception de la #ligne
directives, qui sont interprétées et utilisées pour définir le numéro de ligne et la source
nom de fichier pour les avertissements et les messages d'erreur. Notez que les directives #include ne sont pas
traité par ftnchek. Les programmes qui les utilisent pour inclure des fichiers source doivent être
passé par le préprocesseur avant d'être entré dans ftnchek. Comme indiqué ci-dessous,
ftnchek traite les instructions INCLUDE, qui ont une syntaxe différente. Une
programme optionnel, ftnpp(1L) (disponible séparément) fournit un prétraitement qui
gère correctement les fichiers INCLUDE.

La structure de contrôle Fortran 90 DO ... ENDDO est autorisée. Le CYCLE et SORTIE
les déclarations sont acceptées. Tous ces éléments peuvent avoir un nom de construction facultatif, mais
les noms de construction ne sont pas vérifiés pour la cohérence. (F90)

La construction Fortran 90 SELECT CASE est acceptée. (F90)

Les noms de construction sont également acceptés sur IF, THEN, ELSE, ENDIF et SELECT CASE
déclarations. (F90)

Les instructions ACCEPT et TYPE (pour les E/S du terminal) sont autorisées, avec le même
syntaxe comme PRINT.

La syntaxe dite du ``pointeur Cray'' est tolérée. Ce n'est pas la même chose que le
Instruction Fortran 90 POINTER. Il n'y a pas de véritable vérification de la déclaration autre
que la syntaxe de base. La forme de cette déclaration est
POINTEUR (aiguille, pointe) [,(aiguille, pointe)]
Les variables de pointeur reçoivent un type de données INTEGER *4. Vérification de l'utilisation de
les variables pointées sont supprimées, car en pratique elles sont accédées indirectement
via les pointeurs.

Les syntaxes suivantes liées au pointeur Fortran 90 sont acceptées : ALLOCATABLE,
les instructions POINTER et TARGET et les mêmes attributs dans les déclarations de type ;
les instructions exécutables ALLOCATE, DEALLOCATE et NULLIFY ; affectation de pointeur à l'aide
=> opérateur ; et les fonctions intrinsèques ALLOUÉ et ASSOCIÉ. Peu de sémantique
la vérification des variables et des opérations de pointeur est effectuée au-delà de l'ensemble de base et utilisée
statut. Par exemple, il n'y a pas de vérification d'erreurs telles que les pointeurs pendants,
ou l'utilisation de tableaux non alloués.

Les instructions peuvent avoir n'importe quel nombre de lignes de continuation. Le Fortran 77 et le Fortran
90 normes autorisent un maximum de 19 sous forme de source fixe. La norme Fortran 90
autorise un maximum de 39 sous forme de source libre.

Opérateurs relationnels (de comparaison) composés de ponctuation, à savoir : < <= == /= > >=
sont autorisés. (F90)

Les commentaires en ligne, commençant par un point d'exclamation, sont autorisés. (F90)

L'E/S NAMELIST est prise en charge. La syntaxe est la même que dans Fortran 90.

Les instructions FORMAT peuvent contenir un signe dollar pour indiquer la suppression du transport.
retourner. Une expression entière entre crochets peut être utilisée n'importe où dans un
Instruction FORMAT où la norme Fortran 77 autorise une constante entière (sauf
pour la longueur d'une constante de Hollerith), pour fournir une valeur d'exécution pour une répétition
spécification ou largeur de champ.

Les mots-clés non standard sont autorisés dans les instructions d'E/S, correspondant à ceux de VMS
Fortran.

L'instruction IMPLICIT NONE est prise en charge. Le sens de cette déclaration est que
toutes les variables doivent avoir leurs types de données explicitement déclarés. Plutôt que de signaler le
occurrences de telles variables avec des messages d'erreur de syntaxe, ftnchek attend que le
fin du module, puis imprime une liste de toutes les variables non déclarées, car il
fait pour le -déclarer option. (F90)

Les types de données INTEGER, REAL, COMPLEX et LOGICAL peuvent avoir une valeur facultative
spécification de précision dans les déclarations de type. Par exemple, REAL*8 signifie un 8 octets
type de données à virgule flottante. Le type de données REAL*8 n'est pas nécessairement pris en compte
équivalent à DOUBLE PRECISION, selon le -taille de mot réglage. Le Fortran 77
La norme permet une spécification de longueur uniquement pour les données CHARACTER.

ftnchek prend en charge la spécification de type DOUBLE COMPLEX pour une grandeur complexe dont
les parties réelles et imaginaires sont en double précision. Arithmétique en mode mixte impliquant
complexe simple précision avec données réelles double précision, interdit en vertu de la
Standard, donne un résultat doublement complexe.

Les déclarations de type combinées et les initialiseurs de type data-statement sont acceptés.
Ceux-ci ont la forme d'une déclaration de type Fortran 77 standard, suivie d'une barre oblique-
liste délimitée de constantes comme celle utilisée dans une instruction DATA. Un exemple de
la syntaxe est
ENTIER N / 100 /
Cette forme bâtarde de déclaration d'initialisation n'a pas été adoptée en Fortran 90.
les déclarations doivent être rédigées en utilisant le formulaire standard décrit ci-dessous, qui est
accepté par ftnchek.

La prise en charge des déclarations de type Fortran 90 basées sur les attributs est limitée. Cette
style de déclaration se distingue par l'utilisation d'un double deux-points (::) entre le
liste des attributs et la liste des variables déclarées. Les fonctionnalités prises en charge peuvent
être adéquates pour les programmeurs novices, mais ne sont pas encore suffisantes pour les professionnels-
programmes Fortran 90 de qualité. J'espère ajouter un support pour plus de fonctionnalités à l'avenir
libère. J'invite des bénévoles à m'aider dans cette tâche. Voir le fichier ToDo dans le
distribution du code source pour plus de détails. Les attributs actuellement acceptés, outre
tous les types de données habituels sont DIMENSION, EXTERNAL, INTRINSIC, PARAMETER et SAVE.
La nouvelle forme de déclaration permet également d'affecter des valeurs aux variables
déclaré. À l'heure actuelle, le (LEN=valeur) forme de spécification des longueurs de caractères est également
accepté. Spécifications de type, en utilisant (KIND=valeur) sont analysés mais ne sont pas
traité : tous les types sont traités comme le type par défaut. De plus, il y a peu de contrôle
de ces déclarations au-delà de la syntaxe de base.

De nombreuses fonctions intrinsèques non standard courantes sont fournies. Voir le
discussion de -intrinsèque pour une liste de fonctions et comment contrôler lesquelles sont
reconnu.

La vérification des arguments n'est pas stricte pour les intrinsèques non standard qui prennent des tableaux ou
types d'arguments mixtes.

ftnchek autorise l'instruction INCLUDE, qui entraîne l'inclusion du texte de la
fichier donné. La syntaxe est
INCLURE 'nom de fichier'
Ceci est compatible avec Fortran 90. Si le -source = vms-include l'option est donnée,
ftnchek suit les conventions VMS en ce qui concerne cette déclaration : elle suppose un
extension par défaut de .pour si aucune extension de nom de fichier n'est donnée, et permet au
qualificateur /[NO]LIST après le nom du fichier, pour contrôler la liste des
déposer. L'inclusion de modules de texte VMS n'est pas prise en charge.

Dans la sortie de diagnostic relative aux éléments contenus dans les fichiers d'inclusion, l'emplacement de
l'erreur est spécifiée à la fois par son emplacement dans le fichier d'inclusion et par l'emplacement dans
le fichier parent où le fichier a été inclus.

ftnchek accepte les instructions PARAMETER sans parenthèses. Ceux-ci seront prévenus
à propos de si le -f77=param-noparen le drapeau est donné.

ftnchek accepte les définitions PARAMETER qui impliquent des fonctions intrinsèques et
exponentiation par un exposant non entier. Ces deux cas sont interdits par
la norme Fortran 77, et sera averti si le -f77=param-intrinsèque drapeau
est donné. Si une valeur de fonction intrinsèque est une constante entière à la compilation,
ftnchek l'évaluera. Cela permet de mieux vérifier si le paramètre est utilisé dans
déclarer la taille des tableaux. Fortran 90 permet des fonctions intrinsèques dans PARAMETER
définitions

Les fonctions intrinsèques évaluées sont :

ABS IABS DIM IDIM MAX
SIGNE MOD MAX0 MIN MIN0
INDICE ISIGN LEN ICHAR

Les fonctions d'arguments entiers ne sont évaluées que si les arguments sont entiers
expressions constantes. (Ceux-ci peuvent impliquer des constantes entières, des paramètres et
fonctions intrinsèques évaluées.) La fonction LEN est évaluée si son argument est
une expression impliquant uniquement des constantes de caractères et des variables dont la longueur n'est pas
Ajustable. Les fonctions ICHAR et INDEX ne sont évaluées que si les arguments sont
constantes de caractères. ftnchek donne un avertissement s'il a besoin de la valeur de certains
fonction intrinsèque qui n'est pas évaluée.

NOUVEAU CARACTERISTIQUES

Voici les changements de la version 3.2 à la version 3.3 :

1. Le front-end a été réécrit pour une prévision illimitée, éliminant ainsi le bogue de longue date
qui a causé une interprétation incorrecte des déclarations dont l'ambiguïté n'a pas été résolue dans
la première ligne.

2. le -mkhtml L'option est maintenant disponible dans la version MS-DOS.

3. Ajout de la prise en charge de la syntaxe liée au pointeur Fortran 90 : ALLOCATE, DEALLOCATE et NULLIFY
déclarations; les attributs ALLOCATABLE, POINTER et TARGET dans les déclarations de type ; la
opérateur d'affectation de pointeur => et fonctions intrinsèques ALLOCED et ASSOCIATED ; et
déclarations de tableau de forme différée. À l'heure actuelle, ces nouvelles fonctionnalités de syntaxe sont acceptées
mais pas correctement vérifié. Cette fonctionnalité a été ajoutée par Robert Landrito.

4. le -f77 et -f90 aiguille l'option contrôlant les avertissements concernant les ``pointeurs Cray'' a été
renommé en Cray-pointerL’ -f77=pointeur L'option contrôle désormais les avertissements pour
code contenant la syntaxe liée au pointeur Fortran 90.

5. Réimplémenté -mkhtml traitement, il est donc maintenant beaucoup plus rapide sur les fichiers source contenant
beaucoup de routines.

6. Modification de la disposition du répertoire de test afin qu'il n'y ait plus besoin de modifier
la distribution afin d'exécuter la suite de tests (check.bat) sous MS-DOS.

7. Correction d'un bug dans la lecture des paramètres numériques sur la ligne de commande lors de la définition du nom abrégé en
3 caractères.

8. Correction d'un bug provoquant un avertissement parasite pour un GOTO se référant à une instruction END étiquetée
quand l'instruction avant END était un FORMAT.

9. Nouveau drapeau -f77=caractère pour contrôler les avertissements concernant les extensions au Fortran 77
type de données de caractère. Ce nouveau drapeau est accompagné de la prise en charge des règles Fortran 90 pour
déclarations de variables de caractères qui évaluent à zéro ou à une longueur négative, permettant
eux et en traitant les valeurs de longueur négatives comme zéro.

10. Correction d'un bug mineur dans l'impression des commentaires et des lignes vides après la dernière instruction END
in -liste mode.

Utilisez ftnchek en ligne en utilisant les services onworks.net