Vim documentation: indent (original) (raw)
indent.txt* For Vim version 7.3. Last change: 2011 Mar 18
VIM REFERENCE MANUAL by [Bram](intro.html#Bram) [Moolenaar](intro.html#Moolenaar)
This file is about indenting C programs and other files.
- Indenting C style programs |C-indenting|
- Indenting by expression |indent-expression|
==============================================================================
- Indenting C style programs * C-indenting*
The basics for C style indenting are explained in section |30.2| of the user manual.
Vim has options for automatically indenting C style program files. Many programming languages including Java and C++ follow very closely the formatting conventions established with C. These options affect only the indent and do not perform other formatting. There are additional options that affect other kinds of formatting as well as indenting, see |format-comments|, |fo-table|, |gq| and |formatting| for the main ones.
Note that this will not work when the |+smartindent| or |+cindent| features have been disabled at compile time.
There are in fact four main methods available for indentation, each one overrides the previous if it is enabled, or non-empty for 'indentexpr': 'autoindent' uses the indent from the previous line. 'smartindent' is like 'autoindent' but also recognizes some C syntax to increase/reduce the indent where appropriate. 'cindent' Works more cleverly than the other two and is configurable to different indenting styles. 'indentexpr' The most flexible of all: Evaluates an expression to compute the indent of a line. When non-empty this method overrides the other ones. See |indent-expression|. The rest of this section describes the 'cindent' option.
Note that 'cindent' indenting does not work for every code scenario. Vim is not a C compiler: it does not recognize all syntax. One requirement is that toplevel functions have a '{' in the first column. Otherwise they are easily confused with declarations.
These four options control C program indenting: 'cindent' Enables Vim to perform C program indenting automatically. 'cinkeys' Specifies which keys trigger reindenting in insert mode. 'cinoptions' Sets your preferred indent style. 'cinwords' Defines keywords that start an extra indent in the next line.
If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using Vim's built-in algorithm rather than calling an external program.
See |autocommand| for how to set the 'cindent' option automatically for C code files and reset it for others.
* **cinkeys-format*** * **indentkeys-format***The 'cinkeys' option is a string that controls Vim's indenting in response to typing certain characters or commands in certain contexts. Note that this not only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is used instead. The format of 'cinkeys' and 'indentkeys' is equal.
The default is "0{,0},0),:,0#,!^F,o,O,e" which specifies that indenting occurs as follows:
"0{" if you type '[{](motion.html#{)' [as](motion.html#as) the first character in a line
"0}" if you type '[}](motion.html#})' [as](motion.html#as) the first character in a line
"0)" if you type '[)](motion.html#%29)' [as](motion.html#as) the first character in a line
"[:](cmdline.html#:)" if you type '[:](cmdline.html#:)' after a label or [case](change.html#case) statement
"0#" if you type '[#](pattern.html##)' [as](motion.html#as) the first character in a line
"!^F" if you type [CTRL-F](scroll.html#CTRL-F) (which is not inserted)
"[o](insert.html#o)" if you type a [<CR>](motion.html#<CR>) anywhere or use the "[o](insert.html#o)" command (not in
insert mode!)
"[O](insert.html#O)" if you use the "[O](insert.html#O)" command (not in insert mode!)
"[e](motion.html#e)" if you type the second '[e](motion.html#e)' for an "else" at the start of a
lineCharacters that can precede each key: * i_CTRL-F* ! When a '!' precedes the key, Vim will not insert the key but will instead reindent the current line. This allows you to define a command key for reindenting the current line. CTRL-F is the default key for this. Be careful if you define CTRL-I for this because CTRL-I is the ASCII code for . * When a '' precedes the key, Vim will reindent the line before inserting the key. If 'cinkeys' contains "", Vim reindents the current line before opening a new line. 0 When a zero precedes the key (but appears after '!' or '*') Vim will reindent the line only if the key is the first character you type in the line. When used before "=" Vim will only reindent the line if there is only white space before the word.
When neither '!' nor '*' precedes the key, Vim reindents the line after you type the key. So ';' sets the indentation of a line which includes the ';'.
Special key names: <> Angle brackets mean spelled-out names of keys. For example: "", "" (see |key-notation|). ^ Letters preceded by a caret (^) are control characters. For example: "^F" is CTRL-F. o Reindent a line when you use the "o" command or when Vim opens a new line below the current one (e.g., when you type in insert mode). O Reindent a line when you use the "O" command. e Reindent a line that starts with "else" when you type the second 'e'. : Reindent a line when a ':' is typed which is after a label or case statement. Don't reindent for a ":" in "class::method" for C++. To Reindent for any ":", use "<:>". =word Reindent when typing the last character of "word". "word" may actually be part of another word. Thus "=end" would cause reindenting when typing the "d" in "endif" or "endwhile". But not when typing "bend". Also reindent when completion produces a word that starts with "word". "0=word" reindents when there is only white space before the word. =~word Like =word, but ignore case.
If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>', '*', ':' or '!', use "", "", "", "<0>", "<<>", "<>>", "<*>", "<:>" or "<!>", respectively, for those keys.
For an emacs-style indent mode where lines aren't indented every time you press but only if you press , I suggest: :set cinkeys=0{,0},:,0#,!,!^F You might also want to switch off 'autoindent' then.
Note: If you change the current line's indentation manually, Vim ignores the cindent settings for that line. This prevents vim from reindenting after you have changed the indent by typing , , or in the indent or used CTRL-T or CTRL-D.
* **cinoptions-values***The 'cinoptions' option sets how Vim performs indentation. In the list below, "N" represents a number of your choice (the number can be negative). When there is an 's' after the number, Vim multiplies the number by 'shiftwidth': "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. You can use a decimal point, too: "-0.5s" is minus half a 'shiftwidth'. The examples below assume a 'shiftwidth' of 4.
>N Amount added for "normal" indent. Used after a line that should
increase the indent (lines starting with "if", an opening brace,
etc.). (default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino=>2 cino=>2sif (cond) if (cond) if (cond) { { { foo; foo; foo; } } }
eN Add N to the prevailing indent inside a set of braces if the
opening brace at the End of the line (more precise: is not the
first character in a line). This is useful if you want a
different indent when the '[{](motion.html#{)' is at the start of the line from
when '[{](motion.html#{)' is at the end of the line. (default 0).
cino= cino=e2 cino=e-2if (cond) { if (cond) { if (cond) { foo; foo; foo; } } } else else else { { { bar; bar; bar; } } }
nN Add N to the prevailing indent for a statement after an "if",
"while", etc., if it is NOT inside a set of braces. This is
useful if you want a different indent when there is no '[{](motion.html#{)'
before the statement from when there is a '[{](motion.html#{)' before it.
(default 0).
cino= cino=n2 cino=n-2if (cond) if (cond) if (cond) foo; foo; foo; else else else { { { bar; bar; bar; } } }
fN Place the first opening brace of a function or other block in
column N. This applies only for an opening brace that is not
inside other braces and is at the start of the line. What comes
after the brace is put relative to this brace. (default 0).
cino= cino=f.5s cino=f1sfunc() func() func() { { { int foo; int foo; int foo;
{N Place opening braces N characters from the prevailing indent.
This applies only for opening braces that are inside other
braces. (default 0).
cino= cino={.5s cino={1sif (cond) if (cond) if (cond) { { { foo; foo; foo;
}N Place closing braces N characters from the matching opening
brace. (default 0).
cino= cino={2,}-0.5s cino=}2if (cond) if (cond) if (cond) { { { foo; foo; foo; } } }
^N Add N to the prevailing indent inside a set of braces if the
opening brace is in column 0. This can specify a different
indent for whole of a function (some may like to set it to a
negative number). (default 0).
cino= cino=^-2 cino=^-sfunc() func() func() { { { if (cond) if (cond) if (cond) { { { a = b; a = b; a = b; } } } } } }
LN Controls placement of jump labels. If N is negative, the label
will be placed at column 1. If N is non-negative, the indent of
the label will be the prevailing indent minus N. (default -1).
cino= cino=L2 cino=Lsfunc() func() func() { { { { { { stmt; stmt; stmt; LABEL: LABEL: LABEL: } } } } } }
[:N](editing.html#:N) Place [case](change.html#case) labels N characters from the indent of the switch().
(default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino=:0switch (x) switch(x) { { case 1: case 1: a = b; a = b; default: default: } }
=N Place statements occurring after a [case](change.html#case) label N characters from
the indent of the label. (default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino==10case 11: case 11: a = a + 1; a = a + 1; b = b + 1;
lN If N != 0 Vim will align with a [case](change.html#case) label instead of the
statement after it in the same line.
cino= cino=l1switch (a) { switch (a) { case 1: { case 1: { break; break; } }
bN If N != 0 Vim will align a final "break" with the [case](change.html#case) label,
so that case..break looks like a sort of block. (default: 0).
When using 1, consider adding "0=break" to ['cinkeys'](options.html#'cinkeys').
cino= cino=b1switch (x) switch(x) { { case 1: case 1: a = b; a = b; break; break;
default: default: a = 0; a = 0; break; break; } }
gN Place C++ scope declarations N characters from the indent of the
block they are in. (default ['shiftwidth'](options.html#'shiftwidth')). A scope declaration
can be "public:", "protected:" or "private:".
cino= cino=g0{ { public: public: a = b; a = b; private: private: } }
hN Place statements occurring after a C++ scope declaration N
characters from the indent of the label. (default
['shiftwidth'](options.html#'shiftwidth')).
cino= cino=h10public: public: a = a + 1; a = a + 1; b = b + 1;
pN Parameter declarations for K&R-style function declarations will
be indented N characters from the margin. (default
['shiftwidth'](options.html#'shiftwidth')).
cino= cino=p0 cino=p2sfunc(a, b) func(a, b) func(a, b) int a; int a; int a; char b; char b; char b;
tN Indent a function return type declaration N characters from the
margin. (default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino=t0 cino=t7int int int func() func() func()
iN Indent C++ base class declarations and constructor
initializations, if they start in a new line (otherwise they
are aligned at the right side of the ':').
(default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino=i0class MyClass : class MyClass : public BaseClass public BaseClass {} {} MyClass::MyClass() : MyClass::MyClass() : BaseClass(3) BaseClass(3) {} {}
+N Indent a continuation line (a line that spills onto the next)
inside a function N additional characters. (default
['shiftwidth'](options.html#'shiftwidth')).
Outside of a function, when the previous line ended in a
[backslash](intro.html#backslash), the 2 * N is used.
cino= cino=+10**a = b + 9 * a = b + 9 *** c; c;
cN Indent comment lines after the comment opener, when there is no
other text with which to align, N characters from the comment
opener. (default 3). See also |[format-comments](change.html#format-comments)|.
cino= cino=c5/ /** text. text. ***/ /*
CN When N is non-zero, indent comment lines by the amount specified
with the [c](change.html#c) flag above even if there is other text behind the
comment opener. (default 0).
cino=c0 cino=c0,C1/ /**** text. text. ****/ / (Example uses ":set comments& comments-=s1:/* comments^=s0:/*")
/N Indent comment lines N characters extra. (default 0).
cino= cino=/4a = b; a = b; /* comment / / comment */ c = d; c = d;
(N When in unclosed parentheses, indent N characters from the line
with the unclosed parentheses. Add a ['shiftwidth'](options.html#'shiftwidth') for every
unclosed parentheses. When N is 0 or the unclosed parentheses
is the first non-white character in its line, line up with the
next non-white character after the unclosed parentheses.
(default ['shiftwidth'](options.html#'shiftwidth') * 2).
cino= cino=(0if (c1 && (c2 || if (c1 && (c2 || c3)) c3)) foo; foo; if (c1 && if (c1 && (c2 || c3)) (c2 || c3)) { {
uN Same [as](motion.html#as) (N, but for one level deeper. (default ['shiftwidth'](options.html#'shiftwidth')).
cino= cino=u2if (c123456789 if (c123456789 && (c22345 && (c22345 || c3)) || c3))
UN When N is non-zero, [do](diff.html#do) not ignore the indenting specified by
( or [u](undo.html#u) in [case](change.html#case) that the unclosed parentheses is the first
non-white character in its line. (default 0).
cino= or cino=(s cino=(s,U1c = c1 && c = c1 && ( ( c2 || c2 || c3 c3 ) && c4; ) && c4;
wN When in unclosed parentheses and N is non-zero and either
using "(0" or "u0", respectively, or using "U0" and the unclosed
parentheses is the first non-white character in its line, line
up with the character immediately after the unclosed parentheses
rather than the first non-white character. (default 0).
cino=(0 cino=(0,w1if ( c1 if ( c1 && ( c2 && ( c2 || c3)) || c3)) foo; foo;
WN When in unclosed parentheses and N is non-zero and either
using "(0" or "u0", respectively and the unclosed parentheses is
the last non-white character in its line and it is not the
closing parentheses, indent the following line N characters
relative to the outer context (i.e. start of the line or the
next unclosed parentheses). (default: 0).
cino=(0 cino=(0,W4a_long_line( a_long_line( argument, argument, argument); argument); a_short_line(argument, a_short_line(argument, argument); argument);
mN When N is non-zero, line up a line starting with a closing
parentheses with the first character of the line with the
matching opening parentheses. (default 0).
cino=(s cino=(s,m1c = c1 && ( c = c1 && ( c2 || c2 || c3 c3 ) && c4; ) && c4; if ( if ( c1 && c2 c1 && c2 ) ) foo; foo;
MN When N is non-zero, line up a line starting with a closing
parentheses with the first character of the previous line.
(default 0).
cino= cino=M1if (cond1 && if (cond1 && cond2 cond2 ) )
* **java-cinoptions*** * **java-indenting***
jN Indent java anonymous classes correctly. The value '[N](pattern.html#N)' is
currently unused but must be non-zero (e.g. 'j1'). 'j1' will
indent for example the following code snippet correctly:
**object.add(new ChangeListener() {**public void stateChanged(ChangeEvent e) { do_something(); } });
* **javascript-cinoptions*** * **javascript-indenting***
JN Indent JavaScript object declarations correctly by not confusing
them with labels. The value '[N](pattern.html#N)' is currently unused but must be
non-zero (e.g. 'J1').
**var bar = {**foo: { that: this, some: ok, }, "bar":{ a : 2, b: "123abc", x: 4, "y": 5 } }
)N Vim searches for unclosed parentheses at most N lines away.
This [limits](vi%5Fdiff.html#limits) the time needed to search for parentheses. (default
20 lines).
*N Vim searches for unclosed comments at most N lines away. This
[limits](vi%5Fdiff.html#limits) the time needed to search for the start of a comment.
(default 70 lines).
#N When N is non-zero recognize shell/Perl comments, starting with
'[#](pattern.html##)'. Default N is zero: don't recognizes '[#](pattern.html##)' comments. Note
that lines starting with # will still be seen [as](motion.html#as) preprocessor
lines.The defaults, spelled out in full, are: cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,ps,ts,is,+s, c3,C0,/0,(2s,us,U0,w0,W0,m0,j0,J0,)20,*70,#0
Vim puts a line in column 1 if:
- It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'.
- It starts with a label (a keyword followed by ':', other than "case" and "default") and 'cinoptions' does not contain an 'L' entry with a positive value.
- Any combination of indentations causes the line to have less than 0 indentation.
==============================================================================
- Indenting by expression * indent-expression*
The basics for using flexible indenting are explained in section |30.3| of the user manual.
If you want to write your own indent file, it must set the 'indentexpr' option. Setting the 'indentkeys' option is often useful. See the $VIMRUNTIME/indent directory for examples.
REMARKS ABOUT SPECIFIC INDENT FILES
FORTRAN * ft-fortran-indent*
Block if, select case, and where constructs are indented. Comments, labelled statements and continuation lines are indented if the Fortran is in free source form, whereas they are not indented if the Fortran is in fixed source form because of the left margin requirements. Hence manual indent corrections will be necessary for labelled statements and continuation lines when fixed source form is being used. For further discussion of the method used for the detection of source format see |ft-fortran-syntax|.
Do loops All do loops are left unindented by default. Do loops can be unstructured in Fortran with (possibly multiple) loops ending on a labelled executable statement of almost arbitrary type. Correct indentation requires compiler-quality parsing. Old code with do loops ending on labelled statements of arbitrary type can be indented with elaborate programs such as Tidy http://www.unb.ca/chem/ajit/f_tidy.htm. Structured do/continue loops are also left unindented because continue statements are also used for purposes other than ending a do loop. Programs such as Tidy can convert structured do/continue loops to the do/enddo form. Do loops of the do/enddo variety can be indented. If you use only structured loops of the do/enddo form, you should declare this by setting the fortran_do_enddo variable in your .vimrc as follows
let fortran_do_enddo=1
in which case do loops will be indented. If all your loops are of do/enddo type only in, say, .f90 files, then you should set a buffer flag with an autocommand such as
*au! BufRead,BufNewFile .f90 let b:fortran_do_enddo=1
to get do loops indented in .f90 files and left alone in Fortran files with other extensions such as .for.
PHP * ft-php-indent* * php-indent* * php-indenting*
NOTE: PHP files will be indented correctly only if PHP |syntax| is active.
If you are editing a file in Unix 'fileformat' and '\r' characters are present before new lines, indentation won't proceed correctly ; you have to remove those useless characters first with a command like:
:%s /\r$//g
Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the script will silently remove them when Vim loads a PHP file (at each|BufRead|).
OPTIONS:
PHP indenting can be altered in several ways by modifying the values of some variables:
* **php-comment***To not enable auto-formating of comments by default (if you want to use your own 'formatoptions'): :let g:PHP_autoformatcomment = 0
Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be added, see|fo-table|for more information.
To add an extra indent to every PHP lines with N being the number of 'shiftwidth' to add: :let g:PHP_default_indenting = N
For example, with N = 1, this will give:
<?php if (!isset($History_lst_sel)) if (!isset($History_lst_sel)) if (!isset($History_lst_sel)) { $History_lst_sel=0; } else $foo="bar";
**$command_hist = TRUE;**?> (Notice the extra indent between the PHP container markers and the code)
To indent PHP tags as the surrounding code: :let g:PHP_outdentphpescape = 0
To automatically remove '\r' characters when the 'fileformat' is set to Unix: :let g:PHP_removeCRwhenUnix = 1
To indent braces at the same level than the code they contain: :let g:PHP_BracesAtCodeLevel = 1
This will give the following result: if ($foo) { foo(); } Instead of: if ($foo) { foo(); }
NOTE: Indenting will be a bit slower if this option is used because some optimizations won't be available.
To indent 'case:' and 'default:' statements in switch() blocks: :let g:PHP_vintage_case_default_indent = 1
(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 unnecessary indentation)
PYTHON * ft-python-indent*
The amount of indent can be set for the following situations. The examples given are the defaults. Note that the variables are set to an expression, so that you can change the value of 'shiftwidth' later.
Indent after an open paren: let g:pyindent_open_paren = '&sw * 2' Indent after a nested paren: let g:pyindent_nested_paren = '&sw' Indent for a continuation line: let g:pyindent_continue = '&sw * 2'
SHELL * ft-sh-indent*
The amount of indent applied under various circumstances in a shell file can be configured by setting the following keys in the |Dictionary| b:sh_indent_defaults to a specific amount or to a |Funcref| that references a function that will return the amount desired:
b:sh_indent_options['default'] Default amount of indent.
b:sh_indent_options['continuation-line'] Amount of indent to add to a continued line.
b:sh_indent_options['case-labels'] Amount of indent to add for case labels. (not actually implemented)
b:sh_indent_options['case-statements'] Amount of indent to add for case statements.
b:sh_indent_options['case-breaks'] Amount of indent to add (or more likely remove) for case breaks.
VERILOG * ft-verilog-indent*
General block statements such as if, for, case, always, initial, function, specify and begin, etc., are indented. The module block statements (first level blocks) are not indented by default. you can turn on the indent with setting a variable in the .vimrc as follows:
let b:verilog_indent_modules = 1
then the module blocks will be indented. To stop this, remove the variable:
:unlet b:verilog_indent_modules
To set the variable only for Verilog file. The following statements can be used:
au BufReadPost * if exists("b:current_syntax") au BufReadPost * if b:current_syntax == "verilog" au BufReadPost * let b:verilog_indent_modules = 1 au BufReadPost * endif au BufReadPost * endif
Furthermore, setting the variable b:verilog_indent_width to change the indenting width (default is 'shiftwidth'):
let b:verilog_indent_width = 4 let b:verilog_indent_width = &sw * 2
In addition, you can turn the verbose mode for debug issue:
let b:verilog_indent_verbose = 1
Make sure to do ":set cmdheight=2" first to allow the display of the message.
VHDL * ft-vhdl-indent*
Alignment of generic/port mapping statements are performed by default. This causes the following alignment example:
ENTITY sync IS PORT ( clk : IN STD_LOGIC; reset_n : IN STD_LOGIC; data_input : IN STD_LOGIC; data_out : OUT STD_LOGIC ); END ENTITY sync;
To turn this off, add
let g:vhdl_indent_genportmap = 0
to the .vimrc file, which causes the previous alignment example to change:
ENTITY sync IS PORT ( clk : IN STD_LOGIC; reset_n : IN STD_LOGIC; data_input : IN STD_LOGIC; data_out : OUT STD_LOGIC ); END ENTITY sync;
Alignment of right-hand side assignment "<=" statements are performed by default. This causes the following alignment example:
sig_out <= (bus_a(1) AND (sig_b OR sig_c)) OR (bus_a(0) AND sig_d);
To turn this off, add
let g:vhdl_indent_rhsassign = 0
to the .vimrc file, which causes the previous alignment example to change:
sig_out <= (bus_a(1) AND (sig_b OR sig_c)) OR (bus_a(0) AND sig_d);
Full-line comments (lines that begin with "--") are indented to be aligned with the very previous line's comment, PROVIDED that a whitespace follows after "--".
For example:
sig_a <= sig_b; -- start of a comment -- continuation of the comment -- more of the same comment
While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F will align the current "-- " with the previous line's "--".
If the very previous line does not contain "--", THEN the full-line comment will be aligned with the start of the next non-blank line that is NOT a full-line comment.
Indenting the following code:
sig_c <= sig_d; -- comment 0 -- comment 1 -- comment 2 --debug_code: --PROCESS(debug_in) --BEGIN -- FOR i IN 15 DOWNTO 0 LOOP -- debug_out(8i+7 DOWNTO 8i) <= debug_in(15-i); -- END LOOP; --END PROCESS debug_code;
-- comment 3 sig_e <= sig_f; -- comment 4 -- comment 5
results in:
sig_c <= sig_d; -- comment 0 -- comment 1 -- comment 2 --debug_code: --PROCESS(debug_in) --BEGIN -- FOR i IN 15 DOWNTO 0 LOOP -- debug_out(8i+7 DOWNTO 8i) <= debug_in(15-i); -- END LOOP; --END PROCESS debug_code;
-- comment 3 sig_e <= sig_f; -- comment 4 -- comment 5
Notice that "--debug_code:" does not align with "-- comment 2" because there is no whitespace that follows after "--" in "--debug_code:".
Given the dynamic nature of indenting comments, indenting should be done TWICE. On the first pass, code will be indented. On the second pass, full-line comments will be indented according to the correctly indented code.
VIM * ft-vim-indent*
For indenting Vim scripts there is one variable that specifies the amount of indent for a continuation line, a line that starts with a backslash:
**:let g:vim_indent_cont = &sw * 3**Three times shiftwidth is the default value.