La ligne de commande
La ligne de commande de PC-Lint se présente sous la forme suivante :
| lint options file1 [file2 file3 ...] |
Les options (décrites ci-dessous) précèdent généralement les fichiers, comme illustré ici. Elles peuvent également être intercalées entre les fichiers pour produire des effets spéciaux, les options et les fichiers étant traités simultanément de gauche à droite. PC-Lint renverra un code de sortie.
(Remarque : si la variable d'environnement LINT est définie, sa valeur est ajoutée au début des arguments, séparée par un espace.)
Fichiers
Les fichiers peuvent être spécifiés par leur chemin d'accès complet.
Si l'extension est .lnt, le fichier est considéré comme un fichier indirect. Dans ce cas, il peut contenir une ou plusieurs lignes d'information étant normalement placées sur la ligne de commande. Les fichiers indirects ne peuvent pas eux-mêmes contenir d'autres fichiers indirects. Les fichiers indirects et les fichiers .c peuvent être intercalés librement.
Si l'extension est omise, le système tente d'abord d'utiliser l'extension .lnt. Si le fichier est introuvable, il tente d'utiliser l'extension .c.
Exemples
Supposons qu'il faille vérifier le programme p.c et que le compilateur prévu soit Lattice C. Alors :
| lint sl-lc p |
vérifierais le programme.
Si la variable d'environnement LINT est définie comme dans la commande DOS :
| set LINT = sl-lc |
alors la commande :
| lint p |
aura le même effet que ci-dessus.
Prenons un autre exemple : supposons qu'un programme soit composé de 5 modules, m1, m2, m3, m4 et m5. Supposons également le compilateur Aztec C. La commande appropriée est :
| lint al-aztec m1 m2 m3 m4 m5 |
Si vous n'aimez pas saisir tout cela à chaque fois, vous pouvez placer tout ou partie de ces informations dans un fichier indirect. Supposons que project.lnt contienne :
| sl-aztec m1 m2 m3 m4 m5 |
Alors :
| lint project |
Cette commande sera équivalente à la précédente.
Notez que les options et/ou les fichiers supplémentaires peuvent être placés avant ou après le fichier d'inclusion.
Options
Les options commencent par un signe plus (+) ou moins (-). Elles peuvent être insérées parmi les noms de fichiers sur la ligne de commande (et dans le fichier indirect). Elles sont traitées séquentiellement : une option spécifiée après un nom de fichier ne sera prise en compte qu'après le traitement de ce fichier. Les options peuvent apparaître dans un fichier source C, intégrées dans des commentaires de la forme suivante :
- /*lint option1 option2 ... optional commentary */
Les options dans les commentaires doivent être séparées par un espace. Le commentaire optionnel en fin de commentaire ne doit évidemment pas commencer par un plus ou un moins. Notez que le texte «lint» dans le commentaire doit être en minuscules, comme indiqué, et doit être placé juste après «/*». Le commentaire peut s'étendre sur plusieurs lignes.
Options de masquage des erreurs
Les options commençant par -e permettent de masquer les messages d'erreur. La même option, suivie de +e, rétablit leur affichage. Tous les messages sont activés par défaut.
| Option | Description |
|---|---|
| -e# | (où # est un nombre ou un motif numérique) inhibe, et |
| +e# | réactive, le ou les messages d'erreur #. Par exemple, -e504 désactivera le message d'erreur 504. Le numéro peut contenir le caractère générique ?. Par exemple, -e7?? désactivera tous les messages d'erreur de niveau 700 (messages d'information). |
| -eau | inhibe |
| +eau | Réactive l'affichage des messages d'erreur lorsque les arguments sont de types différents, l'un étant un entier signé et l'autre un entier non signé du même type. Par exemple, si la fonction `f` attend un entier non signé et que `n` est un entier (`int`), l'appel `f(n)` affichera normalement le message d'erreur #516. Ce message sera masqué si l'option `-eau` est activée. |
| -eas | inhibe |
| +eas | Réactive l'affichage des messages d'erreur générés lorsque les arguments sont de types différents et occupent la même taille. Par exemple, si la fonction `f` attend un pointeur comme argument, l'appel `f(3)` affichera normalement le message # 516. Si les pointeurs et les entiers occupent le même espace mémoire (ce qui est le cas par défaut), le message sera masqué si l'option `-eas` est activée. Notez que l'option `-sas` est plus restrictive que l'option `-eau` : si `-eas` est activée, il n'est pas nécessaire d'activer également `-eau`. |
| -epp | inhibe |
| +epp | Réactive l'affichage des messages d'erreur générés par deux pointeurs de types indirects différents. Par exemple, si `p` pointe vers un `int` et `q` vers un `char`, l'opération `p = q` déclenchera normalement un message d'erreur. Ce message peut être masqué par l'option `-epp`. Notez toutefois que si les pointeurs ont des tailles différentes (par exemple avec `-mD` ou `-mP`), l'incompatibilité sera signalée. |
Exemples d'options d'inhibition d'erreurs :
| lint -e7?? p.c |
inhibera tous les messages d'information (messages de la catégorie 700).
| lint -e??? +e526 p.c |
Tous les messages seront désactivés, sauf le numéro 526.
| lint -epp -eau p.c |
empêchera les erreurs résultant de conflits entre pointeurs et d'arguments non signés.
Options de taille
Ce groupe d'options permet de définir la taille des différents scalaires (short, int,...) pour la machine cible. Il n'est généralement pas nécessaire de définir ces paramètres séparément, car les valeurs par défaut sont compatibles avec la plupart des compilateurs de votre environnement. De plus, les options `-mL` ou `-b ` permettent d'obtenir le modèle de pointeurs étendus (pointeurs sur 4 octets). Les options `-mD` ou `-mP` permettent quant à elles de spécifier respectivement le modèle de données étendu et le modèle de programme étendu (voir la description de ces options). Par exemple, si vous effectuez un portage vers une machine M68000 où les int et les pointeurs sont généralement codés sur 32 bits, vous devez spécifier :
| lint -s14 -sp4 ... |
Options de taille
Ce groupe d'options permet de définir la taille des différents scalaires (short, int,...) pour la machine cible. Il n'est généralement pas nécessaire de définir ces paramètres séparément, car les valeurs par défaut sont compatibles avec la plupart des compilateurs de votre environnement. De plus, les options `-ml` ou `-b` permettent d'obtenir le modèle de pointeurs étendus (pointeurs sur 4 octets). Les options `-mD` ou `-mP` permettent quant à elles de spécifier respectivement le modèle de données étendu et le modèle de programme étendu (voir la description de ces options). Par exemple, si vous effectuez un portage vers une machine M68000 où les int et les pointeurs sont généralement codés sur 32 bits, vous devez spécifier :
| lint -s14 -sp4 ... |
Utilisez les options de taille pour spécifier les architectures autres que 8086.
Dans la liste ci-dessous, # représente un petit entier.
| Option | Description |
|---|---|
| -sc# | sizeof(char) devient #. -sc1 est la valeur par défaut. (Cette option est présente par souci d'exhaustivité. Voulez-vous vraiment définir la taille d'un char à une valeur différente de 1 ?) |
| -ss# | sizeof(short) devient #. Par exemple, --s2 est la valeur par défaut. |
| -si# | sizeof(int) devient #. Par exemple, -si2 est la valeur par défaut. |
| -sl# | sizeof(long) devient #. Par exemple, -sl4 est la valeur par défaut. |
| -sf# | sizeof(float) devient #. Par exemple, -sf4 est la valeur par défaut. |
| -sd# | sizeof(double) devient #. Par exemple, -sd8 est la valeur par défaut. |
| -sp# | sizeof(char *) devient #. Par exemple, -sp2 est la valeur par défaut. |
| -sb# | Le nombre de bits dans un octet est #. Par exemple, -sb8 est la valeur par défaut. Le nombre de bits dans un entier est supposé être égal à sizeof(int) multiplié par cette valeur. L'entier maximal est déterminé à partir de cette valeur en supposant une machine à complément à deux. Cet entier maximal sert ensuite à déterminer si une constante est de type int ou long. |
| -spD# | Indique que la longueur d'un pointeur de données est de # octets. Par exemple, -spD4 spécifie que les pointeurs de données ont une longueur de 4 octets. Ceci n'a aucun effet sur la longueur supposée des pointeurs de programme (fonction). La valeur par défaut est 2. Notez que -sp# est équivalent à -apD# et -spP#. (Pour les environnements 8086, l'une des options -a est probablement plus pratique à utiliser). |
| -spP# | Indique que la longueur d'un pointeur de programme (fonction) est de # octets. Par exemple, -spP4 spécifie que les pointeurs de programme ont une longueur de 4 octets. Ceci n'a aucun effet sur la longueur supposée des pointeurs de données. La valeur par défaut est 2. Notez que -sp# est équivalent à -spD# et -spP#. (Pour les environnements 8086, l'une des options -m est probablement plus pratique à utiliser). |
Options de verbosité
La verbosité désigne la fréquence des messages d'avancement. Elle peut être contrôlée par des options commençant par -v.
| Option | Description | |
|---|---|---|
| -v | Désactivez tous ces messages | |
| -vm | Afficher les noms des modules au fur et à mesure qu'ils sont rencontrés (comportement par défaut). | |
| -vf | Affiche le nom de tous les fichiers rencontrés, y compris les fichiers d'entête et les noms de modules. L'option `-vf` implique donc l'option `-vm`. | |
| -v# | (où # est un entier) affichera un message toutes les # lignes. Cette option implique -vf. | |
| +v... | Cela signifie que les messages en cours de traitement sont dirigés non seulement vers la sortie standard, mais aussi vers la sortie d'erreur standard. Ceci est utilisé lors de la redirection de la sortie de PC-Lint vers un fichier. Par exemple :
cela entraînera l'affichage d'informations détaillées sur la console et leur redirection vers le fichier temporaire. |
Options de drapeaux
Les options commençant par +f ou -f permettent d'ajouter des drapeaux.
| Option | Description |
|---|---|
| +fcu | Fixe |
| -fcu | Réinitialise l'indicateur `char-is-unsigned`. Si cet indicateur est activé, toutes les déclarations de type `char` sont considérées comme équivalentes à `unsigned char`. Ceci est utile pour les compilateurs qui, par défaut, traitent les `char` comme non signés. Notez que ce traitement est explicitement autorisé par K&R. Autrement dit, le fait qu'un `char` soit signé ou non dépend de l'implémentation. Cet indicateur est désactivé par défaut. |
| +fdl | Fixe |
| -fdl | Réinitialise l'indicateur `pointer-difference-is-long`. Cet indicateur spécifie que la différence entre deux pointeurs est de type `long`. Sinon, elle est de type `int`. Cet indicateur est désactivé par défaut. Très peu de variantes du langage C nécessitent cet indicateur. |
| +fdr | Fixe |
| -fdr | Réinitialisez l'indicateur de déduction du mode de retour. (Cet indicateur est activé par défaut.) Le mode de retour d'une fonction détermine si elle renvoie ou non
une valeur. Si une fonction est définie ou déclarée avec cet indicateur activé, la déclaration implique un mode de retour comme suit : si un type explicite est fourni, on
suppose que la fonction renvoie une valeur ; si aucun type n'est fourni ou si le type de la fonction est `void`, on suppose que la fonction ne renvoie aucune valeur (voir
l'indicateur `+fvo`). Si cet indicateur n'est pas activé, aucune déduction n'est effectuée à partir de la déclaration. Généralement, cet indicateur est activé ou désactivé globalement pour l'ensemble du programme. Si vous n'utilisez pas `void` et si vous ne suivez pas la convention selon laquelle l'absence de type signifie `void`, vous devrez désactiver cet indicateur. Très souvent, les programmeurs définissent leurs fonctions comme `VOID`, ce qui est défini comme suit :
Bien entendu, VOID peut facilement être redéfini en void si votre nouveau compilateur prend en charge cette constante. Voir aussi les options fvr et fvo. |
| +fie | Fixe |
| -fie | Réinitialise l'indicateur de modèle entier pour les énumérations. Si cet indicateur est activé, un modèle souple est utilisé pour les énumérations. Concrètement, les énumérations sont considérées sémantiquement comme des entiers. Par défaut, un modèle strict est utilisé, selon lequel les valeurs énumérées ne peuvent être affectées ou transmises qu'à des variables ou paramètres du même type, ou comparées à des valeurs énumérées du même type. Cet indicateur est désactivé par défaut. |
| +fkp | Fixe |
| -fkp | Réinitialise l'indicateur de préprocesseur K&R. Certains préprocesseurs compatibles avec la nouvelle norme ANSI C autorisent des fonctionnalités interdites par K&R C, comme les espaces et les tabulations avant le dièse initial. L'activation de cet indicateur impose le strict respect de la spécification K&R. Cet indicateur est désactivé par défaut. |
| +fnc | Fixe |
| -fnc | Réinitialise l'indicateur de commentaires imbriqués. Si cet indicateur est activé, les commentaires peuvent être imbriqués. Cela permet à l'outil d'analyse statique de traiter les fichiers contenant du code commenté. Toutefois, commenter du code est une mauvaise pratique. Il est recommandé de désactiver le code à l'aide d'une condition de préprocesseur, car cela évite le problème des guillemets et des barres obliques, et associe automatiquement une condition à la réactivation du code. Cet indicateur est désactivé par défaut. |
| +fsa | Fixe |
| -fsa | Réinitialise l'indicateur d'affectation de structure. Si cet indicateur est activé, l'affectation de structure est considérée comme valide. Les fonctions, les arguments effectifs et les paramètres peuvent être de type struct ou union, et ces objets peuvent être utilisés dans l'affectation. Cet indicateur est activé par défaut. |
| +fsu | Fixe |
| -fsu | Réinitialise l'indicateur de caractère non signé. Lorsque cet indicateur est activé, une chaîne de caractères constants (comme "...") est considérée comme un pointeur vers un caractère non signé. Cet indicateur est désactivé par défaut. |
| +ful | Fixe |
| -ful | Réinitialise l'indicateur `unsigned long`. Si cet indicateur est activé, `unsigned long` est un type valide. Cela signifie, par exemple, que le résultat d'une opération mixte impliquant un `long` et un `unsigned` sera de type `unsigned long` et non `long`. L'indicateur `unsigned long` est activé par défaut. |
| +fum | Fixe |
| -fum | Réinitialise l'indicateur d'unicité des membres. PC-Lint autorise généralement les noms de membres dupliqués (ou conflictuels) dans différentes structures. Par exemple :
est autorisé par PC-Lint et par la plupart des compilateurs C modernes. Cependant, K&R l'interdit expressément. Si vous souhaitez que votre code respecte strictement la norme K&R concernant l'unicité des noms de membres, activez l'indicateur avec l'option +fum. Il est généralement désactivé. |
| +fva | Fixe |
| -fva | Réinitialise l'indicateur de liste d'arguments variables. Les fonctions déclarées ou définies lorsque cet indicateur est activé sont considérées comme ayant une liste
d'arguments variable. Les messages d'avertissement (515 et 516) signalant des incohérences entre les listes d'arguments sont supprimés pour ces fonctions. Par exemple :
indique que les fonctions printf() et fprintf() sont considérées comme ayant une liste d'arguments variable. Un suffixe entier N peut être ajouté à «va» pour indiquer que la variabilité commence après le N-ième argument. Par exemple :
indique que seul le premier argument de printf doit être vérifié. Notez que le même résultat peut être obtenu en utilisant des prototypes. Une fonction, une fois qualifiée de fonction à arguments variables, ne peut perdre ce statut si elle est déclarée ou définie avec l'indicateur `va` désactivé. Cela permet de définir cet indicateur une seule fois dans un module de déclaration et de l'omettre dans les modules suivants. Notez que cet indicateur n'a aucun effet direct lors d'un appel de fonction. Autrement dit, une fonction appelée avec l'indicateur désactivé ne sera pas marquée comme ayant des arguments variables. La présence ou non d'une erreur dépendra de la présence ou non de l'indicateur activé lors de la définition ou de la déclaration de la fonction. |
| +fvo | Fixe |
| -fvo | Réinitialise le type de données void. Cette option est activée par défaut. Si elle est activée, le type void est reconnu et les fonctions déclarées comme void sont considérées comme ne retournant aucune valeur. |
| +fvr | Fixe |
| -fvr | Réinitialise l'indicateur de mode de retour variable. Cet indicateur est normalement désactivé. Le retour dépend du fait que certaines fonctions renvoient ou non une valeur. Cet indicateur dépend du fait qu'une fonction ait une valeur. Cet indicateur dépend du fait qu'une fonction doive être cohérente à cet égard. Si cet indicateur est activé lors de la définition ou de la déclaration d'une fonction, les messages d'erreur résultant d'une incompatibilité entre les appels à la fonction et sa déclaration, entre deux appels, ou entre les instructions de retour et l'un des éléments ci-dessus sont bloqués. Par exemple, étant donné que `strcpy()` renvoie une chaîne de caractères (dans la plupart des bibliothèques standard) et que cette chaîne est rarement utilisée, il serait judicieux d'activer cet indicateur pour au moins une des déclarations de `strcpy()`. Un exemple est fourni dans `stdlib.c`. |
| +fzl | Fixe |
| -fzl | Réinitialise l'indicateur `sizeof-is-long`. Si cet indicateur est activé, `sizeof` est considéré comme un entier long (ou un entier non signé si l'option `-fau` est également activée). Cet indicateur est désactivé par défaut, car `sizeof` est généralement de type `int`. |
| +fzu | Fixe |
| -fzu | Réinitialise l'indicateur `sizeof-is-unsigned`. Si cet indicateur est activé, `sizeof` est considéré comme renvoyant une quantité non signée (un `unsigned long` si l'option `-fzl` est activée). Cet indicateur est désactivé par défaut. |
Options de hauteur
PC-Lint offre un contrôle précis de la hauteur des messages d'erreur. Plus la hauteur est faible, plus les messages peuvent être affichés sur un petit écran; plus la hauteur est élevée, plus les erreurs sont clairement visibles. La hauteur par défaut de 4 convient à l'impression, mais est presque certainement trop importante pour la plupart des écrans.
La hauteur des messages est contrôlée par l'option `-h`, dont la forme générale est :
| -h[s][C][N] |
L'option «s» indique un espace (ligne vide) après chaque message.
L'option «C» représente un caractère quelconque et sert d'indicateur de position horizontale (il ne peut s'agir ni d'un chiffre ni d'un «s») pour indiquer la position de l'erreur dans la ligne source. Ce caractère est intégré à la ligne source si N = 2 (voir ci-dessous) ; sinon, il apparaît sur une ligne distincte.
N est un entier optionnel indiquant la hauteur des messages (voir ci-dessous). Notez que N correspond à la hauteur nominale des messages. Certains messages comportent une clause supplémentaire qui augmente leur hauteur réelle à N + 1.
Exemples :
| Exemples | Description |
|---|---|
| -h$2 | Les messages s'afficheront sur deux lignes. Le symbole dollar sera inséré dans la ligne source à l'endroit de l'erreur. |
| -h1 | Les messages n'occuperont normalement qu'une seule ligne. |
| -hs4 | Les messages s'afficheront normalement sur quatre lignes, un espace étant omis après chaque message (comportement par défaut). Aucun indicateur de position horizontale particulier n'est spécifié (une valeur par défaut sera choisie). |
Pour N = 4, les messages d'erreur ont la forme générale suivante :
|
File <File-name> Line <Line-number> <Source-line> C <Error-number>: <Message> |
Exemple (-h4) :
|
File x, c, Line 4 n = m; ^ Error 40: Undeclared identifier (m) |
Pour N = 3, la forme générale est :
|
<Source-line> C <File-name> <Line-number> <Error-number>: <Message> |
Exemple (-h3) :
|
n = m; ^ x.c 4 Error 40 : Undeclared identifier (m) |
Pour N = 2, la forme générale est :
|
<Source-line> <File-name> <Line-number> <Error-number>: <Message> |
Exemple (-h$2) :
|
n = $m x.c 4 Error 40 : Undeclared identifier (m) |
Pour N = 1, la forme générale est la même que pour N = 2, sauf que la ligne <Source-line> est omise.
Exemple (-h1) :
| x.c 4 Error 40: Undeclared identifier (m) |
Autres options
| Option | Description | ||
|---|---|---|---|
| -b | On suppose le modèle de mémoire étendue du 8086 (les pointeurs sont supposés faire 4 octets). Cette option est équivalente à -sp4 ou -mL et est disponible pour assurer la compatibilité avec le compilateur C86 de C.I. Elle entraîne également la définition du symbole de préprocesseur _C86_BIG. | ||
| -d | Cette option permet à l'utilisateur de définir des variables de préprocesseur à partir de la ligne de commande. Son format est le suivant :
où les crochets indiquent que la valeur est facultative. Si elle est omise, la valeur 1 est prise en compte. Exemples :
Ces deux options sont équivalentes aux affirmations suivantes :
Ces options apparaissent au début de chaque module. Notez que la casse est conservée. Jusqu'à 6 variables définies sont autorisées. L'option `-d` peut être utilisée dans un commentaire de linting, mais elle ne sera prise en compte qu'au traitement du module suivant. |
||
| -i<prefix> | Les fichiers non trouvés dans le répertoire courant sont recherchés en ajoutant le préfixe indiqué au nom du fichier. Jusqu'à six préfixes sont autorisés, et l'ordre de recherche correspond à l'ordre d'apparition des préfixes `-i<prefix>` sur la ligne de commande. Par exemple :
permet de rechercher tous les fichiers #include introuvables dans le répertoire courant dans un répertoire de bibliothèque nommé «lib». Notez que <prefix> est une chaîne de caractères ajoutée physiquement au nom du fichier. PC-Lint prend également en charge la variable d'environnement INCLUDE. |
||
| -library | Cette option indique que le fichier suivant (si elle est spécifiée en ligne de commande) ou le fichier courant (si elle est spécifiée dans un commentaire `/*lint`) est une bibliothèque. Toute déclaration ou définition de symboles externes pendant que cette option est active marque le symbole comme appartenant à une bibliothèque. Si le symbole n'est pas référencé, le message d'information 714 (défini mais non référencé) est ignoré. De même, si le symbole n'est pas défini, le message d'avertissement 526 (référencé mais non défini) est également ignoré. La condition de bibliothèque est automatiquement levée à la fin d'un module. | ||
| -mD | Spécifie le modèle D (grandes données, petits programmes) pour MS-DOS. Les pointeurs vers les zones de données sont supposés avoir une longueur de 4 octets, tandis que les pointeurs vers les fonctions ont une longueur de 2 octets. Cela équivaut à spécifier -mpD4 et -spP2. | ||
| -mL | On suppose l'utilisation du modèle de mémoire étendue 8086 (les pointeurs sont supposés avoir une longueur de 4 octets). Ceci est équivalent à -sp4 et/ou -b. Cela peut être utilisé pour assurer la compatibilité avec l'option identique de Lattice C. Cela définit également le symbole de préprocesseur SPTR à 0. | ||
| -mP | Spécifie le modèle P (modèle de programme volumineux et de données réduites, parfois appelé modèle moyen) pour MS-DOS. Les pointeurs vers les zones de programme (et les pointeurs vers les fonctions) sont supposés avoir une longueur de 4 octets, tandis que les pointeurs vers les données ont une longueur de 2 octets. Cela équivaut à spécifier -spP4 et -spD2. | ||
| -p | Exécutez uniquement le préprocesseur. Si cette option est activée, PC-Lint se comporte alors comme un préprocesseur et non plus comme un outil de diagnostic. La sortie est
dirigée vers la sortie standard, qui peut être redirigée. Ainsi :
créera dans le fichier fichier.p le résultat du traitement de toutes les # lignes du fichier fichier.c. Ceci peut servir au débogage pour déterminer précisément les transformations appliquées par PC-Lint. Cela peut également s'avérer utile en cas de saturation de la mémoire vive. |
||
| -restore | Restaure l'état des paramètres d'inhibition d'erreur (toutes les options, numériques ou non, commençant par -e ou -e) à leur état au début du dernier module ou lors de la dernière exécution de l'option -save, selon la plus récente. Cette directive est généralement placée à la fin d'un fichier afin que les paramètres -e/+e définis dans un fichier ne soient pas transmis au fichier suivant. Le fichier stdlib.c contient un exemple d'utilisation de cette directive. | ||
| -save | Enregistre l'état actuel de tous les paramètres d'inhibition d'erreurs (définis par les options de la forme `-e...` ou `+e....`). Cet état peut être restauré avec l'option `-restore`. L'option `-save` n'est pertinente que dans un commentaire `/*lint` au sein d'un module, où elle peut être utilisée après la configuration initiale des paramètres d'inhibition d'erreurs qui serviront de base au traitement dans ce module et les suivants. Cette option ne modifie pas l'état enregistré, mais l'efface complètement ; deux appels successifs à `-restore` équivalent donc à une seule restauration. | ||
| -t# | Définit la taille des tabulations selon PC-Lint. Par défaut, PC-Lint considère qu'une tabulation se trouve toutes les 8 colonnes. Si votre éditeur utilise un autre taux de conversion entre espaces et tabulations, utilisez cette option. Par exemple, -t4 indique qu'une tabulation équivaut à 4 caractères. | ||
| -u | Extraction unitaire : cette option correspond aux erreurs -e714 (défini en externe mais non référencé), -e526 (déclaré mais non défini) et -e552 (non accessible globalement). Lors de l'extraction de modules incomplets destinés à être liés à d'autres modules, il est préférable d'éviter ces messages d'erreur. | ||
| -unreachable | Indique qu'un point du programme est inaccessible. Ceci est utile pour éviter certains messages d'erreur. Par exemple :
contient un indicateur d'inaccessibilité pour empêcher PC-Lint de croire qu'un retour implicite existe à la fin de la fonction. Un retour implicite ne renverrait aucune valeur, or f() est déclarée comme renvoyant un entier. |
||
| -Ze | Active les mots réservés suivants : near, far, nuge, fortran, pascal et cdecl. Le nom de cette option et les mots réservés activés sont choisis pour assurer la compatibilité avec une option similaire du compilateur C de Microsoft. Bien que les mots réservés soient reconnus, ils n'interviennent pas dans la vérification des types. | ||
| -zero | Définit le code de retour à 0. Ceci est utile pour empêcher l'arrêt prématuré des fichiers de script. |
Code de sortie
Le système d'exploitation prend en charge le concept de code de sortie, permettant à un programme de renvoyer un octet d'information au programme le contrôlant. PC-Lint attribue au code de sortie le nombre d'erreurs rencontrées (limité à 255). Pour que le code de sortie soit toujours égal à 0, utilisez l'option `-zero`. Vous pouvez utiliser le code de sortie dans les procédures par lots pour modifier conditionnellement le flux d'exécution. Par exemple :
|
lint ... arguments habituels ... if errorlevel 1 goto errorsfound |
L'instruction suivante, dans une procédure par lots, provoque un saut vers l'étiquette `errorsfound` si PC-Lint détecte une ou plusieurs erreurs. Ceci peut être utilisé pour contourner une compilation.