*quickref.txt*  For Vim version 7.0aa.  Last change: 2006 Jan 11


		  VIM REFERENCE MANUAL    by Bram Moolenaar

			    Quick reference guide

							 *quickref* *Contents*
 tag	  subject			 tag	  subject	~
|Q_ct|  list of help files		|Q_re|	Repeating commands
|Q_lr|	motion: Left-right		|Q_km|	Key mapping
|Q_ud|	motion: Up-down			|Q_ab|	Abbreviations
|Q_tm|	motion: Text object		|Q_op|	Options
|Q_pa|	motion: Pattern searches	|Q_ur|	Undo/Redo commands
|Q_ma|	motion: Marks			|Q_et|	External commands
|Q_vm|	motion: Various			|Q_qf|	Quickfix commands
|Q_ta|	motion: Using tags		|Q_vc|	Various commands
|Q_sc|	Scrolling			|Q_ce|	Ex: Command-line editing
|Q_in|	insert: Inserting text		|Q_ra|	Ex: Ranges
|Q_ai|	insert: Keys			|Q_ex|	Ex: Special characters
|Q_ss|	insert: Special keys		|Q_st|	Starting VIM
|Q_di|	insert: Digraphs		|Q_ed|	Editing a file
|Q_si|	insert: Special inserts		|Q_fl|	Using the argument list
|Q_de|	change: Deleting text		|Q_wq|	Writing and quitting
|Q_cm|	change: Copying and moving	|Q_ac|	Automatic commands
|Q_ch|	change: Changing text		|Q_wi|	Multi-window commands
|Q_co|	change: Complex			|Q_bu|	Buffer list commands
|Q_vi|	Visual mode			|Q_sy|	Syntax highlighting
|Q_to|	Text objects			|Q_gu|	GUI commands
					|Q_fo|  Folding

------------------------------------------------------------------------------
N is used to indicate an optional count that can be given before the command.
------------------------------------------------------------------------------
*Q_lr*		Left-right motions

|h|	N  h		left (also: CTRL-H, <BS>, or <Left> key)
|l|	N  l		right (also: <Space> or <Right> key)
|0|	   0		to first character in the line (also: <Home> key)
|^|	   ^		to first non-blank character in the line
|$|	N  $		to the last character in the line (N-1 lines lower)
			   (also: <End> key)
|g0|	N  g0		to first character in screen line (differs from "0"
			   when lines wrap)
|g^|	N  g^		to first non-blank character in screen line (differs
			   from "^" when lines wrap)
|g$|	N  g$		to last character in screen line (differs from "$"
			   when lines wrap)
|gm|	N  gm		to middle of the screen line
|bar|	N  |		to column N (default: 1)
|f|	N  f{char}	to the Nth occurrence of {char} to the right
|F|	N  F{char}	to the Nth occurrence of {char} to the left
|t|	N  t{char}	till before the Nth occurrence of {char} to the right
|T|	N  T{char}	till before the Nth occurrence of {char} to the left
|;|	N  ;		repeat the last "f", "F", "t", or "T" N times
|,|	N  ,		repeat the last "f", "F", "t", or "T" N times in
			   opposite direction
------------------------------------------------------------------------------
*Q_ud*		Up-down motions

|k|	N  k		up N lines (also: CTRL-P and <Up>)
|j|	N  j		down N lines (also: CTRL-J, CTRL-N, <NL>, and <Down>)
|-|	N  -		up N lines, on the first non-blank character
|+|	N  +		down N lines, on the first non-blank character (also:
			   CTRL-M and <CR>)
|_|	N  _		down N-1 lines, on the first non-blank character
|G|	N  G		goto line N (default: last line), on the first
			   non-blank character
|gg|	N  gg		goto line N (default: first line), on the first
			   non-blank character
|N%|	N  %		goto line N percentage down in the file.  N must be
			   given, otherwise it is the |%| command.
|gk|	N  gk		up N screen lines (differs from "k" when line wraps)
|gj|	N  gj		down N screen lines (differs from "j" when line wraps)
------------------------------------------------------------------------------
*Q_tm*		Text object motions

|w|	N  w		N words forward
|W|	N  W		N blank-separated |WORD|s forward
|e|	N  e		forward to the end of the Nth word
|E|	N  E		forward to the end of the Nth blank-separated |WORD|
|b|	N  b		N words backward
|B|	N  B		N blank-separated |WORD|s backward
|ge|	N  ge		backward to the end of the Nth word
|gE|	N  gE		backward to the end of the Nth blank-separated |WORD|

|)|	N  )		N sentences forward
|(|	N  (		N sentences backward
|}|	N  }		N paragraphs forward
|{|	N  {		N paragraphs backward
|]]|	N  ]]		N sections forward, at start of section
|[[|	N  [[		N sections backward, at start of section
|][|	N  ][		N sections forward, at end of section
|[]|	N  []		N sections backward, at end of section
|[(|	N  [(		N times back to unclosed '('
|[{|	N  [{		N times back to unclosed '{'
|[m|	N  [m		N times back to start of method (for Java)
|[M|	N  [M		N times back to end of method (for Java)
|])|	N  ])		N times forward to unclosed ')'
|]}|	N  ]}		N times forward to unclosed '}'
|]m|	N  ]m		N times forward to start of method (for Java)
|]M|	N  ]M		N times forward to end of method (for Java)
|[#|	N  [#		N times back to unclosed "#if" or "#else"
|]#|	N  ]#		N times forward to unclosed "#else" or "#endif"
|[star|	N  [*		N times back to start of comment "/*"
|]star|	N  ]*		N times forward to end of comment "*/"
------------------------------------------------------------------------------
*Q_pa*		Pattern searches

|/|	N  /{pattern}[/[offset]]<CR>
			search forward for the Nth occurrence of {pattern}
|?|	N  ?{pattern}[?[offset]]<CR>
			search backward for the Nth occurrence of {pattern}
|/<CR>|	N  /<CR>	repeat last search, in the forward direction
|?<CR>|	N  ?<CR>	repeat last search, in the backward direction
|n|	N  n		repeat last search
|N|	N  N		repeat last search, in opposite direction
|star|	N  *		search forward for the identifier under the cursor
|#|	N  #		search backward for the identifier under the cursor
|gstar|	N  g*		like "*", but also find partial matches
|g#|	N  g#		like "#", but also find partial matches
|gd|	   gd		goto local declaration of identifier under the cursor
|gD|	   gD		goto global declaration of identifier under the cursor

|pattern|		Special characters in search patterns

			meaning		      magic   nomagic	~
		matches any single character	.	\.
		       matches start of line	^	^
			       matches <EOL>	$	$
		       matches start of word	\<	\<
			 matches end of word	\>	\>
	matches a single char from the range	[a-z]	\[a-z]
      matches a single char not in the range	[^a-z]	\[^a-z]
		  matches an identifier char	\i	\i
		   idem but excluding digits	\I	\I
		 matches a keyword character	\k	\k
		   idem but excluding digits	\K	\K
	       matches a file name character	\f	\f
		   idem but excluding digits	\F	\F
	       matches a printable character	\p	\p
		   idem but excluding digits	\P	\P
	     matches a white space character	\s	\s
	 matches a non-white space character	\S	\S

			       matches <Esc>	\e	\e
			       matches <Tab>	\t	\t
				matches <CR>	\r	\r
				matches <BS>	\b	\b

     matches 0 or more of the preceding atom	*	\*
     matches 1 or more of the preceding atom	\+	\+
	matches 0 or 1 of the preceding atom	\=	\=
	matches 2 to 5 of the preceding atom	\{2,5}  \{2,5}
		  separates two alternatives	\|	\|
		group a pattern into an atom	\(\)	\(\)

|search-offset|		Offsets allowed after search command

    [num]	[num] lines downwards, in column 1
    +[num]	[num] lines downwards, in column 1
    -[num]	[num] lines upwards, in column 1
    e[+num]	[num] characters to the right of the end of the match
    e[-num]	[num] characters to the left of the end of the match
    s[+num]	[num] characters to the right of the start of the match
    s[-num]	[num] characters to the left of the start of the match
    b[+num]	[num] identical to s[+num] above (mnemonic: begin)
    b[-num]	[num] identical to s[-num] above (mnemonic: begin)
    ;{search-command}	execute {search-command} next
------------------------------------------------------------------------------
*Q_ma*		Marks and motions

|m|	   m{a-zA-Z}	mark current position with mark {a-zA-Z}
|`a|	   `{a-z}	go to mark {a-z} within current file
|`A|	   `{A-Z}	go to mark {A-Z} in any file
|`0|	   `{0-9}	go to the position where Vim was previously exited
|``|	   ``		go to the position before the last jump
|`quote|   `"		go to the position when last editing this file
|`[|	   `[		go to the start of the previously operated or put text
|`]|	   `]		go to the end of the previously operated or put text
|`<|	   `<		go to the start of the (previous) Visual area
|`>|	   `>		go to the end of the (previous) Visual area
|`.|	   `.		go to the position of the last change in this file
|'|	   '{a-zA-Z0-9[]'"<>.}
			same as `, but on the first non-blank in the line
|:marks|  :marks	print the active marks
|CTRL-O|  N  CTRL-O	go to Nth older position in jump list
|CTRL-I|  N  CTRL-I	go to Nth newer position in jump list
|:ju|	  :ju[mps]	print the jump list
------------------------------------------------------------------------------
*Q_vm*		Various motions

|%|	   %		find the next brace, bracket, comment, or "#if"/
			   "#else"/"#endif" in this line and go to its match
|H|	N  H		go to the Nth line in the window, on the first
			   non-blank
|M|	   M		go to the middle line in the window, on the first
			   non-blank
|L|	N  L		go to the Nth line from the bottom, on the first
			   non-blank

|go|	N  go			go to Nth byte in the buffer
|:go|	:[range]go[to] [off]	go to [off] byte in the buffer
------------------------------------------------------------------------------
*Q_ta*		Using tags

|:ta|	   :ta[g][!] {tag}	Jump to tag {tag}
|:ta|	   :[count]ta[g][!]	Jump to [count]'th newer tag in tag list
|CTRL-]|      CTRL-]		Jump to the tag under cursor, unless changes
				   have been made
|:ts|	   :ts[elect][!] [tag]	List matching tags and select one to jump to
|:tjump|   :tj[ump][!] [tag]	Jump to tag [tag] or select from list when
				   there are multiple matches

|:tags|	   :tags		Print tag list
|CTRL-T|   N  CTRL-T		Jump back from Nth older tag in tag list
|:po|	   :[count]po[p][!]	Jump back from [count]'th older tag in tag list
|:tnext|   :[count]tn[ext][!]	Jump to [count]'th next matching tag
|:tp|      :[count]tp[revious][!] Jump to [count]'th previous matching tag
|:tr|	   :[count]tr[ewind][!] Jump to [count]'th matching tag
|:tl|	   :tl[ast][!]		Jump to last matching tag

|:ptag|	   :pt[ag] {tag}	open a preview window to show tag {tag}
|CTRL-W_}|     CTRL-W }		like CTRL-] but show tag in preview window
|:pts|     :pts[elect]		like ":tselect" but show tag in preview window
|:ptjump|  :ptj[ump]		like ":tjump" but show tag in preview window
|:pclose|  :pc[lose]		close tag preview window
|CTRL-W_z|     CTRL-W z		close tag preview window
------------------------------------------------------------------------------
*Q_sc*		Scrolling

|CTRL-E|	N  CTRL-E	window N lines downwards (default: 1)
|CTRL-D|	N  CTRL-D	window N lines Downwards (default: 1/2 window)
|CTRL-F|	N  CTRL-F	window N pages Forwards (downwards)
|CTRL-Y|	N  CTRL-Y	window N lines upwards (default: 1)
|CTRL-U|	N  CTRL-U	window N lines Upwards (default: 1/2 window)
|CTRL-B|	N  CTRL-B	window N pages Backwards (upwards)
|z<CR>|		   z<CR> or zt	redraw, current line at top of window
|z.|		   z.	 or zz	redraw, current line at center of window
|z-|		   z-	 or zb	redraw, current line at bottom of window

These only work when 'wrap' is off:
|zh|		N  zh		scroll screen N characters to the right
|zl|		N  zl		scroll screen N characters to the left
|zH|		N  zH		scroll screen half a screenwidth to the right
|zL|		N  zL		scroll screen half a screenwidth to the left
------------------------------------------------------------------------------
*Q_in*		Inserting text

|a|	N  a	append text after the cursor (N times)
|A|	N  A	append text at the end of the line (N times)
|i|	N  i	insert text before the cursor (N times) (also: <Insert>)
|I|	N  I	insert text before the first non-blank in the line (N times)
|gI|	N  gI	insert text in column 1 (N times)
|o|	N  o	open a new line below the current line, append text (N times)
|O|	N  O	open a new line above the current line, append text (N times)
|:startinsert|  :star[tinsert][!]  start Insert mode, append when [!] used
|:startreplace| :startr[eplace][!]  start Replace mode, at EOL when [!] used

in Visual block mode:
|v_b_I|    I	insert the same text in front of all the selected lines
|v_b_A|	   A	append the same text after all the selected lines
------------------------------------------------------------------------------
*Q_ai*		Insert mode keys

|insert-index|	alphabetical index of Insert mode commands

leaving Insert mode:
|i_<Esc>|	<Esc>		  end Insert mode, back to Normal mode
|i_CTRL-C|	CTRL-C		  like <Esc>, but do not use an abbreviation
|i_CTRL-O|	CTRL-O {command}  execute {command} and return to Insert mode

moving around:
|i_<Up>|	cursor keys	  move cursor left/right/up/down
|i_<S-Left>|	shift-left/right  one word left/right
|i_<S-Up>|	shift-up/down	  one screenful backward/forward
|i_<End>|	<End>		  cursor after last character in the line
|i_<Home>|	<Home>		  cursor to first character in the line
------------------------------------------------------------------------------
*Q_ss*		Special keys in Insert mode

|i_CTRL-V|	CTRL-V {char}..	  insert character literally, or enter decimal
				     byte value
|i_<NL>|	<NL> or <CR> or CTRL-M or CTRL-J
				  begin new line
|i_CTRL-E|	CTRL-E		  insert the character from below the cursor
|i_CTRL-Y|	CTRL-Y		  insert the character from above the cursor

|i_CTRL-A|	CTRL-A		  insert previously inserted text
|i_CTRL-@|	CTRL-@		  insert previously inserted text and stop
				     Insert mode
|i_CTRL-R|	CTRL-R {0-9a-z%#:.-="}  insert the contents of a register

|i_CTRL-N|	CTRL-N		  insert next match of identifier before the
				     cursor
|i_CTRL-P|	CTRL-P		  insert previous match of identifier before
				     the cursor
|i_CTRL-X|	CTRL-X ...	  complete the word before the cursor in
				     various ways

|i_<BS>|	<BS> or CTRL-H	  delete the character before the cursor
|i_<Del>|	<Del>		  delete the character under the cursor
|i_CTRL-W|	CTRL-W		  delete word before the cursor
|i_CTRL-U|	CTRL-U		  delete all entered characters in the current
				     line
|i_CTRL-T|	CTRL-T		  insert one shiftwidth of indent in front of
				       the current line
|i_CTRL-D|	CTRL-D		  delete one shiftwidth of indent in front of
				     the current line
|i_0_CTRL-D|	0 CTRL-D	  delete all indent in the current line
|i_^_CTRL-D|	^ CTRL-D	  delete all indent in the current line,
				     restore indent in next line
------------------------------------------------------------------------------
*Q_di*		Digraphs

|:dig|	   :dig[raphs]		show current list of digraphs
|:dig|	   :dig[raphs] {char1}{char2} {number} ...
				add digraph(s) to the list

In Insert or Command-line mode:
|i_CTRL-K|	CTRL-K {char1} {char2}
				  enter digraph
|i_digraph|	{char1} <BS> {char2}
				  enter digraph if 'digraph' option set
------------------------------------------------------------------------------
*Q_si*		Special inserts

|:r|	   :r [file]	   insert the contents of [file] below the cursor
|:r!|	   :r! {command}   insert the standard output of {command} below the
			      cursor
------------------------------------------------------------------------------
*Q_de*		Deleting text

|x|	N  x		delete N characters under and after the cursor
|<Del>| N  <Del>	delete N characters under and after the cursor
|X|	N  X		delete N characters before the cursor
|d|	N  d{motion}	delete the text that is moved over with {motion}
|v_d|	{visual}d	delete the highlighted text
|dd|	N  dd		delete N lines
|D|	N  D		delete to the end of the line (and N-1 more lines)
|J|	N  J		join N-1 lines (delete <EOL>s)
|v_J|	{visual}J	join the highlighted lines
|gJ|	N  gJ		like "J", but without inserting spaces
|v_gJ|	{visual}gJ	like "{visual}J", but without inserting spaces
|:d|	:[range]d [x]	delete [range] lines [into register x]
------------------------------------------------------------------------------
*Q_cm*		Copying and moving text

|quote|	  "{char}	use register {char} for the next delete, yank, or put
|:reg|	  :reg		show the contents of all registers
|:reg|	  :reg {arg}	show the contents of registers mentioned in {arg}
|y|	  N  y{motion}	yank the text moved over with {motion} into a register
|v_y|	     {visual}y	yank the highlighted text into a register
|yy|	  N  yy		yank N lines into a register
|Y|	  N  Y		yank N lines into a register
|p|	  N  p		put a register after the cursor position (N times)
|P|	  N  P		put a register before the cursor position (N times)
|]p|	  N  ]p		like p, but adjust indent to current line
|[p|	  N  [p		like P, but adjust indent to current line
|gp|	  N  gp		like p, but leave cursor after the new text
|gP|	  N  gP		like P, but leave cursor after the new text
------------------------------------------------------------------------------
*Q_ch*		Changing text

|r|	  N  r{char}	replace N characters with {char}
|gr|	  N  gr{char}	replace N characters without affecting layout
|R|	  N  R		enter Replace mode (repeat the entered text N times)
|gR|	  N  gR		enter virtual Replace mode: Like Replace mode but
			   without affecting layout
|v_b_r|	  {visual}r{char}
			in Visual block mode: Replace each char of the
			   selected text with {char}

	(change = delete text and enter Insert mode)
|c|	  N  c{motion}	change the text that is moved over with {motion}
|v_c|	     {visual}c	change the highlighted text
|cc|	  N  cc		change N lines
|S|	  N  S		change N lines
|C|	  N  C		change to the end of the line (and N-1 more lines)
|s|	  N  s		change N characters
|v_b_c|	     {visual}c	in Visual block mode: Change each of the selected
			   lines with the entered text
|v_b_C|	     {visual}C	in Visual block mode: Change each of the selected
			   lines until end-of-line with the entered text

|~|	  N  ~		switch case for N characters and advance cursor
|v_~|	     {visual}~	switch case for highlighted text
|v_u|	     {visual}u	make highlighted text lowercase
|v_U|	     {visual}U	make highlighted text uppercase
|g~|	     g~{motion} switch case for the text that is moved over with
			   {motion}
|gu|	     gu{motion} make the text that is moved over with {motion}
			   lowercase
|gU|	     gU{motion} make the text that is moved over with {motion}
			   uppercase
|v_g?|	     {visual}g? perform rot13 encoding on highlighted text
|g?|	     g?{motion} perform rot13 encoding on the text that is moved over
			   with {motion}

|CTRL-A|  N  CTRL-A	add N to the number at or after the cursor
|CTRL-X|  N  CTRL-X	subtract N from the number at or after the cursor

|<|	  N  <{motion}	move the lines that are moved over with {motion} one
			   shiftwidth left
|<<|	  N  <<		move N lines one shiftwidth left
|>|	  N  >{motion}	move the lines that are moved over with {motion} one
			   shiftwidth right
|>>|	  N  >>		move N lines one shiftwidth right
|gq|	  N  gq{motion}	format the lines that are moved over with {motion} to
			   'textwidth' length
|:ce|	  :[range]ce[nter] [width]
			center the lines in [range]
|:le|	  :[range]le[ft] [indent]
			left-align the lines in [range] (with [indent])
|:ri|	  :[range]ri[ght] [width]
			right-align the lines in [range]
------------------------------------------------------------------------------
*Q_co*		Complex changes

|!|	   N  !{motion}{command}<CR>
			filter the lines that are moved over through {command}
|!!|	   N  !!{command}<CR>
			filter N lines through {command}
|v_!|	      {visual}!{command}<CR>
			filter the highlighted lines through {command}
|:range!|  :[range]! {command}<CR>
			filter [range] lines through {command}
|=|	   N  ={motion}
			filter the lines that are moved over through 'equalprg'
|==|	   N  ==	filter N lines through 'equalprg'
|v_=|	      {visual}=
			filter the highlighted lines through 'equalprg'
|:s|	   :[range]s[ubstitute]/{pattern}/{string}/[g][c]
			substitute {pattern} by {string} in [range] lines;
			   with [g], replace all occurrences of {pattern};
			   with [c], confirm each replacement
|:s|	   :[range]s[ubstitute] [g][c]
			repeat previous ":s" with new range and options
|&|	      &		Repeat previous ":s" on current line without options
|:ret|	   :[range]ret[ab][!] [tabstop]
			set 'tabstop' to new value and adjust white space
			   accordingly
------------------------------------------------------------------------------
*Q_vi*		Visual mode

|visual-index|	list of Visual mode commands.

|v|	   v		start highlighting characters  }  move cursor and use
|V|	   V		start highlighting linewise    }  operator to affect
|CTRL-V|   CTRL-V	start highlighting blockwise   }  highlighted text
|v_o|	   o		exchange cursor position with start of highlighting
|gv|	   gv		start highlighting on previous visual area
|v_v|	   v		highlight characters or stop highlighting
|v_V|	   V		highlight linewise or stop highlighting
|v_CTRL-V| CTRL-V	highlight blockwise or stop highlighting
------------------------------------------------------------------------------
*Q_to*		Text objects (only in Visual mode or after an operator)

|v_aw|	N  aw		Select "a word"
|v_iw|	N  iw		Select "inner word"
|v_aW|	N  aW		Select "a |WORD|"
|v_iW|	N  iW		Select "inner |WORD|"
|v_as|	N  as		Select "a sentence"
|v_is|	N  is		Select "inner sentence"
|v_ap|	N  ap		Select "a paragraph"
|v_ip|	N  ip		Select "inner paragraph"
|v_ab|	N  ab		Select "a block" (from "[(" to "])")
|v_ib|	N  ib		Select "inner block" (from "[(" to "])")
|v_aB|	N  aB		Select "a Block" (from "[{" to "]}")
|v_iB|	N  iB		Select "inner Block" (from "[{" to "]}")
------------------------------------------------------------------------------
*Q_re*		Repeating commands

|.|	   N  .		repeat last change (with count replaced with N)
|q|	      q{a-z}	record typed characters into register {a-z}
|q|	      q{A-Z}	record typed characters, appended to register {a-z}
|q|	      q		stop recording
|@|	   N  @{a-z}	execute the contents of register {a-z} (N times)
|@@|	   N  @@	   repeat previous @{a-z} (N times)
|:@|	   :@{a-z}	execute the contents of register {a-z} as an Ex
			   command
|:@@|	   :@@		repeat previous :@{a-z}
|:g|	   :[range]g[lobal]/{pattern}/[cmd]
			Execute Ex command [cmd] (default: ":p") on the lines
			   within [range] where {pattern} matches.
|:g|	   :[range]g[lobal]!/{pattern}/[cmd]
			Execute Ex command [cmd] (default: ":p") on the lines
			   within [range] where {pattern} does NOT match.
|:so|	   :so[urce] {file}
			Read Ex commands from {file}.
|:so|	   :so[urce]! {file}
			Read Vim commands from {file}.
|:sl|	   :sl[eep] [sec]
			don't do anything for [sec] seconds
|gs|	   N  gs	Goto Sleep for N seconds
------------------------------------------------------------------------------
*Q_km*		Key mapping

|:map|	     :ma[p] {lhs} {rhs}	  Map {lhs} to {rhs} in Normal and Visual
				     mode.
|:map!|	     :ma[p]! {lhs} {rhs}  Map {lhs} to {rhs} in Insert and Command-line
				     mode.
|:noremap|   :no[remap][!] {lhs} {rhs}
				  Same as ":map", no remapping for this {rhs}
|:unmap|     :unm[ap] {lhs}	  Remove the mapping of {lhs} for Normal and
				     Visual mode.
|:unmap!|    :unm[ap]! {lhs}	  Remove the mapping of {lhs} for Insert and
				     Command-line mode.
|:map_l|     :ma[p] [lhs]	  List mappings (starting with [lhs]) for
				     Normal and Visual mode.
|:map_l!|    :ma[p]! [lhs]	  List mappings (starting with [lhs]) for
				     Insert and Command-line mode.
|:cmap|	     :cmap/:cunmap/:cnoremap
				  like ":map!"/":unmap!"/":noremap!" but for
				     Command-line mode only
|:imap|	     :imap/:iunmap/:inoremap
				  like ":map!"/":unmap!"/":noremap!" but for
				     Insert mode only
|:nmap|	     :nmap/:nunmap/:nnoremap
				  like ":map"/":unmap"/":noremap" but for
				     Normal mode only
|:vmap|	     :vmap/:vunmap/:vnoremap
				  like ":map"/":unmap"/":noremap" but for
				     Visual mode only
|:omap|	     :omap/:ounmap/:onoremap
				  like ":map"/":unmap"/":noremap" but only for
				     when an operator is pending
|:mapc|      :mapc[lear]	  remove mappings for Normal and Visual mode
|:mapc|      :mapc[lear]!	  remove mappings for Insert and Cmdline mode
|:imapc|     :imapc[lear]	  remove mappings for Insert mode
|:vmapc|     :vmapc[lear]	  remove mappings for Visual mode
|:omapc|     :omapc[lear]	  remove mappings for Operator-pending mode
|:nmapc|     :nmapc[lear]	  remove mappings for Normal mode
|:cmapc|     :cmapc[lear]	  remove mappings for Cmdline mode
|:mkexrc|    :mk[exrc][!] [file]  write current mappings, abbreviations, and
				     settings to [file] (default: ".exrc";
				     use ! to overwrite)
|:mkvimrc|   :mkv[imrc][!] [file]
				  same as ":mkexrc", but with default ".vimrc"
|:mksession| :mks[ession][!] [file]
				  like ":mkvimrc", but store current files,
				     windows, etc. too, to be able to continue
				     this session later.
------------------------------------------------------------------------------
*Q_ab*		Abbreviations

|:abbreviate|	:ab[breviate] {lhs} {rhs}  add abbreviation for {lhs} to {rhs}
|:abbreviate|	:ab[breviate] {lhs}	   show abbr's that start with {lhs}
|:abbreviate|	:ab[breviate]		   show all abbreviations
|:unabbreviate|	:una[bbreviate] {lhs}	   remove abbreviation for {lhs}
|:noreabbrev|	:norea[bbrev] [lhs] [rhs]  like ":ab", but don't remap [rhs]
|:iabbrev|	:iab/:iunab/:inoreab	   like ":ab", but only for Insert mode
|:cabbrev|	:cab/:cunab/:cnoreab	   like ":ab", but only for
						Command-line mode
|:abclear|	:abc[lear]		   remove all abbreviations
|:cabclear|	:cabc[lear]		   remove all abbr's for Cmdline mode
|:iabclear|	:iabc[lear]		   remove all abbr's for Insert mode
------------------------------------------------------------------------------
*Q_op*		Options

|:set|		:se[t]			  Show all modified options.
|:set|		:se[t] all		  Show all non-termcap options.
|:set|		:se[t] termcap		  Show all termcap options.
|:set|		:se[t] {option}		  Set boolean option (switch it on),
					  show string or number option.
|:set|		:se[t] no{option}	  Reset boolean option (switch it off).
|:set|		:se[t] inv{option}	  invert boolean option.
|:set|		:se[t] {option}={value}	  Set string/number option to {value}.
|:set|		:se[t] {option}+={value}  append {value} to string option, add
					  {value} to number option
|:set|		:se[t] {option}-={value}  remove {value} to string option,
					  subtract {value} from number option
|:set|		:se[t] {option}?	  Show value of {option}.
|:set|		:se[t] {option}&	  Reset {option} to its default value.

|:setlocal|	:setl[ocal]		  like ":set" but set the local value
					  for options that have one
|:setglobal|	:setg[lobal]		  like ":set" but set the global value
					  of a local option

|:fix|		:fix[del]		  Set value of 't_kD' according to
					  value of 't_kb'.
|:options|	:opt[ions]		  Open a new window to view and set
					  options, grouped by functionality,
					  a one line explanation and links to
					  the help.

Short explanation of each option:		*option-list*
|'aleph'|	  |'al'|     ASCII code of the letter Aleph (Hebrew)
|'allowrevins'|	  |'ari'|    allow CTRL-_ in Insert and Command-line mode
|'altkeymap'|	  |'akm'|    for default second language (Farsi/Hebrew)
|'ambiwidth'|	  |'ambw'|   what to do with Unicode chars of ambiguous width
|'antialias'|	  |'anti'|   Mac OS X: use smooth, antialiased fonts
|'autochdir'|	  |'acd'|    change directory to the file in the current window
|'arabic'|	  |'arab'|   for Arabic as a default second language
|'arabicshape'|   |'arshape'| do shaping for Arabic characters
|'autoindent'|	  |'ai'|     take indent for new line from previous line
|'autoread'|	  |'ar'|     autom. read file when changed outside of Vim
|'autowrite'|	  |'aw'|     automatically write file if changed
|'autowriteall'|  |'awa'|    as 'autowrite', but works with more commands
|'background'|	  |'bg'|     "dark" or "light", used for highlight colors
|'backspace'|	  |'bs'|     how backspace works at start of line
|'backup'|	  |'bk'|     keep backup file after overwriting a file
|'backupcopy'|	  |'bkc'|    make backup as a copy, don't rename the file
|'backupdir'|	  |'bdir'|   list of directories for the backup file
|'backupext'|	  |'bex'|    extension used for the backup file
|'backupskip'|	  |'bsk'|    no backup for files that match these patterns
|'balloondelay'|  |'bdlay'|  delay in mS before a balloon may pop up
|'ballooneval'|   |'beval'|  switch on balloon evaluation
|'balloonexpr'|   |'bexpr'|  expression to show in balloon
|'binary'|	  |'bin'|    read/write/edit file in binary mode
|'bioskey'|	  |'biosk'|  MS-DOS: use bios calls for input characters
|'bomb'|		     prepend a Byte Order Mark to the file
|'breakat'|	  |'brk'|    characters that may cause a line break
|'browsedir'|	  |'bsdir'|  which directory to start browsing in
|'bufhidden'|	  |'bh'|     what to do when buffer is no longer in window
|'buflisted'|	  |'bl'|     whether the buffer shows up in the buffer list
|'buftype'|	  |'bt'|     special type of buffer
|'casemap'|	  |'cmp'|    specifies how case of letters is changed
|'cdpath'|	  |'cd'|     list of directories searched with ":cd"
|'cedit'|		     key used to open the command-line window
|'charconvert'|   |'ccv'|    expression for character encoding conversion
|'cindent'|	  |'cin'|    do C program indenting
|'cinkeys'|	  |'cink'|   keys that trigger indent when 'cindent' is set
|'cinoptions'|	  |'cino'|   how to do indenting when 'cindent' is set
|'cinwords'|	  |'cinw'|   words where 'si' and 'cin' add an indent
|'clipboard'|	  |'cb'|     use the clipboard as the unnamed register
|'cmdheight'|	  |'ch'|     number of lines to use for the command-line
|'cmdwinheight'|  |'cwh'|    height of the command-line window
|'columns'|	  |'co'|     number of columns in the display
|'comments'|	  |'com'|    patterns that can start a comment line
|'commentstring'| |'cms'|    template for comments; used for fold marker
|'compatible'|	  |'cp'|     behave Vi-compatible as much as possible
|'complete'|	  |'cpt'|    specify how Insert mode completion works
|'completefunc'|  |'cfu'|    function to be used for Insert mode completion
|'completeopt'|   |'cot'|    options for Insert mode completion
|'confirm'|	  |'cf'|     ask what to do about unsaved/read-only files
|'conskey'|	  |'consk'|  get keys directly from console (MS-DOS only)
|'copyindent'|    |'ci'|     make 'autoindent' use existing indent structure
|'cpoptions'|	  |'cpo'|    flags for Vi-compatible behavior
|'cscopepathcomp'| |'cspc'|  how many components of the path to show
|'cscopeprg'|	  |'csprg'|  command to execute cscope
|'cscopequickfix'| |'csqf'|  use quickfix window for cscope results
|'cscopetag'|	  |'cst'|    use cscope for tag commands
|'cscopetagorder'| |'csto'|  determines ":cstag" search order
|'cscopeverbose'| |'csverb'| give messages when adding a cscope database
|'debug'|		     set to "msg" to see all error messages
|'define'|	  |'def'|    pattern to be used to find a macro definition
|'delcombine'|	  |'deco'|   delete combining characters on their own
|'dictionary'|	  |'dict'|   list of file names used for keyword completion
|'diff'|		     use diff mode for the current window
|'diffexpr'|	  |'dex'|    expression used to obtain a diff file
|'diffopt'|	  |'dip'|    options for using diff mode
|'digraph'|	  |'dg'|     enable the entering of digraphs in Insert mode
|'directory'|	  |'dir'|    list of directory names for the swap file
|'display'|	  |'dy'|     list of flags for how to display text
|'eadirection'|   |'ead'|    in which direction 'equalalways' works
|'edcompatible'|  |'ed'|     toggle flags of ":substitute" command
|'encoding'|	  |'enc'|    encoding used internally
|'endofline'|	  |'eol'|    write <EOL> for last line in file
|'equalalways'|   |'ea'|     windows are automatically made the same size
|'equalprg'|	  |'ep'|     external program to use for "=" command
|'errorbells'|	  |'eb'|     ring the bell for error messages
|'errorfile'|	  |'ef'|     name of the errorfile for the QuickFix mode
|'errorformat'|   |'efm'|    description of the lines in the error file
|'esckeys'|	  |'ek'|     recognize function keys in Insert mode
|'eventignore'|	  |'ei'|     autocommand events that are ignored
|'expandtab'|	  |'et'|     use spaces when <Tab> is inserted
|'exrc'|	  |'ex'|     read .vimrc and .exrc in the current directory
|'fileencoding'|  |'fenc'|   file encoding for multi-byte text
|'fileencodings'| |'fencs'|  automatically detected character encodings
|'fileformat'|	  |'ff'|     file format used for file I/O
|'fileformats'|	  |'ffs'|    automatically detected values for 'fileformat'
|'filetype'|	  |'ft'|     type of file, used for autocommands
|'fillchars'|	  |'fcs'|    characters to use for displaying special items
|'fkmap'|	  |'fk'|     Farsi keyboard mapping
|'foldclose'|	  |'fcl'|    close a fold when the cursor leaves it
|'foldcolumn'|	  |'fdc'|    width of the column used to indicate folds
|'foldenable'|	  |'fen'|    set to display all folds open
|'foldexpr'|	  |'fde'|    expression used when 'foldmethod' is "expr"
|'foldignore'|	  |'fdi'|    ignore lines when 'foldmethod' is "indent"
|'foldlevel'|	  |'fdl'|    close folds with a level higher than this
|'foldlevelstart'| |'fdls'|  'foldlevel' when starting to edit a file
|'foldmarker'|	  |'fmr'|    markers used when 'foldmethod' is "marker"
|'foldmethod'|	  |'fdm'|    folding type
|'foldminlines'|  |'fml'|    minimum number of lines for a fold to be closed
|'foldnestmax'|   |'fdn'|    maximum fold depth
|'foldopen'|	  |'fdo'|    for which commands a fold will be opened
|'foldtext'|	  |'fdt'|    expression used to display for a closed fold
|'formatlistpat'| |'flp'|    pattern used to recognize a list header
|'formatoptions'| |'fo'|     how automatic formatting is to be done
|'formatprg'|	  |'fp'|     name of external program used with "gq" command
|'fsync'|	  |'fs'|     whether to invoke fsync() after file write
|'gdefault'|	  |'gd'|     the ":substitute" flag 'g' is default on
|'grepformat'|	  |'gfm'|    format of 'grepprg' output
|'grepprg'|	  |'gp'|     program to use for ":grep"
|'guicursor'|	  |'gcr'|    GUI: settings for cursor shape and blinking
|'guifont'|	  |'gfn'|    GUI: Name(s) of font(s) to be used
|'guifontset'|	  |'gfs'|    GUI: Names of multi-byte fonts to be used
|'guifontwide'|   |'gfw'|    list of font names for double-wide characters
|'guiheadroom'|	  |'ghr'|    GUI: pixels room for window decorations
|'guioptions'|	  |'go'|     GUI: Which components and options are used
|'guipty'|		     GUI: try to use a pseudo-tty for ":!" commands
|'helpfile'|	  |'hf'|     full path name of the main help file
|'helpheight'|	  |'hh'|     minimum height of a new help window
|'helplang'|	  |'hlg'|    preferred help languages
|'hidden'|	  |'hid'|    don't unload buffer when it is |abandon|ed
|'highlight'|	  |'hl'|     sets highlighting mode for various occasions
|'hlsearch'|	  |'hls'|    highlight matches with last search pattern
|'history'|	  |'hi'|     number of command-lines that are remembered
|'hkmap'|	  |'hk'|     Hebrew keyboard mapping
|'hkmapp'|	  |'hkp'|    phonetic Hebrew keyboard mapping
|'icon'|		     let Vim set the text of the window icon
|'iconstring'|		     string to use for the Vim icon text
|'ignorecase'|	  |'ic'|     ignore case in search patterns
|'imactivatekey'| |'imak'|   key that activates the X input method
|'imcmdline'|	  |'imc'|    use IM when starting to edit a command line
|'imdisable'|	  |'imd'|    do not use the IM in any mode
|'iminsert'|	  |'imi'|    use :lmap or IM in Insert mode
|'imsearch'|	  |'ims'|    use :lmap or IM when typing a search pattern
|'include'|	  |'inc'|    pattern to be used to find an include file
|'includeexpr'|   |'inex'|   expression used to process an include line
|'incsearch'|	  |'is'|     highlight match while typing search pattern
|'indentexpr'|	  |'inde'|   expression used to obtain the indent of a line
|'indentkeys'|	  |'indk'|   keys that trigger indenting with 'indentexpr'
|'infercase'|	  |'inf'|    adjust case of match for keyword completion
|'insertmode'|	  |'im'|     start the edit of a file in Insert mode
|'isfname'|	  |'isf'|    characters included in file names and pathnames
|'isident'|	  |'isi'|    characters included in identifiers
|'iskeyword'|	  |'isk'|    characters included in keywords
|'isprint'|	  |'isp'|    printable characters
|'joinspaces'|	  |'js'|     two spaces after a period with a join command
|'key'|			     encryption key
|'keymap'|	  |'kmp'|    name of a keyboard mapping
|'keymodel'|	  |'km'|     enable starting/stopping selection with keys
|'keywordprg'|	  |'kp'|     program to use for the "K" command
|'langmap'|	  |'lmap'|   alphabetic characters for other language mode
|'langmenu'|	  |'lm'|     language to be used for the menus
|'laststatus'|	  |'ls'|     tells when last window has status lines
|'lazyredraw'|	  |'lz'|     don't redraw while executing macros
|'linebreak'|	  |'lbr'|    wrap long lines at a blank
|'lines'|		     number of lines in the display
|'linespace'|	  |'lsp'|    number of pixel lines to use between characters
|'lisp'|		     automatic indenting for Lisp
|'lispwords'|	  |'lw'|     words that change how lisp indenting works
|'list'|		     show <Tab> and <EOL>
|'listchars'|	  |'lcs'|    characters for displaying in list mode
|'loadplugins'|   |'lpl'|    load plugin scripts when starting up
|'magic'|		     changes special characters in search patterns
|'makeef'|	  |'mef'|    name of the errorfile for ":make"
|'makeprg'|	  |'mp'|     program to use for the ":make" command
|'matchpairs'|	  |'mps'|    pairs of characters that "%" can match
|'matchtime'|	  |'mat'|    tenths of a second to show matching paren
|'maxfuncdepth'|  |'mfd'|    maximum recursive depth for user functions
|'maxmapdepth'|   |'mmd'|    maximum recursive depth for mapping
|'maxmem'|	  |'mm'|     maximum memory (in Kbyte) used for one buffer
|'maxmempattern'| |'mmp'|    maximum memory (in Kbyte) used for pattern search
|'maxmemtot'|	  |'mmt'|    maximum memory (in Kbyte) used for all buffers
|'menuitems'|	  |'mis'|    maximum number of items in a menu
|'mkspellmem'|    |'msm'|    memory used before |:mkspell| compresses the tree
|'modeline'|	  |'ml'|     recognize modelines at start or end of file
|'modelines'|	  |'mls'|    number of lines checked for modelines
|'modifiable'|	  |'ma'|     changes to the text are not possible
|'modified'|	  |'mod'|    buffer has been modified
|'more'|		     pause listings when the whole screen is filled
|'mouse'|		     enable the use of mouse clicks
|'mousefocus'|	  |'mousef'| keyboard focus follows the mouse
|'mousehide'|	  |'mh'|     hide mouse pointer while typing
|'mousemodel'|	  |'mousem'| changes meaning of mouse buttons
|'mouseshape'|	  |'mouses'| shape of the mouse pointer in different modes
|'mousetime'|	  |'mouset'| max time between mouse double-click
|'mzquantum'|	  |'mzq'|    the interval between polls for MzScheme threads
|'nrformats'|	  |'nf'|     number formats recognized for CTRL-A command
|'number'|	  |'nu'|     print the line number in front of each line
|'numberwidth'|	  |'nuw'|    number of columns used for the line number
|'omnifunc'|      |'ofu'|    function for filetype-specific completion
|'operatorfunc'|  |'opfunc'| funtion to be called for |g@| operator
|'osfiletype'|	  |'oft'|    operating system-specific filetype information
|'paragraphs'|	  |'para'|   nroff macros that separate paragraphs
|'paste'|		     allow pasting text
|'pastetoggle'|	  |'pt'|     key code that causes 'paste' to toggle
|'patchexpr'|	  |'pex'|    expression used to patch a file
|'patchmode'|	  |'pm'|     keep the oldest version of a file
|'path'|	  |'pa'|     list of directories searched with "gf" et.al.
|'preserveindent'| |'pi'|    preserve the indent structure when reindenting
|'previewheight'| |'pvh'|    height of the preview window
|'previewwindow'| |'pvw'|    identifies the preview window
|'printdevice'|   |'pdev'|   name of the printer to be used for :hardcopy
|'printencoding'| |'penc'|   encoding to be used for printing
|'printexpr'|     |'pexpr'|  expression used to print PostScript for :hardcopy
|'printfont'|	  |'pfn'|    name of the font to be used for :hardcopy
|'printheader'|   |'pheader'| format of the header used for :hardcopy
|'printmbcharset'| |'pmbcs'| CJK character set to be used for :hardcopy
|'printmbfont'|   |'pmbfn'|  font names to be used for CJK output of :hardcopy
|'printoptions'|  |'popt'|   controls the format of :hardcopy output
|'quoteescape'|   |'qe'|     escape characters used in a string
|'readonly'|	  |'ro'|     disallow writing the buffer
|'remap'|		     allow mappings to work recursively
|'report'|		     threshold for reporting nr. of lines changed
|'restorescreen'| |'rs'|     Win32: restore screen when exiting
|'revins'|	  |'ri'|     inserting characters will work backwards
|'rightleft'|	  |'rl'|     window is right-to-left oriented
|'rightleftcmd'|  |'rlc'|    commands for which editing works right-to-left
|'ruler'|	  |'ru'|     show cursor line and column in the status line
|'rulerformat'|	  |'ruf'|    custom format for the ruler
|'runtimepath'|   |'rtp'|    list of directories used for runtime files
|'scroll'|	  |'scr'|    lines to scroll with CTRL-U and CTRL-D
|'scrollbind'|	  |'scb'|    scroll in window as other windows scroll
|'scrolljump'|	  |'sj'|     minimum number of lines to scroll
|'scrolloff'|	  |'so'|     minimum nr. of lines above and below cursor
|'scrollopt'|	  |'sbo'|    how 'scrollbind' should behave
|'sections'|	  |'sect'|   nroff macros that separate sections
|'secure'|		     secure mode for reading .vimrc in current dir
|'selection'|	  |'sel'|    what type of selection to use
|'selectmode'|	  |'slm'|    when to use Select mode instead of Visual mode
|'sessionoptions'| |'ssop'|  options for |:mksession|
|'shell'|	  |'sh'|     name of shell to use for external commands
|'shellcmdflag'|  |'shcf'|   flag to shell to execute one command
|'shellpipe'|	  |'sp'|     string to put output of ":make" in error file
|'shellquote'|	  |'shq'|    quote character(s) for around shell command
|'shellredir'|	  |'srr'|    string to put output of filter in a temp file
|'shellslash'|	  |'ssl'|    use forward slash for shell file names
|'shelltemp'|	  |'stmp'|   whether to use a temp file for shell commands
|'shelltype'|	  |'st'|     Amiga: influences how to use a shell
|'shellxquote'|	  |'sxq'|    like 'shellquote', but include redirection
|'shiftround'|	  |'sr'|     round indent to multiple of shiftwidth
|'shiftwidth'|	  |'sw'|     number of spaces to use for (auto)indent step
|'shortmess'|	  |'shm'|    list of flags, reduce length of messages
|'shortname'|	  |'sn'|     non-MS-DOS: Filenames assumed to be 8.3 chars
|'showbreak'|	  |'sbr'|    string to use at the start of wrapped lines
|'showcmd'|	  |'sc'|     show (partial) command in status line
|'showfulltag'|	  |'sft'|    show full tag pattern when completing tag
|'showmatch'|	  |'sm'|     briefly jump to matching bracket if insert one
|'showmode'|	  |'smd'|    message on status line to show current mode
|'sidescroll'|	  |'ss'|     minimum number of columns to scroll horizontal
|'sidescrolloff'| |'siso'|   min. nr. of columns to left and right of cursor
|'smartcase'|	  |'scs'|    no ignore case when pattern has uppercase
|'smartindent'|   |'si'|     smart autoindenting for C programs
|'smarttab'|	  |'sta'|    use 'shiftwidth' when inserting <Tab>
|'softtabstop'|	  |'sts'|    number of spaces that <Tab> uses while editing
|'spell'|		     enable spell checking
|'spellcapcheck'| |'spc'|    pattern to locate end of a sentence
|'spellfile'|	  |'spf'|    files where |zg| and |zw| store words
|'spelllang'|	  |'spl'|    language(s) to do spell checking for
|'spellsuggest'|  |'sps'|    method(s) used to suggest spelling corrections
|'splitbelow'|	  |'sb'|     new window from split is below the current one
|'splitright'|	  |'spr'|    new window is put right of the current one
|'startofline'|   |'sol'|    commands move cursor to first blank in line
|'statusline'|	  |'stl'|    custom format for the status line
|'suffixes'|	  |'su'|     suffixes that are ignored with multiple match
|'suffixesadd'|   |'sua'|    suffixes added when searching for a file
|'swapfile'|	  |'swf'|    whether to use a swapfile for a buffer
|'swapsync'|	  |'sws'|    how to sync the swap file
|'switchbuf'|	  |'swb'|    sets behavior when switching to another buffer
|'synmaxcol'|	  |'smc'|    maximum column to find syntax items
|'syntax'|	  |'syn'|    syntax to be loaded for current buffer
|'tabstop'|	  |'ts'|     number of spaces that <Tab> in file uses
|'tagbsearch'|	  |'tbs'|    use binary searching in tags files
|'taglength'|	  |'tl'|     number of significant characters for a tag
|'tagrelative'|   |'tr'|     file names in tag file are relative
|'tags'|	  |'tag'|    list of file names used by the tag command
|'tagstack'|	  |'tgst'|   push tags onto the tag stack
|'term'|		     name of the terminal
|'termbidi'|	  |'tbidi'|  terminal takes care of bi-directionality
|'termencoding'|  |'tenc'|   character encoding used by the terminal
|'terse'|		     shorten some messages
|'textauto'|	  |'ta'|     obsolete, use 'fileformats'
|'textmode'|	  |'tx'|     obsolete, use 'fileformat'
|'textwidth'|	  |'tw'|     maximum width of text that is being inserted
|'thesaurus'|	  |'tsr'|    list of thesaurus files for keyword completion
|'tildeop'|	  |'top'|    tilde command "~" behaves like an operator
|'timeout'|	  |'to'|     time out on mappings and key codes
|'timeoutlen'|	  |'tm'|     time out time in milliseconds
|'title'|		     let Vim set the title of the window
|'titlelen'|		     percentage of 'columns' used for window title
|'titleold'|		     old title, restored when exiting
|'titlestring'|		     string to use for the Vim window title
|'toolbar'|	  |'tb'|     GUI: which items to show in the toolbar
|'toolbariconsize'| |'tbis'| size of the toolbar icons (for GTK 2 only)
|'ttimeout'|		     time out on mappings
|'ttimeoutlen'|	  |'ttm'|    time out time for key codes in milliseconds
|'ttybuiltin'|	  |'tbi'|    use built-in termcap before external termcap
|'ttyfast'|	  |'tf'|     indicates a fast terminal connection
|'ttymouse'|	  |'ttym'|   type of mouse codes generated
|'ttyscroll'|	  |'tsl'|    maximum number of lines for a scroll
|'ttytype'|	  |'tty'|    alias for 'term'
|'undolevels'|	  |'ul'|     maximum number of changes that can be undone
|'updatecount'|   |'uc'|     after this many characters flush swap file
|'updatetime'|	  |'ut'|     after this many milliseconds flush swap file
|'verbose'|	  |'vbs'|    give informative messages
|'verbosefile'|	  |'vfile'|  file to write messages in
|'viewdir'|	  |'vdir'|   directory where to store files with :mkview
|'viewoptions'|   |'vop'|    specifies what to save for :mkview
|'viminfo'|	  |'vi'|     use .viminfo file upon startup and exiting
|'virtualedit'|   |'ve'|     when to use virtual editing
|'visualbell'|	  |'vb'|     use visual bell instead of beeping
|'warn'|		     warn for shell command when buffer was changed
|'weirdinvert'|   |'wi'|     for terminals that have weird inversion method
|'whichwrap'|	  |'ww'|     allow specified keys to cross line boundaries
|'wildchar'|	  |'wc'|     command-line character for wildcard expansion
|'wildcharm'|	  |'wcm'|    like 'wildchar' but also works when mapped
|'wildignore'|	  |'wig'|    files matching these patterns are not completed
|'wildmenu'|	  |'wmnu'|   use menu for command line completion
|'wildmode'|	  |'wim'|    mode for 'wildchar' command-line expansion
|'wildoptions'|   |'wop'|    specifies how command line completion is done.
|'winaltkeys'|	  |'wak'|    when the windows system handles ALT keys
|'winheight'|	  |'wh'|     minimum number of lines for the current window
|'winfixheight'|  |'wfh'|    keep window height when opening/closing windows
|'winminheight'|  |'wmh'|    minimum number of lines for any window
|'winminwidth'|   |'wmw'|    minimal number of columns for any window
|'winwidth'|	  |'wiw'|    minimal number of columns for current window
|'wrap'|		     long lines wrap and continue on the next line
|'wrapmargin'|	  |'wm'|     chars from the right where wrapping starts
|'wrapscan'|	  |'ws'|     searches wrap around the end of the file
|'write'|		     writing to a file is allowed
|'writeany'|	  |'wa'|     write to file with no need for "!" override
|'writebackup'|   |'wb'|     make a backup before overwriting a file
|'writedelay'|	  |'wd'|     delay this many msec for each char (for debug)
------------------------------------------------------------------------------
*Q_ur*		Undo/Redo commands

|u|	  N  u		undo last N changes
|CTRL-R|  N  CTRL-R	redo last N undone changes
|U|	     U		restore last changed line
------------------------------------------------------------------------------
*Q_et*		External commands

|:shell|	:sh[ell]	start a shell
|:!|		:!{command}	execute {command} with a shell
|K|		   K		lookup keyword under the cursor with
				   'keywordprg' program (default: "man")
------------------------------------------------------------------------------
*Q_qf*		Quickfix commands

|:cc|		:cc [nr]	display error [nr] (default is the same again)
|:cnext|	:cn		display the next error
|:cprevious|	:cp		display the previous error
|:clist|	:cl		list all errors
|:cfile|	:cf		read errors from the file 'errorfile'
|:cgetfile|	:cg		like :cfile but don't jump to the first error
|:caddfile|	:caddf		add errors from the error file to the current
				   quickfix list
|:caddexpr|	:cad		add errors from an expression to the current
				   quickfix list
|:cbuffer|	:cb		read errors from text in a buffer
|:cexpr|	:cex		read errors from an expression
|:cquit|	:cq		quit without writing and return error code (to
				   the compiler)
|:make|		:make [args]	start make, read errors, and jump to first
				   error
|:grep|		:gr[ep] [args]	execute 'grepprg' to find matches and jump to
				   the first one.
------------------------------------------------------------------------------
*Q_vc*		Various commands

|CTRL-L|	   CTRL-L	Clear and redraw the screen.
|CTRL-G|	   CTRL-G	show current file name (with path) and cursor
				   position
|ga|		   ga		show ascii value of character under cursor in
				   decimal, hex, and octal
|g8|		   g8		for utf-8 encoding: show byte sequence for
			 	   character under cursor in hex.
|g_CTRL-G|	   g CTRL-G	show cursor column, line, and character
				   position
|CTRL-C|	   CTRL-C	during searches: Interrupt the search
|dos-CTRL-Break|   CTRL-Break	MS-DOS: during searches: Interrupt the search
|<Del>|		   <Del>	while entering a count: delete last character
|:version|	:ve[rsion]	show version information
|:mode|		:mode N		MS-DOS: set screen mode to N (number, C80,
				   C4350, etc.)
|:normal|	:norm[al][!] {commands}
				Execute Normal mode commands.
|Q|		Q		switch to "Ex" mode

|:redir|	:redir >{file}		redirect messages to {file}
|:silent|	:silent[!] {command}	execute {command} silently
|:confirm|	:confirm {command}	quit, write, etc., asking about
					unsaved changes or read-only files.
|:browse|	:browse {command}	open/read/write file, using a
					file selection dialog
------------------------------------------------------------------------------
*Q_ce*		Command-line editing

|c_<Esc>|	<Esc>		   abandon command-line (if 'wildchar' is
				      <Esc>, type it twice)

|c_CTRL-V|	CTRL-V {char}	   insert {char} literally
|c_CTRL-V|	CTRL-V {number}    enter decimal value of character (up to
				      three digits)
|c_CTRL-K|	CTRL-K {char1} {char2}
				   enter digraph (See |Q_di|)
|c_CTRL-R|	CTRL-R {0-9a-z"%#:-=}
				   insert the contents of a register

|c_<Left>|	<Left>/<Right>	   cursor left/right
|c_<S-Left>|	<S-Left>/<S-Right> cursor one word left/right
|c_CTRL-B|	CTRL-B/CTRL-E	   cursor to beginning/end of command-line

|c_<BS>|	<BS>		   delete the character in front of the cursor
|c_<Del>|	<Del>		   delete the character under the cursor
|c_CTRL-W|	CTRL-W		   delete the word in front of the cursor
|c_CTRL-U|	CTRL-U		   remove all characters

|c_<Up>|	<Up>/<Down>	   recall older/newer command-line that starts
				      with current command
|c_<S-Up>|	<S-Up>/<S-Down>	   recall older/newer command-line from history
|:history|	:his[tory]	   show older command-lines

Context-sensitive completion on the command-line:

|c_wildchar|	'wildchar'  (default: <Tab>)
				do completion on the pattern in front of the
				   cursor.  If there are multiple matches,
				   beep and show the first one; further
				   'wildchar' will show the next ones.
|c_CTRL-D|	CTRL-D		list all names that match the pattern in
				   front of the cursor
|c_CTRL-A|	CTRL-A		insert all names that match pattern in front
				   of cursor
|c_CTRL-L|	CTRL-L		insert longest common part of names that
				   match pattern
|c_CTRL-N|	CTRL-N		after 'wildchar' with multiple matches: go
				   to next match
|c_CTRL-P|	CTRL-P		after 'wildchar' with multiple matches: go
				   to previous match
------------------------------------------------------------------------------
*Q_ra*		Ex ranges

|:range|	,		separates two line numbers
|:range|	;		idem, set cursor to the first line number
				before interpreting the second one

|:range|	{number}	an absolute line number
|:range|	.		the current line
|:range|	$		the last line in the file
|:range|	%		equal to 1,$ (the entire file)
|:range|	*		equal to '<,'> (visual area)
|:range|	't		position of mark t
|:range|	/{pattern}[/]	the next line where {pattern} matches
|:range|	?{pattern}[?]	the previous line where {pattern} matches

|:range|	+[num]		add [num] to the preceding line number
				   (default: 1)
|:range|	-[num]		subtract [num] from the preceding line
				   number (default: 1)
------------------------------------------------------------------------------
*Q_ex*		Special Ex characters

|:bar|	    |		separates two commands (not for ":global" and ":!")
|:quote|    "		begins comment

|:_%|	    %		current file name (only where a file name is expected)
|:_#|	    #[num]	alternate file name [num] (only where a file name is
			   expected)
	Note: The next four are typed literally; these are not special keys!
|:<cword>|  <cword>	word under the cursor (only where a file name is
			   expected)
|:<cWORD>|  <cWORD>	WORD under the cursor (only where a file name is
			   expected) (see |WORD|)
|:<cfile>|  <cfile>	file name under the cursor (only where a file name is
			   expected)
|:<afile>|  <afile>	file name for autocommand (only where a file name is
			   expected)
|:<sfile>|  <sfile>	file name of a ":source"d file, within that file (only
			   where a file name is expected)

		After "%", "#", "<cfile>", "<sfile>" or "<afile>"
		|::p|	    :p		full path
		|::h|	    :h		head (file name removed)
		|::t|	    :t		tail (file name only)
		|::r|	    :r		root (extension removed)
		|::e|	    :e		extension
		|::s|	    :s/{pat}/{repl}/	substitute {pat} with {repl}
------------------------------------------------------------------------------
*Q_st*		Starting VIM

|-vim|	   vim [options]		start editing with an empty buffer
|-file|	   vim [options] {file} ..	start editing one or more files
|--|	   vim [options] -		read file from stdin
|-tag|	   vim [options] -t {tag}	edit the file associated with {tag}
|-qf|	   vim [options] -q [fname]	start editing in QuickFix mode,
					   display the first error

	Most useful Vim arguments (for full list see |startup-options|)

|-gui|	-g		    start GUI (also allows other options)

|-+|	+[num]		    put the cursor at line [num] (default: last line)
|-+c|	+{command}	    execute {command} after loading the file
|-+/|	+/{pat} {file} ..   put the cursor at the first occurrence of {pat}
|-v|	-v		    Vi mode, start ex in Normal mode
|-e|	-e		    Ex mode, start vim in Ex mode
|-R|	-R		    Read-only mode, implies -n
|-m|	-m		    modifications not allowed (resets 'write' option)
|-d|	-d		    diff mode |diff|
|-b|	-b		    binary mode
|-l|	-l		    lisp mode
|-A|	-A		    Arabic mode ('arabic' is set)
|-F|	-F		    Farsi mode ('fkmap' and 'rightleft' are set)
|-H|	-H		    Hebrew mode ('hkmap' and 'rightleft' are set)
|-V|	-V		    Verbose, give informative messages
|-C|	-C		    Compatible, set the 'compatible' option
|-N|	-N		    Nocompatible, reset the 'compatible' option
|-r|	-r		    give list of swap files
|-r|	-r {file} ..	    recover aborted edit session
|-n|	-n		    do not create a swap file
|-o|	-o [num]	    open [num] windows (default: one for each file)
|-f|	-f		    GUI: foreground process, don't fork
			    Amiga: do not restart VIM to open a window (for
				e.g., mail)
|-s|	-s {scriptin}	    first read commands from the file {scriptin}
|-w|	-w {scriptout}	    write typed chars to file {scriptout} (append)
|-W|	-W {scriptout}	    write typed chars to file {scriptout} (overwrite)
|-T|	-T {terminal}	    set terminal name
|-d|	-d {device}	    Amiga: open {device} to be used as a console
|-u|	-u {vimrc}	    read inits from {vimrc} instead of other inits
|-U|	-U {gvimrc}	    idem, for when starting the GUI
|-i|	-i {viminfo}	    read info from {viminfo} instead of other files
|---|	--		    end of options, other arguments are file names
|--help|    --help	    show list of arguments and exit
|--version| --version	    show version info and exit
|--|	-		    Read file from stdin.
------------------------------------------------------------------------------
*Q_ed*		Editing a file

	   Without !: Fail if changes has been made to the current buffer.
	      With !: Discard any changes to the current buffer.
|:edit_f|  :e[dit][!] {file}	Edit {file}.
|:edit|	   :e[dit][!]		Reload the current file.
|:enew|	   :ene[w][!]		Edit a new, unnamed buffer.
|:find|    :fin[d][!] {file}	Find {file} in 'path' and edit it.

|CTRL-^|   N   CTRL-^		Edit alternate file N (equivalent to ":e #N").
|gf|	       gf  or ]f	Edit the file whose name is under the cursor
|:pwd|	   :pwd			Print the current directory name.
|:cd|	   :cd [path]		Change the current directory to [path].
|:cd-|	   :cd -		Back to previous current directory.
|:file|	   :f[ile]		Print the current file name and the cursor
				   position.
|:file|	   :f[ile] {name}	Set the current file name to {name}.
|:files|   :files		Show alternate file names.
------------------------------------------------------------------------------
*Q_fl*		Using the argument list			|argument-list|

|:args|	   :ar[gs]		Print the argument list, with the current file
				   in "[]".
|:all|	   :all  or :sall	Open a window for every file in the arg list.
|:wn|	   :wn[ext][!]		Write file and edit next file.
|:wn|	   :wn[ext][!] {file}	Write to {file} and edit next file, unless
				   {file} exists.  With !, overwrite existing
				   file.
|:wN|	   :wN[ext][!] [file]	Write file and edit previous file.

	     in current window    in new window	~
|:argument|  :argu[ment] N	  :sar[gument] N	Edit file N
|:next|	     :n[ext]		  :sn[ext]		Edit next file
|:next_f|    :n[ext] {arglist}	  :sn[ext] {arglist}	define new arg list
							   and edit first file
|:Next|	     :N[ext]		  :sN[ext]		Edit previous file
|:first|     :fir[st]		  :sfir[st]		Edit first file
|:last|	     :la[st]		  :sla[st]		Edit last file
------------------------------------------------------------------------------
*Q_wq*		Writing and quitting

|:w|	  :[range]w[rite][!]		Write to the current file.
|:w_f|	  :[range]w[rite] {file}	Write to {file}, unless it already
					   exists.
|:w_f|	  :[range]w[rite]! {file}	Write to {file}.  Overwrite an existing
					   file.
|:w_a|	  :[range]w[rite][!] >>		Append to the current file.
|:w_a|	  :[range]w[rite][!] >> {file}	Append to {file}.
|:w_c|	  :[range]w[rite] !{cmd}	Execute {cmd} with [range] lines as
					   standard input.
|:up|	  :[range]up[date][!]		write to current file if modified
|:wall|	  :wa[ll][!]			write all changed buffers

|:q|	  :q[uit]		Quit current buffer, unless changes have been
				   made.  Exit Vim when there are no other
				   non-help buffers
|:q|	  :q[uit]!		Quit current buffer always, discard any
				   changes.  Exit Vim when there are no other
				   non-help buffers
|:qa|	  :qa[ll]		Exit Vim, unless changes have been made.
|:qa|	  :qa[ll]!		Exit Vim always, discard any changes.
|:cq|	  :cq			Quit without writing and return error code.

|:wq|	  :wq[!]		Write the current file and exit.
|:wq|	  :wq[!] {file}		Write to {file} and exit.
|:xit|	  :x[it][!] [file]	Like ":wq" but write only when changes have
				   been made
|ZZ|	     ZZ			Same as ":x".
|ZQ|	     ZQ			Same as ":q!".
|:xall|	  :xa[ll][!]  or :wqall[!]
				Write all changed buffers and exit

|:stop|	  :st[op][!]		Suspend VIM or start new shell.  If 'aw' option
				   is set and [!] not given write the buffer.
|CTRL-Z|     CTRL-Z		Same as ":stop"
------------------------------------------------------------------------------
*Q_ac*		Automatic Commands

|viminfo-file|	Read registers, marks, history at startup, save when exiting.

|:rviminfo|	:rv[iminfo] [file]	Read info from viminfo file [file]
|:rviminfo|	:rv[iminfo]! [file]	idem, overwrite existing info
|:wviminfo|	:wv[iminfo] [file]	Add info to viminfo file [file]
|:wviminfo|	:wv[iminfo]! [file]	Write info to viminfo file [file]

|modeline|	Automatic option setting when editing a file

|modeline|	vim:{set-arg}: ..	In the first and last lines of the
					file (see 'ml' option), {set-arg} is
					given as an argument to ":set"

|autocommand|	Automatic execution of commands on certain events.

|:autocmd|	:au			List all autocommands
|:autocmd|	:au {event}		List all autocommands for {event}
|:autocmd|	:au {event} {pat}	List all autocommands for {event} with
					{pat}
|:autocmd|	:au {event} {pat} {cmd}	Enter new autocommands for {event}
					with {pat}
|:autocmd|	:au!			Remove all autocommands
|:autocmd|	:au! {event}		Remove all autocommands for {event}
|:autocmd|	:au! * {pat}		Remove all autocommands for {pat}
|:autocmd|	:au! {event} {pat}	Remove all autocommands for {event}
					with {pat}
|:autocmd|	:au! {event} {pat} {cmd}  Remove all autocommands for {event}
					with {pat} and enter new one
------------------------------------------------------------------------------
*Q_wi*		Multi-window commands

|CTRL-W_s|	CTRL-W s  or  :split	Split window into two parts
|:split_f|	:split {file}		Split window and edit {file} in one of
					   them
|:vsplit|	:vsplit {file}		Same, but split vertically
|:vertical|	:vertical {cmd}		Make {cmd} split vertically

|:sfind|	:sf[ind] {file}		Split window, find {file} in 'path'
					   and edit it.
|CTRL-W_]|	CTRL-W ]		Split window and jump to tag under
					   cursor
|CTRL-W_f|	CTRL-W f		Split window and edit file name under
					   the cursor
|CTRL-W_^|	CTRL-W ^		Split window and edit alternate file
|CTRL-W_n|	CTRL-W n  or  :new	Create new empty window
|CTRL-W_q|	CTRL-W q  or  :q[uit]	Quit editing and close window
|CTRL-W_c|	CTRL-W c  or  :cl[ose]	Make buffer hidden and close window
|CTRL-W_o|	CTRL-W o  or  :on[ly]	Make current window only one on the
					   screen

|CTRL-W_j|	CTRL-W j		Move cursor to window below
|CTRL-W_k|	CTRL-W k		Move cursor to window above
|CTRL-W_CTRL-W|	CTRL-W CTRL-W		Move cursor to window below (wrap)
|CTRL-W_W|	CTRL-W W		Move cursor to window above (wrap)
|CTRL-W_t|	CTRL-W t		Move cursor to top window
|CTRL-W_b|	CTRL-W b		Move cursor to bottom window
|CTRL-W_p|	CTRL-W p		Move cursor to previous active window

|CTRL-W_r|	CTRL-W r		Rotate windows downwards
|CTRL-W_R|	CTRL-W R		Rotate windows upwards
|CTRL-W_x|	CTRL-W x		Exchange current window with next one

|CTRL-W_=|	CTRL-W =		Make all windows equal height
|CTRL-W_-|	CTRL-W -		Decrease current window height
|CTRL-W_+|	CTRL-W +		Increase current window height
|CTRL-W__|	CTRL-W _		Set current window height (default:
					   very high)
------------------------------------------------------------------------------
*Q_bu*		Buffer list commands

|:buffers|	:buffers  or  :files	list all known buffer and file names

|:ball|		:ball	  or  :sball	edit all args/buffers
|:unhide|	:unhide   or  :sunhide	edit all loaded buffers

|:badd|		:badd {fname}		add file name {fname} to the list
|:bunload|	:bunload[!] [N]		unload buffer [N] from memory
|:bdelete|	:bdelete[!] [N]		unload buffer [N] and delete it from
					   the buffer list

	      in current window   in new window	~
|:buffer|     :[N]buffer [N]	  :[N]sbuffer [N]     to arg/buf N
|:bnext|      :[N]bnext [N]	  :[N]sbnext [N]      to Nth next arg/buf
|:bNext|      :[N]bNext [N]	  :[N]sbNext [N]      to Nth previous arg/buf
|:bprevious|  :[N]bprevious [N]   :[N]sbprevious [N]  to Nth previous arg/buf
|:bfirst|     :bfirst		  :sbfirst	      to first arg/buf
|:blast|      :blast		  :sblast	      to last arg/buf
|:bmodified|  :[N]bmod [N]	  :[N]sbmod [N]	      to Nth modified buf
------------------------------------------------------------------------------
*Q_sy*		Syntax Highlighting

|:syn-on|	:syntax on		start using syntax highlighting
|:syn-off|	:syntax off		stop using syntax highlighting

|:syn-keyword|	:syntax keyword {group-name} {keyword} ..
					add a syntax keyword item
|:syn-match|	:syntax match {group-name} {pattern} ...
					add syntax match item
|:syn-region|	:syntax region {group-name} {pattern} ...
					add syntax region item
|:syn-sync|	:syntax sync [ccomment | lines {N} | ...]
					tell syntax how to sync
|:syntax|	:syntax [list]		list current syntax items
|:syn-clear|	:syntax clear		clear all syntax info

|:highlight|	:highlight clear	clear all highlight info
|:highlight|	:highlight {group-name} {key}={arg} ..
					set highlighting for {group-name}

|:filetype|	:filetype on		switch on file type detection, without
					syntax highlighting
|:filetype|	:filetype plugin indent on
					switch on file type detection, with
					automatic indenting and settings
------------------------------------------------------------------------------
*Q_gu*		GUI commands

|:gui|		:gui			UNIX: start the GUI
|:gui|		:gui {fname} ..		idem, and edit {fname} ..

|:menu|		:menu			list all menus
|:menu|		:menu {mpath}		list menus starting with {mpath}
|:menu|		:menu {mpath} {rhs}	add menu {mpath}, giving {lhs}
|:menu|		:menu {pri} {mpath} {rhs}
					idem, with priorities {pri}
|:menu|		:menu ToolBar.{name} {rhs}
					add toolbar item, giving {lhs}
|:tmenu|	:tmenu {mpath} {text}	add tooltip to menu {mpath}
|:unmenu|	:unmenu {mpath}		remove menu {mpath}
------------------------------------------------------------------------------
*Q_fo*		Folding

|'foldmethod'|	set foldmethod=manual	manual folding
		set foldmethod=indent	folding by indent
		set foldmethod=expr	folding by 'foldexpr'
		set foldmethod=syntax	folding by syntax regions
		set foldmethod=marker	folding by 'foldmarkers'

|zf|		zf{motion}		operator: Define a fold manually
|:fold|		:{range}fold		define a fold for {range} lines
|zd|		zd			delete one fold under the cursor
|zD|		zD			delete all folds under the cursor

|zo|		zo			open one fold under the cursor
|zO|		zO			open all folds under the cursor
|zc|		zc			close one fold under the cursor
|zC|		zC			close all folds under the cursor

|zm|		zm			fold more: decrease 'foldlevel'
|zM|		zM			close all folds: make 'foldlevel' zero
|zr|		zr			reduce folding: increase 'foldlevel'
|zR|		zR			open all folds: make 'foldlevel' max.

|zn|		zn			fold none: reset 'foldenable'
|zN|		zN			fold normal set 'foldenable'
|zi|		zi			invert 'foldenable'

 vim:tw=78:ts=8:ft=help:norl:
