Mercurial > vim
annotate runtime/doc/indent.txt @ 2217:120502692d82 vim73
Improve the MS-Windows installer.
| author | Bram Moolenaar <bram@vim.org> |
|---|---|
| date | Mon, 24 May 2010 21:34:22 +0200 |
| parents | 7c8c7c95a865 |
| children | 733f0dc510c3 0b3be97064e5 |
| rev | line source |
|---|---|
|
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
2152
diff
changeset
|
1 *indent.txt* For Vim version 7.3a. Last change: 2010 Mar 27 |
| 7 | 2 |
| 3 | |
| 4 VIM REFERENCE MANUAL by Bram Moolenaar | |
| 5 | |
| 6 | |
| 7 This file is about indenting C programs and other files. | |
| 8 | |
| 1620 | 9 1. Indenting C style programs |C-indenting| |
| 7 | 10 2. Indenting by expression |indent-expression| |
| 11 | |
| 12 ============================================================================== | |
| 1620 | 13 1. Indenting C style programs *C-indenting* |
| 7 | 14 |
| 1620 | 15 The basics for C style indenting are explained in section |30.2| of the user |
| 16 manual. | |
| 7 | 17 |
| 1620 | 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. | |
| 7 | 24 |
| 25 Note that this will not work when the |+smartindent| or |+cindent| features | |
| 26 have been disabled at compile time. | |
| 27 | |
| 1620 | 28 There are in fact four main methods available for indentation, each one |
| 29 overrides the previous if it is enabled, or non-empty for 'indentexpr': | |
| 7 | 30 'autoindent' uses the indent from the previous line. |
| 31 'smartindent' is like 'autoindent' but also recognizes some C syntax to | |
| 32 increase/reduce the indent where appropriate. | |
| 33 'cindent' Works more cleverly than the other two and is configurable to | |
| 34 different indenting styles. | |
| 35 'indentexpr' The most flexible of all: Evaluates an expression to compute | |
| 36 the indent of a line. When non-empty this method overrides | |
| 37 the other ones. See |indent-expression|. | |
| 38 The rest of this section describes the 'cindent' option. | |
| 39 | |
| 40 Note that 'cindent' indenting does not work for every code scenario. Vim | |
| 829 | 41 is not a C compiler: it does not recognize all syntax. One requirement is |
| 42 that toplevel functions have a '{' in the first column. Otherwise they are | |
| 43 easily confused with declarations. | |
| 7 | 44 |
| 45 These four options control C program indenting: | |
| 46 'cindent' Enables Vim to perform C program indenting automatically. | |
| 47 'cinkeys' Specifies which keys trigger reindenting in insert mode. | |
| 48 'cinoptions' Sets your preferred indent style. | |
| 49 'cinwords' Defines keywords that start an extra indent in the next line. | |
| 50 | |
| 51 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using | |
| 52 Vim's built-in algorithm rather than calling an external program. | |
| 53 | |
| 54 See |autocommand| for how to set the 'cindent' option automatically for C code | |
| 55 files and reset it for others. | |
| 56 | |
| 57 *cinkeys-format* *indentkeys-format* | |
| 58 The 'cinkeys' option is a string that controls Vim's indenting in response to | |
| 59 typing certain characters or commands in certain contexts. Note that this not | |
| 60 only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is | |
| 61 used instead. The format of 'cinkeys' and 'indentkeys' is equal. | |
| 62 | |
| 63 The default is "0{,0},0),:,0#,!^F,o,O,e" which specifies that indenting occurs | |
| 64 as follows: | |
| 65 | |
| 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 | |
| 818 | 78 Characters that can precede each key: *i_CTRL-F* |
| 7 | 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 | |
| 1247 | 121 press <Enter> but only if you press <Tab>, I suggest: |
| 7 | 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. In the list below, | |
| 132 "N" represents a number of your choice (the number can be negative). When | |
| 133 there is an 's' after the number, Vim multiplies the number by 'shiftwidth': | |
| 134 "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. You can use a | |
| 135 decimal point, too: "-0.5s" is minus half a 'shiftwidth'. The examples below | |
| 136 assume a 'shiftwidth' of 4. | |
| 137 | |
| 138 >N Amount added for "normal" indent. Used after a line that should | |
| 139 increase the indent (lines starting with "if", an opening brace, | |
| 140 etc.). (default 'shiftwidth'). | |
| 141 | |
| 142 cino= cino=>2 cino=>2s > | |
| 143 if (cond) if (cond) if (cond) | |
| 144 { { { | |
| 145 foo; foo; foo; | |
| 146 } } } | |
| 147 < | |
| 148 eN Add N to the prevailing indent inside a set of braces if the | |
| 149 opening brace at the End of the line (more precise: is not the | |
| 150 first character in a line). This is useful if you want a | |
| 151 different indent when the '{' is at the start of the line from | |
| 152 when '{' is at the end of the line. (default 0). | |
| 153 | |
| 154 cino= cino=e2 cino=e-2 > | |
| 155 if (cond) { if (cond) { if (cond) { | |
| 156 foo; foo; foo; | |
| 157 } } } | |
| 158 else else else | |
| 159 { { { | |
| 160 bar; bar; bar; | |
| 161 } } } | |
| 162 < | |
| 163 nN Add N to the prevailing indent for a statement after an "if", | |
| 164 "while", etc., if it is NOT inside a set of braces. This is | |
| 165 useful if you want a different indent when there is no '{' | |
| 166 before the statement from when there is a '{' before it. | |
| 167 (default 0). | |
| 168 | |
| 169 cino= cino=n2 cino=n-2 > | |
| 170 if (cond) if (cond) if (cond) | |
| 171 foo; foo; foo; | |
| 172 else else else | |
| 173 { { { | |
| 174 bar; bar; bar; | |
| 175 } } } | |
| 176 < | |
| 177 fN Place the first opening brace of a function or other block in | |
| 178 column N. This applies only for an opening brace that is not | |
| 179 inside other braces and is at the start of the line. What comes | |
| 180 after the brace is put relative to this brace. (default 0). | |
| 181 | |
| 182 cino= cino=f.5s cino=f1s > | |
| 183 func() func() func() | |
| 184 { { { | |
| 185 int foo; int foo; int foo; | |
| 186 < | |
| 187 {N Place opening braces N characters from the prevailing indent. | |
| 188 This applies only for opening braces that are inside other | |
| 189 braces. (default 0). | |
| 190 | |
| 191 cino= cino={.5s cino={1s > | |
| 192 if (cond) if (cond) if (cond) | |
| 193 { { { | |
| 194 foo; foo; foo; | |
| 195 < | |
| 196 }N Place closing braces N characters from the matching opening | |
| 197 brace. (default 0). | |
| 198 | |
| 199 cino= cino={2,}-0.5s cino=}2 > | |
| 200 if (cond) if (cond) if (cond) | |
| 201 { { { | |
| 202 foo; foo; foo; | |
| 203 } } } | |
| 204 < | |
| 205 ^N Add N to the prevailing indent inside a set of braces if the | |
| 206 opening brace is in column 0. This can specify a different | |
| 207 indent for whole of a function (some may like to set it to a | |
| 208 negative number). (default 0). | |
| 209 | |
| 210 cino= cino=^-2 cino=^-s > | |
| 211 func() func() func() | |
| 212 { { { | |
| 213 if (cond) if (cond) if (cond) | |
| 214 { { { | |
| 215 a = b; a = b; a = b; | |
| 216 } } } | |
| 217 } } } | |
| 218 < | |
| 219 :N Place case labels N characters from the indent of the switch(). | |
| 220 (default 'shiftwidth'). | |
| 221 | |
| 222 cino= cino=:0 > | |
| 223 switch (x) switch(x) | |
| 224 { { | |
| 225 case 1: case 1: | |
| 226 a = b; a = b; | |
| 227 default: default: | |
| 228 } } | |
| 229 < | |
| 230 =N Place statements occurring after a case label N characters from | |
| 231 the indent of the label. (default 'shiftwidth'). | |
| 232 | |
| 233 cino= cino==10 > | |
| 234 case 11: case 11: a = a + 1; | |
| 235 a = a + 1; b = b + 1; | |
| 236 < | |
| 237 lN If N != 0 Vim will align with a case label instead of the | |
| 238 statement after it in the same line. | |
| 239 | |
| 240 cino= cino=l1 > | |
| 241 switch (a) { switch (a) { | |
| 242 case 1: { case 1: { | |
| 243 break; break; | |
| 244 } } | |
| 245 < | |
| 246 bN If N != 0 Vim will align a final "break" with the case label, | |
| 236 | 247 so that case..break looks like a sort of block. (default: 0). |
| 7 | 248 |
| 249 cino= cino=b1 > | |
| 250 switch (x) switch(x) | |
| 251 { { | |
| 252 case 1: case 1: | |
| 253 a = b; a = b; | |
| 254 break; break; | |
| 255 | |
| 256 default: default: | |
| 257 a = 0; a = 0; | |
| 258 break; break; | |
| 259 } } | |
| 260 < | |
| 261 gN Place C++ scope declarations N characters from the indent of the | |
| 262 block they are in. (default 'shiftwidth'). A scope declaration | |
| 263 can be "public:", "protected:" or "private:". | |
| 264 | |
| 265 cino= cino=g0 > | |
| 266 { { | |
| 267 public: public: | |
| 268 a = b; a = b; | |
| 269 private: private: | |
| 270 } } | |
| 271 < | |
| 272 hN Place statements occurring after a C++ scope declaration N | |
| 273 characters from the indent of the label. (default | |
| 274 'shiftwidth'). | |
| 275 | |
| 276 cino= cino=h10 > | |
| 277 public: public: a = a + 1; | |
| 278 a = a + 1; b = b + 1; | |
| 279 < | |
| 280 pN Parameter declarations for K&R-style function declarations will | |
| 281 be indented N characters from the margin. (default | |
| 282 'shiftwidth'). | |
| 283 | |
| 284 cino= cino=p0 cino=p2s > | |
| 285 func(a, b) func(a, b) func(a, b) | |
| 286 int a; int a; int a; | |
| 287 char b; char b; char b; | |
| 288 < | |
| 289 tN Indent a function return type declaration N characters from the | |
| 290 margin. (default 'shiftwidth'). | |
| 291 | |
| 292 cino= cino=t0 cino=t7 > | |
| 293 int int int | |
| 294 func() func() func() | |
| 295 < | |
| 843 | 296 iN Indent C++ base class declarations and constructor |
| 7 | 297 initializations, if they start in a new line (otherwise they |
| 298 are aligned at the right side of the ':'). | |
| 299 (default 'shiftwidth'). | |
| 300 | |
| 301 cino= cino=i0 > | |
| 302 class MyClass : class MyClass : | |
| 303 public BaseClass public BaseClass | |
| 304 {} {} | |
| 305 MyClass::MyClass() : MyClass::MyClass() : | |
| 306 BaseClass(3) BaseClass(3) | |
| 307 {} {} | |
| 308 < | |
| 309 +N Indent a continuation line (a line that spills onto the next) N | |
| 310 additional characters. (default 'shiftwidth'). | |
| 311 | |
| 312 cino= cino=+10 > | |
| 313 a = b + 9 * a = b + 9 * | |
| 314 c; c; | |
| 315 < | |
| 316 cN Indent comment lines after the comment opener, when there is no | |
| 317 other text with which to align, N characters from the comment | |
| 318 opener. (default 3). See also |format-comments|. | |
| 319 | |
| 320 cino= cino=c5 > | |
| 321 /* /* | |
| 322 text. text. | |
| 323 */ */ | |
| 324 < | |
| 325 CN When N is non-zero, indent comment lines by the amount specified | |
| 326 with the c flag above even if there is other text behind the | |
| 327 comment opener. (default 0). | |
| 328 | |
| 329 cino=c0 cino=c0,C1 > | |
| 330 /******** /******** | |
| 331 text. text. | |
| 332 ********/ ********/ | |
| 333 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*") | |
| 334 | |
| 236 | 335 /N Indent comment lines N characters extra. (default 0). |
| 7 | 336 cino= cino=/4 > |
| 337 a = b; a = b; | |
| 338 /* comment */ /* comment */ | |
| 339 c = d; c = d; | |
| 340 < | |
| 341 (N When in unclosed parentheses, indent N characters from the line | |
| 342 with the unclosed parentheses. Add a 'shiftwidth' for every | |
| 343 unclosed parentheses. When N is 0 or the unclosed parentheses | |
| 344 is the first non-white character in its line, line up with the | |
| 345 next non-white character after the unclosed parentheses. | |
| 346 (default 'shiftwidth' * 2). | |
| 347 | |
| 348 cino= cino=(0 > | |
| 349 if (c1 && (c2 || if (c1 && (c2 || | |
| 350 c3)) c3)) | |
| 351 foo; foo; | |
| 352 if (c1 && if (c1 && | |
| 353 (c2 || c3)) (c2 || c3)) | |
| 354 { { | |
| 355 < | |
| 356 uN Same as (N, but for one level deeper. (default 'shiftwidth'). | |
| 357 | |
| 358 cino= cino=u2 > | |
| 359 if (c123456789 if (c123456789 | |
| 360 && (c22345 && (c22345 | |
| 361 || c3)) || c3)) | |
| 362 < | |
| 363 UN When N is non-zero, do not ignore the indenting specified by | |
| 364 ( or u in case that the unclosed parentheses is the first | |
| 365 non-white character in its line. (default 0). | |
| 366 | |
| 367 cino= or cino=(s cino=(s,U1 > | |
| 368 c = c1 && c = c1 && | |
| 369 ( ( | |
| 370 c2 || c2 || | |
| 371 c3 c3 | |
| 372 ) && c4; ) && c4; | |
| 373 < | |
| 374 wN When in unclosed parentheses and N is non-zero and either | |
| 375 using "(0" or "u0", respectively, or using "U0" and the unclosed | |
| 376 parentheses is the first non-white character in its line, line | |
| 377 up with the character immediately after the unclosed parentheses | |
| 378 rather than the first non-white character. (default 0). | |
| 379 | |
| 380 cino=(0 cino=(0,w1 > | |
| 381 if ( c1 if ( c1 | |
| 382 && ( c2 && ( c2 | |
| 383 || c3)) || c3)) | |
| 384 foo; foo; | |
| 385 < | |
| 386 WN When in unclosed parentheses and N is non-zero and either | |
| 387 using "(0" or "u0", respectively and the unclosed parentheses is | |
| 388 the last non-white character in its line and it is not the | |
| 389 closing parentheses, indent the following line N characters | |
| 390 relative to the outer context (i.e. start of the line or the | |
| 236 | 391 next unclosed parentheses). (default: 0). |
| 7 | 392 |
| 393 cino=(0 cino=(0,W4 > | |
| 394 a_long_line( a_long_line( | |
| 395 argument, argument, | |
| 396 argument); argument); | |
| 397 a_short_line(argument, a_short_line(argument, | |
| 398 argument); argument); | |
| 399 < | |
| 400 mN When N is non-zero, line up a line starting with a closing | |
| 401 parentheses with the first character of the line with the | |
| 402 matching opening parentheses. (default 0). | |
| 403 | |
| 404 cino=(s cino=(s,m1 > | |
| 405 c = c1 && ( c = c1 && ( | |
| 406 c2 || c2 || | |
| 407 c3 c3 | |
| 408 ) && c4; ) && c4; | |
| 409 if ( if ( | |
| 410 c1 && c2 c1 && c2 | |
| 411 ) ) | |
| 412 foo; foo; | |
| 413 < | |
| 829 | 414 MN When N is non-zero, line up a line starting with a closing |
| 415 parentheses with the first character of the previous line. | |
| 416 (default 0). | |
| 417 | |
| 418 cino= cino=M1 > | |
| 419 if (cond1 && if (cond1 && | |
| 856 | 420 cond2 cond2 |
| 421 ) ) | |
| 829 | 422 < |
| 7 | 423 *java-cinoptions* *java-indenting* |
| 424 jN Indent java anonymous classes correctly. The value 'N' is | |
| 236 | 425 currently unused but must be non-zero (e.g. 'j1'). 'j1' will |
| 7 | 426 indent for example the following code snippet correctly: > |
| 427 | |
| 428 object.add(new ChangeListener() { | |
| 429 public void stateChanged(ChangeEvent e) { | |
| 430 do_something(); | |
| 431 } | |
| 432 }); | |
| 433 < | |
| 434 )N Vim searches for unclosed parentheses at most N lines away. | |
| 435 This limits the time needed to search for parentheses. (default | |
| 436 20 lines). | |
| 437 | |
| 438 *N Vim searches for unclosed comments at most N lines away. This | |
| 439 limits the time needed to search for the start of a comment. | |
| 2072 | 440 (default 70 lines). |
| 7 | 441 |
| 1096 | 442 #N When N is non-zero recognize shell/Perl comments, starting with |
| 443 '#'. Default N is zero: don't recognizes '#' comments. Note | |
| 444 that lines starting with # will still be seen as preprocessor | |
| 445 lines. | |
| 446 | |
| 7 | 447 |
| 448 The defaults, spelled out in full, are: | |
| 15 | 449 cinoptions=>s,e0,n0,f0,{0,}0,^0,:s,=s,l0,b0,gs,hs,ps,ts,is,+s,c3,C0, |
| 2152 | 450 /0,(2s,us,U0,w0,W0,m0,j0,)20,*70,#0 |
| 7 | 451 |
| 452 Vim puts a line in column 1 if: | |
| 453 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'. | |
| 454 - It starts with a label (a keyword followed by ':', other than "case" and | |
| 455 "default"). | |
| 456 - Any combination of indentations causes the line to have less than 0 | |
| 457 indentation. | |
| 458 | |
| 459 ============================================================================== | |
| 460 2. Indenting by expression *indent-expression* | |
| 461 | |
| 462 The basics for using flexible indenting are explained in section |30.3| of the | |
| 463 user manual. | |
| 464 | |
| 465 If you want to write your own indent file, it must set the 'indentexpr' | |
| 466 option. Setting the 'indentkeys' option is often useful. See the | |
| 467 $VIMRUNTIME/indent directory for examples. | |
| 468 | |
| 469 | |
| 470 REMARKS ABOUT SPECIFIC INDENT FILES ~ | |
| 471 | |
| 472 | |
| 501 | 473 FORTRAN *ft-fortran-indent* |
| 7 | 474 |
| 236 | 475 Block if, select case, and where constructs are indented. Comments, labelled |
| 7 | 476 statements and continuation lines are indented if the Fortran is in free |
| 477 source form, whereas they are not indented if the Fortran is in fixed source | |
| 236 | 478 form because of the left margin requirements. Hence manual indent corrections |
| 7 | 479 will be necessary for labelled statements and continuation lines when fixed |
| 236 | 480 source form is being used. For further discussion of the method used for the |
| 501 | 481 detection of source format see |ft-fortran-syntax|. |
| 7 | 482 |
| 483 Do loops ~ | |
| 236 | 484 All do loops are left unindented by default. Do loops can be unstructured in |
| 7 | 485 Fortran with (possibly multiple) loops ending on a labelled executable |
| 236 | 486 statement of almost arbitrary type. Correct indentation requires |
| 487 compiler-quality parsing. Old code with do loops ending on labelled statements | |
| 7 | 488 of arbitrary type can be indented with elaborate programs such as Tidy |
| 236 | 489 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are |
| 7 | 490 also left unindented because continue statements are also used for purposes |
| 236 | 491 other than ending a do loop. Programs such as Tidy can convert structured |
| 492 do/continue loops to the do/enddo form. Do loops of the do/enddo variety can | |
| 493 be indented. If you use only structured loops of the do/enddo form, you should | |
| 7 | 494 declare this by setting the fortran_do_enddo variable in your .vimrc as |
| 495 follows > | |
| 496 | |
| 497 let fortran_do_enddo=1 | |
| 498 | |
| 236 | 499 in which case do loops will be indented. If all your loops are of do/enddo |
| 7 | 500 type only in, say, .f90 files, then you should set a buffer flag with an |
| 501 autocommand such as > | |
| 502 | |
| 503 au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1 | |
| 504 | |
| 505 to get do loops indented in .f90 files and left alone in Fortran files with | |
| 506 other extensions such as .for. | |
| 507 | |
| 508 | |
| 1668 | 509 PHP *ft-php-indent* *php-indent* *php-indenting* |
| 510 | |
| 511 NOTE: PHP files will be indented correctly only if PHP |syntax| is active. | |
| 512 | |
| 513 If you are editing a file in Unix 'fileformat' and '\r' characters are present | |
| 514 before new lines, indentation won't proceed correctly ; you have to remove | |
| 515 those useless characters first with a command like: > | |
| 516 | |
| 517 :%s /\r$//g | |
| 518 | |
| 519 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the | |
| 520 script will silently remove them when Vim loads a PHP file (at each|BufRead|). | |
| 521 | |
| 522 OPTIONS: ~ | |
| 523 | |
| 524 PHP indenting can be altered in several ways by modifying the values of some | |
| 525 variables: | |
| 526 | |
| 527 *php-comment* | |
| 528 To not enable auto-formating of comments by default (if you want to use your | |
| 529 own 'formatoptions'): > | |
| 530 :let g:PHP_autoformatcomment = 0 | |
| 531 | |
| 532 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be | |
| 533 added, see|fo-table|for more information. | |
| 534 ------------- | |
| 535 | |
| 536 To add an extra indent to every PHP lines with N being the number of | |
| 537 'shiftwidth' to add: > | |
| 538 :let g:PHP_default_indenting = N | |
| 539 | |
| 540 For example, with N = 1, this will give: | |
| 541 > | |
| 542 <?php | |
| 543 if (!isset($History_lst_sel)) | |
| 544 if (!isset($History_lst_sel)) | |
| 545 if (!isset($History_lst_sel)) { | |
| 546 $History_lst_sel=0; | |
| 547 } else | |
| 548 $foo="bar"; | |
| 549 | |
| 550 $command_hist = TRUE; | |
| 551 ?> | |
| 552 (Notice the extra indent between the PHP container markers and the code) | |
| 553 ------------- | |
| 554 | |
| 555 To automatically remove '\r' characters when the 'fileformat' is set to Unix: > | |
| 556 :let g:PHP_removeCRwhenUnix = 1 | |
| 557 ------------- | |
| 558 | |
| 559 To indent braces at the same level than the code they contain: > | |
| 560 :let g:PHP_BracesAtCodeLevel = 1 | |
| 561 | |
| 562 This will give the following result: > | |
| 563 if ($foo) | |
| 564 { | |
| 565 foo(); | |
| 566 } | |
| 567 Instead of: > | |
| 568 if ($foo) | |
| 569 { | |
| 570 foo(); | |
| 571 } | |
| 572 | |
| 573 NOTE: Indenting will be a bit slower if this option is used because some | |
| 574 optimizations won't be available. | |
| 575 ------------- | |
| 576 | |
| 577 To indent 'case:' and 'default:' statements in switch() blocks: > | |
| 578 :let g:PHP_vintage_case_default_indent = 1 | |
| 579 | |
| 580 (By default they are indented at the same level than the 'switch()' to avoid | |
| 581 unnecessary indentation) | |
| 582 | |
| 583 | |
| 501 | 584 PYTHON *ft-python-indent* |
| 170 | 585 |
| 586 The amount of indent can be set for the following situations. The examples | |
| 1698 | 587 given are the defaults. Note that the variables are set to an expression, so |
| 588 that you can change the value of 'shiftwidth' later. | |
| 170 | 589 |
| 590 Indent after an open paren: > | |
| 591 let g:pyindent_open_paren = '&sw * 2' | |
| 592 Indent after a nested paren: > | |
| 593 let g:pyindent_nested_paren = '&sw' | |
| 594 Indent for a continuation line: > | |
| 595 let g:pyindent_continue = '&sw * 2' | |
| 596 | |
| 597 | |
| 1201 | 598 SHELL *ft-sh-indent* |
| 599 | |
| 600 The amount of indent applied under various circumstances in a shell file can | |
| 601 be configured by setting the following keys in the |Dictionary| | |
| 602 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a | |
| 603 function that will return the amount desired: | |
| 604 | |
| 605 b:sh_indent_options['default'] Default amount of indent. | |
| 606 | |
| 607 b:sh_indent_options['continuation-line'] | |
| 608 Amount of indent to add to a continued line. | |
| 609 | |
| 610 b:sh_indent_options['case-labels'] | |
| 611 Amount of indent to add for case labels. | |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
612 (not actually implemented) |
| 1201 | 613 |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
614 b:sh_indent_options['case-statements'] |
| 1201 | 615 Amount of indent to add for case statements. |
| 616 | |
| 617 b:sh_indent_options['case-breaks'] | |
| 618 Amount of indent to add (or more likely | |
| 619 remove) for case breaks. | |
| 620 | |
| 501 | 621 VERILOG *ft-verilog-indent* |
| 7 | 622 |
| 623 General block statements such as if, for, case, always, initial, function, | |
| 624 specify and begin, etc., are indented. The module block statements (first | |
| 625 level blocks) are not indented by default. you can turn on the indent with | |
| 626 setting a variable in the .vimrc as follows: > | |
| 627 | |
| 628 let b:verilog_indent_modules = 1 | |
| 629 | |
| 630 then the module blocks will be indented. To stop this, remove the variable: > | |
| 631 | |
| 632 :unlet b:verilog_indent_modules | |
| 633 | |
| 634 To set the variable only for Verilog file. The following statements can be | |
| 635 used: > | |
| 636 | |
| 637 au BufReadPost * if exists("b:current_syntax") | |
| 638 au BufReadPost * if b:current_syntax == "verilog" | |
| 639 au BufReadPost * let b:verilog_indent_modules = 1 | |
| 640 au BufReadPost * endif | |
| 641 au BufReadPost * endif | |
| 642 | |
| 643 Furthermore, setting the variable b:verilog_indent_width to change the | |
| 644 indenting width (default is 'shiftwidth'): > | |
| 645 | |
| 646 let b:verilog_indent_width = 4 | |
| 647 let b:verilog_indent_width = &sw * 2 | |
| 648 | |
| 649 In addition, you can turn the verbose mode for debug issue: > | |
| 650 | |
| 651 let b:verilog_indent_verbose = 1 | |
| 652 | |
| 653 Make sure to do ":set cmdheight=2" first to allow the display of the message. | |
| 654 | |
| 22 | 655 |
| 1620 | 656 VHDL *ft-vhdl-indent* |
| 657 | |
| 658 Alignment of generic/port mapping statements are performed by default. This | |
| 659 causes the following alignment example: > | |
| 660 | |
| 661 ENTITY sync IS | |
| 662 PORT ( | |
| 663 clk : IN STD_LOGIC; | |
| 664 reset_n : IN STD_LOGIC; | |
| 665 data_input : IN STD_LOGIC; | |
| 666 data_out : OUT STD_LOGIC | |
| 667 ); | |
| 668 END ENTITY sync; | |
| 669 | |
| 670 To turn this off, add > | |
| 671 | |
| 672 let g:vhdl_indent_genportmap = 0 | |
| 673 | |
| 674 to the .vimrc file, which causes the previous alignment example to change: > | |
| 675 | |
| 676 ENTITY sync IS | |
| 677 PORT ( | |
| 678 clk : IN STD_LOGIC; | |
| 679 reset_n : IN STD_LOGIC; | |
| 680 data_input : IN STD_LOGIC; | |
| 681 data_out : OUT STD_LOGIC | |
| 682 ); | |
| 683 END ENTITY sync; | |
| 684 | |
| 685 ---------------------------------------- | |
| 686 | |
| 687 Alignment of right-hand side assignment "<=" statements are performed by | |
| 688 default. This causes the following alignment example: > | |
| 689 | |
| 690 sig_out <= (bus_a(1) AND | |
| 691 (sig_b OR sig_c)) OR | |
| 692 (bus_a(0) AND sig_d); | |
| 693 | |
| 694 To turn this off, add > | |
| 695 | |
| 696 let g:vhdl_indent_rhsassign = 0 | |
| 697 | |
| 698 to the .vimrc file, which causes the previous alignment example to change: > | |
| 699 | |
| 700 sig_out <= (bus_a(1) AND | |
| 701 (sig_b OR sig_c)) OR | |
| 702 (bus_a(0) AND sig_d); | |
| 703 | |
| 704 ---------------------------------------- | |
| 705 | |
| 706 Full-line comments (lines that begin with "--") are indented to be aligned with | |
| 707 the very previous line's comment, PROVIDED that a whitespace follows after | |
| 708 "--". | |
| 709 | |
| 710 For example: > | |
| 711 | |
| 712 sig_a <= sig_b; -- start of a comment | |
| 713 -- continuation of the comment | |
| 714 -- more of the same comment | |
| 715 | |
| 716 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F | |
| 717 will align the current "-- " with the previous line's "--". | |
| 718 | |
| 719 If the very previous line does not contain "--", THEN the full-line comment | |
| 720 will be aligned with the start of the next non-blank line that is NOT a | |
| 721 full-line comment. | |
| 722 | |
| 723 Indenting the following code: > | |
| 724 | |
| 725 sig_c <= sig_d; -- comment 0 | |
| 726 -- comment 1 | |
| 727 -- comment 2 | |
| 728 --debug_code: | |
| 729 --PROCESS(debug_in) | |
| 730 --BEGIN | |
| 731 -- FOR i IN 15 DOWNTO 0 LOOP | |
| 732 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
| 733 -- END LOOP; | |
| 734 --END PROCESS debug_code; | |
| 735 | |
| 736 -- comment 3 | |
| 737 sig_e <= sig_f; -- comment 4 | |
| 738 -- comment 5 | |
| 739 | |
| 740 results in: > | |
| 741 | |
| 742 sig_c <= sig_d; -- comment 0 | |
| 743 -- comment 1 | |
| 744 -- comment 2 | |
| 745 --debug_code: | |
| 746 --PROCESS(debug_in) | |
| 747 --BEGIN | |
| 748 -- FOR i IN 15 DOWNTO 0 LOOP | |
| 749 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
| 750 -- END LOOP; | |
| 751 --END PROCESS debug_code; | |
| 752 | |
| 753 -- comment 3 | |
| 754 sig_e <= sig_f; -- comment 4 | |
| 755 -- comment 5 | |
| 756 | |
| 757 Notice that "--debug_code:" does not align with "-- comment 2" | |
| 758 because there is no whitespace that follows after "--" in "--debug_code:". | |
| 759 | |
| 760 Given the dynamic nature of indenting comments, indenting should be done TWICE. | |
| 761 On the first pass, code will be indented. On the second pass, full-line | |
| 762 comments will be indented according to the correctly indented code. | |
| 763 | |
| 764 | |
| 501 | 765 VIM *ft-vim-indent* |
| 22 | 766 |
| 767 For indenting Vim scripts there is one variable that specifies the amount of | |
| 768 indent for a continuation line, a line that starts with a backslash: > | |
| 769 | |
| 770 :let g:vim_indent_cont = &sw * 3 | |
| 771 | |
| 772 Three times shiftwidth is the default value. | |
| 773 | |
| 774 | |
| 7 | 775 vim:tw=78:ts=8:ft=help:norl: |