|
799
|
1 *indent.txt* For Vim version 7.0b. Last change: 2005 Aug 30
|
|
7
|
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,
|
|
236
|
240 so that case..break looks like a sort of block. (default: 0).
|
|
7
|
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
|
|
236
|
328 /N Indent comment lines N characters extra. (default 0).
|
|
7
|
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
|
|
236
|
384 next unclosed parentheses). (default: 0).
|
|
7
|
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
|
|
236
|
409 currently unused but must be non-zero (e.g. 'j1'). 'j1' will
|
|
7
|
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:
|
|
15
|
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
|
|
7
|
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
|
|
501
|
452 FORTRAN *ft-fortran-indent*
|
|
7
|
453
|
|
236
|
454 Block if, select case, and where constructs are indented. Comments, labelled
|
|
7
|
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
|
|
236
|
457 form because of the left margin requirements. Hence manual indent corrections
|
|
7
|
458 will be necessary for labelled statements and continuation lines when fixed
|
|
236
|
459 source form is being used. For further discussion of the method used for the
|
|
501
|
460 detection of source format see |ft-fortran-syntax|.
|
|
7
|
461
|
|
|
462 Do loops ~
|
|
236
|
463 All do loops are left unindented by default. Do loops can be unstructured in
|
|
7
|
464 Fortran with (possibly multiple) loops ending on a labelled executable
|
|
236
|
465 statement of almost arbitrary type. Correct indentation requires
|
|
|
466 compiler-quality parsing. Old code with do loops ending on labelled statements
|
|
7
|
467 of arbitrary type can be indented with elaborate programs such as Tidy
|
|
236
|
468 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are
|
|
7
|
469 also left unindented because continue statements are also used for purposes
|
|
236
|
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
|
|
7
|
473 declare this by setting the fortran_do_enddo variable in your .vimrc as
|
|
|
474 follows >
|
|
|
475
|
|
|
476 let fortran_do_enddo=1
|
|
|
477
|
|
236
|
478 in which case do loops will be indented. If all your loops are of do/enddo
|
|
7
|
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
|
|
501
|
488 PYTHON *ft-python-indent*
|
|
170
|
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
|
|
501
|
502 VERILOG *ft-verilog-indent*
|
|
7
|
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
|
|
22
|
536
|
|
501
|
537 VIM *ft-vim-indent*
|
|
22
|
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
|
|
7
|
547 vim:tw=78:ts=8:ft=help:norl:
|
