When using parentheses in combination with '|', like in \([ab]\)\|\([cd]\), either the first or second pattern in parentheses did not match, so either \1 or \2 is empty. Example:
:s/\([ab]\)\|\([cd]\)/\1x/g modifies "a b c d" in "ax bx x x"

:[range]ret[ab][!] [new_tabstop]

All sequences of white-space containing a tab are replaced with new strings of white-space using the new tabstop value given. If no new tabstop size is given, the current value of 'tabstop' is used. With !, strings of normal spaces will also be replace with tabs where appropriate. With 'expandtab' on, all tabs will be replaced with the appropriate number of spaces. This command sets 'tabstop' to the new value given, and if performed on the whole file, which is default, should not make any visible change. Careful: In a C program a inside a string will also be affected. Use "\t" to avoid this (that's a good habit anyway). {not in Vi}

:[range]ce[nter] [width]

Center lines in [range] between [width] columns (default 'textwidth' or 80 when 'textwidth' is 0). {not in Vi}

:[range]ri[ght] [width]

right align lines in [range] at [width] columns (default 'textwidth' or 80 when 'textwidth' is 0). {not in Vi}

:[range]le[ft] [indent]

left align lines in [range]. Sets the indent in the lines to [indent] (default 0). {not in Vi}

Q{motion}

Format the lines that were moved over. The length of each line will be restricted to the width given with the 'textwidth' option. See below. If the 'textwidth' option is 0, the width of the screen is used (with a maximum of 79). {not in Vi}

{Visual}Q

Format the highlighted text. (see the chapter on Visual_mode). {not in Vi}

After the "Q" command the cursor is left in the line where the motion command would take the cursor. This allows for the formatting to be repeated with ".". This works fine with "Qj" (format current and next line) and "Q}" (format until end of paragraph).

If the 'autoindent' option is on, the indent of the first line is used for the following lines.

Empty lines are left unchanged (but lines with spaces or tabs are!).

The 'formatprg' option can be set to the name of an external program, which will be used instead of the internal function. The 'textwidth' and other options will not be used then.

Comments are formatted in a special way. Normally a comment starts with special characters, ends with special characters, and each line in between can start with special characters.

The 'comments' option can be set to a comma separated list of patterns that can start a comment line. A pattern can include spaces, but not at the start of the pattern. If a pattern ends in a space, this means that the pattern can be followed by the end-of-line or any non-zero amount of white space, which is reproduced on the new line. By default "* " is included, but "*" is not. This means that "*" must be followed by some white space or end-of-line for it to be accepted. This avoids a pointer dereference like "*str" to be recognized as a comment. Also, "# " is included. This means that a line that starts with "#include" is not recognized as a comment line. But a line that starts with "# define" is recognized. In C code this is good, because somewhere after this a "#endif" is needed.

The 'nestedcomments' option can be set to a comma separated list of patterns that can start a comment line when they occur at least one time. For example '>' is often used in e-mail reply to show a part that is included from the original message. In a reply to a reply it becomes "> >".

The 'formatoptions' option can be set to influence the way how comments are formatted. It is a string option, that may contain any of these letters. The default is "tcq". Commas can be added for readability.

letter	meaning when present in 'formatoptions'
t	Do text autowrapping using textwidth
c	Do comment autowrapping using textwidth, inserting the current comment leader automatically.
r	Automatically insert the current comment leader after hitting <return> in insert mode.
o	Automatically insert the current comment leader after hitting 'o' or 'O' in Normal mode.
q	Allow formatting of comments with Q. Note that blank lines, or lines containing only the comment leader will be left untouched. A new paragraph starts after such a line, or when the comment leader changes.
2	When formatting text the indent of the second line of a paragraph is used for the rest of the paragraph. This allows for paragraphs with a different indent for the first line.
v	Vi-compatible auto wrapping in insert mode: Only break a line at a blank that has been entered during the current insert command. (Note: this is not 100% Vi compatible, Vi has some "unexpected features" or bugs in this area. It uses the screen column instead of the line column)
b	Like 'v', but only auto wrap if a blank has been entered at or before the wrap margin. If the line was longer than 'textwidth' when the insert started, or no blank was entered in the current insert before reaching 'textwidth', there is no auto wrapping.
l	Long lines are not broken in insert mode: When a line was longer than 'textwidth' when the insert command started it is not automatically formatted.

With 't' and 'c' you can decide when auto-wrapping is done: value action

""	no automatic formatting, "Q" can be used for manual formatting
"t"	automatic formatting of text, not for comments
"c"	automatic formatting for comments, not for text (good for C code)
"tc"	automatic formatting for text and comments

Note that when 'textwidth' is 0, no formatting is done anyway (but the comment leader is inserted). Note that when 'paste' is on, no formatting is done at all. Note that 'textwidth' can be non-zero even though auto-wrapping never occurs. This is good because it can be used for formatting only in this case (with "Q").

If "/*", "*" and "*/" are in the 'comments' variable, then Vim has some built in stuff to treat these types of comments a bit more cleverly. Opening a new line before or after "/*" or "*/" (with 'r' or 'o' present in 'formatoptions') gives the correct start of the line automatically. The same happens with formatting and auto-wrapping. Opening a line after a line starting with "/*" or "*" and containing "*/", will cause no comment leader to be inserted, and the indent of the new line is taken from the line containing the start of the comment. Eg:

All this should be really cool, especially in conjunction with the new :autocmd command to prepare different settings for different types of file.

Some examples:

for C code:	fo="croq"	(only format comments)
for Mail/news:	fo="tcrq"	(format all, don't start comment with "o" command)

11.5 Indenting C programs

There are in fact three methods that can be used.

'autoindent'	Just takes the indent from the previous line.
'smartindent'	Is like 'autoindent' but also recognizes some C syntax to increase/reduce the indent where appropriate.
'cindent'	Works more clever than the other two and can be configured to different indenting styles.

The rest of this section is about the 'cindent' option.

Note that the indenting done with 'cindent' does not work for 100%. Vim is not a C compiler, not all syntax is recognized.

Four options are used for C program indenting:

'cindent'	When on automatic C program indenting is enabled.
'cinkeys'	Keys that trigger reindenting in insert mode.
'cinoptions'	For setting your preferred indent style.
'cinwords'	Defines keywords that start an extra indent in the next line.

If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using this algorithm rather than calling an external program.

See autocommand for how to automatically set the 'cindent' option for C code files and reset it for others.

The 'cinkeys' option can be set to a string that says when to do indenting. The default is "0{,0},:,0#,!^F,o,O,e". This means that indenting is done when:

"0{"	typing '{' as the first character in a line
"0{"	typing '}' as the first character in a line
":"	typing ':' anywhere
"0#"	typing '#' as the first character in a line
"!^F"	typing CTRL-F, which is not inserted
"o"	typing a <CR> anywhere and for the "o" command (not in insert mode!)
"O"	for the "O" command (not in insert mode!)
"e"	typing the second 'e' for an "else" at the start of a line

Characters that can be prepended:

'!'

When the key is preceded with a '!' the key will not be inserted but will just cause the current line to be reindented. This allows you to set a command key for reindenting the current line. By default CTRL-F is used for this. Careful with CTRL-I, you might think that it is a nice command for Indenting, but it is the same as a <Tab>.

'*'

When the key is preceded with a '*' the reindenting will be done before inserting the key. If you use "*<Return>" this means that the current line will be reindented, before opening a new line.

'0'

When a zero is used before the key (but after '!' or '*') it will only trigger reindenting if the key is the first character typed in the line.

<>

Angle brackets mean spelled-out names of keys. For example: "<Up>", "<Ins>".

'^'

Letters preceded by a caret (^) are control characters. For example: "^F" is CTRL-F.

'o'

Means to reindent a line for the "o" command and whenever a new line is opened below the current one. This includes hitting <Return> in insert mode.

'O'

Means to reindent a line for the "O" command.

'e'

Means to reindent a line that starts with "else" when an 'e' is inserted.

For an emacs-style indent mode, where lines aren't indented every time you press Return but only if you press Tab, I suggest:

Note: When the indent of the current line was changed manually, cindenting won't be done for any key. This is to avoid re-indenting after you changed the indent by typing <BS>, <Tab> or <Space> in the indent, or used CTRL-T or CTRL-D.

How the indenting is done can be set with 'cinoptions'. In the list below, "N" represents a number of your choice. It can be negative. When there is an 's' after the number, it is multiplied with 'shiftwidth'. "1s" is 'shiftwidth', "2s" is two times 'shiftwidth', etc. A decimal point is allowed too: "-0.5s" is minus half a 'shiftwidth'. The examples given below assume a 'shiftwidth' of 4.

Lines are put in column 1 if:

• It starts with '#' (preprocessor directives), if 'cinkeys' contains '#'.
• It starts with a label (a keyword followed by ':', other than "case" and "default").
• Any combination of indentations causes the line to have less than 0 indentation.

  12. Copying and moving text

  "<a-zA-Z0-9.%:-">

  Use register <a-zA-Z0-9.%:-"> for next delete, yank or put (use uppercase character to append with delete and yank) (<.%:> only work with put).

  :reg[isters]

  Display the contents of all numbered and named registers. {not in Vi}

  :reg[isters] {arg}

  Display the contents of the numbered and named registers that are mentioned in {arg}. For example: :dis 1a to display registers '1' and 'a'. Spaces are allowed in {arg}. {not in Vi}

  :di[splay] [arg]

  Same as :registers. {not in Vi}

  ["x]y{motion}

  Yank {motion} text [into register x].

  ["x]yy

  Yank [count] lines [into register x] (linewise).

  ["x]Y

  yank [count] lines [into register x] (synonym for yy, linewise). If you like "Y" to work from the cursor to the end of line (which is more logical, but not Vi-compatible) use ":map Y y$".

  {Visual}["x]y

  Yank the highlighed text [into register x] (see the chapter on Visual_mode). {not in Vi}

  {Visual}["x]Y

  Yank the highlighted lines [into register x] (see the chapter on Visual_mode). {not in Vi}

  :[range]y[ank] [x]

  Yank [range] lines [into register x].

  :[range]y[ank] [x] {count}

  Yank {count} lines, starting with last line number in [range] (default: current line, See Command line ranges), [into register x].

  ["x]p

  Put the text [from register x] after the cursor [count] times. {Vi: no count}

  ["x]P or

  ["x]<MiddleMouse>

  Put the text [from register x] before the cursor [count] times. Using the mouse only works when 'mouse' contains 'n' or 'a'. {Vi: no count}

  :[line]pu[t] [x]

  Put the text [from register x] after [line] (default current line).

  :[line]pu[t]! [x]

  Put the text [from register x] before [line] (default current line).

  ["x]]p or

  ["x]]<MiddleMouse>

  Like "p", but adjust the indent to the current line. Using the mouse only works when 'mouse' contains 'n' or 'a'. {not in Vi}

  ["x][P or

  ["x]]P or

  ["x][p or

  ["x][<MiddleMouse>

  Like "P", but adjust the indent to the current line. Using the mouse only works when 'mouse' contains 'n' or 'a'. {not in Vi}

  These commands can be used to copy text from one place to another. This is done by first getting the text into a register with a yank, delete or change command. The register can then be inserted with a put command. All registers are kept when changing files. Thus you can also use this to move text from one file to another (the CTRL-^ command is a quick way to toggle between two files).

  The put commands can be repeated with "." (except for :put) and undone. If the command that was used to get the text into the register was linewise, the text will be inserted below ("p") or above ("P") the line where the cursor is. Otherwise the text will be inserted after ("p") or before ("P") the cursor. With the ":put" command the text will always be inserted in the next line. You can exchange two characters with the command sequence "xp". You can exchange two lines with the command sequence "ddp". You can exchange two words with the command sequence "deep" (start with the cursor in the blank space before the first word). The "']" or "`]" command can be used after the put command to move the cursor to the end of the inserted text, "'[" or "`[" to move the cursor to the start.

  If the command that was used to get the text into the register used blockwise Visual mode, the block of text will be inserted before ("P") or after ("p") the cursor column, in the current and next lines. Vim will make the whole block of text start in the same column. Thus the inserted text looks the same as when it was yanked or deleted. Some <Tab> characters may be replaced with spaces to make this happen. However, if the width of the block is not a multiple of a <Tab> width and the text after the inserted block contains <Tab>s, that text may be misaligned.

  There are five types of registers:

  • The unnamed register ""
  • 10 numbered registers "0 to "9
  • The small delete register "-
  • 26 named registers "a to "z or "A to "Z
  • three read-only registers ":, ". and "%
  The unnamed register is the register where all text deleted with the "d", "c", "s", "x" commands or copied with the yank "y" command is placed, regardless of whether or not a specific register was used (e.g. "xdd). The contents of this register are used by any put command (p or P) which does not specify a register. Additionally it can be accessed by the name '"'. This means you have to type two double quotes. {Vi: register contents lost when changing files, no '"'}

  The numbered registers are filled with yank and delete commands. Numbered register 0 is filled with the last yank command, unless another register was specified with ["x]. Numbered register 1 is filled with the text that was deleted by each delete or change command, unless another register was specified or the text is less than one line (text deleted with "x" or "dw" will be put in the small delete register). The contents of register 1 are put in 2, 2 in 3, and so forth. The contents of register 9 are lost. {Vi: numbered register contents are lost when changing files; register 0 does not exist}

  The small delete register is filled with delete commands that delete less than one line, except when a register was specified with ["x].

  The named registers are only filled when you say so. They are named 'a' to 'z' normally. If you use an uppercase letter, the same registers as with the lower case letter is used, but the text is appended to the previous register contents. With a lower case letter the previous contents are lost.

  The read-only registers are '%', ':' and '.'. They can only be used with the commands "p", "P" and ":put".

  '.'

  Contains the last inserted text (the same as what is inserted with the insert mode commands CTRL-A and CTRL-@).

  '%'

  Contains the name of the current file.

  ':'

  Contains the last command line. It can be used with "@:", this repeats the last command line.

  If you use a put command without specifying a register, the register that was last written to is used (this is also the contents of the unnamed register). If you are confused, use the ":dis" command to find out what will be put (all named and numbered registers are displayed; the unnamed register is labelled '"').

  The next three commands always work on whole lines.

  :[range]co[py] {address}

  Copy the lines given by [range] to below the line given by {address}.

  :t

  Synonym for copy.

  :[range]m[ove] {address}

  Move the lines given by [range] to below the line given by {address}.

  ---

  Part 1 Part 2 Part 3 Part 4 Part 5 Part 6 Part 7 Part 8 Part 9

  ---

  Send feedback on this page to Rajesh Kallingal
  For Vim version 3.24. Last modification: 1996 Apr 25