Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 1 | *indent.txt* For Vim version 7.0aa. Last change: 2005 Mar 29 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 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 programs |C-indenting| |
| 10 | 2. Indenting by expression |indent-expression| |
| 11 | |
| 12 | ============================================================================== |
| 13 | 1. Indenting C programs *C-indenting* |
| 14 | |
| 15 | The basics for C indenting are explained in section |30.2| of the user manual. |
| 16 | |
| 17 | Vim has options for automatically indenting C program files. These options |
| 18 | affect only the indent and do not perform other formatting. For comment |
| 19 | formatting, see |format-comments|. |
| 20 | |
| 21 | Note that this will not work when the |+smartindent| or |+cindent| features |
| 22 | have been disabled at compile time. |
| 23 | |
| 24 | There are in fact four methods available for indentation: |
| 25 | 'autoindent' uses the indent from the previous line. |
| 26 | 'smartindent' is like 'autoindent' but also recognizes some C syntax to |
| 27 | increase/reduce the indent where appropriate. |
| 28 | 'cindent' Works more cleverly than the other two and is configurable to |
| 29 | different indenting styles. |
| 30 | 'indentexpr' The most flexible of all: Evaluates an expression to compute |
| 31 | the indent of a line. When non-empty this method overrides |
| 32 | the other ones. See |indent-expression|. |
| 33 | The rest of this section describes the 'cindent' option. |
| 34 | |
| 35 | Note that 'cindent' indenting does not work for every code scenario. Vim |
| 36 | is not a C compiler: it does not recognize all syntax. |
| 37 | |
| 38 | These four options control C program indenting: |
| 39 | 'cindent' Enables Vim to perform C program indenting automatically. |
| 40 | 'cinkeys' Specifies which keys trigger reindenting in insert mode. |
| 41 | 'cinoptions' Sets your preferred indent style. |
| 42 | 'cinwords' Defines keywords that start an extra indent in the next line. |
| 43 | |
| 44 | If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using |
| 45 | Vim's built-in algorithm rather than calling an external program. |
| 46 | |
| 47 | See |autocommand| for how to set the 'cindent' option automatically for C code |
| 48 | files and reset it for others. |
| 49 | |
| 50 | *cinkeys-format* *indentkeys-format* |
| 51 | The 'cinkeys' option is a string that controls Vim's indenting in response to |
| 52 | typing certain characters or commands in certain contexts. Note that this not |
| 53 | only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is |
| 54 | used instead. The format of 'cinkeys' and 'indentkeys' is equal. |
| 55 | |
| 56 | The default is "0{,0},0),:,0#,!^F,o,O,e" which specifies that indenting occurs |
| 57 | as follows: |
| 58 | |
| 59 | "0{" if you type '{' as the first character in a line |
| 60 | "0}" if you type '}' as the first character in a line |
| 61 | "0)" if you type ')' as the first character in a line |
| 62 | ":" if you type ':' after a label or case statement |
| 63 | "0#" if you type '#' as the first character in a line |
| 64 | "!^F" if you type CTRL-F (which is not inserted) |
| 65 | "o" if you type a <CR> anywhere or use the "o" command (not in |
| 66 | insert mode!) |
| 67 | "O" if you use the "O" command (not in insert mode!) |
| 68 | "e" if you type the second 'e' for an "else" at the start of a |
| 69 | line |
| 70 | |
| 71 | Characters that can precede each key: |
| 72 | ! When a '!' precedes the key, Vim will not insert the key but will |
| 73 | instead reindent the current line. This allows you to define a |
| 74 | command key for reindenting the current line. CTRL-F is the default |
| 75 | key for this. Be careful if you define CTRL-I for this because CTRL-I |
| 76 | is the ASCII code for <Tab>. |
| 77 | * When a '*' precedes the key, Vim will reindent the line before |
| 78 | inserting the key. If 'cinkeys' contains "*<Return>", Vim reindents |
| 79 | the current line before opening a new line. |
| 80 | 0 When a zero precedes the key (but appears after '!' or '*') Vim will |
| 81 | reindent the line only if the key is the first character you type in |
| 82 | the line. When used before "=" Vim will only reindent the line if |
| 83 | there is only white space before the word. |
| 84 | |
| 85 | When neither '!' nor '*' precedes the key, Vim reindents the line after you |
| 86 | type the key. So ';' sets the indentation of a line which includes the ';'. |
| 87 | |
| 88 | Special key names: |
| 89 | <> Angle brackets mean spelled-out names of keys. For example: "<Up>", |
| 90 | "<Ins>" (see |key-notation|). |
| 91 | ^ Letters preceded by a caret (^) are control characters. For example: |
| 92 | "^F" is CTRL-F. |
| 93 | o Reindent a line when you use the "o" command or when Vim opens a new |
| 94 | line below the current one (e.g., when you type <Enter> in insert |
| 95 | mode). |
| 96 | O Reindent a line when you use the "O" command. |
| 97 | e Reindent a line that starts with "else" when you type the second 'e'. |
| 98 | : Reindent a line when a ':' is typed which is after a label or case |
| 99 | statement. Don't reindent for a ":" in "class::method" for C++. To |
| 100 | Reindent for any ":", use "<:>". |
| 101 | =word Reindent when typing the last character of "word". "word" may |
| 102 | actually be part of another word. Thus "=end" would cause reindenting |
| 103 | when typing the "d" in "endif" or "endwhile". But not when typing |
| 104 | "bend". Also reindent when completion produces a word that starts |
| 105 | with "word". "0=word" reindents when there is only white space before |
| 106 | the word. |
| 107 | =~word Like =word, but ignore case. |
| 108 | |
| 109 | If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>', |
| 110 | '*', ':' or '!', use "<o>", "<O>", "<e>", "<0>", "<<>", "<>>", "<*>", "<:>" or |
| 111 | "<!>", respectively, for those keys. |
| 112 | |
| 113 | For an emacs-style indent mode where lines aren't indented every time you |
| 114 | press Enter but only if you press Tab, I suggest: |
| 115 | :set cinkeys=0{,0},:,0#,!<Tab>,!^F |
| 116 | You might also want to switch off 'autoindent' then. |
| 117 | |
| 118 | Note: If you change the current line's indentation manually, Vim ignores the |
| 119 | cindent settings for that line. This prevents vim from reindenting after you |
| 120 | have changed the indent by typing <BS>, <Tab>, or <Space> in the indent or |
| 121 | used CTRL-T or CTRL-D. |
| 122 | |
| 123 | *cinoptions-values* |
| 124 | The 'cinoptions' option sets how Vim performs indentation. In the list below, |
| 125 | "N" represents a number of your choice (the number can be negative). When |
| 126 | there is an 's' after the number, Vim multiplies the number by 'shiftwidth': |
| 127 | "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. You can use a |
| 128 | decimal point, too: "-0.5s" is minus half a 'shiftwidth'. The examples below |
| 129 | assume a 'shiftwidth' of 4. |
| 130 | |
| 131 | >N Amount added for "normal" indent. Used after a line that should |
| 132 | increase the indent (lines starting with "if", an opening brace, |
| 133 | etc.). (default 'shiftwidth'). |
| 134 | |
| 135 | cino= cino=>2 cino=>2s > |
| 136 | if (cond) if (cond) if (cond) |
| 137 | { { { |
| 138 | foo; foo; foo; |
| 139 | } } } |
| 140 | < |
| 141 | eN Add N to the prevailing indent inside a set of braces if the |
| 142 | opening brace at the End of the line (more precise: is not the |
| 143 | first character in a line). This is useful if you want a |
| 144 | different indent when the '{' is at the start of the line from |
| 145 | when '{' is at the end of the line. (default 0). |
| 146 | |
| 147 | cino= cino=e2 cino=e-2 > |
| 148 | if (cond) { if (cond) { if (cond) { |
| 149 | foo; foo; foo; |
| 150 | } } } |
| 151 | else else else |
| 152 | { { { |
| 153 | bar; bar; bar; |
| 154 | } } } |
| 155 | < |
| 156 | nN Add N to the prevailing indent for a statement after an "if", |
| 157 | "while", etc., if it is NOT inside a set of braces. This is |
| 158 | useful if you want a different indent when there is no '{' |
| 159 | before the statement from when there is a '{' before it. |
| 160 | (default 0). |
| 161 | |
| 162 | cino= cino=n2 cino=n-2 > |
| 163 | if (cond) if (cond) if (cond) |
| 164 | foo; foo; foo; |
| 165 | else else else |
| 166 | { { { |
| 167 | bar; bar; bar; |
| 168 | } } } |
| 169 | < |
| 170 | fN Place the first opening brace of a function or other block in |
| 171 | column N. This applies only for an opening brace that is not |
| 172 | inside other braces and is at the start of the line. What comes |
| 173 | after the brace is put relative to this brace. (default 0). |
| 174 | |
| 175 | cino= cino=f.5s cino=f1s > |
| 176 | func() func() func() |
| 177 | { { { |
| 178 | int foo; int foo; int foo; |
| 179 | < |
| 180 | {N Place opening braces N characters from the prevailing indent. |
| 181 | This applies only for opening braces that are inside other |
| 182 | braces. (default 0). |
| 183 | |
| 184 | cino= cino={.5s cino={1s > |
| 185 | if (cond) if (cond) if (cond) |
| 186 | { { { |
| 187 | foo; foo; foo; |
| 188 | < |
| 189 | }N Place closing braces N characters from the matching opening |
| 190 | brace. (default 0). |
| 191 | |
| 192 | cino= cino={2,}-0.5s cino=}2 > |
| 193 | if (cond) if (cond) if (cond) |
| 194 | { { { |
| 195 | foo; foo; foo; |
| 196 | } } } |
| 197 | < |
| 198 | ^N Add N to the prevailing indent inside a set of braces if the |
| 199 | opening brace is in column 0. This can specify a different |
| 200 | indent for whole of a function (some may like to set it to a |
| 201 | negative number). (default 0). |
| 202 | |
| 203 | cino= cino=^-2 cino=^-s > |
| 204 | func() func() func() |
| 205 | { { { |
| 206 | if (cond) if (cond) if (cond) |
| 207 | { { { |
| 208 | a = b; a = b; a = b; |
| 209 | } } } |
| 210 | } } } |
| 211 | < |
| 212 | :N Place case labels N characters from the indent of the switch(). |
| 213 | (default 'shiftwidth'). |
| 214 | |
| 215 | cino= cino=:0 > |
| 216 | switch (x) switch(x) |
| 217 | { { |
| 218 | case 1: case 1: |
| 219 | a = b; a = b; |
| 220 | default: default: |
| 221 | } } |
| 222 | < |
| 223 | =N Place statements occurring after a case label N characters from |
| 224 | the indent of the label. (default 'shiftwidth'). |
| 225 | |
| 226 | cino= cino==10 > |
| 227 | case 11: case 11: a = a + 1; |
| 228 | a = a + 1; b = b + 1; |
| 229 | < |
| 230 | lN If N != 0 Vim will align with a case label instead of the |
| 231 | statement after it in the same line. |
| 232 | |
| 233 | cino= cino=l1 > |
| 234 | switch (a) { switch (a) { |
| 235 | case 1: { case 1: { |
| 236 | break; break; |
| 237 | } } |
| 238 | < |
| 239 | bN If N != 0 Vim will align a final "break" with the case label, |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 240 | so that case..break looks like a sort of block. (default: 0). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 241 | |
| 242 | cino= cino=b1 > |
| 243 | switch (x) switch(x) |
| 244 | { { |
| 245 | case 1: case 1: |
| 246 | a = b; a = b; |
| 247 | break; break; |
| 248 | |
| 249 | default: default: |
| 250 | a = 0; a = 0; |
| 251 | break; break; |
| 252 | } } |
| 253 | < |
| 254 | gN Place C++ scope declarations N characters from the indent of the |
| 255 | block they are in. (default 'shiftwidth'). A scope declaration |
| 256 | can be "public:", "protected:" or "private:". |
| 257 | |
| 258 | cino= cino=g0 > |
| 259 | { { |
| 260 | public: public: |
| 261 | a = b; a = b; |
| 262 | private: private: |
| 263 | } } |
| 264 | < |
| 265 | hN Place statements occurring after a C++ scope declaration N |
| 266 | characters from the indent of the label. (default |
| 267 | 'shiftwidth'). |
| 268 | |
| 269 | cino= cino=h10 > |
| 270 | public: public: a = a + 1; |
| 271 | a = a + 1; b = b + 1; |
| 272 | < |
| 273 | pN Parameter declarations for K&R-style function declarations will |
| 274 | be indented N characters from the margin. (default |
| 275 | 'shiftwidth'). |
| 276 | |
| 277 | cino= cino=p0 cino=p2s > |
| 278 | func(a, b) func(a, b) func(a, b) |
| 279 | int a; int a; int a; |
| 280 | char b; char b; char b; |
| 281 | < |
| 282 | tN Indent a function return type declaration N characters from the |
| 283 | margin. (default 'shiftwidth'). |
| 284 | |
| 285 | cino= cino=t0 cino=t7 > |
| 286 | int int int |
| 287 | func() func() func() |
| 288 | < |
| 289 | iN Indent C++ base class declarations and contructor |
| 290 | initializations, if they start in a new line (otherwise they |
| 291 | are aligned at the right side of the ':'). |
| 292 | (default 'shiftwidth'). |
| 293 | |
| 294 | cino= cino=i0 > |
| 295 | class MyClass : class MyClass : |
| 296 | public BaseClass public BaseClass |
| 297 | {} {} |
| 298 | MyClass::MyClass() : MyClass::MyClass() : |
| 299 | BaseClass(3) BaseClass(3) |
| 300 | {} {} |
| 301 | < |
| 302 | +N Indent a continuation line (a line that spills onto the next) N |
| 303 | additional characters. (default 'shiftwidth'). |
| 304 | |
| 305 | cino= cino=+10 > |
| 306 | a = b + 9 * a = b + 9 * |
| 307 | c; c; |
| 308 | < |
| 309 | cN Indent comment lines after the comment opener, when there is no |
| 310 | other text with which to align, N characters from the comment |
| 311 | opener. (default 3). See also |format-comments|. |
| 312 | |
| 313 | cino= cino=c5 > |
| 314 | /* /* |
| 315 | text. text. |
| 316 | */ */ |
| 317 | < |
| 318 | CN When N is non-zero, indent comment lines by the amount specified |
| 319 | with the c flag above even if there is other text behind the |
| 320 | comment opener. (default 0). |
| 321 | |
| 322 | cino=c0 cino=c0,C1 > |
| 323 | /******** /******** |
| 324 | text. text. |
| 325 | ********/ ********/ |
| 326 | < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*") |
| 327 | |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 328 | /N Indent comment lines N characters extra. (default 0). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 329 | cino= cino=/4 > |
| 330 | a = b; a = b; |
| 331 | /* comment */ /* comment */ |
| 332 | c = d; c = d; |
| 333 | < |
| 334 | (N When in unclosed parentheses, indent N characters from the line |
| 335 | with the unclosed parentheses. Add a 'shiftwidth' for every |
| 336 | unclosed parentheses. When N is 0 or the unclosed parentheses |
| 337 | is the first non-white character in its line, line up with the |
| 338 | next non-white character after the unclosed parentheses. |
| 339 | (default 'shiftwidth' * 2). |
| 340 | |
| 341 | cino= cino=(0 > |
| 342 | if (c1 && (c2 || if (c1 && (c2 || |
| 343 | c3)) c3)) |
| 344 | foo; foo; |
| 345 | if (c1 && if (c1 && |
| 346 | (c2 || c3)) (c2 || c3)) |
| 347 | { { |
| 348 | < |
| 349 | uN Same as (N, but for one level deeper. (default 'shiftwidth'). |
| 350 | |
| 351 | cino= cino=u2 > |
| 352 | if (c123456789 if (c123456789 |
| 353 | && (c22345 && (c22345 |
| 354 | || c3)) || c3)) |
| 355 | < |
| 356 | UN When N is non-zero, do not ignore the indenting specified by |
| 357 | ( or u in case that the unclosed parentheses is the first |
| 358 | non-white character in its line. (default 0). |
| 359 | |
| 360 | cino= or cino=(s cino=(s,U1 > |
| 361 | c = c1 && c = c1 && |
| 362 | ( ( |
| 363 | c2 || c2 || |
| 364 | c3 c3 |
| 365 | ) && c4; ) && c4; |
| 366 | < |
| 367 | wN When in unclosed parentheses and N is non-zero and either |
| 368 | using "(0" or "u0", respectively, or using "U0" and the unclosed |
| 369 | parentheses is the first non-white character in its line, line |
| 370 | up with the character immediately after the unclosed parentheses |
| 371 | rather than the first non-white character. (default 0). |
| 372 | |
| 373 | cino=(0 cino=(0,w1 > |
| 374 | if ( c1 if ( c1 |
| 375 | && ( c2 && ( c2 |
| 376 | || c3)) || c3)) |
| 377 | foo; foo; |
| 378 | < |
| 379 | WN When in unclosed parentheses and N is non-zero and either |
| 380 | using "(0" or "u0", respectively and the unclosed parentheses is |
| 381 | the last non-white character in its line and it is not the |
| 382 | closing parentheses, indent the following line N characters |
| 383 | relative to the outer context (i.e. start of the line or the |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 384 | next unclosed parentheses). (default: 0). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 385 | |
| 386 | cino=(0 cino=(0,W4 > |
| 387 | a_long_line( a_long_line( |
| 388 | argument, argument, |
| 389 | argument); argument); |
| 390 | a_short_line(argument, a_short_line(argument, |
| 391 | argument); argument); |
| 392 | < |
| 393 | mN When N is non-zero, line up a line starting with a closing |
| 394 | parentheses with the first character of the line with the |
| 395 | matching opening parentheses. (default 0). |
| 396 | |
| 397 | cino=(s cino=(s,m1 > |
| 398 | c = c1 && ( c = c1 && ( |
| 399 | c2 || c2 || |
| 400 | c3 c3 |
| 401 | ) && c4; ) && c4; |
| 402 | if ( if ( |
| 403 | c1 && c2 c1 && c2 |
| 404 | ) ) |
| 405 | foo; foo; |
| 406 | < |
| 407 | *java-cinoptions* *java-indenting* |
| 408 | jN Indent java anonymous classes correctly. The value 'N' is |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 409 | currently unused but must be non-zero (e.g. 'j1'). 'j1' will |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 410 | indent for example the following code snippet correctly: > |
| 411 | |
| 412 | object.add(new ChangeListener() { |
| 413 | public void stateChanged(ChangeEvent e) { |
| 414 | do_something(); |
| 415 | } |
| 416 | }); |
| 417 | < |
| 418 | )N Vim searches for unclosed parentheses at most N lines away. |
| 419 | This limits the time needed to search for parentheses. (default |
| 420 | 20 lines). |
| 421 | |
| 422 | *N Vim searches for unclosed comments at most N lines away. This |
| 423 | limits the time needed to search for the start of a comment. |
| 424 | (default 30 lines). |
| 425 | |
| 426 | |
| 427 | The defaults, spelled out in full, are: |
Bram Moolenaar | 8299df9 | 2004-07-10 09:47:34 +0000 | [diff] [blame] | 428 | cinoptions=>s,e0,n0,f0,{0,}0,^0,:s,=s,l0,b0,gs,hs,ps,ts,is,+s,c3,C0, |
| 429 | /0,(2s,us,U0,w0,W0,m0,j0,)20,*30 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 430 | |
| 431 | Vim puts a line in column 1 if: |
| 432 | - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'. |
| 433 | - It starts with a label (a keyword followed by ':', other than "case" and |
| 434 | "default"). |
| 435 | - Any combination of indentations causes the line to have less than 0 |
| 436 | indentation. |
| 437 | |
| 438 | ============================================================================== |
| 439 | 2. Indenting by expression *indent-expression* |
| 440 | |
| 441 | The basics for using flexible indenting are explained in section |30.3| of the |
| 442 | user manual. |
| 443 | |
| 444 | If you want to write your own indent file, it must set the 'indentexpr' |
| 445 | option. Setting the 'indentkeys' option is often useful. See the |
| 446 | $VIMRUNTIME/indent directory for examples. |
| 447 | |
| 448 | |
| 449 | REMARKS ABOUT SPECIFIC INDENT FILES ~ |
| 450 | |
| 451 | |
| 452 | FORTRAN *fortran-indent* |
| 453 | |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 454 | Block if, select case, and where constructs are indented. Comments, labelled |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 455 | statements and continuation lines are indented if the Fortran is in free |
| 456 | source form, whereas they are not indented if the Fortran is in fixed source |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 457 | form because of the left margin requirements. Hence manual indent corrections |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 458 | will be necessary for labelled statements and continuation lines when fixed |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 459 | source form is being used. For further discussion of the method used for the |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 460 | detection of source format see |fortran-syntax|. |
| 461 | |
| 462 | Do loops ~ |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 463 | All do loops are left unindented by default. Do loops can be unstructured in |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 464 | Fortran with (possibly multiple) loops ending on a labelled executable |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 465 | statement of almost arbitrary type. Correct indentation requires |
| 466 | compiler-quality parsing. Old code with do loops ending on labelled statements |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 467 | of arbitrary type can be indented with elaborate programs such as Tidy |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 468 | (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 469 | also left unindented because continue statements are also used for purposes |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 470 | other than ending a do loop. Programs such as Tidy can convert structured |
| 471 | do/continue loops to the do/enddo form. Do loops of the do/enddo variety can |
| 472 | be indented. If you use only structured loops of the do/enddo form, you should |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 473 | declare this by setting the fortran_do_enddo variable in your .vimrc as |
| 474 | follows > |
| 475 | |
| 476 | let fortran_do_enddo=1 |
| 477 | |
Bram Moolenaar | 402d2fe | 2005-04-15 21:00:38 +0000 | [diff] [blame] | 478 | in which case do loops will be indented. If all your loops are of do/enddo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 479 | type only in, say, .f90 files, then you should set a buffer flag with an |
| 480 | autocommand such as > |
| 481 | |
| 482 | au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1 |
| 483 | |
| 484 | to get do loops indented in .f90 files and left alone in Fortran files with |
| 485 | other extensions such as .for. |
| 486 | |
| 487 | |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 488 | PYTHON *python-indent* |
| 489 | |
| 490 | The amount of indent can be set for the following situations. The examples |
| 491 | given are de the defaults. Note that the variables are set to an expression, |
| 492 | so that you can change the value of 'shiftwidth' later. |
| 493 | |
| 494 | Indent after an open paren: > |
| 495 | let g:pyindent_open_paren = '&sw * 2' |
| 496 | Indent after a nested paren: > |
| 497 | let g:pyindent_nested_paren = '&sw' |
| 498 | Indent for a continuation line: > |
| 499 | let g:pyindent_continue = '&sw * 2' |
| 500 | |
| 501 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 502 | VERILOG *verilog-indent* |
| 503 | |
| 504 | General block statements such as if, for, case, always, initial, function, |
| 505 | specify and begin, etc., are indented. The module block statements (first |
| 506 | level blocks) are not indented by default. you can turn on the indent with |
| 507 | setting a variable in the .vimrc as follows: > |
| 508 | |
| 509 | let b:verilog_indent_modules = 1 |
| 510 | |
| 511 | then the module blocks will be indented. To stop this, remove the variable: > |
| 512 | |
| 513 | :unlet b:verilog_indent_modules |
| 514 | |
| 515 | To set the variable only for Verilog file. The following statements can be |
| 516 | used: > |
| 517 | |
| 518 | au BufReadPost * if exists("b:current_syntax") |
| 519 | au BufReadPost * if b:current_syntax == "verilog" |
| 520 | au BufReadPost * let b:verilog_indent_modules = 1 |
| 521 | au BufReadPost * endif |
| 522 | au BufReadPost * endif |
| 523 | |
| 524 | Furthermore, setting the variable b:verilog_indent_width to change the |
| 525 | indenting width (default is 'shiftwidth'): > |
| 526 | |
| 527 | let b:verilog_indent_width = 4 |
| 528 | let b:verilog_indent_width = &sw * 2 |
| 529 | |
| 530 | In addition, you can turn the verbose mode for debug issue: > |
| 531 | |
| 532 | let b:verilog_indent_verbose = 1 |
| 533 | |
| 534 | Make sure to do ":set cmdheight=2" first to allow the display of the message. |
| 535 | |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 536 | |
| 537 | VIM *vim-indent* |
| 538 | |
| 539 | For indenting Vim scripts there is one variable that specifies the amount of |
| 540 | indent for a continuation line, a line that starts with a backslash: > |
| 541 | |
| 542 | :let g:vim_indent_cont = &sw * 3 |
| 543 | |
| 544 | Three times shiftwidth is the default value. |
| 545 | |
| 546 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 547 | vim:tw=78:ts=8:ft=help:norl: |