streepje - Online in de cloud

PROGRAMMA:

NAAM

inspringen - verandert het uiterlijk van een C-programma door witruimte in te voegen of te verwijderen.

KORTE INHOUD

inspringen [opties] [invoerbestanden]

inspringen [opties] [enkel invoerbestand] [-o uitvoerbestand]

inspringen --versie

PRODUCTBESCHRIJVING

Deze manpagina wordt gegenereerd op basis van het bestand streepje.texinfo. Dit is de editie van "The inspringen
Manual", voor ingesprongen versie, laatst bijgewerkt.

De inspringen programma kan worden gebruikt om code gemakkelijker leesbaar te maken. Het kan ook van één worden omgezet
schrijfstijl C naar een ander.

inspringen begrijpt een aanzienlijk deel van de syntaxis van C, maar probeert dat ook
omgaan met onvolledige en verkeerd gevormde syntaxis.

In versie 1.2 en recentere versies is de GNU-inspringstijl de standaard.

OPTIES

-slecht, --lege regels-na-declaraties
Forceer lege regels na de declaraties.
Bekijk BLANK LIJNEN.

-bap, --lege regels-na-procedures
Forceer lege regels na procedureteksten.
Bekijk BLANK LIJNEN.

-bb, --lege regels-voor-blokcommentaar
Forceer lege regels voordat u opmerkingen blokkeert.
Bekijk BLANK LIJNEN.

-bbo, --break-before-boolean-operator
Geef er de voorkeur aan lange regels af te breken vóór Booleaanse operatoren.
Bekijk BREAKING LANG LIJNEN.

-bc, --lege regels na komma's
Forceer nieuwe regel na komma in declaratie.
Bekijk VERKLARINGEN.

-bl, --accolades-na-als-regel
Zet daarna een beugel aan de lijn if, Etc.
Bekijk STATEN.

-blf, --bretels-na-func-def-lijn
Zet accolades op de lijn volgens de functiedefinitieregel.
Bekijk VERKLARINGEN.

-blin, --beugel-inspringenn
Inspringende beugels n ruimten.
Bekijk STATEN.

-bls, --accolade-na-struct-decl-lijn
Zet daarna beugels op de lijn struct declaratielijnen.
Bekijk VERKLARINGEN.

-br, --accolade-op-als-lijn
Zet beugels op één lijn met if, Etc.
Bekijk STATEN.

-brf, --beugels-op-func-def-line
Zet accolades op de functiedefinitieregel.
Bekijk VERKLARINGEN.

-brs, --accolades-op-struct-decl-line
Zet beugels op struct aangifte lijn.
Bekijk VERKLARINGEN.

-bs, --Bill Shannon, --blanco-voor-groottevan
Zet een spatie ertussen De grootte van en zijn betoog.
Bekijk STATEN.

-cn, --commentaar-inspringingn
Plaats opmerkingen rechts van de code in de kolom n.
Bekijk OPMERKINGEN.

-cbin, --case-brace-inspringingn
Accolades na een zaaklabel N spaties inspringen.
Bekijk STATEN.

-CDn, --verklaring-opmerking-kolomn
Plaats opmerkingen rechts van de declaraties in de kolom n.
Bekijk OPMERKINGEN.

-cdb, --commentaar-scheidingstekens-op-lege-regels
Plaats commentaarscheidingstekens op lege regels.
Bekijk OPMERKINGEN.

-cdw, --knuffel-doe-terwijl
Knuffel terwijl van do {} terwijl; en vóór '}'.
Bekijk OPMERKINGEN.

-dit, --knuffel-anders
Knuffel anders en voorafgaand aan '}'.
Bekijk OPMERKINGEN.

-ditn, --vervolg-inspringingn
Vervolg streepje van n ruimten.
Bekijk STATEN.

-clin, --hoofdletterinspringingn
Kastlabel streepje van n ruimten.
Bekijk STATEN.

-kpn, --else-endif-kolomn
Plaats opmerkingen rechts van #anders en #stop als uitspraken in kolom n.
Bekijk OPMERKINGEN.

-cs, --ruimte-na-cast
Plaats een spatie na een cast-operator.
Bekijk STATEN.

-dn, --regel-opmerkingen-inspringenn
Stel de inspringing van opmerkingen niet rechts van de code in n ruimten.
Bekijk OPMERKINGEN.

-bfda, --break-functie-decl-args
Breek de regel vóór alle argumenten in een declaratie.
Bekijk VERKLARINGEN.

-bfde, --break-functie-decl-args-end
Breek de regel na het laatste argument in een declaratie.
Bekijk VERKLARINGEN.

- dj, --left-justify-declaraties
Als -cd 0 wordt gebruikt, worden opmerkingen na declaraties uitgevuld achter de
verklaring.
Bekijk VERKLARINGEN.

-dun, --verklaring-inspringingn
Zet variabelen in de kolom n.
Bekijk VERKLARINGEN.

-fc1, --format-eerste-kolom-opmerkingen
Formatteer opmerkingen in de eerste kolom.
Bekijk OPMERKINGEN.

-fca, --format-alle-opmerkingen
Schakel niet alle opmaak van opmerkingen uit.
Bekijk OPMERKINGEN.

- gnoes, --gnu-stijl
Gebruik de GNU-coderingsstijl. Dit is de standaardinstelling.
Bekijk GEMEENSCHAPPELIJKE STIJLEN.

-hnl, --eer-nieuwe regels
Geef er de voorkeur aan om lange regels af te breken op de positie van nieuwe regels in de invoer.
Bekijk BREAKING LANG LIJNEN.

-in, --inspring-niveaun
Stel het inspringniveau in op n ruimten.
Bekijk INDENTATIE.

-hijn, --inspring-labeln
Stel de offset in voor labels naar kolom n.
Bekijk INDENTATIE.

-ik pn, --parameter-inspringingn
Laat parametertypen in oude functiedefinities inspringen met n ruimten.
Bekijk INDENTATIE.

-kr, --k-en-r-stijl
Gebruik de codeerstijl van Kernighan & Ritchie.
Bekijk GEMEENSCHAPPELIJKE STIJLEN.

-ln, --lijnlengten
Stel de maximale regellengte voor regels zonder commentaar in op n.
Bekijk BREAKING LANG LIJNEN.

-LCn, --commentaar-regel-lengten
Stel de maximale regellengte voor commentaaropmaak in n.
Bekijk OPMERKINGEN.

-linux, --linux-stijl
Gebruik de Linux-coderingsstijl.
Bekijk GEMEENSCHAPPELIJKE STIJLEN.

-LP, --doorgaan-tussen haakjes
Zet doorlopende lijnen tussen haakjes op één lijn.
Bekijk INDENTATIE.

-lps, --leave-preprocessor-ruimte
Laat ruimte vrij tussen '#' en de preprocessorrichtlijn.
Bekijk INDENTATIE.

-nbad, --geen-lege-regels-na-declaraties
Forceer geen lege regels na declaraties.
Bekijk BLANK LIJNEN.

-nbap, --geen-lege-regels-na-procedures
Forceer geen lege regels na procedureteksten.
Bekijk BLANK LIJNEN.

-nbbo, --break-na-booleaanse-operator
Geef er niet de voorkeur aan om lange regels te onderbreken vóór Booleaanse operatoren.
Bekijk BREAKING LANG LIJNEN.

-nbc, --geen lege regels na komma's
Forceer geen nieuwe regels na komma's in declaraties.
Bekijk VERKLARINGEN.

-nbfda, --dont-break-function-decl-args
Plaats niet elk argument in een functiedeclaratie op een aparte regel.
Bekijk VERKLARINGEN.

-ncdb, --geen commentaarscheidingstekens op lege regels
Plaats geen commentaarscheidingstekens op lege regels.
Bekijk OPMERKINGEN.

-ncdw, --niet-knuffel-doen-terwijl
Niet knuffelen } en en een do {} terwijl;.
Bekijk STATEN.

-nooit, --niet-knuffel-anders
Niet knuffelen } en anders.
Bekijk STATEN.

-ncs, --geen spatie na casts
Plaats geen spatie na cast-operators.
Bekijk STATEN.

-ndjn, --niet-links-rechtvaardig-verklaringen
Opmerkingen na verklaringen worden op dezelfde manier behandeld als opmerkingen na andere verklaringen.
Bekijk VERKLARINGEN.

-nfc1, --niet-format-eerste-kolom-opmerkingen
Formatteer opmerkingen in de eerste kolom niet zoals normaal.
Bekijk OPMERKINGEN.

-nfca, --dont-format-opmerkingen
Formatteer geen opmerkingen.
Bekijk OPMERKINGEN.

-nhnl, --negeer-nieuwe regels
Geef er niet de voorkeur aan om lange regels af te breken op de positie van nieuwe regels in de invoer.
Bekijk BREAKING LANG LIJNEN.

-kneep, --geen-parameter-inspringing
Inspringing van nulbreedte voor parameters.
Bekijk INDENTATIE.

-nlp, --maak geen haakjes op één lijn
Zet de haakjes niet op één lijn.
Bekijk STATEN.

-nst, --geen-spatie-na-functie-aanroepnamen
Plaats geen spatie na de functie in functieaanroepen.
Bekijk STATEN.

-nprs, --geen spatie na haakjes
Plaats geen spatie na elke '(' en vóór elke ')'.
Bekijk STATEN.

-npsl, --niet-onderbreken-procedure-type
Zet het type van een procedure op dezelfde regel als de naam ervan.
Bekijk VERKLARINGEN.

-nsaf, --geen spatie na-voor
Plaats geen spatie na elke For.
Bekijk STATEN.

-nsai, --geen-spatie-na-als
Plaats geen spatie na elke if.
Bekijk STATEN.

-nszag, --geen spatie-na-terwijl
Plaats geen spatie na elke en.
Bekijk STATEN.

-nsc, --geen-ster-opmerkingen
Plaats het teken '*' niet links van opmerkingen.
Bekijk OPMERKINGEN.

-nsob, --leave-optioneel-lege regels
Slik optionele witregels niet in.
Bekijk BLANK LIJNEN.

-ns, --geen spatie-special-puntkomma
Forceer na bepaalde uitspraken geen spatie vóór de puntkomma. Schakelt '-ss' uit.
Bekijk STATEN.

-noot, --geen tabbladen
Gebruik spaties in plaats van tabs.
Bekijk INDENTATIE.

-nv, --geen breedsprakigheid
Schakel de uitgebreide modus uit.
Bekijk DIVERSE OPTIES.

-orig, --origineel
Gebruik de originele Berkeley-codeerstijl.
Bekijk GEMEENSCHAPPELIJKE STIJLEN.

-npro, --negeer-profiel
Lees geen '.indent.pro'-bestanden.
Bekijk INVOEREN INSPRINGEN.

-stuks, --spatie-na-procedure-aanroepen
Voeg een spatie in tussen de naam van de procedure die wordt aangeroepen en de '('.
Bekijk STATEN.

-pin, --paren-inspringingn
Specificeer de extra inspringing per open haakjes '(' wanneer een instructie verbroken is. Zie
STATEN.

-pmt, --behoud-mtime
Behoud de toegangs- en wijzigingstijden voor uitvoerbestanden. Zie DIVERSE OPTIES.

-ppin, --preprocessor-inspringingn
Geef de inspringing op voor voorwaardelijke preprocessorinstructies.Zie INDENTATIE.

-vr, --spatie-na-haakjes
Plaats een spatie na elke '(' en vóór elke ')'.
Bekijk STATEN.

-psl, --procnames-startregels
Zet het type procedure op de regel vóór de naam ervan.
Bekijk VERKLARINGEN.

-veilig, --spatie-na-voor
Zet na elk een spatie For.
Bekijk STATEN.

-sai, --spatie-na-als
Zet na elk een spatie if.
Bekijk STATEN.

-zag, --spatie-na-terwijl
Zet na elk een spatie en.
Bekijk STATEN.

-sbin, --struct-beugel-inspringingn
Laat de accolades van een struct, union of enum N spaties inspringen.
Bekijk STATEN.

-sc, --start-linkerkant-van-commentaar
Plaats het teken '*' links van opmerkingen.
Bekijk OPMERKINGEN.

