indent - Online sa Cloud

PROGRAMA:

NAME

indent - binabago ang hitsura ng isang C program sa pamamagitan ng pagpasok o pagtanggal ng whitespace.

SINOPSIS

indent [mga opsyon] [input-file]

indent [mga opsyon] [single-input-file] [-o output-file]

indent --bersyon

DESCRIPTION

Ang man page na ito ay nabuo mula sa file indent.texinfo. Ito ang Edisyon ng "Ang indent
Manual", para sa Indent Version , huling na-update .

Ang indent Maaaring gamitin ang programa upang gawing mas madaling basahin ang code. Maaari rin itong mag-convert mula sa isa
istilo ng pagsulat C sa iba.

indent naiintindihan ang isang malaking halaga tungkol sa syntax ng C, ngunit sinusubukan din nitong
makayanan ang hindi kumpleto at maling syntax.

Sa bersyon 1.2 at higit pang mga kamakailang bersyon, ang GNU style of indenting ay ang default.

Opsyon

-masama, --blank-lines-after-declarations
Pilitin ang mga blangkong linya pagkatapos ng mga deklarasyon.
Tingnan BLANKO MGA LINYA.

-bap, --blangko-linya-pagkatapos-mga-pamamaraan
Pilitin ang mga blangkong linya pagkatapos ng mga katawan ng pamamaraan.
Tingnan BLANKO MGA LINYA.

-bbb, --blank-lines-before-block-comments
Pilitin ang mga blangkong linya bago i-block ang mga komento.
Tingnan BLANKO MGA LINYA.

-bbo, --break-before-boolean-operator
Mas gusto na masira ang mahabang linya bago ang mga boolean operator.
Tingnan Pagsira LONG MGA LINYA.

-bc, --blank-lines-after-comma
Pilitin ang bagong linya pagkatapos ng kuwit sa deklarasyon.
Tingnan MGA PAHAYAG.

-bl, --braces-pagkatapos-kung-linya
Maglagay ng mga braces sa linya pagkatapos if, Atbp
Tingnan Mga pahayag.

-blf, --braces-after-func-def-line
Ilagay ang mga braces sa linya kasunod ng linya ng kahulugan ng function.
Tingnan MGA PAHAYAG.

-blin, --brace-indentn
Indent braces n mga puwang.
Tingnan Mga pahayag.

-bls, --braces-after-struct-decl-line
Maglagay ng braces sa linya pagkatapos istruktura mga linya ng deklarasyon.
Tingnan MGA PAHAYAG.

-br, --braces-on-if-line
Maglagay ng mga braces sa linya na may if, Atbp
Tingnan Mga pahayag.

-brf, --braces-on-func-def-line
Maglagay ng mga braces sa linya ng kahulugan ng function.
Tingnan MGA PAHAYAG.

-brs, --braces-on-struct-decl-line
Maglagay ng braces istruktura linya ng deklarasyon.
Tingnan MGA PAHAYAG.

-bs, --Bill-Shannon, --blangko-before-sizeof
Maglagay ng espasyo sa pagitan sukat ng at ang argumento nito.
Tingnan Mga pahayag.

-cn, --comment-indentationn
Maglagay ng mga komento sa kanan ng code sa column n.
Tingnan KOMENTARYO.

-cbin, --case-brace-indentationn
Indent ang mga brace pagkatapos ng isang case label na N mga puwang.
Tingnan Mga pahayag.

-cdn, --declaration-comment-columnn
Maglagay ng mga komento sa kanan ng mga deklarasyon sa hanay n.
Tingnan KOMENTARYO.

-cdb, --comment-delimiters-sa-blangko-linya
Maglagay ng mga delimiter ng komento sa mga blangkong linya.
Tingnan KOMENTARYO.

-cdw, --cuddle-do-habang
Yakap habang ng do {} habang; at nauuna '}'.
Tingnan KOMENTARYO.

-ito, --yakapin-iba
Yakap sa iba at sa unahan ng '}'.
Tingnan KOMENTARYO.

-iton, --pagpapatuloy-indentasyonn
Pagpapatuloy ng indent ng n mga puwang.
Tingnan Mga pahayag.

-clin, --case-indentationn
Indent ng case label ng n mga puwang.
Tingnan Mga pahayag.

-cpn, --else-endif-columnn
Maglagay ng mga komento sa kanan ng #iba at #endif mga pahayag sa hanay n.
Tingnan KOMENTARYO.

-cs, --space-after-cast
Maglagay ng espasyo pagkatapos ng cast operator.
Tingnan Mga pahayag.

-dn, --line-comments-indentationn
Itakda ang indentation ng mga komento hindi sa kanan ng code sa n mga puwang.
Tingnan KOMENTARYO.

-bfda, --break-function-decl-args
Hatiin ang linya bago ang lahat ng mga argumento sa isang deklarasyon.
Tingnan MGA PAHAYAG.

-bfde, --break-function-decl-args-end
Hatiin ang linya pagkatapos ng huling argumento sa isang deklarasyon.
Tingnan MGA PAHAYAG.

-dj, --left-justify-declarations
Kung ginamit ang -cd 0, ang mga komento pagkatapos ng mga deklarasyon ay naiwang makatwiran sa likod ng
deklarasyon.
Tingnan MGA PAHAYAG.

-dun, --deklarasyon-indentasyonn
Maglagay ng mga variable sa column n.
Tingnan MGA PAHAYAG.

-fc1, --format-first-column-comments
I-format ang mga komento sa unang column.
Tingnan KOMENTARYO.

-fca, --format-all-comments
Huwag paganahin ang lahat ng pag-format ng mga komento.
Tingnan KOMENTARYO.

-gnu, --gnu-style
Gumamit ng GNU coding style. Ito ang default.
Tingnan KARANIWANG MGA Estilo.

-hnl, --honor-newlines
Mas gusto na masira ang mahabang linya sa posisyon ng mga bagong linya sa input.
Tingnan Pagsira LONG MGA LINYA.

-in, --indent-leveln
Itakda ang antas ng indentation sa n mga puwang.
Tingnan INDENTASYON.

-siyan, --indent-labeln
Itakda ang offset para sa mga label sa column n.
Tingnan INDENTASYON.

-ipn, --parameter-indentationn
Indent ang mga uri ng parameter sa lumang-style na mga kahulugan ng function ni n mga puwang.
Tingnan INDENTASYON.

-kr, --k-and-r-style
Gumamit ng Kernighan at Ritchie coding style.
Tingnan KARANIWANG MGA Estilo.

-ln, --haba ng linyan
Itakda ang maximum na haba ng linya para sa mga linyang hindi nagkomento n.
Tingnan Pagsira LONG MGA LINYA.

-lcn, --haba ng linya ng komenton
Itakda ang maximum na haba ng linya para sa pag-format ng komento sa n.
Tingnan KOMENTARYO.

-linux, --linux-style
Gumamit ng Linux coding style.
Tingnan KARANIWANG MGA Estilo.

-lp, --magpatuloy-sa-panaklong
Ihanay ang mga patuloy na linya sa panaklong.
Tingnan INDENTASYON.

-lps, --leave-preprocessor-space
Mag-iwan ng espasyo sa pagitan ng '#' at preprocessor na direktiba.
Tingnan INDENTASYON.

-nbad, --no-blank-lines-after-declarations
Huwag pilitin ang mga blangkong linya pagkatapos ng mga deklarasyon.
Tingnan BLANKO MGA LINYA.

-nbap, --no-blank-lines-after-procedures
Huwag pilitin ang mga blangkong linya pagkatapos ng mga katawan ng pamamaraan.
Tingnan BLANKO MGA LINYA.

-nbbo, --break-after-boolean-operator
Huwag mas gusto na masira ang mahabang linya bago ang mga boolean operator.
Tingnan Pagsira LONG MGA LINYA.

-nbc, --no-blank-lines-after-comma
Huwag pilitin ang mga bagong linya pagkatapos ng mga kuwit sa mga deklarasyon.
Tingnan MGA PAHAYAG.

-nbfda, --dont-break-function-decl-args
Huwag ilagay ang bawat argumento sa isang function na deklarasyon sa isang hiwalay na linya.
Tingnan MGA PAHAYAG.

-ncdb, --no-comment-delimiters-sa-blangko-linya
Huwag maglagay ng mga delimiter ng komento sa mga blangkong linya.
Tingnan KOMENTARYO.

-ncdw, --huwag yakapin-habang
Wag kang magyayakapan } at ang habang ng do {} habang;.
Tingnan Mga pahayag.

-nce, --huwag-yakapin-iba
Wag kang magyayakapan } at iba.
Tingnan Mga pahayag.

-ncs, --no-space-after-cast
Huwag maglagay ng puwang pagkatapos ng mga operator ng cast.
Tingnan Mga pahayag.

-ndjn, --dont-left-justify-declarations
Ang mga komento pagkatapos ng mga deklarasyon ay itinuturing na kapareho ng mga komento pagkatapos ng iba pang mga pahayag.
Tingnan MGA PAHAYAG.

-nfc1, --dont-format-first-column-comments
Huwag i-format ang mga komento sa unang column bilang karaniwan.
Tingnan KOMENTARYO.

-nfca, --dont-format-comments
Huwag mag-format ng anumang komento.
Tingnan KOMENTARYO.

-nhnl, --ignore-newlines
Huwag mas gusto na masira ang mahabang linya sa posisyon ng mga bagong linya sa input.
Tingnan Pagsira LONG MGA LINYA.

-nip, --walang-parameter-indentation
Zero width indentation para sa mga parameter.
Tingnan INDENTASYON.

-nlp, --huwag-linya-up-panaklong
Huwag pumila ng panaklong.
Tingnan Mga pahayag.

-npcs, --no-space-after-function-call-name
Huwag maglagay ng espasyo pagkatapos ng function sa mga function call.
Tingnan Mga pahayag.

-nprs, --no-space-after-parentheses
Huwag maglagay ng puwang pagkatapos ng bawat '(' at bago ang bawat ')'.
Tingnan Mga pahayag.

-npsl, --dont-break-procedure-type
Ilagay ang uri ng isang pamamaraan sa parehong linya ng pangalan nito.
Tingnan MGA PAHAYAG.

-nsaf, --no-space-after-for
Huwag maglagay ng espasyo pagkatapos ng bawat isa para.
Tingnan Mga pahayag.

-nsai, --walang-espasyo-pagkatapos-kung
Huwag maglagay ng espasyo pagkatapos ng bawat isa if.
Tingnan Mga pahayag.

-nsaw, --walang-espasyo-pagkatapos-samantala
Huwag maglagay ng espasyo pagkatapos ng bawat isa habang.
Tingnan Mga pahayag.

-nsc, --huwag-star-comment
Huwag ilagay ang character na '*' sa kaliwa ng mga komento.
Tingnan KOMENTARYO.

-nsob, --iwan-opsyonal-blangko-linya
Huwag lunukin ang mga opsyonal na blangko na linya.
Tingnan BLANKO MGA LINYA.

-nss, --dont-space-special-semicolon
Huwag pilitin ang isang puwang bago ang semicolon pagkatapos ng ilang mga pahayag. Hindi pinapagana ang '-ss'.
Tingnan Mga pahayag.

-mani, --walang-tab
Gumamit ng mga puwang sa halip na mga tab.
Tingnan INDENTASYON.

-nv, --no-verbosity
Huwag paganahin ang verbose mode.
Tingnan IBA PA Opsyon.

-orig, --orihinal
Gamitin ang orihinal na istilo ng coding ng Berkeley.
Tingnan KARANIWANG MGA Estilo.

-npro, --ignore-profile
Huwag basahin ang '.indent.pro' na mga file.
Tingnan PAGTATANGGI INDENT.

-mga pcs, --space-after-procedure-calls
Maglagay ng puwang sa pagitan ng pangalan ng procedure na tinatawag at ng '('.
Tingnan Mga pahayag.

-pin, --paren-indentationn
Tukuyin ang karagdagang indentasyon sa bawat bukas na panaklong '(' kapag nasira ang isang pahayag. Tingnan
Mga pahayag.

-pmt, --preserve-mtime
Panatilihin ang mga oras ng pag-access at pagbabago sa mga output file. Tingnan IBA PA Opsyon.

-ppin, --preprocessor-indentationn
Tukuyin ang indentation para sa preprocessor conditional statement.Tingnan INDENTASYON.

-prs, --space-after-parentheses
Maglagay ng puwang pagkatapos ng bawat '(' at bago ang bawat ')'.
Tingnan Mga pahayag.

-psl, --procnames-start-lines
Ilagay ang uri ng pamamaraan sa linya bago ang pangalan nito.
Tingnan MGA PAHAYAG.

-saf, --space-after-for
Maglagay ng puwang pagkatapos ng bawat isa para.
Tingnan Mga pahayag.

-sai, --space-after-if
Maglagay ng puwang pagkatapos ng bawat isa if.
Tingnan Mga pahayag.

-nakita, --space-after-while
Maglagay ng puwang pagkatapos ng bawat isa habang.
Tingnan Mga pahayag.

-sbin, --struct-brace-indentationn
Indent braces ng isang struct, unyon o enum N space.
Tingnan Mga pahayag.

-sc, --start-left-side-of-comments
Ilagay ang character na '*' sa kaliwa ng mga komento.
Tingnan KOMENTARYO.

-hikbi, --lunok-opsyonal-blangko-linya
Lunukin ang opsyonal na mga blangkong linya.
Tingnan BLANKO MGA LINYA.

-ss, --espesyal-espesyal-semicolon
Sa isang linya para at habang mga pahayag, pilitin ang isang blangko bago ang semicolon.
Tingnan Mga pahayag.

-st, --standard-output
Sumulat sa karaniwang output.
Tingnan PAGTATANGGI INDENT.

-T Sabihin indent ang pangalan ng mga typename.
Tingnan MGA PAHAYAG.

-tsn, --laki ng tabn
Itakda ang laki ng tab sa n mga puwang.
Tingnan INDENTASYON.

-labas, --gamitin ang mga tab
Gumamit ng mga tab. Ito ang default.
Tingnan INDENTASYON.

-v, --verbose
Paganahin ang verbose mode.
Tingnan IBA PA Opsyon.

-version
I-output ang numero ng bersyon ng indent.
Tingnan IBA PA Opsyon.

PAGTATANGGI INDENT

Sa bersyon 1.3, ang format ng indent ang utos ay:

indent [pagpipilian] [mga input-file]

indent [pagpipilian] [single-input-file] [-O output-file]

Ang format na ito ay iba sa mga naunang bersyon at iba pang mga bersyon ng indent.

Sa unang anyo, isa o higit pang mga input file ang tinukoy. indent gumagawa ng backup na kopya ng
bawat file, at ang orihinal na file ay papalitan ng naka-indent na bersyon nito. Tingnan mo BACKUP MGA FILE,
para sa paliwanag kung paano ginagawa ang mga backup.

Sa pangalawang form, isang input file lamang ang tinukoy. Sa kasong ito, o kapag ang pamantayan
input ay ginagamit, maaari mong tukuyin ang isang output file pagkatapos ng '-o' na opsyon.

Magdulot indent upang magsulat sa karaniwang output, gamitin ang '-st' na opsyon. Ito ay pinapayagan lamang
kapag mayroon lamang isang input file, o kapag ginamit ang karaniwang input.

Kung walang pinangalanang input file, ang karaniwang input ay binabasa para sa input. Gayundin, kung ang isang filename
pinangalanang '-' ay tinukoy, pagkatapos ay ang karaniwang input ay basahin.

Bilang halimbawa, ang bawat isa sa mga sumusunod na command ay maglalagay ng 'slithy_toves.c' at programa
isulat ang naka-indent na text nito sa 'slithy_toves.out':

indent slithy_toves.c -o slithy_toves.out

indent -st slithy_toves.c > slithy_toves.out

pusa slithy_toves.c | indent -o slithy_toves.out

Karamihan sa iba pang mga pagpipilian sa indent kontrolin kung paano na-format ang mga program. Sa bersyon 1.2,
indent kinikilala din ang isang mahabang pangalan para sa bawat pangalan ng opsyon. Ang mga mahahabang opsyon ay naka-prefix ng
alinman sa '--' o '+'. Ang [ '+' ay pinapalitan ng '--' upang mapanatili ang pagkakapare-pareho sa
pamantayan ng POSIX.]
Sa karamihan ng dokumentong ito, ang tradisyonal, maiikling pangalan ay ginagamit para sa kapakanan ng kaiklian.
Tingnan OPTION BUOD, para sa isang listahan ng mga opsyon, kabilang ang parehong mahaba at maikling pangalan.

Narito ang isa pang halimbawa:

indent -br pagsubok/metabolismo.c -l85

I-indent nito ang programang 'test/metabolism.c' gamit ang '-br' at '-l85' na mga opsyon, isulat
ang output pabalik sa 'test/metabolism.c', at isulat ang orihinal na nilalaman ng
'test/metabolism.c' sa isang backup na file sa direktoryo na 'test'.

Ang mga katumbas na invocation na gumagamit ng mahahabang pangalan ng opsyon para sa halimbawang ito ay:

indent --braces-on-if-line --line-length185 test/metabolism.c

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

Kung nalaman mong madalas mong gamitin indent sa parehong mga opsyon, maaari mong ilagay ang mga opsyon na iyon
sa isang file na pinangalanang '.indent.pro'. indent maghahanap ng profile file sa tatlong lugar.
Una ay susuriin nito ang variable ng kapaligiran INDENT_PROFILE. Kung iyon ay umiiral ang halaga nito ay
inaasahang pangalanan ang file na gagamitin. Kung wala ang environment variable,
hinahanap ng indent ang '.indent.pro' sa kasalukuyang direktoryo
at gamitin iyon kung natagpuan. Sa wakas indent hahanapin ang iyong home directory para sa '.indent.pro'
at gamitin ang file na iyon kung ito ay natagpuan. Ang pag-uugali na ito ay naiiba sa iba pang mga bersyon
of indent, na naglo-load ng parehong mga file kung pareho silang umiiral.

Ang format ng '.indent.pro' ay isang listahan lamang ng mga opsyon, tulad ng pagpapakita ng mga ito sa
command line, na pinaghihiwalay ng white space (mga tab, space, at newline). Mga opsyon sa
Ang '.indent.pro' ay maaaring napapalibutan ng C o C++ na mga komento, kung saan ang mga ito ay hindi papansinin.

Ang mga switch ng command line ay pinangangasiwaan pagkatapos pinoproseso ang '.indent.pro'. Tinukoy ang mga opsyon sa ibang pagkakataon
i-override ang mga argumentong tinukoy nang mas maaga, na may isang pagbubukod: Mga tahasang tinukoy na opsyon
palaging i-override ang mga pagpipilian sa background (Tingnan KARANIWANG MGA Estilo). Maaari mong pigilan indent mula
pagbabasa ng '.indent.pro' na file sa pamamagitan ng pagtukoy sa '-npro' na opsyon.

BACKUP MGA FILE

Sa bersyon 1.3, GNU indent gumagawa ng GNU-style backup na mga file, sa parehong paraan na ginagawa ng GNU Emacs.
Nangangahulugan ito na alinman simple or bilang na maaaring gumawa ng mga backup na filename.

Ang mga simpleng backup na pangalan ng file ay nabuo sa pamamagitan ng pagdaragdag ng suffix sa orihinal na pangalan ng file.
Ang default para sa suffix na ito ay ang isang-character na string na '~' (tilde). Kaya, ang backup
Ang file para sa 'python.c' ay magiging 'python.c~'.

Sa halip na default, maaari mong tukuyin ang anumang string bilang suffix sa pamamagitan ng pagtatakda ng kapaligiran
nagbabago SIMPLE_BACKUP_SUFFIX sa gusto mong suffix.

