tiret - En ligne dans le Cloud

PROGRAMME:

Nom

indent - modifie l'apparence d'un programme C en insérant ou en supprimant des espaces.

SYNOPSIS

retrait [options] [fichiers-d'entrée]

retrait [options] [fichier-d'entrée unique] [-o fichier-de-sortie]

retrait --version

DESCRIPTION

Cette page de manuel est générée à partir du fichier indent.texinfo. Ceci est l'édition de "Le retrait
Manuel", pour la version en retrait , dernière mise à jour .

Le manuel de formation retrait programme peut être utilisé pour rendre le code plus facile à lire. Il peut également convertir d'un
style d'écriture C à l'autre.

retrait comprend une quantité substantielle de la syntaxe du C, mais il tente également de
faire face à une syntaxe incomplète et mal formée.

Dans la version 1.2 et les versions plus récentes, le style GNU d'indentation est la valeur par défaut.

OPTIONS

-mal, --lignes-vierges-après-déclarations
Forcer les lignes vides après les déclarations.
See BLANC LIGNES.

-bap, --lignes-vierges-après-procédures
Forcer les lignes vides après les corps de procédure.
See BLANC LIGNES.

-bb, --lignes-vierges-avant-bloc-commentaires
Forcer les lignes vides avant de bloquer les commentaires.
See BLANC LIGNES.

-bbo, --break-before-opérateur-booléen
Préférez rompre les longues lignes avant les opérateurs booléens.
See RUPTURE LONGUE LIGNES.

-avant JC, --blank-lines-after-virgules
Forcer le saut de ligne après la virgule dans la déclaration.
See DÉCLARATIONS.

-bl, --accolades-après-si-ligne
Mettez les accolades en ligne après if, etc.
See ÉTATS.

-blf, --braces-after-func-def-ligne
Mettez des accolades en ligne après la ligne de définition de fonction.
See DÉCLARATIONS.

-blin, --brace-indentationn
Retrait des accolades n les espaces.
See ÉTATS.

-bls, --braces-after-struct-decl-line
Mettez des accolades sur la ligne après struct lignes de déclaration.
See DÉCLARATIONS.

-br, --accolades-sur-si-ligne
Mettez les accolades en ligne avec if, etc.
See ÉTATS.

-brf, --braces-on-func-def-ligne
Mettez des accolades sur la ligne de définition de fonction.
See DÉCLARATIONS.

-brs, --braces-on-struct-decl-line
Mettez des bretelles struct ligne de déclaration.
See DÉCLARATIONS.

-bs, --Bill Shannon, --blanc-avant-taillede
Mettez un espace entre taille de et son argumentation.
See ÉTATS.

-cn, --commentaire-indentationn
Mettre les commentaires à droite du code dans la colonne n.
See COMMENTAIRES.

-cbin, --case-brace-indentationn
Indenter les accolades après une étiquette de cas N espaces.
See ÉTATS.

-CDn, --déclaration-commentaire-colonnen
Mettre des commentaires à droite des déclarations en colonne n.
See COMMENTAIRES.

-cdb, --comment-delimiters-on-blank-lines
Mettez des délimiteurs de commentaires sur des lignes vides.
See COMMENTAIRES.

-cdw, --câlin-faire-pendant
Câlin pendant de do {} tandis que; et précédant '}'.
See COMMENTAIRES.

-ce, --cuddle-autre
Cuddle else et précédant '}'.
See COMMENTAIRES.

-Làn, --suite-indentationn
Suite du tiret de n les espaces.
See ÉTATS.

-clin, --case-indentationn
Retrait de l'étiquette du boîtier de n les espaces.
See ÉTATS.

-cpn, --else-endif-colonnen
Mettez les commentaires à droite de #else et #endif déclarations dans la colonne n.
See COMMENTAIRES.

-cs, --espace-après-cast
Mettez un espace après un opérateur de distribution.
See ÉTATS.

-dn, --line-commentaires-indentationn
Définir l'indentation des commentaires non à droite du code pour n les espaces.
See COMMENTAIRES.

-bfda, --break-fonction-decl-args
Coupez la ligne avant tous les arguments dans une déclaration.
See DÉCLARATIONS.

-bfde, --break-function-decl-args-end
Couper la ligne après le dernier argument dans une déclaration.
See DÉCLARATIONS.

-dj, --left-justify-déclarations
Si -cd 0 est utilisé, les commentaires après les déclarations sont justifiés à gauche derrière le
déclaration.
See DÉCLARATIONS.

-dun, --déclaration-indentationn
Mettre les variables en colonne n.
See DÉCLARATIONS.

-fc1, --format-premier-commentaire-colonne
Formatez les commentaires dans la première colonne.
See COMMENTAIRES.

-fca, --format-all-commentaires
Ne désactivez pas toutes les mises en forme des commentaires.
See COMMENTAIRES.

-gnou, --style gnu
Utilisez le style de codage GNU. C'est la valeur par défaut.
See COMMUNE MODES.

-hnl, --honneur-nouvelles lignes
Préférez rompre les longues lignes à la position des nouvelles lignes dans l'entrée.
See RUPTURE LONGUE LIGNES.

-in, --niveau d'indentationn
Définir le niveau d'indentation sur n les espaces.
See ÉCHANCRURE.

-lesn, --indent-étiquetten
Définir le décalage des étiquettes sur la colonne n.
See ÉCHANCRURE.

-ipn, --paramètre-indentationn
Indenter les types de paramètres dans les définitions de fonctions à l'ancienne en n les espaces.
See ÉCHANCRURE.

-kr, --style-k-et-r
Utilisez le style de codage Kernighan & Ritchie.
See COMMUNE MODES.

-ln, --longueur de la lignen
Définir la longueur de ligne maximale pour les lignes non-commentaires à n.
See RUPTURE LONGUE LIGNES.

-n, --comment-line-lengthn
Définir la longueur de ligne maximale pour le formatage des commentaires sur n.
See COMMENTAIRES.

-linux, --style Linux
Utilisez le style de codage Linux.
See COMMUNE MODES.

-lp, --continue-at-parenthèses
Alignez les lignes continues entre parenthèses.
See ÉCHANCRURE.

-lps, --laisser-l'espace-préprocesseur
Laissez un espace entre '#' et la directive du préprocesseur.
See ÉCHANCRURE.

-n'est pas mauvais, --pas de lignes vides après les déclarations
Ne forcez pas les lignes vides après les déclarations.
See BLANC LIGNES.

-nbap, --pas de lignes blanches après les procédures
Ne forcez pas les lignes vides après les corps de la procédure.
See BLANC LIGNES.

-nbbo, --break-after-boolean-opérateur
Ne préférez pas rompre les longues lignes avant les opérateurs booléens.
See RUPTURE LONGUE LIGNES.

-NBC, --no-blank-lines-after-virgules
Ne forcez pas les retours à la ligne après les virgules dans les déclarations.
See DÉCLARATIONS.

-nbfda, --dont-break-function-decl-args
Ne placez pas chaque argument d'une déclaration de fonction sur une ligne distincte.
See DÉCLARATIONS.

-ncdb, --aucun-délimiteur-de-commentaire-sur-lignes-vierges
Ne placez pas de délimiteurs de commentaires sur des lignes vides.
See COMMENTAIRES.

-ncdw, --ne-câliner-faire-pendant
Ne pas faire de câlins } et la tout en d'un do {} tandis que;.
See ÉTATS.

-nce, --ne-câlinez-autre
Ne pas faire de câlins } et d'autre.
See ÉTATS.

-ncs, --pas d'espace après les diffusions
Ne mettez pas d'espace après les opérateurs de distribution.
See ÉTATS.

-ndjn, --dont-left-justify-declarations
Les commentaires après les déclarations sont traités de la même manière que les commentaires après d'autres déclarations.
See DÉCLARATIONS.

-nfc1, --dont-format-première-colonne-commentaires
Ne formatez pas les commentaires dans la première colonne comme d'habitude.
See COMMENTAIRES.

-nfca, --dont-format-commentaires
Ne formatez aucun commentaire.
See COMMENTAIRES.

-nhnl, --ignore-nouvelles lignes
Ne préférez pas casser les longues lignes à la position des nouvelles lignes dans l'entrée.
See RUPTURE LONGUE LIGNES.

-pincer, --pas d'indentation de paramètre
Indentation de largeur nulle pour les paramètres.
See ÉCHANCRURE.

-pnl, --dont-line-up-parenthèses
N'alignez pas les parenthèses.
See ÉTATS.

-npc, --pas d'espace après les noms d'appel de fonction
Ne mettez pas d'espace après la fonction dans les appels de fonction.
See ÉTATS.

-nprs, --no-space-after-parenthèses
Ne mettez pas d'espace après chaque '(' et avant chaque ')'.
See ÉTATS.

-npsl, --dont-break-procédure-type
Mettez le type d'une procédure sur la même ligne que son nom.
See DÉCLARATIONS.

-nsaf, --no-space-after-pour
Ne mettez pas d'espace après chaque pour.
See ÉTATS.

-nsai, --pas d'espace après si
Ne mettez pas d'espace après chaque if.
See ÉTATS.

-nsaw, --pas d'espace après un certain temps
Ne mettez pas d'espace après chaque tout en.
See ÉTATS.

-nsc, --dont-star-commentaires
Ne mettez pas le caractère '*' à gauche des commentaires.
See COMMENTAIRES.

-nsob, --leave-facultatif-lignes-blanches
N'avalez pas les lignes blanches facultatives.
See BLANC LIGNES.

-nss, --dont-space-special-point-virgule
Ne forcez pas un espace avant le point-virgule après certaines instructions. Désactive '-ss'.
See ÉTATS.

-écrou, --no-onglets
Utilisez des espaces au lieu de tabulations.
See ÉCHANCRURE.

-nv, --no-verbosité
Désactivez le mode verbeux.
See DIVERS OPTIONS.

-origine, --original
Utilisez le style de codage original de Berkeley.
See COMMUNE MODES.

-npro, --ignore-profil
Ne lisez pas les fichiers '.indent.pro'.
See INVOQUER RETRAIT.

-pièces, --espace-après-procédure-appels
Insérez un espace entre le nom de la procédure appelée et le '('.
See ÉTATS.

