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