Ang mga may bilang na backup na bersyon ng isang file na 'momeraths.c' ay mukhang 'momeraths.c.~23~', kung saan ang 23 ay
ang bersyon ng partikular na backup na ito. Kapag gumagawa ng isang bilang na backup ng file
'src/momeraths.c', ang backup na file ay tatawaging 'src/momeraths.c.~V~', saan V ay isa
mas malaki kaysa sa pinakamataas na bersyon na kasalukuyang umiiral sa direktoryo na 'src'. Ang
variable ng kapaligiran VERSION_WIDTH kinokontrol ang bilang ng mga digit, gamit ang left zero padding
kung kinakailangan. Halimbawa, ang pagtatakda ng variable na ito sa "2" ay hahantong sa backup file
pinangalanang 'momeraths.c.~04~'.

Ang uri ng backup na file na ginawa ay kinokontrol ng halaga ng variable ng kapaligiran
VERSION_CONTROL. Kung ito ay ang string na 'simple', kung gayon ang mga simpleng backup lamang ang gagawin. Kung
ang halaga nito ay ang string na 'numbered', pagkatapos ay may numerong pag-backup ang gagawin. Kung ang halaga nito ay
'numbered-existing', pagkatapos ay gagawa ng numbered backups kung naroon na umiral bilang na
mga backup para sa file na naka-indent; kung hindi, isang simpleng backup ang ginawa. Kung
VERSION_CONTROL ay hindi nakatakda, kung gayon indent ipinapalagay ang pag-uugali ng 'numbered-existing'.

Iba pang mga bersyon ng indent gamitin ang suffix na '.BAK' sa pagbibigay ng pangalan sa mga backup na file. Maaari itong pag-uugali
tularan sa pamamagitan ng pagtatakda SIMPLE_BACKUP_SUFFIX sa '.BAK'.

Tandaan din na ang iba pang mga bersyon ng indent gumawa ng mga backup sa kasalukuyang direktoryo, sa halip na
sa direktoryo ng source file bilang GNU indent ngayon ginagawa.

KARANIWANG MGA Estilo

Mayroong ilang mga karaniwang estilo ng C code, kabilang ang GNU style, ang Kernighan &
Ritchie style, at ang orihinal na Berkeley style. Ang isang istilo ay maaaring mapili sa isang solong
likuran opsyon, na tumutukoy sa isang hanay ng mga halaga para sa lahat ng iba pang opsyon. gayunpaman,
Ang mga tahasang tinukoy na opsyon ay palaging nag-o-override sa mga opsyon na ipinahiwatig ng isang opsyon sa background.

Sa bersyon 1.2, ang default na istilo ng GNU indent ay ang estilo ng GNU. Kaya, ito ay hindi
mas matagal na kinakailangan upang tukuyin ang opsyon na '-gnu' upang makuha ang format na ito, bagama't ginagawa ito
hindi magdudulot ng error. Ang mga setting ng opsyon na tumutugma sa estilo ng GNU ay:

-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

Ang GNU coding style ay ang ginusto ng GNU project. Ito ang istilo ng GNU
Ang Emacs C mode ay naghihikayat at ginagamit sa mga C na bahagi ng GNU Emacs. (Mga tao
interesado sa pagsulat ng mga programa para sa Project GNU ay dapat makakuha ng kopya ng "The GNU Coding
Standards", na sumasaklaw din sa mga isyu sa semantiko at portability gaya ng paggamit ng memorya, ang
laki ng mga integer, atbp.)

Ginagamit ang istilong Kernighan at Ritchie sa kabuuan ng kanilang kilalang aklat na "The C Programming
Language". Ito ay pinagana gamit ang '-kr' na opsyon. Ang Kernighan at Ritchie na istilo
tumutugma sa sumusunod na hanay ng mga opsyon:

-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

Ang istilong Kernighan at Ritchie ay hindi naglalagay ng mga komento sa kanan ng code sa parehong column sa
sa lahat ng oras (hindi rin gumagamit ng isang puwang sa kanan ng code), kaya para sa istilong ito
indent arbitraryong pumili ng column 33.

Ang istilo ng orihinal na Berkeley indent maaaring makuha sa pamamagitan ng pagtukoy ng '-orig' (o sa pamamagitan ng
tumutukoy sa '--orihinal', gamit ang mahabang pangalan ng opsyon). Ang istilong ito ay katumbas ng
sumusunod na mga setting:

-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

Ang estilo ng Linux ay ginagamit sa linux kernel code at mga driver. Karaniwang kailangang sundin ang code
ang Linux coding style na tatanggapin. Ang istilong ito ay katumbas ng sumusunod
mga setting:

-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

BLANKO MGA LINYA

Ang iba't ibang mga istilo ng programming ay gumagamit ng mga blangkong linya sa iba't ibang lugar. indent ay may isang bilang ng
mga opsyon para magpasok o magtanggal ng mga blangkong linya sa mga partikular na lugar.

Ang '-bad' na opsyon ay nagiging sanhi indent upang pilitin ang isang blangkong linya pagkatapos ng bawat bloke ng mga deklarasyon.
Ang '-nbad' na opsyon ay nagiging sanhi indent huwag pilitin ang mga blangkong linya.

Pinipilit ng opsyong '-bap' ang isang blangkong linya pagkatapos ng bawat katawan ng pamamaraan. Ang '-nbap' na opsyon
hindi pinipilit ang ganoong blangkong linya.

Pinipilit ng opsyong '-bbb' ang isang blangkong linya bago ang bawat naka-box na komento (Tingnan KOMENTARYO.) Ang
Ang '-nbbb' na opsyon ay hindi pinipilit ang mga blangkong linya.

Nagdudulot ang opsyong '-sob' indent upang lunukin ang mga opsyonal na blangko na linya (iyon ay, anumang opsyonal
ang mga blangkong linya na nasa input ay aalisin sa output). Kung ang '-nsob' ay
tinukoy, ang anumang mga blangkong linya na nasa input file ay makokopya sa output file.

--blank-lines-after-declarations

Pinipilit ng opsyong '-bad' ang isang blangkong linya pagkatapos ng bawat bloke ng mga deklarasyon. Ang '-nbad'
ang opsyon ay hindi nagdaragdag ng anumang mga blangkong linya.

Halimbawa, ibinigay ang input
char *foo;
char *bar;
/* Ito ay naghihiwalay sa mga bloke ng mga deklarasyon. */
int baz;

indent -masama naglalabas

char *foo;
char *bar;

/* Ito ay naghihiwalay sa mga bloke ng mga deklarasyon. */
int baz;

at indent -nbad naglalabas

char *foo;
char *bar;
/* Ito ay naghihiwalay sa mga bloke ng mga deklarasyon. */
int baz;

--blangko-linya-pagkatapos-mga-pamamaraan

