| blob | 74e08043a7c72a106d9b75bee8f9f05ad5c6d86a |
1 *indent.txt* For Vim version 7.4. Last change: 2013 Aug 03
4 VIM REFERENCE MANUAL by Bram Moolenaar
7 This file is about indenting C programs and other files.
9 1. Indenting C style programs |C-indenting|
10 2. Indenting by expression |indent-expression|
12 ==============================================================================
13 1. Indenting C style programs *C-indenting*
15 The basics for C style indenting are explained in section |30.2| of the user
16 manual.
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.
25 Note that this will not work when the |+smartindent| or |+cindent| features
26 have been disabled at compile time.
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':
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.
40 Note that 'cindent' indenting does not work for every code scenario. Vim
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.
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.
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.
54 See |autocommand| for how to set the 'cindent' option automatically for C code
55 files and reset it for others.
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.
63 The default is "0{,0},0),:,0#,!^F,o,O,e" which specifies that indenting occurs
64 as follows:
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
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.
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 ';'.
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.
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.
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.
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.
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
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').
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).
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).
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).
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).
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).
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).
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).
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').
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').
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.
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'.
281 cino= cino=b1 >
282 switch (x) switch(x)
283 { {
284 case 1: case 1:
285 a = b; a = b;
286 break; break;
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'). A scope declaration
296 can be "public:", "protected:" or "private:".
298 cino= cino=g0 >
299 { {
300 public: public:
301 a = b; a = b;
302 private: private:
303 } }
304 <
305 *cino-h*
306 hN Place statements occurring after a C++ scope declaration N
307 characters from the indent of the label. (default
308 'shiftwidth').
310 cino= cino=h10 >
311 public: public: a = a + 1;
312 a = a + 1; b = b + 1;
313 <
314 *cino-N*
315 NN Indent inside C++ namespace N characters extra compared to a
316 normal block. (default 0).
318 cino= cino=N-s >
319 namespace { namespace {
320 void function(); void function();
321 } }
323 namespace my namespace my
324 { {
325 void function(); void function();
326 } }
327 <
328 *cino-p*
329 pN Parameter declarations for K&R-style function declarations will
330 be indented N characters from the margin. (default
331 'shiftwidth').
333 cino= cino=p0 cino=p2s >
334 func(a, b) func(a, b) func(a, b)
335 int a; int a; int a;
336 char b; char b; char b;
337 <
338 *cino-t*
339 tN Indent a function return type declaration N characters from the
340 margin. (default 'shiftwidth').
342 cino= cino=t0 cino=t7 >
343 int int int
344 func() func() func()
345 <
346 *cino-i*
347 iN Indent C++ base class declarations and constructor
348 initializations, if they start in a new line (otherwise they
349 are aligned at the right side of the ':').
350 (default 'shiftwidth').
352 cino= cino=i0 >
353 class MyClass : class MyClass :
354 public BaseClass public BaseClass
355 {} {}
356 MyClass::MyClass() : MyClass::MyClass() :
357 BaseClass(3) BaseClass(3)
358 {} {}
359 <
360 *cino-+*
361 +N Indent a continuation line (a line that spills onto the next)
362 inside a function N additional characters. (default
363 'shiftwidth').
364 Outside of a function, when the previous line ended in a
365 backslash, the 2 * N is used.
367 cino= cino=+10 >
368 a = b + 9 * a = b + 9 *
369 c; c;
370 <
371 *cino-c*
372 cN Indent comment lines after the comment opener, when there is no
373 other text with which to align, N characters from the comment
374 opener. (default 3). See also |format-comments|.
376 cino= cino=c5 >
377 /* /*
378 text. text.
379 */ */
380 <
381 *cino-C*
382 CN When N is non-zero, indent comment lines by the amount specified
383 with the c flag above even if there is other text behind the
384 comment opener. (default 0).
386 cino=c0 cino=c0,C1 >
387 /******** /********
388 text. text.
389 ********/ ********/
390 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*")
392 *cino-/*
393 /N Indent comment lines N characters extra. (default 0).
394 cino= cino=/4 >
395 a = b; a = b;
396 /* comment */ /* comment */
397 c = d; c = d;
398 <
399 *cino-(*
400 (N When in unclosed parentheses, indent N characters from the line
401 with the unclosed parentheses. Add a 'shiftwidth' for every
402 unclosed parentheses. When N is 0 or the unclosed parentheses
403 is the first non-white character in its line, line up with the
404 next non-white character after the unclosed parentheses.
405 (default 'shiftwidth' * 2).
407 cino= cino=(0 >
408 if (c1 && (c2 || if (c1 && (c2 ||
409 c3)) c3))
410 foo; foo;
411 if (c1 && if (c1 &&
412 (c2 || c3)) (c2 || c3))
413 { {
414 <
415 *cino-u*
416 uN Same as (N, but for one level deeper. (default 'shiftwidth').
418 cino= cino=u2 >
419 if (c123456789 if (c123456789
420 && (c22345 && (c22345
421 || c3)) || c3))
422 <
423 *cino-U*
424 UN When N is non-zero, do not ignore the indenting specified by
425 ( or u in case that the unclosed parentheses is the first
426 non-white character in its line. (default 0).
428 cino= or cino=(s cino=(s,U1 >
429 c = c1 && c = c1 &&
430 ( (
431 c2 || c2 ||
432 c3 c3
433 ) && c4; ) && c4;
434 <
435 *cino-w*
436 wN When in unclosed parentheses and N is non-zero and either
437 using "(0" or "u0", respectively, or using "U0" and the unclosed
438 parentheses is the first non-white character in its line, line
439 up with the character immediately after the unclosed parentheses
440 rather than the first non-white character. (default 0).
442 cino=(0 cino=(0,w1 >
443 if ( c1 if ( c1
444 && ( c2 && ( c2
445 || c3)) || c3))
446 foo; foo;
447 <
448 *cino-W*
449 WN When in unclosed parentheses and N is non-zero and either
450 using "(0" or "u0", respectively and the unclosed parentheses is
451 the last non-white character in its line and it is not the
452 closing parentheses, indent the following line N characters
453 relative to the outer context (i.e. start of the line or the
454 next unclosed parentheses). (default: 0).
456 cino=(0 cino=(0,W4 >
457 a_long_line( a_long_line(
458 argument, argument,
459 argument); argument);
460 a_short_line(argument, a_short_line(argument,
461 argument); argument);
462 <
463 *cino-k*
464 kN When in unclosed parentheses which follow "if", "for" or
465 "while" and N is non-zero, overrides the behaviour defined by
466 "(N": causes the indent to be N characters relative to the outer
467 context (i.e. the line where "if", "for" or "while" is). Has
468 no effect on deeper levels of nesting. Affects flags like "wN"
469 only for the "if", "for" and "while" conditions. If 0, defaults
470 to behaviour defined by the "(N" flag. (default: 0).
472 cino=(0 cino=(0,ks >
473 if (condition1 if (condition1
474 && condition2) && condition2)
475 action(); action();
476 function(argument1 function(argument1
477 && argument2); && argument2);
478 <
479 *cino-m*
480 mN When N is non-zero, line up a line starting with a closing
481 parentheses with the first character of the line with the
482 matching opening parentheses. (default 0).
484 cino=(s cino=(s,m1 >
485 c = c1 && ( c = c1 && (
486 c2 || c2 ||
487 c3 c3
488 ) && c4; ) && c4;
489 if ( if (
490 c1 && c2 c1 && c2
491 ) )
492 foo; foo;
493 <
494 *cino-M*
495 MN When N is non-zero, line up a line starting with a closing
496 parentheses with the first character of the previous line.
497 (default 0).
499 cino= cino=M1 >
500 if (cond1 && if (cond1 &&
501 cond2 cond2
502 ) )
503 <
504 *java-cinoptions* *java-indenting* *cino-j*
505 jN Indent Java anonymous classes correctly. Also works well for
506 Javascript. The value 'N' is currently unused but must be
507 non-zero (e.g. 'j1'). 'j1' will indent for example the
508 following code snippet correctly: >
510 object.add(new ChangeListener() {
511 public void stateChanged(ChangeEvent e) {
512 do_something();
513 }
514 });
515 <
516 *javascript-cinoptions* *javascript-indenting* *cino-J*
517 JN Indent JavaScript object declarations correctly by not confusing
518 them with labels. The value 'N' is currently unused but must be
519 non-zero (e.g. 'J1'). If you enable this you probably also want
520 to set |cino-j|. >
522 var bar = {
523 foo: {
524 that: this,
525 some: ok,
526 },
527 "bar":{
528 a : 2,
529 b: "123abc",
530 x: 4,
531 "y": 5
532 }
533 }
534 <
535 *cino-)*
536 )N Vim searches for unclosed parentheses at most N lines away.
537 This limits the time needed to search for parentheses. (default
538 20 lines).
540 *cino-star*
541 *N Vim searches for unclosed comments at most N lines away. This
542 limits the time needed to search for the start of a comment.
543 If your /* */ comments stop indenting after N lines this is the
544 value you will want to change.
545 (default 70 lines).
547 *cino-#*
548 #N When N is non-zero recognize shell/Perl comments, starting with
549 '#'. Default N is zero: don't recognize '#' comments. Note
550 that lines starting with # will still be seen as preprocessor
551 lines.
554 The defaults, spelled out in full, are:
555 cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,ps,ts,is,+s,
556 c3,C0,/0,(2s,us,U0,w0,W0,k0,m0,j0,J0,)20,*70,#0
558 Vim puts a line in column 1 if:
559 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'.
560 - It starts with a label (a keyword followed by ':', other than "case" and
561 "default") and 'cinoptions' does not contain an 'L' entry with a positive
562 value.
563 - Any combination of indentations causes the line to have less than 0
564 indentation.
566 ==============================================================================
567 2. Indenting by expression *indent-expression*
569 The basics for using flexible indenting are explained in section |30.3| of the
570 user manual.
572 If you want to write your own indent file, it must set the 'indentexpr'
573 option. Setting the 'indentkeys' option is often useful. See the
574 $VIMRUNTIME/indent directory for examples.
577 REMARKS ABOUT SPECIFIC INDENT FILES ~
580 CLOJURE *ft-clojure-indent* *clojure-indent*
582 Clojure indentation differs somewhat from traditional Lisps, due in part to
583 the use of square and curly brackets, and otherwise by community convention.
584 These conventions are not always universally followed, so the Clojure indent
585 script offers a few configurable options, listed below.
587 If the current vim does not include searchpairpos(), the indent script falls
588 back to normal 'lisp' indenting, and the following options are ignored.
590 *g:clojure_maxlines*
592 Set maximum scan distance of searchpairpos(). Larger values trade performance
593 for correctness when dealing with very long forms. A value of 0 will scan
594 without limits.
595 >
596 " Default
597 let g:clojure_maxlines = 100
598 <
600 *g:clojure_fuzzy_indent*
601 *g:clojure_fuzzy_indent_patterns*
602 *g:clojure_fuzzy_indent_blacklist*
604 The 'lispwords' option is a list of comma-separated words that mark special
605 forms whose subforms must be indented with two spaces.
607 For example:
608 >
609 (defn bad []
610 "Incorrect indentation")
612 (defn good []
613 "Correct indentation")
614 <
615 If you would like to specify 'lispwords' with a |pattern| instead, you can use
616 the fuzzy indent feature:
617 >
618 " Default
619 let g:clojure_fuzzy_indent = 1
620 let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']
621 let g:clojure_fuzzy_indent_blacklist =
622 \ ['-fn$', '\v^with-%(meta|out-str|loading-context)$']
624 " Legacy comma-delimited string version; the list format above is
625 " recommended. Note that patterns are implicitly anchored with ^ and $
626 let g:clojure_fuzzy_indent_patterns = 'with.*,def.*,let.*'
627 <
628 |g:clojure_fuzzy_indent_patterns| and |g:clojure_fuzzy_indent_blacklist| are
629 |Lists| of patterns that will be matched against the unquoted, unqualified
630 symbol at the head of a list. This means that a pattern like "^foo" will match
631 all these candidates: "foobar", "my.ns/foobar", and "#'foobar".
633 Each candidate word is tested for special treatment in this order:
635 1. Return true if word is literally in 'lispwords'
636 2. Return false if word matches a pattern in
637 |g:clojure_fuzzy_indent_blacklist|
638 3. Return true if word matches a pattern in
639 |g:clojure_fuzzy_indent_patterns|
640 4. Return false and indent normally otherwise
642 *g:clojure_special_indent_words*
644 Some forms in Clojure are indented so that every subform is indented only two
645 spaces, regardless of 'lispwords'. If you have a custom construct that should
646 be indented in this idiosyncratic fashion, you can add your symbols to the
647 default list below.
648 >
649 " Default
650 let g:clojure_special_indent_words =
651 \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'
652 <
654 *g:clojure_align_multiline_strings*
656 Align subsequent lines in multiline strings to the column after the opening
657 quote, instead of the same column.
659 For example:
660 >
661 (def default
662 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
663 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
664 enim ad minim veniam, quis nostrud exercitation ullamco laboris
665 nisi ut aliquip ex ea commodo consequat.")
667 (def aligned
668 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
669 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
670 enim ad minim veniam, quis nostrud exercitation ullamco laboris
671 nisi ut aliquip ex ea commodo consequat.")
672 <
673 This option is off by default.
674 >
675 " Default
676 let g:clojure_align_multiline_strings = 0
677 <
680 FORTRAN *ft-fortran-indent*
682 Block if, select case, where, and forall constructs are indented. So are
683 type, interface, associate, block, and enum constructs. The indenting of
684 subroutines, functions, modules, and program blocks is optional. Comments,
685 labelled statements and continuation lines are indented if the Fortran is in
686 free source form, whereas they are not indented if the Fortran is in fixed
687 source form because of the left margin requirements. Hence manual indent
688 corrections will be necessary for labelled statements and continuation lines
689 when fixed source form is being used. For further discussion of the method
690 used for the detection of source format see |ft-fortran-syntax|.
692 Do loops ~
693 All do loops are left unindented by default. Do loops can be unstructured in
694 Fortran with (possibly multiple) loops ending on a labelled executable
695 statement of almost arbitrary type. Correct indentation requires
696 compiler-quality parsing. Old code with do loops ending on labelled statements
697 of arbitrary type can be indented with elaborate programs such as Tidy
698 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are
699 also left unindented because continue statements are also used for purposes
700 other than ending a do loop. Programs such as Tidy can convert structured
701 do/continue loops to the do/enddo form. Do loops of the do/enddo variety can
702 be indented. If you use only structured loops of the do/enddo form, you should
703 declare this by setting the fortran_do_enddo variable in your .vimrc as
704 follows >
706 let fortran_do_enddo=1
708 in which case do loops will be indented. If all your loops are of do/enddo
709 type only in, say, .f90 files, then you should set a buffer flag with an
710 autocommand such as >
712 au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1
714 to get do loops indented in .f90 files and left alone in Fortran files with
715 other extensions such as .for.
717 Program units ~
718 The indenting of program units (subroutines, functions, modules, and program
719 blocks) is enabled by default but can be suppressed if a lighter, screen-width
720 preserving indent style is desired. To suppress the indenting of program
721 units for all fortran files set the global fortran_indent_less variable in
722 your .vimrc as follows >
724 let fortran_indent_less=1
726 A finer level of suppression can be achieved by setting the corresponding
727 buffer-local variable as follows >
729 let b:fortran_indent_less=1
732 HTML *ft-html-indent* *html-indent* *html-indenting*
734 This is about variables you can set in your vimrc to customize HTML indenting.
736 You can set the indent for the first line after <script> and <style>
737 "blocktags" (default "zero"): >
739 :let g:html_indent_script1 = "inc"
740 :let g:html_indent_style1 = "inc"
741 <
742 VALUE MEANING ~
743 "zero" zero indent
744 "auto" auto indent (same indent as the blocktag)
745 "inc" auto indent + one indent step
747 Many tags increase the indent for what follows per default (see "Add Indent
748 Tags" in the script). You can add further tags with: >
750 :let g:html_indent_inctags = "html,body,head,tbody"
752 You can also remove such tags with: >
754 :let g:html_indent_autotags = "th,td,tr,tfoot,thead"
756 Default value is empty for both variables. Note: the initial "inctags" are
757 only defined once per Vim session.
759 User variables are only read when the script is sourced. To enable your
760 changes during a session, without reloading the HTML file, you can manually
761 do: >
763 :call HtmlIndent_CheckUserSettings()
765 Detail:
766 Calculation of indent inside "blocktags" with "alien" content:
767 BLOCKTAG INDENT EXPR WHEN APPLICABLE ~
768 <script> : {customizable} if first line of block
769 : cindent(v:lnum) if attributes empty or contain "java"
770 : -1 else (vbscript, tcl, ...)
771 <style> : {customizable} if first line of block
772 : GetCSSIndent() else
773 <!-- --> : -1
776 PHP *ft-php-indent* *php-indent* *php-indenting*
778 NOTE: PHP files will be indented correctly only if PHP |syntax| is active.
780 If you are editing a file in Unix 'fileformat' and '\r' characters are present
781 before new lines, indentation won't proceed correctly ; you have to remove
782 those useless characters first with a command like: >
784 :%s /\r$//g
786 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the
787 script will silently remove them when Vim loads a PHP file (at each |BufRead|).
789 OPTIONS: ~
791 PHP indenting can be altered in several ways by modifying the values of some
792 global variables:
794 *php-comment*
795 To not enable auto-formating of comments by default (if you want to use your
796 own 'formatoptions'): >
797 :let g:PHP_autoformatcomment = 0
799 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be
800 added, see |fo-table| for more information.
801 -------------
803 To add extra indentation to single-line comments: >
804 :let g:PHP_outdentSLComments = N
806 With N being the number of 'shiftwidth' to add.
808 Only single-line comments will be affected such as: >
809 # Comment
810 // Comment
811 /* Comment */
812 -------------
814 To add extra indentation to every PHP lines with N being the number of
815 'shiftwidth' to add: >
816 :let g:PHP_default_indenting = N
818 For example, with N = 1, this will give:
819 >
820 <?php
821 if (!isset($History_lst_sel))
822 if (!isset($History_lst_sel))
823 if (!isset($History_lst_sel)) {
824 $History_lst_sel=0;
825 } else
826 $foo="bar";
828 $command_hist = TRUE;
829 ?>
830 (Notice the extra indentation between the PHP container markers and the code)
831 -------------
833 To indent PHP tags as the surrounding code: >
834 :let g:PHP_outdentphpescape = 0
835 -------------
837 To automatically remove '\r' characters when the 'fileformat' is set to Unix: >
838 :let g:PHP_removeCRwhenUnix = 1
839 -------------
841 To indent braces at the same level than the code they contain: >
842 :let g:PHP_BracesAtCodeLevel = 1
844 This will give the following result: >
845 if ($foo)
846 {
847 foo();
848 }
849 Instead of: >
850 if ($foo)
851 {
852 foo();
853 }
855 NOTE: Indenting will be a bit slower if this option is used because some
856 optimizations won't be available.
857 -------------
859 To indent 'case:' and 'default:' statements in switch() blocks: >
860 :let g:PHP_vintage_case_default_indent = 1
862 In PHP braces are not required inside 'case/default' blocks therefore 'case:'
863 and 'default:' are indented at the same level than the 'switch()' to avoid
864 meaningless indentation. You can use the above option to return to the
865 traditional way.
868 PYTHON *ft-python-indent*
870 The amount of indent can be set for the following situations. The examples
871 given are the defaults. Note that the variables are set to an expression, so
872 that you can change the value of 'shiftwidth' later.
874 Indent after an open paren: >
875 let g:pyindent_open_paren = '&sw * 2'
876 Indent after a nested paren: >
877 let g:pyindent_nested_paren = '&sw'
878 Indent for a continuation line: >
879 let g:pyindent_continue = '&sw * 2'
882 R *ft-r-indent*
884 Function arguments are aligned if they span for multiple lines. If you prefer
885 do not have the arguments of functions aligned, put in your |vimrc|:
886 >
887 let r_indent_align_args = 0
888 <
889 All lines beginning with a comment character, #, get the same indentation
890 level of the normal R code. Users of Emacs/ESS may be used to have lines
891 beginning with a single # indented in the 40th column, ## indented as R code,
892 and ### not indented. If you prefer that lines beginning with comment
893 characters are aligned as they are by Emacs/ESS, put in your |vimrc|:
894 >
895 let r_indent_ess_comments = 1
896 <
897 If you prefer that lines beginning with a single # are aligned at a column
898 different from the 40th one, you should set a new value to the variable
899 r_indent_comment_column, as in the example below:
900 >
901 let r_indent_comment_column = 30
902 <
903 Any code after a line that ends with "<-" is indented. Emacs/ESS does not
904 indent the code if it is a top level function. If you prefer that the
905 Vim-R-plugin behaves like Emacs/ESS in this regard, put in your |vimrc|:
906 >
907 let r_indent_ess_compatible = 1
908 <
909 Below is an example of indentation with and without this option enabled:
910 >
911 ### r_indent_ess_compatible = 1 ### r_indent_ess_compatible = 0
912 foo <- foo <-
913 function(x) function(x)
914 { {
915 paste(x) paste(x)
916 } }
917 <
919 SHELL *ft-sh-indent*
921 The amount of indent applied under various circumstances in a shell file can
922 be configured by setting the following keys in the |Dictionary|
923 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a
924 function that will return the amount desired:
926 b:sh_indent_options['default'] Default amount of indent.
928 b:sh_indent_options['continuation-line']
929 Amount of indent to add to a continued line.
931 b:sh_indent_options['case-labels']
932 Amount of indent to add for case labels.
933 (not actually implemented)
935 b:sh_indent_options['case-statements']
936 Amount of indent to add for case statements.
938 b:sh_indent_options['case-breaks']
939 Amount of indent to add (or more likely
940 remove) for case breaks.
942 VERILOG *ft-verilog-indent*
944 General block statements such as if, for, case, always, initial, function,
945 specify and begin, etc., are indented. The module block statements (first
946 level blocks) are not indented by default. you can turn on the indent with
947 setting a variable in the .vimrc as follows: >
949 let b:verilog_indent_modules = 1
951 then the module blocks will be indented. To stop this, remove the variable: >
953 :unlet b:verilog_indent_modules
955 To set the variable only for Verilog file. The following statements can be
956 used: >
958 au BufReadPost * if exists("b:current_syntax")
959 au BufReadPost * if b:current_syntax == "verilog"
960 au BufReadPost * let b:verilog_indent_modules = 1
961 au BufReadPost * endif
962 au BufReadPost * endif
964 Furthermore, setting the variable b:verilog_indent_width to change the
965 indenting width (default is 'shiftwidth'): >
967 let b:verilog_indent_width = 4
968 let b:verilog_indent_width = &sw * 2
970 In addition, you can turn the verbose mode for debug issue: >
972 let b:verilog_indent_verbose = 1
974 Make sure to do ":set cmdheight=2" first to allow the display of the message.
977 VHDL *ft-vhdl-indent*
979 Alignment of generic/port mapping statements are performed by default. This
980 causes the following alignment example: >
982 ENTITY sync IS
983 PORT (
984 clk : IN STD_LOGIC;
985 reset_n : IN STD_LOGIC;
986 data_input : IN STD_LOGIC;
987 data_out : OUT STD_LOGIC
988 );
989 END ENTITY sync;
991 To turn this off, add >
993 let g:vhdl_indent_genportmap = 0
995 to the .vimrc file, which causes the previous alignment example to change: >
997 ENTITY sync IS
998 PORT (
999 clk : IN STD_LOGIC;
1000 reset_n : IN STD_LOGIC;
1001 data_input : IN STD_LOGIC;
1002 data_out : OUT STD_LOGIC
1003 );
1004 END ENTITY sync;
1006 ----------------------------------------
1008 Alignment of right-hand side assignment "<=" statements are performed by
1009 default. This causes the following alignment example: >
1011 sig_out <= (bus_a(1) AND
1012 (sig_b OR sig_c)) OR
1013 (bus_a(0) AND sig_d);
1015 To turn this off, add >
1017 let g:vhdl_indent_rhsassign = 0
1019 to the .vimrc file, which causes the previous alignment example to change: >
1021 sig_out <= (bus_a(1) AND
1022 (sig_b OR sig_c)) OR
1023 (bus_a(0) AND sig_d);
1025 ----------------------------------------
1027 Full-line comments (lines that begin with "--") are indented to be aligned with
1028 the very previous line's comment, PROVIDED that a whitespace follows after
1029 "--".
1031 For example: >
1033 sig_a <= sig_b; -- start of a comment
1034 -- continuation of the comment
1035 -- more of the same comment
1037 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F
1038 will align the current "-- " with the previous line's "--".
1040 If the very previous line does not contain "--", THEN the full-line comment
1041 will be aligned with the start of the next non-blank line that is NOT a
1042 full-line comment.
1044 Indenting the following code: >
1046 sig_c <= sig_d; -- comment 0
1047 -- comment 1
1048 -- comment 2
1049 --debug_code:
1050 --PROCESS(debug_in)
1051 --BEGIN
1052 -- FOR i IN 15 DOWNTO 0 LOOP
1053 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
1054 -- END LOOP;
1055 --END PROCESS debug_code;
1057 -- comment 3
1058 sig_e <= sig_f; -- comment 4
1059 -- comment 5
1061 results in: >
1063 sig_c <= sig_d; -- comment 0
1064 -- comment 1
1065 -- comment 2
1066 --debug_code:
1067 --PROCESS(debug_in)
1068 --BEGIN
1069 -- FOR i IN 15 DOWNTO 0 LOOP
1070 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
1071 -- END LOOP;
1072 --END PROCESS debug_code;
1074 -- comment 3
1075 sig_e <= sig_f; -- comment 4
1076 -- comment 5
1078 Notice that "--debug_code:" does not align with "-- comment 2"
1079 because there is no whitespace that follows after "--" in "--debug_code:".
1081 Given the dynamic nature of indenting comments, indenting should be done TWICE.
1082 On the first pass, code will be indented. On the second pass, full-line
1083 comments will be indented according to the correctly indented code.
1086 VIM *ft-vim-indent*
1088 For indenting Vim scripts there is one variable that specifies the amount of
1089 indent for a continuation line, a line that starts with a backslash: >
1091 :let g:vim_indent_cont = &sw * 3
1093 Three times shiftwidth is the default value.
1096 vim:tw=78:ts=8:ft=help:norl: