cmdline.txt

MSYS在windows下模拟了一个类unix的终端

>	:set ai		"set 'autoindent' option
It is not possible to add a comment to a shell command ":!cmd" or to the
":map" command and friends, because they see the '"' as part of their
argument.

							*:bar* *:\bar*
'|' can be used to separate commands, so you can give multiple commands in one
line.  If you want to use '|' in an argument, precede it with '\'.

These commands see the '|' as their argument, and can therefore not be
followed by another command:
    :autocmd
    :global
    :normal
    :perl
    :perldo
    :pyfile
    :python
    :read !
    :tcl
    :tcldo
    :tclfile
    :vglobal
    :write !
    :[range]!

Note that this is confusing (inherited from Vi): With ":g" the '|' is included
in the command, with ":s" it is not.

To be able to use another command anyway, use the ":execute" command.
Example (append the output of "ls" and jump to the first line):
>	:execute 'r !ls' | '[

There is one exception: When the 'b' flag is present in 'cpoptions', with the
":map" and ":abbr" commands and friends CTRL-V needs to be used instead of
'\'.  You can also use "<Bar>" instead.  See also |map_bar|.

Examples:
>	:!ls | wc		view the output of two commands
>	:r !ls | wc		insert the same output in the text
>	:%g/foo/p|>		moves all matching lines one shiftwidth
>	:%s/foo/bar/|>		moves one line one shiftwidth
>	:map q 10^V|		map "q" to "10|"
>	:map q 10\| map \ l	map "q" to "10\" and map "\" to "l"
>					(when 'b' is present in 'cpoptions')

You can also use <NL> to separate commands in the same way as with '|'.  To
insert a <NL> use CTRL-V CTRL-J.  "^@" will be shown.  Using '|' is the
preferred method.  But for external commands a <NL> must be used, because a
'|' is included in the external command.  To avoid the special meaning of <NL>
it must be preceded with a backslash.  Example:
>	:r !date<NL>-join
This reads the current date into the file and joins it with the previous line.

Note that when the command before the '|' generates an error, the following
commands will not be executed.


Because of Vi compatibility the following strange commands are supported:
>	:|			print current line (like ":p")
>	:3|			print line 3 (like ":3p")
>	:3			goto line 3

A colon is allowed between the range and the command name.  It is ignored
(this is Vi compatible).  For example:
>	:1,$:s/pat/string