Pinipilit ng opsyong '-bap' ang isang blangkong linya pagkatapos ng bawat katawan ng pamamaraan.

Halimbawa, ibinigay ang input

int
foo ()
{
puts("Hi");
}
/* Ang procedure bar ay hindi gaanong kawili-wili. */
char *
bar ()
{
puts("Hello");
}

indent -bap naglalabas

int
foo ()
{
naglalagay ("Hi");
}

/* Ang procedure bar ay hindi gaanong kawili-wili. */
char *
bar ()
{
naglalagay ("Hello");
}

at indent -nbap naglalabas

int
foo ()
{
naglalagay ("Hi");
}
/* Ang procedure bar ay hindi gaanong kawili-wili. */
char *
bar ()
{
naglalagay ("Hello");
}

Walang idadagdag na blangkong linya pagkatapos ng pamamaraan foo.

KOMENTARYO

indent format ng parehong C at C++ na mga komento. Ang mga komento sa C ay sinimulan sa '/*', tinapos ng
'*/' at maaaring maglaman ng mga bagong linyang character. Ang mga komento sa C++ ay nagsisimula sa delimiter na '//' at
magtatapos sa bagong linya.

indent iba ang paghawak ng mga komento depende sa kanilang konteksto. indent pagtatangka upang
tukuyin ang pagkakaiba sa pagitan ng mga komento na sumusunod sa mga pahayag, mga komento na sumusunod sa mga deklarasyon,
mga komento kasunod ng mga direktiba ng preprocessor, at mga komento na hindi pinangungunahan ng code ng
anumang uri, ibig sabihin, sinisimulan nila ang teksto ng linya (bagaman hindi kinakailangan sa hanay 1).

indent higit pang nakikilala sa pagitan ng mga komentong makikita sa labas ng mga pamamaraan at pinagsama-samang,
at ang mga matatagpuan sa loob ng mga ito. Sa partikular, ang mga komento na nagsisimula sa isang linya na matatagpuan sa loob ng a
ang procedure ay ilalagay sa column kung saan kasalukuyang naka-indent ang code. Ang
Ang pagbubukod dito ay isang komento na nagsisimula sa pinakakaliwang column; ang ganitong komento ay output
sa column na iyon.

indent nagtatangkang umalis boxed Tingnan ang mga komento hindi binago. Ang pangkalahatang ideya ng naturang komento ay
na ito ay nakapaloob sa isang parihaba o ''kahon'' ng mga bituin o gitling upang makita itong mapaghiwalay.
Mas tiyak, ang mga naka-box na komento ay tinukoy bilang mga kung saan sinusunod ang paunang '/*'
kaagad sa pamamagitan ng karakter na '*', '=', '_', o '-', o mga kung saan ang simula
comment delimiter ('/*') ay nasa isang linya mismo, at ang sumusunod na linya ay nagsisimula sa isang '*'
sa parehong hanay ng bituin ng pambungad na delimiter.

Ang mga halimbawa ng mga naka-box na komento ay:

/************************
* Comment sa isang box!! *
***********************/

/*
*Ibang klase ng amoy,
* para sa ibang uri ng komento.
*/

indent sumusubok na mag-iwan ng mga naka-box na komento nang eksakto kung paanong matatagpuan ang mga ito sa source file.
Kaya ang indentation ng komento ay hindi nagbabago, at ang haba nito ay hindi naka-check sa alinman
paraan. Ang tanging ginawang pagbabago ay ang isang naka-embed na character ng tab ay maaaring ma-convert sa
naaangkop na bilang ng mga puwang.

Kung ang '-bbb' na opsyon ay tinukoy, ang lahat ng naturang naka-box na komento ay mauunahan ng blangko
linya, maliban kung ang naturang komento ay nauunahan ng code.

Maaaring ma-format ang mga komentong hindi naka-box na mga komento, na nangangahulugang ang linya ay
sira upang magkasya sa loob ng kanang margin at kaliwang puno ng whitespace. Ang mga nag-iisang bagong linya ay
katumbas ng isang puwang, ngunit ang mga blangkong linya (dalawa o higit pang mga bagong linya sa isang hilera) ay itinuturing na isang
putol ng talata. Pag-format ng mga komento na magsisimula pagkatapos paganahin ang unang column
gamit ang '-fca' na opsyon. Upang i-format ang mga nagsisimula sa unang hanay, tukuyin ang '-fc1'. ganyan
ang pag-format ay hindi pinagana bilang default.

Ang tamang margin para sa pag-format ay nagde-default sa 78, ngunit maaaring baguhin gamit ang '-lc' na opsyon.
Kung hindi pinapayagan ng margin na tinukoy na mai-print ang komento, ang margin ay magiging
awtomatikong pinalawig para sa tagal ng komentong iyon. Ang margin ay hindi iginagalang kung
ang komento ay hindi na-format.

Kung ang komento ay magsisimula ng isang linya (ibig sabihin, walang teksto ng programa sa kaliwa nito), ito ay magiging
naka-indent sa column kung saan ito matatagpuan maliban kung ang komento ay nasa loob ng isang bloke ng code. Sa
sa kasong iyon, ang naturang komento ay ihahanay sa naka-indent na code ng bloke na iyon (maliban kung ang
nagsimula ang komento sa unang kolum). Ang pagkakahanay na ito ay maaaring maapektuhan ng '-d' na opsyon,
na tumutukoy ng halaga kung saan inililipat ang mga naturang komento sa kaliwa, o hindi naka-indent.
Halimbawa, ang '-d2' ay naglalagay ng mga komento ng dalawang puwang sa kaliwa ng code. Bilang default, mga komento
ay nakahanay sa code, maliban kung magsisimula sila sa unang column, kung saan sila ay naiwan
doon bilang default --- upang maihanay ang mga ito sa code, tukuyin ang '-fc1'.

Ang mga komento sa kanan ng code ay lilitaw bilang default sa column 33. Ito ay maaaring baguhin
na may isa sa tatlong opsyon. Ang '-c' ay tutukuyin ang hanay para sa mga komento kasunod ng code,
Tinutukoy ng '-cd' ang column para sa mga komento kasunod ng mga deklarasyon, at ang '-cp' ay tumutukoy sa
column para sa mga komento kasunod ng mga preprocessor na direktiba #iba at #endif. '-dj' magkasama
na may '-cd0' ay maaaring gamitin upang sugpuin ang pagkakahanay ng mga komento sa kanan ng mga deklarasyon,
nagiging sanhi ng komento na sumunod sa isang tabstop mula sa dulo ng deklarasyon. Karaniwang '-cd0'
nagiging sanhi ng pagiging epektibo ng '-c'.

Kung ang code sa kaliwa ng komento ay lumampas sa panimulang column, ang comment column
ay mapapalawak sa susunod na tabstop column lampas sa dulo ng code, o sa kaso ng
mga direktiba ng preprocessor, sa isang puwang na lampas sa dulo ng direktiba. Ang extension na ito ay tumatagal
para lamang sa output ng partikular na komentong iyon.

Inilalagay ng opsyong '-cdb' ang mga delimiter ng komento sa mga blangkong linya. Kaya, isang linya
comment like /* Mapagmahal yakapin */ maaaring mabago sa:

/*
Mapagmahal na yakap
*/

Maaaring ilagay ang mga bituin sa simula ng mga multi-line na komento na may opsyong '-sc'. kaya,
ang solong-linya na komento sa itaas ay maaaring mabago (na may '-cdb -sc') sa:

/*
*Mapagmahal na yakap
*/

Mga pahayag

Ang '-br' o '-bl' na opsyon ay tumutukoy kung paano i-format ang mga braces.

Ang opsyon na '-br' ay nag-format ng mga brace ng pahayag na tulad nito:

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

Ang '-bl' na opsyon ay nagfo-format sa kanila ng ganito:

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

Kung gagamitin mo ang '-bl' na opsyon, maaari mo ring tukuyin ang '-bli' na opsyon. Ang pagpipiliang ito
tumutukoy sa bilang ng mga puwang kung saan naka-indent ang mga braces. '-bli2', ang default, ay nagbibigay
ang resulta na ipinakita sa itaas. Ang '-bli0' ay nagreresulta sa mga sumusunod:

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

Kung gumagamit ka ng '-br' na opsyon, malamang na gusto mo ring gamitin ang '-ce' na opsyon. Ito
nagiging sanhi ng iba sa isang if-then-else construct para yakapin ang nauna kaagad
'}'. Halimbawa, sa '-br -ce' makukuha mo ang sumusunod:

kung (x > 0) {
x--;
} Iba pa {
fprintf (stderr, "...may mali?\n");
}

Sa '-br -nce' lalabas ang code na iyon bilang

kung (x > 0) {
x--;
}
tao {
fprintf (stderr, "...may mali?\n");
}

Ito ang sanhi ng habang sa isang do-while loop upang yakapin ang kaagad na sinusundan na '}'.
Halimbawa, sa '-cdw' makukuha mo ang sumusunod:

gawin
x--;
} habang (x);

Sa '-ncdw' lalabas ang code na iyon bilang

gawin
x--;
}
habang (x);

Tinutukoy ng opsyong '-cli' ang bilang ng mga puwang kung saan dapat naka-indent ang mga label ng case
ang karapatan ng naglalaman lumipat pahayag.

Ang default ay nagbibigay ng code tulad ng:

lumipat (i)
{
kaso 0:
masira;
kaso 1:
{
++i;
}
default:
masira;
}

Gamit ang '-cli2' na magiging:

lumipat (i)
{
kaso 0:
masira;
kaso 1:
{
++i;
}
default:
masira;
}

Ang indentation ng mga braces sa ibaba ng case statement ay maaaring kontrolin gamit ang '-cbin'
opsyon. Halimbawa, ang paggamit ng '-cli2 -cbi0' ay nagreresulta sa:

lumipat (i)
{
kaso 0:
masira;
kaso 1:
{
++i;
}
default:
masira;
}

Kung ang isang semicolon ay nasa parehong linya ng a para or habang pahayag, ang '-ss' na opsyon ay
maglagay ng puwang bago ang semicolon. Binibigyang-diin nito ang semicolon, ginagawa ito
malinaw na ang katawan ng mga para or habang ang pahayag ay isang walang laman na pahayag. Hindi pinapagana ang '-nss'
ang tampok na ito.

Ang opsyon na '-pcs' ay nagdudulot ng puwang na mailagay sa pagitan ng pangalan ng pagiging procedure
tinatawag at ang '(' (halimbawa, naglalagay ("Hi");. Ang '-npcs' na opsyon ay magbibigay
puts("Hi");).

Kung ang '-cs' na opsyon ay tinukoy, indent naglalagay ng puwang sa pagitan ng cast operator at ng
bagay na ihahagis. Tinitiyak ng '-ncs' na walang puwang sa pagitan ng cast operator at
ang bagay. Tandaan mo yan indent alam lamang ang tungkol sa karaniwang mga uri ng data ng C at sa gayon ay hindi
kilalanin ang mga uri na tinukoy ng user sa mga cast. Sa gayon (mytype) bagay ay hindi itinuturing bilang isang cast.

Tinitiyak ng pagpipiliang '-bs' na mayroong puwang sa pagitan ng keyword sukat ng at ang
argumento. Sa ilang bersyon, kilala ito bilang opsyon na 'Bill_Shannon'.

Pinipilit ng opsyong '-saf' ang isang puwang sa pagitan ng a para at ang sumusunod na panaklong. Ito ang
default.

Pinipilit ng opsyong '-sai' ang isang puwang sa pagitan ng a if at ang sumusunod na panaklong. Ito ang
default.

Pinipilit ng opsyong '-saw' ang isang puwang sa pagitan ng a habang at ang sumusunod na panaklong. Ito ay
ang default.

Ang opsyon na '-prs' ay nagdudulot ng paghihiwalay ng lahat ng panaklong na may puwang mula sa kung ano man
sa pagitan nila. Halimbawa, ang paggamit ng '-prs' ay nagreresulta sa code tulad ng:

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

MGA PAHAYAG

Bilang default indent ay maglinya ng mga identifier, sa column na tinukoy ng '-di' na opsyon.
Halimbawa, ginagawa ng '-di16' ang mga bagay na parang:

int foo;
char *bar;

Ang paggamit ng maliit na halaga (tulad ng isa o dalawa) para sa '-di' na opsyon ay maaaring gamitin upang maging sanhi ng
mga identifier na ilalagay sa unang magagamit na posisyon; Halimbawa:

int foo;
char *bar;

Ang value na ibinigay sa '-di' na opsyon ay makakaapekto pa rin sa mga variable na inilalagay sa hiwalay
mga linya mula sa kanilang mga uri, halimbawa '-di2' ay hahantong sa:

int
foo;

Kung ang '-bc' na opsyon ay tinukoy, ang isang bagong linya ay sapilitang pagkatapos ng bawat kuwit sa isang deklarasyon.
Halimbawa,

int a,
b,
c;

Sa pagpipiliang '-nbc' ganito ang magiging hitsura

int a, b, c;

Ang opsyon na '-bfda' ay nagdudulot ng pagpilit sa isang bagong linya pagkatapos ng kuwit na naghihiwalay sa mga argumento
ng isang deklarasyon ng function. Lalabas ang mga argumento sa isang antas ng indensyon na mas malalim kaysa
ang deklarasyon ng function. Ito ay partikular na nakakatulong para sa mga function na may mahabang argumento
mga listahan. Ang opsyon na '-bfde' ay nagiging sanhi ng isang bagong linya na mapilitan bago ang pagsasara ng bracket ng
deklarasyon ng function. Para sa parehong mga opsyon ang 'n' na setting ay ang default: -nbdfa at -nbdfe.

Halimbawa,

void foo (int arg1, char arg2, int *arg3, long arg4, char arg5);
Gamit ang '-bfda' na opsyon ganito ang magiging hitsura

void foo (
int arg1,
char arg2,
int *arg3,
mahabang arg4,
char arg5);

Bilang karagdagan, ang '-bfde' na opsyon ay magiging ganito

void foo (
int arg1,
char arg2,
int *arg3,
mahabang arg4,
char arg5
);

Ang '-psl' na opsyon ay nagiging sanhi ng uri ng isang pamamaraan na tinukoy na mailagay sa linya
bago ang pangalan ng pamamaraan. Ang istilong ito ay kinakailangan para sa etag programa upang gumana
tama, gayundin ang ilan sa mga c-mode mga function ng Emacs.

Dapat mong gamitin ang '-T' na opsyon para sabihin indent ang pangalan ng lahat ng typename sa iyong programa
na tinukoy ng typedef. Maaaring tukuyin ang '-T' nang higit sa isang beses, at lahat ng pangalan
ang mga tinukoy ay ginagamit. Halimbawa, kung naglalaman ang iyong programa

typedef unsigned mahabang CODE_ADDR;
typedef enum {pula, asul, berde} KULAY;

gagamitin mo ang mga opsyon na '-T CODE_ADDR -T COLOR'.

Tinutukoy ng opsyon na '-brs' o '-bls' kung paano i-format ang mga brace sa mga deklarasyon ng struct. Ang
Ang '-brs' na opsyon ay nag-format ng mga brace na tulad nito:

struct foo {
intx;
};

Ang '-bls' na opsyon ay nag-format sa kanila ng ganito:

struct foo
{
intx;
};

Katulad ng mga pagpipilian sa structure brace na '-brs' at '-bls',
ang mga opsyon sa function na brace na '-brf' o '-blf' ay tumutukoy kung paano i-format ang mga brace sa function
mga kahulugan. Ang '-brf' na opsyon ay nag-format ng mga brace na tulad nito:

int one(void) {
1 bumalik;
};

Ang '-blf' na opsyon ay nagfo-format sa kanila ng ganito:

int one (walang bisa)
{
1 bumalik;
};

INDENTASYON

Ang isang isyu sa pag-format ng code ay kung gaano kalayo dapat naka-indent ang bawat linya mula sa kaliwa
margin. Kapag ang simula ng isang pahayag tulad ng if or para ay nakatagpo, ang
Ang antas ng indentasyon ay tinataasan ng halagang tinukoy ng opsyong '-i'. Halimbawa,
gamitin ang '-i8' para tumukoy ng walong character na indentation para sa bawat level. Kapag ang isang pahayag ay
naputol sa dalawang linya, ang pangalawang linya ay naka-indent ng ilang karagdagang puwang
tinukoy ng '-ci' na opsyon. Nagde-default ang '-ci' sa 0. Gayunpaman, kung ang opsyon na '-lp' ay
tinukoy, at ang isang linya ay may kaliwang panaklong na hindi nakasara sa linyang iyon, kung gayon
Ang mga linya ng pagpapatuloy ay lilinya upang magsimula sa posisyon ng character pagkatapos lamang ng kaliwa
panaklong. Nalalapat din ang pagproseso na ito sa '[' at nalalapat sa '{' kapag nangyari ito sa
mga listahan ng pagsisimula. Halimbawa, maaaring ganito ang hitsura ng isang piraso ng patuloy na code
'-nlp -ci3' sa bisa:

p1 = first_procedure (pangalawang_procedure (p2, p3),
ikatlong_pamamaraan (p4, p5));

Sa epekto ng '-lp' ang code ay mukhang mas malinaw:

p1 = first_procedure (pangalawang_procedure (p2, p3),
ikatlong_pamamaraan (p4, p5));

Kapag ang isang pahayag ay nasira sa pagitan ng dalawa o higit pang mga pares ng paren (...), bawat karagdagang pares
nagiging sanhi ng karagdagang indentation sa antas ng indentation:

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

Ang opsyon na '-ipN' ay maaaring gamitin upang itakda ang dagdag na offset bawat paren. Halimbawa, '-ip0'
ay i-format ang nasa itaas bilang:

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

indent Ipinapalagay na ang mga tab ay inilalagay sa mga regular na pagitan ng parehong input at output
mga stream ng character. Ang mga pagitan na ito ay bilang default na 8 column ang lapad, ngunit (mula sa bersyon 1.2)
maaaring baguhin ng '-ts' na opsyon. Ang mga tab ay itinuturing bilang katumbas na bilang ng mga puwang.

Ang indentation ng mga deklarasyon ng uri sa mga kahulugan ng lumang istilo ng function ay kinokontrol ng
ang parameter na '-ip'. Ito ay isang numeric na parameter na tumutukoy kung gaano karaming mga puwang ang i-indent
uri ng mga deklarasyon. Halimbawa, ginagawa ng default na '-ip5' ang mga kahulugan na ganito:

char *
create_world (x, y, scale)
intx;
int y;
float scale;
{
. . .
}

Para sa pagiging tugma sa iba pang mga bersyon ng indent, ang opsyon na '-nip' ay ibinigay, na
katumbas ng '-ip0'.

Ang ANSI C ay nagbibigay-daan sa puting espasyo na mailagay sa preprocessor command lines sa pagitan ng character
'#' at ang pangalan ng command. Bilang default, indent inaalis ang puwang na ito, ngunit tinukoy ang
Ang '-lps' na opsyon ay nagdidirekta indent upang iwanan ang espasyong ito na hindi nabago. Ino-override ang opsyong '-ppi'
'-nlps' at '-lps'.

Ang opsyong ito ay maaaring gamitin upang humiling na ang preprocessor conditional statement ay maaaring maging
naka-indent ng sa ibinigay na bilang ng mga puwang, halimbawa na may opsyon na '-ppi 3'

#kung X
#kung si Y
#define Z 1
#iba
#define Z 0
#endif
#endif
nagiging
#kung X
# kung Y
# tukuyin ang Z 1
# iba pa
# tukuyin ang Z 0
# tapusin kung
#endif