-snik, --slik-optionele-lege-regels
Slik optionele lege regels door.
Bekijk BLANK LIJNEN.

-SS, --spatie-special-puntkomma
Op één lijn For en en instructies, forceer dan een spatie vóór de puntkomma.
Bekijk STATEN.

-st, --standaard-uitvoer
Schrijf naar standaarduitvoer.
Bekijk INVOEREN INSPRINGEN.

-T Vertellen inspringen de naam van typenamen.
Bekijk VERKLARINGEN.

-tsn, --tabbladgrootten
Stel de tabgrootte in op n ruimten.
Bekijk INDENTATIE.

-u, --gebruik-tabbladen
Gebruik tabbladen. Dit is de standaardinstelling.
Bekijk INDENTATIE.

-v, --uitgebreid
Uitgebreide modus inschakelen.
Bekijk DIVERSE OPTIES.

-versie
Voer het versienummer uit van inspringen.
Bekijk DIVERSE OPTIES.

INVOEREN INSPRINGEN

Vanaf versie 1.3 is het formaat van de inspringen commando is:

streepje [opties] [invoerbestanden]

streepje [opties] [enkelvoudig invoerbestand] [-O output-bestand]

Dit formaat verschilt van eerdere versies en andere versies van inspringen.

In het eerste formulier worden één of meerdere invoerbestanden opgegeven. inspringen maakt een reservekopie van
elk bestand en het originele bestand wordt vervangen door de ingesprongen versie ervan. Zien BACK-UP FILES,
voor uitleg over hoe back-ups worden gemaakt.

In het tweede formulier is slechts één invoerbestand opgegeven. In dit geval, of wanneer de standaard
invoer wordt gebruikt, kunt u een uitvoerbestand opgeven na de optie '-o'.

Veroorzaken inspringen om naar standaarduitvoer te schrijven, gebruikt u de optie '-st'. Dit is alleen toegestaan
wanneer er slechts één invoerbestand is, of wanneer de standaardinvoer wordt gebruikt.

Als er geen invoerbestanden zijn benoemd, wordt de standaardinvoer gelezen voor invoer. Ook als een bestandsnaam
met de naam '-' wordt opgegeven, waarna de standaardinvoer wordt gelezen.

Elk van de volgende opdrachten zal bijvoorbeeld het programma 'slithy_toves.c' en
schrijf de ingesprongen tekst naar 'slithy_toves.out':

streepje slithy_toves.c -o slithy_toves.out

streepje -st slithy_toves.c > slithy_toves.out

kat slithy_toves.c | streepje -o slithy_toves.out

De meeste andere opties inspringen bepalen hoe programma's worden geformatteerd. Vanaf versie 1.2,
inspringen herkent ook een lange naam voor elke optienaam. Lange opties worden voorafgegaan door
'--' of '+'. [ '+' wordt vervangen door '--' om de consistentie met de
POSIX-standaard.]
In het grootste deel van dit document worden omwille van de beknoptheid de traditionele, korte namen gebruikt.
Bekijk OPTIE OVERZICHT, voor een lijst met opties, inclusief zowel lange als korte namen.

Hier is nog een voorbeeld:

streepje -br test/metabolisme.c -l85

Hierdoor wordt het programma 'test/metabolism.c' ingesprongen met de opties '-br' en '-l85', schrijf
de uitvoer terug naar 'test/metabolism.c', en schrijf de originele inhoud ervan
'test/metabolism.c' naar een back-upbestand in de map 'test'.

Equivalente aanroepen met lange optienamen voor dit voorbeeld zouden zijn:

streepje --accolade-op-als-lijn --line-length185 test/metabolisme.c

streepje + accolades-op-als-lijn +lijnlengte185 test/metabolisme.c

Als je merkt dat je dat vaak gebruikt inspringen met dezelfde opties, kunt u die opties plaatsen
naar een bestand met de naam '.indent.pro'. inspringen zal op drie plaatsen naar een profielbestand zoeken.
Eerst wordt de omgevingsvariabele gecontroleerd INDENT_PROFIEL. Als dat bestaat, is de waarde ervan
verwacht dat het bestand een naam krijgt die moet worden gebruikt. Als de omgevingsvariabele niet bestaat,
indent zoekt naar '.indent.pro' in de huidige map
en gebruik dat als je het vindt. Eindelijk inspringen zal in uw thuismap zoeken naar '.indent.pro'
en gebruik dat bestand als het wordt gevonden. Dit gedrag is anders dan dat van andere versies
of inspringen, die beide bestanden laadt als ze allebei bestaan.

Het formaat van '.indent.pro' is eenvoudigweg een lijst met opties, precies zoals ze op het
opdrachtregel, gescheiden door witruimte (tabs, spaties en nieuwe regels). Opties binnen
'.indent.pro' kan worden omgeven door C- of C++-opmerkingen, in welk geval deze worden genegeerd.

Commandoregelschakelaars worden afgehandeld na verwerking van '.indent.pro'. Opties die later worden gespecificeerd
overschrijf de eerder opgegeven argumenten, met één uitzondering: expliciet opgegeven opties
overschrijf altijd achtergrondopties (zie GEMEENSCHAPPELIJKE STIJLEN). Je kunt voorkomen inspringen oppompen van
het lezen van een '.indent.pro'-bestand door de optie '-npro' op te geven.

BACK-UP FILES

Vanaf versie 1.3, GNU inspringen maakt back-upbestanden in GNU-stijl, op dezelfde manier als GNU Emacs dat doet.
Dit betekent dat ook simpel or genummerd back-upbestandsnamen kunnen worden gemaakt.

Eenvoudige back-upbestandsnamen worden gegenereerd door een achtervoegsel aan de oorspronkelijke bestandsnaam toe te voegen.
De standaardwaarde voor dit achtervoegsel is de tekenreeks van één teken '~' (tilde). De back-up dus
bestand voor 'python.c' zou 'python.c~' zijn.

In plaats van de standaardwaarde kunt u elke tekenreeks als achtervoegsel opgeven door de omgeving in te stellen
variabele SIMPLE_BACKUP_SUFFIX naar het door u gewenste achtervoegsel.