When the character '%' or '#' is used where a file name is expected, they are
expanded to the current and alternate file name (see the chapter "editing
files" |:_%| |:_#|).

Embedded spaces in file names are allowed on the Amiga if one file name is
expected as argument.  Trailing spaces will be ignored, unless escaped with a
backslash or CTRL-V.  Note that the ":next" command uses spaces to separate
file names.  Escape the spaces to include them in a file name.  Example:
>	:next foo\ bar goes\ to school\
starts editing the three files "foo bar", "goes to" and "school ".

When you want to use the special characters '"' or '|' in a command, or want
to use '%' or '#' in a file name, precede them with a backslash.  The
backslash is not required in a range and in the ":substitute" command.

							*:_!*
The '!' (bang) character after an Ex command makes the command behave in a
different way.  The '!' should be placed immediately after the command, without
any blanks in between.  If you insert blanks the '!' will be seen as an
argument for the command, which has a different meaning.  For example:
	:w! name	write the current buffer to file "name", overwriting
			any existing file
	:w !name	send the current buffer as standard input to command
			"name"

==============================================================================
4. Ex command-line ranges			*cmdline-ranges* *[range]*

Some Ex commands accept a line range in front of them.  This is noted as
[range].  It consists of one or more line specifiers, separated with ',' or
';'.

						*:,* *:;*
When separated with ';' the cursor position will be set to that line
before interpreting the next line specifier.  This doesn't happen for ','.
Examples:
>	4,/this line/		from line 4 till match with "this line" after
>				the cursor line.
>	5;/that line/		from line 5 till match with "that line" after
>				line 5.

The default line specifier for most commands is the cursor position, but the
commands ":write" and ":global" have the whole file (1,$) as default.

If more line specifiers are given than required for the command, the first
one(s) will be ignored.

Line numbers may be specified with:			*:range*
	{number}	an absolute line number
	.		the current line			  *:.*
	$		the last line in the file		  *:$*
	%		equal to 1,$ (the entire file)		  *:%*
	't		position of mark t (lower case)		  *:'*
	/{pattern}[/]	the next line where {pattern} matches	  *:/*
	?{pattern}[?]	the previous line where {pattern} matches *:?*
	\/		the next line where the previously used search
			pattern matches
	\?		the previous line where the previously used search
			pattern matches
	\&		the next line where the previously used substitute
			pattern matches

Each may be followed (several times) by '+' or '-' and an optional number.
This number is added or subtracted from the preceding line number.  If the
number is omitted, 1 is used.

The "/" and "?" after {pattern} are required to separate the pattern from
anything that follows.

The "/" and "?" may be preceded with another address.  The search starts from
there.  The difference from using ';' is that the cursor isn't moved.
Examples:
>	/pat1//pat2/	Find line containing "pat2" after line containing
>			"pat1", without moving the cursor.
>	7;/pat2/	Find line containing "pat2", after line 7, leaving
>			the cursor in line 7.

The {number} must be between 0 and the number of lines in the file.  When
using a 0 (zero) this is interpreted as a 1 by most commands.  Commands that
use it as a count do use it as a zero (|:tag|, |:pop|, etc).  Some commands
interpret the zero as "before the first line" (|:read|, search pattern, etc).

Examples:
>	.+3		three lines below the cursor
>	/that/+1	the line below the next line containing "that"
>	.,$		from current line until end of file
>	0;/that		the first line containing "that", also matches in the
>			first line.
>	1;/that		the first line after line 1 containing "that"

Some commands allow for a count after the command.  This count is used as the
number of lines to be used, starting with the line given in the last line
specifier (the default is the cursor line).  The commands that accept a count
are the ones that use a range but do not have a file name argument (because
a file name can also be a number).

Examples:
>	:s/x/X/g 5	substitute 'x' by 'X' in the current line and four
>			following lines
>	:23d 4		delete lines 23, 24, 25 and 26

A range should have the lower line number first.  If this is not the case, Vim
will ask you if it should swap the line numbers.  This is not done within the
global command ":g".

							*N:*
When giving a count before entering ":", this is translated into:
		:.,.+(count - 1)
In words: The 'count' lines at and after the cursor.  Example: To delete
three lines:
>		3:d<CR>		is translated into: .,.+2d<CR>

							*v_:*
{Visual}:	Starts a command-line with the Visual selected lines as a
		range.  The code ":'<,'>" is used for this range, which makes
		it possible to select a similar line from the command-line
		history for repeating a command on different Visually selected
		lines.

==============================================================================
5. Ex special characters				*cmdline-special*

In Ex commands, at places where a file name can be used, the following
characters have a special meaning.  These can also be used in the expression
function expand() |expand()|.
	%	   is replaced with the current file name		*:_%*
	#	   is replaced with the alternate file name		*:_#*
	#n	   (where n is a number) is replaced with the file name of
		   buffer n.  "#0" is the same as "#"
Note that these give the file name as it was typed.  If an absolute path is
needed (when using the file name from a different directory), you need to add
":p".  See |filename-modifiers|.

To avoid the special meaning of '%' and '#' insert a backslash before it.
Detail: The special meaning is always escaped when there is a backslash before
it, no matter how many backslashes.
	you type:		result	~
	   #			alternate.file
	   \#			#
	   \\#			\#

			       *:<cword>* *:<cWORD>* *:<cfile>* *<cfile>*
			       *:<sfile>* *<sfile>* *:<afile>* *<afile>*
			       *:<abuf>* *<abuf>* *:<amatch>* *<amatch>*
Note: these are typed literally, they are not special keys!
	<cword>    is replaced with the word under the cursor (like |star|)
	<cWORD>    is replaced with the WORD under the cursor (see |WORD|)
	<cfile>    is replaced with the path name under the cursor
	<afile>    when executing autocommands, is replaced with the file name
		   for a file read or write
	<abuf>     when executing autocommands, is replaced with the currently
		   effective buffer number (for ":r file" it is the current
		   buffer, the file being read is not in a buffer).
	<amatch>   when executing autocommands, is replaced with the match for
		   which this autocommand was executed.  It differs form
		   <afile> only when the file name isn't used to match with
		   (for FileType and Syntax events).
	<sfile>    when executing a ":source" command, is replaced with the
		   file name of the sourced file;
		   when executing a function, is replaced with
		   "function {function-name}"; function call nesting is
		   indicated like this:
		   "function {function-name1}->{function-name2}".  Note that
		   filename-modifiers are useless when <sfile> is used inside
		   a function.

							 *filename-modifiers*
		 *:_%:* *::p* *::.* *::~* *::h* *::t* *::r* *::e* *::s* *::gs*
The file name modifiers can be used after "%", "#", "#n", "<cfile>", "<sfile>",
"<afile>" or "<abuf>".  They are also used with the |fnamemodify()| function.
These are not available when Vim has been compiled without the |+modify_fname|
feature.
These modifiers can be given, in this order:
	:p	Make file name a full path.  Must be the first modifier.
	:~	Reduce file name to be relative to the home directory, if
		possible.  File name is unmodified if it is not below the home
		directory.
	:.	Reduce file name to be relative to current directory, if
		possible.  File name is unmodified if it is not below the
		current directory.
		For maximum shortness, use ":~:.".
	:h	Head of the file name (the last component and any separators
		removed).  Cannot be used with :e, :r or :t.
		Can be repeated to remove several components at the end.
		When the file name is an absolute path (starts with "/" for
		Unix; "x:\" for MS-DOS, WIN32, OS/2; "drive:" for Amiga), that
		part is not removed.  When there is no head (path is relative
		to current directory) the result is empty.
	:t	Tail of the file name (last component of the name).  Must
		precede any :r or :e.
	:r	Root of the file name (the last extension removed).  When
		there is only an extension (file name that starts with '.',
		e.g., ".vimrc"), it is not removed.  Can be repeated to remove
		several extensions (last one first).
	:e	Extension of the file name.  Only makes sense when used alone.
		When there is no extension the result is empty.
		When there is only an extension (file name that starts with
		'.'), the result is empty.  Can be repeated to include more
		extensions.  If there are not enough extensions (but at least
		one) as much as possible are included.
	:s?pat?sub?
		Substitute the first occurrence of "pat" with "sub".  This
		works like the |:s| command.  "pat" is a regular expression.
		Any character can be used for '?', but it must not occur in
		"pat" or "sub".
		After this, the previous modifiers can be used again.  For
		example ":p", to make a full path after the substitution.
	:gs?pat?sub?
		Substitute all occurrences of "path" with "sub".  Otherwise
		this works like ":s".

Examples, when the file name is "src/version.c", current dir "/home/mool/vim":
>  :p			/home/mool/vim/src/version.c
>  :p:.				       src/version.c
>  :p:~				 ~/vim/src/version.c
>  :h				       src
>  :p:h			/home/mool/vim/src
>  :p:h:h		/home/mool/vim
>  :t					   version.c
>  :p:t					   version.c
>  :r				       src/version
>  :p:r			/home/mool/vim/src/version
>  :t:r					   version
>  :e						   c
>  :s?version?main?		       src/main.c
>  :s?version?main?:p	/home/mool/vim/src/main.c
>  :p:gs?/?\\?		\home\mool\vim\src\version.c

Examples, when the file name is "src/version.c.gz":
>  :p			/home/mool/vim/src/version.c.gz
>  :e						     gz
>  :e:e						   c.gz
>  :e:e:e					   c.gz
>  :e:e:r					   c
>  :r				       src/version.c
>  :r:e						   c
>  :r:r				       src/version
>  :r:r:r			       src/version

					*extension-removal* *:_%<*
If a "<" is appended to "%", "#", "#n" or "CTRL-V p" the extension of the file
name is removed (everything after and including the last '.' in the file
name).  This is included for backwards compatibility with version 3.0, the
":r" form is preferred.  Examples:

>	%		current file name
>	%<		current file name without extension
>	#		alternate file name for current window
>	#<		idem, without extension
>	#31		alternate file number 31
>	#31<		idem, without extension
>	<cword>		word under the cursor
>	<cWORD>		WORD under the cursor (see |WORD|)
>	<cfile>		path name under the cursor
>	<cfile><	idem, without extension

Note: Where a file name is expected wildcards expansion is done.  On Unix the
shell is used for this.  Backticks also work, like in
>	:n `echo *.c`
(backtick expansion is not possible in |restricted-mode|)
But expansion is only done if there are any wildcards before expanding the
'%', '#', etc..  This avoids expanding wildcards inside a file name.  If you
want to expand the result of <cfile>, add a wildcard character to it.
Examples: (alternate file name is "?readme?")
	command		expands to  ~
	:e #		:e ?readme?
	:e `ls #`	:e {files matching "?readme?"}
	:e #.*		:e {files matching "?readme?.*"}
	:cd <cfile>	:cd {file name under cursor}
	:cd <cfile>*	:cd {file name under cursor plus "*" and then expanded}

							*filename-backslash*
For filesystems that use a backslash as directory separator (MS-DOS, Windows,
OS/2), it's a bit difficult to recognize a backslash that is used to escape
the special meaning of the next character.  The general rule is: If the
backslash is followed by a normal file name character, it does not have a
special meaning.  Therefore "\file\foo" is a valid file name, you don't have
to type the backslash twice.

And exception is the '$' sign.  It is a valid character in a file name.  But
to avoid a file name like "$home" to be interpreted as an environment variable,
it needs to be preceded by a backslash.  Therefore you need to use "/\$home"
for the file "$home" in the root directory.  A few examples:

	FILE NAME	INTERPRETED AS	~
	$home		expanded to value of environment var $home
	\$home		file "$home" in current directory
	/\$home		file "$home" in root directory
	\\$home		file "\\", followed by expanded $home

 vim:tw=78:ts=8:sw=8: