Mercurial > vim
annotate runtime/doc/indent.txt @ 2965:f2de38a019a2
Updated runtime files.
Add missing test82 files.
author | Bram Moolenaar <bram@vim.org> |
---|---|
date | Mon, 18 Jul 2011 19:40:27 +0200 |
parents | fd09a9c8468e |
children | 3502a7f991fc |
rev | line source |
---|---|
2965 | 1 *indent.txt* For Vim version 7.3. Last change: 2011 Jul 15 |
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* | |
2857 | 131 The 'cinoptions' option sets how Vim performs indentation. The value after |
132 the option character can be one of these (N is any number): | |
133 N indent N spaces | |
134 -N indent N spaces to the left | |
135 Ns N times 'shiftwidth spaces | |
136 -Ns N times 'shiftwidth spaces to the left | |
137 | |
138 In the list below, | |
7 | 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 | |
2857 | 142 decimal point, too: "-0.5s" is minus half a 'shiftwidth'. |
143 The examples below assume a 'shiftwidth' of 4. | |
144 *cino->* | |
7 | 145 >N Amount added for "normal" indent. Used after a line that should |
146 increase the indent (lines starting with "if", an opening brace, | |
147 etc.). (default 'shiftwidth'). | |
148 | |
149 cino= cino=>2 cino=>2s > | |
150 if (cond) if (cond) if (cond) | |
151 { { { | |
152 foo; foo; foo; | |
153 } } } | |
154 < | |
2857 | 155 *cino-e* |
7 | 156 eN Add N to the prevailing indent inside a set of braces if the |
157 opening brace at the End of the line (more precise: is not the | |
158 first character in a line). This is useful if you want a | |
159 different indent when the '{' is at the start of the line from | |
160 when '{' is at the end of the line. (default 0). | |
161 | |
162 cino= cino=e2 cino=e-2 > | |
163 if (cond) { if (cond) { if (cond) { | |
164 foo; foo; foo; | |
165 } } } | |
166 else else else | |
167 { { { | |
168 bar; bar; bar; | |
169 } } } | |
170 < | |
2857 | 171 *cino-n* |
7 | 172 nN Add N to the prevailing indent for a statement after an "if", |
173 "while", etc., if it is NOT inside a set of braces. This is | |
174 useful if you want a different indent when there is no '{' | |
175 before the statement from when there is a '{' before it. | |
176 (default 0). | |
177 | |
178 cino= cino=n2 cino=n-2 > | |
179 if (cond) if (cond) if (cond) | |
180 foo; foo; foo; | |
181 else else else | |
182 { { { | |
183 bar; bar; bar; | |
184 } } } | |
185 < | |
2857 | 186 *cino-f* |
7 | 187 fN Place the first opening brace of a function or other block in |
188 column N. This applies only for an opening brace that is not | |
189 inside other braces and is at the start of the line. What comes | |
190 after the brace is put relative to this brace. (default 0). | |
191 | |
192 cino= cino=f.5s cino=f1s > | |
193 func() func() func() | |
194 { { { | |
195 int foo; int foo; int foo; | |
196 < | |
2857 | 197 *cino-{* |
7 | 198 {N Place opening braces N characters from the prevailing indent. |
199 This applies only for opening braces that are inside other | |
200 braces. (default 0). | |
201 | |
202 cino= cino={.5s cino={1s > | |
203 if (cond) if (cond) if (cond) | |
204 { { { | |
205 foo; foo; foo; | |
206 < | |
2857 | 207 *cino-}* |
7 | 208 }N Place closing braces N characters from the matching opening |
209 brace. (default 0). | |
210 | |
211 cino= cino={2,}-0.5s cino=}2 > | |
212 if (cond) if (cond) if (cond) | |
213 { { { | |
214 foo; foo; foo; | |
215 } } } | |
216 < | |
2857 | 217 *cino-^* |
7 | 218 ^N Add N to the prevailing indent inside a set of braces if the |
219 opening brace is in column 0. This can specify a different | |
220 indent for whole of a function (some may like to set it to a | |
221 negative number). (default 0). | |
222 | |
223 cino= cino=^-2 cino=^-s > | |
224 func() func() func() | |
225 { { { | |
226 if (cond) if (cond) if (cond) | |
227 { { { | |
228 a = b; a = b; a = b; | |
229 } } } | |
230 } } } | |
231 < | |
2857 | 232 *cino-L* |
2328
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
233 LN Controls placement of jump labels. If N is negative, the label |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
234 will be placed at column 1. If N is non-negative, the indent of |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
235 the label will be the prevailing indent minus N. (default -1). |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
236 |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
237 cino= cino=L2 cino=Ls > |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
238 func() func() func() |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
239 { { { |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
240 { { { |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
241 stmt; stmt; stmt; |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
242 LABEL: LABEL: LABEL: |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
243 } } } |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
244 } } } |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
245 < |
2857 | 246 *cino-:* |
7 | 247 :N Place case labels N characters from the indent of the switch(). |
248 (default 'shiftwidth'). | |
249 | |
250 cino= cino=:0 > | |
251 switch (x) switch(x) | |
252 { { | |
253 case 1: case 1: | |
254 a = b; a = b; | |
255 default: default: | |
256 } } | |
257 < | |
2857 | 258 *cino-=* |
7 | 259 =N Place statements occurring after a case label N characters from |
260 the indent of the label. (default 'shiftwidth'). | |
261 | |
262 cino= cino==10 > | |
263 case 11: case 11: a = a + 1; | |
264 a = a + 1; b = b + 1; | |
265 < | |
2857 | 266 *cino-l* |
7 | 267 lN If N != 0 Vim will align with a case label instead of the |
268 statement after it in the same line. | |
269 | |
270 cino= cino=l1 > | |
271 switch (a) { switch (a) { | |
272 case 1: { case 1: { | |
273 break; break; | |
274 } } | |
275 < | |
2857 | 276 *cino-b* |
7 | 277 bN If N != 0 Vim will align a final "break" with the case label, |
236 | 278 so that case..break looks like a sort of block. (default: 0). |
2662 | 279 When using 1, consider adding "0=break" to 'cinkeys'. |
7 | 280 |
281 cino= cino=b1 > | |
282 switch (x) switch(x) | |
283 { { | |
284 case 1: case 1: | |
285 a = b; a = b; | |
286 break; break; | |
287 | |
288 default: default: | |
289 a = 0; a = 0; | |
290 break; break; | |
291 } } | |
292 < | |
2857 | 293 *cino-g* |
7 | 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:". | |
297 | |
298 cino= cino=g0 > | |
299 { { | |
300 public: public: | |
301 a = b; a = b; | |
302 private: private: | |
303 } } | |
304 < | |
2857 | 305 *cino-h* |
7 | 306 hN Place statements occurring after a C++ scope declaration N |
307 characters from the indent of the label. (default | |
308 'shiftwidth'). | |
309 | |
310 cino= cino=h10 > | |
311 public: public: a = a + 1; | |
312 a = a + 1; b = b + 1; | |
313 < | |
2857 | 314 *cino-N* |
315 NN Indent inside C++ namespace N characters extra compared to a | |
316 normal block. (default 0). | |
317 | |
318 cino= cino=N-s > | |
319 namespace { namespace { | |
320 void function(); void function(); | |
321 } } | |
322 | |
323 namespace my namespace my | |
324 { { | |
325 void function(); void function(); | |
326 } } | |
327 < | |
328 *cino-p* | |
7 | 329 pN Parameter declarations for K&R-style function declarations will |
330 be indented N characters from the margin. (default | |
331 'shiftwidth'). | |
332 | |
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 < | |
2857 | 338 *cino-t* |
7 | 339 tN Indent a function return type declaration N characters from the |
340 margin. (default 'shiftwidth'). | |
341 | |
342 cino= cino=t0 cino=t7 > | |
343 int int int | |
344 func() func() func() | |
345 < | |
2857 | 346 *cino-i* |
843 | 347 iN Indent C++ base class declarations and constructor |
7 | 348 initializations, if they start in a new line (otherwise they |
349 are aligned at the right side of the ':'). | |
350 (default 'shiftwidth'). | |
351 | |
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 < | |
2857 | 360 *cino-+* |
2725 | 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. | |
7 | 366 |
367 cino= cino=+10 > | |
368 a = b + 9 * a = b + 9 * | |
369 c; c; | |
370 < | |
2857 | 371 *cino-c* |
7 | 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|. | |
375 | |
376 cino= cino=c5 > | |
377 /* /* | |
378 text. text. | |
379 */ */ | |
380 < | |
2857 | 381 *cino-C* |
7 | 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). | |
385 | |
386 cino=c0 cino=c0,C1 > | |
387 /******** /******** | |
388 text. text. | |
389 ********/ ********/ | |
390 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*") | |
391 | |
2857 | 392 *cino-/* |
236 | 393 /N Indent comment lines N characters extra. (default 0). |
7 | 394 cino= cino=/4 > |
395 a = b; a = b; | |
396 /* comment */ /* comment */ | |
397 c = d; c = d; | |
398 < | |
2857 | 399 *cino-(* |
7 | 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). | |
406 | |
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 < | |
2857 | 415 *cino-u* |
7 | 416 uN Same as (N, but for one level deeper. (default 'shiftwidth'). |
417 | |
418 cino= cino=u2 > | |
419 if (c123456789 if (c123456789 | |
420 && (c22345 && (c22345 | |
421 || c3)) || c3)) | |
422 < | |
2857 | 423 *cino-U* |
7 | 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). | |
427 | |
428 cino= or cino=(s cino=(s,U1 > | |
429 c = c1 && c = c1 && | |
430 ( ( | |
431 c2 || c2 || | |
432 c3 c3 | |
433 ) && c4; ) && c4; | |
434 < | |
2857 | 435 *cino-2* |
7 | 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). | |
441 | |
442 cino=(0 cino=(0,w1 > | |
443 if ( c1 if ( c1 | |
444 && ( c2 && ( c2 | |
445 || c3)) || c3)) | |
446 foo; foo; | |
447 < | |
2857 | 448 *cino-W* |
7 | 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 | |
236 | 454 next unclosed parentheses). (default: 0). |
7 | 455 |
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 < | |
2857 | 463 *cino-m* |
7 | 464 mN When N is non-zero, line up a line starting with a closing |
465 parentheses with the first character of the line with the | |
466 matching opening parentheses. (default 0). | |
467 | |
468 cino=(s cino=(s,m1 > | |
469 c = c1 && ( c = c1 && ( | |
470 c2 || c2 || | |
471 c3 c3 | |
472 ) && c4; ) && c4; | |
473 if ( if ( | |
474 c1 && c2 c1 && c2 | |
475 ) ) | |
476 foo; foo; | |
477 < | |
2857 | 478 *cino-M* |
829 | 479 MN When N is non-zero, line up a line starting with a closing |
480 parentheses with the first character of the previous line. | |
481 (default 0). | |
482 | |
483 cino= cino=M1 > | |
484 if (cond1 && if (cond1 && | |
856 | 485 cond2 cond2 |
486 ) ) | |
829 | 487 < |
2857 | 488 *java-cinoptions* *java-indenting* *cino-j* |
2965 | 489 jN Indent Java anonymous classes correctly. Also works well for |
490 Javascript. The value 'N' is currently unused but must be | |
491 non-zero (e.g. 'j1'). 'j1' will indent for example the | |
492 following code snippet correctly: > | |
7 | 493 |
494 object.add(new ChangeListener() { | |
495 public void stateChanged(ChangeEvent e) { | |
496 do_something(); | |
497 } | |
498 }); | |
499 < | |
2857 | 500 *javascript-cinoptions* *javascript-indenting* *cino-J* |
2297
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
501 JN Indent JavaScript object declarations correctly by not confusing |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
502 them with labels. The value 'N' is currently unused but must be |
2965 | 503 non-zero (e.g. 'J1'). If you enable this you probably also want |
504 to set |cino-j|. > | |
2297
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
505 |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
506 var bar = { |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
507 foo: { |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
508 that: this, |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
509 some: ok, |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
510 }, |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
511 "bar":{ |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
512 a : 2, |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
513 b: "123abc", |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
514 x: 4, |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
515 "y": 5 |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
516 } |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
517 } |
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
518 < |
2857 | 519 *cino-)* |
7 | 520 )N Vim searches for unclosed parentheses at most N lines away. |
521 This limits the time needed to search for parentheses. (default | |
522 20 lines). | |
523 | |
2857 | 524 *cino-star* |
7 | 525 *N Vim searches for unclosed comments at most N lines away. This |
526 limits the time needed to search for the start of a comment. | |
2788 | 527 If your /* */ comments stop indenting afer N lines this is the |
528 value you will want to change. | |
2072 | 529 (default 70 lines). |
7 | 530 |
2857 | 531 *cino-#* |
1096 | 532 #N When N is non-zero recognize shell/Perl comments, starting with |
533 '#'. Default N is zero: don't recognizes '#' comments. Note | |
534 that lines starting with # will still be seen as preprocessor | |
535 lines. | |
536 | |
7 | 537 |
538 The defaults, spelled out in full, are: | |
2857 | 539 cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,ps,ts,is,+s, |
2328
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
540 c3,C0,/0,(2s,us,U0,w0,W0,m0,j0,J0,)20,*70,#0 |
7 | 541 |
542 Vim puts a line in column 1 if: | |
543 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'. | |
544 - It starts with a label (a keyword followed by ':', other than "case" and | |
2328
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
545 "default") and 'cinoptions' does not contain an 'L' entry with a positive |
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
546 value. |
7 | 547 - Any combination of indentations causes the line to have less than 0 |
548 indentation. | |
549 | |
550 ============================================================================== | |
551 2. Indenting by expression *indent-expression* | |
552 | |
553 The basics for using flexible indenting are explained in section |30.3| of the | |
554 user manual. | |
555 | |
556 If you want to write your own indent file, it must set the 'indentexpr' | |
557 option. Setting the 'indentkeys' option is often useful. See the | |
558 $VIMRUNTIME/indent directory for examples. | |
559 | |
560 | |
561 REMARKS ABOUT SPECIFIC INDENT FILES ~ | |
562 | |
563 | |
501 | 564 FORTRAN *ft-fortran-indent* |
7 | 565 |
2908 | 566 Block if, select case, where, and forall constructs are indented. So are |
567 type, interface, associate, block, and enum constructs. The indenting of | |
568 subroutines, functions, modules, and program blocks is optional. Comments, | |
569 labelled statements and continuation lines are indented if the Fortran is in | |
570 free source form, whereas they are not indented if the Fortran is in fixed | |
571 source form because of the left margin requirements. Hence manual indent | |
572 corrections will be necessary for labelled statements and continuation lines | |
573 when fixed source form is being used. For further discussion of the method | |
574 used for the detection of source format see |ft-fortran-syntax|. | |
7 | 575 |
576 Do loops ~ | |
236 | 577 All do loops are left unindented by default. Do loops can be unstructured in |
7 | 578 Fortran with (possibly multiple) loops ending on a labelled executable |
236 | 579 statement of almost arbitrary type. Correct indentation requires |
580 compiler-quality parsing. Old code with do loops ending on labelled statements | |
7 | 581 of arbitrary type can be indented with elaborate programs such as Tidy |
236 | 582 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are |
7 | 583 also left unindented because continue statements are also used for purposes |
236 | 584 other than ending a do loop. Programs such as Tidy can convert structured |
585 do/continue loops to the do/enddo form. Do loops of the do/enddo variety can | |
586 be indented. If you use only structured loops of the do/enddo form, you should | |
7 | 587 declare this by setting the fortran_do_enddo variable in your .vimrc as |
588 follows > | |
589 | |
590 let fortran_do_enddo=1 | |
591 | |
236 | 592 in which case do loops will be indented. If all your loops are of do/enddo |
7 | 593 type only in, say, .f90 files, then you should set a buffer flag with an |
594 autocommand such as > | |
595 | |
596 au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1 | |
597 | |
598 to get do loops indented in .f90 files and left alone in Fortran files with | |
599 other extensions such as .for. | |
600 | |
2908 | 601 Program units ~ |
602 The indenting of program units (subroutines, functions, modules, and program | |
603 blocks) is enabled by default but can be suppressed if a lighter, screen-width | |
604 preserving indent style is desired. To suppress the indenting of program | |
605 units for all fortran files set the global fortran_indent_less variable in | |
606 your .vimrc as follows > | |
607 | |
608 let fortran_indent_less=1 | |
609 | |
610 A finer level of suppression can be achieved by setting the corresponding | |
611 buffer-local variable as follows > | |
612 | |
613 let b:fortran_indent_less=1 | |
614 | |
7 | 615 |
1668 | 616 PHP *ft-php-indent* *php-indent* *php-indenting* |
617 | |
618 NOTE: PHP files will be indented correctly only if PHP |syntax| is active. | |
619 | |
620 If you are editing a file in Unix 'fileformat' and '\r' characters are present | |
621 before new lines, indentation won't proceed correctly ; you have to remove | |
622 those useless characters first with a command like: > | |
623 | |
624 :%s /\r$//g | |
625 | |
626 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the | |
627 script will silently remove them when Vim loads a PHP file (at each|BufRead|). | |
628 | |
629 OPTIONS: ~ | |
630 | |
631 PHP indenting can be altered in several ways by modifying the values of some | |
632 variables: | |
633 | |
634 *php-comment* | |
635 To not enable auto-formating of comments by default (if you want to use your | |
636 own 'formatoptions'): > | |
637 :let g:PHP_autoformatcomment = 0 | |
638 | |
639 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be | |
640 added, see|fo-table|for more information. | |
641 ------------- | |
642 | |
643 To add an extra indent to every PHP lines with N being the number of | |
644 'shiftwidth' to add: > | |
645 :let g:PHP_default_indenting = N | |
646 | |
647 For example, with N = 1, this will give: | |
648 > | |
649 <?php | |
650 if (!isset($History_lst_sel)) | |
651 if (!isset($History_lst_sel)) | |
652 if (!isset($History_lst_sel)) { | |
653 $History_lst_sel=0; | |
654 } else | |
655 $foo="bar"; | |
656 | |
657 $command_hist = TRUE; | |
658 ?> | |
659 (Notice the extra indent between the PHP container markers and the code) | |
660 ------------- | |
661 | |
2442 | 662 To indent PHP tags as the surrounding code: > |
663 :let g:PHP_outdentphpescape = 0 | |
664 ------------- | |
665 | |
1668 | 666 To automatically remove '\r' characters when the 'fileformat' is set to Unix: > |
667 :let g:PHP_removeCRwhenUnix = 1 | |
668 ------------- | |
669 | |
670 To indent braces at the same level than the code they contain: > | |
671 :let g:PHP_BracesAtCodeLevel = 1 | |
672 | |
673 This will give the following result: > | |
674 if ($foo) | |
675 { | |
676 foo(); | |
677 } | |
678 Instead of: > | |
679 if ($foo) | |
680 { | |
681 foo(); | |
682 } | |
683 | |
684 NOTE: Indenting will be a bit slower if this option is used because some | |
685 optimizations won't be available. | |
686 ------------- | |
687 | |
688 To indent 'case:' and 'default:' statements in switch() blocks: > | |
689 :let g:PHP_vintage_case_default_indent = 1 | |
690 | |
2442 | 691 (Since in PHP braces are not required inside 'case/default' blocks, by default they are indented at the same level than the 'switch()' to avoid |
1668 | 692 unnecessary indentation) |
693 | |
694 | |
501 | 695 PYTHON *ft-python-indent* |
170 | 696 |
697 The amount of indent can be set for the following situations. The examples | |
1698 | 698 given are the defaults. Note that the variables are set to an expression, so |
699 that you can change the value of 'shiftwidth' later. | |
170 | 700 |
701 Indent after an open paren: > | |
702 let g:pyindent_open_paren = '&sw * 2' | |
703 Indent after a nested paren: > | |
704 let g:pyindent_nested_paren = '&sw' | |
705 Indent for a continuation line: > | |
706 let g:pyindent_continue = '&sw * 2' | |
707 | |
708 | |
1201 | 709 SHELL *ft-sh-indent* |
710 | |
711 The amount of indent applied under various circumstances in a shell file can | |
712 be configured by setting the following keys in the |Dictionary| | |
713 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a | |
714 function that will return the amount desired: | |
715 | |
716 b:sh_indent_options['default'] Default amount of indent. | |
717 | |
718 b:sh_indent_options['continuation-line'] | |
719 Amount of indent to add to a continued line. | |
720 | |
721 b:sh_indent_options['case-labels'] | |
722 Amount of indent to add for case labels. | |
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
723 (not actually implemented) |
1201 | 724 |
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
725 b:sh_indent_options['case-statements'] |
1201 | 726 Amount of indent to add for case statements. |
727 | |
728 b:sh_indent_options['case-breaks'] | |
729 Amount of indent to add (or more likely | |
730 remove) for case breaks. | |
731 | |
501 | 732 VERILOG *ft-verilog-indent* |
7 | 733 |
734 General block statements such as if, for, case, always, initial, function, | |
735 specify and begin, etc., are indented. The module block statements (first | |
736 level blocks) are not indented by default. you can turn on the indent with | |
737 setting a variable in the .vimrc as follows: > | |
738 | |
739 let b:verilog_indent_modules = 1 | |
740 | |
741 then the module blocks will be indented. To stop this, remove the variable: > | |
742 | |
743 :unlet b:verilog_indent_modules | |
744 | |
745 To set the variable only for Verilog file. The following statements can be | |
746 used: > | |
747 | |
748 au BufReadPost * if exists("b:current_syntax") | |
749 au BufReadPost * if b:current_syntax == "verilog" | |
750 au BufReadPost * let b:verilog_indent_modules = 1 | |
751 au BufReadPost * endif | |
752 au BufReadPost * endif | |
753 | |
754 Furthermore, setting the variable b:verilog_indent_width to change the | |
755 indenting width (default is 'shiftwidth'): > | |
756 | |
757 let b:verilog_indent_width = 4 | |
758 let b:verilog_indent_width = &sw * 2 | |
759 | |
760 In addition, you can turn the verbose mode for debug issue: > | |
761 | |
762 let b:verilog_indent_verbose = 1 | |
763 | |
764 Make sure to do ":set cmdheight=2" first to allow the display of the message. | |
765 | |
22 | 766 |
1620 | 767 VHDL *ft-vhdl-indent* |
768 | |
769 Alignment of generic/port mapping statements are performed by default. This | |
770 causes the following alignment example: > | |
771 | |
772 ENTITY sync IS | |
773 PORT ( | |
774 clk : IN STD_LOGIC; | |
775 reset_n : IN STD_LOGIC; | |
776 data_input : IN STD_LOGIC; | |
777 data_out : OUT STD_LOGIC | |
778 ); | |
779 END ENTITY sync; | |
780 | |
781 To turn this off, add > | |
782 | |
783 let g:vhdl_indent_genportmap = 0 | |
784 | |
785 to the .vimrc file, which causes the previous alignment example to change: > | |
786 | |
787 ENTITY sync IS | |
788 PORT ( | |
789 clk : IN STD_LOGIC; | |
790 reset_n : IN STD_LOGIC; | |
791 data_input : IN STD_LOGIC; | |
792 data_out : OUT STD_LOGIC | |
793 ); | |
794 END ENTITY sync; | |
795 | |
796 ---------------------------------------- | |
797 | |
798 Alignment of right-hand side assignment "<=" statements are performed by | |
799 default. This causes the following alignment example: > | |
800 | |
801 sig_out <= (bus_a(1) AND | |
802 (sig_b OR sig_c)) OR | |
803 (bus_a(0) AND sig_d); | |
804 | |
805 To turn this off, add > | |
806 | |
807 let g:vhdl_indent_rhsassign = 0 | |
808 | |
809 to the .vimrc file, which causes the previous alignment example to change: > | |
810 | |
811 sig_out <= (bus_a(1) AND | |
812 (sig_b OR sig_c)) OR | |
813 (bus_a(0) AND sig_d); | |
814 | |
815 ---------------------------------------- | |
816 | |
817 Full-line comments (lines that begin with "--") are indented to be aligned with | |
818 the very previous line's comment, PROVIDED that a whitespace follows after | |
819 "--". | |
820 | |
821 For example: > | |
822 | |
823 sig_a <= sig_b; -- start of a comment | |
824 -- continuation of the comment | |
825 -- more of the same comment | |
826 | |
827 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F | |
828 will align the current "-- " with the previous line's "--". | |
829 | |
830 If the very previous line does not contain "--", THEN the full-line comment | |
831 will be aligned with the start of the next non-blank line that is NOT a | |
832 full-line comment. | |
833 | |
834 Indenting the following code: > | |
835 | |
836 sig_c <= sig_d; -- comment 0 | |
837 -- comment 1 | |
838 -- comment 2 | |
839 --debug_code: | |
840 --PROCESS(debug_in) | |
841 --BEGIN | |
842 -- FOR i IN 15 DOWNTO 0 LOOP | |
843 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
844 -- END LOOP; | |
845 --END PROCESS debug_code; | |
846 | |
847 -- comment 3 | |
848 sig_e <= sig_f; -- comment 4 | |
849 -- comment 5 | |
850 | |
851 results in: > | |
852 | |
853 sig_c <= sig_d; -- comment 0 | |
854 -- comment 1 | |
855 -- comment 2 | |
856 --debug_code: | |
857 --PROCESS(debug_in) | |
858 --BEGIN | |
859 -- FOR i IN 15 DOWNTO 0 LOOP | |
860 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
861 -- END LOOP; | |
862 --END PROCESS debug_code; | |
863 | |
864 -- comment 3 | |
865 sig_e <= sig_f; -- comment 4 | |
866 -- comment 5 | |
867 | |
868 Notice that "--debug_code:" does not align with "-- comment 2" | |
869 because there is no whitespace that follows after "--" in "--debug_code:". | |
870 | |
871 Given the dynamic nature of indenting comments, indenting should be done TWICE. | |
872 On the first pass, code will be indented. On the second pass, full-line | |
873 comments will be indented according to the correctly indented code. | |
874 | |
875 | |
501 | 876 VIM *ft-vim-indent* |
22 | 877 |
878 For indenting Vim scripts there is one variable that specifies the amount of | |
879 indent for a continuation line, a line that starts with a backslash: > | |
880 | |
881 :let g:vim_indent_cont = &sw * 3 | |
882 | |
883 Three times shiftwidth is the default value. | |
884 | |
885 | |
7 | 886 vim:tw=78:ts=8:ft=help:norl: |