Genummerde back-upversies van een bestand 'momeraths.c' zien eruit als 'momeraths.c.~23~', waarbij 23 is
de versie van deze specifieke back-up. Bij het maken van een genummerde back-up van het bestand
'src/momeraths.c', het back-upbestand krijgt de naam 'src/momeraths.c.~V~', waar V is een
groter dan de hoogste versie die momenteel in de map 'src' aanwezig is. De
variabele omgeving VERSION_WIDTH regelt het aantal cijfers, met behulp van linkernulvulling
wanneer nodig. Als u deze variabele bijvoorbeeld op "2" instelt, wordt naar het back-upbestand geleid
met de naam 'momeraths.c.~04~'.

Het type back-upbestand dat wordt gemaakt, wordt bepaald door de waarde van de omgevingsvariabele
VERSIEBEHEER. Als het de string 'simple' is, worden er alleen eenvoudige back-ups gemaakt. Als
de waarde ervan is de tekenreeks 'genummerd', waarna er genummerde back-ups worden gemaakt. Als de waarde ervan is
'genummerd-bestaand', dan worden er genummerde back-ups gemaakt als die er zijn al bestaan genummerd
back-ups van het bestand dat wordt ingesprongen; anders wordt er een eenvoudige back-up gemaakt. Als
VERSIEBEHEER is niet ingesteld, dan inspringen gaat uit van het gedrag van 'genummerd-bestaand'.

andere versies van inspringen gebruik het achtervoegsel '.BAK' bij het benoemen van back-upbestanden. Dit gedrag kan
worden geëmuleerd door instelling SIMPLE_BACKUP_SUFFIX naar '.BAK'.

Merk ook op dat andere versies van inspringen maak back-ups in de huidige map, in plaats van
in de directory van het bronbestand als GNU inspringen nu wel.

GEMEENSCHAPPELIJKE STIJLEN

Er zijn verschillende veel voorkomende stijlen van C-code, waaronder de GNU-stijl, de Kernighan &
Ritchie-stijl en de originele Berkeley-stijl. Met een enkele stijl kan een stijl worden geselecteerd
achtergrond optie, die een reeks waarden voor alle andere opties specificeert. Echter,
expliciet opgegeven opties overschrijven altijd de opties die door een achtergrondoptie worden geïmpliceerd.

Vanaf versie 1.2 is dit de standaardstijl van GNU inspringen is de GNU-stijl. Het is dus nee
Het is langer nodig om de optie '-gnu' te specificeren om dit formaat te verkrijgen, hoewel dit wel gebeurt
zal geen fout veroorzaken. Optie-instellingen die overeenkomen met de GNU-stijl zijn:

-nbad -bap -nbc -bbo -bl -bli2 -bls -ncdb -nce -cp1 -cs -di2
-ndj -nfc1 -nfca -hnl -i2 -ip5 -lp -pcs -nprs -psl -saf -sai
-zaag -nsc -nsob

De GNU-codeerstijl heeft de voorkeur van het GNU-project. Het is de stijl die de GNU
Emacs C-modus moedigt aan en wordt gebruikt in de C-gedeelten van GNU Emacs. (Mensen
geïnteresseerd in het schrijven van programma's voor Project GNU zou een exemplaar moeten krijgen van "The GNU Coding
Standards", die ook betrekking heeft op semantische en portabiliteitskwesties, zoals geheugengebruik, de
grootte van gehele getallen, enz.)

De Kernighan & Ritchie-stijl wordt gebruikt in hun bekende boek "The C Programming
Taal". Het wordt ingeschakeld met de optie '-kr'. De Kernighan & Ritchie-stijl
komt overeen met de volgende reeks opties:

-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 -zag -nsc -nsob -nss

De stijl van Kernighan & Ritchie plaatst geen commentaar rechts van de code in dezelfde kolom op
altijd (en er wordt ook niet slechts één spatie rechts van de code gebruikt), dus voor deze stijl
inspringen heeft willekeurig kolom 33 gekozen.

De stijl van het originele Berkeley inspringen kan worden verkregen door '-orig' op te geven (of door
door '--original' op te geven, met behulp van de lange optienaam). Deze stijl is gelijk aan de
volgende instellingen:

-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 -zag -sc -nsob -nss -ts8

De Linux-stijl wordt gebruikt in de Linux-kernelcode en stuurprogramma's. Code moet over het algemeen volgen
de Linux-coderingsstijl die moet worden geaccepteerd. Deze stijl komt overeen met het volgende
instellingen:

-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 -zaag -ncs -nsc -sob -nfca -cp33 -ss -ts8 -il1

BLANK LIJNEN

Verschillende programmeerstijlen gebruiken op verschillende plaatsen lege regels. inspringen heeft een aantal
opties om op specifieke plaatsen lege regels in te voegen of te verwijderen.

De '-slecht' optie veroorzaakt inspringen om na elk blok met declaraties een lege regel te forceren.
De optie '-nbad' veroorzaakt inspringen om zulke lege regels niet te forceren.

De optie '-bap' dwingt een lege regel af na elke proceduretekst. De '-nbap'-optie
dwingt een dergelijke lege regel af.

De optie '-bbb' dwingt een lege regel af vóór elk commentaar in een kader (zie OPMERKINGEN.) De
De optie '-nbbb' forceert dergelijke lege regels niet.

De '-sob'-optie veroorzaakt inspringen om optionele lege regels in te slikken (dat wil zeggen, eventuele optionele
lege regels in de invoer worden uit de uitvoer verwijderd). Als de '-nsob' is
opgegeven, worden eventuele lege regels in het invoerbestand naar het uitvoerbestand gekopieerd.

--lege regels-na-declaraties

De optie '-bad' forceert een lege regel na elk blok met declaraties. De '-nbad'
optie voegt dergelijke lege regels niet toe.

Bijvoorbeeld gezien de invoer
char *foe;
teken *balk;
/* Dit scheidt blokken met declaraties. */
int baz;

inspringen -slecht produceert

char *foe;
teken *balk;

/* Dit scheidt blokken met declaraties. */
int baz;

en inspringen -nbad produceert

char *foe;
teken *balk;
/* Dit scheidt blokken met declaraties. */
int baz;

--lege regels-na-procedures

De optie '-bap' dwingt een lege regel af na elke proceduretekst.

Bijvoorbeeld gezien de invoer

int
Foo ()
{
zet("Hallo");
}
/* De procedurebalk is zelfs nog minder interessant. */
teken *
bar ()
{
zet("Hallo");
}

inspringen -bap produceert

int
Foo ()
{
zet ("Hallo");
}

/* De procedurebalk is zelfs nog minder interessant. */
teken *
bar ()
{
zet ("Hallo");
}

en inspringen -nbap produceert

int
Foo ()
{
zet ("Hallo");
}
/* De procedurebalk is zelfs nog minder interessant. */
teken *
bar ()
{
zet ("Hallo");
}

Er wordt na de procedure geen lege regel toegevoegd foo.

OPMERKINGEN

inspringen formatteert zowel C- als C++-opmerkingen. C-opmerkingen beginnen met '/*' en eindigen met
'*/' en kan nieuweregeltekens bevatten. C++-opmerkingen beginnen met het scheidingsteken '//' en
eindigen op de nieuwe regel.

inspringen verwerkt opmerkingen anders, afhankelijk van hun context. inspringen probeert om
maak onderscheid tussen commentaren die volgen op verklaringen, commentaren die volgen op verklaringen,
commentaar dat volgt op preprocessor-richtlijnen, en commentaar dat niet wordt voorafgegaan door code of
welke soort dan ook, dwz ze beginnen met de tekst van de regel (hoewel niet noodzakelijkerwijs in kolom 1).

inspringen maakt verder onderscheid tussen opmerkingen die buiten de procedures en aggregaten worden aangetroffen,
en die daarin gevonden worden. Met name opmerkingen die beginnen met een regel binnen a
procedure wordt ingesprongen in de kolom waarin de code momenteel is ingesprongen. De
uitzondering hierop is een commentaar dat begint in de meest linkse kolom; zo'n commentaar wordt uitgevoerd
bij die kolom.

inspringen probeert te vertrekken boxed opmerkingen ongewijzigd. Het algemene idee van een dergelijke opmerking is
dat het is ingesloten in een rechthoek of ‘doos’ met sterren of streepjes om het visueel te onderscheiden.
Preciezer gezegd, omkaderde commentaren worden gedefinieerd als commentaren waarin de initiaal '/*' wordt gevolgd
onmiddellijk door het teken '*', '=', '_' of '-', of de tekens waarin het begin staat
commentaarscheidingsteken ('/*') staat op zichzelf op een regel en de volgende regel begint met een '*'
in dezelfde kolom als de ster van het openingsscheidingsteken.

Voorbeelden van omkaderde opmerkingen zijn:

/*************************
* Reageer in een vakje!! *
*************************/

/*
* Een ander soort geur,
* voor een ander soort commentaar.
*/

inspringen probeert de omkaderde opmerkingen precies zo achter te laten als ze in het bronbestand worden aangetroffen.
De inspringing van het commentaar blijft dus ongewijzigd en de lengte ervan wordt nergens gecontroleerd
manier. De enige wijziging die is aangebracht, is dat een ingesloten tabteken kan worden omgezet in de
passend aantal plaatsen.

Als de optie '-bbb' is opgegeven, worden al deze omkaderde opmerkingen voorafgegaan door een spatie
regel, tenzij een dergelijk commentaar wordt voorafgegaan door code.

Opmerkingen die geen omkaderde opmerkingen zijn, kunnen worden opgemaakt, wat betekent dat de regel dat wel is
gebroken om binnen de rechtermarge te passen en links gevuld met witruimte. Enkele nieuwe regels zijn dat wel
gelijk aan een spatie, maar met blanco regels (twee of meer nieuwe regels op een rij) wordt a bedoeld
paragraaf pauze. Opmaak van opmerkingen die beginnen na de eerste kolom is ingeschakeld
met de optie '-fca'. Om degenen die in kolom één beginnen op te maken, specificeert u '-fc1'. Zo een
formatteren is standaard uitgeschakeld.

De rechtermarge voor opmaak is standaard 78, maar kan worden gewijzigd met de optie '-lc'.
Als de opgegeven marge het niet mogelijk maakt om de opmerking af te drukken, zal de marge dat wel zijn
automatisch verlengd voor de duur van die opmerking. De marge wordt niet gerespecteerd als
de opmerking wordt niet opgemaakt.

Als het commentaar met een regel begint (dwz er staat links geen programmatekst), dan zal dat zo zijn
ingesprongen in de kolom waarin deze is gevonden, tenzij de opmerking zich binnen een codeblok bevindt. In
in dat geval wordt een dergelijke opmerking uitgelijnd met de ingesprongen code van dat blok (tenzij de
opmerking begon in de eerste kolom). Deze uitlijning kan worden beïnvloed door de optie '-d',
die een bedrag specificeert waarmee dergelijke opmerkingen naar de links, of niet ingesprongen.
Met '-d2' worden opmerkingen bijvoorbeeld twee spaties links van de code geplaatst. Standaard opmerkingen
zijn uitgelijnd met de code, tenzij ze in de eerste kolom beginnen. In dat geval blijven ze staan
daar standaard --- om ze uitgelijnd te krijgen met de code, specificeert u '-fc1'.

Opmerkingen rechts van de code verschijnen standaard in kolom 33. Dit kan worden gewijzigd
met een van de drie opties. '-c' specificeert de kolom voor opmerkingen na code,
'-cd' specificeert de kolom voor commentaar na declaraties, en '-cp' specificeert de
kolom voor commentaar na preprocessorrichtlijnen #anders en #stop als. '-dj' samen
met '-cd0' kan worden gebruikt om de uitlijning van opmerkingen rechts van declaraties te onderdrukken,
waardoor de opmerking één tabstop na het einde van de declaratie volgt. Normaal gesproken '-cd0'
zorgt ervoor dat '-c' effectief wordt.

Als de code links van het commentaar de beginkolom overschrijdt, de commentaarkolom
wordt uitgebreid naar de volgende tabstopkolom na het einde van de code, of in het geval van
preprocessor-richtlijnen, tot één spatie voorbij het einde van de richtlijn. Deze verlenging duurt
alleen voor de uitvoer van dat specifieke commentaar.

De optie '-cdb' plaatst de commentaarscheidingstekens op lege regels. Eén lijn dus
commentaar zoals /* Loving knuffelen */ kan worden omgezet in:

/*
Liefdevolle knuffel
*/

Sterren kunnen aan het begin van commentaar met meerdere regels worden geplaatst met de optie '-sc'. Dus,
het commentaar van één regel hierboven kan worden omgezet (met '-cdb -sc') in:

/*
*Liefdevolle knuffel
*/

STATEN

De optie '-br' of '-bl' specificeert hoe accolades moeten worden opgemaakt.

Met de optie '-br' worden statement-accolades als volgt opgemaakt:

als (x > 0) {
X--;
}

De optie '-bl' formatteert ze als volgt:

als (x > 0)
{
X--;
}

Als u de optie '-bl' gebruikt, wilt u wellicht ook de optie '-bli' opgeven. Deze optie
specificeert het aantal spaties waarmee accolades worden ingesprongen. '-bli2', de standaardwaarde, geeft
het hierboven getoonde resultaat. '-bli0' resulteert in het volgende:

als (x > 0)
{
X--;
}

Als u de optie '-br' gebruikt, wilt u waarschijnlijk ook de optie '-ce' gebruiken. Dit
veroorzaakt de anders in een als-dan-anders-constructie om te knuffelen met het onmiddellijk voorafgaande
'}'. Met '-br -ce' krijg je bijvoorbeeld het volgende:

als (x > 0) {
X--;
} Else {
fprintf (stderr, "...iets mis?\n");
}

Met '-br -nce' zou die code verschijnen als

als (x > 0) {
X--;
}
else {
fprintf (stderr, "...iets mis?\n");
}

Dit veroorzaakt de en in een do-while-lus om te knuffelen met de onmiddellijk voorafgaande '}'.
Met '-cdw' krijg je bijvoorbeeld het volgende:

Doen {
X--;
} terwijl (x);

Met '-ncdw' zou die code verschijnen als

Doen {
X--;
}
terwijl (x);

De optie '-cli' specificeert het aantal spaties waarin de caselabels moeten worden ingesprongen
het recht van de bevattende schakelaar verklaring.

De standaard geeft code als:

schakelaar (ik)
{
geval 0:
te breken;
geval 1:
{
++ ik;
}
default:
te breken;
}

Met behulp van de '-cli2' zou dat worden:

schakelaar (ik)
{
geval 0:
te breken;
geval 1:
{
++ ik;
}
default:
te breken;
}

De inspringing van de accolades onder een case-instructie kan worden geregeld met de '-cbin'
keuze. Als u bijvoorbeeld '-cli2 -cbi0' gebruikt, resulteert dit in:

schakelaar (ik)
{
geval 0:
te breken;
geval 1:
{
++ ik;
}
default:
te breken;
}

Als een puntkomma op dezelfde regel staat als a For or en statement, zal de '-ss' optie dat wel doen
ervoor zorgen dat er een spatie vóór de puntkomma wordt geplaatst. Dit benadrukt de puntkomma en maakt deze
duidelijk dat het lichaam van de For or en verklaring is een lege verklaring. '-nss' wordt uitgeschakeld
deze functie.

De optie '-pcs' zorgt ervoor dat er een spatie wordt geplaatst tussen de naam van de procedure
aangeroepen en de '(' (bijvoorbeeld puts ("Hoi");. De optie '-npcs' zou geven
zet("Hallo");).

Als de optie '-cs' is opgegeven, inspringen plaatst een spatie tussen een cast-operator en de
voorwerp dat moet worden gegoten. De '-ncs' zorgt ervoor dat er geen spatie zit tussen de cast-operator en
het object. Onthoud dat inspringen kent alleen de standaard C-gegevenstypen en kan dat dus niet
door de gebruiker gedefinieerde typen in casts herkennen. Dus (mijntype) ding wordt niet behandeld als een cast.

De optie '-bs' zorgt ervoor dat er een spatie tussen het trefwoord staat De grootte van en
argument. In sommige versies staat dit bekend als de 'Bill_Shannon'-optie.

De optie '-saf' forceert een spatie tussen a For en het volgende haakje. Dit is de
standaard.

De optie '-sai' forceert een spatie tussen a if en het volgende haakje. Dit is de
standaard.

De optie '-saw' forceert een spatie tussen a en en het volgende haakje. Dit is
de standaard.

De optie '-prs' zorgt ervoor dat alle haakjes worden gescheiden door een spatie
tussen hen. Als u bijvoorbeeld '-prs' gebruikt, resulteert dit in code zoals:

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

VERKLARINGEN

Standaard inspringen zal identificatiegegevens op een rij zetten, in de kolom gespecificeerd door de '-di' optie.
Met '-di16' ziet het er bijvoorbeeld als volgt uit:

int foo;
teken *balk;

Het gebruik van een kleine waarde (zoals één of twee) voor de optie '-di' kan worden gebruikt om de
identificatiegegevens die op de eerste beschikbare positie moeten worden geplaatst; Bijvoorbeeld:

int foo;
teken *balk;

De waarde die aan de optie '-di' wordt gegeven, heeft nog steeds invloed op variabelen die afzonderlijk zijn ingesteld
regels van hun typen, bijvoorbeeld '-di2', zullen leiden tot:

int
foe;

Als de optie '-bc' is opgegeven, wordt na elke komma in een declaratie een nieuwe regel geforceerd.
Bijvoorbeeld

int een,
b,
c;

Met de optie '-nbc' zou dit er zo uitzien

int a, b, c;

De optie '-bfda' zorgt ervoor dat er een nieuwe regel wordt geforceerd na de komma die de argumenten scheidt
van een functiedeclaratie. De argumenten verschijnen op één inspringniveau dieper dan
de functiedeclaratie. Dit is vooral handig voor functies met lange argumenten
lijsten. De optie '-bfde' zorgt ervoor dat een nieuwe regel wordt geforceerd vóór het haakje sluiten van de
functieverklaring. Voor beide opties is de 'n'-instelling de standaard: -nbdfa en -nbdfe.

