indent − indente un programme C, ou change son style.

indent [options] [fichiers]

indent [options] [fichier] [−o fichier]

indent −−version

Cette page de man est générée à partir du fichier indent.texinfo. C’est l’édition de "The indent Manual", pour la dernière mise à jour de la version d’Indent.

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.

-bad, --blank-lines-after-declarations

Place une ligne blanche après les déclarations.
Voir LIGNES BLANCHES.

-bap, --blank-lines-after-procedures

Place une ligne blanche après le corps des procédures.
Voir LIGNES BLANCHES.

-bbb, --blank-lines-before-block-comments

Place une ligne blanche avant les commentaires sous forme de boîte.
Voir LIGNES BLANCHES.

-bbo, --break-before-boolean-operator

Préfère couper les lignes devant les opérateurs booléens
Voir COUPURE DES LIGNES TROP LONGUES.

-bc, --blank-lines-after-commas

Passe à la ligne après une virgule dans une déclaration.
Voir DÃCLARATIONS.

-bl, --braces-after-if-line

Met des crochets sur la ligne suivant un if, un while, un for, une déclaration de fonction, etc.
Voir ASSERTIONS.

-blin, --brace-indentn

Nombre d’espaces pour l’indentation des crochets
Voir ASSERTIONS.

-bls, --braces-after-struct-decl-line

Met des crochets sur la ligne suivant une déclaration de structure.
Voir DÃCLARATIONS.

-br, --braces-on-if-line

Met les crochet sur la ligne après if, etc.
Voir ASSERTIONS.

-brs, --braces-on-struct-decl-line

Met des crochets sur la même ligne après une déclaration de structure.
Voir DÃCLARATIONS.

-bs, --Bill-Shannon, --blank-before-sizeof

Place un espace entre sizeof et son argument.
Voir ASSERTIONS.

-cn, --comment-indentationn

Place les commentaires à droite du code à la colonne n.
Voir COMMENTAIRES.

-cbin, --case-brace-indentationn

Indente les crochets après un case de N espaces.
Voir ASSERTIONS.

-cdn, --declaration-comment-columnn

Place les commentaires à droite des déclaration à la colonne n.
Voir COMMENTAIRES.

-cdb, --comment-delimiters-on-blank-lines

Place les délimiteurs de commentaires sur une ligne blanche.
Voir COMMENTAIRES.

-cdw, --cuddle-do-while

Colle le `}´ et le while d’un do {} while;.
Voir COMMENTAIRES.

-ce, --cuddle-else

Colle le else avec le `}´ qui le précède.
Voir COMMENTAIRES.

-cin, --continuation-indentationn

Indentation continue de n espaces.
Voir ASSERTIONS.

-clin, --case-indentationn

Indentation pour les case de n espaces.
Voir ASSERTIONS.

-cpn, --else-endif-columnn

Place les commentairs à droite des assertions #else et de #endif à la colonne n.
Voir COMMENTAIRES.

-cs, --space-after-cast

Place une espace après un opérateur de transtypage.
Voir ASSERTIONS.

-dn, --line-comments-indentationn

Spécifie l’indentation des commentaires qui ne sont pas à droite de code.
Voir COMMENTAIRES.

-bfda, --break-function-decl-args

Coupe la ligne avant tous les arguments d’une déclaration.
Voir DÃCLARATIONS.

-bfde, --break-function-decl-args

Coupe la ligne après le dernier argument d’une déclaration.
Voir DÃCLARATIONS.

-din, --declaration-indentationn

Place les variables à la colonne n.
Voir DÃCLARATIONS.

-fc1, --format-first-column-comments

Place les commentaires à la première colonne.
Voir COMMENTAIRES.

-fca, --format-all-comments

Ne pas désactiver le formatage des commentaires.
Voir COMMENTAIRES.

-gnu, --gnu-style

Utilise le style GNU. C’est l’option par défaut.
Voir STYLES COURANTS.

-hnl, --honour-newlines

Préfère respecter les sauts de ligne du fichier d’entrée.
Voir COUPURE DES LIGNES TROP LONGUES.

-in, --indent-leveln

Fixe le niveau d’indentation à n espace.
Voir INDENTATION.

-ipn, --parameter-indentationn

Indente les paramètres dans le vieux style d’écriture des fonctions de n spaces.
Voir INDENTATION.

-kr, --k-and-r-style

Utilise le style Kernighan & Ritchie.
Voir STYLES COURANTS.

-ln, --line-lengthn

Fixe la longueur maximale d’une ligne de code à n.
Voir COUPURE DES LIGNES TROP LONGUES.

-lcn, --comment-line-lengthn

Fixe la longueur maximale d’une ligne de commentaire à n.
Voir COMMENTAIRES.

-lp, --continue-at-parentheses

Aligner les lignes d’une parenthèse.
Voir INDENTATION.

-lps, --leave-preprocessor-space

Laisser l’espace entre `#´ et une directive du préprocesseur.
Voir INDENTATION.

-nbad, --no-blank-lines-after-declarations

Ne place pas de lignes blanches après les déclarations.
Voir LIGNES BLANCHES.

-nbap, --no-blank-lines-after-procedures

Ne place pas de lignes blanches après le corps des procédures.
Voir LIGNES BLANCHES.

-nbbo, --break-after-boolean-operator

Ne pas préférer couper les lignes avant les opérateurs booléens.
Voir COUPURE DES LIGNES TROP LONGUES.

-nbc, --no-blank-lines-after-commas

Ne pas placer de saut de ligne après les virgules dans les déclarations.
Voir 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 DÃCLARATIONS.

-ncdb, --no-comment-delimiters-on-blank-lines

Ne pas placer les délimiteurs de commentaires /* et */ sur des lignes séparées.
Voir COMMENTAIRES.

-ncdw, --dont-cuddle-do-while

Ne pas coller } et while dans un do {} while;.
Voir ASSERTIONS.

-nce, --dont-cuddle-else

Ne pas coller } et else.
Voir ASSERTIONS.

-ncs, --no-space-after-casts

Ne pas placer d’espace après les opérateurs de transtypage.
Voir ASSERTIONS.

-nfc1, --dont-format-first-column-comments

Ne pas formater les commentaires dans la première colonne. (comportement pas défaut.)
Voir COMMENTAIRES.

-nfca, --dont-format-comments

Ne pas formater les commentaires.
Voir COMMENTAIRES.

-nhnl, --ignore-newlines

Ne pas préférer respecter les sauts de ligne du fichier d’entrée.
Voir COUPURE DES LIGNES TROP LONGUES.

-nip, --no-parameter-indentation

Ne pas indenter les paramètres.
Voir INDENTATION.

-nlp, --dont-line-up-parentheses

Ne pas aligner les parenthèses.
Voir ASSERTIONS.

-npcs, --no-space-after-function-call-names

Ne pas placer d’espace après la fonction dans les appels de fonctions.
Voir ASSERTIONS.

-nprs, --no-space-after-parentheses

Ne pas placer d’espace après chaque ´(´ et chaque ´)´.
Voir ASSERTIONS.

-npsl, --dont-break-procedure-type

Place le type de la procédure sur la même ligne que son nom.
Voir DÃCLARATIONS.

-nsaf, --no-space-after-for

Ne place pas d’espace après chaque for.
Voir ASSERTIONS.

-nsai, --no-space-after-if

Ne place pas d’espace après chaque if.
Voir ASSERTIONS.

-nsaw, --no-space-after-while

Ne place pas d’espace après chaque while.
Voir ASSERTIONS.

-nsc, --dont-star-comments

Ne place pas d’`*´ Ã gauche des commentaires.
Voir COMMENTAIRES.

-nsob, --leave-optional-blank-lines

Ne pas supprimer les lignes superflues.
Voir LIGNES BLANCHES.

-nss, --dont-space-special-semicolon

Ne pas placer d’espace avant le point virgule après certaines assertions. Désactive `-ss´.
Voir ASSERTIONS.

-nut, --no-tabs

Utilise des espaces plutôt que des tabulations.
Voir INDENTATION.

-nv, --no-verbosity

Mode non verbeux.
Voir MISCELLANEOUS OPTIONS.

-orig, --original

Utilise le style original de Berkeley.
Voir STYLES COURANTS.

-npro, --ignore-profile

Ne pas lire les fichiers de profil `.indent.pro´.
Voir INVOKING INDENT.

-pcs, --space-after-procedure-calls

Place un espace entre le nom d’une procedure appelée et `(´.
Voir ASSERTIONS.

-pin, --paren-indentationn

Specifie l’indentation par parenthèse ouvrante quand une assertion est coupée sur plusieurs lignes. Voir ASSERTIONS.

-pmt, --preserve-mtime

Conserver les droits et l’horodatage du fichier. Voir MISCELLANEOUS OPTIONS.

-prs, --space-after-parentheses

Place une espace avant chaque ´(´ et après chaque ´)´.
Voir ASSERTIONS.

-psl, --procnames-start-lines

Place le type d’une procédure sur la ligne au dessus de son nom.
Voir DÃCLARATIONS.

-saf, --space-after-for

Place un espace après chaque for.
Voir ASSERTIONS.

-sai, --space-after-if

Place un espace après chaque if.
Voir ASSERTIONS.

-saw, --space-after-while

Place un espace après chaque while.
Voir ASSERTIONS.

-sbin, --struct-brace-indentationn

Spécifie l’indentation pour strut, union et enum.
Voir ASSERTIONS.

-sc, --start-left-side-of-comments

Ajouter le caractère `*´ au début des commentaires, pour former des boîtes.
Voir COMMENTAIRES.

-sob, --swallow-optional-blank-lines

Supprimer les lignes blanches superflues.
Voir LIGNES BLANCHES.

-ss, --space-special-semicolon

Quand une assertion for ou while tient sur une ligne, placer un espace avant le point virgule.
Voir ASSERTIONS.

-st, --standard-output

Ãcrit sur la sortie standard.
Voir INVOCATION D’D’ INDENT.

-T

Indique à indent le nom des types.

Voir DÃCLARATIONS.

-tsn, --tab-sizen

Spécifie la taille de la tabulation, en espaces.
Voir INDENTATION.

-ut, --use-tabs

Utilise les tabulations. C’est l’option par défaut.
Voir INDENTATION.

-v, --verbose

Mode verbeux.
Voir MISCELLANEOUS OPTIONS.

-version

Afficher le numéro de version de indent.
Voir MISCELLANEOUS OPTIONS.

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
#endif

devient

#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

Inconnue. (NdT.) Toujours 0 ?

$HOME/.indent.pro   fichier de profil, contient les options par défaut.

Carlo Wood
Joseph Arceneaux
Jim Kingdon
David Ingamells

Dérivé du programme UCB «indent».

Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. Copyright (C) 1995, 1996 Joseph Arceneaux. Copyright (C) 1999 Carlo Wood. Copyright (C) 2001 David Ingamells.

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.

Il est possible que cette traduction soit imparfaite ou périmée. En cas de doute, veuillez vous reporter au document original en langue anglaise fourni avec le programme.