Itinatakda ng opsyong ito ang offset kung saan ipoposisyon ang isang label (maliban sa mga label ng case). Kung
ito ay nakatakda sa zero o isang positibong numero, ito ay nagpapahiwatig kung gaano kalayo mula sa kaliwang margin hanggang
indent ang isang label. Kung ito ay nakatakda sa isang negatibong numero, ito ay nagpapahiwatig kung gaano kalayo pabalik mula sa
kasalukuyang antas ng indent para ilagay ang label. Ang default na setting ay -2 na tumutugma sa
gawi ng mga naunang bersyon ng indent. Tandaan na ang parameter na ito ay hindi nakakaapekto sa
paglalagay ng mga label ng case; tingnan ang parameter na '-cli' para doon. Halimbawa sa opsyon
'-il 1'

grupo
function()
{
kung (do_stuff1() == ERROR)
goto cleanup1;

kung (do_stuff2() == ERROR)
goto cleanup2;

ibalik ang TAGUMPAY;

paglilinis2:
do_cleanup2();

paglilinis1:
do_cleanup1();

ibalik ang ERROR;
}
nagiging
grupo
function()
{
kung (do_stuff1() == ERROR)
goto cleanup1;

kung (do_stuff2() == ERROR)
goto cleanup2;

ibalik ang TAGUMPAY;

paglilinis2:
do_cleanup2();

paglilinis1:
do_cleanup1();

ibalik ang ERROR;
}

Pagsira LONG MGA LINYA

Gamit ang opsyon na '-ln', o '--haba ng linyan', posibleng tukuyin ang maximum na haba
ng isang linya ng C code, hindi kasama ang mga posibleng komento na sumusunod dito.

Kapag ang mga linya ay naging mas mahaba kaysa sa tinukoy na haba ng linya, ang GNU indent sinusubukang sirain ang
linya sa isang lohikal na lugar. Ito ay bago sa bersyon 2.1 gayunpaman at hindi masyadong matalino
o flexible pa.

Sa kasalukuyan, mayroong dalawang opsyon na nagpapahintulot sa isa na makagambala sa algorithm na iyon
tinutukoy kung saan mapuputol ang isang linya.

Ang opsyon na '-bbo' ay nagiging sanhi ng GNU indent mas gusto na putulin ang mahabang linya bago ang boolean
operator && at ||. Ang opsyon na '-nbbo' ay nagiging sanhi ng GNU indent walang ganoong kagustuhan. Para sa
halimbawa, ang default na opsyon na '-bbo' (kasama ang '--line-length60' at '--ignore-
newlines') ginagawang ganito ang code:

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

Ang paggamit ng opsyon na '-nbbo' ay magiging ganito:

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

Ang default na '-hnl', gayunpaman, ay nagpaparangal sa mga bagong linya sa input file sa pamamagitan ng pagbibigay sa kanila ng pinakamataas
posibleng priyoridad na masira ang mga linya sa. Halimbawa, kapag ganito ang hitsura ng input file:

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

pagkatapos ay gamit ang opsyong '-hnl', o '--honour-newlines', kasama ang naunang
nabanggit '-nbbo' at '--line-length60', ay magiging sanhi ng output na hindi kung ano ang ibinigay sa
ang huling halimbawa ngunit sa halip ay mas gugustuhin na masira sa mga posisyon kung saan ang code ay
nasira sa input file:

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

Ang ideya sa likod ng opsyong ito ay ang mga linyang masyadong mahaba, ngunit naputol na,
ay hindi magagalaw ng GNU indent. Talagang magulo code ay dapat na tumakbo sa pamamagitan ng indent at
kahit isang beses gamit ang '--ignore-newlines' na opsyon bagaman.

disable PAG-FORMAT

Maaaring hindi paganahin ang pag-format ng C code para sa mga bahagi ng isang programa sa pamamagitan ng pag-embed ng espesyal
kontrol Tingnan ang mga komento sa programa. Upang i-off ang pag-format para sa isang seksyon ng isang programa, ilagay
ang hindi pagpapagana ng kontrol na komento /* *INDENT-OFF* */ sa isang linya mismo bago iyon
seksyon. Ang text ng program na na-scan pagkatapos ng control comment na ito ay eksaktong output bilang input
na walang pagbabago hanggang sa ma-scan ang kaukulang pagpapagana ng komento sa isang linya ng
mismo. Ang hindi pagpapagana ng kontrol na komento ay /* *INDENT-ON* */, at anumang teksto kasunod ng
ang komento sa linya ay hindi naka-format din ang output. Magsisimula muli ang pag-format sa input
linya kasunod ng pagpapagana ng kontrol na komento.

Mas tumpak, indent hindi sinusubukang i-verify ang pagsasara ng delimiter (*/) para sa mga ito C
mga komento, at anumang whitespace sa linya ay ganap na transparent.

Ang mga kontrol na komentong ito ay gumagana din sa kanilang mga C++ na format, ibig sabihin // *INDENT-OFF* at //
*INDENT-ON*.

Dapat pansinin na ang panloob na estado ng indent nananatiling hindi nagbabago sa paglipas ng panahon
ang hindi naka-format na seksyon. Kaya, halimbawa, i-off ang pag-format sa gitna ng a
function at pagpapatuloy nito pagkatapos ng pagtatapos ng function ay maaaring humantong sa mga kakaibang resulta. Ito
samakatuwid ay matalino na medyo modular sa pagpili ng code na iiwan na hindi naka-format.

Bilang isang makasaysayang tala, ilang naunang bersyon ng indent gumawa ng mga mensahe ng error simula
sa *INDENT**. Ang mga bersyon na ito ng indent ay isinulat upang huwag pansinin ang anumang input na linya ng teksto
na nagsimula sa mga ganitong mensahe ng error. Inalis ko ang incestuous feature na ito sa GNU
indent.

IBA PA Opsyon

Para malaman kung anong bersyon ng indent mayroon ka, gamitin ang utos indent -version. Ito ay
iulat ang numero ng bersyon ng indent, nang hindi ginagawa ang alinman sa normal na pagproseso.

Maaaring gamitin ang opsyong '-v' para i-on ang verbose mode. Kapag nasa verbose mode, indent ulat
kapag hinati nito ang isang linya ng input sa dalawa pang linya ng output, at nagbibigay ng ilang sukat
mga istatistika sa pagkumpleto.

Nagdudulot ang opsyong '-pmt' indent upang mapanatili ang mga oras ng pag-access at pagbabago sa
mga output file. Ang paggamit ng opsyong ito ay may kalamangan na ang pagpapatakbo ng indent sa lahat ng pinagmulan at
Ang mga file ng header sa isang proyekto ay hindi magiging sanhi gumawa upang muling itayo ang lahat ng mga target. Ang pagpipiliang ito ay lamang
magagamit sa Mga Operating System na mayroong POSIX utime(2) function.

Gumamit ng indent online gamit ang mga serbisyo ng onworks.net