indent [options] [fichier] [-o fichier]
indent rend le programme plus lisible en faisant automatiquement les indentations et le formatage. Il permet aussi de convertir un programme d'un style d'écriture à un autre.
indent comprend un bonne part de la syntaxe du C, mais il peut traiter des fichiers dont la syntaxe est incomplète ou erronée.
Dans les version 1.2 et plus récentes, le style GNU est le style d'indentation par défaut.
Comme dans la version 1.3, le format de la commande indent est :
indent [options] [input-files] indent [options] [single-input-file] [-o output-file]
Ce format n'est pas le même que celui de versions plus anciennes, ni que celui d'autres versions d' indent.
La première forme accepte plusieurs fichiers en entrée. Indent fait une copie de chaque fichier, et le fichier original est remplacé par sa version indentée. Voir BACKUP FILES.
Le seconde forme n'accepte qu'un fichier en entrée, ou l'entrée standard, et permet de spécifier un fichier de sortie.
Utilisez l'option `-st' pour une sortie sur la sortie standard. Cela n'est
possible qu'avec la deuxième forme.
Si aucun nom de ficher d'entrée n'est fourni, l'entrée standard est
utilisée. C'est aussi le cas si le nom de fichier est `-'.
Ces trois commandes indentent `confus.c' et écrivent le résultat dans `clair.c' :
indent confus.c -o clair.c indent -st confus.c > clair.c cat confus.c | indent -o clair.c
La plupart des options d'indent servent à définir de quelle façon le code est formaté. Chaque option une forme longue, comme dans la version 1.2. Celles-ci ont pour préfixe `--' ou `+' ( `+' est transformé en `--' pour maintenir la conformité avec le standard POSIX). Dans ce document on utilise plutôt la forme courte tradionnelle. Voir la LISTE DES OPTIONS qui indique les deux formes.
La commande :
indent -br test/metabolism.c -l85
indente `test/metabolism.c' avec les options `-br' et `-l85', et écrit le fichier de sauvegarde dans le répertoire `test'.
Avec les noms d'option longs le même commande devient :
indent --braces-on-if-line --line-length185 test/metabolism.c indent +braces-on-if-line +line-length185 test/metabolism.c
Si vous utilisez souvent le même ensemble d'options vous pouvez placer celles-ci dans un fichier de profil nommé `.indent.pro'. indent cherche d'abord un fichier de profil défini par la variable INDENT_PROFILE. Si cette variable n'est pas définie il cherche le fichier `.indent.pro' dans le répertoire courant, puis dans le répertoire personnel de l'utilisateur. Les autres version d'indent ont un comportement différent : elles chargent tous les fichiers s'ils existent.
Le fichier de profil est simplement le liste des options telle qu'elle apparaîtrait sur la ligne de commande, séparées par des espaces, des tabulations ou des sauts de ligne. On peut utiliser les commentaires du C ou du C++.
Les options de la ligne de commande sont traitées après celles du fichier de profil et priment sur elles, à une exception près : les options explicites priment toujours sur les options globales (voir STYLES COURANTS). L'option `-npro' force indent à ne pas lire les fichiers de profil.
Comme dans sa version 1.3, GNU indent fait une sauvegarde dans le style GNU, comme GNU Emacs. On peut donc faire des sauvegardes simples ou numérotées.
Les fichiers de sauvegarde simples sont nommés d'après le nom du fichier auquel on ajoute un suffixe, par défaut un tilde (`~'), ou la chaîne définie par la variable d'environnement SIMPLE_BACKUP_SUFFIX.
Les sauvegardes numérotées du fichier momeraths.c vont ressembler à `momeraths.c.~23~', où 23 est la numéro de la sauvegarde. Si on fait une sauvegarde numérotée de `src/momeraths.c', elle s'appellera `src/momeraths.c.~.I V~', où .I V est supérieur à la plus haute version qui existe déja dans le répertoire. La variable d'environnement VERSION_WIDTH permet d'indiquer le nombre de chiffres significatifs. Si elle vaut 2, par exemple, les fichiers ressembleront à `momeraths.c.~04~'
Le type de sauvegarde est fonction de la variable d'environnement VERSION_CONTROL, qui peut contenir `simple', pour une copie simple, `numbered', pour une copie numérotée, ou encore `numbered-existing', pour faire une copie numérotée uniquement s'il en existe déja une dans le répertoire, et sinon une simple.
Les autres versions d'indent utilisent le suffixe .BAK. Ce comportement peut être obtenu en donnant à SIMPLE_BACKUP_SUFFIX la valeur `.BAK'.
Notez aussi que les autres versions d'indent font toujours les sauvegardes dans le réperoire courant, contrairement au comportement actuel de GNU indent.
Il existe plusieurs styles courants d'écriture en C. Le style GNU, le style Kernighan & Ritchie, et le style de Berkeley. Un style peut être défini par une option globale, ou par un ensemble d'options explicites. Les options explicites priment toujours sur celles définies par au sein l'option globale.
Comme dans la version 1.2, le style par défaut est le style GNU. On peut aussi le spécifier avec l'option globale `-gnu', qui correspond à :
-nbad -bap -nbc -bbo -bl -bli2 -bls -ncdb -nce -cp1 -cs -di2 -ndj -nfc1 -nfca -hnl -i2 -ip5 -lp -pcs -nprs -psl -saf -sai -saw -nsc -nsob
Le style GNU est le style de préference du projet GNU. C'est celui que GNU Emacs encourage à utiliser, et dans lequel les portions en C de Emacs sont écrites. (Les personnes intéressés par le développement de programmes pour le projet GNU peuvent utilement se référer à "Standard de Codage GNU", qu traite également de la sémantique et de la portabilité, par exemple pour les questions touchant à l'utilisation de la mémoire ou à la taille des entiers).
Le style Kernighan & Ritchie a commencé à être utilisé après la parution du fameux livre "The C Programming Language". Il est spécifié par l'option `-kr', et correspond à :
-nbad -bap -bbo -nbc -br -brs -c33 -cd33 -ncdb -ce -ci4 -cli0 -cp33 -cs -d0 -di1 -nfc1 -nfca -hnl -i4 -ip0 -l75 -lp -npcs -nprs -npsl -saf -sai -saw -nsc -nsob -nss
Le style Kernighan & Ritchie ne place pas tout le temps les commentaires à droite du code à la même colonne (il ne place pas non plus toujours un seul espace à la droite du code). Le choix a donc été fait de la colonne 33.
Le style original de Berkeley est obtenu avec l'option `-orig' (ou `--original'). Il correspond à :
-nbad -nbap -bbo -bc -br -brs -c33 -cd33 -cdb -ce -ci4 -cli0 -cp33 -di16 -fc1 -fca -hnl -i4 -ip4 -l75 -lp -npcs -nprs -psl -saf -sai -saw -sc -nsob -nss -ts8
Les styles de programmation utilisent les lignes blanches à plusieurs occasions. Voici les options d'indent les concernant:
L'option `-bad' provoque l'ajout d'une ligne blanche après chaque bloc de déclarations. Avec l'option `-nbad', cet ajout n'aura pas lieu.
L'option `-bap' provoque l'ajout d'une ligne blanche après chaque corps de procédure. Avec l'option `-nbad', cet ajout n'aura pas lieu.
L'option `-bbb' provoque l'ajout d'une ligne blanche après chaque bloc de commentaire (voir COMMENTAIRES). Avec l'option `-nbbb', cet ajout n'aura pas lieu.
L'option `-sob` provoque la suppression de toutes les lignes blanches superflues. Avec l'option `-nsob', cette suppression n'aura pas lieu.
L'option `-bad' provoque l'ajout d'une ligne blanche après chaque bloc de déclarations. Avec l'option `-nbad', cet ajout n'aura pas lieu.
Par exemple,
char *foo; char *bar; /* Séparation entre deux blocs de déclarations. */ int baz;
donnera avec indent -bad
char *foo; char *bar; /* Séparation entre deux blocs de déclarations. */ int baz;
et avec indent -nbad
char *foo; char *bar; /* Séparation entre deux blocs de déclarations. */ int baz;
L'option `-bap' provoque l'ajout d'une ligne blanche après chaque corps de procédure. Avec l'option `-nbad', cet ajout n'aura pas lieu.
Par exemple,
int
foo ()
{
puts("Salut !");
}
/* La procédure bar est moins importante. */
char *
bar ()
{
puts("est-ce bien utile ?");
}
donnera avec indent -bap
int
foo ()
{
puts ("Salut !");
}
/* La procédure bar est moins importante. */
char *
bar ()
{
puts("est-ce bien utile ?");
}
et avec indent -nbad
int
foo ()
{
puts ("Hi");
}
/* La procédure bar est moins importante. */
char *
bar ()
{
puts("est-ce bien utile ?");
}
indent formate les commentaires dans le style C (commençant par `/*', se terminant par `*/', et pouvant contenir des sauts de ligne) et dans le style C++ (commençant par `//' et se terminant avec la ligne).
indent traite les commentaires différemment selon leur contexte. Il distingue ceux qui suivent une instruction, ceux qui suivent une déclaration, ceux qui suivent une directive du préprocesseur et ceux qui ne sont pas précédés de code d'aucune sorte, par exemple ceux qui commencent une ligne (mais pas forcément à la première colonne).
indent fait aussi la différence entre les commentaires situés à l'intérieur de procédures et de blocs , et ceux qui ne le sont pas. Ceux qui commencent une ligne à l'intérieur d'une procedure seront indentés à la colonne où le code est indenté à cet endroit, sauf s'il commence au début de la ligne, auquel cas il est laissé inchangé.
indent laisse les commentaires sous forme de boîte inchangés. Ce type de commentaire est défini rigoureusement ainsi : le `/*' initial est immédiatement suivi par `*', `=', `_', `-', ou par un saut de ligne suivi d'un `*' aligné avec l'astérisque situé au dessus, comme on le voit sur ces exemples :
/************************************
* Un commentaire dans une boîte !! *
************************************/
/*
* Un autre style de commentaire
* inclus dans une «boîte».
*/
indent laissera ces commentaires inchangés. Il changera seulement les tabulations en un nombre d'espaces correspondant.
Si l'option `-bbb' est spécifiée, tout commentaire sous forme de boîte sera précédé d'une ligne blanche, sauf s'il est précédé de code sur sa première ligne.
Les commentaires qui n'ont pas cette forme seront formatés, c'est-à-dire alignés sur la marge de droite et remplis d'espaces à gauche. Un simple saut de ligne sera considéré comme un espace, mais une ligne blanche, ou un groupe d'au moins deux sauts de lignes, comme un changement de paragraphe. Le formatage des commentaires qui commencent après la première colonne est activé par l'option `-fca'. Pour formater ceux qui commencent à la première colonne, utilisez l'option `-fc1'. Ces formatages sont inactivés par défaut.
La marge de droite est par défaut à la colonne 78, mais peut être spécifiée avec l'option `-lc'. Si celle-ci ne permet pas l'affichage d'un commentaire, elle sera modifiée pour la durée de ce commentaire. La marge ne sera pas respectée si le commentaire n'est pas formaté.
Si un commentaire commence une ligne (c'est-à-dire s'il il n'y a pas de de texte, qui ne soit pas lui même un commentaire, à sa gauche), il sera indenté à la colonne à laquelle il sera trouvé, sauf s'il se trouve à l' intérieur d'un bloc de code (et qu'il ne commence pas à la première colonne), auquel cas il sera indenté comme ce code. Ceci peut être modifié par l'option `-d' qui spécifie de combien le commentaire est déplacé vers la gauche. Ainsi, `-d2' place les commentaires deux colonnes à gauche du code. Pour aligner le commentaire avec le code, utilisez l'option `-fc1'. Un commentaire commençant à la première colonne ne sera pas formaté.
Les commentaires situés à droite du code sont placés par défaut à la colonne 33. Cela peut être modifié par l'une des trois options suivantes. `-c' spécifie la colonne pour les commentaires qui suivent du code en général, `-cd' pour ceux qui suivent des déclarations et `-c' pour ceux qui suivent les directives du preprocesseur #else et #endif.
Si le code à gauche d'un commentaire dépasse la colonne à laquelle le commentaire doit commencer, celui-ci commencera à la première tabulation après le code, ou dans le cas d'une directive de compilation, un espace après la fin de cette directive.
L'option `-cdb' place les délimiteurs de commentaires sur des lignes à part. Ainsi le commentaire /* Loving hug */ deviendra :
/* Il vaudrait mieux tout effacer */
Les astérisques peuvent être placés au début des commentaires occupant plusieurs lignes avec l'option `-sc'. Un commentaire d'une ligne comme le précédent devient alors, avec `-cdb -sc' :
/* * Il vaudrait mieux tout effacer */
Les options `-br' ou `-bl' spécifient comment formater les crochets.
L'option `-br' les formate ainsi :
if (x > 0) {
x--;
}
L'option `-bl' les formate ainsi :
if (x > 0)
{
x--;
}
On peut ajouter à l'option `-bl' l'option `-bli' qui spécifie de combien d'espaces les crochets sont indentés. La valeur par défaut est 2. `-bli0' donne le résultat suivant :
if (x > 0)
{
x--;
}
On peut ajouter à l'option `-br' l'option `-ce', qui indique à indent de placer le else immédiatement après le `}' qui le précède dans une construction if-then-else. Ainsi, avec `-br -ce', on obtient par exemple :
if (x > 0) {
x--;
} else {
fprintf (stderr, "...OK\n");
}
Ainsi avec `-br -nce', on obtiendrait
if (x > 0) {
x--;
}
else {
fprintf (stderr, "...OK\n");
}
L'option `-cdw' indique à indent de placer le while juste après le `}' dans une boucle do-while, pour donner par exemple :
do {
x--;
} while (x);
Avec `-ncdw' on obtiendrait :
do {
x--;
}
while (x);
L'option `-cli' spécifie de combien d'espaces doit être indenté chaque branchement case par rapport à la droite de l'instruction switch. La valeur par défaut est zéro, et donne quelque chose comme :
switch (i)
{
case 0:
break;
case 1:
{
++i;
}
default:
break;
}
Avec l'option `-cli2', ce code deviendrait :
switch (i)
{
case 0:
break;
case 1:
{
++i;
}
default:
break;
}
L'indentation des crochets après l'instruction case peut être spécifiée par l'option `-cbin'. Par exemple, `-cli2 -cbi0' donnera :
switch (i)
{
case 0:
break;
case 1:
{
++i;
}
default:
break;
}
Si un point-virgule est sur la même ligne qu'une assertion for ou while, l'option `-ss' permet de placer un espace avant le point-virgule. Cela met bien en évidence le point-virgule, on voit mieux que l'assertion while ou for n'a pas de corps. Avec l'option `-nss', ce comportement n'a pas lieu.
L'option `-pcs' place un espace entre le nom d'une procédure appelée et le `(' (par exemple, puts ("OK");). L'option `-npcs' retirera cet espace.
L'option `-cs' place un espace après les opérateurs de transtypage.
L'option `-bs' place un espace entre sizeof et son argument. Dans certaines versions cette option est appelée l'option `Bill_Shannon'.
L'option `-saf' place un espace entre un for et la parenthèse qui le suit. C'est le comportement par défaut.
L'option `-sai' place un espace entre un if et la parenthèse qui le suit. C'est le comportement par défaut.
L'option `-saw' place un espace entre un while et la parenthèse qui le suit. C'est le comportement par défaut.
L'option `-prs' placera un espace entre les parenthèses et ce qu'elles contiennent. Cela donnera par exemple :
while ( ( e_code - s_code ) < ( dec_ind - 1 ) )
{
set_buf_break ( bb_dec_ind );
*e_code++ = ' ';
}
Par défaut indent aligne les identificateurs, à la colonne spécifiée par l'option `-di'. `-di16' donnera par exemple :
int foo; char *bar;
On peut spécifier une petite valeur à l'option `-di' (un ou deux) pour que les identificateurs soient placés le plus à gauche possible :
int foo; char *bar;
La valeur donnée à `-di' affectera toujours les variables qui sont sur des lignes séparées. Par exemple `-di2' donnera :
int foo;
L'option `-bc' permet de passer une ligne après chaque virgule dans une déclaration :
int a, b, c;
L'option `-nbc' force le comportement contraire :
int a, b, c;
L'option `-bfda' permet de passer une ligne après chaque virgule dans la déclaration des arguments d'une fonction. Ceux-ci vont apparaître à un niveau d'indentation immédiatement supérieur à celui de la déclaration de la fonction. C'est pratique pour les fonctions qui prennent beaucoup d'arguments. L'option `-bfde' permet de passer une ligne avant le crochet fermant. Les options `-nbdfa' et `-nbdfe' ont les comportements contraires. Le comportement par défaut est `-nbdfa -nbdfe'.
Par exemple,
void foo (int arg1, char arg2, int *arg3, long arg4, char arg5);
donne avec l'option `-bfda' :
void foo (
int arg1,
char arg2,
int *arg3,
long arg4,
char arg5);
et avec en plus l'option `-bfde' :
void foo (
int arg1,
char arg2,
int *arg3,
long arg4,
char arg5
);
L'option `-psl' place, lors d'une définition de procédure, le type de celle-ci sur la ligne précédant son nom. Ce style est nécessaire pour que le programme etags puisse correctement lire le code, de même que pour certaines fonctions du mode C d'Emacs.
L'option `-T' permet d'indiquer à indent les noms de tous les types définis par typedef dans votre programme. `-T' peut être spécifié plusieurs fois. Par exemple si vous avez de telles déclarations :
typedef unsigned long CODE_ADDR;
typedef enum {red, blue, green} COLOR;
vous pourrez utiliser les options `-T CODE_ADDR -T COLOR'.
Les options `-brs' ou `-bls' spécifient comment formater les crochets dans une déclaration de structure. L'option `-brs' donne :
struct foo {
int x;
};
et l'option `-bls' donne :
struct foo
{
int x;
};
L'indentation consiste à placer chaque ligne de code à une certaine distance de la marge de droite. après le début d'un bloc, par exemple après un if ou un for, le niveau d'indentation est augmenté de la valeur spécifiée par l'option `-i'. Si le début d'un bloc est situé sur plusieurs lignes, chaque ligne est indentée par rapport à la prédédente d'un nombre d'espaces spécifié par l'option `-ci'. La valeur par défaut de `-ci' est 0. Cependant si l'option `-lp' est spécifiée, et si une ligne a une parenthèse ouvrante qui ne se ferme pas sur cette même ligne, alors les lignes suivantes seront alignées sur la position qui suit immédiatement cette parenthèse ouvrante. Cela s'applique aussi à `[', et à `{' (dans les listes d'initialisations). Voilà par exemple un résultat possible avec `-nlp -ci3' :
p1 = first_procedure (second_procedure (p2, p3),
third_procedure (p4, p5));
et avec `-lp', qui donne un code peut-être un peu plus clair :
p1 = first_procedure (second_procedure (p2, p3),
third_procedure (p4, p5));
Quand une assertion est située entre plusieurs paires de parenthèses, chaque paire supplémentaire entraîne un niveau d'indentation supplémentaire :
if ((((i < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)
L'option `-ipN\' permet de spécifier le nombre d'espaces supplémentaires par parenthèse. Avec `-ip0' le code précédent deviendrait :
if ((((i < 2 && k > 0) || p == 0) && q == 1) || n = 0)
indent suppose que les tabulations sont placées à des intervalles réguliers à la fois dans les flux d'entrée et dans les flux de sortie. Ces intervalles sont de 8 colonnes par défaut, et peuvent être spécifiés avec l'option `-ts' (comme dans la version 1.2). Les tabulations sont traitées comme la quantité équivalente d'espaces. L'identation des déclarations de type dans l'ancienne façon de déclarer les fonctions est contrôlée par l'option `-ip'. L'option `-ip5' donnera par exemple :
char *
create_world (x, y, scale)
int x;
int y;
float scale;
{
. . .
}
Pour assurer la compatibilité avec les autres versions d'indent, l'option `-nip' est définie et est équivalente à `ip0'.
On peut en ANSI C placer un espace, dans les directives du préprocesseur, entre le `#' et le nom de la commande. Le comportement par défaut d'indent est d'enlever cet espace. L'option `-lps' permet de laisser cet espace. L'option `-nlps' redonne le comportement par défaut. L'option `-ppi' remplace `-nlps' et `-lps'.
Cette option `-ppi' permet d'indenter les statements conditionnels des directives du préprocesseur. Ainsi avec l'option `-ppi 3'
#if X #if Y #define Z 1 #else #define Z 0 #endif #endifdevient
#if X # if Y # define Z 1 # else # define Z 0 # endif #endif
L'option `-ln', ou `--line-lengthn', permet de spécifier la longueur maximale d'une ligne de code C, sans inclure les commentaires qui pourraient suivre sur la même ligne.
Quand la ligne est plus longue que cette longueur, GNU indent essaye de couper la ligne à une place logique. C'est une nouveauté de la version 2.1, qui n'est encore ni très intelligente ni très flexible.
Il y a pour l'instant deux options qui permettent de contrôler comment l'algorithme détermine à quel endroit couper la ligne.
Avec l'option `-bbo', indent préfèrera couper la ligne avant les opérateurs booléens && et ||. Avec l'option `-nbbo' il n'aura pas cette préférence. L'option `-bbo' est l'option par défaut. Avec les options `-bbo', `--line-length60' et `--ignore-newlines', on peut obtenir quelque chose comme :
if (mask
&& ((mask[0] == '\0')
|| (mask[1] == '\0'
&& ((mask[0] == '0') || (mask[0] == '*')))))
Avec l'option `-nbbo' ceci deviendra :
if (mask &&
((mask[0] == '\0') ||
(mask[1] == '\0\' &&
((mask[0] == '0') || (mask[0] == '*')))))
L'option `-hnl', ou `--honour-newlines', permet de demander à indent de respecter les sauts de lignes du fichier d'entrée, en leur donnant la priorité la plus haute. C'est l'option par défaut. Avec l'option `-nhnl', ou `--ignore-newlines', il n'aura pas ce comportement. Ainsi si le fichier d'entrée contient par exemple :
if (mask
&& ((mask[0] == '\0')
|| (mask[1] == '\0\' && ((mask[0] == '0') || (mask[0] == '*')))))
alors, avec les options `-hnl', `-nbbo' et `--line-length60', indent préfèrera couper les lignes là où elles l'étaient dans le ficher d'entrée :
if (mask
&& ((mask[0] == '\0')
|| (mask[1] == '\0\' &&
((mask[0] == '0') || (mask[0] == '*')))))
L'idée derrière cela est qu'une ligne trop longue mais déja coupée ne sera pas modifiée par indent. Les codes vraiment très confus peuvent être passés au moins une fois par indent avec l'option `--ignore-newlines'.
Le formatage du code C peut être désactivé pour des portions de programme en y plaçant des commentaires de contrôle. Pour désactiver le formatage, placez la commentaire /* *INDENT-OFF* */, tout seul sur une ligne. Pour le réactiver, insérez /* *INDENT-ON* */. Le texte entre ces deux séquences ne sera pas modifié. indent ne vérifie pas l'espace entre les délimiteurs et les commentaires de contrôle. On peut écrire /* *INDENT-OFF* */. On peut aussi utiliser le format du C++ et écrire // *INDENT-OFF* et // *INDENT-OFF*.
Notez que le niveau d'indentation reste inchangé lors d'une section non formatée. Il peut en résulter de drôles de résultats si l'on place ces séquences de contrôle à des niveaux de pronfondeur différents, par exemple l'un au sein d'une fonction et l'autre après la fin de cette fonction.
Note historique : certaines versions anciennes d'indent affichaient des messages d'erreur commençant par *INDENT**. Ces versions d'indent ignoraient toute ligne commençant par ce message. L'auteur a supprimé ce comportement.
-version : Afficher le numéro de version de GNU indent et quitter.
-v : Mode verbeux. Indique quand une ligne est coupée et donne certaines statistiques.
-pmt : Ne pas modifier l'horodatage des fichiers. Cela permet d'indenter les sources et les en-têtes d'un projet sans que make doive reconstruire toutes les cibles. Cette option fonctionne uniquement sur les systèmes possédant la fonction POSIX utime(2).
Rapportez-les à bug-indent@gnu.org.
Si indent est lancé deux fois de suite sur le même fichier, il ne devrait faire aucune modification lors du deuxième passage. Avec la structure actuelle d'indent, cela n'est pas du tout garanti, et n'a pas été intensivement testé.
indent ne comprend pas le C. Ça l'empêche parfois de relier certaines lignes coupées. Cela entraîne que l'effet d'indent sur un fichier est irréversible, même si le fichier d'entrée est le résultat de l'execution de indent avec un fichier de profil (`.indent.pro').
Bien qu'un effort ait été fait pour faire fonctionner indent avec du C++, le résultat ne sera peut-être pas toujours très bon, sauf pour les codes sources les plus simples.
indent ne tient pas compte de l'option `--line-length' quand il écrit les commentaires dans le fichier de sortie. Les commentaires se retrouvent donc parfois très décalés vers la droite. Pour empêcher indent de réunir des lignes coupées qui finissent par un commentaire, placez le commentaire au début de la ligne juste après la coupure.
indent ne compte pas les lignes ni les commentaires (voir l'option `-v') quand le formatage est désactivé par la séquence /* *INDENT-OFF* */.
Les commentaires de la forme /*UPPERCASE*/ ne sont pas traités comme des commentaires mais comme des identifiants, et sont dont réunis à la ligne suivante. Ce type de commentaire n'est pas très utile, sauf s'il est intégré à un début de code.
The following copyright notice applies to the indent program. The copyright and copying permissions for this manual appear near the beginning of `indent.texinfo' and `indent.info', and near the end of `indent.1'.
Copyright (c) 2001 David Ingamells. Copyright (c) 1999 Carlo Wood. Copyright (c) 1995, 1996 Joseph Arceneaux. Copyright (c) 1989, 1992, 1993, 1994, 1995, 1996 Free Software Foundation Copyright (c) 1985 Sun Microsystems, Inc. Copyright (c) 1980 The Regents of the University of California. Copyright (c) 1976 Board of Trustees of the University of Illinois. All rights reserved. Redistribution and use in source and binary forms are permitted provided that the above copyright notice and this paragraph are duplicated in all such forms and that any documentation, advertising materials, and other materials related to such distribution and use acknowledge that the software was developed by the University of California, Berkeley, the University of Illinois, Urbana, and Sun Microsystems, Inc. The name of either University or Sun Microsystems may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
Voici une liste des options classées par ordre alphabétique des noms d'options longs, avec la forme courte correspondante.
--blank-lines-after-commas -bc --blank-lines-after-declarations -bad --blank-lines-after-procedures -bap --blank-lines-before-block-comments -bbb --braces-after-if-line -bl --brace-indent -bli --braces-after-struct-decl-line -bls --braces-on-if-line -br --braces-on-struct-decl-line -brs --break-after-boolean-operator -nbbo --break-before-boolean-operator -bbo --break-function-decl-args -bfda --break-function-decl-args-end -bfde --case-indentation -clin --case-brace-indentation -cbin --comment-delimiters-on-blank-lines -cdb --comment-indentation -cn --continuation-indentation -cin --continue-at-parentheses -lp --cuddle-do-while -cdw --cuddle-else -ce --declaration-comment-column -cdn --declaration-indentation -din --dont-break-function-decl-args -nbfda --dont-break-function-decl-args-end -nbfde --dont-break-procedure-type -npsl --dont-cuddle-do-while -ncdw --dont-cuddle-else -nce --dont-format-comments -nfca --dont-format-first-column-comments -nfc1 --dont-line-up-parentheses -nlp --dont-space-special-semicolon -nss --dont-star-comments -nsc --else-endif-column -cpn --format-all-comments -fca --format-first-column-comments -fc1 --gnu-style -gnu --honour-newlines -hnl --ignore-newlines -nhnl --ignore-profile -npro --indent-level -in --k-and-r-style -kr --leave-optional-blank-lines -nsob --leave-preprocessor-space -lps --line-comments-indentation -dn --line-length -ln --no-blank-lines-after-commas -nbc --no-blank-lines-after-declarations -nbad --no-blank-lines-after-procedures -nbap --no-blank-lines-before-block-comments -nbbb --no-comment-delimiters-on-blank-lines -ncdb --no-space-after-casts -ncs --no-parameter-indentation -nip --no-space-after-for -nsaf --no-space-after-function-call-names -npcs --no-space-after-if -nsai --no-space-after-parentheses -nprs --no-space-after-while -nsaw --no-tabs -nut --no-verbosity -nv --original -orig --parameter-indentation -ipn --paren-indentation -pin --preserve-mtime -pmt --procnames-start-lines -psl --space-after-cast -cs --space-after-for -saf --space-after-if -sai --space-after-parentheses -prs --space-after-procedure-calls -pcs --space-after-while -saw --space-special-semicolon -ss --standard-output -st --start-left-side-of-comments -sc --struct-brace-indentation -sbin --swallow-optional-blank-lines -sob --tab-size -tsn --use-tabs -ut --verbose -v
$HOME/.indent.pro fichier de profil, contient les options par défaut.
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.