vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

indent.txt (44900B)


      1 *indent.txt*	For Vim version 9.2.  Last change: 2026 Feb 14
      2 
      3 
      4 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
      5 
      6 
      7 This file is about indenting C programs and other files.
      8 
      9 1. Indenting C style programs	|C-indenting|
     10 2. Indenting by expression	|indent-expression|
     11 
     12 ==============================================================================
     13 1. Indenting C style programs				*C-indenting*
     14 
     15 The basics for C style indenting are explained in section |30.2| of the user
     16 manual.
     17 
     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.
     24 
     25 There are in fact four main methods available for indentation, each one
     26 overrides the previous if it is enabled, or non-empty for 'indentexpr':
     27 'autoindent'	uses the indent from the previous line.
     28 'smartindent'	is like 'autoindent' but also recognizes some C syntax to
     29 		increase/reduce the indent where appropriate.
     30 'cindent'	Works more cleverly than the other two and is configurable to
     31 		different indenting styles.
     32 'indentexpr'	The most flexible of all: Evaluates an expression to compute
     33 		the indent of a line.  When non-empty this method overrides
     34 		the other ones.  See |indent-expression|.
     35 The rest of this section describes the 'cindent' option.
     36 
     37 Note that 'cindent' indenting does not work for every code scenario.  Vim
     38 is not a C compiler: it does not recognize all syntax.  One requirement is
     39 that toplevel functions have a '{' in the first column.  Otherwise they are
     40 easily confused with declarations.
     41 
     42 These five options control C program indenting:
     43 'cindent'	Enables Vim to perform C program indenting automatically.
     44 'cinkeys'	Specifies which keys trigger reindenting in insert mode.
     45 'cinoptions'	Sets your preferred indent style.
     46 'cinwords'	Defines keywords that start an extra indent in the next line.
     47 'cinscopedecls'	Defines strings that are recognized as a C++ scope
     48 		declaration.
     49 
     50 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using
     51 Vim's built-in algorithm rather than calling an external program.
     52 
     53 See |autocommand| for how to set the 'cindent' option automatically for C code
     54 files and reset it for others.
     55 
     56 					*cinkeys-format* *indentkeys-format*
     57 The 'cinkeys' option is a string that controls Vim's indenting in response to
     58 typing certain characters or commands in certain contexts.  Note that this not
     59 only triggers C-indenting.  When 'indentexpr' is not empty 'indentkeys' is
     60 used instead.  The format of 'cinkeys' and 'indentkeys' is equal.
     61 
     62 The default is "0{,0},0),0],:,0#,!^F,o,O,e" which specifies that indenting
     63 occurs as follows:
     64 
     65 	"0{"	if you type '{' as the first character in a line
     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 
     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.
     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
    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.
    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.  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,
    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
    142 decimal point, too: "-0.5s" is minus half a 'shiftwidth'.
    143 The examples below assume a 'shiftwidth' of 4.
    144 							*cino->*
    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 <
    155 							*cino-e*
    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 <
    171 							*cino-n*
    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 <
    186 							*cino-f*
    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 <
    197 							*cino-{*
    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 <
    207 							*cino-}*
    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 <
    217 							*cino-^*
    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 <
    232 							*cino-L*
    233 	LN    Controls placement of jump labels.  If N is negative, the label
    234 	      will be placed at column 1.  If N is non-negative, the indent of
    235 	      the label will be the prevailing indent minus N.  (default -1).
    236 
    237 		cino=               cino=L2             cino=Ls >
    238 		  func()              func()              func()
    239 		  {                   {                   {
    240 		      {                   {                   {
    241 		          stmt;               stmt;               stmt;
    242 		  LABEL:                    LABEL:            LABEL:
    243 		      }                   }                   }
    244 		  }                   }                   }
    245 <
    246 							*cino-:*
    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 <
    258 							*cino-=*
    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 <
    266 							*cino-l*
    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 <
    276 							*cino-b*
    277 	bN    If N != 0 Vim will align a final "break" with the case label,
    278 	      so that case..break looks like a sort of block.  (default: 0).
    279 	      When using 1, consider adding "0=break" to 'cinkeys'.
    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 <
    293 							*cino-g*
    294 	gN    Place C++ scope declarations N characters from the indent of the
    295 	      block they are in.  (default 'shiftwidth').  By default, a scope
    296 	      declaration is "public:", "protected:" or "private:".  This can
    297 	      be adjusted with the 'cinscopedecls' option.
    298 
    299 		cino=		    cino=g0 >
    300 		  {		      {
    301 		      public:	      public:
    302 			  a = b;	  a = b;
    303 		      private:	      private:
    304 		  }		      }
    305 <
    306 							*cino-h*
    307 	hN    Place statements occurring after a C++ scope declaration N
    308 	      characters from the indent of the label.  (default
    309 	      'shiftwidth').
    310 
    311 		cino=		    cino=h10 >
    312 		   public:		public:   a = a + 1;
    313 		       a = a + 1;		  b = b + 1;
    314 <
    315 							*cino-N*
    316 	NN    Indent inside C++ namespace N characters extra compared to a
    317 	      normal block.  (default 0).
    318 
    319 		cino=			   cino=N-s >
    320 		  namespace {                namespace {
    321 		      void function();       void function();
    322 		  }                          }
    323 
    324 		  namespace my               namespace my
    325 		  {                          {
    326 		      void function();       void function();
    327 		  }                          }
    328 <
    329 							*cino-E*
    330 	EN    Indent inside C++ linkage specifications (extern "C" or
    331 	      extern "C++") N characters extra compared to a normal block.
    332 	      (default 0).
    333 
    334 		cino=			   cino=E-s >
    335 		  extern "C" {               extern "C" {
    336 		      void function();       void function();
    337 		  }                          }
    338 
    339 		  extern "C"                 extern "C"
    340 		  {                          {
    341 		      void function();       void function();
    342 		  }                          }
    343 <
    344 							*cino-p*
    345 	pN    Parameter declarations for K&R-style function declarations will
    346 	      be indented N characters from the margin.  (default
    347 	      'shiftwidth').
    348 
    349 		cino=		    cino=p0		cino=p2s >
    350 		  func(a, b)	      func(a, b)	  func(a, b)
    351 		      int a;	      int a;			  int a;
    352 		      char b;	      char b;			  char b;
    353 <
    354 							*cino-t*
    355 	tN    Indent a function return type declaration N characters from the
    356 	      margin.  (default 'shiftwidth').
    357 
    358 		cino=		    cino=t0		cino=t7 >
    359 		      int	      int			 int
    360 		  func()	      func()		  func()
    361 <
    362 							*cino-i*
    363 	iN    Indent C++ base class declarations and constructor
    364 	      initializations, if they start in a new line (otherwise they
    365 	      are aligned at the right side of the ':').
    366 	      (default 'shiftwidth').
    367 
    368 		cino=			  cino=i0 >
    369 		  class MyClass :	    class MyClass :
    370 		      public BaseClass      public BaseClass
    371 		  {}			    {}
    372 		  MyClass::MyClass() :	    MyClass::MyClass() :
    373 		      BaseClass(3)	    BaseClass(3)
    374 		  {}			    {}
    375 <
    376 							*cino-+*
    377 	+N    Indent a continuation line (a line that spills onto the next)
    378               inside a function N additional characters.  (default
    379               'shiftwidth').
    380               Outside of a function, when the previous line ended in a
    381               backslash, the 2 * N is used.
    382 
    383 		cino=			  cino=+10 >
    384 		  a = b + 9 *		    a = b + 9 *
    385 		      c;			      c;
    386 <
    387 							*cino-c*
    388 	cN    Indent comment lines after the comment opener, when there is no
    389 	      other text with which to align, N characters from the comment
    390 	      opener.  (default 3).  See also |format-comments|.
    391 
    392 		cino=			  cino=c5 >
    393 		  /*			    /*
    394 		     text.			 text.
    395 		   */			     */
    396 <
    397 							*cino-C*
    398 	CN    When N is non-zero, indent comment lines by the amount specified
    399 	      with the c flag above even if there is other text behind the
    400 	      comment opener.  (default 0).
    401 
    402 		cino=c0			  cino=c0,C1 >
    403 		  /********		    /********
    404 		    text.		    text.
    405 		  ********/		    ********/
    406 <	      (Example uses ":set comments& comments-=s1:/* comments^=s0:/*")
    407 
    408 							*cino-/*
    409 	/N    Indent comment lines N characters extra.  (default 0).
    410 		cino=			  cino=/4 >
    411 		  a = b;		    a = b;
    412 		  /* comment */			/* comment */
    413 		  c = d;		    c = d;
    414 <
    415 							*cino-(*
    416 	(N    When in unclosed parentheses, indent N characters from the line
    417 	      with the unclosed parenthesis.  Add a 'shiftwidth' for every
    418 	      extra unclosed parentheses.  When N is 0 or the unclosed
    419 	      parenthesis is the first non-white character in its line, line
    420 	      up with the next non-white character after the unclosed
    421 	      parenthesis.  (default 'shiftwidth' * 2).
    422 
    423 		cino=			  cino=(0 >
    424 		  if (c1 && (c2 ||	    if (c1 && (c2 ||
    425 			      c3))		       c3))
    426 		      foo;			foo;
    427 		  if (c1 &&		    if (c1 &&
    428 			  (c2 || c3))		(c2 || c3))
    429 		     {			       {
    430 <
    431 							*cino-u*
    432 	uN    Same as (N, but for one nesting level deeper.
    433 	      (default 'shiftwidth').
    434 
    435 		cino=			  cino=u2 >
    436 		  if (c123456789	    if (c123456789
    437 			  && (c22345		    && (c22345
    438 			      || c3))		      || c3))
    439 <
    440 							*cino-U*
    441 	UN    When N is non-zero, do not ignore the indenting specified by
    442 	      ( or u in case that the unclosed parenthesis is the first
    443 	      non-white character in its line.  (default 0).
    444 
    445 		cino= or cino=(s	  cino=(s,U1 >
    446 		  c = c1 &&		    c = c1 &&
    447 		      (				(
    448 		       c2 ||			    c2 ||
    449 		       c3			    c3
    450 		      ) && c4;			) && c4;
    451 <
    452 							*cino-w*
    453 	wN    When in unclosed parentheses and N is non-zero and either
    454 	      using "(0" or "u0", respectively, or using "U0" and the unclosed
    455 	      parenthesis is the first non-white character in its line, line
    456 	      up with the character immediately after the unclosed parenthesis
    457 	      rather than the first non-white character.  (default 0).
    458 
    459 		cino=(0			  cino=(0,w1 >
    460 		  if (   c1		    if (   c1
    461 			 && (   c2		&& (   c2
    462 				|| c3))		    || c3))
    463 		      foo;			foo;
    464 <
    465 							*cino-W*
    466 	WN    When in unclosed parentheses and N is non-zero and either
    467 	      using "(0" or "u0", respectively and the unclosed parenthesis is
    468 	      the last non-white character in its line and it is not the
    469 	      closing parenthesis, indent the following line N characters
    470 	      relative to the outer context (i.e. start of the line or the
    471 	      next unclosed parenthesis).  (default: 0).
    472 
    473 		cino=(0			   cino=(0,W4 >
    474 		  a_long_line(		    a_long_line(
    475 			      argument,		argument,
    476 			      argument);	argument);
    477 		  a_short_line(argument,    a_short_line(argument,
    478 			       argument);		 argument);
    479 <
    480 							*cino-k*
    481 	kN    When in unclosed parentheses which follow "if", "for" or
    482 	      "while" and N is non-zero, overrides the behaviour defined by
    483 	      "(N": causes the indent to be N characters relative to the outer
    484 	      context (i.e. the line where "if", "for" or "while" is).  Has
    485 	      no effect on deeper levels of nesting.  Affects flags like "wN"
    486 	      only for the "if", "for" and "while" conditions.  If 0, defaults
    487 	      to behaviour defined by the "(N" flag.  (default: 0).
    488 
    489 		cino=(0			   cino=(0,ks >
    490 		  if (condition1	    if (condition1
    491 		      && condition2)		    && condition2)
    492 		      action();			action();
    493 		  function(argument1	    function(argument1
    494 			   && argument2);	     && argument2);
    495 <
    496 							*cino-m*
    497 	mN    When N is non-zero, line up a line starting with a closing
    498 	      parenthesis with the first character of the line with the
    499 	      matching opening parenthesis.  (default 0).
    500 
    501 		cino=(s			  cino=(s,m1 >
    502 		  c = c1 && (		    c = c1 && (
    503 		      c2 ||			c2 ||
    504 		      c3			c3
    505 		      ) && c4;		    ) && c4;
    506 		  if (			    if (
    507 		      c1 && c2			c1 && c2
    508 		     )			    )
    509 		      foo;			foo;
    510 <
    511 							*cino-M*
    512 	MN    When N is non-zero, line up a line starting with a closing
    513 	      parenthesis with the first character of the previous line.
    514 	      (default 0).
    515 
    516 		cino=			  cino=M1 >
    517 		  if (cond1 &&		    if (cond1 &&
    518 			 cond2			   cond2
    519 		     )				   )
    520 <
    521 				*java-cinoptions* *java-indenting* *cino-j*
    522 	jN    Indent Java anonymous classes correctly.  Also works well for
    523 	      Javascript.  The value 'N' is currently unused but must be
    524 	      non-zero (e.g. 'j1').  'j1' will indent for example the
    525 	      following code snippet correctly: >
    526 
    527 		object.add(new ChangeListener() {
    528 		    public void stateChanged(ChangeEvent e) {
    529 			do_something();
    530 		    }
    531 		});
    532 <
    533 			*javascript-cinoptions* *javascript-indenting* *cino-J*
    534 	JN    Indent JavaScript object declarations correctly by not confusing
    535 	      them with labels.  The value 'N' is currently unused but must be
    536 	      non-zero (e.g. 'J1').  If you enable this you probably also want
    537 	      to set |cino-j|. >
    538 
    539 		var bar = {
    540 		    foo: {
    541 			that: this,
    542 			some: ok,
    543 		    },
    544 		    "bar":{
    545 			a : 2,
    546 			b: "123abc",
    547 			x: 4,
    548 			"y": 5
    549 		    }
    550 		}
    551 <
    552 								*cino-)*
    553 	)N    Vim searches for unclosed parentheses at most N lines away.
    554 	      This limits the time needed to search for parentheses.  (default
    555 	      20 lines).
    556 
    557 								*cino-star*
    558 	*N    Vim searches for unclosed comments at most N lines away.  This
    559 	      limits the time needed to search for the start of a comment.
    560 	      If your /* */ comments stop indenting after N lines this is the
    561 	      value you will want to change.
    562 	      (default 70 lines).
    563 
    564 								*cino-#*
    565 	#N    When N is non-zero recognize shell/Perl comments starting with
    566 	      '#', do not recognize preprocessor lines; allow right-shifting
    567 	      lines that start with "#".
    568 	      When N is zero (default): don't recognize '#' comments, do
    569 	      recognize preprocessor lines; right-shifting lines that start
    570 	      with "#" does not work.
    571 
    572 								*cino-P*
    573 	PN    When N is non-zero recognize C pragmas, and indent them like any
    574 	      other code; does not concern other preprocessor directives.
    575 	      When N is zero (default): don't recognize C pragmas, treating
    576 	      them like every other preprocessor directive.
    577 
    578 
    579 The defaults, spelled out in full, are:
    580 	cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,E0,ps,ts,is,+s,
    581 			c3,C0,/0,(2s,us,U0,w0,W0,k0,m0,j0,J0,)20,*70,#0,P0
    582 
    583 Vim puts a line in column 1 if:
    584 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#0'.
    585 - It starts with a label (a keyword followed by ':', other than "case" and
    586   "default") and 'cinoptions' does not contain an 'L' entry with a positive
    587   value.
    588 - Any combination of indentations causes the line to have less than 0
    589   indentation.
    590 
    591 ==============================================================================
    592 2. Indenting by expression				*indent-expression*
    593 
    594 The basics for using flexible indenting are explained in section |30.3| of the
    595 user manual.
    596 
    597 If you want to write your own indent file, it must set the 'indentexpr'
    598 option.  Setting the 'indentkeys' option is often useful.
    599 See the $VIMRUNTIME/indent/README.txt file for hints.
    600 See the $VIMRUNTIME/indent directory for examples.
    601 
    602 
    603 REMARKS ABOUT SPECIFIC INDENT FILES ~
    604 
    605 
    606 CLOJURE					*ft-clojure-indent* *clojure-indent*
    607 
    608 Clojure indentation differs somewhat from traditional Lisps, due in part to
    609 the use of square and curly brackets, and otherwise by community convention.
    610 These conventions are not universally followed, so the Clojure indent script
    611 offers a few configuration options.
    612 
    613 (If the current Vim does not include |searchpairpos()|, the indent script falls
    614 back to normal 'lisp' indenting, and the following options are ignored.)
    615 
    616 
    617 							*g:clojure_maxlines*
    618 
    619 Sets maximum scan distance of `searchpairpos()`.  Larger values trade
    620 performance for correctness when dealing with very long forms.  A value of
    621 0 will scan without limits.  The default is 300.
    622 
    623 
    624 						*g:clojure_fuzzy_indent*
    625 					*g:clojure_fuzzy_indent_patterns*
    626 					*g:clojure_fuzzy_indent_blacklist*
    627 
    628 The 'lispwords' option is a list of comma-separated words that mark special
    629 forms whose subforms should be indented with two spaces.
    630 
    631 For example:
    632 >
    633 	(defn bad []
    634 	      "Incorrect indentation")
    635 
    636 	(defn good []
    637 	  "Correct indentation")
    638 <
    639 If you would like to specify 'lispwords' with a |pattern| instead, you can use
    640 the fuzzy indent feature:
    641 >
    642 	" Default
    643 	let g:clojure_fuzzy_indent = 1
    644 	let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']
    645 	let g:clojure_fuzzy_indent_blacklist =
    646 		\ ['-fn$', '\v^with-%(meta|out-str|loading-context)$']
    647 <
    648 |g:clojure_fuzzy_indent_patterns| and |g:clojure_fuzzy_indent_blacklist| are
    649 lists of patterns that will be matched against the unqualified symbol at the
    650 head of a list.  This means that a pattern like `"^foo"` will match all these
    651 candidates: `foobar`, `my.ns/foobar`, and `#'foobar`.
    652 
    653 Each candidate word is tested for special treatment in this order:
    654 
    655 	1. Return true if word is literally in 'lispwords'
    656 	2. Return false if word matches a pattern in
    657 	   |g:clojure_fuzzy_indent_blacklist|
    658 	3. Return true if word matches a pattern in
    659 	   |g:clojure_fuzzy_indent_patterns|
    660 	4. Return false and indent normally otherwise
    661 
    662 
    663 					*g:clojure_special_indent_words*
    664 
    665 Some forms in Clojure are indented such that every subform is indented by only
    666 two spaces, regardless of 'lispwords'.  If you have a custom construct that
    667 should be indented in this idiosyncratic fashion, you can add your symbols to
    668 the default list below.
    669 >
    670 	" Default
    671 	let g:clojure_special_indent_words =
    672 	   \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'
    673 <
    674 
    675 					*g:clojure_align_multiline_strings*
    676 
    677 Align subsequent lines in multi-line strings to the column after the opening
    678 quote, instead of the same column.
    679 
    680 For example:
    681 >
    682 	(def default
    683 	  "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
    684 	  eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
    685 	  enim ad minim veniam, quis nostrud exercitation ullamco laboris
    686 	  nisi ut aliquip ex ea commodo consequat.")
    687 
    688 	(def aligned
    689 	  "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
    690 	   eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
    691 	   enim ad minim veniam, quis nostrud exercitation ullamco laboris
    692 	   nisi ut aliquip ex ea commodo consequat.")
    693 <
    694 
    695 						*g:clojure_align_subforms*
    696 
    697 By default, parenthesized compound forms that look like function calls and
    698 whose head subform is on its own line have subsequent subforms indented by
    699 two spaces relative to the opening paren:
    700 >
    701 	(foo
    702 	  bar
    703 	  baz)
    704 <
    705 Setting this option to `1` changes this behaviour so that all subforms are
    706 aligned to the same column, emulating the default behaviour of
    707 clojure-mode.el:
    708 >
    709 	(foo
    710 	 bar
    711 	 baz)
    712 <
    713 
    714 FORTRAN							*ft-fortran-indent*
    715 
    716 Block if, select case, select type, select rank,  where, forall, type,
    717 interface, associate, block, enum, critical, and change team constructs are
    718 indented.  The indenting of subroutines, functions, modules, and program
    719 blocks is optional.  Comments, labeled statements, and continuation lines are
    720 indented in free source form, whereas they are not indented in fixed source
    721 form because of the left margin requirements.  Hence manual indent corrections
    722 will be necessary for labeled statements and continuation lines when fixed
    723 source form is being used.  For further discussion of the method used for the
    724 detection of source format see |ft-fortran-syntax|.
    725 
    726 Do loops ~
    727 All do loops are left unindented by default.  Do loops can be unstructured in
    728 Fortran with (possibly multiple) loops ending on a labeled executable
    729 statement of almost arbitrary type.  Correct indentation requires
    730 compiler-quality parsing.  Old code with do loops ending on labeled statements
    731 of arbitrary type can be indented with elaborate programs such as Tidy.
    732 Structured do/continue loops are also left unindented because continue
    733 statements are used for purposes other than ending a do loop.  Programs such
    734 as Tidy can convert structured do/continue loops to the do/enddo form.  Do
    735 loops of the do/enddo variety can be indented.  If you use only structured
    736 loops of the do/enddo form, you should declare this by setting the
    737 fortran_do_enddo variable in your .vimrc as follows >
    738 
    739    let fortran_do_enddo=1
    740 
    741 in which case do loops will be indented.  If all your loops are of do/enddo
    742 type only in, say, .f90 files, then you should set a buffer flag with an
    743 autocommand such as >
    744 
    745   au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1
    746 
    747 to get do loops indented in .f90 files and left alone in Fortran files with
    748 other extensions such as .for.
    749 
    750 Program units ~
    751 Indenting of program units (subroutines, functions, modules, and program
    752 blocks) can be increased by setting the variable fortran_indent_more and can
    753 be decreased by setting the variable fortran_indent_less.  These variables
    754 can be set for all fortran files in your .vimrc as follows >
    755 
    756   let fortran_indent_less=1
    757 
    758 A finer level of control can be achieved by setting the corresponding
    759 buffer-local variable as follows >
    760 
    761   let b:fortran_indent_less=1
    762 
    763 
    764 HTML				*ft-html-indent* *html-indent* *html-indenting*
    765 
    766 This is about variables you can set in your vimrc to customize HTML indenting.
    767 
    768 You can set the indent for the first line after <script> and <style>
    769 "blocktags" (default "zero"): >
    770 
    771       :let g:html_indent_script1 = "inc"
    772       :let g:html_indent_style1 = "inc"
    773 <
    774       VALUE	MEANING ~
    775       "zero"	zero indent
    776       "auto"	auto indent (same indent as the blocktag)
    777       "inc"	auto indent + one indent step
    778 
    779 You can set the indent for attributes after an open <tag line: >
    780 
    781       :let g:html_indent_attribute = 1
    782 <
    783       VALUE	MEANING ~
    784       1		auto indent, one indent step more than <tag
    785       2		auto indent, two indent steps (default)
    786       > 2	auto indent, more indent steps
    787 
    788 Many tags increase the indent for what follows per default (see "Add Indent
    789 Tags" in the script).  You can add further tags with: >
    790 
    791       :let g:html_indent_inctags = "html,body,head,tbody"
    792 
    793 You can also remove such tags with: >
    794 
    795       :let g:html_indent_autotags = "th,td,tr,tfoot,thead"
    796 
    797 Default value is empty for both variables.  Note: the initial "inctags" are
    798 only defined once per Vim session.
    799 
    800 User variables are only read when the script is sourced.  To enable your
    801 changes during a session, without reloading the HTML file, you can manually
    802 do: >
    803 
    804       :call HtmlIndent_CheckUserSettings()
    805 
    806 Detail:
    807   Calculation of indent inside "blocktags" with "alien" content:
    808       BLOCKTAG   INDENT EXPR	    WHEN APPLICABLE ~
    809       <script> : {customizable}	    if first line of block
    810 	       : cindent(v:lnum)    if attributes empty or contain "java"
    811 	       : -1		    else (vbscript, tcl, ...)
    812       <style>  : {customizable}	    if first line of block
    813 	       : GetCSSIndent()	    else
    814       <!-- --> : -1
    815 
    816 IDRIS2							*ft-idris2-indent*
    817 
    818 Idris 2 indentation can be configured with several variables that control the
    819 indentation level for different language constructs:
    820 
    821 The "g:idris2_indent_if" variable controls the indentation of `then` and `else`
    822 blocks after `if` statements.  Defaults to 3.
    823 
    824 The "g:idris2_indent_case" variable controls the indentation of patterns in
    825 `case` expressions.  Defaults to 5.
    826 
    827 The "g:idris2_indent_let" variable controls the indentation after `let`
    828 bindings.  Defaults to 4.
    829 
    830 The "g:idris2_indent_rewrite" variable controls the indentation after `rewrite`
    831 expressions.  Defaults to 8.
    832 
    833 The "g:idris2_indent_where" variable controls the indentation of `where`
    834 blocks.  Defaults to 6.
    835 
    836 The "g:idris2_indent_do" variable controls the indentation in `do` blocks.
    837 Defaults to 3.
    838 
    839 Example configuration: >
    840 
    841 	let g:idris2_indent_if = 2
    842 	let g:idris2_indent_case = 4
    843 	let g:idris2_indent_let = 4
    844 	let g:idris2_indent_rewrite = 8
    845 	let g:idris2_indent_where = 6
    846 	let g:idris2_indent_do = 3
    847 <
    848 
    849 MATLAB			*ft-matlab-indent* *matlab-indent* *matlab-indenting*
    850 
    851 The setting Function indenting format in MATLAB Editor/Debugger Language
    852 Preferences corresponds to: >
    853     :let g:MATLAB_function_indent = {0, 1 or 2 (default)}
    854 
    855 Where 0 is for Classic, 1 for Indent nested functions and 2 for Indent all
    856 functions.
    857 
    858 
    859 PHP				*ft-php-indent* *php-indent* *php-indenting*
    860 
    861 NOTE:	PHP files will be indented correctly only if PHP |syntax| is active.
    862 
    863 If you are editing a file in Unix 'fileformat' and '\r' characters are present
    864 before new lines, indentation won't proceed correctly ; you have to remove
    865 those useless characters first with a command like: >
    866 
    867     :%s /\r$//g
    868 
    869 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the
    870 script will silently remove them when Vim loads a PHP file (at each |BufRead|).
    871 
    872 OPTIONS: ~
    873 
    874 PHP indenting can be altered in several ways by modifying the values of some
    875 global variables:
    876 
    877 					*php-comment* *PHP_autoformatcomment*
    878 To not enable auto-formatting of comments by default (if you want to use your
    879 own 'formatoptions'): >
    880     :let g:PHP_autoformatcomment = 0
    881 
    882 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be
    883 added, see |fo-table| for more information.
    884 -------------
    885 
    886 							*PHP_outdentSLComments*
    887 To add extra indentation to single-line comments: >
    888     :let g:PHP_outdentSLComments = N
    889 
    890 With N being the number of 'shiftwidth' to add.
    891 
    892 Only single-line comments will be affected such as: >
    893     # Comment
    894     // Comment
    895     /* Comment */
    896 -------------
    897 
    898 							*PHP_default_indenting*
    899 To add extra indentation to every PHP lines with N being the number of
    900 'shiftwidth' to add: >
    901     :let g:PHP_default_indenting = N
    902 
    903 For example, with N = 1, this will give:
    904 >
    905     <?php
    906 	if (!isset($History_lst_sel))
    907 	    if (!isset($History_lst_sel))
    908 		if (!isset($History_lst_sel)) {
    909 		    $History_lst_sel=0;
    910 		} else
    911 		    $foo="bar";
    912 
    913 	$command_hist = TRUE;
    914     ?>
    915 (Notice the extra indentation between the PHP container markers and the code)
    916 -------------
    917 
    918 							*PHP_outdentphpescape*
    919 To indent PHP escape tags as the surrounding non-PHP code (only affects the
    920 PHP escape tags): >
    921     :let g:PHP_outdentphpescape = 0
    922 -------------
    923 
    924 							*PHP_removeCRwhenUnix*
    925 To automatically remove '\r' characters when the 'fileformat' is set to Unix: >
    926     :let g:PHP_removeCRwhenUnix = 1
    927 -------------
    928 
    929 							*PHP_BracesAtCodeLevel*
    930 To indent braces at the same level than the code they contain: >
    931     :let g:PHP_BracesAtCodeLevel = 1
    932 
    933 This will give the following result: >
    934     if ($foo)
    935 	{
    936 	foo();
    937 	}
    938 Instead of: >
    939     if ($foo)
    940     {
    941 	foo();
    942     }
    943 
    944 NOTE:	Indenting will be a bit slower if this option is used because some
    945 	optimizations won't be available.
    946 -------------
    947 
    948 					*PHP_vintage_case_default_indent*
    949 To indent 'case:' and 'default:' statements in switch() blocks: >
    950     :let g:PHP_vintage_case_default_indent = 1
    951 
    952 In PHP braces are not required inside 'case/default' blocks therefore 'case:'
    953 and 'default:' are indented at the same level than the 'switch()' to avoid
    954 meaningless indentation.  You can use the above option to return to the
    955 traditional way.
    956 -------------
    957 
    958 							*PHP_noArrowMatching*
    959 By default the indent script will indent multi-line chained calls by matching
    960 the position of the '->': >
    961 
    962     $user_name_very_long->name()
    963                         ->age()
    964                         ->info();
    965 
    966 You can revert to the classic way of indenting by setting this option to 1: >
    967     :let g:PHP_noArrowMatching = 1
    968 
    969 You will obtain the following result: >
    970 
    971     $user_name_very_long->name()
    972         ->age()
    973         ->info();
    974 
    975 -------------
    976 
    977 					*PHP_IndentFunctionCallParameters*
    978 Extra indentation levels to add to parameters in multi-line function calls. >
    979     let g:PHP_IndentFunctionCallParameters = 1
    980 
    981 Function call arguments will indent 1 extra level.  For two-space indentation: >
    982 
    983     function call_the_thing(
    984       $with_this,
    985       $and_that
    986     ) {
    987       $this->do_the_thing(
    988           $with_this,
    989           $and_that
    990       );
    991     }
    992 
    993 -------------
    994 
    995 				*PHP_IndentFunctionDeclarationParameters*
    996 Extra indentation levels to add to arguments in multi-line function
    997 definitions. >
    998     let g:PHP_IndentFunctionDeclarationParameters = 1
    999 
   1000 Function arguments in declarations will indent 1 extra level.  For two-space
   1001 indentation: >
   1002 
   1003     function call_the_thing(
   1004         $with_this,
   1005         $and_that
   1006     ) {
   1007       $this->do_the_thing(
   1008         $with_this,
   1009         $and_that
   1010       );
   1011     }
   1012 
   1013 
   1014 PYTHON							*ft-python-indent*
   1015 
   1016 The amount of indent can be set with the `g:python_indent` |Dictionary|, which
   1017 needs to be created before adding the items: >
   1018 	let g:python_indent = {}
   1019 The examples given are the defaults.  Note that the dictionary values are set
   1020 to an expression, so that you can change the value of 'shiftwidth' later
   1021 without having to update these values.
   1022 
   1023 Indent after an open paren: >
   1024 	let g:python_indent.open_paren = 'shiftwidth() * 2'
   1025 Indent after a nested paren: >
   1026 	let g:python_indent.nested_paren = 'shiftwidth()'
   1027 Indent for a continuation line: >
   1028 	let g:python_indent.continue = 'shiftwidth() * 2'
   1029 
   1030 By default, the closing paren on a multiline construct lines up under the
   1031 first non-whitespace character of the previous line.
   1032 If you prefer that it's lined up under the first character of the line that
   1033 starts the multiline construct, reset this key: >
   1034 	let g:python_indent.closed_paren_align_last_line = v:false
   1035 
   1036 The method uses |searchpair()| to look back for unclosed parentheses.  This
   1037 can sometimes be slow, thus it timeouts after 150 msec.  If you notice the
   1038 indenting isn't correct, you can set a larger timeout in msec: >
   1039 	let g:python_indent.searchpair_timeout = 500
   1040 
   1041 If looking back for unclosed parenthesis is still too slow, especially during
   1042 a copy-paste operation, or if you don't need indenting inside multi-line
   1043 parentheses, you can completely disable this feature: >
   1044 	let g:python_indent.disable_parentheses_indenting = 1
   1045 
   1046 For backward compatibility, these variables are also supported: >
   1047 	g:pyindent_open_paren
   1048 	g:pyindent_nested_paren
   1049 	g:pyindent_continue
   1050 	g:pyindent_searchpair_timeout
   1051 	g:pyindent_disable_parentheses_indenting
   1052 
   1053 
   1054 R								*ft-r-indent*
   1055 
   1056 Function arguments are aligned if they span for multiple lines.  If you prefer
   1057 do not have the arguments of functions aligned, put in your |vimrc|:
   1058 >
   1059    let r_indent_align_args = 0
   1060 <
   1061 All lines beginning with a comment character, #, get the same indentation
   1062 level of the normal R code.  Users of Emacs/ESS may be used to have lines
   1063 beginning with a single # indented in the 40th column, ## indented as R code,
   1064 and ### not indented.  If you prefer that lines beginning with comment
   1065 characters are aligned as they are by Emacs/ESS, put in your |vimrc|:
   1066 >
   1067    let r_indent_ess_comments = 1
   1068 <
   1069 If you prefer that lines beginning with a single # are aligned at a column
   1070 different from the 40th one, you should set a new value to the variable
   1071 r_indent_comment_column, as in the example below:
   1072 >
   1073    let r_indent_comment_column = 30
   1074 <
   1075 Any code after a line that ends with "<-" is indented.  Emacs/ESS does not
   1076 indent the code if it is a top-level function.  If you prefer a behavior like
   1077 Emacs/ESS one in this regard, put in your |vimrc|:
   1078 >
   1079    let r_indent_ess_compatible = 1
   1080 <
   1081 Below is an example of indentation with and without this option enabled:
   1082 >
   1083    ### r_indent_ess_compatible = 1           ### r_indent_ess_compatible = 0
   1084    foo <-                                    foo <-
   1085        function(x)                               function(x)
   1086    {                                             {
   1087        paste(x)                                      paste(x)
   1088    }                                             }
   1089 <
   1090 The code will be indented after lines that match the pattern
   1091 `'\(&\||\|+\|-\|\*\|/\|=\|\~\|%\|->\)\s*$'`.  If you want indentation after
   1092 lines that match a different pattern, you should set the appropriate value of
   1093 `r_indent_op_pattern` in your |vimrc|.
   1094 
   1095 
   1096 SHELL							*ft-sh-indent*
   1097 
   1098 The amount of indent applied under various circumstances in a shell file can
   1099 be configured by setting the following keys in the |Dictionary|
   1100 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a
   1101 function that will return the amount desired:
   1102 
   1103 b:sh_indent_options['default']	Default amount of indent.
   1104 
   1105 b:sh_indent_options['continuation-line']
   1106 				Amount of indent to add to a continued line.
   1107 
   1108 b:sh_indent_options['case-labels']
   1109 				Amount of indent to add for case labels.
   1110 				(not actually implemented)
   1111 
   1112 b:sh_indent_options['case-statements']
   1113 				Amount of indent to add for case statements.
   1114 
   1115 b:sh_indent_options['case-breaks']
   1116 				Amount of indent to add (or more likely
   1117 				remove) for case breaks.
   1118 
   1119 VERILOG							*ft-verilog-indent*
   1120 
   1121 General block statements such as if, for, case, always, initial, function,
   1122 specify and begin, etc., are indented.  The module block statements (first
   1123 level blocks) are not indented by default.  you can turn on the indent with
   1124 setting a variable in the .vimrc as follows: >
   1125 
   1126   let b:verilog_indent_modules = 1
   1127 
   1128 then the module blocks will be indented.  To stop this, remove the variable: >
   1129 
   1130   :unlet b:verilog_indent_modules
   1131 
   1132 To set the variable only for Verilog file.  The following statements can be
   1133 used: >
   1134 
   1135   au BufReadPost * if exists("b:current_syntax")
   1136   au BufReadPost *   if b:current_syntax == "verilog"
   1137   au BufReadPost *     let b:verilog_indent_modules = 1
   1138   au BufReadPost *   endif
   1139   au BufReadPost * endif
   1140 
   1141 Furthermore, setting the variable b:verilog_indent_width to change the
   1142 indenting width (default is 'shiftwidth'): >
   1143 
   1144   let b:verilog_indent_width = 4
   1145   let b:verilog_indent_width = shiftwidth() * 2
   1146 
   1147 In addition, you can turn the verbose mode for debug issue: >
   1148 
   1149   let b:verilog_indent_verbose = 1
   1150 
   1151 Make sure to do ":set cmdheight=2" first to allow the display of the message.
   1152 
   1153 
   1154 VHDL							*ft-vhdl-indent*
   1155 
   1156 Alignment of generic/port mapping statements are performed by default.  This
   1157 causes the following alignment example: >
   1158 
   1159   ENTITY sync IS
   1160   PORT (
   1161          clk        : IN  STD_LOGIC;
   1162          reset_n    : IN  STD_LOGIC;
   1163          data_input : IN  STD_LOGIC;
   1164          data_out   : OUT STD_LOGIC
   1165        );
   1166   END ENTITY sync;
   1167 
   1168 To turn this off, add >
   1169 
   1170   let g:vhdl_indent_genportmap = 0
   1171 
   1172 to the .vimrc file, which causes the previous alignment example to change: >
   1173 
   1174   ENTITY sync IS
   1175   PORT (
   1176     clk        : IN  STD_LOGIC;
   1177     reset_n    : IN  STD_LOGIC;
   1178     data_input : IN  STD_LOGIC;
   1179     data_out   : OUT STD_LOGIC
   1180   );
   1181   END ENTITY sync;
   1182 
   1183 ----------------------------------------
   1184 
   1185 Alignment of right-hand side assignment "<=" statements are performed by
   1186 default.  This causes the following alignment example: >
   1187 
   1188   sig_out <= (bus_a(1) AND
   1189              (sig_b OR sig_c)) OR
   1190              (bus_a(0) AND sig_d);
   1191 
   1192 To turn this off, add >
   1193 
   1194   let g:vhdl_indent_rhsassign = 0
   1195 
   1196 to the .vimrc file, which causes the previous alignment example to change: >
   1197 
   1198   sig_out <= (bus_a(1) AND
   1199     (sig_b OR sig_c)) OR
   1200     (bus_a(0) AND sig_d);
   1201 
   1202 ----------------------------------------
   1203 
   1204 Full-line comments (lines that begin with "--") are indented to be aligned
   1205 with the very previous line's comment, PROVIDED that a whitespace follows
   1206 after "--".
   1207 
   1208 For example: >
   1209 
   1210   sig_a <= sig_b; -- start of a comment
   1211                   -- continuation of the comment
   1212                   -- more of the same comment
   1213 
   1214 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F
   1215 will align the current "-- " with the previous line's "--".
   1216 
   1217 If the very previous line does not contain "--", THEN the full-line comment
   1218 will be aligned with the start of the next non-blank line that is NOT a
   1219 full-line comment.
   1220 
   1221 Indenting the following code: >
   1222 
   1223   sig_c <= sig_d; -- comment 0
   1224          -- comment 1
   1225                -- comment 2
   1226     --debug_code:
   1227     --PROCESS(debug_in)
   1228          --BEGIN
   1229             --  FOR i IN 15 DOWNTO 0 LOOP
   1230              --    debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
   1231             --  END LOOP;
   1232      --END PROCESS debug_code;
   1233 
   1234       -- comment 3
   1235   sig_e <= sig_f; -- comment 4
   1236            -- comment 5
   1237 
   1238 results in: >
   1239 
   1240   sig_c <= sig_d; -- comment 0
   1241                   -- comment 1
   1242                   -- comment 2
   1243   --debug_code:
   1244   --PROCESS(debug_in)
   1245   --BEGIN
   1246   --  FOR i IN 15 DOWNTO 0 LOOP
   1247   --    debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i);
   1248   --  END LOOP;
   1249   --END PROCESS debug_code;
   1250 
   1251   -- comment 3
   1252   sig_e <= sig_f; -- comment 4
   1253                   -- comment 5
   1254 
   1255 Notice that "--debug_code:" does not align with "-- comment 2"
   1256 because there is no whitespace that follows after "--" in "--debug_code:".
   1257 
   1258 Given the dynamic nature of indenting comments, indenting should be done
   1259 TWICE.  On the first pass, code will be indented.  On the second pass,
   1260 full-line comments will be indented according to the correctly indented code.
   1261 
   1262 
   1263 VIM							*ft-vim-indent*
   1264 							*g:vim_indent*
   1265 Vim scripts indentation can be configured with the `g:vim_indent` dictionary
   1266 variable.  It supports 3 keys, `line_continuation`, `more_in_bracket_block`,
   1267 and `searchpair_timeout`.
   1268 `line_continuation` expects a number which will be added to the indent level of
   1269 a continuation line starting with a backslash, and defaults to
   1270 `shiftwidth() * 3` .  It also accepts a string, which is evaluated at runtime.
   1271 `more_in_bracket_block` expects a boolean value; when on, an extra
   1272 `shiftwidth()` is added inside blocks surrounded with brackets.  It defaults to
   1273 `v:false`.
   1274 `searchpair_timeout` expects a number which will be passed to `searchpair()` as
   1275 a timeout.  Increasing the value might give more accurate results, but also
   1276 causes the indentation to take more time.  It defaults to 100 (milliseconds).
   1277 
   1278 Example of configuration: >
   1279 
   1280 	let g:vim_indent = #{
   1281 	    \ line_continuation: shiftwidth() * 3,
   1282 	    \ more_in_bracket_block: v:false,
   1283 	    \ searchpair_timeout: 100,
   1284 	    \ }
   1285 <
   1286 							*g:vim_indent_cont*
   1287 This variable is equivalent to `g:vim_indent.line_continuation`.
   1288 It's supported for backward compatibility.
   1289 
   1290 YAML							*ft-yaml-indent*
   1291 
   1292 By default, the yaml indent script does not try to detect multiline scalars.
   1293 If you want to enable this, set the following variable: >
   1294 
   1295   let g:yaml_indent_multiline_scalar = 1
   1296 <
   1297  vim:tw=78:ts=8:noet:ft=help:norl: