Mercurial > vim
annotate runtime/doc/indent.txt @ 28942:6cdf55afaae9 v8.2.4993
patch 8.2.4993: smart/C/lisp indenting is optional
Commit: https://github.com/vim/vim/commit/8e145b82464a21ee4fdf7948f04e2a1d505f8bfa
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat May 21 20:17:31 2022 +0100
patch 8.2.4993: smart/C/lisp indenting is optional
Problem: smart/C/lisp indenting is optional, which makes the code more
complex, while it only reduces the executable size a bit.
Solution: Graduate FEAT_CINDENT, FEAT_SMARTINDENT and FEAT_LISP.
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sat, 21 May 2022 21:30:04 +0200 |
| parents | 6dd88e45d47d |
| children | 3e6e6b4e74eb |
| rev | line source |
|---|---|
| 28379 | 1 *indent.txt* For Vim version 8.2. Last change: 2022 Apr 07 |
| 7 | 2 |
| 3 | |
| 4 VIM REFERENCE MANUAL by Bram Moolenaar | |
| 5 | |
| 6 | |
| 7 This file is about indenting C programs and other files. | |
| 8 | |
| 1620 | 9 1. Indenting C style programs |C-indenting| |
| 7 | 10 2. Indenting by expression |indent-expression| |
| 11 | |
| 12 ============================================================================== | |
| 1620 | 13 1. Indenting C style programs *C-indenting* |
| 7 | 14 |
| 1620 | 15 The basics for C style indenting are explained in section |30.2| of the user |
| 16 manual. | |
| 7 | 17 |
| 1620 | 18 Vim has options for automatically indenting C style program files. Many |
| 19 programming languages including Java and C++ follow very closely the | |
| 20 formatting conventions established with C. These options affect only the | |
| 21 indent and do not perform other formatting. There are additional options that | |
| 22 affect other kinds of formatting as well as indenting, see |format-comments|, | |
| 23 |fo-table|, |gq| and |formatting| for the main ones. | |
| 7 | 24 |
| 1620 | 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': | |
| 7 | 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 | |
| 829 | 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. | |
| 7 | 41 |
|
28353
8bc8071928ed
patch 8.2.4702: C++ scope labels are hard-coded
Bram Moolenaar <Bram@vim.org>
parents:
27492
diff
changeset
|
42 These five options control C program indenting: |
| 7 | 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. | |
|
28353
8bc8071928ed
patch 8.2.4702: C++ scope labels are hard-coded
Bram Moolenaar <Bram@vim.org>
parents:
27492
diff
changeset
|
47 'cinscopedecls' Defines strings that are recognized as a C++ scope declaration. |
| 7 | 48 |
| 49 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using | |
| 50 Vim's built-in algorithm rather than calling an external program. | |
| 51 | |
| 52 See |autocommand| for how to set the 'cindent' option automatically for C code | |
| 53 files and reset it for others. | |
| 54 | |
| 55 *cinkeys-format* *indentkeys-format* | |
| 56 The 'cinkeys' option is a string that controls Vim's indenting in response to | |
| 57 typing certain characters or commands in certain contexts. Note that this not | |
| 58 only triggers C-indenting. When 'indentexpr' is not empty 'indentkeys' is | |
| 59 used instead. The format of 'cinkeys' and 'indentkeys' is equal. | |
| 60 | |
|
15701
9cd11f6beb70
patch 8.1.0858: 'indentkeys' and 'cinkeys' defaults are different
Bram Moolenaar <Bram@vim.org>
parents:
15033
diff
changeset
|
61 The default is "0{,0},0),0],:,0#,!^F,o,O,e" which specifies that indenting |
|
9cd11f6beb70
patch 8.1.0858: 'indentkeys' and 'cinkeys' defaults are different
Bram Moolenaar <Bram@vim.org>
parents:
15033
diff
changeset
|
62 occurs as follows: |
| 7 | 63 |
| 64 "0{" if you type '{' as the first character in a line | |
| 65 "0}" if you type '}' as the first character in a line | |
| 66 "0)" if you type ')' as the first character in a line | |
|
15701
9cd11f6beb70
patch 8.1.0858: 'indentkeys' and 'cinkeys' defaults are different
Bram Moolenaar <Bram@vim.org>
parents:
15033
diff
changeset
|
67 "0]" if you type ']' as the first character in a line |
| 7 | 68 ":" if you type ':' after a label or case statement |
| 69 "0#" if you type '#' as the first character in a line | |
| 70 "!^F" if you type CTRL-F (which is not inserted) | |
| 71 "o" if you type a <CR> anywhere or use the "o" command (not in | |
| 72 insert mode!) | |
| 73 "O" if you use the "O" command (not in insert mode!) | |
| 74 "e" if you type the second 'e' for an "else" at the start of a | |
| 75 line | |
| 76 | |
| 818 | 77 Characters that can precede each key: *i_CTRL-F* |
| 7 | 78 ! When a '!' precedes the key, Vim will not insert the key but will |
| 79 instead reindent the current line. This allows you to define a | |
| 80 command key for reindenting the current line. CTRL-F is the default | |
| 81 key for this. Be careful if you define CTRL-I for this because CTRL-I | |
| 82 is the ASCII code for <Tab>. | |
| 83 * When a '*' precedes the key, Vim will reindent the line before | |
| 84 inserting the key. If 'cinkeys' contains "*<Return>", Vim reindents | |
| 85 the current line before opening a new line. | |
| 86 0 When a zero precedes the key (but appears after '!' or '*') Vim will | |
| 87 reindent the line only if the key is the first character you type in | |
| 88 the line. When used before "=" Vim will only reindent the line if | |
| 89 there is only white space before the word. | |
| 90 | |
| 91 When neither '!' nor '*' precedes the key, Vim reindents the line after you | |
| 92 type the key. So ';' sets the indentation of a line which includes the ';'. | |
| 93 | |
| 94 Special key names: | |
| 95 <> Angle brackets mean spelled-out names of keys. For example: "<Up>", | |
| 96 "<Ins>" (see |key-notation|). | |
| 97 ^ Letters preceded by a caret (^) are control characters. For example: | |
| 98 "^F" is CTRL-F. | |
| 99 o Reindent a line when you use the "o" command or when Vim opens a new | |
| 100 line below the current one (e.g., when you type <Enter> in insert | |
| 101 mode). | |
| 102 O Reindent a line when you use the "O" command. | |
| 103 e Reindent a line that starts with "else" when you type the second 'e'. | |
| 104 : Reindent a line when a ':' is typed which is after a label or case | |
| 105 statement. Don't reindent for a ":" in "class::method" for C++. To | |
| 106 Reindent for any ":", use "<:>". | |
| 107 =word Reindent when typing the last character of "word". "word" may | |
| 108 actually be part of another word. Thus "=end" would cause reindenting | |
| 109 when typing the "d" in "endif" or "endwhile". But not when typing | |
| 110 "bend". Also reindent when completion produces a word that starts | |
| 111 with "word". "0=word" reindents when there is only white space before | |
| 112 the word. | |
| 113 =~word Like =word, but ignore case. | |
| 114 | |
| 115 If you really want to reindent when you type 'o', 'O', 'e', '0', '<', '>', | |
| 116 '*', ':' or '!', use "<o>", "<O>", "<e>", "<0>", "<<>", "<>>", "<*>", "<:>" or | |
| 117 "<!>", respectively, for those keys. | |
| 118 | |
| 119 For an emacs-style indent mode where lines aren't indented every time you | |
| 1247 | 120 press <Enter> but only if you press <Tab>, I suggest: |
| 7 | 121 :set cinkeys=0{,0},:,0#,!<Tab>,!^F |
| 122 You might also want to switch off 'autoindent' then. | |
| 123 | |
| 124 Note: If you change the current line's indentation manually, Vim ignores the | |
| 125 cindent settings for that line. This prevents vim from reindenting after you | |
| 126 have changed the indent by typing <BS>, <Tab>, or <Space> in the indent or | |
| 127 used CTRL-T or CTRL-D. | |
| 128 | |
| 129 *cinoptions-values* | |
| 2857 | 130 The 'cinoptions' option sets how Vim performs indentation. The value after |
| 131 the option character can be one of these (N is any number): | |
| 132 N indent N spaces | |
| 133 -N indent N spaces to the left | |
| 3082 | 134 Ns N times 'shiftwidth' spaces |
| 135 -Ns N times 'shiftwidth' spaces to the left | |
| 2857 | 136 |
| 137 In the list below, | |
| 7 | 138 "N" represents a number of your choice (the number can be negative). When |
| 139 there is an 's' after the number, Vim multiplies the number by 'shiftwidth': | |
| 140 "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. You can use a | |
| 2857 | 141 decimal point, too: "-0.5s" is minus half a 'shiftwidth'. |
| 142 The examples below assume a 'shiftwidth' of 4. | |
| 143 *cino->* | |
| 7 | 144 >N Amount added for "normal" indent. Used after a line that should |
| 145 increase the indent (lines starting with "if", an opening brace, | |
| 146 etc.). (default 'shiftwidth'). | |
| 147 | |
| 148 cino= cino=>2 cino=>2s > | |
| 149 if (cond) if (cond) if (cond) | |
| 150 { { { | |
| 151 foo; foo; foo; | |
| 152 } } } | |
| 153 < | |
| 2857 | 154 *cino-e* |
| 7 | 155 eN Add N to the prevailing indent inside a set of braces if the |
| 156 opening brace at the End of the line (more precise: is not the | |
| 157 first character in a line). This is useful if you want a | |
| 158 different indent when the '{' is at the start of the line from | |
| 159 when '{' is at the end of the line. (default 0). | |
| 160 | |
| 161 cino= cino=e2 cino=e-2 > | |
| 162 if (cond) { if (cond) { if (cond) { | |
| 163 foo; foo; foo; | |
| 164 } } } | |
| 165 else else else | |
| 166 { { { | |
| 167 bar; bar; bar; | |
| 168 } } } | |
| 169 < | |
| 2857 | 170 *cino-n* |
| 7 | 171 nN Add N to the prevailing indent for a statement after an "if", |
| 172 "while", etc., if it is NOT inside a set of braces. This is | |
| 173 useful if you want a different indent when there is no '{' | |
| 174 before the statement from when there is a '{' before it. | |
| 175 (default 0). | |
| 176 | |
| 177 cino= cino=n2 cino=n-2 > | |
| 178 if (cond) if (cond) if (cond) | |
| 179 foo; foo; foo; | |
| 180 else else else | |
| 181 { { { | |
| 182 bar; bar; bar; | |
| 183 } } } | |
| 184 < | |
| 2857 | 185 *cino-f* |
| 7 | 186 fN Place the first opening brace of a function or other block in |
| 187 column N. This applies only for an opening brace that is not | |
| 188 inside other braces and is at the start of the line. What comes | |
| 189 after the brace is put relative to this brace. (default 0). | |
| 190 | |
| 191 cino= cino=f.5s cino=f1s > | |
| 192 func() func() func() | |
| 193 { { { | |
| 194 int foo; int foo; int foo; | |
| 195 < | |
| 2857 | 196 *cino-{* |
| 7 | 197 {N Place opening braces N characters from the prevailing indent. |
| 198 This applies only for opening braces that are inside other | |
| 199 braces. (default 0). | |
| 200 | |
| 201 cino= cino={.5s cino={1s > | |
| 202 if (cond) if (cond) if (cond) | |
| 203 { { { | |
| 204 foo; foo; foo; | |
| 205 < | |
| 2857 | 206 *cino-}* |
| 7 | 207 }N Place closing braces N characters from the matching opening |
| 208 brace. (default 0). | |
| 209 | |
| 210 cino= cino={2,}-0.5s cino=}2 > | |
| 211 if (cond) if (cond) if (cond) | |
| 212 { { { | |
| 213 foo; foo; foo; | |
| 214 } } } | |
| 215 < | |
| 2857 | 216 *cino-^* |
| 7 | 217 ^N Add N to the prevailing indent inside a set of braces if the |
| 218 opening brace is in column 0. This can specify a different | |
| 219 indent for whole of a function (some may like to set it to a | |
| 220 negative number). (default 0). | |
| 221 | |
| 222 cino= cino=^-2 cino=^-s > | |
| 223 func() func() func() | |
| 224 { { { | |
| 225 if (cond) if (cond) if (cond) | |
| 226 { { { | |
| 227 a = b; a = b; a = b; | |
| 228 } } } | |
| 229 } } } | |
| 230 < | |
| 2857 | 231 *cino-L* |
|
2328
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
232 LN Controls placement of jump labels. If N is negative, the label |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
233 will be placed at column 1. If N is non-negative, the indent of |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
234 the label will be the prevailing indent minus N. (default -1). |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
235 |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
236 cino= cino=L2 cino=Ls > |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
237 func() func() func() |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
238 { { { |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
239 { { { |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
240 stmt; stmt; stmt; |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
241 LABEL: LABEL: LABEL: |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
242 } } } |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
243 } } } |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
244 < |
| 2857 | 245 *cino-:* |
| 7 | 246 :N Place case labels N characters from the indent of the switch(). |
| 247 (default 'shiftwidth'). | |
| 248 | |
| 249 cino= cino=:0 > | |
| 250 switch (x) switch(x) | |
| 251 { { | |
| 252 case 1: case 1: | |
| 253 a = b; a = b; | |
| 254 default: default: | |
| 255 } } | |
| 256 < | |
| 2857 | 257 *cino-=* |
| 7 | 258 =N Place statements occurring after a case label N characters from |
| 259 the indent of the label. (default 'shiftwidth'). | |
| 260 | |
| 261 cino= cino==10 > | |
| 262 case 11: case 11: a = a + 1; | |
| 263 a = a + 1; b = b + 1; | |
| 264 < | |
| 2857 | 265 *cino-l* |
| 7 | 266 lN If N != 0 Vim will align with a case label instead of the |
| 267 statement after it in the same line. | |
| 268 | |
| 269 cino= cino=l1 > | |
| 270 switch (a) { switch (a) { | |
| 271 case 1: { case 1: { | |
| 272 break; break; | |
| 273 } } | |
| 274 < | |
| 2857 | 275 *cino-b* |
| 7 | 276 bN If N != 0 Vim will align a final "break" with the case label, |
| 236 | 277 so that case..break looks like a sort of block. (default: 0). |
| 2662 | 278 When using 1, consider adding "0=break" to 'cinkeys'. |
| 7 | 279 |
| 280 cino= cino=b1 > | |
| 281 switch (x) switch(x) | |
| 282 { { | |
| 283 case 1: case 1: | |
| 284 a = b; a = b; | |
| 285 break; break; | |
| 286 | |
| 287 default: default: | |
| 288 a = 0; a = 0; | |
| 289 break; break; | |
| 290 } } | |
| 291 < | |
| 2857 | 292 *cino-g* |
| 7 | 293 gN Place C++ scope declarations N characters from the indent of the |
|
28353
8bc8071928ed
patch 8.2.4702: C++ scope labels are hard-coded
Bram Moolenaar <Bram@vim.org>
parents:
27492
diff
changeset
|
294 block they are in. (default 'shiftwidth'). By default, a scope |
|
8bc8071928ed
patch 8.2.4702: C++ scope labels are hard-coded
Bram Moolenaar <Bram@vim.org>
parents:
27492
diff
changeset
|
295 declaration is "public:", "protected:" or "private:". This can |
|
8bc8071928ed
patch 8.2.4702: C++ scope labels are hard-coded
Bram Moolenaar <Bram@vim.org>
parents:
27492
diff
changeset
|
296 be adjusted with the 'cinscopedecls' option. |
| 7 | 297 |
| 298 cino= cino=g0 > | |
| 299 { { | |
| 300 public: public: | |
| 301 a = b; a = b; | |
| 302 private: private: | |
| 303 } } | |
| 304 < | |
| 2857 | 305 *cino-h* |
| 7 | 306 hN Place statements occurring after a C++ scope declaration N |
| 307 characters from the indent of the label. (default | |
| 308 'shiftwidth'). | |
| 309 | |
| 310 cino= cino=h10 > | |
| 311 public: public: a = a + 1; | |
| 312 a = a + 1; b = b + 1; | |
| 313 < | |
| 2857 | 314 *cino-N* |
| 315 NN Indent inside C++ namespace N characters extra compared to a | |
| 316 normal block. (default 0). | |
| 317 | |
| 318 cino= cino=N-s > | |
| 319 namespace { namespace { | |
| 320 void function(); void function(); | |
| 321 } } | |
| 322 | |
| 323 namespace my namespace my | |
| 324 { { | |
| 325 void function(); void function(); | |
| 326 } } | |
| 327 < | |
|
11087
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
328 *cino-E* |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
329 EN Indent inside C++ linkage specifications (extern "C" or |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
330 extern "C++") N characters extra compared to a normal block. |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
331 (default 0). |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
332 |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
333 cino= cino=E-s > |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
334 extern "C" { extern "C" { |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
335 void function(); void function(); |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
336 } } |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
337 |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
338 extern "C" extern "C" |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
339 { { |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
340 void function(); void function(); |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
341 } } |
|
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
342 < |
| 2857 | 343 *cino-p* |
| 7 | 344 pN Parameter declarations for K&R-style function declarations will |
| 345 be indented N characters from the margin. (default | |
| 346 'shiftwidth'). | |
| 347 | |
| 348 cino= cino=p0 cino=p2s > | |
| 349 func(a, b) func(a, b) func(a, b) | |
| 350 int a; int a; int a; | |
| 351 char b; char b; char b; | |
| 352 < | |
| 2857 | 353 *cino-t* |
| 7 | 354 tN Indent a function return type declaration N characters from the |
| 355 margin. (default 'shiftwidth'). | |
| 356 | |
| 357 cino= cino=t0 cino=t7 > | |
| 358 int int int | |
| 359 func() func() func() | |
| 360 < | |
| 2857 | 361 *cino-i* |
| 843 | 362 iN Indent C++ base class declarations and constructor |
| 7 | 363 initializations, if they start in a new line (otherwise they |
| 364 are aligned at the right side of the ':'). | |
| 365 (default 'shiftwidth'). | |
| 366 | |
| 367 cino= cino=i0 > | |
| 368 class MyClass : class MyClass : | |
| 369 public BaseClass public BaseClass | |
| 370 {} {} | |
| 371 MyClass::MyClass() : MyClass::MyClass() : | |
| 372 BaseClass(3) BaseClass(3) | |
| 373 {} {} | |
| 374 < | |
| 2857 | 375 *cino-+* |
| 2725 | 376 +N Indent a continuation line (a line that spills onto the next) |
| 377 inside a function N additional characters. (default | |
| 378 'shiftwidth'). | |
| 379 Outside of a function, when the previous line ended in a | |
| 380 backslash, the 2 * N is used. | |
| 7 | 381 |
| 382 cino= cino=+10 > | |
| 383 a = b + 9 * a = b + 9 * | |
| 384 c; c; | |
| 385 < | |
| 2857 | 386 *cino-c* |
| 7 | 387 cN Indent comment lines after the comment opener, when there is no |
| 388 other text with which to align, N characters from the comment | |
| 389 opener. (default 3). See also |format-comments|. | |
| 390 | |
| 391 cino= cino=c5 > | |
| 392 /* /* | |
| 393 text. text. | |
| 394 */ */ | |
| 395 < | |
| 2857 | 396 *cino-C* |
| 7 | 397 CN When N is non-zero, indent comment lines by the amount specified |
| 398 with the c flag above even if there is other text behind the | |
| 399 comment opener. (default 0). | |
| 400 | |
| 401 cino=c0 cino=c0,C1 > | |
| 402 /******** /******** | |
| 403 text. text. | |
| 404 ********/ ********/ | |
| 405 < (Example uses ":set comments& comments-=s1:/* comments^=s0:/*") | |
| 406 | |
| 2857 | 407 *cino-/* |
| 236 | 408 /N Indent comment lines N characters extra. (default 0). |
| 7 | 409 cino= cino=/4 > |
| 410 a = b; a = b; | |
| 411 /* comment */ /* comment */ | |
| 412 c = d; c = d; | |
| 413 < | |
| 2857 | 414 *cino-(* |
| 7 | 415 (N When in unclosed parentheses, indent N characters from the line |
| 21676 | 416 with the unclosed parenthesis. Add a 'shiftwidth' for every |
| 13589 | 417 extra unclosed parentheses. When N is 0 or the unclosed |
| 21676 | 418 parenthesis is the first non-white character in its line, line |
| 13589 | 419 up with the next non-white character after the unclosed |
| 21676 | 420 parenthesis. (default 'shiftwidth' * 2). |
| 7 | 421 |
| 422 cino= cino=(0 > | |
| 423 if (c1 && (c2 || if (c1 && (c2 || | |
| 424 c3)) c3)) | |
| 425 foo; foo; | |
| 426 if (c1 && if (c1 && | |
| 427 (c2 || c3)) (c2 || c3)) | |
| 428 { { | |
| 429 < | |
| 2857 | 430 *cino-u* |
| 13589 | 431 uN Same as (N, but for one nesting level deeper. |
| 432 (default 'shiftwidth'). | |
| 7 | 433 |
| 434 cino= cino=u2 > | |
| 435 if (c123456789 if (c123456789 | |
| 436 && (c22345 && (c22345 | |
| 437 || c3)) || c3)) | |
| 438 < | |
| 2857 | 439 *cino-U* |
| 7 | 440 UN When N is non-zero, do not ignore the indenting specified by |
| 21676 | 441 ( or u in case that the unclosed parenthesis is the first |
| 7 | 442 non-white character in its line. (default 0). |
| 443 | |
| 444 cino= or cino=(s cino=(s,U1 > | |
| 445 c = c1 && c = c1 && | |
| 446 ( ( | |
| 447 c2 || c2 || | |
| 448 c3 c3 | |
| 449 ) && c4; ) && c4; | |
| 450 < | |
| 3082 | 451 *cino-w* |
| 7 | 452 wN When in unclosed parentheses and N is non-zero and either |
| 453 using "(0" or "u0", respectively, or using "U0" and the unclosed | |
| 21676 | 454 parenthesis is the first non-white character in its line, line |
| 455 up with the character immediately after the unclosed parenthesis | |
| 7 | 456 rather than the first non-white character. (default 0). |
| 457 | |
| 458 cino=(0 cino=(0,w1 > | |
| 459 if ( c1 if ( c1 | |
| 460 && ( c2 && ( c2 | |
| 461 || c3)) || c3)) | |
| 462 foo; foo; | |
| 463 < | |
| 2857 | 464 *cino-W* |
| 7 | 465 WN When in unclosed parentheses and N is non-zero and either |
| 21676 | 466 using "(0" or "u0", respectively and the unclosed parenthesis is |
| 7 | 467 the last non-white character in its line and it is not the |
| 21676 | 468 closing parenthesis, indent the following line N characters |
| 7 | 469 relative to the outer context (i.e. start of the line or the |
| 21676 | 470 next unclosed parenthesis). (default: 0). |
| 7 | 471 |
| 472 cino=(0 cino=(0,W4 > | |
| 473 a_long_line( a_long_line( | |
| 474 argument, argument, | |
| 475 argument); argument); | |
| 476 a_short_line(argument, a_short_line(argument, | |
| 477 argument); argument); | |
| 478 < | |
| 3454 | 479 *cino-k* |
| 480 kN When in unclosed parentheses which follow "if", "for" or | |
| 481 "while" and N is non-zero, overrides the behaviour defined by | |
| 482 "(N": causes the indent to be N characters relative to the outer | |
| 483 context (i.e. the line where "if", "for" or "while" is). Has | |
| 484 no effect on deeper levels of nesting. Affects flags like "wN" | |
| 485 only for the "if", "for" and "while" conditions. If 0, defaults | |
| 486 to behaviour defined by the "(N" flag. (default: 0). | |
| 487 | |
| 488 cino=(0 cino=(0,ks > | |
| 489 if (condition1 if (condition1 | |
| 490 && condition2) && condition2) | |
| 491 action(); action(); | |
| 492 function(argument1 function(argument1 | |
| 493 && argument2); && argument2); | |
| 494 < | |
| 2857 | 495 *cino-m* |
| 7 | 496 mN When N is non-zero, line up a line starting with a closing |
| 21676 | 497 parenthesis with the first character of the line with the |
| 498 matching opening parenthesis. (default 0). | |
| 7 | 499 |
| 500 cino=(s cino=(s,m1 > | |
| 501 c = c1 && ( c = c1 && ( | |
| 502 c2 || c2 || | |
| 503 c3 c3 | |
| 504 ) && c4; ) && c4; | |
| 505 if ( if ( | |
| 506 c1 && c2 c1 && c2 | |
| 507 ) ) | |
| 508 foo; foo; | |
| 509 < | |
| 2857 | 510 *cino-M* |
| 829 | 511 MN When N is non-zero, line up a line starting with a closing |
| 21676 | 512 parenthesis with the first character of the previous line. |
| 829 | 513 (default 0). |
| 514 | |
| 515 cino= cino=M1 > | |
| 516 if (cond1 && if (cond1 && | |
| 856 | 517 cond2 cond2 |
| 518 ) ) | |
| 829 | 519 < |
| 2857 | 520 *java-cinoptions* *java-indenting* *cino-j* |
| 2965 | 521 jN Indent Java anonymous classes correctly. Also works well for |
| 522 Javascript. The value 'N' is currently unused but must be | |
| 523 non-zero (e.g. 'j1'). 'j1' will indent for example the | |
| 524 following code snippet correctly: > | |
| 7 | 525 |
| 526 object.add(new ChangeListener() { | |
| 527 public void stateChanged(ChangeEvent e) { | |
| 528 do_something(); | |
| 529 } | |
| 530 }); | |
| 531 < | |
| 2857 | 532 *javascript-cinoptions* *javascript-indenting* *cino-J* |
|
2297
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
533 JN Indent JavaScript object declarations correctly by not confusing |
| 18831 | 534 them with labels. The value 'N' is currently unused but must be |
| 2965 | 535 non-zero (e.g. 'J1'). If you enable this you probably also want |
| 536 to set |cino-j|. > | |
|
2297
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
537 |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
538 var bar = { |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
539 foo: { |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
540 that: this, |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
541 some: ok, |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
542 }, |
| 18831 | 543 "bar":{ |
|
2297
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
544 a : 2, |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
545 b: "123abc", |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
546 x: 4, |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
547 "y": 5 |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
548 } |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
549 } |
|
5ffe000a9ecf
Improve Javascript indenting. Add "J" flag to 'cino'. (Hari Kumar G)
Bram Moolenaar <bram@vim.org>
parents:
2278
diff
changeset
|
550 < |
| 2857 | 551 *cino-)* |
| 7 | 552 )N Vim searches for unclosed parentheses at most N lines away. |
| 553 This limits the time needed to search for parentheses. (default | |
| 554 20 lines). | |
| 555 | |
| 2857 | 556 *cino-star* |
| 7 | 557 *N Vim searches for unclosed comments at most N lines away. This |
| 558 limits the time needed to search for the start of a comment. | |
| 3830 | 559 If your /* */ comments stop indenting after N lines this is the |
| 2788 | 560 value you will want to change. |
| 2072 | 561 (default 70 lines). |
| 7 | 562 |
| 2857 | 563 *cino-#* |
| 5438 | 564 #N When N is non-zero recognize shell/Perl comments starting with |
| 565 '#', do not recognize preprocessor lines; allow right-shifting | |
| 566 lines that start with "#". | |
| 567 When N is zero (default): don't recognize '#' comments, do | |
| 568 recognize preprocessor lines; right-shifting lines that start | |
| 569 with "#" does not work. | |
| 1096 | 570 |
| 21676 | 571 *cino-P* |
|
20621
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
572 PN When N is non-zero recognize C pragmas, and indent them like any |
|
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
573 other code; does not concern other preprocessor directives. |
|
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
574 When N is zero (default): don't recognize C pragmas, treating |
|
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
575 them like every other preprocessor directive. |
|
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
576 |
|
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
577 |
| 7 | 578 The defaults, spelled out in full, are: |
|
11087
242e0617aa51
patch 8.0.0431: 'cinoptions' cannot set indent for extern block
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
579 cinoptions=>s,e0,n0,f0,{0,}0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,E0,ps,ts,is,+s, |
|
20621
d30b16692ce0
patch 8.2.0864: pragmas are indented all the way to the left
Bram Moolenaar <Bram@vim.org>
parents:
18879
diff
changeset
|
580 c3,C0,/0,(2s,us,U0,w0,W0,k0,m0,j0,J0,)20,*70,#0,P0 |
| 7 | 581 |
| 582 Vim puts a line in column 1 if: | |
| 5438 | 583 - It starts with '#' (preprocessor directives), if 'cinkeys' contains '#0'. |
| 7 | 584 - It starts with a label (a keyword followed by ':', other than "case" and |
|
2328
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
585 "default") and 'cinoptions' does not contain an 'L' entry with a positive |
|
15379284e55a
Add the 'L' item to 'cinoptions'. (Manuel Konig)
Bram Moolenaar <bram@vim.org>
parents:
2297
diff
changeset
|
586 value. |
| 7 | 587 - Any combination of indentations causes the line to have less than 0 |
| 588 indentation. | |
| 589 | |
| 590 ============================================================================== | |
| 591 2. Indenting by expression *indent-expression* | |
| 592 | |
| 593 The basics for using flexible indenting are explained in section |30.3| of the | |
| 594 user manual. | |
| 595 | |
| 596 If you want to write your own indent file, it must set the 'indentexpr' | |
| 14999 | 597 option. Setting the 'indentkeys' option is often useful. |
| 598 See the $VIMRUNTIME/indent/README.txt file for hints. | |
| 599 See the $VIMRUNTIME/indent directory for examples. | |
| 7 | 600 |
| 601 | |
| 602 REMARKS ABOUT SPECIFIC INDENT FILES ~ | |
| 603 | |
| 604 | |
| 4098 | 605 CLOJURE *ft-clojure-indent* *clojure-indent* |
| 606 | |
| 607 Clojure indentation differs somewhat from traditional Lisps, due in part to | |
| 608 the use of square and curly brackets, and otherwise by community convention. | |
|
5362
ab1508486b12
Update runtime files. Add support for J.
Bram Moolenaar <bram@vim.org>
parents:
5294
diff
changeset
|
609 These conventions are not universally followed, so the Clojure indent script |
| 26100 | 610 offers a few configuration options. |
| 4098 | 611 |
| 26100 | 612 (If the current Vim does not include |searchpairpos()|, the indent script falls |
| 613 back to normal 'lisp' indenting, and the following options are ignored.) | |
| 614 | |
| 4098 | 615 |
| 616 *g:clojure_maxlines* | |
| 617 | |
| 26100 | 618 Sets maximum scan distance of `searchpairpos()`. Larger values trade |
| 619 performance for correctness when dealing with very long forms. A value of | |
| 620 0 will scan without limits. The default is 300. | |
| 621 | |
| 622 | |
| 4098 | 623 *g:clojure_fuzzy_indent* |
| 624 *g:clojure_fuzzy_indent_patterns* | |
| 625 *g:clojure_fuzzy_indent_blacklist* | |
| 626 | |
| 627 The 'lispwords' option is a list of comma-separated words that mark special | |
| 26100 | 628 forms whose subforms should be indented with two spaces. |
| 4098 | 629 |
| 630 For example: | |
| 631 > | |
| 632 (defn bad [] | |
| 633 "Incorrect indentation") | |
| 634 | |
| 635 (defn good [] | |
| 636 "Correct indentation") | |
| 637 < | |
| 638 If you would like to specify 'lispwords' with a |pattern| instead, you can use | |
| 639 the fuzzy indent feature: | |
| 640 > | |
| 641 " Default | |
| 642 let g:clojure_fuzzy_indent = 1 | |
| 643 let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let'] | |
| 644 let g:clojure_fuzzy_indent_blacklist = | |
| 645 \ ['-fn$', '\v^with-%(meta|out-str|loading-context)$'] | |
| 646 < | |
| 647 |g:clojure_fuzzy_indent_patterns| and |g:clojure_fuzzy_indent_blacklist| are | |
| 26100 | 648 lists of patterns that will be matched against the unqualified symbol at the |
| 649 head of a list. This means that a pattern like `"^foo"` will match all these | |
| 650 candidates: `foobar`, `my.ns/foobar`, and `#'foobar`. | |
| 4098 | 651 |
| 652 Each candidate word is tested for special treatment in this order: | |
| 653 | |
| 654 1. Return true if word is literally in 'lispwords' | |
| 655 2. Return false if word matches a pattern in | |
| 656 |g:clojure_fuzzy_indent_blacklist| | |
| 657 3. Return true if word matches a pattern in | |
| 658 |g:clojure_fuzzy_indent_patterns| | |
| 659 4. Return false and indent normally otherwise | |
| 660 | |
| 26100 | 661 |
| 4098 | 662 *g:clojure_special_indent_words* |
| 663 | |
| 26100 | 664 Some forms in Clojure are indented such that every subform is indented by only |
| 665 two spaces, regardless of 'lispwords'. If you have a custom construct that | |
| 666 should be indented in this idiosyncratic fashion, you can add your symbols to | |
| 667 the default list below. | |
| 4098 | 668 > |
| 669 " Default | |
| 670 let g:clojure_special_indent_words = | |
| 671 \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn' | |
| 672 < | |
| 26100 | 673 |
| 4098 | 674 *g:clojure_align_multiline_strings* |
| 675 | |
| 26100 | 676 Align subsequent lines in multi-line strings to the column after the opening |
| 4098 | 677 quote, instead of the same column. |
| 678 | |
| 679 For example: | |
| 680 > | |
| 681 (def default | |
| 682 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do | |
| 683 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut | |
| 684 enim ad minim veniam, quis nostrud exercitation ullamco laboris | |
| 685 nisi ut aliquip ex ea commodo consequat.") | |
| 686 | |
| 687 (def aligned | |
| 688 "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do | |
| 689 eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut | |
| 690 enim ad minim veniam, quis nostrud exercitation ullamco laboris | |
| 691 nisi ut aliquip ex ea commodo consequat.") | |
| 692 < | |
| 26100 | 693 |
| 5577 | 694 *g:clojure_align_subforms* |
| 695 | |
| 696 By default, parenthesized compound forms that look like function calls and | |
| 697 whose head subform is on its own line have subsequent subforms indented by | |
| 698 two spaces relative to the opening paren: | |
| 699 > | |
| 700 (foo | |
| 701 bar | |
| 702 baz) | |
| 703 < | |
| 26100 | 704 Setting this option to `1` changes this behaviour so that all subforms are |
| 705 aligned to the same column, emulating the default behaviour of | |
| 706 clojure-mode.el: | |
| 5577 | 707 > |
| 708 (foo | |
| 709 bar | |
| 710 baz) | |
| 711 < | |
| 4098 | 712 |
| 501 | 713 FORTRAN *ft-fortran-indent* |
| 7 | 714 |
| 2908 | 715 Block if, select case, where, and forall constructs are indented. So are |
| 716 type, interface, associate, block, and enum constructs. The indenting of | |
| 717 subroutines, functions, modules, and program blocks is optional. Comments, | |
| 718 labelled statements and continuation lines are indented if the Fortran is in | |
| 719 free source form, whereas they are not indented if the Fortran is in fixed | |
| 720 source form because of the left margin requirements. Hence manual indent | |
| 721 corrections will be necessary for labelled statements and continuation lines | |
| 722 when fixed source form is being used. For further discussion of the method | |
| 723 used for the detection of source format see |ft-fortran-syntax|. | |
| 7 | 724 |
| 725 Do loops ~ | |
| 236 | 726 All do loops are left unindented by default. Do loops can be unstructured in |
| 7 | 727 Fortran with (possibly multiple) loops ending on a labelled executable |
| 236 | 728 statement of almost arbitrary type. Correct indentation requires |
| 729 compiler-quality parsing. Old code with do loops ending on labelled statements | |
| 7 | 730 of arbitrary type can be indented with elaborate programs such as Tidy |
| 236 | 731 (http://www.unb.ca/chem/ajit/f_tidy.htm). Structured do/continue loops are |
| 7 | 732 also left unindented because continue statements are also used for purposes |
| 236 | 733 other than ending a do loop. Programs such as Tidy can convert structured |
| 734 do/continue loops to the do/enddo form. Do loops of the do/enddo variety can | |
| 735 be indented. If you use only structured loops of the do/enddo form, you should | |
| 7 | 736 declare this by setting the fortran_do_enddo variable in your .vimrc as |
| 737 follows > | |
| 738 | |
| 739 let fortran_do_enddo=1 | |
| 740 | |
| 236 | 741 in which case do loops will be indented. If all your loops are of do/enddo |
| 7 | 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 | |
| 2908 | 750 Program units ~ |
| 751 The indenting of program units (subroutines, functions, modules, and program | |
| 752 blocks) is enabled by default but can be suppressed if a lighter, screen-width | |
| 753 preserving indent style is desired. To suppress the indenting of program | |
| 754 units for all fortran files set the global fortran_indent_less variable in | |
| 755 your .vimrc as follows > | |
| 756 | |
| 757 let fortran_indent_less=1 | |
| 758 | |
| 759 A finer level of suppression can be achieved by setting the corresponding | |
| 760 buffer-local variable as follows > | |
| 761 | |
| 762 let b:fortran_indent_less=1 | |
| 763 | |
| 7 | 764 |
| 4869 | 765 HTML *ft-html-indent* *html-indent* *html-indenting* |
| 766 | |
| 767 This is about variables you can set in your vimrc to customize HTML indenting. | |
| 768 | |
| 769 You can set the indent for the first line after <script> and <style> | |
| 770 "blocktags" (default "zero"): > | |
| 771 | |
| 772 :let g:html_indent_script1 = "inc" | |
| 773 :let g:html_indent_style1 = "inc" | |
| 774 < | |
| 775 VALUE MEANING ~ | |
| 776 "zero" zero indent | |
| 777 "auto" auto indent (same indent as the blocktag) | |
| 778 "inc" auto indent + one indent step | |
| 779 | |
| 27492 | 780 You can set the indent for attributes after an open <tag line: > |
| 781 | |
| 782 :let g:html_indent_attribute = 1 | |
| 783 < | |
| 784 VALUE MEANING ~ | |
| 785 1 auto indent, one indent step more than <tag | |
| 786 2 auto indent, two indent steps (default) | |
| 787 > 2 auto indent, more indent steps | |
| 788 | |
| 4869 | 789 Many tags increase the indent for what follows per default (see "Add Indent |
| 4911 | 790 Tags" in the script). You can add further tags with: > |
| 4869 | 791 |
| 792 :let g:html_indent_inctags = "html,body,head,tbody" | |
| 793 | |
| 794 You can also remove such tags with: > | |
| 795 | |
| 796 :let g:html_indent_autotags = "th,td,tr,tfoot,thead" | |
| 797 | |
| 798 Default value is empty for both variables. Note: the initial "inctags" are | |
| 799 only defined once per Vim session. | |
| 800 | |
| 801 User variables are only read when the script is sourced. To enable your | |
| 4911 | 802 changes during a session, without reloading the HTML file, you can manually |
| 4869 | 803 do: > |
| 804 | |
| 805 :call HtmlIndent_CheckUserSettings() | |
| 806 | |
| 807 Detail: | |
| 808 Calculation of indent inside "blocktags" with "alien" content: | |
| 809 BLOCKTAG INDENT EXPR WHEN APPLICABLE ~ | |
| 4911 | 810 <script> : {customizable} if first line of block |
| 811 : cindent(v:lnum) if attributes empty or contain "java" | |
| 812 : -1 else (vbscript, tcl, ...) | |
| 813 <style> : {customizable} if first line of block | |
| 814 : GetCSSIndent() else | |
| 4869 | 815 <!-- --> : -1 |
| 816 | |
| 817 | |
| 18848 | 818 MATLAB *ft-matlab-indent* *matlab-indent* *matlab-indenting* |
| 819 | |
| 820 The setting Function indenting format in MATLAB Editor/Debugger Language | |
| 821 Preferences corresponds to: > | |
| 822 :let g:MATLAB_function_indent = {0, 1 or 2 (default)} | |
| 823 | |
| 824 Where 0 is for Classic, 1 for Indent nested functions and 2 for Indent all | |
| 825 functions. | |
| 826 | |
| 827 | |
| 1668 | 828 PHP *ft-php-indent* *php-indent* *php-indenting* |
| 829 | |
| 830 NOTE: PHP files will be indented correctly only if PHP |syntax| is active. | |
| 831 | |
| 832 If you are editing a file in Unix 'fileformat' and '\r' characters are present | |
| 833 before new lines, indentation won't proceed correctly ; you have to remove | |
| 834 those useless characters first with a command like: > | |
| 835 | |
| 836 :%s /\r$//g | |
| 837 | |
| 838 Or, you can simply |:let| the variable PHP_removeCRwhenUnix to 1 and the | |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
839 script will silently remove them when Vim loads a PHP file (at each |BufRead|). |
| 1668 | 840 |
| 841 OPTIONS: ~ | |
| 842 | |
| 843 PHP indenting can be altered in several ways by modifying the values of some | |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
844 global variables: |
| 1668 | 845 |
| 5862 | 846 *php-comment* *PHP_autoformatcomment* |
| 17667 | 847 To not enable auto-formatting of comments by default (if you want to use your |
| 1668 | 848 own 'formatoptions'): > |
| 849 :let g:PHP_autoformatcomment = 0 | |
| 850 | |
| 851 Else, 't' will be removed from the 'formatoptions' string and "qrowcb" will be | |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
852 added, see |fo-table| for more information. |
| 1668 | 853 ------------- |
| 854 | |
| 5862 | 855 *PHP_outdentSLComments* |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
856 To add extra indentation to single-line comments: > |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
857 :let g:PHP_outdentSLComments = N |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
858 |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
859 With N being the number of 'shiftwidth' to add. |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
860 |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
861 Only single-line comments will be affected such as: > |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
862 # Comment |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
863 // Comment |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
864 /* Comment */ |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
865 ------------- |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
866 |
| 5862 | 867 *PHP_default_indenting* |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
868 To add extra indentation to every PHP lines with N being the number of |
| 1668 | 869 'shiftwidth' to add: > |
| 870 :let g:PHP_default_indenting = N | |
| 871 | |
| 872 For example, with N = 1, this will give: | |
| 873 > | |
| 874 <?php | |
| 875 if (!isset($History_lst_sel)) | |
| 876 if (!isset($History_lst_sel)) | |
| 877 if (!isset($History_lst_sel)) { | |
| 878 $History_lst_sel=0; | |
| 879 } else | |
| 880 $foo="bar"; | |
| 881 | |
| 882 $command_hist = TRUE; | |
| 883 ?> | |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
884 (Notice the extra indentation between the PHP container markers and the code) |
| 1668 | 885 ------------- |
| 886 | |
| 5862 | 887 *PHP_outdentphpescape* |
| 888 To indent PHP escape tags as the surrounding non-PHP code (only affects the | |
| 889 PHP escape tags): > | |
| 27036 | 890 :let g:PHP_outdentphpescape = 0 |
| 2442 | 891 ------------- |
| 892 | |
| 5862 | 893 *PHP_removeCRwhenUnix* |
| 1668 | 894 To automatically remove '\r' characters when the 'fileformat' is set to Unix: > |
| 895 :let g:PHP_removeCRwhenUnix = 1 | |
| 896 ------------- | |
| 897 | |
| 5862 | 898 *PHP_BracesAtCodeLevel* |
| 1668 | 899 To indent braces at the same level than the code they contain: > |
| 900 :let g:PHP_BracesAtCodeLevel = 1 | |
| 18831 | 901 |
| 1668 | 902 This will give the following result: > |
| 903 if ($foo) | |
| 904 { | |
| 905 foo(); | |
| 906 } | |
| 907 Instead of: > | |
| 908 if ($foo) | |
| 909 { | |
| 910 foo(); | |
| 911 } | |
| 912 | |
| 913 NOTE: Indenting will be a bit slower if this option is used because some | |
| 914 optimizations won't be available. | |
| 915 ------------- | |
| 916 | |
| 17571 | 917 *PHP_vintage_case_default_indent* |
| 1668 | 918 To indent 'case:' and 'default:' statements in switch() blocks: > |
| 919 :let g:PHP_vintage_case_default_indent = 1 | |
| 920 | |
|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
921 In PHP braces are not required inside 'case/default' blocks therefore 'case:' |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
922 and 'default:' are indented at the same level than the 'switch()' to avoid |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
923 meaningless indentation. You can use the above option to return to the |
|
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4098
diff
changeset
|
924 traditional way. |
| 14006 | 925 ------------- |
| 926 | |
| 927 *PHP_noArrowMatching* | |
| 928 By default the indent script will indent multi-line chained calls by matching | |
| 929 the position of the '->': > | |
| 930 | |
| 931 $user_name_very_long->name() | |
| 932 ->age() | |
| 933 ->info(); | |
| 934 | |
| 935 You can revert to the classic way of indenting by setting this option to 1: > | |
| 936 :let g:PHP_noArrowMatching = 1 | |
| 937 | |
| 938 You will obtain the following result: > | |
| 939 | |
| 940 $user_name_very_long->name() | |
| 941 ->age() | |
| 942 ->info(); | |
| 943 | |
| 17571 | 944 ------------- |
| 945 | |
| 946 *PHP_IndentFunctionCallParameters* | |
| 947 Extra indentation levels to add to parameters in multi-line function calls. > | |
| 948 let g:PHP_IndentFunctionCallParameters = 1 | |
| 949 | |
| 950 Function call arguments will indent 1 extra level. For two-space indentation: > | |
| 951 | |
| 952 function call_the_thing( | |
| 953 $with_this, | |
| 954 $and_that | |
| 955 ) { | |
| 956 $this->do_the_thing( | |
| 957 $with_this, | |
| 958 $and_that | |
| 959 ); | |
| 960 } | |
| 961 | |
| 962 ------------- | |
| 963 | |
| 964 *PHP_IndentFunctionDeclarationParameters* | |
| 18343 | 965 Extra indentation levels to add to arguments in multi-line function |
| 966 definitions. > | |
| 17571 | 967 let g:PHP_IndentFunctionDeclarationParameters = 1 |
| 968 | |
| 18343 | 969 Function arguments in declarations will indent 1 extra level. For two-space |
| 970 indentation: > | |
| 17571 | 971 |
| 972 function call_the_thing( | |
| 973 $with_this, | |
| 974 $and_that | |
| 975 ) { | |
| 976 $this->do_the_thing( | |
| 977 $with_this, | |
| 978 $and_that | |
| 979 ); | |
| 980 } | |
| 1668 | 981 |
| 982 | |
| 501 | 983 PYTHON *ft-python-indent* |
| 170 | 984 |
| 985 The amount of indent can be set for the following situations. The examples | |
| 1698 | 986 given are the defaults. Note that the variables are set to an expression, so |
| 987 that you can change the value of 'shiftwidth' later. | |
| 170 | 988 |
| 989 Indent after an open paren: > | |
| 15033 | 990 let g:pyindent_open_paren = 'shiftwidth() * 2' |
| 170 | 991 Indent after a nested paren: > |
| 15033 | 992 let g:pyindent_nested_paren = 'shiftwidth()' |
| 170 | 993 Indent for a continuation line: > |
| 15033 | 994 let g:pyindent_continue = 'shiftwidth() * 2' |
| 170 | 995 |
| 21676 | 996 The method uses |searchpair()| to look back for unclosed parentheses. This |
| 15033 | 997 can sometimes be slow, thus it timeouts after 150 msec. If you notice the |
| 14945 | 998 indenting isn't correct, you can set a larger timeout in msec: > |
| 999 let g:pyindent_searchpair_timeout = 500 | |
| 1000 | |
| 15932 | 1001 If looking back for unclosed parenthesis is still too slow, especially during |
| 1002 a copy-paste operation, or if you don't need indenting inside multi-line | |
| 1003 parentheses, you can completely disable this feature: > | |
| 1004 let g:pyindent_disable_parentheses_indenting = 1 | |
| 1005 | |
| 170 | 1006 |
| 3082 | 1007 R *ft-r-indent* |
| 1008 | |
| 1009 Function arguments are aligned if they span for multiple lines. If you prefer | |
| 1010 do not have the arguments of functions aligned, put in your |vimrc|: | |
| 1011 > | |
| 1012 let r_indent_align_args = 0 | |
| 1013 < | |
| 1014 All lines beginning with a comment character, #, get the same indentation | |
| 1015 level of the normal R code. Users of Emacs/ESS may be used to have lines | |
| 1016 beginning with a single # indented in the 40th column, ## indented as R code, | |
| 1017 and ### not indented. If you prefer that lines beginning with comment | |
| 1018 characters are aligned as they are by Emacs/ESS, put in your |vimrc|: | |
| 1019 > | |
| 1020 let r_indent_ess_comments = 1 | |
| 1021 < | |
| 1022 If you prefer that lines beginning with a single # are aligned at a column | |
| 1023 different from the 40th one, you should set a new value to the variable | |
| 1024 r_indent_comment_column, as in the example below: | |
| 1025 > | |
| 1026 let r_indent_comment_column = 30 | |
| 1027 < | |
| 1028 Any code after a line that ends with "<-" is indented. Emacs/ESS does not | |
| 1029 indent the code if it is a top level function. If you prefer that the | |
| 1030 Vim-R-plugin behaves like Emacs/ESS in this regard, put in your |vimrc|: | |
| 1031 > | |
| 1032 let r_indent_ess_compatible = 1 | |
| 1033 < | |
| 1034 Below is an example of indentation with and without this option enabled: | |
| 1035 > | |
| 1036 ### r_indent_ess_compatible = 1 ### r_indent_ess_compatible = 0 | |
| 1037 foo <- foo <- | |
| 1038 function(x) function(x) | |
| 1039 { { | |
| 1040 paste(x) paste(x) | |
| 1041 } } | |
| 1042 < | |
| 14637 | 1043 The code will be indented after lines that match the pattern |
| 1044 `'\(&\||\|+\|-\|\*\|/\|=\|\~\|%\|->\)\s*$'`. If you want indentation after | |
| 1045 lines that match a different pattern, you should set the appropriate value of | |
| 1046 `r_indent_op_pattern` in your |vimrc|. | |
| 1047 | |
| 3082 | 1048 |
| 1201 | 1049 SHELL *ft-sh-indent* |
| 1050 | |
| 1051 The amount of indent applied under various circumstances in a shell file can | |
| 1052 be configured by setting the following keys in the |Dictionary| | |
| 1053 b:sh_indent_defaults to a specific amount or to a |Funcref| that references a | |
| 1054 function that will return the amount desired: | |
| 1055 | |
| 1056 b:sh_indent_options['default'] Default amount of indent. | |
| 1057 | |
| 1058 b:sh_indent_options['continuation-line'] | |
| 1059 Amount of indent to add to a continued line. | |
| 1060 | |
| 1061 b:sh_indent_options['case-labels'] | |
| 1062 Amount of indent to add for case labels. | |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
1063 (not actually implemented) |
| 1201 | 1064 |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
1065 b:sh_indent_options['case-statements'] |
| 1201 | 1066 Amount of indent to add for case statements. |
| 1067 | |
| 1068 b:sh_indent_options['case-breaks'] | |
| 1069 Amount of indent to add (or more likely | |
| 1070 remove) for case breaks. | |
| 1071 | |
| 501 | 1072 VERILOG *ft-verilog-indent* |
| 7 | 1073 |
| 1074 General block statements such as if, for, case, always, initial, function, | |
| 1075 specify and begin, etc., are indented. The module block statements (first | |
| 1076 level blocks) are not indented by default. you can turn on the indent with | |
| 1077 setting a variable in the .vimrc as follows: > | |
| 1078 | |
| 1079 let b:verilog_indent_modules = 1 | |
| 1080 | |
| 1081 then the module blocks will be indented. To stop this, remove the variable: > | |
| 1082 | |
| 1083 :unlet b:verilog_indent_modules | |
| 1084 | |
| 1085 To set the variable only for Verilog file. The following statements can be | |
| 1086 used: > | |
| 1087 | |
| 1088 au BufReadPost * if exists("b:current_syntax") | |
| 1089 au BufReadPost * if b:current_syntax == "verilog" | |
| 1090 au BufReadPost * let b:verilog_indent_modules = 1 | |
| 1091 au BufReadPost * endif | |
| 1092 au BufReadPost * endif | |
| 1093 | |
| 1094 Furthermore, setting the variable b:verilog_indent_width to change the | |
| 1095 indenting width (default is 'shiftwidth'): > | |
| 1096 | |
| 1097 let b:verilog_indent_width = 4 | |
| 15033 | 1098 let b:verilog_indent_width = shiftwidth() * 2 |
| 7 | 1099 |
| 1100 In addition, you can turn the verbose mode for debug issue: > | |
| 1101 | |
| 1102 let b:verilog_indent_verbose = 1 | |
| 1103 | |
| 1104 Make sure to do ":set cmdheight=2" first to allow the display of the message. | |
| 1105 | |
| 22 | 1106 |
| 1620 | 1107 VHDL *ft-vhdl-indent* |
| 1108 | |
| 1109 Alignment of generic/port mapping statements are performed by default. This | |
| 1110 causes the following alignment example: > | |
| 1111 | |
| 1112 ENTITY sync IS | |
| 1113 PORT ( | |
| 1114 clk : IN STD_LOGIC; | |
| 1115 reset_n : IN STD_LOGIC; | |
| 1116 data_input : IN STD_LOGIC; | |
| 1117 data_out : OUT STD_LOGIC | |
| 1118 ); | |
| 1119 END ENTITY sync; | |
| 1120 | |
| 1121 To turn this off, add > | |
| 1122 | |
| 1123 let g:vhdl_indent_genportmap = 0 | |
| 1124 | |
| 1125 to the .vimrc file, which causes the previous alignment example to change: > | |
| 1126 | |
| 1127 ENTITY sync IS | |
| 1128 PORT ( | |
| 1129 clk : IN STD_LOGIC; | |
| 1130 reset_n : IN STD_LOGIC; | |
| 1131 data_input : IN STD_LOGIC; | |
| 1132 data_out : OUT STD_LOGIC | |
| 1133 ); | |
| 1134 END ENTITY sync; | |
| 1135 | |
| 1136 ---------------------------------------- | |
| 1137 | |
| 1138 Alignment of right-hand side assignment "<=" statements are performed by | |
| 1139 default. This causes the following alignment example: > | |
| 1140 | |
| 1141 sig_out <= (bus_a(1) AND | |
| 1142 (sig_b OR sig_c)) OR | |
| 1143 (bus_a(0) AND sig_d); | |
| 1144 | |
| 1145 To turn this off, add > | |
| 1146 | |
| 1147 let g:vhdl_indent_rhsassign = 0 | |
| 1148 | |
| 1149 to the .vimrc file, which causes the previous alignment example to change: > | |
| 1150 | |
| 1151 sig_out <= (bus_a(1) AND | |
| 1152 (sig_b OR sig_c)) OR | |
| 1153 (bus_a(0) AND sig_d); | |
| 1154 | |
| 1155 ---------------------------------------- | |
| 1156 | |
| 1157 Full-line comments (lines that begin with "--") are indented to be aligned with | |
| 1158 the very previous line's comment, PROVIDED that a whitespace follows after | |
| 1159 "--". | |
| 1160 | |
| 1161 For example: > | |
| 1162 | |
| 1163 sig_a <= sig_b; -- start of a comment | |
| 1164 -- continuation of the comment | |
| 1165 -- more of the same comment | |
| 1166 | |
| 1167 While in Insert mode, after typing "-- " (note the space " "), hitting CTRL-F | |
| 1168 will align the current "-- " with the previous line's "--". | |
| 1169 | |
| 1170 If the very previous line does not contain "--", THEN the full-line comment | |
| 1171 will be aligned with the start of the next non-blank line that is NOT a | |
| 1172 full-line comment. | |
| 1173 | |
| 1174 Indenting the following code: > | |
| 1175 | |
| 1176 sig_c <= sig_d; -- comment 0 | |
| 1177 -- comment 1 | |
| 1178 -- comment 2 | |
| 1179 --debug_code: | |
| 1180 --PROCESS(debug_in) | |
| 1181 --BEGIN | |
| 1182 -- FOR i IN 15 DOWNTO 0 LOOP | |
| 1183 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
| 1184 -- END LOOP; | |
| 1185 --END PROCESS debug_code; | |
| 1186 | |
| 1187 -- comment 3 | |
| 1188 sig_e <= sig_f; -- comment 4 | |
| 1189 -- comment 5 | |
| 1190 | |
| 1191 results in: > | |
| 1192 | |
| 1193 sig_c <= sig_d; -- comment 0 | |
| 1194 -- comment 1 | |
| 1195 -- comment 2 | |
| 1196 --debug_code: | |
| 1197 --PROCESS(debug_in) | |
| 1198 --BEGIN | |
| 1199 -- FOR i IN 15 DOWNTO 0 LOOP | |
| 1200 -- debug_out(8*i+7 DOWNTO 8*i) <= debug_in(15-i); | |
| 1201 -- END LOOP; | |
| 1202 --END PROCESS debug_code; | |
| 1203 | |
| 1204 -- comment 3 | |
| 1205 sig_e <= sig_f; -- comment 4 | |
| 1206 -- comment 5 | |
| 1207 | |
| 1208 Notice that "--debug_code:" does not align with "-- comment 2" | |
| 1209 because there is no whitespace that follows after "--" in "--debug_code:". | |
| 1210 | |
| 1211 Given the dynamic nature of indenting comments, indenting should be done TWICE. | |
| 1212 On the first pass, code will be indented. On the second pass, full-line | |
| 1213 comments will be indented according to the correctly indented code. | |
| 1214 | |
| 1215 | |
| 501 | 1216 VIM *ft-vim-indent* |
| 27036 | 1217 *g:vim_indent_cont* |
| 22 | 1218 For indenting Vim scripts there is one variable that specifies the amount of |
| 1219 indent for a continuation line, a line that starts with a backslash: > | |
| 1220 | |
| 15033 | 1221 :let g:vim_indent_cont = shiftwidth() * 3 |
| 22 | 1222 |
| 1223 Three times shiftwidth is the default value. | |
| 1224 | |
| 1225 | |
| 14421 | 1226 vim:tw=78:ts=8:noet:ft=help:norl: |