-pin, --paren-indentationn
Spécifiez l'indentation supplémentaire par parenthèses ouvertes '(' lorsqu'une instruction est rompue.Voir
ÉTATS.

-pm, --preserve-mtime
Conserver les temps d'accès et de modification sur les fichiers de sortie.Voir DIVERS OPTIONS.

-ppin, --indentation du préprocesseurn
Spécifiez l'indentation pour les instructions conditionnelles du préprocesseur.Voir ÉCHANCRURE.

-prs, --espace-après-parenthèses
Mettez un espace après chaque '(' et avant chaque ')'.
See ÉTATS.

-psl, --procnames-start-lines
Mettez le type d'une procédure sur la ligne avant son nom.
See DÉCLARATIONS.

-saf, --espace-après-pour
Mettez un espace après chaque pour.
See ÉTATS.

-sai, --espace-après-if
Mettez un espace après chaque if.
See ÉTATS.

-vu, --espace-après-temps
Mettez un espace après chaque tout en.
See ÉTATS.

-sbin, --struct-brace-indentationn
Indenter les accolades d'une structure, d'une union ou d'une énumération N espaces.
See ÉTATS.

-sc, --start-left-side-des-commentaires
Mettez le caractère '*' à gauche des commentaires.
See COMMENTAIRES.

-sanglot, --swallow-facultatif-lignes-blanches
Avalez les lignes vides facultatives.
See BLANC LIGNES.

-ss, --espace-spécial-point-virgule
Sur une seule ligne pour et tout en instructions, forcez un espace avant le point-virgule.
See ÉTATS.

-St, --sortie standard
Écrire sur la sortie standard.
See INVOQUER RETRAIT.

-T Avertir retrait le nom des noms de type.
See DÉCLARATIONS.

-tsn, --tab-taillen
Définir la taille de l'onglet sur n les espaces.
See ÉCHANCRURE.

-Utah, --use-onglets
Utilisez des onglets. C'est la valeur par défaut.
See ÉCHANCRURE.

-v, --verbeux
Activer le mode détaillé.
See DIVERS OPTIONS.

-version
Sortir le numéro de version de retrait.
See DIVERS OPTIONS.

INVOQUER RETRAIT

A partir de la version 1.3, le format du retrait la commande est:

retrait [Options] [fichiers-d'entrée]

retrait [Options] [fichier à entrée unique] [-O fichier de sortie]

Ce format est différent des versions antérieures et des autres versions de retrait.

Dans la première forme, un ou plusieurs fichiers d'entrée sont spécifiés. retrait fait une copie de sauvegarde de
chaque fichier, et le fichier d'origine est remplacé par sa version en retrait. Voir SAUVEGARDE DES DOSSIERS,
pour une explication de la façon dont les sauvegardes sont effectuées.

Dans la seconde forme, un seul fichier d'entrée est spécifié. Dans ce cas, ou lorsque la norme
input est utilisé, vous pouvez spécifier un fichier de sortie après l'option '-o'.

Causer retrait pour écrire sur la sortie standard, utilisez l'option '-st'. Ceci n'est autorisé que
lorsqu'il n'y a qu'un seul fichier d'entrée, ou lorsque l'entrée standard est utilisée.

Si aucun fichier d'entrée n'est nommé, l'entrée standard est lue pour l'entrée. De plus, si un nom de fichier
nommé '-' est spécifié, puis l'entrée standard est lue.

A titre d'exemple, chacune des commandes suivantes entrera le programme 'slithy_toves.c' et
écrivez son texte en retrait sur 'slithy_toves.out' :

retrait slithy_toves.c -o slithy_toves.out

indent -st slithy_toves.c > slithy_toves.out

chat slithy_toves.c | retrait -o slithy_toves.out

La plupart des autres options pour retrait contrôler la façon dont les programmes sont formatés. A partir de la version 1.2,
retrait reconnaît également un nom long pour chaque nom d'option. Les options longues sont préfixées par
soit '--' ou '+'. [ '+' est remplacé par '--' pour maintenir la cohérence avec le
Norme POSIX.]
Dans la plupart de ce document, les noms abrégés traditionnels sont utilisés par souci de concision.
See OPTION EN RÉSUMÉ, pour une liste d'options, y compris les noms longs et courts.

Voici un autre exemple:

tiret -br test/métabolisme.c -l85

Cela indentera le programme 'test/metabolism.c' en utilisant les options '-br' et '-l85', écrivez
la sortie vers 'test/metabolism.c', et écrivez le contenu original de
'test/metabolism.c' dans un fichier de sauvegarde dans le répertoire 'test'.

Les appels équivalents utilisant des noms d'option longs pour cet exemple seraient :

indent --braces-on-if-line --line-length185 test/métabolisme.c

indent +accolades-on-if-line +line-length185 test/metabolism.c

Si vous trouvez que vous utilisez souvent retrait avec les mêmes options, vous pouvez mettre ces options
dans un fichier nommé '.indent.pro'. retrait recherchera un fichier de profil à trois endroits.
Tout d'abord, il vérifiera la variable d'environnement INDENT_PROFIL. Si cela existe, sa valeur est
devrait nommer le fichier qui doit être utilisé. Si la variable d'environnement n'existe pas,
indent recherche '.indent.pro' dans le répertoire courant
et l'utiliser s'il est trouvé. finalement retrait recherchera '.indent.pro' dans votre répertoire personnel
et utilisez ce fichier s'il est trouvé. Ce comportement est différent de celui des autres versions
of retrait, qui charge les deux fichiers s'ils existent tous les deux.

Le format de '.indent.pro' est simplement une liste d'options, tout comme elles apparaîtraient sur le
ligne de commande, séparés par des espaces blancs (tabulations, espaces et sauts de ligne). Options dans
'.indent.pro' peut être entouré de commentaires C ou C++, auquel cas ils sont ignorés.

Les commutateurs de ligne de commande sont gérés après traitement '.indent.pro'. Options spécifiées ultérieurement
remplacer les arguments spécifiés précédemment, à une exception près : les options spécifiées explicitement
toujours remplacer les options d'arrière-plan (voir COMMUNE MODES). Vous pouvez empêcher retrait grâce au
lire un fichier '.indent.pro' en spécifiant l'option '-npro'.

SAUVEGARDE DES DOSSIERS

A partir de la version 1.3, GNU retrait crée des fichiers de sauvegarde de style GNU, de la même manière que GNU Emacs.
Cela signifie que soit simple or numéroté des noms de fichiers de sauvegarde peuvent être créés.

Les noms de fichiers de sauvegarde simples sont générés en ajoutant un suffixe au nom de fichier d'origine.
La valeur par défaut pour ce suffixe est la chaîne à un caractère « ~ » (tilde). Ainsi, la sauvegarde
le fichier pour 'python.c' serait 'python.c~'.

Au lieu de la valeur par défaut, vous pouvez spécifier n'importe quelle chaîne comme suffixe en définissant l'environnement
variable SIMPLE_BACKUP_SUFFIX à votre suffixe préféré.

Les versions de sauvegarde numérotées d'un fichier « momeraths.c » ressemblent à « momeraths.c.~23~ », où 23 est
la version de cette sauvegarde particulière. Lors d'une sauvegarde numérotée du fichier
'src/momeraths.c', le fichier de sauvegarde sera nommé 'src/momeraths.c.~V~', où V est une
supérieure à la version la plus élevée existant actuellement dans le répertoire 'src'. Les
variable d'environnement VERSION_WIDTH contrôle le nombre de chiffres, en utilisant le remplissage zéro à gauche
quand c'est nécessaire. Par exemple, définir cette variable sur "2" conduira au fichier de sauvegarde
étant nommé 'momeraths.c.~04~'.

Le type de fichier de sauvegarde réalisé est contrôlé par la valeur de la variable d'environnement
CONTRÔLE DE VERSION. S'il s'agit de la chaîne 'simple', alors seules des sauvegardes simples seront effectuées. Si
sa valeur est la chaîne 'numéroté', des sauvegardes numérotées seront alors effectuées. Si sa valeur est
'numéro-existant', des sauvegardes numérotées seront effectuées s'il y a déjà exister numéroté
les sauvegardes du fichier en retrait ; sinon, une simple sauvegarde est effectuée. Si
CONTRÔLE DE VERSION n'est pas défini, alors retrait suppose le comportement de « numéro-existant ».

D'autres versions de retrait utilisez le suffixe '.BAK' pour nommer les fichiers de sauvegarde. Ce comportement peut
être imité en définissant SIMPLE_BACKUP_SUFFIX à '.BAK'.

Notez également que d'autres versions de retrait faire des sauvegardes dans le répertoire courant, plutôt que
dans le répertoire du fichier source en tant que GNU retrait le fait maintenant.

COMMUNE MODES

Il existe plusieurs styles courants de code C, y compris le style GNU, le Kernighan &
Le style Ritchie et le style original de Berkeley. Un style peut être sélectionné avec un seul
fond option, qui spécifie un ensemble de valeurs pour toutes les autres options. Cependant,
les options explicitement spécifiées remplacent toujours les options impliquées par une option d'arrière-plan.

Depuis la version 1.2, le style par défaut de GNU retrait est le style GNU. Ainsi, ce n'est pas
plus nécessaire de spécifier l'option '-gnu' pour obtenir ce format, bien que le faire
ne provoquera pas d'erreur. Les paramètres d'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
-scie -nsc -nsob

Le style de codage GNU est celui préféré par le projet GNU. C'est le style que le GNU
Le mode Emacs C encourage et qui est utilisé dans les portions C de GNU Emacs. (Personnes
intéressés à écrire des programmes pour le projet GNU devraient obtenir une copie de "The GNU Coding
Standards", qui couvre également les problèmes de sémantique et de portabilité tels que l'utilisation de la mémoire, la
taille des nombres entiers, etc.)

Le style Kernighan & Ritchie est utilisé tout au long de leur livre bien connu "The C Programming
Langue". Il est activé avec l'option '-kr'. Le style Kernighan & Ritchie
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

Le style Kernighan & Ritchie ne place pas les commentaires à droite du code dans la même colonne à
tout le temps (il n'utilise pas non plus qu'un seul espace à droite du code), donc pour ce style
retrait a choisi arbitrairement la colonne 33.

Le style du Berkeley original retrait peut être obtenu en spécifiant '-orig' (ou par
en spécifiant '--original', en utilisant le nom d'option long). Ce style est équivalent au
paramètres suivants :

-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 et les pilotes du noyau Linux. Le code doit généralement suivre
le style de codage Linux à accepter. Ce style est équivalent au suivant
paramètres:

-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

BLANC LIGNES

Différents styles de programmation utilisent des lignes vierges à différents endroits. retrait a un certain nombre de
options pour insérer ou supprimer des lignes vides à des endroits spécifiques.

L'option '-mauvais' provoque retrait pour forcer une ligne vide après chaque bloc de déclarations.
L'option '-nbad' provoque retrait de ne pas forcer de telles lignes vides.

L'option '-bap' force une ligne vierge après chaque corps de procédure. L'option '-nbap'
ne force pas une telle ligne vide.

L'option '-bbb' force une ligne vierge avant chaque commentaire encadré (Voir COMMENTAIRES.) Le
L'option '-nbbb' ne force pas de telles lignes vides.

L'option '-sob' provoque retrait pour avaler des lignes blanches facultatives (c'est-à-dire toute
les lignes vides présentes dans l'entrée seront supprimées de la sortie). Si le '-nsob' est
spécifié, toutes les lignes vides présentes dans le fichier d'entrée seront copiées dans le fichier de sortie.

--lignes-vierges-après-déclarations

L'option '-bad' force une ligne vierge après chaque bloc de déclarations. Le '-nbad'
L'option n'ajoute pas de telles lignes vides.

Par exemple, étant donné l'entrée
caractère *foo ;
caractère *barre ;
/* Ceci sépare les blocs de déclarations. */
baz int ;

retrait -mal produit

caractère *foo ;
caractère *barre ;

/* Ceci sépare les blocs de déclarations. */
baz int ;

et retrait -n'est pas mauvais produit

caractère *foo ;
caractère *barre ;
/* Ceci sépare les blocs de déclarations. */
baz int ;

--lignes-vierges-après-procédures

L'option '-bap' force une ligne vierge après chaque corps de procédure.

Par exemple, étant donné l'entrée

int
foo ()
{
puts("Salut");
}
/* La barre de procédure est encore moins intéressante. */
char *
bar ()
{
puts("Bonjour");
}

retrait -bap produit

int
foo ()
{
met ("Salut");
}

/* La barre de procédure est encore moins intéressante. */
char *
bar ()
{
met ("Bonjour");
}

et retrait -nbap produit

int
foo ()
{
met ("Salut");
}
/* La barre de procédure est encore moins intéressante. */
char *
bar ()
{
met ("Bonjour");
}

Aucune ligne vide ne sera ajoutée après la procédure foo.

COMMENTAIRES

retrait formate les commentaires C et C++. Les commentaires C commencent par '/*', se terminent par
'*/' et peut contenir des caractères de nouvelle ligne. Les commentaires C++ commencent par le délimiteur '//' et
terminer à la nouvelle ligne.

retrait gère les commentaires différemment selon leur contexte. retrait essayer de
distinguer entre les commentaires qui suivent les déclarations, les commentaires qui suivent les déclarations,
les commentaires suivant les directives du préprocesseur et les commentaires qui ne sont pas précédés du code de
n'importe quelle sorte, c'est-à-dire qu'ils commencent le texte de la ligne (mais pas nécessairement dans la colonne 1).

retrait distingue en outre les commentaires trouvés en dehors des procédures et les agrégats,
et ceux qui s'y trouvent. En particulier, les commentaires commençant une ligne trouvée dans un
La procédure sera indentée par rapport à la colonne dans laquelle le code est actuellement indenté. Les
exception à cette règle est un commentaire commençant dans la colonne la plus à gauche ; un tel commentaire est émis
à cette colonne.

retrait tente de partir en boîte commentaires non modifié. L'idée générale d'un tel commentaire est
qu'il soit enfermé dans un rectangle ou une « boîte » d'étoiles ou de tirets pour le distinguer visuellement.
Plus précisément, les commentaires encadrés sont définis comme ceux dans lesquels le '/*' initial est suivi
immédiatement par le caractère '*', '=', '_', ou '-', ou ceux dont le début
le délimiteur de commentaire ('/*') est sur une ligne par lui-même, et la ligne suivante commence par un '*'
dans la même colonne que l'étoile du délimiteur d'ouverture.

Voici des exemples de commentaires encadrés :

/************************
* Commentaire dans une boîte !! *
*************************/

/*
* Un parfum différent,
* pour un autre type de commentaire.
*/

retrait tente de laisser les commentaires encadrés exactement tels qu'ils se trouvent dans le fichier source.
Ainsi l'indentation du commentaire est inchangée, et sa longueur n'est vérifiée dans aucun
manière. La seule modification apportée est qu'un caractère de tabulation intégré peut être converti en
nombre approprié d'espaces.

Si l'option '-bbb' est spécifiée, tous ces commentaires encadrés seront précédés d'un blanc
ligne, à moins qu'un tel commentaire ne soit précédé d'un code.

Les commentaires qui ne sont pas des commentaires encadrés peuvent être formatés, ce qui signifie que la ligne est
brisé pour tenir dans une marge de droite et rempli à gauche d'espaces blancs. Les nouvelles lignes simples sont
équivalent à un espace, mais les lignes vides (deux ou plusieurs nouvelles lignes d'affilée) sont considérées comme signifiant un
saut de paragraphe. Formatage des commentaires qui commencent après l'activation de la première colonne
avec l'option '-fca'. Pour formater ceux qui commencent dans la première colonne, spécifiez '-fc1'. Tel
le formatage est désactivé par défaut.

La marge de droite pour le formatage est par défaut de 78, mais peut être modifiée avec l'option '-lc'.
Si la marge spécifiée ne permet pas l'impression du commentaire, la marge sera
automatiquement prolongé pour la durée de ce commentaire. La marge n'est pas respectée si
le commentaire n'est pas formaté.

Si le commentaire commence une ligne (c'est-à-dire qu'il n'y a pas de texte de programme à sa gauche), il sera
en retrait de la colonne dans laquelle il a été trouvé, sauf si le commentaire se trouve dans un bloc de code. Dans
ce cas, un tel commentaire sera aligné avec le code indenté de ce bloc (à moins que le
commentaire a commencé dans la première colonne). Cet alignement peut être affecté par l'option '-d',
qui spécifie un montant par lequel ces commentaires sont transférés au à gauche, ou sans retrait.
Par exemple, '-d2' place les commentaires deux espaces à gauche du code. Par défaut, les commentaires
sont alignés avec le code, à moins qu'ils ne commencent dans la première colonne, auquel cas ils sont laissés
là par défaut --- pour les aligner avec le code, spécifiez '-fc1'.

Les commentaires à droite du code apparaîtront par défaut dans la colonne 33. Ceci peut être modifié
avec l'une des trois options. '-c' spécifiera la colonne pour les commentaires suivant le code,
'-cd' spécifie la colonne pour les commentaires suivant les déclarations, et '-cp' spécifie la
colonne pour les commentaires suivant les directives du préprocesseur #else et #endif. '-dj' ensemble
avec '-cd0' peut être utilisé pour supprimer l'alignement des commentaires à droite des déclarations,
faisant en sorte que le commentaire suive une tabulation à partir de la fin de la déclaration. Normalement '-cd0'
fait que '-c' devient effectif.

Si le code à gauche du commentaire dépasse la colonne de début, la colonne de commentaire
sera étendu à la colonne de tabulation suivante après la fin du code, ou dans le cas de
directives du préprocesseur, à un espace après la fin de la directive. Cette prolongation dure
uniquement pour la sortie de ce commentaire particulier.

L'option '-cdb' place les délimiteurs de commentaires sur des lignes vides. Ainsi, une seule ligne
commenter comme /* Affectueux étreindre */ peut être transformé en :

/*
Câlin d'amour
*/

Des étoiles peuvent être placées au début des commentaires multilignes avec l'option '-sc'. Ainsi,
le commentaire d'une seule ligne ci-dessus peut être transformé (avec '-cdb -sc') en :

/*
* Câlin d'amour
*/

ÉTATS

L'option '-br' ou '-bl' spécifie comment formater les accolades.

L'option '-br' formate les accolades de l'instruction comme ceci :

si (x > 0) {
x--;
}

L'option '-bl' les formate comme ceci :

si (x > 0)
{
x--;
}

Si vous utilisez l'option '-bl', vous pouvez également vouloir spécifier l'option '-bli'. Cette option
spécifie le nombre d'espaces par lesquels les accolades sont en retrait. '-bli2', la valeur par défaut, donne
le résultat montré ci-dessus. '-bli0' donne ce qui suit :

si (x > 0)
{
x--;
}

Si vous utilisez l'option '-br', vous voudrez probablement aussi utiliser l'option '-ce'. Cette
provoque la d'autre dans une construction if-then-else pour se blottir contre le précédent
'}'. Par exemple, avec '-br -ce' vous obtenez ce qui suit :

si (x > 0) {
x--;
} Else {
fprintf (stderr, "...quelque chose ne va pas ?\n");
}

Avec '-br -nce' ce code apparaîtrait comme

si (x > 0) {
x--;
}
else {
fprintf (stderr, "...quelque chose ne va pas ?\n");
}

Cela provoque le tout en dans une boucle do-while pour se blottir contre le '}' immédiatement précédent.
Par exemple, avec '-cdw' vous obtenez ce qui suit :

faire {
x--;
} tandis que (x);

Avec '-ncdw' ce code apparaîtrait comme

faire {
x--;
}
tandis que (x);

L'option '-cli' spécifie le nombre d'espaces sur lesquels les étiquettes de cas doivent être indentées
le droit du contenant interrupteur déclaration.

La valeur par défaut donne un code comme :

interrupteur (i)
{
cas 0:
break;
cas 1:
{
++i ;
}
par défaut:
break;
}

En utilisant le '-cli2' qui deviendrait :

interrupteur (i)
{
cas 0:
break;
cas 1:
{
++i ;
}
par défaut:
break;
}

L'indentation des accolades sous une instruction case peut être contrôlée avec le '-cbin»
option. Par exemple, l'utilisation de « -cli2 -cbi0 » donne :

interrupteur (i)
{
cas 0:
break;
cas 1:
{
++i ;
}
par défaut:
break;
}

Si un point-virgule se trouve sur la même ligne qu'un pour or tout en instruction, l'option '-ss'
place un espace avant le point-virgule. Cela met l'accent sur le point-virgule, ce qui en fait
clair que le corps du pour or tout en déclaration est une déclaration vide. '-nss' désactive
cette fonctionnalité.

L'option '-pcs' provoque l'insertion d'un espace entre le nom de la procédure en cours
appelé et le '(' (par exemple, met ("Salut");. L'option '-npcs' donnerait
puts("Salut");).

Si l'option '-cs' est spécifiée, retrait place un espace entre un opérateur de distribution et le
objet à jeter. Le '-ncs' garantit qu'il n'y a pas d'espace entre l'opérateur de distribution et
L'object. Souviens-toi que retrait ne connaît que les types de données C standard et ne peut donc pas
reconnaître les types définis par l'utilisateur dans les distributions. Ainsi (mon type) chose n'est pas traité comme un casting.

L'option '-bs' garantit qu'il y a un espace entre le mot-clé taille de : besoins particuliers, topographie du site et intégration paysagère.
argument. Dans certaines versions, cette option est connue sous le nom d'option « Bill_Shannon ».

L'option '-saf' force un espace entre un pour et la parenthèse suivante. C'est le
défaut.

L'option '-sai' force un espace entre un if et la parenthèse suivante. C'est le
défaut.

L'option '-saw' force un espace entre un tout en et la parenthèse suivante. C'est
le défaut.

L'option '-prs' fait que toutes les parenthèses sont séparées par un espace de tout ce qui est
entre eux. Par exemple, l'utilisation de '-prs' donne un code tel que :

while ( ( e_code - s_code ) < ( dec_ind - 1 ) )
{
set_buf_break ( bb_dec_ind );
*e_code++ = ' ';
}

DÉCLARATIONS

Par défaut retrait alignera les identifiants, dans la colonne spécifiée par l'option '-di'.
Par exemple, '-di16' fait ressembler les choses à :

int foo ;
caractère *barre ;

L'utilisation d'une petite valeur (comme un ou deux) pour l'option '-di' peut être utilisée pour provoquer le
des identifiants à placer dans la première position disponible ; par exemple:

int foo ;
caractère *barre ;

La valeur donnée à l'option '-di' affectera toujours les variables qui sont placées séparément
lignes de leurs types, par exemple '-di2' conduira à :

int
fou ;

Si l'option '-bc' est spécifiée, une nouvelle ligne est forcée après chaque virgule dans une déclaration.
Par exemple,

int un,
b,
c;

Avec l'option '-nbc', cela ressemblerait à

entier a, b, c ;

L'option '-bfda' force un retour à la ligne après la virgule séparant les arguments
d'une déclaration de fonction. Les arguments apparaîtront à un niveau d'indentation plus profond que
la déclaration de fonction. Ceci est particulièrement utile pour les fonctions avec un argument long
listes. L'option '-bfde' force un retour à la ligne avant la parenthèse fermante du
déclaration de fonction. Pour les deux options, le paramètre « n » est la valeur par défaut : -nbdfa et -nbdfe.

Par exemple,

void foo (int arg1, char arg2, int *arg3, long arg4, char arg5) ;
Avec l'option '-bfda', cela ressemblerait à

vide foo (
entier arg1,
caractère arg2,
entier *arg3,
longue arg4,
caractère arg5) ;

Avec, en plus, l'option '-bfde' cela ressemblerait à

vide foo (
entier arg1,
caractère arg2,
entier *arg3,
longue arg4,
caractère arg5
);

L'option '-psl' fait que le type d'une procédure en cours de définition est placé sur la ligne
avant le nom de la procédure. Ce style est requis pour le étiquettes programme pour travailler
correctement, ainsi que certains des mode c fonctions d'Emacs.

Vous devez utiliser l'option '-T' pour dire retrait le nom de tous les types de votre programme
qui sont définis par typedef. '-T' peut être spécifié plus d'une fois, et tous les noms
spécifiés sont utilisés. Par exemple, si votre programme contient

typedef long CODE_ADDR non signé ;
typedef enum {rouge, bleu, vert} COLOR;

vous utiliseriez les options '-T CODE_ADDR -T COLOR'.

L'option '-brs' ou '-bls' spécifie comment formater les accolades dans les déclarations de structure. Les
L'option '-brs' formate les accolades comme ceci :

structure foo {
int x;
};

L'option '-bls' les formate comme ceci :

structure foo
{
int x;
};

De la même manière que les options d'accolade de structure '-brs' et '-bls',
les options d'accolade de fonction '-brf' ou '-blf' spécifient comment formater les accolades dans la fonction
définitions. L'option '-brf' formate les accolades comme ceci :

int un (vide) {
1 revenir;
};

L'option '-blf' les formate comme ceci :

int un (vide)
{
1 revenir;
};

ÉCHANCRURE

Un problème dans le formatage du code est de savoir jusqu'où chaque ligne doit être en retrait à partir de la gauche
marge. Lorsque le début d'une déclaration telle que if or pour est rencontré, le
le niveau d'indentation est augmenté de la valeur spécifiée par l'option '-i'. Par exemple,
utilisez '-i8' pour spécifier une indentation de huit caractères pour chaque niveau. Lorsqu'une déclaration est
interrompue sur deux lignes, la deuxième ligne est indentée par un certain nombre d'espaces supplémentaires
spécifié par l'option '-ci'. '-ci' est par défaut à 0. Cependant, si l'option '-lp' est
spécifié, et une ligne a une parenthèse gauche qui n'est pas fermée sur cette ligne, alors
les lignes de continuation seront alignées pour commencer à la position du caractère juste après la gauche
parenthèse. Ce traitement s'applique également à '[' et s'applique à '{' lorsqu'il se produit dans
listes d'initialisation. Par exemple, un morceau de code continu pourrait ressembler à ceci avec
'-nlp -ci3' en effet :

p1 = première_procédure (seconde_procédure (p2, p3),
troisième_procédure (p4, p5));

Avec '-lp' en vigueur, le code semble un peu plus clair :

p1 = première_procédure (seconde_procédure (p2, p3),
troisième_procédure (p4, p5));

Lorsqu'une instruction est séparée entre deux ou plusieurs paires de parent (...), chaque paire supplémentaire
provoque l'indentation supplémentaire du niveau d'indentation :

si ((((i < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

L'option '-ipN' peut être utilisé pour définir le décalage supplémentaire par parenthèse. Par exemple, '-ip0'
formaterait ce qui précède comme :

si ((((i < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

retrait suppose que les onglets sont placés à intervalles réguliers à la fois en entrée et en sortie
flux de caractères. Ces intervalles ont par défaut une largeur de 8 colonnes, mais (à partir de la version 1.2)
peut être modifié par l'option '-ts'. Les tabulations sont traitées comme le nombre équivalent d'espaces.

L'indentation des déclarations de type dans les définitions de fonction à l'ancienne est contrôlée par
le paramètre '-ip'. Il s'agit d'un paramètre numérique spécifiant le nombre d'espaces à indenter
déclarations de type. Par exemple, la valeur par défaut '-ip5' donne aux définitions l'aspect suivant :

char *
create_world (x, y, échelle)
int x;
int y;
échelle flottante;
{
. . .
}

Pour la compatibilité avec d'autres versions d'indent, l'option '-nip' est fournie, qui est
équivalent à '-ip0'.

ANSI C permet de placer un espace blanc sur les lignes de commande du préprocesseur entre le caractère
'#' et le nom de la commande. Par défaut, retrait supprime cet espace, mais en spécifiant le
L'option '-lps' dirige retrait de laisser cet espace inchangé. L'option '-ppi' remplace
'-nlps' et '-lps'.

Cette option peut être utilisée pour demander que les instructions conditionnelles du préprocesseur puissent être
en retrait d'un nombre d'espaces donné, par exemple avec l'option '-ppi 3'

#si X
#si O
#définir Z 1
#else
#définir Z 0
#endif
#endif
devient
#si X
# si O
# définir Z 1
# autre
# définir Z 0
# fin si
#endif

Cette option définit le décalage auquel une étiquette (à l'exception des étiquettes de cas) sera positionnée. Si
il est mis à zéro ou un nombre positif, cela indique à quelle distance de la marge gauche à
indenter une étiquette. S'il est défini sur un nombre négatif, cela indique à quelle distance du
niveau de retrait actuel pour placer l'étiquette. Le paramètre par défaut est -2, ce qui correspond au
comportement des versions antérieures d'indent. Notez que ce paramètre n'affecte pas le
pose d'étiquettes de caisses; voir le paramètre '-cli' pour cela. Par exemple avec l'option
'-il 1'

groupe
une fonction()
{
if (do_stuff1() == ERREUR)
aller à nettoyage1;

if (do_stuff2() == ERREUR)
aller à nettoyage2;

retour SUCCÈS;

nettoyage2 :
do_cleanup2();

nettoyage1 :
do_cleanup1();

retourner ERREUR;
}
devient
groupe
une fonction()
{
if (do_stuff1() == ERREUR)
aller à nettoyage1;

if (do_stuff2() == ERREUR)
aller à nettoyage2;

retour SUCCÈS;

nettoyage2 :
do_cleanup2();

nettoyage1 :
do_cleanup1();

retourner ERREUR;
}

RUPTURE LONGUE LIGNES

Avec l'option '-ln', ou '--line-lengthn', il est possible de spécifier la longueur maximale
d'une ligne de code C, sans compter les éventuels commentaires qui la suivent.

Lorsque les lignes deviennent plus longues que la longueur de ligne spécifiée, GNU retrait essaie de briser le
ligne à un endroit logique. C'est nouveau à partir de la version 2.1 cependant et pas très intelligent
ou encore flexible.

Actuellement, il existe deux options qui permettent d'interférer avec l'algorithme qui
détermine où casser une ligne.

L'option '-bbo' provoque GNU retrait préférer rompre les longues lignes avant le booléen
opérateurs && et ||. L'option '-nbbo' provoque GNU retrait pas cette préférence. Pour
exemple, l'option par défaut '-bbo' (avec '--line-length60' et '--ignore-
newlines') fait ressembler le code à ceci :

si (masque
&& ((masque[0] == '\0')
|| (masque[1] == '\0'
&& ((mask[0] == '0') || (mask[0] == '*'))))))

L'utilisation de l'option '-nbbo' le fera ressembler à ceci :

si (masquer &&
((masque[0] == '\0') ||
(masque[1] == '\0' &&
((masque[0] == '0') || (masque[0] == '*')))))))

La valeur par défaut '-hnl', cependant, respecte les nouvelles lignes dans le fichier d'entrée en leur donnant la valeur la plus élevée
priorité possible pour casser les lignes. Par exemple, lorsque le fichier d'entrée ressemble à ceci :

si (masque
&& ((masque[0] == '\0')
|| (mask[1] == '\0' && ((mask[0] == '0') || (mask[0] == '*'))))))

puis en utilisant l'option '-hnl', ou '--honour-newlines', avec le précédent
mentionné '-nbbo' et '--line-length60', la sortie ne sera pas celle qui est donnée dans
le dernier exemple mais préférera plutôt casser aux positions où le code était
cassé dans le fichier d'entrée :

si (masque
&& ((masque[0] == '\0')
|| (masque[1] == '\0' &&
((masque[0] == '0') || (masque[0] == '*')))))))

L'idée derrière cette option est que les lignes trop longues, mais déjà interrompues,
ne sera pas touché par GNU retrait. Le code vraiment désordonné doit être exécuté retrait at
au moins une fois en utilisant l'option '--ignore-newlines'.

DÉSACTIVATION MISE EN PAGE

Le formatage du code C peut être désactivé pour des parties d'un programme en incorporant des
des bactéries commentaires dans le programme. Pour désactiver le formatage d'une section d'un programme, placez
le commentaire de contrôle de désactivation /* *RETRAIT DÉSACTIVÉ* */ sur une ligne par lui-même juste avant cela
section. Le texte du programme scanné après ce commentaire de contrôle est sorti précisément comme entrée
sans modification jusqu'à ce que le commentaire d'activation correspondant soit scanné sur une ligne par
lui-même. Le commentaire de contrôle de désactivation est /* *RETRAIT SUR* */, et tout texte suivant le
le commentaire sur la ligne est également sorti sans formatage. Le formatage recommence avec la saisie
ligne suivant le commentaire de contrôle d'activation.

Plus précisément, retrait ne tente pas de vérifier le délimiteur de fermeture (*/) pour ces C
commentaires, et tout espace blanc sur la ligne est totalement transparent.

Ces commentaires de contrôle fonctionnent également dans leurs formats C++, à savoir // *RETRAIT DÉSACTIVÉ* et //
*RETRAIT SUR*.

Il est à noter que l'état interne de retrait reste inchangé au cours de
la section non formatée. Ainsi, par exemple, désactiver le formatage au milieu d'un
fonction et le poursuivre après la fin de la fonction peut conduire à des résultats bizarres. Ce
est donc sage d'être quelque peu modulaire dans la sélection du code à laisser non formaté.

À titre de note historique, certaines versions antérieures de retrait produit des messages d'erreur commençant
avec *RETRAIT**. Ces versions de retrait ont été écrits pour ignorer les lignes de texte saisies
qui a commencé avec de tels messages d'erreur. J'ai supprimé cette fonctionnalité incestueuse de GNU
retrait.

DIVERS OPTIONS

Pour savoir quelle version de retrait vous avez, utilisez la commande retrait -version. Cette volonté
signaler le numéro de version de retrait, sans effectuer aucun des traitements normaux.

L'option '-v' peut être utilisée pour activer le mode verbeux. En mode verbeux, retrait (lire ici)
quand il divise une ligne d'entrée en deux autres lignes de sortie et donne une certaine taille
statistiques à la fin.

L'option '-pmt' provoque retrait de conserver les horaires d'accès et de modification sur le
fichiers de sortie. L'utilisation de cette option a l'avantage d'exécuter l'indentation sur toutes les sources et
les fichiers d'en-tête dans un projet ne causeront pas a prendre une pour reconstruire toutes les cibles. Cette option est uniquement
disponible sur les systèmes d'exploitation qui ont le POSIX temps utile(2) la fonction.

Utiliser l'indentation en ligne à l'aide des services onworks.net