Bijvoorbeeld

leegte foo (int arg1, char arg2, int *arg3, long arg4, char arg5);
Met de optie '-bfda' zou dit er zo uitzien

leegte foo (
int arg1,
teken arg2,
int *arg3,
lange arg4,
char arg5);

Met daarnaast de optie '-bfde' zou dit er zo uitzien

leegte foo (
int arg1,
teken arg2,
int *arg3,
lange arg4,
teken arg5
);

De optie '-psl' zorgt ervoor dat het type procedure dat wordt gedefinieerd op de regel wordt geplaatst
vóór de naam van de procedure. Deze stijl is vereist voor de tags programma om te werken
correct, evenals enkele van de c-modus functies van Emacs.

U moet de optie '-T' gebruiken om dit te vertellen inspringen de naam van alle typenamen in uw programma
die worden gedefinieerd door typedef. '-T' kan meerdere keren worden opgegeven, en alle namen
gespecificeerd worden gebruikt. Als uw programma bijvoorbeeld

typedef niet-ondertekend lang CODE_ADDR;
typedef enum {rood, blauw, groen} KLEUR;

je zou de opties '-T CODE_ADDR -T COLOR' gebruiken.

De optie '-brs' of '-bls' specificeert hoe accolades in struct-declaraties moeten worden opgemaakt. De
'-brs' optie formatteert accolades als volgt:

struct foo {
int x;
};

De optie '-bls' formatteert ze als volgt:

structuur foo
{
int x;
};

Vergelijkbaar met de structuuraccolade '-brs' en '-bls' opties,
de functie accolade-opties '-brf' of '-blf' specificeren hoe de accolades in functie moeten worden opgemaakt
definities. De optie '-brf' formatteert accolades als volgt:

int een(nietig) {
1 terug;
};

De optie '-blf' formatteert ze als volgt:

int één (nietig)
{
1 terug;
};

INDENTATIE

Een probleem bij de opmaak van code is hoe ver elke regel van links moet worden ingesprongen
marge. Wanneer het begin van een verklaring zoals if or For wordt aangetroffen, de
het inspringniveau wordt verhoogd met de waarde die is opgegeven door de optie '-i'. Bijvoorbeeld,
gebruik '-i8' om voor elk niveau een inspringing van acht tekens op te geven. Wanneer een verklaring is
verdeeld over twee regels, wordt de tweede regel ingesprongen met een aantal extra spaties
gespecificeerd door de optie '-ci'. '-ci' is standaard ingesteld op 0. Als de optie '-lp' dat wel is
opgegeven, en een regel heeft dan een haakje links dat niet op die regel wordt gesloten
vervolglijnen worden opgesteld om te beginnen op de tekenpositie net na links
haakje. Deze verwerking is ook van toepassing op '[' en is van toepassing op '{' wanneer deze plaatsvindt in
initialisatielijsten. Een stuk voortgezette code kan er bijvoorbeeld zo uitzien met
'-nlp -ci3' is van kracht:

p1 = eerste_procedure (tweede_procedure (p2, p3),
derde_procedure (p4, p5));

Met '-lp' ziet de code er wat duidelijker uit:

p1 = eerste_procedure (tweede_procedure (p2, p3),
derde_procedure (p4, p5));

Wanneer een uitspraak wordt opgesplitst tussen twee of meer bovenliggende paren (...), wordt elk extra paar
zorgt ervoor dat het inspringniveau extra inspringt:

als ((((ik < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

De optie '-ipN' kan worden gebruikt om de extra verschuiving per ouder in te stellen. Bijvoorbeeld '-ip0'
zou het bovenstaande formatteren als:

als ((((ik < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

inspringen gaat ervan uit dat tabbladen op regelmatige intervallen van zowel invoer als uitvoer worden geplaatst
karakterstromen. Deze intervallen zijn standaard 8 kolommen breed, maar (vanaf versie 1.2)
kan worden gewijzigd met de optie '-ts'. Tabbladen worden behandeld als het equivalente aantal spaties.

De inspringing van typedeclaraties in functiedefinities in oude stijl wordt geregeld door
de '-ip'-parameter. Dit is een numerieke parameter die specificeert hoeveel spaties er moeten worden ingesprongen
soort aangiften. De standaard '-ip5' zorgt er bijvoorbeeld voor dat definities er als volgt uitzien:

teken *
create_world (x, y, schaal)
int x;
int y;
vlotter schaal;
{
. . .
}

Voor compatibiliteit met andere versies van indent is de optie '-nip' beschikbaar
gelijk aan '-ip0'.

Met ANSI C kan er witruimte worden geplaatst op de opdrachtregels van de preprocessor tussen het teken
'#' en de opdrachtnaam. Standaard, inspringen verwijdert deze spatie, maar specificeert de
'-lps' optie stuurt inspringen om deze ruimte ongewijzigd te laten. De optie '-ppi' heeft voorrang
'-nlps' en '-lps'.

Deze optie kan worden gebruikt om aan te vragen dat preprocessor voorwaardelijke instructies kunnen worden gegeven
ingesprongen met een bepaald aantal spaties, bijvoorbeeld met de optie '-ppi 3'

#als X
#als Y
#define Z 1
#anders
#define Z 0
#stop als
#stop als
wordt
#als X
# als Y
# definieer Z 1
# anders
# definieer Z 0
# stop als
#stop als

Met deze optie stelt u de offset in waarop een label (behalve dooslabels) wordt gepositioneerd. Als
deze is ingesteld op nul of een positief getal, dit geeft aan hoe ver de linkermarge verwijderd is
een label inspringen. Als het op een negatief getal is ingesteld, geeft dit aan hoe ver terug van de
huidige inspringniveau om het label te plaatsen. De standaardinstelling is -2, wat overeenkomt met de
gedrag van eerdere versies van inspringen. Houd er rekening mee dat deze parameter geen invloed heeft op de
plaatsen van kofferlabels; zie daarvoor de parameter '-cli'. Bijvoorbeeld met de optie
'-il 1'

groep
functie()
{
als (do_stuff1() == FOUT)
ga naar opruimen1;

als (do_stuff2() == FOUT)
ga naar opruimen2;

terugkeer SUCCES;

opruimen2:
doe_opruim2();

opruimen1:
doe_opruim1();

retourneer FOUT;
}
wordt
groep
functie()
{
als (do_stuff1() == FOUT)
ga naar opruimen1;

als (do_stuff2() == FOUT)
ga naar opruimen2;

terugkeer SUCCES;

opruimen2:
doe_opruim2();

opruimen1:
doe_opruim1();

retourneer FOUT;
}

BREAKING LANG LIJNEN

Met de optie '-ln', of '--regellengten', is het mogelijk om de maximale lengte op te geven
van een regel C-code, exclusief eventuele opmerkingen die daarop volgen.

Wanneer regels langer worden dan de opgegeven regellengte, kan GNU inspringen probeert de te doorbreken
lijn op een logische plaats. Dit is echter nieuw vanaf versie 2.1 en niet erg intelligent
of nog flexibel.

Momenteel zijn er twee opties waarmee je het algoritme kunt verstoren
bepaalt waar een lijn moet worden doorbroken.

De optie '-bbo' veroorzaakt GNU inspringen om de voorkeur te geven aan het afbreken van lange regels vóór de Booleaanse waarde
exploitanten && en ||. De optie '-nbbo' veroorzaakt GNU inspringen hebben die voorkeur niet. Voor
bijvoorbeeld de standaardoptie '-bbo' (samen met '--line-length60' en '--ignore-
newlines') zorgt ervoor dat de code er als volgt uitziet:

als (masker
&& ((masker[0] == '\0')
|| (masker[1] == '\0'
&& ((masker[0] == '0') || (masker[0] == '*')))))

Als u de optie '-nbbo' gebruikt, ziet het er als volgt uit:

als (masker &&
((masker[0] == '\0') ||
(masker[1] == '\0' &&
((masker[0] == '0') || (masker[0] == '*')))))

De standaard '-hnl' respecteert echter nieuwe regels in het invoerbestand door ze de hoogste te geven
mogelijke prioriteit om lijnen te breken. Als het invoerbestand er bijvoorbeeld zo uitziet:

als (masker
&& ((masker[0] == '\0')
|| (masker[1] == '\0' && ((masker[0] == '0') || (masker[0] == '*')))))

gebruik vervolgens de optie '-hnl', of '--honour-newlines', samen met de vorige
genoemde '-nbbo' en '--line-length60', zal ervoor zorgen dat de uitvoer niet is wat is opgegeven in
het laatste voorbeeld, maar geeft er de voorkeur aan om te breken op de posities waar de code stond
gebroken in het invoerbestand:

als (masker
&& ((masker[0] == '\0')
|| (masker[1] == '\0' &&
((masker[0] == '0') || (masker[0] == '*')))))

Het idee achter deze optie is dat lijnen die te lang zijn, maar al zijn opgebroken,
zal niet worden aangetast door GNU inspringen. Echt rommelige code moet worden doorlopen inspringen at
Wel minstens één keer met behulp van de optie '--ignore-newlines'.

UITSCHAKELEN FORMATTEREN

Het formatteren van C-code kan voor delen van een programma worden uitgeschakeld door speciaal in te sluiten
onder controle te houden opmerkingen in het programma. Als u de opmaak voor een gedeelte van een programma wilt uitschakelen, plaatst u
de uitschakelingscontrolecommentaar /* *INDENT-UIT* */ op een regel alleen, vlak daarvoor
sectie. Programmatekst die na dit besturingscommentaar wordt gescand, wordt precies als invoer uitgevoerd
zonder wijzigingen totdat het corresponderende inschakelcommentaar op één regel wordt gescand
zelf. De opmerking over het uitschakelen van de controle is /* *INDENT-AAN* */, en elke tekst die volgt op de
commentaar op de regel wordt ook ongeformatteerd uitgevoerd. Het formatteren begint opnieuw met de invoer
regel na het inschakelen van controlecommentaar.

Preciezer, inspringen probeert niet het sluitscheidingsteken te verifiëren (*/) voor deze C
opmerkingen en eventuele witruimte op de regel is volledig transparant.

Deze controleopmerkingen functioneren ook in hun C++-formaten, namelijk // *INDENT-UIT* en //
*INDENT-AAN*.

Opgemerkt moet worden dat de interne toestand van inspringen blijft in de loop van de tijd onveranderd
het niet-geformatteerde gedeelte. Als u bijvoorbeeld de opmaak midden in een
functie en het voortzetten ervan na afloop van de functie kan tot bizarre resultaten leiden. Het
Het is daarom verstandig om enigszins modulair te zijn bij het selecteren van code die ongeformatteerd moet blijven.

Als historische noot: enkele eerdere versies van inspringen geproduceerde foutmeldingen beginnen
Met *INSPRINGEN**. Deze versies van inspringen zijn geschreven om invoertekstregels te negeren
die begon met dergelijke foutmeldingen. Ik heb deze incestueuze eigenschap uit GNU verwijderd
inspringen.

DIVERSE OPTIES

Om erachter te komen welke versie van inspringen je hebt, gebruik dan de opdracht inspringen -versie. Dit zal
vermeld het versienummer van inspringen, zonder enige normale verwerking uit te voeren.

De optie '-v' kan worden gebruikt om de uitgebreide modus in te schakelen. Wanneer u zich in de uitgebreide modus bevindt, inspringen meldt
wanneer het een invoerregel opsplitst in nog twee regels uitvoer, en enige grootte geeft
statistieken bij voltooiing.

De optie '-pmt' veroorzaakt inspringen om de toegangs- en wijzigingstijden op de
uitvoerbestanden. Het gebruik van deze optie heeft het voordeel dat inspringen op alle bron- en
header-bestanden in een project veroorzaken geen maken om alle doelen opnieuw op te bouwen. Deze optie is alleen
beschikbaar op besturingssystemen met POSIX tijd(2) functie.

Gebruik online inspringen met behulp van onworks.net-services