| blob | 4d00da257311c82696476b12c824f9ab1af03396 |
1 *indent.txt* For Vim version 7.2. Last change: 2008 Jul 30
4 VIM REFERENCE MANUAL by Bram Moolenaar
7 This file is about indenting C programs and other files.
9 1. Indenting C style programs |C-indenting|
10 2. Indenting by expression |indent-expression|
12 ==============================================================================
13 1. Indenting C style programs *C-indenting*
15 The basics for C style indenting are explained in section |30.2| of the user
16 manual.
18 Vim has options for automatically indenting C style program files. Many
19 programming languages including Java and C++ follow very closely the
20 formatting conventions established with C. These options affect only the
21 indent and do not perform other formatting. There are additional options that
22 affect other kinds of formatting as well as indenting, see |format-comments|,
23 |fo-table|, |gq| and |formatting| for the main ones.
25 Note that this will not work when the |+smartindent| or |+cindent| features
26 have been disabled at compile time.
28 There are in fact four main methods available for indentation, each one
29 overrides the previous if it is enabled, or non-empty for 'indentexpr':
30 'autoindent' uses the indent from the previous line.
31 'smartindent' is like 'autoindent' but also recognizes some C syntax to
32 increase/reduce the indent where appropriate.
33 'cindent' Works more cleverly than the other two and is configurable to
34 different indenting styles.
35 'indentexpr' The most flexible of all: Evaluates an expression to compute
36 the indent of a line. When non-empty this method overrides
37 the other ones. See |indent-expression|.
38 The rest of this section describes the 'cindent' option.
40 Note that 'cindent' indenting does not work for every code scenario. Vim
41 is not a C compiler: it does not recognize all syntax. One requirement is
42 that toplevel functions have a '{' in the first column. Otherwise they are
43 easily confused with declarations.
45 These four options control C program indenting:
46 'cindent' Enables Vim to perform C program indenting automatically.
47 'cinkeys' Specifies which keys trigger reindenting in insert mode.
48 'cinoptions' Sets your preferred indent style.
49 'cinwords' Defines keywords that start an extra indent in the next line.
51 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using
52 Vim's built-in algorithm rather than calling an external program.
54 See |autocommand| for how to set the 'cindent' option automatically for C code
55 files and reset it for others.
57 *cinkeys-format* *indentkeys-format*
58 The 'cinkeys' option is a string that controls Vim's indenting in response to
59 typing certain characters or commands in certain contexts. Note that this not
60 only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is
61 used instead. The format of 'cinkeys' and 'indentkeys' is equal.
63 The default is "0{,0},0),:,0#,!^F,o,O,e" which specifies that indenting occurs
64 as follows:
66 "0{" if you type '{' as the first character in a line
67 "0}" if you type '}' as the first character in a line
68 "0)" if you type ')' as the first character in a line
69 ":" if you type ':' after a label or case statement
70 "0#" if you type '#' as the first character in a line
71 "!^F" if you type CTRL-F (which is not inserted)
72 "o" if you type a <CR> anywhere or use the "o" command (not in
73 insert mode!)
74 "O" if you use the "O" command (not in insert mode!)
75 "e" if you type the second 'e' for an "else" at the start of a
76 line
78 Characters that can precede each key: *i_CTRL-F*
79 ! When a '!' precedes the key, Vim will not insert the key but will
80 instead reindent the current line. This allows you to define a
81 command key for reindenting the current line. CTRL-F is the default
82 key for this. Be careful if you define CTRL-I for this because CTRL-I
83 is the ASCII code for <Tab>.
84 * When a '*' precedes the key, Vim will reindent the line before
85 inserting the key. If 'cinkeys' contains "*<Return>", Vim reindents
86 the current line before opening a new line.
87 0 When a zero precedes the key (but appears after '!' or '*') Vim will
88 reindent the line only if the key is the first character you type in
89 the line. When used before "=" Vim will only reindent the line if
90 there is only white space before the word.
92 When neither '!' nor '*' precedes the key, Vim reindents the line after you
93 type the key. So ';' sets the indentation of a line which includes the ';'.
95 Special key names:
96 <> Angle brackets mean spelled-out names of keys. For example: "<Up>",
97 "<Ins>" (see |key-notation|).
98 ^ Letters preceded by a caret (^) are control characters. For example:
99 "^F" is CTRL-F.
100 o Reindent a line when you use the "o" command or when Vim opens a new
101 line below the current one (e.g., when you type <Enter> in insert
102 mode).
103 O Reindent a line when you use the "O" command.
104 e Reindent a line that starts with "else" when you type the second 'e'.
105 : Reindent a line when a ':' is typed which is after a label or case
106 statement. Don't reindent for a ":" in "class::method" for C++. To
107 Reindent for any ":", use "<:>".
108 =word Reindent when typing the last character of "word". "word" may
109 actually be part of another word. Thus "=end" would cause reindenting
110 when typing the "d" in "endif" or "endwhile". But not when typing
111 "bend". Also reindent when completion produces a word that starts
112 with "word". "0=word" reindents when there is only white space before
113 the word.
114 =~word Like =word, but ignore case.
116 If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>',
117 '*', ':' or '!', use "<o>", "<O>", "<e>", "<0>", "<<>", "<>>", "<*>", "<:>" or
118 "<!>", respectively, for those keys.
120 For an emacs-style indent mode where lines aren't indented every time you
121 press <Enter> but only if you press <Tab>, I suggest:
122 :set cinkeys=0{,0},:,0#,!<Tab>,!^F
123 You might also want to switch off 'autoindent' then.
125 Note: If you change the current line's indentation manually, Vim ignores the
126 cindent settings for that line. This prevents vim from reindenting after you
127 have changed the indent by typing <BS>, <Tab>, or <Space> in the indent or
128 used CTRL-T or CTRL-D.
130 *cinoptions-values*
131 The 'cinoptions' option sets how Vim performs indentation. 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.
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').
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).
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).
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).
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).
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).
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).
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 <
219 :N Place case labels N characters from the indent of the switch().
220 (default 'shiftwidth').
222 cino= cino=:0 >
223 switch (x) switch(x)
224 { {
225 case 1: case 1:
226 a = b; a = b;
227 default: default:
228 } }
229 <
230 =N Place statements occurring after a case label N characters from
231 the indent of the label. (default 'shiftwidth').
233 cino= cino==10 >
234 case 11: case 11: a = a + 1;
235 a = a + 1; b = b + 1;
236 <
237 lN If N != 0 Vim will align with a case label instead of the
238 statement after it in the same line.
240 cino= cino=l1 >
241 switch (a) { switch (a) {
242 case 1: { case 1: {
243 break; break;
244 } }
245 <
246 bN If N != 0 Vim will align a final "break" with the case label,
247 so that case..break looks like a sort of block. (default: 0).
249 cino= cino=b1 >
250 switch (x) switch(x)
251 { {
252 case 1: case 1:
253 a = b; a = b;
254 break; break;
256 default: default:
257 a = 0; a = 0;
258 break; break;
259 } }
260 <
261 gN Place C++ scope declarations N characters from the indent of the
262 block they are in. (default 'shiftwidth'). A scope declaration
263 can be "public:", "protected:" or "private:".
265 cino= cino=g0 >
266 { {
267 public: public:
268 a = b; a = b;
269 private: private:
270 } }
271 <
272 hN Place statements occurring after a C++ scope declaration N
273 characters from the indent of the label. (default
274 'shiftwidth').
276 cino= cino=h10 >
277 public: public: a = a + 1;
278 a = a + 1; b = b + 1;
279 <
280 pN Parameter declarations for K&R-style function declarations will
281 be indented N characters from the margin. (default
282 'shiftwidth').
284 cino= cino=p0 cino=p2s >
285 func(a, b) func(a, b) func(a, b)
286 int a; int a; int a;
287 char b; char b; char b;
288 <
289 tN Indent a function return type declaration N characters from the
290 margin. (default 'shiftwidth').
292 cino= cino=t0 cino=t7 >
293 int int int
294 func() func() func()
295 <
296 iN Indent C++ base class declarations and constructor
297 initializations, if they start in a new line (otherwise they
298 are aligned at the right side of the ':').
299 (default 'shiftwidth').
301 cino= cino=i0 >
302 class MyClass : class MyClass :
303 public BaseClass public BaseClass
304 {} {}
305 MyClass::MyClass() : MyClass::MyClass() :
306 BaseClass(3) BaseClass(3)
307 {} {}
308 <
309 +N Indent a continuation line (a line that spills onto the next) N
310 additional characters. (default 'shiftwidth').
312 cino= cino=+10 >
313 a = b + 9 * a = b + 9 *
314 c; c;
315 <
316 cN Indent comment lines after the comment opener, when there is no
317 other text with which to align, N characters from the comment
318 opener. (default 3). See also |format-comments|.
320 cino= cino=c5 >
321 /* /*
322 text. text.
323 */ */
324 <
325 CN When N is non-zero, indent comment lines by the amount specified
326 with the c flag above even if there is other text behind the
327 comment opener. (default 0).
329 cino=c0 cino=c0,C1 >
330 /******** /********
331 text. text.
332 ********/ ********/
333 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*")
335 /N Indent comment lines N characters extra. (default 0).
336 cino= cino=/4 >
337 a = b; a = b;
338 /* comment */ /* comment */
339 c = d; c = d;
340 <
341 (N When in unclosed parentheses, indent N characters from the line
342 with the unclosed parentheses. Add a 'shiftwidth' for every
343 unclosed parentheses. When N is 0 or the unclosed parentheses
344 is the first non-white character in its line, line up with the
345 next non-white character after the unclosed parentheses.
346 (default 'shiftwidth' * 2).
348 cino= cino=(0 >
349 if (c1 && (c2 || if (c1 && (c2 ||
350 c3)) c3))
351 foo; foo;
352 if (c1 && if (c1 &&
353 (c2 || c3)) (c2 || c3))
354 { {
355 <
356 uN Same as (N, but for one level deeper. (default 'shiftwidth').
358 cino= cino=u2 >
359 if (c123456789 if (c123456789
360 && (c22345 && (c22345
361 || c3)) || c3))
362 <
363 UN When N is non-zero, do not ignore the indenting specified by
364 ( or u in case that the unclosed parentheses is the first
365 non-white character in its line. (default 0).
367 cino= or cino=(s cino=(s,U1 >
368 c = c1 && c = c1 &&
369 ( (
370 c2 || c2 ||
371 c3 c3
372 ) && c4; ) && c4;
373 <
374 wN When in unclosed parentheses and N is non-zero and either
375 using "(0" or "u0", respectively, or using "U0" and the unclosed
376 parentheses is the first non-white character in its line, line
377 up with the character immediately after the unclosed parentheses
378 rather than the first non-white character. (default 0).
380 cino=(0 cino=(0,w1 >
381 if ( c1 if ( c1
382 && ( c2 && ( c2
383 || c3)) || c3))
384 foo; foo;
385 <
386 WN When in unclosed parentheses and N is non-zero and either
387 using "(0" or "u0", respectively and the unclosed parentheses is
388 the last non-white character in its line and it is not the
389 closing parentheses, indent the following line N characters
390 relative to the outer context (i.e. start of the line or the
391 next unclosed parentheses). (default: 0).
393 cino=(0 cino=(0,W4 >
394 a_long_line( a_long_line(
395 argument, argument,
396 argument); argument);
397 a_short_line(argument, a_short_line(argument,
398 argument); argument);
399 <
400 mN When N is non-zero, line up a line starting with a closing
401 parentheses with the first character of the line with the
402 matching opening parentheses. (default 0).
404 cino=(s cino=(s,m1 >
405 c = c1 && ( c = c1 && (
406 c2 || c2 ||
407 c3 c3
408 ) && c4; ) && c4;
409 if ( if (
410 c1 && c2 c1 && c2
411 ) )
412 foo; foo;
413 <
414 MN When N is non-zero, line up a line starting with a closing
415 parentheses with the first character of the previous line.
416 (default 0).
418 cino= cino=M1 >
419 if (cond1 && if (cond1 &&
420 cond2 cond2
421 ) )
422 <
423 *java-cinoptions* *java-indenting*
424 jN Indent java anonymous classes correctly. The value 'N' is
425 currently unused but must be non-zero (e.g. 'j1'). 'j1' will
426 indent for example the following code snippet correctly: >
428 object.add(new ChangeListener() {
429 public void stateChanged(ChangeEvent e) {
430 do_something();
431 }
432 });
433 <
434 )N Vim searches for unclosed parentheses at most N lines away.
435 This limits the time needed to search for parentheses. (default
436 20 lines).
438 *N Vim searches for unclosed comments at most N lines away. This
439 limits the time needed to search for the start of a comment.
440 (default 30 lines).
442 #N When N is non-zero recognize shell/Perl comments, starting with
443 '#'. Default N is zero: don't recognizes '#' comments. Note
444 that lines starting with # will still be seen as preprocessor
445 lines.
448 The defaults, spelled out in full, are:
449 cinoptions=>s,e0,n0,f0,{0,}0,^0,:s,=s,l0,b0,gs,hs,ps,ts,is,+s,c3,C0,
450 /0,(2s,us,U0,w0,W0,m0,j0,)20,*30,#0
452 Vim puts a line in column 1 if:
453 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'.
454 - It starts with a label (a keyword followed by ':', other than "case" and
455 "default").
456 - Any combination of indentations causes the line to have less than 0
457 indentation.
459 ==============================================================================
460 2. Indenting by expression *indent-expression*
462 The basics for using flexible indenting are explained in section |30.3| of the
463 user manual.
465 If you want to write your own indent file, it must set the 'indentexpr'
466 option. Setting the 'indentkeys' option is often useful. See the
467 $VIMRUNTIME/indent directory for examples.
470 REMARKS ABOUT SPECIFIC INDENT FILES ~
473 FORTRAN *ft-fortran-indent*
475 Block if, select case, and where constructs are indented. Comments, labelled
476 statements and continuation lines are indented if the Fortran is in free
477 source form, whereas they are not indented if the Fortran is in fixed source
478 form because of the left margin requirements. Hence manual indent corrections
479 will be necessary for labelled statements and continuation lines when fixed
480 source form is being used. For further discussion of the method used for the
481 detection of source format see |ft-fortran-syntax|.
483 Do loops ~
484 All do loops are left unindented by default. Do loops can be unstructured in
485 Fortran with (possibly multiple) loops ending on a labelled executable
486 statement of almost arbitrary type. Correct indentation requires
487 compiler-quality parsing. Old code with do loops ending on labelled statements
488 of arbitrary type can be indented with elaborate programs such as Tidy
489 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are
490 also left unindented because continue statements are also used for purposes
491 other than ending a do loop. Programs such as Tidy can convert structured
492 do/continue loops to the do/enddo form. Do loops of the do/enddo variety can
493 be indented. If you use only structured loops of the do/enddo form, you should
494 declare this by setting the fortran_do_enddo variable in your .vimrc as
495 follows >
497 let fortran_do_enddo=1
499 in which case do loops will be indented. If all your loops are of do/enddo
500 type only in, say, .f90 files, then you should set a buffer flag with an
501 autocommand such as >
503 au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1
505 to get do loops indented in .f90 files and left alone in Fortran files with
506 other extensions such as .for.
509 PHP *ft-php-indent* *php-indent* *php-indenting*
511 NOTE: PHP files will be indented correctly only if PHP |syntax| is active.
513 If you are editing a file in Unix 'fileformat' and '\r' characters are present
514 before new lines, indentation won't proceed correctly ; you have to remove
515 those useless characters first with a command like: >
517 :%s /\r$//g
519 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the
520 script will silently remove them when Vim loads a PHP file (at each|BufRead|).
522 OPTIONS: ~
524 PHP indenting can be altered in several ways by modifying the values of some
525 variables:
527 *php-comment*
528 To not enable auto-formating of comments by default (if you want to use your
529 own 'formatoptions'): >
530 :let g:PHP_autoformatcomment = 0
532 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be
533 added, see|fo-table|for more information.
534 -------------
536 To add an extra indent to every PHP lines with N being the number of
537 'shiftwidth' to add: >
538 :let g:PHP_default_indenting = N
540 For example, with N = 1, this will give:
541 >
542 <?php
543 if (!isset($History_lst_sel))
544 if (!isset($History_lst_sel))
545 if (!isset($History_lst_sel)) {
546 $History_lst_sel=0;
547 } else
548 $foo="bar";
550 $command_hist = TRUE;
551 ?>
552 (Notice the extra indent between the PHP container markers and the code)
553 -------------
555 To automatically remove '\r' characters when the 'fileformat' is set to Unix: >
556 :let g:PHP_removeCRwhenUnix = 1
557 -------------
559 To indent braces at the same level than the code they contain: >
560 :let g:PHP_BracesAtCodeLevel = 1
562 This will give the following result: >
563 if ($foo)
564 {
565 foo();
566 }
567 Instead of: >
568 if ($foo)
569 {
570 foo();
571 }
573 NOTE: Indenting will be a bit slower if this option is used because some
574 optimizations won't be available.
575 -------------
577 To indent 'case:' and 'default:' statements in switch() blocks: >
578 :let g:PHP_vintage_case_default_indent = 1
580 (By default they are indented at the same level than the 'switch()' to avoid
581 unnecessary indentation)
584 PYTHON *ft-python-indent*
586 The amount of indent can be set for the following situations. The examples
587 given are the defaults. Note that the variables are set to an expression, so
588 that you can change the value of 'shiftwidth' later.
590 Indent after an open paren: >
591 let g:pyindent_open_paren = '&sw * 2'
592 Indent after a nested paren: >
593 let g:pyindent_nested_paren = '&sw'
594 Indent for a continuation line: >
595 let g:pyindent_continue = '&sw * 2'
598 SHELL *ft-sh-indent*
600 The amount of indent applied under various circumstances in a shell file can
601 be configured by setting the following keys in the |Dictionary|
602 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a
603 function that will return the amount desired:
605 b:sh_indent_options['default'] Default amount of indent.
607 b:sh_indent_options['continuation-line']
608 Amount of indent to add to a continued line.
610 b:sh_indent_options['case-labels']
611 Amount of indent to add for case labels.
613 b:sh_indent_options['case-statement']
614 Amount of indent to add for case statements.
616 b:sh_indent_options['case-breaks']
617 Amount of indent to add (or more likely
618 remove) for case breaks.
620 VERILOG *ft-verilog-indent*
622 General block statements such as if, for, case, always, initial, function,
623 specify and begin, etc., are indented. The module block statements (first
624 level blocks) are not indented by default. you can turn on the indent with
625 setting a variable in the .vimrc as follows: >
627 let b:verilog_indent_modules = 1
629 then the module blocks will be indented. To stop this, remove the variable: >
631 :unlet b:verilog_indent_modules
633 To set the variable only for Verilog file. The following statements can be
634 used: >
636 au BufReadPost * if exists("b:current_syntax")
637 au BufReadPost * if b:current_syntax == "verilog"
638 au BufReadPost * let b:verilog_indent_modules = 1
639 au BufReadPost * endif
640 au BufReadPost * endif
642 Furthermore, setting the variable b:verilog_indent_width to change the
643 indenting width (default is 'shiftwidth'): >
645 let b:verilog_indent_width = 4
646 let b:verilog_indent_width = &sw * 2
648 In addition, you can turn the verbose mode for debug issue: >
650 let b:verilog_indent_verbose = 1
652 Make sure to do ":set cmdheight=2" first to allow the display of the message.
655 VHDL *ft-vhdl-indent*
657 Alignment of generic/port mapping statements are performed by default. This
658 causes the following alignment example: >
660 ENTITY sync IS
661 PORT (
662 clk : IN STD_LOGIC;
663 reset_n : IN STD_LOGIC;
664 data_input : IN STD_LOGIC;
665 data_out : OUT STD_LOGIC
666 );
667 END ENTITY sync;
669 To turn this off, add >
671 let g:vhdl_indent_genportmap = 0
673 to the .vimrc file, which causes the previous alignment example to change: >
675 ENTITY sync IS
676 PORT (
677 clk : IN STD_LOGIC;
678 reset_n : IN STD_LOGIC;
679 data_input : IN STD_LOGIC;
680 data_out : OUT STD_LOGIC
681 );
682 END ENTITY sync;
684 ----------------------------------------
686 Alignment of right-hand side assignment "<=" statements are performed by
687 default. This causes the following alignment example: >
689 sig_out <= (bus_a(1) AND
690 (sig_b OR sig_c)) OR
691 (bus_a(0) AND sig_d);
693 To turn this off, add >
695 let g:vhdl_indent_rhsassign = 0
697 to the .vimrc file, which causes the previous alignment example to change: >
699 sig_out <= (bus_a(1) AND
700 (sig_b OR sig_c)) OR
701 (bus_a(0) AND sig_d);
703 ----------------------------------------
705 Full-line comments (lines that begin with "--") are indented to be aligned with
706 the very previous line's comment, PROVIDED that a whitespace follows after
707 "--".
709 For example: >
711 sig_a <= sig_b; -- start of a comment
712 -- continuation of the comment
713 -- more of the same comment
715 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F
716 will align the current "-- " with the previous line's "--".
718 If the very previous line does not contain "--", THEN the full-line comment
719 will be aligned with the start of the next non-blank line that is NOT a
720 full-line comment.
722 Indenting the following code: >
724 sig_c <= sig_d; -- comment 0
725 -- comment 1
726 -- comment 2
727 --debug_code:
728 --PROCESS(debug_in)
729 --BEGIN
730 -- FOR i IN 15 DOWNTO 0 LOOP
731 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
732 -- END LOOP;
733 --END PROCESS debug_code;
735 -- comment 3
736 sig_e <= sig_f; -- comment 4
737 -- comment 5
739 results in: >
741 sig_c <= sig_d; -- comment 0
742 -- comment 1
743 -- comment 2
744 --debug_code:
745 --PROCESS(debug_in)
746 --BEGIN
747 -- FOR i IN 15 DOWNTO 0 LOOP
748 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
749 -- END LOOP;
750 --END PROCESS debug_code;
752 -- comment 3
753 sig_e <= sig_f; -- comment 4
754 -- comment 5
756 Notice that "--debug_code:" does not align with "-- comment 2"
757 because there is no whitespace that follows after "--" in "--debug_code:".
759 Given the dynamic nature of indenting comments, indenting should be done TWICE.
760 On the first pass, code will be indented. On the second pass, full-line
761 comments will be indented according to the correctly indented code.
764 VIM *ft-vim-indent*
766 For indenting Vim scripts there is one variable that specifies the amount of
767 indent for a continuation line, a line that starts with a backslash: >
769 :let g:vim_indent_cont = &sw * 3
771 Three times shiftwidth is the default value.
774 vim:tw=78:ts=8:ft=help:norl: