indent.txt (44900B)
1 *indent.txt* For Vim version 9.2. Last change: 2026 Feb 14 2 3 4 VIM REFERENCE MANUAL by Bram Moolenaar 5 6 7 This file is about indenting C programs and other files. 8 9 1. Indenting C style programs |C-indenting| 10 2. Indenting by expression |indent-expression| 11 12 ============================================================================== 13 1. Indenting C style programs *C-indenting* 14 15 The basics for C style indenting are explained in section |30.2| of the user 16 manual. 17 18 Vim has options for automatically indenting C style program files. Many 19 programming languages including Java and C++ follow very closely the 20 formatting conventions established with C. These options affect only the 21 indent and do not perform other formatting. There are additional options that 22 affect other kinds of formatting as well as indenting, see |format-comments|, 23 |fo-table|, |gq| and |formatting| for the main ones. 24 25 There are in fact four main methods available for indentation, each one 26 overrides the previous if it is enabled, or non-empty for 'indentexpr': 27 'autoindent' uses the indent from the previous line. 28 'smartindent' is like 'autoindent' but also recognizes some C syntax to 29 increase/reduce the indent where appropriate. 30 'cindent' Works more cleverly than the other two and is configurable to 31 different indenting styles. 32 'indentexpr' The most flexible of all: Evaluates an expression to compute 33 the indent of a line. When non-empty this method overrides 34 the other ones. See |indent-expression|. 35 The rest of this section describes the 'cindent' option. 36 37 Note that 'cindent' indenting does not work for every code scenario. Vim 38 is not a C compiler: it does not recognize all syntax. One requirement is 39 that toplevel functions have a '{' in the first column. Otherwise they are 40 easily confused with declarations. 41 42 These five options control C program indenting: 43 'cindent' Enables Vim to perform C program indenting automatically. 44 'cinkeys' Specifies which keys trigger reindenting in insert mode. 45 'cinoptions' Sets your preferred indent style. 46 'cinwords' Defines keywords that start an extra indent in the next line. 47 'cinscopedecls' Defines strings that are recognized as a C++ scope 48 declaration. 49 50 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using 51 Vim's built-in algorithm rather than calling an external program. 52 53 See |autocommand| for how to set the 'cindent' option automatically for C code 54 files and reset it for others. 55 56 *cinkeys-format* *indentkeys-format* 57 The 'cinkeys' option is a string that controls Vim's indenting in response to 58 typing certain characters or commands in certain contexts. Note that this not 59 only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is 60 used instead. The format of 'cinkeys' and 'indentkeys' is equal. 61 62 The default is "0{,0},0),0],:,0#,!^F,o,O,e" which specifies that indenting 63 occurs as follows: 64 65 "0{" if you type '{' as the first character in a line 66 "0}" if you type '}' as the first character in a line 67 "0)" if you type ')' as the first character in a line 68 "0]" if you type ']' as the first character in a line 69 ":" if you type ':' after a label or case statement 70 "0#" if you type '#' as the first character in a line 71 "!^F" if you type CTRL-F (which is not inserted) 72 "o" if you type a <CR> anywhere or use the "o" command (not in 73 insert mode!) 74 "O" if you use the "O" command (not in insert mode!) 75 "e" if you type the second 'e' for an "else" at the start of a 76 line 77 78 Characters that can precede each key: *i_CTRL-F* 79 ! When a '!' precedes the key, Vim will not insert the key but will 80 instead reindent the current line. This allows you to define a 81 command key for reindenting the current line. CTRL-F is the default 82 key for this. Be careful if you define CTRL-I for this because CTRL-I 83 is the ASCII code for <Tab>. 84 * When a '*' precedes the key, Vim will reindent the line before 85 inserting the key. If 'cinkeys' contains "*<Return>", Vim reindents 86 the current line before opening a new line. 87 0 When a zero precedes the key (but appears after '!' or '*') Vim will 88 reindent the line only if the key is the first character you type in 89 the line. When used before "=" Vim will only reindent the line if 90 there is only white space before the word. 91 92 When neither '!' nor '*' precedes the key, Vim reindents the line after you 93 type the key. So ';' sets the indentation of a line which includes the ';'. 94 95 Special key names: 96 <> Angle brackets mean spelled-out names of keys. For example: "<Up>", 97 "<Ins>" (see |key-notation|). 98 ^ Letters preceded by a caret (^) are control characters. For example: 99 "^F" is CTRL-F. 100 o Reindent a line when you use the "o" command or when Vim opens a new 101 line below the current one (e.g., when you type <Enter> in insert 102 mode). 103 O Reindent a line when you use the "O" command. 104 e Reindent a line that starts with "else" when you type the second 'e'. 105 : Reindent a line when a ':' is typed which is after a label or case 106 statement. Don't reindent for a ":" in "class::method" for C++. To 107 Reindent for any ":", use "<:>". 108 =word Reindent when typing the last character of "word". "word" may 109 actually be part of another word. Thus "=end" would cause reindenting 110 when typing the "d" in "endif" or "endwhile". But not when typing 111 "bend". Also reindent when completion produces a word that starts 112 with "word". "0=word" reindents when there is only white space before 113 the word. 114 =~word Like =word, but ignore case. 115 116 If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>', 117 '*', ':' or '!', use "<o>", "<O>", "<e>", "<0>", "<<>", "<>>", "<*>", "<:>" or 118 "<!>", respectively, for those keys. 119 120 For an emacs-style indent mode where lines aren't indented every time you 121 press <Enter> but only if you press <Tab>, I suggest: > 122 :set cinkeys=0{,0},:,0#,!<Tab>,!^F 123 You might also want to switch off 'autoindent' then. 124 125 Note: If you change the current line's indentation manually, Vim ignores the 126 cindent settings for that line. This prevents vim from reindenting after you 127 have changed the indent by typing <BS>, <Tab>, or <Space> in the indent or 128 used CTRL-T or CTRL-D. 129 130 *cinoptions-values* 131 The 'cinoptions' option sets how Vim performs indentation. The value after 132 the option character can be one of these (N is any number): 133 N indent N spaces 134 -N indent N spaces to the left 135 Ns N times 'shiftwidth' spaces 136 -Ns N times 'shiftwidth' spaces to the left 137 138 In the list below, 139 "N" represents a number of your choice (the number can be negative). When 140 there is an 's' after the number, Vim multiplies the number by 'shiftwidth': 141 "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. You can use a 142 decimal point, too: "-0.5s" is minus half a 'shiftwidth'. 143 The examples below assume a 'shiftwidth' of 4. 144 *cino->* 145 >N Amount added for "normal" indent. Used after a line that should 146 increase the indent (lines starting with "if", an opening brace, 147 etc.). (default 'shiftwidth'). 148 149 cino= cino=>2 cino=>2s > 150 if (cond) if (cond) if (cond) 151 { { { 152 foo; foo; foo; 153 } } } 154 < 155 *cino-e* 156 eN Add N to the prevailing indent inside a set of braces if the 157 opening brace at the End of the line (more precise: is not the 158 first character in a line). This is useful if you want a 159 different indent when the '{' is at the start of the line from 160 when '{' is at the end of the line. (default 0). 161 162 cino= cino=e2 cino=e-2 > 163 if (cond) { if (cond) { if (cond) { 164 foo; foo; foo; 165 } } } 166 else else else 167 { { { 168 bar; bar; bar; 169 } } } 170 < 171 *cino-n* 172 nN Add N to the prevailing indent for a statement after an "if", 173 "while", etc., if it is NOT inside a set of braces. This is 174 useful if you want a different indent when there is no '{' 175 before the statement from when there is a '{' before it. 176 (default 0). 177 178 cino= cino=n2 cino=n-2 > 179 if (cond) if (cond) if (cond) 180 foo; foo; foo; 181 else else else 182 { { { 183 bar; bar; bar; 184 } } } 185 < 186 *cino-f* 187 fN Place the first opening brace of a function or other block in 188 column N. This applies only for an opening brace that is not 189 inside other braces and is at the start of the line. What comes 190 after the brace is put relative to this brace. (default 0). 191 192 cino= cino=f.5s cino=f1s > 193 func() func() func() 194 { { { 195 int foo; int foo; int foo; 196 < 197 *cino-{* 198 {N Place opening braces N characters from the prevailing indent. 199 This applies only for opening braces that are inside other 200 braces. (default 0). 201 202 cino= cino={.5s cino={1s > 203 if (cond) if (cond) if (cond) 204 { { { 205 foo; foo; foo; 206 < 207 *cino-}* 208 }N Place closing braces N characters from the matching opening 209 brace. (default 0). 210 211 cino= cino={2,}-0.5s cino=}2 > 212 if (cond) if (cond) if (cond) 213 { { { 214 foo; foo; foo; 215 } } } 216 < 217 *cino-^* 218 ^N Add N to the prevailing indent inside a set of braces if the 219 opening brace is in column 0. This can specify a different 220 indent for whole of a function (some may like to set it to a 221 negative number). (default 0). 222 223 cino= cino=^-2 cino=^-s > 224 func() func() func() 225 { { { 226 if (cond) if (cond) if (cond) 227 { { { 228 a = b; a = b; a = b; 229 } } } 230 } } } 231 < 232 *cino-L* 233 LN Controls placement of jump labels. If N is negative, the label 234 will be placed at column 1. If N is non-negative, the indent of 235 the label will be the prevailing indent minus N. (default -1). 236 237 cino= cino=L2 cino=Ls > 238 func() func() func() 239 { { { 240 { { { 241 stmt; stmt; stmt; 242 LABEL: LABEL: LABEL: 243 } } } 244 } } } 245 < 246 *cino-:* 247 :N Place case labels N characters from the indent of the switch(). 248 (default 'shiftwidth'). 249 250 cino= cino=:0 > 251 switch (x) switch(x) 252 { { 253 case 1: case 1: 254 a = b; a = b; 255 default: default: 256 } } 257 < 258 *cino-=* 259 =N Place statements occurring after a case label N characters from 260 the indent of the label. (default 'shiftwidth'). 261 262 cino= cino==10 > 263 case 11: case 11: a = a + 1; 264 a = a + 1; b = b + 1; 265 < 266 *cino-l* 267 lN If N != 0 Vim will align with a case label instead of the 268 statement after it in the same line. 269 270 cino= cino=l1 > 271 switch (a) { switch (a) { 272 case 1: { case 1: { 273 break; break; 274 } } 275 < 276 *cino-b* 277 bN If N != 0 Vim will align a final "break" with the case label, 278 so that case..break looks like a sort of block. (default: 0). 279 When using 1, consider adding "0=break" to 'cinkeys'. 280 281 cino= cino=b1 > 282 switch (x) switch(x) 283 { { 284 case 1: case 1: 285 a = b; a = b; 286 break; break; 287 288 default: default: 289 a = 0; a = 0; 290 break; break; 291 } } 292 < 293 *cino-g* 294 gN Place C++ scope declarations N characters from the indent of the 295 block they are in. (default 'shiftwidth'). By default, a scope 296 declaration is "public:", "protected:" or "private:". This can 297 be adjusted with the 'cinscopedecls' option. 298 299 cino= cino=g0 > 300 { { 301 public: public: 302 a = b; a = b; 303 private: private: 304 } } 305 < 306 *cino-h* 307 hN Place statements occurring after a C++ scope declaration N 308 characters from the indent of the label. (default 309 'shiftwidth'). 310 311 cino= cino=h10 > 312 public: public: a = a + 1; 313 a = a + 1; b = b + 1; 314 < 315 *cino-N* 316 NN Indent inside C++ namespace N characters extra compared to a 317 normal block. (default 0). 318 319 cino= cino=N-s > 320 namespace { namespace { 321 void function(); void function(); 322 } } 323 324 namespace my namespace my 325 { { 326 void function(); void function(); 327 } } 328 < 329 *cino-E* 330 EN Indent inside C++ linkage specifications (extern "C" or 331 extern "C++") N characters extra compared to a normal block. 332 (default 0). 333 334 cino= cino=E-s > 335 extern "C" { extern "C" { 336 void function(); void function(); 337 } } 338 339 extern "C" extern "C" 340 { { 341 void function(); void function(); 342 } } 343 < 344 *cino-p* 345 pN Parameter declarations for K&R-style function declarations will 346 be indented N characters from the margin. (default 347 'shiftwidth'). 348 349 cino= cino=p0 cino=p2s > 350 func(a, b) func(a, b) func(a, b) 351 int a; int a; int a; 352 char b; char b; char b; 353 < 354 *cino-t* 355 tN Indent a function return type declaration N characters from the 356 margin. (default 'shiftwidth'). 357 358 cino= cino=t0 cino=t7 > 359 int int int 360 func() func() func() 361 < 362 *cino-i* 363 iN Indent C++ base class declarations and constructor 364 initializations, if they start in a new line (otherwise they 365 are aligned at the right side of the ':'). 366 (default 'shiftwidth'). 367 368 cino= cino=i0 > 369 class MyClass : class MyClass : 370 public BaseClass public BaseClass 371 {} {} 372 MyClass::MyClass() : MyClass::MyClass() : 373 BaseClass(3) BaseClass(3) 374 {} {} 375 < 376 *cino-+* 377 +N Indent a continuation line (a line that spills onto the next) 378 inside a function N additional characters. (default 379 'shiftwidth'). 380 Outside of a function, when the previous line ended in a 381 backslash, the 2 * N is used. 382 383 cino= cino=+10 > 384 a = b + 9 * a = b + 9 * 385 c; c; 386 < 387 *cino-c* 388 cN Indent comment lines after the comment opener, when there is no 389 other text with which to align, N characters from the comment 390 opener. (default 3). See also |format-comments|. 391 392 cino= cino=c5 > 393 /* /* 394 text. text. 395 */ */ 396 < 397 *cino-C* 398 CN When N is non-zero, indent comment lines by the amount specified 399 with the c flag above even if there is other text behind the 400 comment opener. (default 0). 401 402 cino=c0 cino=c0,C1 > 403 /******** /******** 404 text. text. 405 ********/ ********/ 406 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*") 407 408 *cino-/* 409 /N Indent comment lines N characters extra. (default 0). 410 cino= cino=/4 > 411 a = b; a = b; 412 /* comment */ /* comment */ 413 c = d; c = d; 414 < 415 *cino-(* 416 (N When in unclosed parentheses, indent N characters from the line 417 with the unclosed parenthesis. Add a 'shiftwidth' for every 418 extra unclosed parentheses. When N is 0 or the unclosed 419 parenthesis is the first non-white character in its line, line 420 up with the next non-white character after the unclosed 421 parenthesis. (default 'shiftwidth' * 2). 422 423 cino= cino=(0 > 424 if (c1 && (c2 || if (c1 && (c2 || 425 c3)) c3)) 426 foo; foo; 427 if (c1 && if (c1 && 428 (c2 || c3)) (c2 || c3)) 429 { { 430 < 431 *cino-u* 432 uN Same as (N, but for one nesting level deeper. 433 (default 'shiftwidth'). 434 435 cino= cino=u2 > 436 if (c123456789 if (c123456789 437 && (c22345 && (c22345 438 || c3)) || c3)) 439 < 440 *cino-U* 441 UN When N is non-zero, do not ignore the indenting specified by 442 ( or u in case that the unclosed parenthesis is the first 443 non-white character in its line. (default 0). 444 445 cino= or cino=(s cino=(s,U1 > 446 c = c1 && c = c1 && 447 ( ( 448 c2 || c2 || 449 c3 c3 450 ) && c4; ) && c4; 451 < 452 *cino-w* 453 wN When in unclosed parentheses and N is non-zero and either 454 using "(0" or "u0", respectively, or using "U0" and the unclosed 455 parenthesis is the first non-white character in its line, line 456 up with the character immediately after the unclosed parenthesis 457 rather than the first non-white character. (default 0). 458 459 cino=(0 cino=(0,w1 > 460 if ( c1 if ( c1 461 && ( c2 && ( c2 462 || c3)) || c3)) 463 foo; foo; 464 < 465 *cino-W* 466 WN When in unclosed parentheses and N is non-zero and either 467 using "(0" or "u0", respectively and the unclosed parenthesis is 468 the last non-white character in its line and it is not the 469 closing parenthesis, indent the following line N characters 470 relative to the outer context (i.e. start of the line or the 471 next unclosed parenthesis). (default: 0). 472 473 cino=(0 cino=(0,W4 > 474 a_long_line( a_long_line( 475 argument, argument, 476 argument); argument); 477 a_short_line(argument, a_short_line(argument, 478 argument); argument); 479 < 480 *cino-k* 481 kN When in unclosed parentheses which follow "if", "for" or 482 "while" and N is non-zero, overrides the behaviour defined by 483 "(N": causes the indent to be N characters relative to the outer 484 context (i.e. the line where "if", "for" or "while" is). Has 485 no effect on deeper levels of nesting. Affects flags like "wN" 486 only for the "if", "for" and "while" conditions. If 0, defaults 487 to behaviour defined by the "(N" flag. (default: 0). 488 489 cino=(0 cino=(0,ks > 490 if (condition1 if (condition1 491 && condition2) && condition2) 492 action(); action(); 493 function(argument1 function(argument1 494 && argument2); && argument2); 495 < 496 *cino-m* 497 mN When N is non-zero, line up a line starting with a closing 498 parenthesis with the first character of the line with the 499 matching opening parenthesis. (default 0). 500 501 cino=(s cino=(s,m1 > 502 c = c1 && ( c = c1 && ( 503 c2 || c2 || 504 c3 c3 505 ) && c4; ) && c4; 506 if ( if ( 507 c1 && c2 c1 && c2 508 ) ) 509 foo; foo; 510 < 511 *cino-M* 512 MN When N is non-zero, line up a line starting with a closing 513 parenthesis with the first character of the previous line. 514 (default 0). 515 516 cino= cino=M1 > 517 if (cond1 && if (cond1 && 518 cond2 cond2 519 ) ) 520 < 521 *java-cinoptions* *java-indenting* *cino-j* 522 jN Indent Java anonymous classes correctly. Also works well for 523 Javascript. The value 'N' is currently unused but must be 524 non-zero (e.g. 'j1'). 'j1' will indent for example the 525 following code snippet correctly: > 526 527 object.add(new ChangeListener() { 528 public void stateChanged(ChangeEvent e) { 529 do_something(); 530 } 531 }); 532 < 533 *javascript-cinoptions* *javascript-indenting* *cino-J* 534 JN Indent JavaScript object declarations correctly by not confusing 535 them with labels. The value 'N' is currently unused but must be 536 non-zero (e.g. 'J1'). If you enable this you probably also want 537 to set |cino-j|. > 538 539 var bar = { 540 foo: { 541 that: this, 542 some: ok, 543 }, 544 "bar":{ 545 a : 2, 546 b: "123abc", 547 x: 4, 548 "y": 5 549 } 550 } 551 < 552 *cino-)* 553 )N Vim searches for unclosed parentheses at most N lines away. 554 This limits the time needed to search for parentheses. (default 555 20 lines). 556 557 *cino-star* 558 *N Vim searches for unclosed comments at most N lines away. This 559 limits the time needed to search for the start of a comment. 560 If your /* */ comments stop indenting after N lines this is the 561 value you will want to change. 562 (default 70 lines). 563 564 *cino-#* 565 #N When N is non-zero recognize shell/Perl comments starting with 566 '#', do not recognize preprocessor lines; allow right-shifting 567 lines that start with "#". 568 When N is zero (default): don't recognize '#' comments, do 569 recognize preprocessor lines; right-shifting lines that start 570 with "#" does not work. 571 572 *cino-P* 573 PN When N is non-zero recognize C pragmas, and indent them like any 574 other code; does not concern other preprocessor directives. 575 When N is zero (default): don't recognize C pragmas, treating 576 them like every other preprocessor directive. 577 578 579 The defaults, spelled out in full, are: 580 cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,E0,ps,ts,is,+s, 581 c3,C0,/0,(2s,us,U0,w0,W0,k0,m0,j0,J0,)20,*70,#0,P0 582 583 Vim puts a line in column 1 if: 584 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#0'. 585 - It starts with a label (a keyword followed by ':', other than "case" and 586 "default") and 'cinoptions' does not contain an 'L' entry with a positive 587 value. 588 - Any combination of indentations causes the line to have less than 0 589 indentation. 590 591 ============================================================================== 592 2. Indenting by expression *indent-expression* 593 594 The basics for using flexible indenting are explained in section |30.3| of the 595 user manual. 596 597 If you want to write your own indent file, it must set the 'indentexpr' 598 option. Setting the 'indentkeys' option is often useful. 599 See the $VIMRUNTIME/indent/README.txt file for hints. 600 See the $VIMRUNTIME/indent directory for examples. 601 602 603 REMARKS ABOUT SPECIFIC INDENT FILES ~ 604 605 606 CLOJURE *ft-clojure-indent* *clojure-indent* 607 608 Clojure indentation differs somewhat from traditional Lisps, due in part to 609 the use of square and curly brackets, and otherwise by community convention. 610 These conventions are not universally followed, so the Clojure indent script 611 offers a few configuration options. 612 613 (If the current Vim does not include |searchpairpos()|, the indent script falls 614 back to normal 'lisp' indenting, and the following options are ignored.) 615 616 617 *g:clojure_maxlines* 618 619 Sets maximum scan distance of `searchpairpos()`. Larger values trade 620 performance for correctness when dealing with very long forms. A value of 621 0 will scan without limits. The default is 300. 622 623 624 *g:clojure_fuzzy_indent* 625 *g:clojure_fuzzy_indent_patterns* 626 *g:clojure_fuzzy_indent_blacklist* 627 628 The 'lispwords' option is a list of comma-separated words that mark special 629 forms whose subforms should be indented with two spaces. 630 631 For example: 632 > 633 (defn bad [] 634 "Incorrect indentation") 635 636 (defn good [] 637 "Correct indentation") 638 < 639 If you would like to specify 'lispwords' with a |pattern| instead, you can use 640 the fuzzy indent feature: 641 > 642 " Default 643 let g:clojure_fuzzy_indent = 1 644 let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let'] 645 let g:clojure_fuzzy_indent_blacklist = 646 \ ['-fn$', '\v^with-%(meta|out-str|loading-context)$'] 647 < 648 |g:clojure_fuzzy_indent_patterns| and |g:clojure_fuzzy_indent_blacklist| are 649 lists of patterns that will be matched against the unqualified symbol at the 650 head of a list. This means that a pattern like `"^foo"` will match all these 651 candidates: `foobar`, `my.ns/foobar`, and `#'foobar`. 652 653 Each candidate word is tested for special treatment in this order: 654 655 1. Return true if word is literally in 'lispwords' 656 2. Return false if word matches a pattern in 657 |g:clojure_fuzzy_indent_blacklist| 658 3. Return true if word matches a pattern in 659 |g:clojure_fuzzy_indent_patterns| 660 4. Return false and indent normally otherwise 661 662 663 *g:clojure_special_indent_words* 664 665 Some forms in Clojure are indented such that every subform is indented by only 666 two spaces, regardless of 'lispwords'. If you have a custom construct that 667 should be indented in this idiosyncratic fashion, you can add your symbols to 668 the default list below. 669 > 670 " Default 671 let g:clojure_special_indent_words = 672 \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn' 673 < 674 675 *g:clojure_align_multiline_strings* 676 677 Align subsequent lines in multi-line strings to the column after the opening 678 quote, instead of the same column. 679 680 For example: 681 > 682 (def default 683 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do 684 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut 685 enim ad minim veniam, quis nostrud exercitation ullamco laboris 686 nisi ut aliquip ex ea commodo consequat.") 687 688 (def aligned 689 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do 690 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut 691 enim ad minim veniam, quis nostrud exercitation ullamco laboris 692 nisi ut aliquip ex ea commodo consequat.") 693 < 694 695 *g:clojure_align_subforms* 696 697 By default, parenthesized compound forms that look like function calls and 698 whose head subform is on its own line have subsequent subforms indented by 699 two spaces relative to the opening paren: 700 > 701 (foo 702 bar 703 baz) 704 < 705 Setting this option to `1` changes this behaviour so that all subforms are 706 aligned to the same column, emulating the default behaviour of 707 clojure-mode.el: 708 > 709 (foo 710 bar 711 baz) 712 < 713 714 FORTRAN *ft-fortran-indent* 715 716 Block if, select case, select type, select rank, where, forall, type, 717 interface, associate, block, enum, critical, and change team constructs are 718 indented. The indenting of subroutines, functions, modules, and program 719 blocks is optional. Comments, labeled statements, and continuation lines are 720 indented in free source form, whereas they are not indented in fixed source 721 form because of the left margin requirements. Hence manual indent corrections 722 will be necessary for labeled statements and continuation lines when fixed 723 source form is being used. For further discussion of the method used for the 724 detection of source format see |ft-fortran-syntax|. 725 726 Do loops ~ 727 All do loops are left unindented by default. Do loops can be unstructured in 728 Fortran with (possibly multiple) loops ending on a labeled executable 729 statement of almost arbitrary type. Correct indentation requires 730 compiler-quality parsing. Old code with do loops ending on labeled statements 731 of arbitrary type can be indented with elaborate programs such as Tidy. 732 Structured do/continue loops are also left unindented because continue 733 statements are used for purposes other than ending a do loop. Programs such 734 as Tidy can convert structured do/continue loops to the do/enddo form. Do 735 loops of the do/enddo variety can be indented. If you use only structured 736 loops of the do/enddo form, you should declare this by setting the 737 fortran_do_enddo variable in your .vimrc as follows > 738 739 let fortran_do_enddo=1 740 741 in which case do loops will be indented. If all your loops are of do/enddo 742 type only in, say, .f90 files, then you should set a buffer flag with an 743 autocommand such as > 744 745 au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1 746 747 to get do loops indented in .f90 files and left alone in Fortran files with 748 other extensions such as .for. 749 750 Program units ~ 751 Indenting of program units (subroutines, functions, modules, and program 752 blocks) can be increased by setting the variable fortran_indent_more and can 753 be decreased by setting the variable fortran_indent_less. These variables 754 can be set for all fortran files in your .vimrc as follows > 755 756 let fortran_indent_less=1 757 758 A finer level of control can be achieved by setting the corresponding 759 buffer-local variable as follows > 760 761 let b:fortran_indent_less=1 762 763 764 HTML *ft-html-indent* *html-indent* *html-indenting* 765 766 This is about variables you can set in your vimrc to customize HTML indenting. 767 768 You can set the indent for the first line after <script> and <style> 769 "blocktags" (default "zero"): > 770 771 :let g:html_indent_script1 = "inc" 772 :let g:html_indent_style1 = "inc" 773 < 774 VALUE MEANING ~ 775 "zero" zero indent 776 "auto" auto indent (same indent as the blocktag) 777 "inc" auto indent + one indent step 778 779 You can set the indent for attributes after an open <tag line: > 780 781 :let g:html_indent_attribute = 1 782 < 783 VALUE MEANING ~ 784 1 auto indent, one indent step more than <tag 785 2 auto indent, two indent steps (default) 786 > 2 auto indent, more indent steps 787 788 Many tags increase the indent for what follows per default (see "Add Indent 789 Tags" in the script). You can add further tags with: > 790 791 :let g:html_indent_inctags = "html,body,head,tbody" 792 793 You can also remove such tags with: > 794 795 :let g:html_indent_autotags = "th,td,tr,tfoot,thead" 796 797 Default value is empty for both variables. Note: the initial "inctags" are 798 only defined once per Vim session. 799 800 User variables are only read when the script is sourced. To enable your 801 changes during a session, without reloading the HTML file, you can manually 802 do: > 803 804 :call HtmlIndent_CheckUserSettings() 805 806 Detail: 807 Calculation of indent inside "blocktags" with "alien" content: 808 BLOCKTAG INDENT EXPR WHEN APPLICABLE ~ 809 <script> : {customizable} if first line of block 810 : cindent(v:lnum) if attributes empty or contain "java" 811 : -1 else (vbscript, tcl, ...) 812 <style> : {customizable} if first line of block 813 : GetCSSIndent() else 814 <!-- --> : -1 815 816 IDRIS2 *ft-idris2-indent* 817 818 Idris 2 indentation can be configured with several variables that control the 819 indentation level for different language constructs: 820 821 The "g:idris2_indent_if" variable controls the indentation of `then` and `else` 822 blocks after `if` statements. Defaults to 3. 823 824 The "g:idris2_indent_case" variable controls the indentation of patterns in 825 `case` expressions. Defaults to 5. 826 827 The "g:idris2_indent_let" variable controls the indentation after `let` 828 bindings. Defaults to 4. 829 830 The "g:idris2_indent_rewrite" variable controls the indentation after `rewrite` 831 expressions. Defaults to 8. 832 833 The "g:idris2_indent_where" variable controls the indentation of `where` 834 blocks. Defaults to 6. 835 836 The "g:idris2_indent_do" variable controls the indentation in `do` blocks. 837 Defaults to 3. 838 839 Example configuration: > 840 841 let g:idris2_indent_if = 2 842 let g:idris2_indent_case = 4 843 let g:idris2_indent_let = 4 844 let g:idris2_indent_rewrite = 8 845 let g:idris2_indent_where = 6 846 let g:idris2_indent_do = 3 847 < 848 849 MATLAB *ft-matlab-indent* *matlab-indent* *matlab-indenting* 850 851 The setting Function indenting format in MATLAB Editor/Debugger Language 852 Preferences corresponds to: > 853 :let g:MATLAB_function_indent = {0, 1 or 2 (default)} 854 855 Where 0 is for Classic, 1 for Indent nested functions and 2 for Indent all 856 functions. 857 858 859 PHP *ft-php-indent* *php-indent* *php-indenting* 860 861 NOTE: PHP files will be indented correctly only if PHP |syntax| is active. 862 863 If you are editing a file in Unix 'fileformat' and '\r' characters are present 864 before new lines, indentation won't proceed correctly ; you have to remove 865 those useless characters first with a command like: > 866 867 :%s /\r$//g 868 869 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the 870 script will silently remove them when Vim loads a PHP file (at each |BufRead|). 871 872 OPTIONS: ~ 873 874 PHP indenting can be altered in several ways by modifying the values of some 875 global variables: 876 877 *php-comment* *PHP_autoformatcomment* 878 To not enable auto-formatting of comments by default (if you want to use your 879 own 'formatoptions'): > 880 :let g:PHP_autoformatcomment = 0 881 882 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be 883 added, see |fo-table| for more information. 884 ------------- 885 886 *PHP_outdentSLComments* 887 To add extra indentation to single-line comments: > 888 :let g:PHP_outdentSLComments = N 889 890 With N being the number of 'shiftwidth' to add. 891 892 Only single-line comments will be affected such as: > 893 # Comment 894 // Comment 895 /* Comment */ 896 ------------- 897 898 *PHP_default_indenting* 899 To add extra indentation to every PHP lines with N being the number of 900 'shiftwidth' to add: > 901 :let g:PHP_default_indenting = N 902 903 For example, with N = 1, this will give: 904 > 905 <?php 906 if (!isset($History_lst_sel)) 907 if (!isset($History_lst_sel)) 908 if (!isset($History_lst_sel)) { 909 $History_lst_sel=0; 910 } else 911 $foo="bar"; 912 913 $command_hist = TRUE; 914 ?> 915 (Notice the extra indentation between the PHP container markers and the code) 916 ------------- 917 918 *PHP_outdentphpescape* 919 To indent PHP escape tags as the surrounding non-PHP code (only affects the 920 PHP escape tags): > 921 :let g:PHP_outdentphpescape = 0 922 ------------- 923 924 *PHP_removeCRwhenUnix* 925 To automatically remove '\r' characters when the 'fileformat' is set to Unix: > 926 :let g:PHP_removeCRwhenUnix = 1 927 ------------- 928 929 *PHP_BracesAtCodeLevel* 930 To indent braces at the same level than the code they contain: > 931 :let g:PHP_BracesAtCodeLevel = 1 932 933 This will give the following result: > 934 if ($foo) 935 { 936 foo(); 937 } 938 Instead of: > 939 if ($foo) 940 { 941 foo(); 942 } 943 944 NOTE: Indenting will be a bit slower if this option is used because some 945 optimizations won't be available. 946 ------------- 947 948 *PHP_vintage_case_default_indent* 949 To indent 'case:' and 'default:' statements in switch() blocks: > 950 :let g:PHP_vintage_case_default_indent = 1 951 952 In PHP braces are not required inside 'case/default' blocks therefore 'case:' 953 and 'default:' are indented at the same level than the 'switch()' to avoid 954 meaningless indentation. You can use the above option to return to the 955 traditional way. 956 ------------- 957 958 *PHP_noArrowMatching* 959 By default the indent script will indent multi-line chained calls by matching 960 the position of the '->': > 961 962 $user_name_very_long->name() 963 ->age() 964 ->info(); 965 966 You can revert to the classic way of indenting by setting this option to 1: > 967 :let g:PHP_noArrowMatching = 1 968 969 You will obtain the following result: > 970 971 $user_name_very_long->name() 972 ->age() 973 ->info(); 974 975 ------------- 976 977 *PHP_IndentFunctionCallParameters* 978 Extra indentation levels to add to parameters in multi-line function calls. > 979 let g:PHP_IndentFunctionCallParameters = 1 980 981 Function call arguments will indent 1 extra level. For two-space indentation: > 982 983 function call_the_thing( 984 $with_this, 985 $and_that 986 ) { 987 $this->do_the_thing( 988 $with_this, 989 $and_that 990 ); 991 } 992 993 ------------- 994 995 *PHP_IndentFunctionDeclarationParameters* 996 Extra indentation levels to add to arguments in multi-line function 997 definitions. > 998 let g:PHP_IndentFunctionDeclarationParameters = 1 999 1000 Function arguments in declarations will indent 1 extra level. For two-space 1001 indentation: > 1002 1003 function call_the_thing( 1004 $with_this, 1005 $and_that 1006 ) { 1007 $this->do_the_thing( 1008 $with_this, 1009 $and_that 1010 ); 1011 } 1012 1013 1014 PYTHON *ft-python-indent* 1015 1016 The amount of indent can be set with the `g:python_indent` |Dictionary|, which 1017 needs to be created before adding the items: > 1018 let g:python_indent = {} 1019 The examples given are the defaults. Note that the dictionary values are set 1020 to an expression, so that you can change the value of 'shiftwidth' later 1021 without having to update these values. 1022 1023 Indent after an open paren: > 1024 let g:python_indent.open_paren = 'shiftwidth() * 2' 1025 Indent after a nested paren: > 1026 let g:python_indent.nested_paren = 'shiftwidth()' 1027 Indent for a continuation line: > 1028 let g:python_indent.continue = 'shiftwidth() * 2' 1029 1030 By default, the closing paren on a multiline construct lines up under the 1031 first non-whitespace character of the previous line. 1032 If you prefer that it's lined up under the first character of the line that 1033 starts the multiline construct, reset this key: > 1034 let g:python_indent.closed_paren_align_last_line = v:false 1035 1036 The method uses |searchpair()| to look back for unclosed parentheses. This 1037 can sometimes be slow, thus it timeouts after 150 msec. If you notice the 1038 indenting isn't correct, you can set a larger timeout in msec: > 1039 let g:python_indent.searchpair_timeout = 500 1040 1041 If looking back for unclosed parenthesis is still too slow, especially during 1042 a copy-paste operation, or if you don't need indenting inside multi-line 1043 parentheses, you can completely disable this feature: > 1044 let g:python_indent.disable_parentheses_indenting = 1 1045 1046 For backward compatibility, these variables are also supported: > 1047 g:pyindent_open_paren 1048 g:pyindent_nested_paren 1049 g:pyindent_continue 1050 g:pyindent_searchpair_timeout 1051 g:pyindent_disable_parentheses_indenting 1052 1053 1054 R *ft-r-indent* 1055 1056 Function arguments are aligned if they span for multiple lines. If you prefer 1057 do not have the arguments of functions aligned, put in your |vimrc|: 1058 > 1059 let r_indent_align_args = 0 1060 < 1061 All lines beginning with a comment character, #, get the same indentation 1062 level of the normal R code. Users of Emacs/ESS may be used to have lines 1063 beginning with a single # indented in the 40th column, ## indented as R code, 1064 and ### not indented. If you prefer that lines beginning with comment 1065 characters are aligned as they are by Emacs/ESS, put in your |vimrc|: 1066 > 1067 let r_indent_ess_comments = 1 1068 < 1069 If you prefer that lines beginning with a single # are aligned at a column 1070 different from the 40th one, you should set a new value to the variable 1071 r_indent_comment_column, as in the example below: 1072 > 1073 let r_indent_comment_column = 30 1074 < 1075 Any code after a line that ends with "<-" is indented. Emacs/ESS does not 1076 indent the code if it is a top-level function. If you prefer a behavior like 1077 Emacs/ESS one in this regard, put in your |vimrc|: 1078 > 1079 let r_indent_ess_compatible = 1 1080 < 1081 Below is an example of indentation with and without this option enabled: 1082 > 1083 ### r_indent_ess_compatible = 1 ### r_indent_ess_compatible = 0 1084 foo <- foo <- 1085 function(x) function(x) 1086 { { 1087 paste(x) paste(x) 1088 } } 1089 < 1090 The code will be indented after lines that match the pattern 1091 `'\(&\||\|+\|-\|\*\|/\|=\|\~\|%\|->\)\s*$'`. If you want indentation after 1092 lines that match a different pattern, you should set the appropriate value of 1093 `r_indent_op_pattern` in your |vimrc|. 1094 1095 1096 SHELL *ft-sh-indent* 1097 1098 The amount of indent applied under various circumstances in a shell file can 1099 be configured by setting the following keys in the |Dictionary| 1100 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a 1101 function that will return the amount desired: 1102 1103 b:sh_indent_options['default'] Default amount of indent. 1104 1105 b:sh_indent_options['continuation-line'] 1106 Amount of indent to add to a continued line. 1107 1108 b:sh_indent_options['case-labels'] 1109 Amount of indent to add for case labels. 1110 (not actually implemented) 1111 1112 b:sh_indent_options['case-statements'] 1113 Amount of indent to add for case statements. 1114 1115 b:sh_indent_options['case-breaks'] 1116 Amount of indent to add (or more likely 1117 remove) for case breaks. 1118 1119 VERILOG *ft-verilog-indent* 1120 1121 General block statements such as if, for, case, always, initial, function, 1122 specify and begin, etc., are indented. The module block statements (first 1123 level blocks) are not indented by default. you can turn on the indent with 1124 setting a variable in the .vimrc as follows: > 1125 1126 let b:verilog_indent_modules = 1 1127 1128 then the module blocks will be indented. To stop this, remove the variable: > 1129 1130 :unlet b:verilog_indent_modules 1131 1132 To set the variable only for Verilog file. The following statements can be 1133 used: > 1134 1135 au BufReadPost * if exists("b:current_syntax") 1136 au BufReadPost * if b:current_syntax == "verilog" 1137 au BufReadPost * let b:verilog_indent_modules = 1 1138 au BufReadPost * endif 1139 au BufReadPost * endif 1140 1141 Furthermore, setting the variable b:verilog_indent_width to change the 1142 indenting width (default is 'shiftwidth'): > 1143 1144 let b:verilog_indent_width = 4 1145 let b:verilog_indent_width = shiftwidth() * 2 1146 1147 In addition, you can turn the verbose mode for debug issue: > 1148 1149 let b:verilog_indent_verbose = 1 1150 1151 Make sure to do ":set cmdheight=2" first to allow the display of the message. 1152 1153 1154 VHDL *ft-vhdl-indent* 1155 1156 Alignment of generic/port mapping statements are performed by default. This 1157 causes the following alignment example: > 1158 1159 ENTITY sync IS 1160 PORT ( 1161 clk : IN STD_LOGIC; 1162 reset_n : IN STD_LOGIC; 1163 data_input : IN STD_LOGIC; 1164 data_out : OUT STD_LOGIC 1165 ); 1166 END ENTITY sync; 1167 1168 To turn this off, add > 1169 1170 let g:vhdl_indent_genportmap = 0 1171 1172 to the .vimrc file, which causes the previous alignment example to change: > 1173 1174 ENTITY sync IS 1175 PORT ( 1176 clk : IN STD_LOGIC; 1177 reset_n : IN STD_LOGIC; 1178 data_input : IN STD_LOGIC; 1179 data_out : OUT STD_LOGIC 1180 ); 1181 END ENTITY sync; 1182 1183 ---------------------------------------- 1184 1185 Alignment of right-hand side assignment "<=" statements are performed by 1186 default. This causes the following alignment example: > 1187 1188 sig_out <= (bus_a(1) AND 1189 (sig_b OR sig_c)) OR 1190 (bus_a(0) AND sig_d); 1191 1192 To turn this off, add > 1193 1194 let g:vhdl_indent_rhsassign = 0 1195 1196 to the .vimrc file, which causes the previous alignment example to change: > 1197 1198 sig_out <= (bus_a(1) AND 1199 (sig_b OR sig_c)) OR 1200 (bus_a(0) AND sig_d); 1201 1202 ---------------------------------------- 1203 1204 Full-line comments (lines that begin with "--") are indented to be aligned 1205 with the very previous line's comment, PROVIDED that a whitespace follows 1206 after "--". 1207 1208 For example: > 1209 1210 sig_a <= sig_b; -- start of a comment 1211 -- continuation of the comment 1212 -- more of the same comment 1213 1214 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F 1215 will align the current "-- " with the previous line's "--". 1216 1217 If the very previous line does not contain "--", THEN the full-line comment 1218 will be aligned with the start of the next non-blank line that is NOT a 1219 full-line comment. 1220 1221 Indenting the following code: > 1222 1223 sig_c <= sig_d; -- comment 0 1224 -- comment 1 1225 -- comment 2 1226 --debug_code: 1227 --PROCESS(debug_in) 1228 --BEGIN 1229 -- FOR i IN 15 DOWNTO 0 LOOP 1230 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); 1231 -- END LOOP; 1232 --END PROCESS debug_code; 1233 1234 -- comment 3 1235 sig_e <= sig_f; -- comment 4 1236 -- comment 5 1237 1238 results in: > 1239 1240 sig_c <= sig_d; -- comment 0 1241 -- comment 1 1242 -- comment 2 1243 --debug_code: 1244 --PROCESS(debug_in) 1245 --BEGIN 1246 -- FOR i IN 15 DOWNTO 0 LOOP 1247 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); 1248 -- END LOOP; 1249 --END PROCESS debug_code; 1250 1251 -- comment 3 1252 sig_e <= sig_f; -- comment 4 1253 -- comment 5 1254 1255 Notice that "--debug_code:" does not align with "-- comment 2" 1256 because there is no whitespace that follows after "--" in "--debug_code:". 1257 1258 Given the dynamic nature of indenting comments, indenting should be done 1259 TWICE. On the first pass, code will be indented. On the second pass, 1260 full-line comments will be indented according to the correctly indented code. 1261 1262 1263 VIM *ft-vim-indent* 1264 *g:vim_indent* 1265 Vim scripts indentation can be configured with the `g:vim_indent` dictionary 1266 variable. It supports 3 keys, `line_continuation`, `more_in_bracket_block`, 1267 and `searchpair_timeout`. 1268 `line_continuation` expects a number which will be added to the indent level of 1269 a continuation line starting with a backslash, and defaults to 1270 `shiftwidth() * 3` . It also accepts a string, which is evaluated at runtime. 1271 `more_in_bracket_block` expects a boolean value; when on, an extra 1272 `shiftwidth()` is added inside blocks surrounded with brackets. It defaults to 1273 `v:false`. 1274 `searchpair_timeout` expects a number which will be passed to `searchpair()` as 1275 a timeout. Increasing the value might give more accurate results, but also 1276 causes the indentation to take more time. It defaults to 100 (milliseconds). 1277 1278 Example of configuration: > 1279 1280 let g:vim_indent = #{ 1281 \ line_continuation: shiftwidth() * 3, 1282 \ more_in_bracket_block: v:false, 1283 \ searchpair_timeout: 100, 1284 \ } 1285 < 1286 *g:vim_indent_cont* 1287 This variable is equivalent to `g:vim_indent.line_continuation`. 1288 It's supported for backward compatibility. 1289 1290 YAML *ft-yaml-indent* 1291 1292 By default, the yaml indent script does not try to detect multiline scalars. 1293 If you want to enable this, set the following variable: > 1294 1295 let g:yaml_indent_multiline_scalar = 1 1296 < 1297 vim:tw=78:ts=8:noet:ft=help:norl: