INDENT(1)

NOM
indent — Modification de l’apparence d’un programme en C en insérant ou en supprimant des blancs

SYNOPSIS
indent [options] [fichiers_entrée]

indent [options] [fichier_entrée_unique] [-o fichier_sortie]

indent --version

DESCRIPTION
Cette page de manuel est générée à partir du fichier indent.texinfo. Il s’agit de l’édition de « The indent Manual » pour la dernière mise à jour de la version d'Indent. Le programme indent permet d’améliorer la lisibilité du code. Il permet aussi de convertir un programme d’un style d’écriture en C à un autre. indent comprend une grande partie de la syntaxe du C, mais il peut aussi traiter des fichiers dont la syntaxe est incomplète ou erronée. À partir de la version 1.2, le style d’indentation par défaut est le style GNU.

OPTIONS

-as, --align-with-spaces
    Si l’indentation utilise des tabulations, utiliser des espaces pour l’alignement.
    Voir la section INDENTATION.

-bad, --blank-lines-after-declarations
    Insérer une ligne vide après chaque déclaration.
    Voir la section LIGNES VIDES.

-bap, --blank-lines-after-procedures
    Insérer une ligne vide après un corps de fonction.
    Voir la section LIGNES VIDES.

-bbb, --blank-lines-before-block-comments
    Insérer une ligne vide avant un commentaire multiligne.
    Voir la section LIGNES VIDES.

-bbo, --break-before-boolean-operator
    De préférence, couper les longues lignes avant un opérateur booléen.
    Voir la section COUPURE DES LONGUES LIGNES.

-bc, --blank-lines-after-commas
    Passer à la ligne après une virgule dans une déclaration.
    Voir la section DÉCLARATIONS.

-bl, --braces-after-if-line
    Mettre l’accolade ouvrante sur la ligne suivant un if, etc.
    Voir la section INSTRUCTIONS.

-blf, --braces-after-func-def-line
    Mettre l’accolade ouvrante sur la ligne suivant la ligne de définition d’une fonction.
    Voir la section DÉCLARATIONS.

-blin, --brace-indentn
    Indenter les accolades de n espaces.
    Voir la section INSTRUCTIONS.

-bls, --braces-after-struct-decl-line
    Mettre l’accolade ouvrante sur la ligne suivant la ligne contenant struct.
    Voir la section DÉCLARATIONS.

-br, --braces-on-if-line
    Mettre l’accolade ouvrante sur la ligne contenant if, etc.
    Voir la section INSTRUCTIONS.

-brf, --braces-on-func-def-line
    Mettre l’accolade ouvrante sur la ligne de définition d’une fonction.
    Voir la section DÉCLARATIONS.

-brs, --braces-on-struct-decl-line
    Mettre l’accolade ouvrante sur la ligne contenant struct.
    Voir la section DÉCLARATIONS.

-bs, --Bill-Shannon, --blank-before-sizeof
    Mettre une espace entre sizeof et son argument.
    Voir la section INSTRUCTIONS.

-cn, --comment-indentationn
    Mettre les commentaires à droite du code à la colonne n.
    Voir la section COMMENTAIRES.

-cbin, --case-brace-indentationn
    Indenter l’accolade de n espaces après une étiquette case.
    Voir la section INSTRUCTIONS.

-cdn, --declaration-comment-columnn
    Mettre les commentaires à droite des déclarations à la colonne n.
    Voir la section COMMENTAIRES.

-cdb, --comment-delimiters-on-blank-lines
    Mettre les délimiteurs de commentaire sur des lignes vides.
    Voir la section COMMENTAIRES.

-cdw, --cuddle-do-while
    Rapprocher le while du « } » précédent dans une boucle do {} while;.
    Voir la section COMMENTAIRES.

-ce, --cuddle-else
    Réunir sur une même ligne le else et le « } » précédent.
    Voir la section COMMENTAIRES.

-cin, --continuation-indentationn
    Indentation des lignes de continuation de n espaces.
    Voir la section INSTRUCTIONS.

-clin, --case-indentationn
    Indenter l’étiquette case de n espaces.
    Voir la section INSTRUCTIONS.

-cpn, --else-endif-columnn
    Mettre les commentaires à droite des directives #else et #endif à la colonne n.
    Voir la section COMMENTAIRES.

-cs, --space-after-cast
    Mettre une espace après un opérateur de transtypage.
    Voir la section INSTRUCTIONS.

-dn, --line-comments-indentationn
    Définir l’indentation des commentaires qui ne sont pas à droite du code à n espaces.
    Voir la section COMMENTAIRES.

-bfda, --break-function-decl-args
    Passer à la ligne avant chaque argument d’une déclaration de fonction.
    Voir la section DÉCLARATIONS.

-bfde, --break-function-decl-args-end
    Passer à la ligne après le dernier argument d’une déclaration de fonction.
    Voir la section DÉCLARATIONS.

-dj, --left-justify-declarations
    Si -cd0 est spécifié, les commentaires situés après les déclarations seront alignés à gauche.
    Voir la section DÉCLARATIONS.

-din, --declaration-indentationn
    Placer les variables à la colonne n.
    Voir la section DÉCLARATIONS.

-fc1, --format-first-column-comments
    Commencer les commentaires à la première colonne.
    Voir la section COMMENTAIRES.

-fca, --format-all-comments
    Ne pas désactiver le formatage des commentaires.
    Voir la section COMMENTAIRES.

-fnc, --fix-nested-comments
    Suppression de l’imbrication des commentaires.
    Voir la section COMMENTAIRES.

-gnu, --gnu-style
    Utiliser le style de code GNU. C’est le comportement par défaut.
    Voir la section STYLES COURANTS.

-gts, --gettext-strings
    Traiter les macros _("...") et N_("...") de gettext comme des chaînes, pas comme des fonctions.
    Voir la section COUPURE DES LONGUES LIGNES.

-hnl, --honour-newlines
    Préférer la coupure des longues lignes à la position des caractères nouvelle ligne dans le fichier d’entrée.
    Voir la section COUPURE DES LONGUES LIGNES.

-in, --indent-leveln
    Définir la valeur de l’indentation à n espaces.
    Voir la section INDENTATION.

-iln, --indent-labeln
    Définir l’indentation des étiquettes à la colonne n.
    Voir la section INDENTATION.

-ipn, --parameter-indentationn
    Indenter les types des paramètres dans le vieux style d’écriture des fonctions de n espaces.
    Voir la section INDENTATION.

-kr, --k-and-r-style
    Utiliser le style de code de Kernighan & Ritchie.
    Voir la section STYLES COURANTS.

-ln, --line-lengthn
    Fixer la longueur maximale des lignes autres que les commentaires à n.
    Voir la section COUPURE DES LONGUES LIGNES.

-lcn, --comment-line-lengthn
    Fixer la longueur maximale des lignes de commentaire à n.
    Voir la section COMMENTAIRES.

-linux, --linux-style
    Utiliser le style de code de Linux.
    Voir la section STYLES COURANTS.

-lp, --continue-at-parentheses
    Aligner les lignes coupées sur les parenthèses.
    Voir la section INDENTATION.

-lps, --leave-preprocessor-space
    Conserver l’espace entre le « # » et une directive du préprocesseur.
    Voir la section INDENTATION.

-nlps, --remove-preprocessor-space
    Supprimer l’espace entre le « # » et une directive du préprocesseur.
    Voir la section INDENTATION.

-nbad, --no-blank-lines-after-declarations
    Ne pas insérer de lignes vides après les déclarations.
    Voir la section LIGNES VIDES.

-nbap, --no-blank-lines-after-procedures
    Ne pas insérer de lignes vides après les corps de fonction.
    Voir la section LIGNES VIDES.

-nbbo, --break-after-boolean-operator
    Préférer ne pas couper les longues lignes avant un opérateur booléen.
    Voir la section COUPURE DES LONGUES LIGNES.

-nbc, --no-blank-lines-after-commas
    Ne pas passer à la ligne après une virgule dans les déclarations.
    Voir la section DÉCLARATIONS.

-nbfda, --dont-break-function-decl-args
    Ne pas placer chaque argument d’une fonction sur une ligne séparée lors de sa déclaration.
    Voir la section DÉCLARATIONS.

-ncdb, --no-comment-delimiters-on-blank-lines
    Ne pas mettre les délimiteurs de commentaires « /* » et « */ » sur les lignes vides.
    Voir la section COMMENTAIRES.

-ncdw, --dont-cuddle-do-while
    Ne pas rapprocher le while du « } » précédent dans une boucle do {} while;.
    Voir la section INSTRUCTIONS.

-nce, --dont-cuddle-else
    Ne pas réunir sur une même ligne } et else.
    Voir la section INSTRUCTIONS.

-ncs, --no-space-after-casts
    Ne pas insérer d’espace après un opérateur de transtypage.
    Voir la section INSTRUCTIONS.

-ndjn, --dont-left-justify-declarations
    Traiter les commentaires situés après une déclaration comme ceux situés après les autres instructions.
    Voir la section DÉCLARATIONS.

-nfc1, --dont-format-first-column-comments
    Ne pas débuter les commentaires à la première colonne (comportement par défaut).
    Voir la section COMMENTAIRES.

-nfca, --dont-format-comments
    Ne formater aucun commentaire.
    Voir la section COMMENTAIRES.

-ngts, --no-gettext-strings
    Traiter les macros _("...") et N_("...") de gettext comme des fonctions normales (comportement par défaut).
    Voir la section COUPURE DES LONGUES LIGNES.

-nhnl, --ignore-newlines
    Préférer ne pas couper les longues lignes à la position des caractères nouvelle ligne dans le fichier d’entrée.
    Voir la section COUPURE DES LONGUES LIGNES.

-nip, --no-parameter-indentation
    Pas d’indentation pour les paramètres.
    Voir la section INDENTATION.

-nlp, --dont-line-up-parentheses
    Ne pas aligner les parenthèses.
    Voir la section INSTRUCTIONS.

-npcs, --no-space-after-function-call-names
    Ne pas insérer d’espace après le nom de fonction lors des appels de fonction.
    Voir la section INSTRUCTIONS.

-nprs, --no-space-after-parentheses
    Ne pas insérer d’espace après un « ( » ou avant un « ) ».
    Voir la section INSTRUCTIONS.

-npsl, --dont-break-procedure-type
    Mettre le type d’une fonction sur la même ligne que son nom.
    Voir la section DÉCLARATIONS.

-nsaf, --no-space-after-for
    Ne pas insérer d’espace après for.
    Voir la section INSTRUCTIONS.

-nsai, --no-space-after-if
    Ne pas insérer d’espace après if.
    Voir la section INSTRUCTIONS.

-nsaw, --no-space-after-while
    Ne pas insérer d’espace après while.
    Voir la section INSTRUCTIONS.

-nsc, --dont-star-comments
    Ne pas mettre de « * » à gauche de chaque ligne d’un commentaire multiligne.
    Voir la section COMMENTAIRES.

-nsob, --leave-optional-blank-lines
    Ne pas supprimer les lignes vides facultatives.
    Voir la section LIGNES VIDES.

-nss, --dont-space-special-semicolon
    Ne pas insérer d’espace avant le point-virgule après certaines instructions. Désactive -ss.
    Voir la section INSTRUCTIONS.

-ntac, --dont-tab-align-comments
    Ne pas aligner les commentaires avec le taquet de tabulation le plus proche.
    Voir la section COMMENTAIRES.

-nut, --no-tabs
    Utiliser des espaces à la place des tabulations.
    Voir la section INDENTATION.

-nv, --no-verbosity
    Désactiver le mode prolixe.
    Voir la section OPTIONS DIVERSES.

-orig, --original
    Utiliser le style de code original de Berkeley.
    Voir la section STYLES COURANTS.

-npro, --ignore-profile
    Ignorer les fichiers .indent.pro.
    Voir la section INVOQUER INDENT.

-pal, --pointer-align-left
    Dans une déclaration de pointeur, mettre une espace après l’astérisque et accoler ce dernier au type, comme dans char* p.

-par, --pointer-align-right
    Dans une déclaration de pointeur, mettre une espace avant l’astérisque et accoler ce dernier au nom de la variable, comme dans char * p.

-pcs, --space-after-procedure-calls
    Insérer une espace entre le nom d’une fonction appelée et « ( ».
    Voir la section INSTRUCTIONS.

-pin, --paren-indentationn
    Spécifier l'indentation supplémentaire pour chaque parenthèse ouvrante quand une instruction est coupée sur plusieurs lignes. Voir la section INSTRUCTIONS.

-pmt, --preserve-mtime
    Conserver les dates d’accès et de modification dans les fichiers de sortie. Voir la section OPTIONS DIVERSES.

-ppin, --preprocessor-indentationn
    Spécifier l’indentation pour les directives conditionnelles du préprocesseur. Voir la section INDENTATION.

-prs, --space-after-parentheses
    Insérer une espace après chaque « ( » et avant chaque « ) ».
    Voir la section INSTRUCTIONS.

-psl, --procnames-start-lines
    Mettre le type d’une fonction sur la ligne au-dessus de son nom.
    Voir la section DÉCLARATIONS.

-saf, --space-after-for
    Insérer une espace après chaque for.
    Voir la section INSTRUCTIONS.

-sai, --space-after-if
    Insérer une espace après chaque if.
    Voir la section INSTRUCTIONS.

-sar, --spaces-around-initializers
    Insérer une espace après le « { » et avant le « } » dans les initialiseurs.
    Voir la section DÉCLARATIONS.

-saw, --space-after-while
    Insérer une espace après chaque while.
    Voir la section INSTRUCTIONS.

-sbin, --struct-brace-indentationn
    Spécifier l’indentation des accolades pour struct, union et enum.
    Voir la section INSTRUCTIONS.

-sc, --start-left-side-of-comments
    Ajouter le caractère « * » au début de chaque ligne d’un commentaire multi-lignes.
    Voir la section COMMENTAIRES.

-slc, --single-line-conditionals
    Permettre aux structures conditionnelles (if, else, etc.) sans accolades d’avoir leur bloc d’instructions sur la même ligne.
    Voir la section INSTRUCTIONS.

-sob, --swallow-optional-blank-lines
    Supprimer les lignes vides facultatives.
    Voir la section LIGNES VIDES.

-ss, --space-special-semicolon
    Pour les boucles for et while sur une seule ligne, insérer une espace avant le point virgule.
    Voir la section INSTRUCTIONS.

-st, --standard-output
    Écrire sur la sortie standard.
    Voir la section INVOQUER INDENT.

-T  Indiquer à indent le nom des types définis à l’aide de typedef (voir la section DÉCLARATIONS).
    Voir la section DÉCLARATIONS.

-tsn, --tab-sizen
    Définir la taille d’une tabulation à n espaces.
    Voir la section INDENTATION.

-ut, --use-tabs
    Utiliser les tabulations. C’est le comportement par défaut.
    Voir la section INDENTATION.

-v, --verbose
    Activer le mode prolixe.
    Voir la section OPTIONS DIVERSES.

-version
    Afficher le numéro de version d’indent.
    Voir la section OPTIONS DIVERSES.

INVOQUER INDENT
Depuis la version 1.3, le format de la commande d’invocation d’indent est :
indent [options] [fichiers_entrée]
indent [options] [fichier_entrée_unique] [-o fichier_sortie]
Ce format est différent de celui des versions plus anciennes et d’autres versions d’indent. Sous sa première forme, un ou plusieurs fichiers d’entrée sont spécifiés. indent fait une copie de sauvegarde de chaque fichier et l’original est remplacé par sa version indentée. Voir la section FICHIERS DE SAUVEGARDE pour une explication de la manière dont les sauvegardes sont effectuées. Sous sa seconde forme, un seul fichier d’entrée est spécifié. Dans ce cas, ou lorsque l’entrée standard est utilisée, il est possible de spécifier le nom du fichier de sortie à l’aide de l’option -o. Pour qu’indent écrive sur la sortie standard, utiliser l’option -st. Cela n’est permis que si un seul fichier d’entrée est spécifié ou si l’entrée standard est utilisée. Si aucun fichier d’entrée n’est spécifié, c’est l’entrée standard qui sera utilisée comme entrée. De même, si un fichier d’entrée nommé - est spécifié, c’est l’entrée standard qui sera lue. À titre d’exemple, chacune des commandes suivantes prend en entrée le fichier slithy_toves.c et écrit sa version indentée dans slithy_toves.out.
indent slithy_toves.c -o slithy_toves.out
indent -st slithy_toves.c > slithy_toves.out
cat slithy_toves.c | indent -o slithy_toves.out
La plupart des autres options d’indent permettent de contrôler la manière dont les programmes sont formatés. À partir de la version 1.2, indent reconnaît aussi les options à nom long. Les options à nom long sont préfixées de « -- » ou « + ». [« + » est en cours de remplacement par « -- » pour conserver une compatibilité avec la norme POSIX]. Dans un souci de concision, on utilisera le plus souvent les noms courts traditionnels dans ce document. Voir la section OPTIONS pour une liste des options avec leurs noms courts et leurs noms longs. Voici un autre exemple :
indent -br test/metabolisme.c -l85
Cet exemple indente le fichier test/metabolisme.c en utilisant les options -br et -l85, écrit sa sortie dans test/metabolisme.c et conserve le contenu originel du fichier test/metabolisme.c dans un fichier de sauvegarde dans le répertoire test. Les commandes équivalentes utilisant les noms d’option longs pour cet exemple seraient :
indent --braces-on-if-line --line-length185 test/metabolisme.c
indent +braces-on-if-line +line-length185 test/metabolisme.c
Si vous estimez que vous utilisez souvent indent avec le même ensemble d'options, vous pouvez placer ces dernières dans un fichier nommé .indent.pro. indent recherche le fichier de profil dans trois emplacements. Il va tout d’abord consulter la variable d’environnement INDENT_PROFILE. Si elle est définie, son contenu sera considéré comme le nom du fichier de profil à utiliser. Si elle n’est pas définie, indent recherche le fichier .indent.pro dans le répertoire actuel ; s’il existe, il utilisera son contenu comme nom du fichier de profil à utiliser ; s’il n’existe pas, indent recherche le fichier .indent.pro dans le répertoire personnel de l’utilisateur et s’il existe, utilisera son contenu comme nom du fichier de profil à utiliser. Ce comportement est différent avec les autres versions d’indent qui chargent les deux fichiers s’ils existent tous les deux. Le format du fichier de profil est une simple liste d’options séparées par des blancs (tabulations, espaces et nouvelles lignes), telle qu’elle apparaîtrait sur la ligne de commande. Ces options peuvent être entourées de commentaires de style C ou C++, auquel cas elles seront ignorées. Command line switches are handled after processing ‘ earlier, with one exception: Explicitly specified options always override background options (See COMMON STYLES). You can prevent indent from reading an ‘.indent.pro’ file by specifying the ‘-npro’ option.

FICHIERS DE SAUVEGARDE
À partir de la version 1.3, GNU indent génère des fichiers de sauvegarde dans le style GNU, comme le fait GNU emacs(1). Autrement dit, il est possible de faire des sauvegardes simples ou numérotées. Les noms de fichier de sauvegarde simple sont générés en ajoutant un suffixe au nom de fichier originel, par défaut un tilde (« ~ »). Ainsi, le fichier de sauvegarde pour python.c sera python.c~. Pour définir un suffixe différent du suffixe par défaut, il suffit de définir la variable d’environnement SIMPLE_BACKUP_SUFFIX avec le suffixe souhaité. Les sauvegardes numérotées du fichier python.c ressembleront à python.c.~23~, où 23 est le numéro de version de cette sauvegarde. Lorsqu’on effectue une sauvegarde numérotée de src/python.c, elle est nommée src/python.c.~V~, où V est supérieur de 1 à la plus haute version qui existe dans le répertoire src. La variable d'environnement VERSION_WIDTH permet d'indiquer le nombre de chiffres que comporte le numéro de version ; des zéros seront insérés à gauche pour compléter si nécessaire. Si cette variable a pour valeur 2, par exemple, les fichiers ressembleront à python.c.~04~. Le type de fichier de sauvegarde est contrôlé par la valeur de la variable d’environnement VERSION_CONTROL. Si cette dernière contient la chaîne « simple », seules des sauvegardes simples seront effectuées. Si elle contient la chaîne « numbered », des sauvegardes numérotées seront effectuées. Si elle contient la chaîne « numbered-existing », des sauvegardes numérotées seront effectuées s’il existe déjà des sauvegardes numérotées pour le fichier en cours d’indentation ; dans le cas contraire, une sauvegarde simple sera effectuée. Si VERSION_CONTROL n’est pas définie, indent se comporte comme si elle contenait la chaîne « numbered-existing ». Les autres versions d’indent utilisent le suffixe « .BAK » pour nommer les fichiers de sauvegarde. Ce comportement peut être adopté en donnant à la variable d’environnement SIMPLE_BACKUP_SUFFIX la valeur « .BAK ». Notez aussi que les autres versions d’indent effectuent les sauvegardes dans le répertoire actuel, au lieu de les effectuer dans le répertoire qui contient le fichier source, comme le fait la version actuelle de GNU indent.

STYLES COURANTS
Il existe plusieurs styles courants de code en C, dont le style GNU, le style Kernighan & Ritchie et le style Berkeley. Un style peut être défini par une seule option « globale » qui spécifie un ensemble de valeurs pour toutes les autres options. Cependant, les options explicites priment toujours sur celles définies par l’option globale. À partir de la version 1.2, le style par défaut de GNU indent est le style GNU. Il n’est donc plus nécessaire de spécifier l’option -gnu pour utiliser ce style, bien que cela ne causerait pas d’erreur. Les options qui correspondent au style GNU sont :
-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 préféré du projet GNU. C'est celui que GNU Emacs encourage à utiliser pour son mode C, et qui est utilisé dans les portions en C de GNU Emacs (les personnes intéressées par le développement de programmes pour le projet GNU peuvent obtenir une copie de « The GNU Coding Standards », qui traite aussi les problèmes de sémantique et de portabilité, comme les questions touchant à l’utilisation de la mémoire, la taille des entiers, etc.). Le style Kernighan & Ritchie est utilisé tout au long de leur fameux livre « The C Programming Language ». Il est activé à l’aide de l’option -kr et correspond à l’ensemble d’options suivant :
-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 -par
Le style Kernighan & Ritchie ne place pas systématiquement les commentaires à droite du code à la même colonne (de même, il n’insère pas une espace unique à la droite du code). La colonne 33 a donc été arbitrairement choisie. Le style de la version originelle de Berkeley indent peut être spécifié à l’aide de l’option -orig (ou --original dans son format long). Il correspond aux options suivantes :
-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
Le style Linux est utilisé dans le code du noyau et les pilotes de Linux. Pour être accepté, le code doit en général respecter le style de code de Linux. Ce style correspond aux options suivantes :
-nbad -bap -nbc -bbo -hnl -br -brs -c33 -cd33 -ncdb -ce -ci4
-cli0 -d0 -di1 -nfc1 -i8 -ip0 -l80 -lp -npcs -nprs -npsl -sai
-saf -saw -ncs -nsc -sob -nfca -cp33 -ss -ts8 -il1

LIGNES VIDES
Les différents styles de programmation insèrent çà et là des lignes vides. indent possède plusieurs options permettant d’insérer ou supprimer des lignes vides à des emplacements spécifiques. L’option -bad provoque l’ajout d’une ligne vide après chaque bloc de déclarations. Avec l’option -nbad, cet ajout n'est pas effectué. L’option -bap provoque l’ajout d’une ligne vide après chaque corps de fonction. Avec l’option -nbap, cet ajout n'est pas effectué. L’option -bbb provoque l’ajout d’une ligne vide avant chaque bloc de commentaire (voir la section COMMENTAIRES). Avec l’option -nbbb, cet ajout n'est pas effectué. L’option -sob provoque la suppression de toutes les lignes vides facultatives (cela signifie que toute ligne vide facultative présente dans l’entrée sera supprimée dans la sortie). Avec l’option -nsob, toutes les lignes vides présentes dans le fichier d'entrée seront copiées dans le fichier de sortie.

--blank-lines-after-declarations
L’option -bad provoque l’ajout d’une ligne vide après chaque bloc de déclarations. Avec l’option -nbad, cet ajout n'est pas effectué. Par exemple, considérons l’entrée
char *toto;
char *titi;
/* Séparation entre deux blocs de déclarations.  */
int baz;
indent -bad produira
char *toto;
char *titi;
/* Séparation entre deux blocs de déclarations.  */
int baz;
et indent -nbad produira
char *toto;
char *titi;
/* Séparation entre deux blocs de déclarations.  */
int baz;

--blank-lines-after-procedures
L’option -bap provoque l’ajout d’une ligne vide après chaque corps de fonction. Par exemple, considérons l’entrée
int
toto ()
{
  puts("Salut");
}
/* La fonction titi est encore moins intéressante.  */
char *
titi ()
{
  puts("Bonjour");
}
indent -bap produira
int
toto ()
{
  puts ("Salut");
}
/* La fonction titi est encore moins intéressante.  */
char *
titi ()
{
  puts ("Bonjour");
}
et indent -nbap produira
int
toto ()
{
  puts ("Salut");
}
/* La fonction titi est encore moins intéressante.  */
char *
titi ()
{
  puts ("Bonjour");
}
Aucune ligne vide ne sera ajoutée après la fonction toto.

COMMENTAIRES
indent formate les commentaires C et C++. Les commentaires C commencent par « /* », se terminent par « */ », et peuvent contenir des caractères nouvelle ligne. Les commentaires C++ commencent par le délimiteur « // » et se terminent au caractère nouvelle ligne. indent traite les commentaires en fonction de leur contexte. Il s’efforce de distinguer les commentaires qui suivent une instruction, une déclaration ou une directive du préprocesseur, et les commentaires qui ne sont précédés d’aucun code, c’est-à-dire qui commencent au début d’une ligne (et pas nécessairement en colonne 1). indent fait aussi la différence entre les commentaires situés à l’intérieur de fonctions et de blocs et ceux qui ne le sont pas. En particulier, ceux qui commencent une ligne à l’intérieur d'une fonction seront indentés à la colonne où le code est actuellement indenté. Une exception est faite si un commentaire commence à la colonne la plus à gauche, auquel cas il restera à la même place. indent s’efforce de laisser les commentaires sous forme de boîte inchangés. Ce type de commentaire est entouré d’un rectangle (ou « boîte ») délimité par des astérisques ou par des tirets pour l’isoler et le mettre en valeur. Plus précisément, les commentaires sous forme de boîte sont ceux dont le délimiteur initial « /* » est suivi immédiatement de caractères « * », « = », « _ » ou « - », ou ceux dont le délimiteur initial « /* » occupe une ligne à lui seul et dont les lignes suivantes commencent par un astérisque sur la même colonne que le délimiteur initial. Exemples de commentaires sous forme de boîte :
/*********************************
 * Commentaire dans une boîte !! *
 *********************************/
       /*
        * Une présentation différente,
        * pour une autre sorte de commentaire.
        */
indent s’efforce de garder intacte la forme qu’ont les commentaires sous forme de boîte dans le fichier source. Ainsi, leur indentation reste inchangée et leur longueur n’est pas vérifiée. La seule modification qu’ils peuvent subir est la conversion des tabulations qu’ils pourraient contenir en un nombre approprié d’espaces. Si l’option -bbb est spécifiée, tout commentaire sous forme de boîte sera précédé d’une ligne vide, sauf si du code le précède. Les commentaires qui n’ont pas cette forme seront formatés, c’est-à-dire que la ligne est brisée pour s’aligner sur la marge de droite et remplie d’espaces à gauche. Un simple saut de ligne sera considéré comme une espace, mais une ligne vide (deux caractères nouvelle ligne ou plus dans une ligne) sera considérée comme un changement de paragraphe. Le formatage des commentaires qui commencent après la première colonne est activé à l’aide de l'option -fca. Pour formater ceux qui commencent à la première colonne, utiliser l'option -fc1. Ces formatages sont désactivés par défaut. La marge de droite pour le formatage est par défaut à la colonne 78, mais peut être modifiée à l’aide de l’option -lc. Si celle-ci ne permet pas l’affichage d’un commentaire, elle sera modifiée en conséquence et uniquement pour ce commentaire. La marge n’est pas respectée si le commentaire n’est pas formaté. Si l’option -fnc est spécifiée, tous les commentaires contenant la séquence de caractères « /* » verront cette dernière remplacée par une espace suivie d’un astérisque, éliminant de ce fait l’imbrication de commentaires. Si un commentaire commence une ligne (c'est-à-dire s'il n’y a pas de code à sa gauche), il est indenté à la colonne à laquelle il a été trouvé, sauf s’il se trouve à l’intérieur d’un bloc de code, auquel cas il sera aligné avec le code indenté de ce bloc (sauf s’il commence à la première colonne). Cet alignement peut être modifié à l’aide de l’option -d qui spécifie le nombre de colonnes dont le commentaire sera décalé vers la gauche par rapport au code, ou « désindenté ». Par exemple, -d2 place les commentaires deux colonnes à gauche du code. Par défaut, les commentaires sont alignés avec le code, sauf s’ils commencent à la première colonne, auquel cas ils sont laissés à cette place ; pour forcer l’alignement des commentaires avec le code, utiliser l’option -fc1. Les commentaires situés à droite du code sont placés par défaut à la colonne 33. Ce comportement peut être modifié à l’aide d’une des trois options suivantes : -c spécifie la colonne à laquelle seront placés les commentaires qui suivent du code, -cd celle à laquelle seront placés les commentaires qui suivent une déclaration et -cp celle à laquelle seront placés les commentaires qui suivent une directive du préprocesseur #else ou #endif. Pour supprimer l’alignement des commentaires à la droite des déclarations et les placer à une tabulation de la fin de ces dernières, utiliser les options -dj et -cd0 en combinaison. Normalement, -cd0 rend effective -c. Si le code à gauche d’un commentaire dépasse la colonne à laquelle le commentaire commence, ce dernier sera déplacé à la première tabulation après le code, sauf si l’option -ntac a été spécifiée. Dans le cas d’une directive du préprocesseur, le commentaire sera placé une espace après la fin de cette directive. Ce déplacement n’est valable que pour ce type de commentaire. L’option -cdb place les délimiteurs de commentaire sur des lignes vides. Ainsi le commentaire sur une seule ligne /* Un câlin affectueux */ deviendra :
/*
   Un câlin affectueux
 */
L’option -sc permet de placer des astérisques au début de chaque ligne d’un commentaire multiligne. Le commentaire sur une seule ligne précédent devient alors (avec -cdb -sc) :
/*
 * Un câlin affectueux
 */

INSTRUCTIONS
Les options -br et -bl spécifient la manière dont devront être présentées les accolades. L’option -br les présente de la manière suivante :
if (x > 0) {
  x--;
}
L’option -bl les présente de la manière suivante :
if (x > 0)
  {
    x--;
  }
La combinaison des options -bl et -bli permet de spécifier le nombre d'espaces dont les accolades doivent être indentées. La valeur par défaut est 2 et elle donne pour résultat l’exemple précédent. -bli0 donne le résultat suivant :
if (x > 0)
{
  x--;
}
La combinaison des options -br et -ce place le else d’une structure conditionnelle if-then-else une espace après l’accolade fermante qui le précède. Par exemple, avec -br -ce, on obtient :
if (x > 0) {
  x--;
} else {
  fprintf (stderr, "... un problème ?\n");
}
Avec -br -nce, on obtiendra :
if (x > 0) {
  x--;
}
else {
  fprintf (stderr, "... un problème ?\n");
}
La présence d’un commentaire entre l’accolade fermante et le else qui suit constitue un cas particulier : si l’option -br fait qu’une accolade ouvrante passe par dessus le commentaire, le else ne passera pas par dessus le commentaire pour l’entourer car il y a un forte probabilité qu’il modifie la signification de ce commentaire. L’option -cdw place le while d’une boucle do-while une espace après l’accolade qui le précède ; par exemple, avec -cdw, on obtient :
do {
  x--;
} while (x);
Avec -ncdw, on obtient :
do {
  x--;
}
while (x);
L’option -slc permet d’autoriser les structures conditionnelles sans accolade et de placer les instructions qu’elles contiennent sur la même ligne. Par exemple :
if (x) x--;
else x++;
Sans l’option -slc, on aurait obtenu :
if (x)
  x--;
else
  x++;
L’option -cli permet de spécifier le nombre d'espaces dont les étiquettes case doivent être indentées vers la droite de l’instruction switch. Par défaut, le code se présente comme suit :
switch (i)
  {
  case 0:
    break;
  case 1:
    {
      ++i;
    }
  default:
    break;
  }
En utilisant l’option -cli2, il devient :
switch (i)
  {
    case 0:
      break;
    case 1:
      {
        ++i;
      }
    default:
      break;
  }
L’indentation des accolades englobant le code associé à une étiquette case peut être définie à l’aide de l’option -cbin. Par exemple, avec les options -cli2 -cbi0, le code précédent devient :
switch (i)
  {
    case 0:
      break;
    case 1:
    {
      ++i;
    }
    default:
      break;
  }
Si un point-virgule est sur la même ligne qu’une instruction for ou while, l’option -ss placera une espace avant ce point-virgule. Cela permet de mettre en évidence le point-virgule, et montre clairement que la boucle for ou while ne contient aucune instruction. L’option -nss désactive cette fonctionnalité. L’option -pcs permet de placer une espace entre le nom d’une fonction appelée et le « ( » (par exemple, puts ("OK");). L’option -npcs supprime cette espace, si elle existe (par exemple, puts("OK");). L’option -cs permet de placer une espace entre un opérateur de transtypage et l’objet de ce transtypage. L’option -ncs permet de supprimer cette espace, si elle existe. Gardez à l’esprit qu’indent ne connaît que les types de données standards du C et ne reconnaît donc pas les types définis par l’utilisateur dans les transtypages. Par exemple, (mon_type)var ne sera pas traité en tant que transtypage. L’option -bs permet de placer une espace entre sizeof et son argument. Dans certaines versions, cette option est appelée l’option de « Bill_Shannon ». L’option -saf permet de placer une espace entre un for et la parenthèse qui le suit. C’est le comportement par défaut. L’option -sai permet de placer une espace entre un if et la parenthèse qui le suit. C’est le comportement par défaut. L’option -saw permet de placer une espace entre un while et la parenthèse qui le suit. C’est le comportement par défaut. L’option -prs permet de placer une espace entre des parenthèses et ce qu'elles entourent. Voici un exemple de code modifié par cette option :
  while ( ( e_code - s_code ) < ( dec_ind - 1 ) )
    {
      set_buf_break ( bb_dec_ind );
      *e_code++ = ’ ’;
    }

DÉCLARATIONS
Par défaut, indent aligne les identificateurs à la colonne spécifiée par l’option -di. Par exemple, -di16 donnera :
int             un_entier;
char           *un_caractère;
Pour que les identificateurs soient placés à la première position disponible en partant de la gauche, il faut spécifier une petite valeur pour l’option -di (un ou deux) ; par exemple :
int un_entier;
char *un_caractère;
La valeur donnée à l’option -di affecte aussi les variables dont le nom est placé sur une ligne différente de celle du type ; par exemple, -di2 donne :
int
  un_entier;
L’option -bc force un passage à la ligne après chaque virgule dans une déclaration, comme dans cet exemple :
int a,
  b,
  c;
Avec l’option -nbc l’exemple précédent devient :
int a, b, c;
L’option -bfda force un passage à la ligne après chaque virgule séparant les arguments dans la déclaration d'une fonction. Ceux-ci apparaîtront à une profondeur d'indentation immédiatement supérieure à celle de la déclaration de la fonction. Cela s’avère utile pour les fonctions qui possèdent de nombreux arguments. L’option -bfde force un passage à la ligne avant la parenthèse fermante d’une déclaration de fonction. Les options -nbdfa et -nbdfe sont les négations des options -bfda et -bfde ; elles correspondent au comportement par défaut. Par exemple,
void une_fonction (int arg1, char arg2, int *arg3, long arg4, char arg5);
apparaîtra comme suit avec l’option -bfda :
void une_fonction (
    int arg1,
    char arg2,
    int *arg3,
    long arg4,
    char arg5);
et si on ajoute l’option -bfde :
void une_fonction (
    int arg1,
    char arg2,
    int *arg3,
    long arg4,
    char arg5
    );
Lors d’une déclaration de fonction, l’option -psl place son type sur la ligne précédant son nom. Ce style est requis par le programme etags(1) pour qu’il puisse fonctionner correctement, ainsi que pour certaines fonctions du mode c-mode 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ée plusieurs fois, et tous les noms spécifiés sont utilisés. Par exemple si votre programme contient :
typedef unsigned long ADRESSE_CODE;
typedef enum {rouge, bleu, vert} COULEUR;
vous utiliserez les options -T ADRESSE_CODE -T COULEUR Les options -brs et -bls permettent de spécifier la manière de présenter les accolades dans une déclaration de structure. L’option -brs les présente ainsi :
struct ma_struct {
  int x;
};
alors que l’option -bls les présente ainsi :
struct ma_struct
{
  int x;
};
De manière similaire, les options -brf et -blf permettent de
 spécifier la manière de présenter les accolades dans la définition d’une
 fonction. L’option -brf les présente ainsi :
int renvoie_un(void) {
  return 1;
};
alors que l’option -blf les présente ainsi :
int renvoie_un(void)
{
  return 1;
};
L’option -sar affecte la manière dont indent va présenter les listes d’initialiseurs. Sans l’option -sar, elles sont présentées comme ceci :
int a[] = {1, 2, 3, 4};
struct s {
  const char *nom;
  int x;
} a[] = {
  {"un_nom", 0},
  {"autre_nom", 1}
};
Avec l’option -sar, elles sont présentées comme ceci (avec des espaces entre les accolades et leur contenu) :
int a[] = { 1, 2, 3, 4 };
struct s {
  const char *nom;
  int x;
} a[] = {
  { "un_nom", 0 },
  { "autre_nom", 1 }
};

INDENTATION
Le sujet le plus basique et le plus controversé à propos du formatage du code est précisément la manière dont l’indentation doit être effectuée. Heureusement, indent prend en charge plusieurs styles d’indentation différents. Le comportement par défaut, aussi défini à l’aide de l’option -ut, consiste à utiliser des tabulations pour l’indentation. En supposant qu’une tabulation équivaut à 8 espaces, le code ressemble à ceci :
int a(int b)
{
        return b;
|------|
 1 tab
}
Pour celles et ceux qui préfèrent les espaces aux tabulations, indent propose l’utilisation de l’option -nut. Le code ressemble alors à ceci :
int a(int b)
{
        return b;
|------|
8 espaces
}
Un autre sujet à propos du formatage du code est le nombre de colonnes dont chaque ligne doit être indentée par rapport à la marge de gauche. Lorsque le début d’une instruction telle que if ou for est rencontré, le niveau d’indentation est augmenté selon un pas déterminé par la valeur spécifiée à l’aide de l’option -i. Par exemple, spécifier -i8 définit un pas d’indentation de 8 caractères pour chaque niveau. Quand une instruction est répartie sur deux lignes, la seconde ligne est indentée d’un nombre d’espaces supplémentaires spécifié à l’aide de l’option -ci dont la valeur par défaut est 0. Cependant, si l’option -lp est spécifiée et si une ligne contient une parenthèse ouvrante mais pas la parenthèse fermante correspondante, les lignes suivantes seront alignées avec le caractère situé juste après la parenthèse ouvrante. Cette règle s’applique aussi aux crochets « [ » et aux accolades « { » (au sein des listes d’initialisation dans ce dernier cas). Par exemple, une portion de code peut ressembler à ceci si les options -nlp et -ci3 sont spécifiées :
  p1 = fonction1 (fonction2 (p2, p3),
     fonction3 (p4, p5));
Avec l’option -lp, le code semble plus clair :
  p1 = fonction1 (fonction2 (p2, p3),
                  fonction3 (p4, p5));
Lorsqu’une instruction est coupée entre deux paires de parenthèses ou plus (...), chaque paire supplémentaire implique un niveau d’indentation supplémentaire :
if ((((i < 2 &&
        k > 0) || p == 0) &&
    q == 1) ||
  n = 0)
L’option -ipN permet de spécifier l’indentation supplémentaire par parenthèse. Avec -ip0, le code précédent devient :
if ((((i < 2 &&
  k > 0) || p == 0) &&
  q == 1) ||
  n = 0)
indent suppose que les tabulations sont placées à intervalles réguliers dans les flux d’entrée et de sortie de caractères. La valeur de ces intervalles est de 8 espaces par défaut, mais peut être modifiée à l’aide de l’option -ts (depuis la version 1.2). Les tabulations sont traitées comme leur quantité équivalente d’espaces. Par défaut et autant que possible, indent utilise des tabulations pour l’indentation, et fait l’appoint avec des espaces jusqu’à ce que la position souhaitée soit atteinte. Cependant, si l’option -as est spécifiée, des espaces seront utilisées pour l’alignement au delà du niveau d’indentation actuel. Par défaut, en supposant que l’option -lp a été spécifiée, le code sera indenté de la manière suivante (« t » représente une tabulation et « e » une espace) :
unsigned long nom_fonction_très_long(unsigned long x, unsigned long y,
                                     int a)
|------||-------||------||-------|___
   t        t       t       t     eee
{
        p1 = fonction_alpha (fonction_beta (p2, p3),
                             fonction_gamma (p4, p5));
|------||------||------|_____
   t       t       t    eeeee
}
Cela est correct si l’on considère que tout lecteur de ce code utilise aussi des tabulations de 8 espaces. S’il utilise des tabulations de 5 espaces, le code ressemble à ceci :
unsigned long nom_fonction_très_long(unsigned long x, unsigned long y,
                       int a)
|---||---||---||---|___
  t    t    t    t  eee
{
        p1 = fonction_alpha (fonction_beta (p2, p3),
                    fonction_gamma (p4, p5));
|---||---||---|_____
  t    t    t  eeeee
}
L’option -as permet de résoudre ce problème en corrigeant le code de façon que le résultat soit correct quelle que soit la taille de tabulation utilisée pour lire le code. Ce dernier devient alors :
unsigned long nom_fonction_très_long(unsigned long x, unsigned long y,
                                     int a)
_____________________________________
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
{
        p1 = fonction_alpha (fonction_beta (p2, p3),
                             fonction_gamma (p4, p5));
|------|_____________________
   t    eeeeeeeeeeeeeeeeeeeee
}
L’indentation des déclarations de type dans l’ancien style des définitions de fonction est sélectionnée à l’aide de l’option -ip. C’est une option possédant un argument numérique permettant de spécifier le nombre d’espaces dont doivent être indentées les déclarations de type. Par exemple, l’option -ip5 (valeur par défaut) donne aux définitions l’aspect suivant :
char *
créer_le_monde (x, y, echelle)
     int x;
     int y;
     float echelle;
{
  . . .
}
L’option -nip, équivalente à -ip0, est fournie à des fins de compatibilité avec les autres versions d’indent. ANSI C autorise l’insertion d’une espace dans les directives du préprocesseur entre le caractère « # » et le nom de la directive. Par défaut, indent supprime cette espace, mais avec l’option -lps, il la conserve. L’option -ppi l’emporte sur -nlps et -lps. Cette option fait que les directives conditionnelles du préprocesseur sont indentées du nombre d’espaces donné ; par exemple, avec l’option -ppi3,
#if X
#if Y
#define Z 1
#else
#define Z 0
#endif
#endif
devient
#if X
#   if Y
#      define Z 1
#   else
#      define Z 0
#   endif
#endif
Cette option permet de définir l’indentation des étiquettes (sauf les étiquettes case). Si elle a pour argument 0 ou un nombre positif, ce dernier indique à quelle distance de la marge de gauche devra être indentée une étiquette. Si elle a pour argument un nombre négatif, ce dernier indique la valeur à retrancher du niveau d’indentation actuel pour placer l’étiquette. La valeur par défaut est -2, ce qui correspond au comportement des versions précédente d’indent. Notez que cette option n’affecte pas le placement des étiquettes case ; voir l’option -cli pour le placement de ces dernières. Par exemple, avec l’option -il1,
group
fonction()
{
    if (action1() == ERROR)
        goto nettoyage1;
    if (action2() == ERROR)
        goto nettoyage2;
    return SUCCESS;
  nettoyage2:
    do_nettoyage2();
  nettoyage1:
    do_nettoyage1();
    return ERROR;
}
devient
group
fonction()
{
    if (action1() == ERROR)
        goto nettoyage1;
    if (action2() == ERROR)
        goto nettoyage2;
    return SUCCESS;
 nettoyage2:
    do_nettoyage2();
 nettoyage1:
    do_nettoyage1();
    return ERROR;
}

COUPURE DES LONGUES LIGNES
L’option -ln (ou --line-lengthn) permet de spécifier la longueur maximale d’une ligne de code C, les éventuels commentaires qui pourraient la suivre non compris. Si une ligne est plus longue que cette valeur limite, GNU indent essaie de couper la ligne à un endroit approprié. Cette fonctionnalité, qui n’est encore ni très astucieuse ni très flexible, est une nouveauté de la version 2.1. Trois options permettent pour l’instant d’interférer avec l’algorithme qui détermine à quel endroit couper une ligne. Avec l’option -bbo, GNU indent préfère couper la ligne avant les opérateurs booléens « && » et « || ». Avec l’option -nbbo il n’a pas cette préférence. Par exemple, avec l’option par défaut -bbo (en combinaison avec les options --line-length60 et --ignore-newlines), le code ressemble à ceci :
  if (masque
      && ((masque[0] == ’\0’)
          || (masque[1] == ’\0’
              && ((masque[0] == ’0’) || (masque[0] == ’*’)))))
Avec l’option -nbbo, il ressemble à ceci :
  if (masque &&
      ((masque[0] == ’\0’) ||
       (masque[1] == ’\0’ &&
        ((masque[0] == ’0’) || (masque[0] == ’*’)))))
L’option par défaut -hnl, quant à elle, respecte les sauts de ligne du fichier d'entrée en leur donnant la priorité la plus haute pour la coupure de ligne. Ainsi, si le fichier d'entrée contient :
  if (masque
      && ((masque[0] == ’\0’)
      || (masque[1] == ’\0’ && ((masque[0] == ’0’) || (masque[0] == ’*’)))))
utiliser l’option -hnl ou --honour-newlines en combinaison avec les options -nbbo et --line-length60 déjà mentionnées fait que la sortie ne correspond pas à ce que montre le dernier exemple, mais préfère couper la ligne aux endroits indiqués dans le fichier d’entrée :
  if (masque
      && ((masque[0] == ’\0’)
          || (masque[1] == ’\0’ &&
              ((masque[0] == ’0’) || (masque[0] == ’*’)))))
L’idée derrière cette option est qu’une ligne trop longue, mais qui a déjà été coupée, ne sera pas modifiée par GNU indent. Un code d’aspect très confus devrait tout de même être soumis à indent au moins une fois en utilisant l’option --ignore-newlines. L’option -gts affecte la manière dont les macros standards de gettext(1) _() et N_() sont traitées. Le comportement par défaut (ou l’utilisation de l’option -ngts) consiste à les traiter comme le fait indent avec les autres fonctions ; ainsi, une longue chaîne sera coupée comme dans l’exemple suivant :
  if (masque)
    {
      avertissement (_
               ("Ceci est une longue chaîne qui reste en un seul morceau."));
    }
Avec l’option -gts, le caractère de soulignement est traité comme associé à la chaîne en le plaçant tout contre cette dernière et en respectant le fait que gettext(1) fournit discrètement une chaîne régionalisée. Cette option ne fonctionne que si « _(" » est en un seul morceau en début de chaîne, ainsi que « ") » à la fin de cette dernière.
  if (masque)
    {
      avertissement
        (_("Ceci est une longue chaîne qui reste en un seul morceau."));
    }

DÉSACTIVATION DU FORMATAGE
Le formatage du code C peut être désactivé pour certaines portions de programme en y plaçant des commentaires de contrôle. Pour désactiver le formatage d’une section de programme, placer le commentaire de contrôle de désactivation /* *INDENT-OFF* */ tout seul sur une ligne, juste avant la section concernée. Le texte du programme entre ce commentaire de contrôle et le prochain commentaire de contrôle d’activation sera envoyé en sortie sans aucune modification. Le commentaire de contrôle d’activation est /* *INDENT-ON* */, et tout code qui suit ce commentaire sur la même ligne sera encore envoyé sur la sortie sans modification. Le formatage est réactivé à partir de la ligne qui suit le commentaire de contrôle d’activation. Plus précisément, indent n’essaie pas de vérifier le délimiteur fermant (« */ ») pour ces commentaires C, et tout espace sur la ligne est totalement transparent. Ces commentaires de contrôle fonctionnent aussi dans leur format C++, à savoir // *INDENT-OFF* et // *INDENT-ON*. Il est à noter que l’état interne d’indent reste inchangé lors du parcours d’une section pour laquelle le formatage est désactivé. Ainsi par exemple, la désactivation du formatage au beau milieu d’une fonction et sa réactivation après la fin de la fonction peut donner un résultat inattendu. Il est donc conseillé de s’en tenir à une certaine modularité en sélectionnant le code ne devant pas être formaté. À titre historique, notez que certaines versions antérieures d’indent généraient leurs messages d’erreur préfixés par *INDENT**. Ces versions d’indent ont été conçues pour ignorer toute ligne de texte en entrée qui commençait par de tels messages d’erreur. J’ai supprimé cette fonctionnalité incestueuse dans GNU indent.

OPTIONS DIVERSES
Pour obtenir la version d’indent installée, utilisez la commande indent -version. Elle vous indiquera le numéro de version d’indent et n’effectuera aucun traitement. L’option -v permet d’activer le mode prolixe. Dans ce mode, indent génère une notification lorsqu’il coupe une ligne d’entrée en deux lignes ou plus en sortie, et fournit certaines statistiques de taille en fin de traitement. Avec l’option -pmt, indent conserve les horodatages d’accès et de modification dans les fichiers de sortie. Utiliser cette option a pour avantage qu’exécuter indent sur tous les fichiers source et d’en-tête d’un projet ne nécessitera pas pour make(1) de reconstruire toutes les cibles. Cette option n’est disponible que sur les systèmes d’exploitation qui fournissent la fonction POSIX utime(2).

BOGUES
Veuillez envoyer tout rapport de bogue à bug-indent@gnu.org. Si indent est lancé deux fois de suite sur le même fichier avec le même profil, il ne devrait jamais faire de modification lors du deuxième passage. Avec la structure actuelle d'indent, cela ne peut pas être garanti et n'a pas été testé de manière approfondie. indent ne comprend pas le C. Dans certains cas, cela peut l’empêcher de relier des lignes, ce qui a pour conséquence que l’effet d’indent sur un fichier est irréversible, même si le fichier d’entrée utilisé est le résultat de l’exécution d’indent avec un profil donné (.indent.pro). Bien qu'un effort ait été fourni pour faire fonctionner indent avec C++, il ne fera pas du bon travail sur du code source en C++, sauf s’il est très simple. 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 sur la première ligne de la coupure. indent ne compte ni 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 /*CAPITALE*/ ne sont pas traités comme des commentaires mais comme des identifiants, et sont de ce fait réunis à la ligne suivante. Cela rend les commentaires de ce type inutiles, sauf s'ils sont intégrés en début de code.

COPYRIGHT
La note de copyright suivante s’applique au programme indent. Les permissions de copie et le copyright pour ce manuel apparaissent vers le début de indent.texinfo et indent.info et vers la fin de indent.1.
Copyright (c) 2015 Tim Hentenaar.
Copyright (c) 2001 David Ingamells.
Copyright (c) 1999 Carlo Wood.
Copyright (c) 1995, 1996 Joseph Arceneaux.
Copyright (c) 1989, 1992, 1993, 1994, 1995, 1996, 2014 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.
Tous droits réservés.
La redistribution et l’utilisation en version source et
binaire sont permises, à la condition que la note de copyright
ci-avant et ce paragraphe soient copiés sous ces deux versions et
que toute documentation, matériels publicitaires et autres concernant
cette distribution et cette utilisation mentionnent que le logiciel
a été développé par l’Université de Californie, Berkeley, l’Université
de l’Illinois, Urbana et Sun Microsystems, Inc. Les noms de ces
Universités ou Sun Microsystems ne peuvent pas être utilisés pour
approuver ou promouvoir des produits dérivés de ce logiciel sans
autorisation écrite préalable spécifique.
CE LOGICIEL EST FOURNI « TEL QUEL » ET SANS AUCUNE GARANTIE EXPRESSE
OU IMPLICITE, Y COMPRIS, SANS LIMITATION, LES GARANTIES IMPLICITES DE
QUALITÉ MARCHANDE ET D'ADÉQUATION À UN USAGE PARTICULIER.

Table de correspondance entre les deux formats d’option
Voici une liste des options par ordre alphabétique des noms d’option longs, associés à leur version courte.
--align-with-spaces                             -as
--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
--braces-after-func-def-line                    -blf
--brace-indent                                  -bli
--braces-after-struct-decl-line                 -bls
--braces-on-if-line                             -br
--braces-on-func-def-line                       -brf
--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-left-justify-declarations                -ndj
--dont-space-special-semicolon                  -nss
--dont-star-comments                            -nsc
--dont-tab-align-comments                       -ntac
--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-label                                  -iln
--indent-level                                  -in
--k-and-r-style                                 -kr
--leave-optional-blank-lines                    -nsob
--leave-preprocessor-space                      -lps
--left-justify-declarations                     -dj
--line-comments-indentation                     -dn
--line-length                                   -ln
--linux-style                                   -linux
--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
--preprocessor-indentation                      -ppin
--procnames-start-lines                         -psl
--remove-preprocessor-space                     -nlps
--single-line-conditionals                      -slc
--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
--spaces-around-initializers                    -sar
--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

VALEUR RENVOYÉE

–   0 signifie qu’aucune erreur n’est survenue et qu’aucun avertissement n’a été émis lors d’une invocation avec succès de ce programme.

–   2 est renvoyé si des erreurs sont survenues pendant le formatage sans empêcher son achèvement, mais qui sont probablement dues à du code incorrect (c’est-à-dire dont la compilation échouerait).

–   3 est renvoyé si le formatage d’un fichier est stoppé à cause d’une erreur avec le fichier qui empêche l’achèvement du formatage. Si plusieurs fichiers d’entrée ont été spécifiés, indent continue son traitement avec le fichier suivant.

–   4 est renvoyé si un problème interne sérieux est survenu ; le processus indent est alors terminé, même si tous les fichiers spécifiés n’ont pas été traités.

–   64 est renvoyé si un problème d’invocation (comme une option non valable) empêche tout processus de formatage.

FICHIERS
$HOME/.indent.pro	contient les options par défaut pour indent.

AUTEURS
Tim Hentenaar
Carlo Wood
Joseph Arceneaux
Jim Kingdon
David Ingamells

HISTORIQUE
Dérivé du programme indent de l’UCB.

COPIE
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 2014, 2015 Free Software Foundation, Inc. Copyright (C) 1995, 1996 Joseph Arceneaux. Copyright (C) 1999 Carlo Wood. Copyright (C) 2001 David Ingamells. Copyright (C) 2013 Łukasz Stelmach. Copyright (C) 2015 Tim Hentenaar. Effectuer et distribuer des copies conformes de ce manuel est autorisé à condition que la note de copyright et cette note de permission soient présentes dans chaque copie.

TRADUCTION
La traduction française de cette page de manuel a été créée par Lucien Gentis <lucien.gentis@univ-lorraine.fr>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 (https://www.gnu.org/licenses/gpl-3.0.html) concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à debian-l10n-french@lists.debian.org.