VIM: eval

## EVAL

    *eval.txt*      For Vim version 6.1.  Last change: 2002 Mar 21

    		  VIM REFERENCE MANUAL    by Bram Moolenaar

    Expression evaluation			*expression* *expr* *E15* *eval*

    Using expressions is introduced in chapter 41 of the user manual |usr_41|.

    Note: Expression evaluation can be disabled at compile time.  If this has been
    done, the features in this document are not available.  See |+eval| and the
    last chapter below.

    1. Variables		|variables|
    2. Expression syntax	|expression-syntax|
    3. Internal variable	|internal-variables|
    4. Builtin Functions	|functions|
    5. Defining functions	|user-functions|
    6. Curly braces names	|curly-braces-names|
    7. Commands		|expression-commands|
    8. Examples		|eval-examples|
    9. No +eval feature	|no-eval-feature|
    10. The sandbox		|eval-sandbox|

    {Vi does not have any of these commands}

    1. Variables						*variables*

    There are two types of variables:

    Number		a 32 bit signed number.
    String		a NUL terminated string of 8-bit unsigned characters.

    These are converted automatically, depending on how they are used.

    Conversion from a Number to a String is by making the ASCII representation of
    the Number.  Examples:
    Number 123	-->	String "123"
    Number 0	-->	String "0"
    Number -1	-->	String "-1"

    Conversion from a String to a Number is done by converting the first digits
    to a number.  Hexadecimal "0xf9" and Octal "017" numbers are recognized.  If
    the String doesn't start with digits, the result is zero.  Examples:
    String "456"	-->	Number 456
    String "6bar"	-->	Number 6
    String "foo"	-->	Number 0
    String "0xf1"	-->	Number 241
    String "0100"	-->	Number 64

    To force conversion from String to Number, add zero to it:
    :echo "0100" + 0

    For boolean operators Numbers are used.  Zero is FALSE, non-zero is TRUE.

    Note that in the command
    :if "foo"
    "foo" is converted to 0, which means FALSE.  To test for a non-empty string,
    use strlen():
    :if strlen("foo")

    If you need to know the type of a variable or expression, use the |type()|
    function.

    When the '!' flag is included in the 'viminfo' option, global variables that
    start with an uppercase letter, and don't contain a lowercase letter, are
    stored in the viminfo file |viminfo-file|.

    When the 'sessionoptions' option contains "global", global variables that
    start with an uppercase letter and contain at least one lowercase letter are
    stored in the session file |session-file|.

    variable name		can be stored where
    my_var_6		not
    My_Var_6		session file
    MY_VAR_6		viminfo file

    It's possible to form a variable name with curly braces, see
    |curly-braces-names|.

    2. Expression syntax					*expression-syntax*

    Expression syntax summary, from least to most significant:

    |expr1| expr2 ? expr1 : expr1	if-then-else

    |expr2|	expr3 || expr3 ..	logical OR

    |expr3|	expr4 && expr4 ..	logical AND

    |expr4|	expr5 == expr5		equal
    expr5 != expr5		not equal
    expr5 >	 expr5		greater than
    expr5 >= expr5		greater than or equal
    expr5 <	 expr5		smaller than
    expr5 <= expr5		smaller than or equal
    expr5 =~ expr5		regexp matches
    expr5 !~ expr5		regexp doesn't match
    expr5 ==? expr5		equal, ignoring case
    expr5 ==# expr5		equal, match case
    etc.  As above, append ? for ignoring case, # for matching case

    |expr5|	expr6 +	 expr6 ..	number addition
    expr6 -	 expr6 ..	number subtraction
    expr6 .	 expr6 ..	string concatenation

    |expr6|	expr7 *	 expr7 ..	number multiplication
    expr7 /	 expr7 ..	number division
    expr7 %	 expr7 ..	number modulo

    |expr7|	! expr7			logical NOT
    - expr7			unary minus
    + expr7			unary plus
    expr8

    |expr8|	expr9[expr1]		index in String

    |expr9|	number			number constant
    "string"		string constant
    'string'		literal string constant
    &option			option value
    (expr1)			nested expression
    variable		internal variable
    va{ria}ble		internal variable with curly braces
    $VAR			environment variable
    @r			contents of register 'r'
    function(expr1, ...)	function call
    func{ti}on(expr1, ...)	function call with curly braces

    ".." indicates that the operations in this level can be concatenated.
    Example:
    &nu || &list && &shell == "csh"

    All expressions within one level are parsed from left to right.

    expr1							*expr1* *E109*

    expr2 ? expr1 : expr1

    The expression before the '?' is evaluated to a number.  If it evaluates to
    non-zero, the result is the value of the expression between the '?' and ':',
    otherwise the result is the value of the expression after the ':'.
    Example:
    :echo lnum == 1 ? "top" : lnum

    Since the first expression is an "expr2", it cannot contain another ?:.  The
    other two expressions can, thus allow for recursive use of ?:.
    Example:
    :echo lnum == 1 ? "top" : lnum == 1000 ? "last" : lnum

    To keep this readable, using |line-continuation| is suggested:
    :echo lnum == 1
    :\	? "top"
    :\	: lnum == 1000
    :\		? "last"
    :\		: lnum

    expr2 and expr3						*expr2* *expr3*

    					*expr-barbar* *expr-&&*
    The "||" and "&&" operators take one argument on each side.  The arguments
    are (converted to) Numbers.  The result is:

     input				 output
    n1		n2		n1 || n2	n1 && n2
    zero		zero		zero		zero
    zero		non-zero	non-zero	zero
    non-zero	zero		non-zero	zero
    non-zero	non-zero	non-zero	non-zero

    The operators can be concatenated, for example:

    &nu || &list && &shell == "csh"

    Note that "&&" takes precedence over "||", so this has the meaning of:

    &nu || (&list && &shell == "csh")

    Once the result is known, the expression "short-circuits", that is, further
    arguments are not evaluated.  This is like what happens in C.  For example:

    let a = 1
    echo a || b

    This is valid even if there is no variable called "b" because "a" is non-zero,
    so the result must be non-zero.  Similarly below:

    echo exists("b") && b == "yes"

    This is valid whether "b" has been defined or not.  The second clause will
    only be evaluated if "b" has been defined.

    expr4							*expr4*

    expr5 {cmp} expr5

    Compare two expr5 expressions, resulting in a 0 if it evaluates to false, or 1
    if it evaluates to true.

    			*expr-==*  *expr-!=*  *expr->*   *expr->=*
    			*expr-<*   *expr-<=*  *expr-=~*  *expr-!~*
    			*expr-==#* *expr-!=#* *expr->#*  *expr->=#*
    			*expr-<#*  *expr-<=#* *expr-=~#* *expr-!~#*
    			*expr-==?* *expr-!=?* *expr->?*  *expr->=?*
    			*expr-<?*  *expr-<=?* *expr-=~?* *expr-!~?*
    		use 'ignorecase'    match case	   ignore case
    equal			==		==#		==?
    not equal		!=		!=#		!=?
    greater than		>		>#		>?
    greater than or equal	>=		>=#		>=?
    smaller than		<		<#		<?
    smaller than or equal	<=		<=#		<=?
    regexp matches		=~		=~#		=~?
    regexp doesn't match	!~		!~#		!~?

    Examples:
    "abc" ==# "Abc"	  evaluates to 0
    "abc" ==? "Abc"	  evaluates to 1
    "abc" == "Abc"	  evaluates to 1 if 'ignorecase' is set, 0 otherwise

    When comparing a String with a Number, the String is converted to a Number,
    and the comparison is done on Numbers.

    When comparing two Strings, this is done with strcmp() or stricmp().  This
    results in the mathematical difference (comparing byte values), not
    necessarily the alphabetical difference in the local language.

    When using the operators with a trailing '#", or the short version and
    'ignorecase' is off, the comparing is done with strcmp().

    When using the operators with a trailing '?', or the short version and
    'ignorecase' is set, the comparing is done with stricmp().

    The "=~" and "!~" operators match the lefthand argument with the righthand
    argument, which is used as a pattern.  See |pattern| for what a pattern is.
    This matching is always done like 'magic' was set and 'cpoptions' is empty, no
    matter what the actual value of 'magic' or 'cpoptions' is.  This makes scripts
    portable.  To avoid backslashes in the regexp pattern to be doubled, use a
    single-quote string, see |literal-string|.
    Since a string is considered to be a single line, a multi-line pattern
    (containing \n, backslash-n) will not match.  However, a literal NL character
    can be matched like an ordinary character.  Examples:
    "foo\nbar" =~ "\n"	evaluates to 1
    "foo\nbar" =~ "\\n"	evaluates to 0

    expr5 and expr6						*expr5* *expr6*

    expr6 +	 expr6 ..	number addition		*expr-+*
    expr6 -	 expr6 ..	number subtraction	*expr--*
    expr6 .	 expr6 ..	string concatenation	*expr-.*

    expr7 *	 expr7 ..	number multiplication	*expr-star*
    expr7 /	 expr7 ..	number division		*expr-/*
    expr7 %	 expr7 ..	number modulo		*expr-%*

    For all, except ".", Strings are converted to Numbers.

    Note the difference between "+" and ".":
    "123" + "456" = 579
    "123" . "456" = "123456"

    When the righthand side of '/' is zero, the result is 0xfffffff.
    When the righthand side of '%' is zero, the result is 0.

    expr7							*expr7*

    ! expr7			logical NOT		*expr-!*
    - expr7			unary minus		*expr-unary--*
    + expr7			unary plus		*expr-unary-+*

    For '!' non-zero becomes zero, zero becomes one.
    For '-' the sign of the number is changed.
    For '+' the number is unchanged.

    A String will be converted to a Number first.

    These three can be repeated and mixed.  Examples:
    !-1	    == 0
    !!8	    == 1
    --9	    == 9

    expr8							*expr8*

    expr9[expr1]		index in String		*expr-[]* *E111*

    This results in a String that contains the expr1'th single character from
    expr9.  expr9 is used as a String, expr1 as a Number.

    Note that index zero gives the first character.  This is like it works in C.
    Careful: text column numbers start with one!  Example, to get the character
    under the cursor:
    :let c = getline(line("."))[col(".") - 1]

    If the length of the String is less than the index, the result is an empty
    String.

    						*expr9*
    number

    number			number constant		*expr-number*

    Decimal, Hexadecimal (starting with 0x or 0X), or Octal (starting with 0).

    string							*expr-string* *E114*

    "string"		string constant		*expr-quote*

    Note that double quotes are used.

    A string constant accepts these special characters:
    \...	three-digit octal number (e.g., "\316")
    \..	two-digit octal number (must be followed by non-digit)
    \.	one-digit octal number (must be followed by non-digit)
    \x..	two-character hex number (e.g., "\x1f")
    \x.	one-character hex number (must be followed by non-hex)
    \X..	same as \x..
    \X.	same as \x.
    \b	backspace <BS>
    \e	escape <Esc>
    \f	formfeed <FF>
    \n	newline <NL>
    \r	return <CR>
    \t	tab <Tab>
    \\	backslash
    \"	double quote
    \<xxx>	Special key named "xxx".  e.g. "\<C-W>" for CTRL-W.

    Note that "\000" and "\x00" force the end of the string.

    literal-string						*literal-string* *E115*

    'string'		literal string constant		*expr-'*

    Note that single quotes are used.

    This string is taken literally.  No backslashes are removed or have a special
    meaning.  A literal-string cannot contain a single quote.  Use a normal string
    for that.

    option						*expr-option* *E112* *E113*

    &option			option value, local value if possible
    &g:option		global option value
    &l:option		local option value

    Examples:
    	echo "tabstop is " . &tabstop
    	if &insertmode

    Any option name can be used here.  See |options|.  When using the local value
    and there is no buffer-local or window-local value, the global value is used
    anyway.

    register						*expr-register*

    @r			contents of register 'r'

    The result is the contents of the named register, as a single string.
    Newlines are inserted where required.  To get the contents of the unnamed
    register use @@.  The '=' register can not be used here.  See |registers| for
    an explanation of the available registers.

    nesting							*expr-nesting* *E110*

    (expr1)			nested expression

    environment variable					*expr-env*

    $VAR			environment variable

    The String value of any environment variable.  When it is not defined, the
    result is an empty string.
    						*expr-env-expand*
    Note that there is a difference between using $VAR directly and using
    expand("$VAR").  Using it directly will only expand environment variables that
    are known inside the current Vim session.  Using expand() will first try using
    the environment variables known inside the current Vim session.  If that
    fails, a shell will be used to expand the variable.  This can be slow, but it
    does expand all variables that the shell knows about.  Example:
    :echo $version
    :echo expand("$version")
    The first one probably doesn't echo anything, the second echoes the $version
    variable (if your shell supports it).

    internal variable					*expr-variable*

    variable		internal variable
    See below |internal-variables|.

    function call		*expr-function* *E116* *E117* *E118* *E119* *E120*

    function(expr1, ...)	function call
    See below |functions|.

    3. Internal variable				*internal-variables* *E121*

    An internal variable name can be made up of letters, digits and '_'.  But it
    cannot start with a digit.  It's also possible to use curly braces, see
    |curly-braces-names|.

    An internal variable is created with the ":let" command |:let|.
    An internal variable is destroyed with the ":unlet" command |:unlet|.
    Using a name that isn't an internal variable, or an internal variable that has
    been destroyed, results in an error.

    There are several name spaces for variables.  Which one is to be used is
    specified by what is prepended::

    	(nothing) In a function: local to a function; Otherwise: global
    |buffer-variable|    b:	  Local to the current buffer.
    |window-variable|    w:	  Local to the current window.
    |global-variable|    g:	  Global.
    |local-variable|     l:	  Local to a function.
    |script-variable|    s:	  Local to a |:source|'ed Vim script.
    |function-argument|  a:	  Function argument (only inside a function).
    |vim-variable|       v:	  Global, predefined by Vim.

    						*buffer-variable* *b:var*
    A variable name that is preceded with "b:" is local to the current buffer.
    Thus you can have several "b:foo" variables, one for each buffer.
    This kind of variable is deleted when the buffer is unloaded.  If you want to
    keep it, ensure that the buffer is not unloaded (e.g., by setting the 'hidden'
    option).

    One local buffer variable is predefined:
    					*b:changedtick-variable* *changetick*
    b:changedtick	The total number of changes to the current buffer.  It is
    		incremented for each change.  An undo command is also a change
    		in this case.  This can be used to perform an action only when
    		the buffer has changed.  Example:
    		    :if my_changedtick != b:changedtick
    		    :   let my_changedtick = b:changedtick
    		    :   call My_Update()
    		    :endif

    						*window-variable* *w:var*
    A variable name that is preceded with "w:" is local to the current window.  It
    is deleted when the window is closed.

    						*global-variable* *g:var*
    Inside functions global variables are accessed with "g:".  Omitting this will
    access a variable local to a function.  But "g:" can also be used in any other
    place if you like.

    						*local-variable* *l:var*
    Inside functions local variables are accessed without prepending anything.
    But you can also prepend "l:" if you like.

    						*script-variable* *s:var*
    In a Vim script variables starting with "s:" can be used.  They cannot be
    accessed from outside of the scripts, thus are local to the script.

    They can be used in:
    - commands executed while the script is sourced
    - functions defined in the script
    - autocommands defined in the script
    - functions and autocommands defined in functions and autocommands which were
      defined in the script (recursively)
    - user defined commands defined in the script
    Thus not in:
    - other scripts sourced from this one
    - mappings
    - etc.

    script variables can be used to avoid conflicts with global variable names.
    An example that works:

    	let s:counter = 0
    	function MyCounter()
    	  let s:counter = s:counter + 1
    	  echo s:counter
    	endfunction
    	command Tick call MyCounter()

    And an example that does NOT work:

    	let s:counter = 0
    	command Tick let s:counter = s:counter + 1 | echo s:counter

    When the ":Tick" command is executed outside the script, the s:counter
    variable will not be available.  In the previous example, calling the
    MyCounter() function sets the context for script variables to where the
    function was defined, then s:counter can be used.
    The script variables are also available when a function is defined inside a
    function that is defined in a script.  Example:

    	let s:counter = 0
    	function StartCounting(incr)
    	  if a:incr
    	    function MyCounter()
    	      let s:counter = s:counter + 1
    	    endfunction
    	  else
    	    function MyCounter()
    	      let s:counter = s:counter - 1
    	    endfunction
    	  endif
    	endfunction

    This defines the MyCounter() function either for counting up or counting down
    when calling StartCounting().  It doesn't matter from where StartCounting() is
    called, the s:counter variable will be accessible in MyCounter().

    When the same script is sourced again it will use the same script variables.
    They will remain valid as long as Vim is running.  This can be used to
    maintain a counter:

    	if !exists("s:counter")
    	  let s:counter = 1
    	  echo "script executed for the first time"
    	else
    	  let s:counter = s:counter + 1
    	  echo "script executed " . s:counter . " times now"
    	endif

    Note that this means that filetype plugins don't get a different set of script
    variables for each buffer.  Use local buffer variables instead |b:var|.

    Predefined Vim variables:			*vim-variable* *v:var*

    			*v:charconvert_from* *charconvert_from-variable*
    v:charconvert_from
    		The name of the character encoding of a file to be converted.
    		Only valid while evaluating the 'charconvert' option.

    			*v:charconvert_to* *charconvert_to-variable*
    v:charconvert_to
    		The name of the character encoding of a file after conversion.
    		Only valid while evaluating the 'charconvert' option.

    					*v:cmdarg* *cmdarg-variable*
    v:cmdarg	This variable is used for two purposes:
    		1. The extra arguments given to a file read/write command.
    		   Currently these are "++enc=" and "++ff=".  This variable is
    		   set before an autocommand event for a file read/write
    		   command is triggered.  There is a leading space to make it
    		   possible to append this variable directly after the
    		   read/write command.  Note: The "+cmd" argument isn't
    		   included here, because it will be executed anyway.
    		2. When printing a PostScript file with ":hardcopy" this is
    		   the argument for the ":hardcopy" command.  This can be used
    		   in 'printexpr'.

    					*v:count* *count-variable*
    v:count		The count given for the last Normal mode command.  Can be used
    		to get the count before a mapping.  Read-only.  Example:
    	:map _x :<C-U>echo "the count is " . v:count<CR>
    		Note: The <C-U> is required to remove the line range that you
    		get when typing ':' after a count.
    		"count" also works, for backwards compatibility.

    					*v:count1* *count1-variable*
    v:count1	Just like "v:count", but defaults to one when no count is
    		used.

    						*v:ctype* *ctype-variable*
    v:ctype		The current locale setting for characters of the runtime
    		environment.  This allows Vim scripts to be aware of the
    		current locale encoding.  Technical: it's the value of
    		LC_CTYPE.
    		This variable can not be set directly, use the |:language|
    		command.
    		Normally it's equal to 'encoding', but not always...
    		See |multi-lang|.

    					*v:dying* *dying-variable*
    v:dying		Normally zero.  When a deadly signal is caught it's set to
    		one.  When multiple signals are caught the number increases.
    		Can be used in an autocommand to check if Vim didn't
    		terminate normally. {only works on Unix}
    		Example:
    	:au VimLeave * if v:dying | echo "\nAAAAaaaarrrggghhhh!!!\n" | endif

    					*v:errmsg* *errmsg-variable*
    v:errmsg	Last given error message.  It's allowed to set this variable.
    		Example:
    	:let v:errmsg = ""
    	:silent! next
    	:if v:errmsg != ""
    	:  ... handle error
    		"errmsg" also works, for backwards compatibility.

    					*v:fname_in* *fname_in-variable*
    v:fname_in	The name of the input file.  Only valid while evaluating:
    			option		used for
    			'charconvert'	file to be converted
    			'diffexpr'	original file
    			'patchexpr'	original file
    			'printexpr'	file to be printed

    					*v:fname_out* *fname_out-variable*
    v:fname_out	The name of the output file.  Only valid while
    		evaluating:
    			option		used for
    			'charconvert'	resulting converted file (*)
    			'diffexpr'	output of diff
    			'patchexpr'	resulting patched file
    		(*) When doing conversion for a write command (e.g., ":w
    		file") it will be equal to v:fname_in.  When doing conversion
    		for a read command (e.g., ":e file") it will be a temporary
    		file and different from v:fname_in.

    					*v:fname_new* *fname_new-variable*
    v:fname_new	The name of the new version of the file.  Only valid while
    		evaluating 'diffexpr'.

    					*v:fname_diff* *fname_diff-variable*
    v:fname_diff	The name of the diff (patch) file.  Only valid while
    		evaluating 'patchexpr'.

    					*v:folddashes* *folddashes-variable*
    v:folddashes	Used for 'foldtext': dashes representing foldlevel of a closed
    		fold.
    		Read-only. |fold-foldtext|

    					*v:foldlevel* *foldlevel-variable*
    v:foldlevel	Used for 'foldtext': foldlevel of closed fold.
    		Read-only. |fold-foldtext|

    					*v:foldend* *foldend-variable*
    v:foldend	Used for 'foldtext': last line of closed fold.
    		Read-only. |fold-foldtext|

    					*v:foldstart* *foldstart-variable*
    v:foldstart	Used for 'foldtext': first line of closed fold.
    		Read-only. |fold-foldtext|

    						*v:lang* *lang-variable*
    v:lang		The current locale setting for messages of the runtime
    		environment.  This allows Vim scripts to be aware of the
    		current language.  Technical: it's the value of LC_MESSAGES.
    		This variable can not be set directly, use the |:language|
    		command.
    		It can be different from |v:ctype| when messages are desired
    		in a different language than what is used for character
    		encoding.  See |multi-lang|.

    						*v:lc_time* *lc_time-variable*
    v:lc_time	The current locale setting for time messages of the runtime
    		environment.  This allows Vim scripts to be aware of the
    		current language.  Technical: it's the value of LC_TIME.
    		This variable can not be set directly, use the |:language|
    		command.  See |multi-lang|.

    						*v:lnum* *lnum-variable*
    v:lnum		Line number for the 'foldexpr' and 'indentexpr' expressions.
    		Only valid while one of these expressions is being evaluated.
    		Read-only. |fold-expr| 'indentexpr'

    					*v:prevcount* *prevcount-variable*
    v:prevcount	The count given for the last but one Normal mode command.
    		This is the v:count value of the previous command.  Useful if
    		you want to cancel Visual mode and then use the count.
    			:vmap % <Esc>:call MyFilter(v:prevcount)<CR>
    		Read-only.

    					*v:progname* *progname-variable*
    v:progname	Contains the name (with path removed) with which vim was
    		invoked.  Allows you to do special initialisations for "view",
    		"evim" etc., or any other name you might symlink to vim.
    		Read-only.

    					*v:servername* *servername-variable*
    v:servername	The resulting registered |x11-clientserver| name if any.
    		Read-only.

    					*v:shell_error* *shell_error-variable*
    v:shell_error	Result of the last shell command.  When non-zero, the last
    		shell command had an error.  When zero, there was no problem.
    		This only works when the shell returns the error code to Vim.
    		The value -1 is often used when the command could not be
    		executed.  Read-only.
    		Example:
    	:!mv foo bar
    	:if v:shell_error
    	:  echo 'could not rename "foo" to "bar"!'
    	:endif
    		"shell_error" also works, for backwards compatibility.

    					*v:statusmsg* *statusmsg-variable*
    v:statusmsg	Last given status message.  It's allowed to set this variable.

    				*v:termresponse* *termresponse-variable*
    v:termresponse	The escape sequence returned by the terminal for the |t_RV|
    		termcap entry.  It is set when Vim receives an escape sequence
    		that starts with ESC [ or CSI and ends in a 'c', with only
    		digits, ';' and '.' in between.
    		When this option is set, the TermResponse autocommand event is
    		fired, so that you can react to the response from the
    		terminal.
    		The response from a new xterm is: "<Esc>[ Pp ; Pv ; Pc c".  Pp
    		is the terminal type: 0 for vt100 and 1 for vt220.  Pv is the
    		patch level (since this was introduced in patch 95, it's
    		always 95 or bigger).  Pc is always zero.
    		{only when compiled with |+termresponse| feature}

    				*v:this_session* *this_session-variable*
    v:this_session	Full filename of the last loaded or saved session file.  See
    		|:mksession|.  It is allowed to set this variable.  When no
    		session file has been saved, this variable is empty.
    		"this_session" also works, for backwards compatibility.

    					*v:version* *version-variable*
    v:version	Version number of Vim: Major version number times 100 plus
    		minor version number.  Version 5.0 is 500.  Version 5.1 (5.01)
    		is 501.  Read-only.  "version" also works, for backwards
    		compatibility.

    					*v:warningmsg* *warningmsg-variable*
    v:warningmsg	Last given warning message.  It's allowed to set this variable.

    4. Builtin Functions					*functions*

    See |function-list| for a list grouped by what the function is used for.

    (Use CTRL-] on the function name to jump to the full explanation)

    USAGE				RESULT	DESCRIPTION

    append( {lnum}, {string})	Number  append {string} below line {lnum}
    argc()				Number	number of files in the argument list
    argidx()			Number  current index in the argument list
    argv( {nr})			String	{nr} entry of the argument list
    browse( {save}, {title}, {initdir}, {default})
    				String	put up a file requester
    bufexists( {expr})		Number	TRUE if buffer {expr} exists
    buflisted( {expr})		Number  TRUE if buffer {expr} is listed
    bufloaded( {expr})		Number  TRUE if buffer {expr} is loaded
    bufname( {expr})		String	Name of the buffer {expr}
    bufnr( {expr})			Number	Number of the buffer {expr}
    bufwinnr( {expr})		Number	window number of buffer {expr}
    byte2line( {byte})		Number	line number at byte count {byte}
    char2nr( {expr})		Number	ASCII value of first char in {expr}
    cindent( {lnum})		Number  C indent for line {lnum}
    col( {expr})			Number	column nr of cursor or mark
    confirm( {msg} [, {choices} [, {default} [, {type}]]])
    				Number	number of choice picked by user
    cscope_connection( [{num} , {dbpath} [, {prepend}]])
    				Number	checks existence of cscope connection
    cursor( {lnum}, {col})		Number  position cursor at {lnum}, {col}
    delete( {fname})		Number	delete file {fname}
    did_filetype()			Number	TRUE if FileType autocommand event used
    escape( {string}, {chars})	String	escape {chars} in {string} with '\'
    eventhandler( )			Number  TRUE if inside an event handler
    executable( {expr})		Number	1 if executable {expr} exists
    exists( {var})			Number	TRUE if {var} exists
    expand( {expr})			String	expand special keywords in {expr}
    filereadable( {file})		Number	TRUE if {file} is a readable file
    filewritable( {file})		Number	TRUE if {file} is a writable file
    fnamemodify( {fname}, {mods})	String	modify file name
    foldclosed( {lnum})		Number  first line of fold at {lnum} if closed
    foldclosedend( {lnum})		Number  last line of fold at {lnum} if closed
    foldlevel( {lnum})		Number	fold level at {lnum}
    foldtext( )			String  line displayed for closed fold
    foreground( )			Number	bring the Vim window to the foreground
    getchar( [expr])		Number  get one character from the user
    getcharmod( )			Number  modifiers for the last typed character
    getbufvar( {expr}, {varname})		variable {varname} in buffer {expr}
    getcwd()			String	the current working directory
    getftime( {fname})		Number	last modification time of file
    getfsize( {fname})		Number	size in bytes of file
    getline( {lnum})		String	line {lnum} from current buffer
    getwinposx()			Number	X coord in pixels of GUI vim window
    getwinposy()			Number	Y coord in pixels of GUI vim window
    getwinvar( {nr}, {varname}		variable {varname} in window {nr}
    glob( {expr}])			String	expand file wildcards in {expr}
    globpath( {path}, {expr})	String	do glob({expr}) for all dirs in {path}
    has( {feature})			Number	TRUE if feature {feature} supported
    hasmapto( {what} [, {mode}])	Number	TRUE if mapping to {what} exists
    histadd( {history},{item})	String	add an item to a history
    histdel( {history} [, {item}])	String	remove an item from a history
    histget( {history} [, {index}])	String	get the item {index} from a history
    histnr( {history})		Number	highest index of a history
    hlexists( {name})		Number	TRUE if highlight group {name} exists
    hlID( {name})			Number	syntax ID of highlight group {name}
    hostname()			String	name of the machine vim is running on
    iconv( {expr}, {from}, {to})	String  convert encoding of {expr}
    indent( {lnum})			Number  indent of line {lnum}
    input( {prompt} [, {text}])	String	get input from the user
    inputdialog( {prompt} [, {text}]) String  like input() but in a GUI dialog
    inputsecret( {prompt} [, {text}]) String  like input() but hiding the text
    isdirectory( {directory})	Number	TRUE if {directory} is a directory
    libcall( {lib}, {func}, {arg})	String  call {func} in library {lib} with {arg}
    libcallnr( {lib}, {func}, {arg})  Number  idem, but return a Number
    line( {expr})			Number	line nr of cursor, last line or mark
    line2byte( {lnum})		Number	byte count of line {lnum}
    lispindent( {lnum})		Number  Lisp indent for line {lnum}
    localtime()			Number	current time
    maparg( {name}[, {mode}])	String	rhs of mapping {name} in mode {mode}
    mapcheck( {name}[, {mode}])	String	check for mappings matching {name}
    match( {expr}, {pat}[, {start}])
    				Number	position where {pat} matches in {expr}
    matchend( {expr}, {pat}[, {start})
    				Number	position where {pat} ends in {expr}
    matchstr( {expr}, {pat}[, {start}])
    				String	match of {pat} in {expr}
    mode()				String  current editing mode
    nextnonblank( {lnum})		Number	line nr of non-blank line >= {lnum}
    nr2char( {expr})		String	single char with ASCII value {expr}
    prevnonblank( {lnum})		Number	line nr of non-blank line <= {lnum}
    remote_expr( {server}, {string} [, {idvar}])
    				String	send expression
    remote_foreground( {server})	Number	bring Vim server to the foreground
    remote_peek( {serverid} [, {retvar}])
    				Number	check for reply string
    remote_read( {serverid})	String	read reply string
    remote_send( {server}, {string} [, {idvar}])
    				String	send key sequence
    rename( {from}, {to})		Number  rename (move) file from {from} to {to}
    resolve( {filename})		String  get filename a shortcut points to
    search( {pattern} [, {flags}])	Number  search for {pattern}
    searchpair( {start}, {middle}, {end} [, {flags} [, {skip}]])
    				Number  search for other end of start/end pair
    server2client( {serverid}, {string})
    				Number	send reply string
    serverlist()			String	get a list of available servers
    setbufvar( {expr}, {varname}, {val})	set {varname} in buffer {expr} to {val}
    setline( {lnum}, {line})	Number	set line {lnum} to {line}
    setwinvar( {nr}, {varname}, {val})	set {varname} in window {nr} to {val}
    strftime( {format}[, {time}])	String	time in specified format
    stridx( {haystack}, {needle})	Number	first index of {needle} in {haystack}
    strlen( {expr})			Number	length of the String {expr}
    strpart( {src}, {start}[, {len}])
    				String	{len} characters of {src} at {start}
    strridx( {haystack}, {needle})	Number	last index of {needle} in {haystack}
    strtrans( {expr})		String	translate string to make it printable
    submatch( {nr})			String  specific match in ":substitute"
    substitute( {expr}, {pat}, {sub}, {flags})
    				String	all {pat} in {expr} replaced with {sub}
    synID( {line}, {col}, {trans})	Number	syntax ID at {line} and {col}
    synIDattr( {synID}, {what} [, {mode}])
    				String	attribute {what} of syntax ID {synID}
    synIDtrans( {synID})		Number	translated syntax ID of {synID}
    system( {expr})			String	output of shell command {expr}
    tempname()			String	name for a temporary file
    tolower( {expr})		String	the String {expr} switched to lowercase
    toupper( {expr})		String	the String {expr} switched to uppercase
    type( {name})			Number	type of variable {name}
    virtcol( {expr})		Number	screen column of cursor or mark
    visualmode()			String	last visual mode used
    winbufnr( {nr})			Number	buffer number of window {nr}
    wincol()			Number	window column of the cursor
    winheight( {nr})		Number	height of window {nr}
    winline()			Number	window line of the cursor
    winnr()				Number	number of current window
    winwidth( {nr})			Number	width of window {nr}

    append({lnum}, {string})				*append()*
    		Append the text {string} after line {lnum} in the current
    		buffer.  {lnum} can be zero, to insert a line before the first
    		one.  Returns 1 for failure ({lnum} out of range) or 0 for
    		success.

    							*argc()*
    argc()		The result is the number of files in the argument list of the
    		current window.  See |arglist|.

    							*argidx()*
    argidx()	The result is the current index in the argument list.  0 is
    		the first file.  argc() - 1 is the last one.  See |arglist|.

    							*argv()*
    argv({nr})	The result is the {nr}th file in the argument list of the
    		current window.  See |arglist|.  "argv(0)" is the first one.
    		Example:
    	:let i = 0
    	:while i < argc()
    	:  let f = substitute(argv(i), '\([. ]\)', '\\&', 'g')
    	:  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
    	:  let i = i + 1
    	:endwhile

    							*browse()*
    browse({save}, {title}, {initdir}, {default})
    		Put up a file requester.  This only works when "has("browse")"
    		returns non-zero (only in some GUI versions).
    		The input fields are:
    		    {save}	when non-zero, select file to write
    		    {title}	title for the requester
    		    {initdir}	directory to start browsing in
    		    {default}	default file name
    		When the "Cancel" button is hit, something went wrong, or
    		browsing is not possible, an empty string is returned.

    bufexists({expr})					*bufexists()*
    		The result is a Number, which is non-zero if a buffer called
    		{expr} exists.
    		If the {expr} argument is a string it must match a buffer name
    		exactly.
    		If the {expr} argument is a number buffer numbers are used.
    		Unlisted buffers will be found.
    		Note that help files are listed by their short name in the
    		output of |:buffers|, but bufexists() requires using their
    		long name to be able to find them.
    		Use "bufexists(0)" to test for the existence of an alternate
    		file name.
    							*buffer_exists()*
    		Obsolete name: buffer_exists().

    buflisted({expr})					*buflisted()*
    		The result is a Number, which is non-zero if a buffer called
    		{expr} exists and is listed (has the 'buflisted' option set).
    		The {expr} argument is used like with bufexists().

    bufloaded({expr})					*bufloaded()*
    		The result is a Number, which is non-zero if a buffer called
    		{expr} exists and is loaded (shown in a window or hidden).
    		The {expr} argument is used like with bufexists().

    bufname({expr})						*bufname()*
    		The result is the name of a buffer, as it is displayed by the
    		":ls" command.
    		If {expr} is a Number, that buffer number's name is given.
    		Number zero is the alternate buffer for the current window.
    		If {expr} is a String, it is used as a regexp pattern to match
    		with the buffer names.  This is always done like 'magic' is
    		set and 'cpoptions' is empty.  When there is more than one
    		match an empty string is returned.
    		"" or "%" can be used for the current buffer, "#" for the
    		alternate buffer.
    		A full match is preferred, otherwise a match at the start, end
    		or middle of the buffer name is accepted.
    		Listed buffers are found first.  If there is a single match
    		with a listed buffer, that one is returned.  Next unlisted
    		buffers are searched for.
    		If the {expr} is a String, but you want to use it as a buffer
    		number, force it to be a Number by adding zero to it:
    			:echo bufname("3" + 0)
    		If the buffer doesn't exist, or doesn't have a name, an empty
    		string is returned.
    	bufname("#")		alternate buffer name
    	bufname(3)		name of buffer 3
    	bufname("%")		name of current buffer
    	bufname("file2")	name of buffer where "file2" matches.
    							*buffer_name()*
    		Obsolete name: buffer_name().

    							*bufnr()*
    bufnr({expr})	The result is the number of a buffer, as it is displayed by
    		the ":ls" command.  For the use of {expr}, see |bufname()|
    		above.  If the buffer doesn't exist, -1 is returned.
    		bufnr("$") is the last buffer:
    	:let last_buffer = bufnr("$")
    		The result is a Number, which is the highest buffer number
    		of existing buffers.  Note that not all buffers with a smaller
    		number necessarily exist, because ":bwipeout" may have removed
    		them.  Use bufexists() to test for the existence of a buffer.
    							*buffer_number()*
    		Obsolete name: buffer_number().
    							*last_buffer_nr()*
    		Obsolete name for bufnr("$"): last_buffer_nr().

    bufwinnr({expr})					*bufwinnr()*
    		The result is a Number, which is the number of the first
    		window associated with buffer {expr}.  For the use of {expr},
    		see |bufname()| above.  If buffer {expr} doesn't exist or
    		there is no such window, -1 is returned.  Example:
    	echo "A window containing buffer 1 is " . (bufwinnr(1))

    byte2line({byte})					*byte2line()*
    		Return the line number that contains the character at byte
    		count {byte} in the current buffer.  This includes the
    		end-of-line character, depending on the 'fileformat' option
    		for the current buffer.  The first character has byte count
    		one.
    		Also see |line2byte()|, |go| and |:goto|.
    		{not available when compiled without the |+byte_offset|
    		feature}

    char2nr({expr})						*char2nr()*
    		Return number value of the first char in {expr}.  Examples:
    			char2nr(" ")		returns 32
    			char2nr("ABC")		returns 65
    <		The current 'encoding' is used.  Example for "utf-8":
    			char2nr("á")		returns 225
    			char2nr("á"[0])		returns 195

    cindent({lnum})						*cindent()*
    		Get the amount of indent for line {lnum} according the C
    		indenting rules, as with 'cindent'.
    		The indent is counted in spaces, the value of 'tabstop' is
    		relevant.  {lnum} is used just like in |getline()|.
    		When {lnum} is invalid or Vim was not compiled the |+cindent|
    		feature, -1 is returned.

    							*col()*
    col({expr})	The result is a Number, which is the column of the file
    		position given with {expr}.  The accepted positions are:
    		    .	    the cursor position
    		    $	    the end of the cursor line (the result is the
    			    number of characters in the cursor line plus one)
    		    'x	    position of mark x (if the mark is not set, 0 is
    			    returned)
    		Note that only marks in the current file can be used.
    		Examples:
    			col(".")		column of cursor
    			col("$")		length of cursor line plus one
    			col("'t")		column of mark t
    			col("'" . markname)	column of mark markname
    		The first column is 1.  0 is returned for an error.
    		For the cursor position, when 'virtualedit' is active, the
    		column is one higher if the cursor is after the end of the
    		line.  This can be used to obtain the column in Insert mode:
    			:imap <F2> <C-O>:let save_ve = &ve<CR>
    				\<C-O>:set ve=all<CR>
    				\<C-O>:echo col(".") . "\n" <Bar>
    				\let &ve = save_ve<CR>

    						*confirm()*
    confirm({msg} [, {choices} [, {default} [, {type}]]])
    		Confirm() offers the user a dialog, from which a choice can be
    		made.  It returns the number of the choice.  For the first
    		choice this is 1.
    		Note: confirm() is only supported when compiled with dialog
    		support, see |+dialog_con| and |+dialog_gui|.
    		{msg} is displayed in a |dialog| with {choices} as the
    		alternatives.  When {choices} is missing or empty, "&OK" is
    		used (and translated).
    		{msg} is a String, use '\n' to include a newline.  Only on
    		some systems the string is wrapped when it doesn't fit.
    		{choices} is a String, with the individual choices separated
    		by '\n', e.g.
    			confirm("Save changes?", "&Yes\n&No\n&Cancel")
    		The letter after the '&' is the shortcut key for that choice.
    		Thus you can type 'c' to select "Cancel".  The shorcut does
    		not need to be the first letter:
    			confirm("file has been modified", "&Save\nSave &All")
    		For the console, the first letter of each choice is used as
    		the default shortcut key.
    		The optional {default} argument is the number of the choice
    		that is made if the user hits <CR>.  Use 1 to make the first
    		choice the default one.  Use 0 to not set a default.  If
    		{default} is omitted, 0 is used.
    		The optional {type} argument gives the type of dialog.  This
    		is only used for the icon of the Win32 GUI.  It can be one of
    		these values: "Error", "Question", "Info", "Warning" or
    		"Generic".  Only the first character is relevant.  When {type}
    		is omitted, "Generic" is used.
    		If the user aborts the dialog by pressing <Esc>, CTRL-C,
    		or another valid interrupt key, confirm() returns 0.

    		An example:
       :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2)
       :if choice == 0
       :	echo "make up your mind!"
       :elseif choice == 3
       :	echo "tasteful"
       :else
       :	echo "I prefer bananas myself."
       :endif
    		In a GUI dialog, buttons are used.  The layout of the buttons
    		depends on the 'v' flag in 'guioptions'.  If it is included,
    		the buttons are always put vertically.  Otherwise,  confirm()
    		tries to put the buttons in one horizontal line.  If they
    		don't fit, a vertical layout is used anyway.  For some systems
    		the horizontal layout is always used.

    							*cscope_connection()*
    cscope_connection([{num} , {dbpath} [, {prepend}]])
    		Checks for the existence of a |cscope| connection.  If no
    		parameters are specified, then the function returns:
    			0, if cscope was not available (not compiled in), or
    			   if there are no cscope connections;
    			1, if there is at least one cscope connection.

    		If parameters are specified, then the value of {num}
    		determines how existence of a cscope connection is checked:

    		{num}	Description of existence check
    		-----	------------------------------
    		0	Same as no parameters (e.g., "cscope_connection()").
    		1	Ignore {prepend}, and use partial string matches for
    			{dbpath}.
    		2	Ignore {prepend}, and use exact string matches for
    			{dbpath}.
    		3	Use {prepend}, use partial string matches for both
    			{dbpath} and {prepend}.
    		4	Use {prepend}, use exact string matches for both
    			{dbpath} and {prepend}.

    		Note: All string comparisons are case sensitive!

    		Examples.  Suppose we had the following (from ":cs show"):

      # pid    database name			prepend path
      0 27664  cscope.out				/usr/local

    		Invokation					Return Val
    		----------					----------
    		cscope_connection()					1
    		cscope_connection(1, "out")				1
    		cscope_connection(2, "out")				0
    		cscope_connection(3, "out")				0
    		cscope_connection(3, "out", "local")			1
    		cscope_connection(4, "out")				0
    		cscope_connection(4, "out", "local")			0
    		cscope_connection(4, "cscope.out", "/usr/local")	1

    cursor({lnum}, {col})					*cursor()*
    		Positions the cursor at the column {col} in the line {lnum}.
    		Does not change the jumplist.
    		If {lnum} is greater than the number of lines in the buffer,
    		the cursor will be positioned at the last line in the buffer.
    		If {lnum} is zero, the cursor will stay in the current line.
    		If {col} is greater than the number of characters in the line,
    		the cursor will be positioned at the last character in the
    		line.
    		If {col} is zero, the cursor will stay in the current column.

    							*delete()*
    delete({fname})	Deletes the file by the name {fname}.  The result is a Number,
    		which is 0 if the file was deleted successfully, and non-zero
    		when the deletion failed.

    							*did_filetype()*
    did_filetype()	Returns non-zero when autocommands are being executed and the
    		FileType event has been triggered at least once.  Can be used
    		to avoid triggering the FileType event again in the scripts
    		that detect the file type. |FileType|
    		When editing another file, the counter is reset, thus this
    		really checks if the FileType event has been triggered for the
    		current buffer.  This allows an autocommand that starts
    		editing another buffer to set 'filetype' and load a sytnax
    		file.

    escape({string}, {chars})				*escape()*
    		Escape the characters in {chars} that occur in {string} with a
    		backslash.  Example:
    			:echo escape('c:\program files\vim', ' \')
    <		results in:
    			c:\\program\ files\\vim

    eventhandler()						*eventhandler()*
    		Returns 1 when inside an event handler.  This means
    		interactive commands cannot be used.  Otherwise zero is
    		returned.

    executable({expr})					*executable()*
    		This function checks if an executable with the name {expr}
    		exists.  {expr} must be the name of the program without any
    		arguments.  executable() uses the normal $PATH.
    		The result is a Number:
    			1	exists
    			0	does not exist
    			-1	not implemented on this system

    							*exists()*
    exists({expr})	The result is a Number, which is non-zero if {var} is defined,
    		zero otherwise.  The {expr} argument is a string, which
    		contains one of these:
    			&option-name	Vim option (only checks if it exists,
    					not if it really works)
    			$ENVNAME	environment variable (could also be
    					done by comparing with an empty
    					string)
    			*funcname	built-in function (see |functions|)
    					or user defined function (see
    					|user-functions|).
    			varname		internal variable (see
    					|internal-variables|).
    			:cmdname	Ex command, both built-in and user
    					commands |:command|
    					returns:
    					1  for match with start of a command
    					2  full match with a command
    					3  matches several user commands
    			#event		autocommand defined for this event
    			#event#pattern	autocommand defined for this event and
    					pattern (the pattern is taken
    					literally and compared to the
    					autocommand patterns character by
    					character)

    		Examples:
    			exists("&shortname")
    			exists("$HOSTNAME")
    			exists("*strftime")
    			exists("bufcount")
    			exists(":Make")
    			exists("#CursorHold");
    			exists("#BufReadPre#*.gz")
    		There must be no space between the symbol (&/$/*/#) and the
    		name.
    		Note that the argument must be a string, not the name of the
    		variable itself!  For example:
    			exists(bufcount)
    		This doesn't check for existence of the "bufcount" variable,
    		but gets the contents of "bufcount", and checks if that
    		exists.

    expand({expr} [, {flag}])				*expand()*
    		Expand wildcards and the following special keywords in {expr}.
    		The result is a String.

    		When there are several matches, they are separated by <NL>
    		characters.  [Note: in version 5.0 a space was used, which
    		caused problems when a file name contains a space]

    		If the expansion fails, the result is an empty string.  A name
    		for a non-existing file is not included.

    		When {expr} starts with '%', '#' or '<', the expansion is done
    		like for the |cmdline-special| variables with their associated
    		modifiers.  Here is a short overview:

    			%		current file name
    			#		alternate file name
    			#n		alternate file name n
    			<cfile>		file name under the cursor
    			<afile>		autocmd file name
    			<abuf>		autocmd buffer number
    			<amatch>	autocmd matched name
    			<sfile>		sourced script file name
    			<cword>		word under the cursor
    			<cWORD>		WORD under the cursor
    			<client>	the {clientid} of the last received
    					message |server2client()|
    		Modifiers:
    			:p		expand to full path
    			:h		head (last path component removed)
    			:t		tail (last path component only)
    			:r		root (one extension removed)
    			:e		extension only

    		Example:
    			:let &tags = expand("%:p:h") . "/tags"
    		Note that when expanding a string that starts with '%', '#' or
    		'<', any following text is ignored.  This does NOT work:
    			:let doesntwork = expand("%:h.bak")
    <		Use this:
    			:let doeswork = expand("%:h") . ".bak"
    		Also note that expanding "<cfile>" and others only returns the
    		referenced file name without further expansion.  If "<cfile>"
    		is "~/.cshrc", you need to do another expand() to have the
    		"~/" expanded into the path of the home directory:
    			:echo expand(expand("<cfile>"))

    		There cannot be white space between the variables and the
    		following modifier.  The |fnamemodify()| function can be used
    		to modify normal file names.

    		When using '%' or '#', and the current or alternate file name
    		is not defined, an empty string is used.  Using "%:p" in a
    		buffer with no name, results in the current directory, with a
    		'/' added.

    		When {expr} does not start with '%', '#' or '<', it is
    		expanded like a file name is expanded on the command line.
    		'suffixes' and 'wildignore' are used, unless the optional
    		{flag} argument is given and it is non-zero.

    		Expand() can also be used to expand variables and environment
    		variables that are only known in a shell.  But this can be
    		slow, because a shell must be started.  See |expr-env-expand|.

    		See |glob()| for finding existing files.  See |system()| for
    		getting the raw output of an external command.

    filereadable({file})					*filereadable()*
    		The result is a Number, which is TRUE when a file with the
    		name {file} exists, and can be read.  If {file} doesn't exist,
    		or is a directory, the result is FALSE.  {file} is any
    		expression, which is used as a String.
    							*file_readable()*
    		Obsolete name: file_readable().

    filewritable({file})					*filewritable()*
    		The result is a Number, which is 1 when a file with the
    		name {file} exists, and can be written.  If {file} doesn't
    		exist, or is not writable, the result is 0.  If (file) is a
    		directory, and we can write to it, the result is 2.

    fnamemodify({fname}, {mods})				*fnamemodify()*
    		Modify file name {fname} according to {mods}.  {mods} is a
    		string of characters like it is used for file names on the
    		command line.  See |filename-modifiers|.
    		Example:
    			:echo fnamemodify("main.c", ":p:h")
    <		results in:
    			/home/mool/vim/vim/src
    		Note: Environment variables and "~" don't work in {fname}, use
    		|expand()| first then.

    foldclosed({lnum})					*foldclosed()*
    		The result is a Number.  If the line {lnum} is in a closed
    		fold, the result is the number of the first line in that fold.
    		If the line {lnum} is not in a closed fold, -1 is returned.

    foldclosedend({lnum})					*foldclosedend()*
    		The result is a Number.  If the line {lnum} is in a closed
    		fold, the result is the number of the last line in that fold.
    		If the line {lnum} is not in a closed fold, -1 is returned.

    foldlevel({lnum})					*foldlevel()*
    		The result is a Number, which is the foldlevel of line {lnum}
    		in the current buffer.  For nested folds the deepest level is
    		returned.  If there is no fold at line {lnum}, zero is
    		returned.  It doesn't matter if the folds are open or closed.
    		When used while updating folds (from 'foldexpr') -1 is
    		returned for lines where folds are still to be updated and the
    		foldlevel is unknown.

    							*foldtext()*
    foldtext()	Returns a String, to be displayed for a closed fold.  This is
    		the default function used for the 'foldtext' option and should
    		only be called from evaluating 'foldtext'.  It uses the
    		|v:foldstart|, |v:foldend| and |v:folddashes| variables.
    		The returned string looks like this:
    			+-- 45 lines: abcdef
    		The number of dashes depends on the foldlevel.  The "45" is
    		the number of lines in the fold.  "abcdef" is the text in the
    		first non-blank line of the fold.  Leading white space, "//"
    		or "/*" and the text from the 'foldmarker' and 'commentstring'
    		options is removed.
    		{not available when compiled without the |+folding| feature}

    							*foreground()*
    foreground()	Move the Vim window to the foreground.  Useful when sent from
    		a client to a Vim server. |remote_send()|
    		On Win32 systems this might not work, the OS does not always
    		allow a window to bring itself to the foreground.  Use
    		|remote_foreground()| instead.
    		{only in the Win32, Athena, Motif and GTK GUI versions and the
    		Win32 console version}

    getchar([expr])						*getchar()*
    		Get a single character from the user.  If it is an 8-bit
    		character, the result is a number.  Otherwise a String is
    		returned with the encoded character.
    		If [expr] is omitted, wait until a character is available.
    		If [expr] is 0, only get a character when one is available.
    		If [expr] is 1, only check if a character is available, it is
    				not consumed.  If a normal character is
    				available, it is returned, otherwise a
    				non-zero value is returned.
    		If a character available, it is returned as a Number.  Use
    		nr2char() to convert it to a String.
    		The returned value is negative for special keys.
    		The returned value is zero if no character is available.
    		There is no prompt, you will somehow have to make clear to the
    		user that a character has to be typed.
    		There is no mapping for the character.
    		Key codes are replaced, thus when the user presses the <Del>
    		key you get the code for the <Del> key, not the raw character
    		sequence.  Examples:
    			getchar() == "\<Del>"
    			getchar() == "\<S-Left>"
    <		This example redefines "f" to ignore case:
    			:nmap f :call FindChar()<CR>
    			:function FindChar()
    			:  let c = nr2char(getchar())
    			:  while col('.') < col('$') - 1
    			:    normal l
    			:    if getline('.')[col('.') - 1] ==? c
    			:      break
    			:    endif
    			:  endwhile
    			:endfunction

    getcharmod()						*getcharmod()*
    		The result is a Number which is the state of the modifiers for
    		the last obtained character with getchar() or in another way.
    		These values are added together:
    			2	shift
    			4	control
    			8	alt (meta)
    			16	mouse double click
    			32	mouse triple click
    			64	mouse quadruple click
    			128	Macintosh only: command

    getbufvar({expr}, {varname})				*getbufvar()*
    		The result is the value of option or local buffer variable
    		{varname} in buffer {expr}.
    		This also works for a global or local window option, but it
    		doesn't work for a global or local window variable.
    		For the use of {expr}, see |bufname()| above.
    		Note that the name without "b:" must be used.
    		Examples:
    			:let bufmodified = getbufvar(1, "&mod")
    			:echo "todo myvar = " . getbufvar("todo", "myvar")

    							*getcwd()*
    getcwd()	The result is a String, which is the name of the current
    		working directory.

    getftime({fname})					*getftime()*
    		The result is a Number, which is the last modification time of
    		the given file {fname}.  The value is measured as seconds
    		since 1st Jan 1970, and may be passed to strftime().  See also
    		|localtime()| and |strftime()|.
    		If the file {fname} can't be found -1 is returned.

    getfsize({fname})					*getfsize()*
    		The result is a Number, which is the size in bytes of the
    		given file {fname}.
    		If {fname} is a directory, 0 is returned.
    		If the file {fname} can't be found, -1 is returned.

    							*getline()*
    getline({lnum}) The result is a String, which is line {lnum} from the current
    		buffer.  Example:
    			getline(1)
    		When {lnum} is a String that doesn't start with a
    		digit, line() is called to translate the String into a Number.
    		To get the line under the cursor:
    			getline(".")
    		When {lnum} is smaller than 1 or bigger than the number of
    		lines in the buffer, an empty string is returned.

    							*getwinposx()*
    getwinposx()	The result is a Number, which is the X coordinate in pixels of
    		the left hand side of the GUI vim window.  The result will be
    		-1 if the information is not available.

    							*getwinposy()*
    getwinposy()	The result is a Number, which is the Y coordinate in pixels of
    		the top of the GUI vim window.  The result will be -1 if the
    		information is not available.

    getwinvar({nr}, {varname})				*getwinvar()*
    		The result is the value of option or local window variable
    		{varname} in window {nr}.
    		This also works for a global or local buffer option, but it
    		doesn't work for a global or local buffer variable.
    		Note that the name without "w:" must be used.
    		Examples:
    			:let list_is_on = getwinvar(2, '&list')
    			:echo "myvar = " . getwinvar(1, 'myvar')

    							*glob()*
    glob({expr})	Expand the file wildcards in {expr}.  The result is a String.
    		When there are several matches, they are separated by <NL>
    		characters.
    		If the expansion fails, the result is an empty string.
    		A name for a non-existing file is not included.

    		For most systems backticks can be used to get files names from
    		any external command.  Example:
    			:let tagfiles = glob("`find . -name tags -print`")
    			:let &tags = substitute(tagfiles, "\n", ",", "g")
    		The result of the program inside the backticks should be one
    		item per line.  Spaces inside an item are allowed.

    		See |expand()| for expanding special Vim variables.  See
    		|system()| for getting the raw output of an external command.

    globpath({path}, {expr})				*globpath()*
    		Perform glob() on all directories in {path} and concatenate
    		the results.  Example:
    			:echo globpath(&rtp, "syntax/c.vim")
    		{path} is a comma-separated list of directory names.  Each
    		directory name is prepended to {expr} and expanded like with
    		glob().  A path separator is inserted when needed.
    		If the expansion fails for one of the directories, there is no
    		error message.
    		The 'wildignore' option applies: Names matching one of the
    		patterns in 'wildignore' will be skipped.

    							*has()*
    has({feature})	The result is a Number, which is 1 if the feature {feature} is
    		supported, zero otherwise.  The {feature} argument is a
    		string.  See |feature-list| below.

    hasmapto({what} [, {mode}])				*hasmapto()*
    		The result is a Number, which is 1 if there is a mapping that
    		contains {what} in the rhs (what it is mapped to) and this
    		mapping exists in one of the modes indicated by {mode}.
    		Both the global mappings and the mappings local to the current
    		buffer are checked for a match.
    		If no matching mapping is found 0 is returned.
    		The following characters are recognized in {mode}:
    			n	Normal mode
    			v	Visual mode
    			o	Operator-pending mode
    			i	Insert mode
    			l	Language-Argument ("r", "f", "t", etc.)
    			c	Command-line mode
    		When {mode} is omitted, "nvo" is used.

    		This function is useful to check if a mapping already exists
    		to a function in a Vim script.  Example:
    			:if !hasmapto('\ABCdoit')
    			:   map <Leader>d \ABCdoit
    			:endif
    		This installs the mapping to "\ABCdoit" only if there isn't
    		already a mapping to "\ABCdoit".

    histadd({history}, {item})				*histadd()*
    		Add the String {item} to the history {history} which can be
    		one of:					*hist-names*
    			"cmd"	 or ":"	  command line history
    			"search" or "/"   search pattern history
    			"expr"   or "="   typed expression history
    			"input"  or "@"	  input line history
    		If {item} does already exist in the history, it will be
    		shifted to become the newest entry.
    		The result is a Number: 1 if the operation was successful,
    		otherwise 0 is returned.

    		Example:
    			:call histadd("input", strftime("%Y %b %d"))
    			:let date=input("Enter date: ")

    histdel({history} [, {item}])				*histdel()*
    		Clear {history}, ie. delete all its entries.  See |hist-names|
    		for the possible values of {history}.

    		If the parameter {item} is given as String, this is seen
    		as regular expression.  All entries matching that expression
    		will be removed from the history (if there are any).
    		Upper/lowercase must match, unless "\c" is used |/\c|"
    		If {item} is a Number, it will be interpreted as index, see
    		|:history-indexing|.  The respective entry will be removed
    		if it exists.

    		The result is a Number: 1 for a successful operation,
    		otherwise 0 is returned.

    		Examples:
    		Clear expression register history:
    			:call histdel("expr")

    		Remove all entries starting with "*" from the search history:
    			:call histdel("/", '^\*')

    		The following three are equivalent:
    			:call histdel("search", histnr("search"))
    			:call histdel("search", -1)
    			:call histdel("search", '^'.histget("search", -1).'$')

    		To delete the last search pattern and use the last-but-one for
    		the "n" command and 'hlsearch':
    			:call histdel("search", -1)
    			:let @/ = histget("search", -1)

    histget({history} [, {index}])				*histget()*
    		The result is a String, the entry with Number {index} from
    		{history}.  See |hist-names| for the possible values of
    		{history}, and |:history-indexing| for {index}.  If there is
    		no such entry, an empty String is returned.  When {index} is
    		omitted, the most recent item from the history is used.

    		Examples:
    		Redo the second last search from history.
    			:execute '/' . histget("search", -2)

    		Define an Ex command ":H {num}" that supports re-execution of
    		the {num}th entry from the output of |:history|.
    			:command -nargs=1 H execute histget("cmd", 0+<args>)

    histnr({history})					*histnr()*
    		The result is the Number of the current entry in {history}.
    		See |hist-names| for the possible values of {history}.
    		If an error occurred, -1 is returned.

    		Example:
    			:let inp_index = histnr("expr")

    hlexists({name})					*hlexists()*
    		The result is a Number, which is non-zero if a highlight group
    		called {name} exists.  This is when the group has been
    		defined in some way.  Not necessarily when highlighting has
    		been defined for it, it may also have been used for a syntax
    		item.
    							*highlight_exists()*
    		Obsolete name: highlight_exists().

    							*hlID()*
    hlID({name})	The result is a Number, which is the ID of the highlight group
    		with name {name}.  When the highlight group doesn't exist,
    		zero is returned.
    		This can be used to retrieve information about the highlight
    		group.  For example, to get the background color of the
    		"Comment" group:
    	:echo synIDattr(synIDtrans(hlID("Comment")), "bg")
    							*highlightID()*
    		Obsolete name: highlightID().

    hostname()						*hostname()*
    		The result is a String, which is the name of the machine on
    		which Vim is currently running. Machine names greater than
    		256 characters long are truncated.

    iconv({expr}, {from}, {to})				*iconv()*
    		The result is a String, which is the text {expr} converted
    		from encoding {from} to encoding {to}.
    		When the conversion fails an empty string is returned.
    		The encoding names are whatever the iconv() library function
    		can accept, see ":!man 3 iconv".
    		Most conversions require Vim to be compiled with the |+iconv|
    		feature.  Otherwise only UTF-8 to latin1 conversion and back
    		can be done.
    		This can be used to display messages with special characters,
    		no matter what 'encoding' is set to.  Write the message in
    		UTF-8 and use:
    			echo iconv(utf8_str, "utf-8", &enc)
    		Note that Vim uses UTF-8 for all Unicode encodings, conversion
    		from/to UCS-2 is automatically changed to use UTF-8.  You
    		cannot use UCS-2 in a string anyway, because of the NUL bytes.
    		{only available when compiled with the +multi_byte feature}

    							*indent()*
    indent({lnum})	The result is a Number, which is indent of line {lnum} in the
    		current buffer.  The indent is counted in spaces, the value
    		of 'tabstop' is relevant.  {lnum} is used just like in
    		|getline()|.
    		When {lnum} is invalid -1 is returned.

    input({prompt} [, {text}])				*input()*
    		The result is a String, which is whatever the user typed on
    		the command-line.  The parameter is either a prompt string, or
    		a blank string (for no prompt).  A '\n' can be used in the
    		prompt to start a new line.  The highlighting set with
    		|:echohl| is used for the prompt.  The input is entered just
    		like a command-line, with the same editing commands and
    		mappings.  There is a separate history for lines typed for
    		input().
    		If the optional {text} is present, this is used for the
    		default reply, as if the user typed this.
    		NOTE: This must not be used in a startup file, for the
    		versions that only run in GUI mode (e.g., the Win32 GUI).

    		Example:
    			:if input("Coffee or beer? ") == "beer"
    			:  echo "Cheers!"
    			:endif
    <		Example with default text:
    			:let color = input("Color? ", "white")

    inputdialog({prompt} [, {text})				*inputdialog()*
    		Like input(), but when the GUI is running and text dialogs are
    		supported, a dialog window pops up to input the text.
    		Example:
    			:let n = inputdialog("value for shiftwidth", &sw)
    			:if n != ""
    			:  let &sw = n
    			:endif
    		Hitting <Enter> works like pressing the OK button.  Hitting
    		<Esc> works like pressing the Cancel button.

    inputsecret({prompt} [, {text}])			*inputsecret()*
    		This function acts much like the |input()| function with but
    		two exceptions:
    		a) the user's response will be displayed as a sequence of
    		asterisks ("*") thereby keeping the entry secret, and
    		b) the user's response will not be recorded on the input
    		|history| stack.
    		The result is a String, which is whatever the user actually
    		typed on the command-line in response to the issued prompt.

    isdirectory({directory})				*isdirectory()*
    		The result is a Number, which is non-zero when a directory
    		with the name {directory} exists.  If {directory} doesn't
    		exist, or isn't a directory, the result is FALSE.  {directory}
    		is any expression, which is used as a String.

    						*libcall()* *E364* *E368*
    libcall({libname}, {funcname}, {argument})
    		Call function {funcname} in the run-time library {libname}
    		with single argument {argument}.
    		This is useful to call functions in a library that you
    		especially made to be used with Vim.  Since only one argument
    		is possible, calling standard library functions is rather
    		limited.
    		The result is the String returned by the function.  If the
    		function returns NULL, this will appear as an empty string ""
    		to Vim.
    		If the function returns a number, use libcallnr()!
    		If {argument} is a number, it is passed to the function as an
    		int; if {param} is a string, it is passed as a null-terminated
    		string.

    		libcall() allows you to write your own 'plug-in' extensions to
    		Vim without having to recompile the program.  It is NOT a
    		means to call system functions!  If you try to do so Vim will
    		very probably crash.

    		For Win32, the functions you write must be placed in a DLL
    		and use the normal C calling convention (NOT Pascal which is
    		used in Windows System DLLs).  The function must take exactly
    		one parameter, either a character pointer or a long integer,
    		and must return a character pointer or NULL.  The character
    		pointer returned must point to memory that will remain valid
    		after the function has returned (e.g. in static data in the
    		DLL).  If it points to allocated memory, that memory will
    		leak away.  Using a static buffer in the function should work,
    		it's then freed when the DLL is unloaded.

    		WARNING: If the function returns a non-valid pointer, Vim may
    		crash!  This also happens if the function returns a number,
    		because Vim thinks it's a pointer.
    		For Win32 systems, {libname} should be the filename of the DLL
    		without the ".DLL" suffix.  A full path is only required if
    		the DLL is not in the usual places.
    		For Unix: When compiling your own plugins, remember that the
    		object code must be compiled as position-independant ('PIC').
    		{only in Win32 on some Unix versions, when the |+libcall|
    		feature is present}
    		Examples:
    			:echo libcall("libc.so", "getenv", "HOME")
    			:echo libcallnr("/usr/lib/libc.so", "getpid", "")

    							*libcallnr()*
    libcallnr({libname}, {funcname}, {argument})
    		Just like libcall(), but used for a function that returns an
    		int instead of a string.
    		{only in Win32 on some Unix versions, when the |+libcall|
    		feature is present}
    		Example (not very useful...):
    			:call libcallnr("libc.so", "printf", "Hello World!\n")
    			:call libcallnr("libc.so", "sleep", 10)

    							*line()*
    line({expr})	The result is a Number, which is the line number of the file
    		position given with {expr}.  The accepted positions are:
    		    .	    the cursor position
    		    $	    the last line in the current buffer
    		    'x	    position of mark x (if the mark is not set, 0 is
    			    returned)
    		Note that only marks in the current file can be used.
    		Examples:
    			line(".")		line number of the cursor
    			line("'t")		line number of mark t
    			line("'" . marker)	line number of mark marker
    							*last-position-jump*
    		This autocommand jumps to the last known position in a file
    		just after opening it, if the '" mark is set:
    	:au BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") | exe "normal g'\"" | endif

    line2byte({lnum})					*line2byte()*
    		Return the byte count from the start of the buffer for line
    		{lnum}.  This includes the end-of-line character, depending on
    		the 'fileformat' option for the current buffer.  The first
    		line returns 1.
    		This can also be used to get the byte count for the line just
    		below the last line:
    			line2byte(line("$") + 1)
    		This is the file size plus one.
    		When {lnum} is invalid, or the |+byte_offset| feature has been
    		disabled at compile time, -1 is returned.
    		Also see |byte2line()|, |go| and |:goto|.

    lispindent({lnum})					*lispindent()*
    		Get the amount of indent for line {lnum} according the lisp
    		indenting rules, as with 'lisp'.
    		The indent is counted in spaces, the value of 'tabstop' is
    		relevant.  {lnum} is used just like in |getline()|.
    		When {lnum} is invalid or Vim was not compiled the
    		|+lispindent| feature, -1 is returned.

    localtime()						*localtime()*
    		Return the current time, measured as seconds since 1st Jan
    		1970.  See also |strftime()| and |getftime()|.

    maparg({name}[, {mode}])				*maparg()*
    		Return the rhs of mapping {name} in mode {mode}.  When there
    		is no mapping for {name}, an empty String is returned.
    		These characters can be used for {mode}:
    			"n"	Normal
    			"v"	Visual
    			"o"	Operator-pending
    			"i"	Insert
    			"c"	Cmd-line
    			""	Normal, Visual and Operator-pending
    		When {mode} is omitted, the modes from "" are used.
    		The {name} can have special key names, like in the ":map"
    		command.  The returned String has special characters
    		translated like in the output of the ":map" command listing.
    		The mappings local to the current buffer are checked first,
    		then the global mappings.

    mapcheck({name}[, {mode}])				*mapcheck()*
    		Check if there is a mapping that matches with {name} in mode
    		{mode}.  See |maparg()| for {mode} and special names in
    		{name}.
    		A match happens with a mapping that starts with {name} and
    		with a mapping which is equal to the start of {name}.

    			matches mapping "a"     "ab"    "abc"
    		   mapcheck("a")	yes	yes	 yes
    		   mapcheck("abc")	yes	yes	 yes
    		   mapcheck("ax")	yes	no	 no
    		   mapcheck("b")	no	no	 no

    		The difference with maparg() is that mapcheck() finds a
    		mapping that matches with {name}, while maparg() only finds a
    		mapping for {name} exactly.
    		When there is no mapping that starts with {name}, an empty
    		String is returned.  If there is one, the rhs of that mapping
    		is returned.  If there are several mappings that start with
    		{name}, the rhs of one of them is returned.
    		The mappings local to the current buffer are checked first,
    		then the global mappings.
    		This function can be used to check if a mapping can be added
    		without being ambiguous.  Example:
    	:if mapcheck("_vv") == ""
    	:   map _vv :set guifont=7x13<CR>
    	:endif
    		This avoids adding the "_vv" mapping when there already is a
    		mapping for "_v" or for "_vvv".

    match({expr}, {pat}[, {start}])				*match()*
    		The result is a Number, which gives the index in {expr} where
    		{pat} matches.  A match at the first character returns zero.
    		If there is no match -1 is returned.  Example:
    			:echo match("testing", "ing")
    		results in "4".
    		See |string-match| for how {pat} is used.
    		If {start} is given, the search starts from character {start}.
    		The result, however, is still the index counted from the
    		first character. Example:
    			:echo match("testing", "ing", 2)
    <		result is again "4".
    			:echo match("testing", "ing", 4)
    <		result is again "4".
    			:echo match("testing", "t", 2)
    		result is "3".
    		If {start} < 0, it will be set to 0.
    		If {start} > strlen({expr}) -1 is returned.
    		See |pattern| for the patterns that are accepted.
    		The 'ignorecase' option is used to set the ignore-caseness of
    		the pattern.  'smartcase' is NOT used.  The matching is always
    		done like 'magic' is set and 'cpoptions' is empty.

    matchend({expr}, {pat}[, {start}])			*matchend()*
    		Same as match(), but return the index of first character after
    		the match.  Example:
    			:echo matchend("testing", "ing")
    		results in "7".
    		The {start}, if given, has the same meaning as for match().
    			:echo matchend("testing", "ing", 2)
    <		results in "7".
    			:echo matchend("testing", "ing", 5)
    		result is "-1".

    matchstr({expr}, {pat}[, {start}])			*matchstr()*
    		Same as match(), but return the matched string.  Example:
    			:echo matchstr("testing", "ing")
    		results in "ing".
    		When there is no match "" is returned.
    		The {start}, if given, has the same meaning as for match().
    			:echo matchstr("testing", "ing", 2)
    <		results in "ing".
    			:echo matchstr("testing", "ing", 5)
    		result is "".

    							*mode()*
    mode()		Return a string that indicates the current mode:
    			n	Normal
    			v	Visual by character
    			V	Visual by line
    			CTRL-V	Visual blockwise
    			s	Select by character
    			S	Select by line
    			CTRL-S	Select blockwise
    			i	Insert
    			R	Replace
    			c	Command-line
    			r	Hit-enter prompt
    		This is useful in the 'statusline' option.  In most other
    		places it always returns "c" or "n".

    nextnonblank({lnum})					*nextnonblank()*
    		Return the line number of the first line at or below {lnum}
    		that is not blank.  Example:
    			if getline(nextnonblank(1)) =~ "Java"
    		When {lnum} is invalid or there is no non-blank line at or
    		below it, zero is returned.
    		See also |prevnonblank()|.

    nr2char({expr})						*nr2char()*
    		Return a string with a single character, which has the number
    		value {expr}.  Examples:
    			nr2char(64)		returns "@"
    			nr2char(32)		returns " "
    <		The current 'encoding' is used.  Example for "utf-8":
    			nr2char(300)		returns I with bow character

    prevnonblank({lnum})					*prevnonblank()*
    		Return the line number of the first line at or above {lnum}
    		that is not blank.  Example:
    			let ind = indent(prevnonblank(v:lnum - 1))
    		When {lnum} is invalid or there is no non-blank line at or
    		above it, zero is returned.

    							*remote_expr()* *E449*
    remote_expr({server}, {string} [, {idvar}])
    		Send the {string} to {server}.  The string is sent as an
    		expression and the result is returned after evaluation.
    		If {idvar} is present, it is taken as the name of a
    		variable and a {serverid} for later use with
    		remote_read() is stored there.
    		See also |clientserver| |RemoteReply|.
    		{only available when compiled with the |+clientserver| feature}
    		Note: Any errors will cause a local error message to be issued
    		and the result will be the empty string.
    		Examples:
    			:echo remote_expr("gvim", "2+2")
    			:echo remote_expr("gvim1", "b:current_syntax")

    remote_foreground({server})				*remote_foreground()*
    		Move the Vim server with the name {server} to the foreground.
    		This works like:
    			remote_expr({server}, "foreground()")
    		Except that on Win32 systems the client does the work, to work
    		around the problem that the OS doesn't always allow the server
    		to bring itself to the foreground.
    		{only in the Win32, Athena, Motif and GTK GUI versions and the
    		Win32 console version}

    remote_peek({serverid} [, {retvar}])		*remote_peek()*
    		Returns a positive number if there are available strings
    		from {serverid}.  Copies any reply string into the variable
    		{retvar} if specified.  {retvar} must be a string with the
    		name of a variable.
    		Returns zero if none are available.
    		See also |clientserver|.
    		{only available when compiled with the |+clientserver| feature}
    		Examples:
    			:let repl = ""
    			:echo "PEEK: ".remote_peek(id, "repl").": ".repl

    remote_read({serverid})				*remote_read()*
    		Return the oldest available reply from {serverid} and consume
    		it.  It blocks until a reply is available.
    		See also |clientserver|.
    		{only available when compiled with the |+clientserver| feature}
    		Examples:
    			:echo remote_read(id)

    							*remote_send()* *E241*
    remote_send({server}, {string} [, {idvar}])
    		Send the {string} to {server}.  The string is sent as
    		input keys and the function returns immediately.
    		If {idvar} is present, it is taken as the name of a
    		variable and a {serverid} for later use with
    		remote_read() is stored there.
    		See also |clientserver| |RemoteReply|.
    		{only available when compiled with the |+clientserver| feature}
    		Note: Any errors will be reported in the server and may mess
    		up the display.
    		Examples:
    		:echo remote_send("gvim", ":DropAndReply ".file, "serverid").
    		 \ remote_read(serverid)

    		:autocmd NONE RemoteReply *
    		 \ echo remote_read(expand("<amatch>"))
    		:echo remote_send("gvim", ":sleep 10 | echo ".
    		 \ 'server2client(expand("<client>"), "HELLO")<CR>')

    rename({from}, {to})					*rename()*
    		Rename the file by the name {from} to the name {to}.  This
    		should also work to move files across file systems.  The
    		result is a Number, which is 0 if the file was renamed
    		successfully, and non-zero when the renaming failed.

    resolve({filename})					*resolve()*
    		On MS-Windows, when {filename} is a shortcut (a .lnk file),
    		returns the path the shortcut points to.
    		On Unix, when {filename} is a symbolic link, returns the path
    		the symlink points to.  This only happens once, the returned
    		path could be a symlink again.
    		Otherwise {filename} is returned.

    search({pattern} [, {flags}])				*search()*
    		Search for regexp pattern {pattern}.  The search starts at the
    		cursor position.
    		{flags} is a String, which can contain these character flags:
    		'b'	search backward instead of forward
    		'w'	wrap around the end of the file
    		'W'	don't wrap around the end of the file
    		If neither 'w' or 'W' is given, the 'wrapscan' option applies.

    		When a match has been found its line number is returned, and
    		the cursor will be positioned at the match.  If there is no
    		match a 0 is returned and the cursor doesn't move.  No error
    		message is given.

    		Example (goes over all files in the argument list):
    		    :let n = 1
    		    :while n <= argc()	    " loop over all files in arglist
    		    :  exe "argument " . n
    		    :  " start at the last char in the file and wrap for the
    		    :  " first search to find match at start of file
    		    :  normal G$
    		    :  let flags = "w"
    		    :  while search("foo", flags) > 0
    		    :    s/foo/bar/g
    		    :	 let flags = "W"
    		    :  endwhile
    		    :  update		    " write the file if modified
    		    :  let n = n + 1
    		    :endwhile

    							*searchpair()*
    searchpair({start}, {middle}, {end} [, {flags} [, {skip}]])
    		Search for the match of a nested start-end pair.  This can be
    		used to find the "endif" that matches an "if", while other
    		if/endif pairs in between are ignored.
    		The search starts at the cursor.  If a match is found, the
    		cursor is positioned at it and the line number is returned.
    		If no match is found 0 or -1 is returned and the cursor
    		doesn't move.  No error message is given.

    		{start}, {middle} and {end} are patterns, see |pattern|.  They
    		must not contain \( \) pairs.  Use of \%( \) is allowed.  When
    		{middle} is not empty, it is found when searching from either
    		direction, but only when not in a nested start-end pair.  A
    		typical use is:
    			searchpair("if", "else", "endif")
    		By leaving {middle} empty the "else" is skipped.

    		{flags} are used like with |search()|.  Additionally:
    		'n'	do Not move the cursor
    		'r'	Repeat until no more matches found; will find the
    			outer pair
    		'm'	return number of Matches instead of line number with
    			the match; will only be > 1 when 'r' is used.

    		When a match for {start}, {middle} or {end} is found, the
    		{skip} expression is evaluated with the cursor positioned on
    		the start of the match.  It should return non-zero if this
    		match is to be skipped.  E.g., because it is inside a comment
    		or a string.
    		When {skip} is omitted or empty, every match is accepted.
    		When evaluating {skip} causes an error the search is aborted
    		and -1 returned.

    		The value of 'ignorecase' is used.  'magic' is ignored, the
    		patterns are used like it's on.

    		The search starts exactly at the cursor.  A match with
    		{start}, {middle} or {end} at the next character, in the
    		direction of searching, is the first one found.  Example:
    			if 1
    			  if 2
    			  endif 2
    			endif 1
    		When starting at the "if 2", with the cursor on the "i", and
    		searching forwards, the "endif 2" is found.  When starting on
    		the character just before the "if 2", the "endif 1" will be
    		found.  That's because the "if 2" will be found first, and
    		then this is considered to be a nested if/endif from "if 2" to
    		"endif 2".

    		Example, to find the "endif" command in a Vim script:

    	:echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
    			\ 'getline(".") =~ "^\\s*\""')

    		The cursor must be at or after the "if" for which a match is
    		to be found.  Note that single-quote strings are used to avoid
    		having to double the backslashes.  The skip expression only
    		catches comments at the start of a line, not after a command.
    		Also, a word "en" or "if" halfway a line is considered a
    		match.
    		Another example, to search for the matching "{" of a "}":

    	:echo searchpair('{', '', '}', 'bW')

    		This works when the cursor is at or before the "}" for which a
    		match is to be found.  To reject matches that syntax
    		highlighting recognized as strings:

    	:echo searchpair('{', '', '}', 'bW',
    	     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')

    server2client( {clientid}, {string})			*server2client()*
    		Send a reply string to {clientid}.  The most recent {clientid}
    		that sent a string can be retrieved with expand("<client>").
    		{only available when compiled with the |+clientserver| feature}
    		Note:
    		This id has to be stored before the next command can be
    		received. Ie. before returning from the received command and
    		before calling any commands that waits for input.
    		See also |clientserver|.
    		Example:
    			:echo server2client(expand("<client>"), "HELLO")

    serverlist()					*serverlist()*
    		Return a list of available server names, one per line.
    		When there are no servers an empty string is returned.
    		See also |clientserver|.
    		{only available when compiled with the |+clientserver| feature}
    		Example:
    			:echo serverlist()

    setbufvar({expr}, {varname}, {val})			*setbufvar()*
    		Set option or local variable {varname} in buffer {expr} to
    		{val}.
    		This also works for a global or local window option, but it
    		doesn't work for a global or local window variable.
    		For a local window option the global value is unchanged.
    		For the use of {expr}, see |bufname()| above.
    		Note that the variable name without "b:" must be used.
    		Examples:
    			:call setbufvar(1, "&mod", 1)
    			:call setbufvar("todo", "myvar", "foobar")

    setline({lnum}, {line})					*setline()*
    		Set line {lnum} of the current buffer to {line}.  If this
    		succeeds, 0 is returned.  If this fails (most likely because
    		{lnum} is invalid) 1 is returned.  Example:
    			:call setline(5, strftime("%c"))
    		Note: The '[ and '] marks are not set.

    setwinvar({nr}, {varname}, {val})			*setwinvar()*
    		Set option or local variable {varname} in window {nr} to
    		{val}.
    		This also works for a global or local buffer option, but it
    		doesn't work for a global or local buffer variable.
    		For a local buffer option the global value is unchanged.
    		Note that the variable name without "w:" must be used.
    		Examples:
    			:call setwinvar(1, "&list", 0)
    			:call setwinvar(2, "myvar", "foobar")

    strftime({format} [, {time}])				*strftime()*
    		The result is a String, which is a formatted date and time, as
    		specified by the {format} string.  The given {time} is used,
    		or the current time if no time is given.  The accepted
    		{format} depends on your system, thus this is not portable!
    		See the manual page of the C function strftime() for the
    		format.  The maximum length of the result is 80 characters.
    		See also |localtime()| and |getftime()|.
    		The language can be changed with the |:language| command.
    		Examples:
    		  :echo strftime("%c")		   Sun Apr 27 11:49:23 1997
    		  :echo strftime("%Y %b %d %X")	   1997 Apr 27 11:53:25
    		  :echo strftime("%y%m%d %T")	   970427 11:53:55
    		  :echo strftime("%H:%M")	   11:55
    		  :echo strftime("%c", getftime("file.c"))
    						   Show mod time of file.c.

    stridx({haystack}, {needle})				*stridx()*
    		The result is a Number, which gives the index in {haystack} of
    		the first occurrence of the String {needle} in the String
    		{haystack}. The search is done case-sensitive. For advanced
    		searches use |match()|.
    		If the {needle} does not occur in {haystack} it returns -1.
    		See also |strridx()|. Examples:
    		  :echo stridx("An Example", "Example")	     3
    		  :echo stridx("Starting point", "Start")    0
    		  :echo stridx("Starting point", "start")   -1

    							*strlen()*
    strlen({expr})	The result is a Number, which is the length of the String
    		{expr}.

    strpart({src}, {start}[, {len}])			*strpart()*
    		The result is a String, which is part of {src},
    		starting from character {start}, with the length {len}.
    		When non-existing characters are included, this doesn't result
    		in an error, the characters are simply omitted.
    		If {len} is missing, the copy continues from {start} till
    		the end of the {src}.
    			strpart("abcdefg", 3, 2)    == "de"
    			strpart("abcdefg", -2, 4)   == "ab"
    			strpart("abcdefg", 5, 4)    == "fg"
    			strpart("abcdefg", 3)       == "defg"
    		Note: To get the first character, {start} must be 0.  For
    		example, to get three characters under and after the cursor:
    			strpart(getline(line(".")), col(".") - 1, 3)

    strridx({haystack}, {needle})				*strridx()*
    		The result is a Number, which gives the index in {haystack} of
    		the last occurrence of the String {needle} in the String
    		{haystack}. The search is done case-sensitive. For advanced
    		searches use |match()|.
    		If the {needle} does not occur in {haystack} it returns -1.
    		See also |stridx()|. Examples:
    		  :echo strridx("an angry armadillo", "an")	     3

    strtrans({expr})					*strtrans()*
    		The result is a String, which is {expr} with all unprintable
    		characters translated into printable characters |'isprint'|.
    		Like they are shown in a window.  Example:
    			echo strtrans(@a)
    		This displays a newline in register a as "^@" instead of
    		starting a new line.

    submatch({nr})						*submatch()*
    		Only for an expression in a |:substitute| command.  Returns
    		the {nr}'th submatch of the matched text  When {nr} is 0
    		the whole matched text is returned.
    		Example:
    			:s/\d\+/\=submatch(0) + 1/
    		This finds the first number in the line and adds one to it.

    substitute({expr}, {pat}, {sub}, {flags})		*substitute()*
    		The result is a String, which is a copy of {expr}, in which
    		the first match of {pat} is replaced with {sub}.  This works
    		like the ":substitute" command (without any flags).  But the
    		matching with {pat} is always done like the 'magic' option is
    		set and 'cpoptions' is empty (to make scripts portable).
    		See |string-match| for how {pat} is used.
    		And a "~" in {sub} is not replaced with the previous {sub}.
    		Note that some codes in {sub} have a special meaning
    		|sub-replace-special|.  For example, to replace something with
    		a literal "\n", use "\\\\n" or '\\n'.
    		When {pat} does not match in {expr}, {expr} is returned
    		unmodified.
    		When {flags} is "g", all matches of {pat} in {expr} are
    		replaced.  Otherwise {flags} should be "".
    		Example:
    			:let &path = substitute(&path, ",\\=[^,]*$", "", "")
    <		This removes the last component of the 'path' option.
    			:echo substitute("testing", ".*", "\\U\\0", "")
    		results in "TESTING".

    synID({line}, {col}, {trans})				*synID()*
    		The result is a Number, which is the syntax ID at the position
    		{line} and {col} in the current window.
    		The syntax ID can be used with |synIDattr()| and
    		|synIDtrans()| to obtain syntax information about text.
    		{col} is 1 for the leftmost column, {line} is 1 for the first
    		line.
    		When {trans} is non-zero, transparent items are reduced to the
    		item that they reveal.  This is useful when wanting to know
    		the effective color.  When {trans} is zero, the transparent
    		item is returned.  This is useful when wanting to know which
    		syntax item is effective (e.g. inside parens).
    		Warning: This function can be very slow.  Best speed is
    		obtained by going through the file in forward direction.

    		Example (echos the name of the syntax item under the cursor):
    			:echo synIDattr(synID(line("."), col("."), 1), "name")

    synIDattr({synID}, {what} [, {mode}])			*synIDattr()*
    		The result is a String, which is the {what} attribute of
    		syntax ID {synID}.  This can be used to obtain information
    		about a syntax item.
    		{mode} can be "gui", "cterm" or "term", to get the attributes
    		for that mode.  When {mode} is omitted, or an invalid value is
    		used, the attributes for the currently active highlighting are
    		used (GUI, cterm or term).
    		Use synIDtrans() to follow linked highlight groups.
    		{what}		result
    		"name"		the name of the syntax item
    		"fg"		foreground color (GUI: color name, cterm:
    				color number as a string, term: empty string)
    		"bg"		background color (like "fg")
    		"fg#"		like "fg", but name in "#RRGGBB" form
    		"bg#"		like "bg", but name in "#RRGGBB" form
    		"bold"		"1" if bold
    		"italic"	"1" if italic
    		"reverse"	"1" if reverse
    		"inverse"	"1" if inverse (= reverse)
    		"underline"	"1" if underlined

    		When the GUI is not running or the cterm mode is asked for,
    		"fg#" is equal to "fg" and "bg#" is equal to "bg".

    		Example (echos the color of the syntax item under the cursor):
    	:echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")

    synIDtrans({synID})					*synIDtrans()*
    		The result is a Number, which is the translated syntax ID of
    		{synID}.  This is the syntax group ID of what is being used to
    		highlight the character.  Highlight links given with
    		":highlight link" are followed.

    							*system()*
    system({expr})	Get the output of the shell command {expr}.  Note: newlines
    		in {expr} may cause the command to fail.  The characters in
    		'shellquote' and 'shellxquote' may also cause trouble.
    		This is not to be used for interactive commands.
    		The result is a String.
    		To make the result more system-independent, the shell output
    		is filtered to replace <CR> with <NL> for Macintosh, and
    		<CR><NL> with <NL> for DOS-like systems.
    		The command executed is constructed using several options:
    	'shell' 'shellcmdflag' 'shellxquote' {expr} 'shellredir' {tmp} 'shellxquote'
    		({tmp} is an automatically generated file name).
    		For Unix and OS/2 braces are put around {expr} to allow for
    		concatenated commands.

    		The resulting error code can be found in |v:shell_error|.
    		This function will fail in |restricted-mode|.
    		Unlike ":!cmd" there is no automatic check for changed files.
    		Use |:checktime| to force a check.

    tempname()					*tempname()* *temp-file-name*
    		The result is a String, which is the name of a file that
    		doesn't exist.  It can be used for a temporary file.  The name
    		is different for at least 26 consecutive calls.  Example:
    			:let tmpfile = tempname()
    			:exe "redir > " . tmpfile
    		For Unix, the file will be in a private directory (only
    		accessible by the current user) to avoid security problems
    		(e.g., a symlink attack or other people reading your file).
    		When Vim exits the directory and all files in it are deleted.

    tolower({expr})						*tolower()*
    		The result is a copy of the String given, with all uppercase
    		characters turned into lowercase (just like applying |gu| to
    		the string).

    toupper({expr})						*toupper()*
    		The result is a copy of the String given, with all lowercase
    		characters turned into uppercase (just like applying |gU| to
    		the string).

    type({expr})						*type()*
    		The result is a Number:
    			0 if {expr} has the type Number
    			1 if {expr} has the type String

    virtcol({expr})						*virtcol()*
    		The result is a Number, which is the screen column of the file
    		position given with {expr}.  That is, the last screen position
    		occupied by the character at that position, when the screen
    		would be of unlimited width.  When there is a <Tab> at the
    		position, the returned Number will be the column at the end of
    		the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
    		set to 8, it returns 8;
    		When Virtual editing is active in the current mode, a position
    		beyond the end of the line can be returned. |'virtualedit'|
    		The accepted positions are:
    		    .	    the cursor position
    		    $	    the end of the cursor line (the result is the
    			    number of displayed characters in the cursor line
    			    plus one)
    		    'x	    position of mark x (if the mark is not set, 0 is
    			    returned)
    		Note that only marks in the current file can be used.
    		Examples:
      virtcol(".")	   with text "foo^Lbar", with cursor on the "^L", returns 5
      virtcol("$")	   with text "foo^Lbar", returns 9
      virtcol("'t")    with text "    there", with 't at 'h', returns 6
    		The first column is 1.  0 is returned for an error.

    visualmode()						*visualmode()*
    		The result is a String, which describes the last Visual mode
    		used.  Initially it returns an empty string, but once Visual
    		mode has been used, it returns "v", "V", or "<CTRL-V>" (a
    		single CTRL-V character) for character-wise, line-wise, or
    		block-wise Visual mode respectively.
    		Example:
    			:exe "normal " . visualmode()
    		This enters the same Visual mode as before.  It is also useful
    		in scripts if you wish to act differently depending on the
    		Visual mode that was used.

    							*winbufnr()*
    winbufnr({nr})	The result is a Number, which is the number of the buffer
    		associated with window {nr}. When {nr} is zero, the number of
    		the buffer in the current window is returned.  When window
    		{nr} doesn't exist, -1 is returned.
    		Example:
      :echo "The file in the current window is " . bufname(winbufnr(0))

    							*wincol()*
    wincol()	The result is a Number, which is the virtual column of the
    		cursor in the window.  This is counting screen cells from the
    		left side of the window.  The leftmost column is one.

    winheight({nr})						*winheight()*
    		The result is a Number, which is the height of window {nr}.
    		When {nr} is zero, the height of the current window is
    		returned.  When window {nr} doesn't exist, -1 is returned.
    		An existing window always has a height of zero or more.
    		Examples:
      :echo "The current window has " . winheight(0) . " lines."

    							*winline()*
    winline()	The result is a Number, which is the screen line of the cursor
    		in the window.  This is counting screen lines from the top of
    		the window.  The first line is one.

    							*winnr()*
    winnr()		The result is a Number, which is the number of the current
    		window.  The top window has number 1.

    winwidth({nr})						*winwidth()*
    		The result is a Number, which is the width of window {nr}.
    		When {nr} is zero, the width of the current window is
    		returned.  When window {nr} doesn't exist, -1 is returned.
    		An existing window always has a width of zero or more.
    		Examples:
      :echo "The current window has " . winwidth(0) . " columns."
      :if winwidth(0) <= 50
      :  exe "normal 50\<C-W>|"
      :endif

    							*feature-list*
    There are two types of features:
    1.  Features that are only supported when they have been enabled when Vim
        was compiled |+feature-list|.  Example:
    	:if has("cindent")
    2.  Features that are only supported when certain conditions have been met.
        Example:
    	:if has("gui_running")

    all_builtin_terms	Compiled with all builtin terminals enabled.
    amiga			Amiga version of Vim.
    arp			Compiled with ARP support (Amiga).
    autocmd			Compiled with autocommands support.
    balloon_eval		Compiled with |balloon-eval| support.
    beos			BeOS version of Vim.
    browse			Compiled with |:browse| support, and browse() will
    			work.
    builtin_terms		Compiled with some builtin terminals.
    byte_offset		Compiled with support for 'o' in 'statusline'
    cindent			Compiled with 'cindent' support.
    clientserver		Compiled with remote invocation support |clientserver|.
    clipboard		Compiled with 'clipboard' support.
    cmdline_compl		Compiled with |cmdline-completion| support.
    cmdline_hist		Compiled with |cmdline-history| support.
    cmdline_info		Compiled with 'showcmd' and 'ruler' support.
    comments		Compiled with |'comments'| support.
    cryptv			Compiled with encryption support |encryption|.
    cscope			Compiled with |cscope| support.
    compatible		Compiled to be very Vi compatible.
    debug			Compiled with "DEBUG" defined.
    dialog_con		Compiled with console dialog support.
    dialog_gui		Compiled with GUI dialog support.
    diff			Compiled with |vimdiff| and 'diff' support.
    digraphs		Compiled with support for digraphs.
    dos32			32 bits DOS (DJGPP) version of Vim.
    dos16			16 bits DOS version of Vim.
    ebcdic			Compiled on a machine with ebcdic character set.
    emacs_tags		Compiled with support for Emacs tags.
    eval			Compiled with expression evaluation support.  Always
    			true, of course!
    ex_extra		Compiled with extra Ex commands |+ex_extra|.
    extra_search		Compiled with support for |'incsearch'| and
    			|'hlsearch'|
    farsi			Compiled with Farsi support |farsi|.
    file_in_path		Compiled with support for |gf| and |<cfile>|
    find_in_path		Compiled with support for include file searches
    			|+find_in_path|.
    fname_case		Case in file names matters (for Amiga, MS-DOS, and
    			Windows this is not present).
    folding			Compiled with |folding| support.
    footer			Compiled with GUI footer support. |gui-footer|
    fork			Compiled to use fork()/exec() instead of system().
    gettext			Compiled with message translation |multi-lang|
    gui			Compiled with GUI enabled.
    gui_athena		Compiled with Athena GUI.
    gui_beos		Compiled with BeOs GUI.
    gui_gtk			Compiled with GTK+ GUI.
    gui_mac			Compiled with Macintosh GUI.
    gui_motif		Compiled with Motif GUI.
    gui_photon		Compiled with Photon GUI.
    gui_win32		Compiled with MS Windows Win32 GUI.
    gui_win32s		idem, and Win32s system being used (Windows 3.1)
    gui_running		Vim is running in the GUI, or it will start soon.
    hangul_input		Compiled with Hangul input support. |hangul|
    iconv			Can use iconv() for coversion.
    insert_expand		Compiled with support for CTRL-X expansion commands in
    			Insert mode.
    jumplist		Compiled with |jumplist| support.
    keymap			Compiled with 'keymap' support.
    langmap			Compiled with 'langmap' support.
    libcall			Compiled with |libcall()| support.
    linebreak		Compiled with 'linebreak', 'breakat' and 'showbreak'
    			support.
    lispindent		Compiled with support for lisp indenting.
    listcmds		Compiled with commands for the buffer list |:files|
    			and the argument list |arglist|.
    localmap		Compiled with local mappings and abbr. |:map-local|
    mac			Macintosh version of Vim.
    menu			Compiled with support for |:menu|.
    mksession		Compiled with support for |:mksession|.
    modify_fname		Compiled with file name modifiers. |filename-modifiers|
    mouse			Compiled with support mouse.
    mouseshape		Compiled with support for 'mouseshape'.
    mouse_dec		Compiled with support for Dec terminal mouse.
    mouse_gpm		Compiled with support for gpm (Linux console mouse)
    mouse_netterm		Compiled with support for netterm mouse.
    mouse_pterm		Compiled with support for qnx pterm mouse.
    mouse_xterm		Compiled with support for xterm mouse.
    multi_byte		Compiled with support for editing Korean et al.
    multi_byte_ime		Compiled with support for IME input method.
    multi_lang		Compiled with support for multiple languages.
    ole			Compiled with OLE automation support for Win32.
    os2			OS/2 version of Vim.
    osfiletype		Compiled with support for osfiletypes |+osfiletype|
    path_extra		Compiled with up/downwards search in 'path' and 'tags'
    perl			Compiled with Perl interface.
    postscript		Compiled with PostScript file printing.
    printer			Compiled with |:hardcopy| support.
    python			Compiled with Python interface.
    qnx			QNX version of vim.
    quickfix		Compiled with |quickfix| support.
    rightleft		Compiled with 'rightleft' support.
    ruby			Compiled with Ruby interface |ruby|.
    scrollbind		Compiled with 'scrollbind' support.
    showcmd			Compiled with 'showcmd' support.
    signs			Compiled with |:sign| support.
    smartindent		Compiled with 'smartindent' support.
    sniff			Compiled with SniFF interface support.
    statusline		Compiled with support for 'statusline', 'rulerformat'
    			and special formats of 'titlestring' and 'iconstring'.
    sun_workshop		Compiled with support for Sun |workshop|.
    syntax			Compiled with syntax highlighting support.
    syntax_items		There are active syntax highlighting items for the
    			current buffer.
    system			Compiled to use system() instead of fork()/exec().
    tag_binary		Compiled with binary searching in tags files
    			|tag-binary-search|.
    tag_old_static		Compiled with support for old static tags
    			|tag-old-static|.
    tag_any_white		Compiled with support for any white characters in tags
    			files |tag-any-white|.
    tcl			Compiled with Tcl interface.
    terminfo		Compiled with terminfo instead of termcap.
    termresponse		Compiled with support for |t_RV| and |v:termresponse|.
    textobjects		Compiled with support for |text-objects|.
    tgetent			Compiled with tgetent support, able to use a termcap
    			or terminfo file.
    title			Compiled with window title support |'title'|.
    toolbar			Compiled with support for |gui-toolbar|.
    unix			Unix version of Vim.
    user_commands		User-defined commands.
    viminfo			Compiled with viminfo support.
    vim_starting		True while initial source'ing takes place.
    vertsplit		Compiled with vertically split windows |:vsplit|.
    virtualedit		Compiled with 'virtualedit' option.
    visual			Compiled with Visual mode.
    visualextra		Compiled with extra Visual mode commands.
    			|blockwise-operators|.
    vms			VMS version of Vim.
    vreplace		Compiled with |gR| and |gr| commands.
    wildignore		Compiled with 'wildignore' option.
    wildmenu		Compiled with 'wildmenu' option.
    windows			Compiled with support for more than one window.
    winaltkeys		Compiled with 'winaltkeys' option.
    win16			Win16 version of Vim (MS-Windows 3.1).
    win32			Win32 version of Vim (MS-Windows 95/98/ME/NT/2000/XP).
    win95			Win32 version for MS-Windows 95/98/ME.
    writebackup		Compiled with 'writebackup' default on.
    xfontset		Compiled with X fontset support |xfontset|.
    xim			Compiled with X input method support |xim|.
    xterm_clipboard		Compiled with support for xterm clipboard.
    xterm_save		Compiled with support for saving and restoring the
    			xterm screen.
    x11			Compiled with X11 support.

    							*string-match*
    Matching a pattern in a String

    A regexp pattern as explained at |pattern| is normally used to find a match in
    the buffer lines.  When a pattern is used to find a match in a String, almost
    everything works in the same way.  The difference is that a String is handled
    like it is one line.  When it contains a "\n" character, this is not seen as a
    line break for the pattern.  It can be matched with a "\n" in the pattern, or
    with ".".  Example:
    	:let a = "aaaa\nxxxx"
    	:echo matchstr(a, "..\n..")
    	aa
    	xx
    	:echo matchstr(a, "a.x")
    	a
    	x

    Don't forget that "^" will only match at the first character of the String and
    "$" at the last character of the string.  They don't match after or before a
    "\n".

    5. Defining functions					*user-functions*

    New functions can be defined.  These can be called just like builtin
    functions.

    The function name must start with an uppercase letter, to avoid confusion with
    builtin functions.  To prevent from using the same name in different scripts
    avoid obvious, short names.  A good habit is to start the function name with
    the name of the script, e.g., "HTMLcolor()".

    It's also possible to use curly braces, see |curly-braces-names|.

    							*local-function*
    A function local to a script must start with "s:".  A local script function
    can only be called from within the script and from functions, user commands
    and autocommands defined in the script.  It is also possible to call the
    function from a mappings defined in the script, but then |<SID>| must be used
    instead of "s:" when the mapping is expanded outside of the script.

    					*:fu* *:function* *E128* *E129* *E123*
    :fu[nction]		List all functions and their arguments.

    :fu[nction] {name}	List function {name}.
    							*E124* *E125*
    :fu[nction][!] {name}([arguments]) [range] [abort]
    			Define a new function by the name {name}.  The name
    			must be made of alphanumeric characters and '_', and
    			must start with a capital or "s:" (see above).
    						*function-argument* *a:var*
    			An argument can be defined by giving its name.  In the
    			function this can then be used as "a:name" ("a:" for
    			argument).
    			Up to 20 arguments can be given, separated by commas.
    			Finally, an argument "..." can be specified, which
    			means that more arguments may be following.  In the
    			function they can be used as "a:1", "a:2", etc.  "a:0"
    			is set to the number of extra arguments (which can be
    			0).
    			When not using "...", the number of arguments in a
    			function call must be equal the number of named
    			arguments.  When using "...", the number of arguments
    			may be larger.
    			It is also possible to define a function without any
    			arguments.  You must still supply the () then.
    			The body of the function follows in the next lines,
    			until the matching |:endfunction|.  It is allowed to
    			define another function inside a function body.
    								*E127* *E122*
    			When a function by this name already exists and [!] is
    			not used an error message is given.  When [!] is used,
    			an existing function is silently replaced.
    			When the [range] argument is added, the function is
    			expected to take care of a range itself.  The range is
    			passed as "a:firstline" and "a:lastline".  If [range]
    			is excluded, ":{range}call" will call the function for
    			each line in the range, with the cursor on the start
    			of each line.  See |function-range-example|.
    			When the [abort] argument is added, the function will
    			abort as soon as an error is detected.
    			The last used search pattern and the redo command "."
    			will not be changed by the function.

    					*:endf* *:endfunction* *E126* *E193*
    :endf[unction]		The end of a function definition.  Must be on a line
    			by its own, without other commands.

    					*:delf* *:delfunction* *E130* *E131*
    :delf[unction] {name}	Delete function {name}.

    							*:retu* *:return* *E133*
    :retu[rn] [expr]	Return from a function.  When "[expr]" is given, it is
    			evaluated and returned as the result of the function.
    			If "[expr]" is not given, the number 0 is returned.
    			When a function ends without an explicit ":return",
    			the number 0 is returned.
    			Note that there is no check for unreachable lines,
    			thus there is no warning if commands follow ":return".

    Inside a function variables can be used.  These are local variables, which
    will disappear when the function returns.  Global variables need to be
    accessed with "g:".

    Example:
      :function Table(title, ...)
      :  echohl Title
      :  echo a:title
      :  echohl None
      :  let idx = 1
      :  while idx <= a:0
      :    exe "echo a:" . idx
      :    let idx = idx + 1
      :  endwhile
      :  return idx
      :endfunction

    This function can then be called with:
      let lines = Table("Table", "line1", "line2")
      let lines = Table("Empty Table")

    To return more than one value, pass the name of a global variable:
      :function Compute(n1, n2, divname)
      :  if a:n2 == 0
      :    return "fail"
      :  endif
      :  exe "let g:" . a:divname . " = ". a:n1 / a:n2
      :  return "ok"
      :endfunction

    This function can then be called with:
      :let success = Compute(13, 1324, "div")
      :if success == "ok"
      :  echo div
      :endif

    An alternative is to return a command that can be executed.  This also works
    with local variables in a calling function.  Example:
      :function Foo()
      :  execute Bar()
      :  echo "line " . lnum . " column " . col
      :endfunction

      :function Bar()
      :  return "let lnum = " . line(".") . " | let col = " . col(".")
      :endfunction

    The names "lnum" and "col" could also be passed as argument to Bar(), to allow
    the caller to set the names.

    							*:cal* *:call* *E107*
    :[range]cal[l] {name}([arguments])
    		Call a function.  The name of the function and its arguments
    		are as specified with |:function|.  Up to 20 arguments can be
    		used.
    		Without a range and for functions that accept a range, the
    		function is called once.  When a range is given the cursor is
    		positioned at the start of the first line before executing the
    		function.
    		When a range is given and the function doesn't handle it
    		itself, the function is executed for each line in the range,
    		with the cursor in the first column of that line.  The cursor
    		is left at the last line (possibly moved by the last function
    		call).  The arguments are re-evaluated for each line.  Thus
    		this works:
    						*function-range-example*
    	:function Mynumber(arg)
    	:  echo line(".") . " " . a:arg
    	:endfunction
    	:1,5call Mynumber(getline("."))

    		The "a:firstline" and "a:lastline" are defined anyway, they
    		can be used to do something different at the start or end of
    		the range.

    		Example of a function that handles the range itself:

    	:function Cont() range
    	:  execute (a:firstline + 1) . "," . a:lastline . 's/^/\t\\ '
    	:endfunction
    	:4,8call Cont()

    		This function inserts the continuation character "\" in front
    		of all the lines in the range, except the first one.

    								*E132*
    The recursiveness of user functions is restricted with the |'maxfuncdepth'|
    option.

    							*autoload-functions*
    When using many or large functions, it's possible to automatically define them
    only when they are used.  Example:

    	:au FuncUndefined BufNet* source ~/vim/bufnetfuncs.vim

    The file "~/vim/bufnetfuncs.vim" should then define functions that start with
    "BufNet".  Also see |FuncUndefined|.

    6. Curly braces names					*curly-braces-names*

    Wherever you can use a variable, you can use a "curly braces name" variable.
    This is a regular variable name with one or more expressions wrapped in braces
    {} like this:
    	my_{adjective}_variable

    When Vim encounters this, it evaluates the expression inside the braces, puts
    that in place of the expression, and re-interprets the whole as a variable
    name.  So in the above example, if the variable "adjective" was set to
    "noisy", then the reference would be to "my_noisy_variable", whereas if
    "adjective" was set to "quiet", then it would be to "my_quiet_variable".

    One application for this is to create a set of variables governed by an option
    value.  For example, the statement
    	echo my_{&background}_message

    would output the contents of "my_dark_message" or "my_light_message" depending
    on the current value of 'background'.

    You can use multiple brace pairs:
    	echo my_{adverb}_{adjective}_message
    ..or even nest them:
    	echo my_{ad{end_of_word}}_message
    where "end_of_word" is either "verb" or "jective"

    However, the expression inside the braces must evaluate to a valid single
    variable name. e.g. this is invalid:
    	:let foo='a + b'
    	:echo c{foo}d
    .. since the result of expansion is "ca + bd", which is not a variable name.

    						*curly-braces-function-names*
    You can call and define functions by an evaluated name in a similar way.
    Example:
    	:let func_end='whizz'
    	:call my_func_{func_end}(parameter)

    This would call the function "my_func_whizz(parameter)"

    7. Commands						*expression-commands*

    :let {var-name} = {expr1}				*:let* *E18*
    			Set internal variable {var-name} to the result of the
    			expression {expr1}.  The variable will get the type
    			from the {expr}.  if {var-name} didn't exist yet, it
    			is created.

    :let ${env-name} = {expr1}			*:let-environment* *:let-$*
    			Set environment variable {env-name} to the result of
    			the expression {expr1}.  The type is always String.

    :let @{reg-name} = {expr1}			*:let-register* *:let-@*
    			Write the result of the expression {expr1} in register
    			{reg-name}.  {reg-name} must be a single letter, and
    			must be the name of a writable register (see
    			|registers|).  "@@" can be used for the unnamed
    			register, "@/" for the search pattern.
    			If the result of {expr1} ends in a <CR> or <NL>, the
    			register will be linewise, otherwise it will be set to
    			characterwise.
    			This can be used to clear the last search pattern:
    				:let @/ = ""
    			This is different from searching for an empty string,
    			that would match everywhere.

    :let &{option-name} = {expr1}			*:let-option* *:let-star*
    			Set option {option-name} to the result of the
    			expression {expr1}.  The value is always converted to
    			the type of the option.
    			For an option local to a window or buffer the effect
    			is just like using the |:set| command: both the local
    			value and the global value is changed.

    :let &l:{option-name} = {expr1}
    			Like above, but only set the local value of an option
    			(if there is one).  Works like |:setlocal|.

    :let &g:{option-name} = {expr1}
    			Like above, but only set the global value of an option
    			(if there is one).  Works like |:setglobal|.

    							*E106*
    :let {var-name}	..	List the value of variable {var-name}.  Several
    			variable names may be given.

    :let			List the values of all variables.

    							*:unlet* *:unl* *E108*
    :unl[et][!] {var-name} ...
    			Remove the internal variable {var-name}.  Several
    			variable names can be given, they are all removed.
    			With [!] no error message is given for non-existing
    			variables.

    :if {expr1}					*:if* *:endif* *:en* *E171*
    :en[dif]		Execute the commands until the next matching ":else"
    			or ":endif" if {expr1} evaluates to non-zero.

    			From Vim version 4.5 until 5.0, every Ex command in
    			between the ":if" and ":endif" is ignored.  These two
    			commands were just to allow for future expansions in a
    			backwards compatible way.  Nesting was allowed.  Note
    			that any ":else" or ":elseif" was ignored, the "else"
    			part was not executed either.

    			You can use this to remain compatible with older
    			versions:
    				:if version >= 500
    				:  version-5-specific-commands
    				:endif
    			The commands still need to be parsed to find the
    			"endif".  Sometimes an older Vim has a problem with a
    			new command.  For example, ":silent" is recognized as
    			a ":substitute" command.  In that case ":execute" can
    			avoid problems:
    				:if version >= 600
    				:  execute "silent 1,$delete"
    				:endif

    			NOTE: The ":append" and ":insert" commands don't work
    			properly in between ":if" and ":endif".

    							*:else* *:el*
    :el[se]			Execute the commands until the next matching ":else"
    			or ":endif" if they previously were not being
    			executed.

    							*:elseif* *:elsei*
    :elsei[f] {expr1}	Short for ":else" ":if", with the addition that there
    			is no extra ":endif".

    :wh[ile] {expr1}		*:while* *:endwhile* *:wh* *:endw* *E170*
    :endw[hile]		Repeat the commands between ":while" and ":endwhile",
    			as long as {expr1} evaluates to non-zero.
    			When an error is detected from a command inside the
    			loop, execution continues after the "endwhile".

    			NOTE: The ":append" and ":insert" commands don't work
    			properly inside a ":while" loop.

    							*:continue* *:con*
    :con[tinue]		When used inside a ":while", jumps back to the
    			":while".

    							*:break* *:brea*
    :brea[k]		When used inside a ":while", skips to the command
    			after the matching ":endwhile".

    							*:ec* *:echo*
    :ec[ho] {expr1} ..	Echoes each {expr1}, with a space in between and a
    			terminating <EOL>.  Also see |:comment|.
    			Use "\n" to start a new line.  Use "\r" to move the
    			cursor to the first column.
    			Uses the highlighting set by the |:echohl| command.
    			Cannot be followed by a comment.
    			Example:
    		:echo "the value of 'shell' is" &shell
    			A later redraw may make the message disappear again.
    			To avoid that a command from before the ":echo" causes
    			a redraw afterwards (redraws are often postponed until
    			you type something), force a redraw with the |:redraw|
    			command.  Example:
    		:new | redraw | echo "there is a new window"

    							*:echon*
    :echon {expr1} ..	Echoes each {expr1}, without anything added.  Also see
    			|:comment|.
    			Uses the highlighting set by the |:echohl| command.
    			Cannot be followed by a comment.
    			Example:
    				:echon "the value of 'shell' is " &shell

    			Note the difference between using ":echo", which is a
    			Vim command, and ":!echo", which is an external shell
    			command:
    		:!echo %		--> filename
    <			The arguments of ":!" are expanded, see |:_%|.
    		:!echo "%"		--> filename or "filename"
    			Like the previous example.  Whether you see the double
    			quotes or not depends on your 'shell'.
    		:echo %			--> nothing
    <			The '%' is an illegal character in an expression.
    		:echo "%"		--> %
    <			This just echoes the '%' character.
    		:echo expand("%")	--> filename
    			This calls the expand() function to expand the '%'.

    							*:echoh* *:echohl*
    :echoh[l] {name}	Use the highlight group {name} for the following
    			|:echo|, |:echon| and |:echomsg| commands.  Also used
    			for the |input()| prompt.  Example:
    		:echohl WarningMsg | echo "Don't panic!" | echohl None
    			Don't forget to set the group back to "None",
    			otherwise all following echo's will be highlighted.

    							*:echom* *:echomsg*
    :echom[sg] {expr1} ..	Echo the expression(s) as a true message, saving the
    			message in the |message-history|.
    			Spaces are placed between the arguments as with the
    			|:echo| command.
    			Uses the highlighting set by the |:echohl| command.
    			Example:
    		:echomsg "It's a Zizzer Zazzer Zuzz, as you can plainly see."

    							*:echoe* *:echoerr*
    :echoe[rr] {expr1} ..	Echo the expression(s) as an error message, saving the
    			message in the |message-history|.  When used in a
    			script or function the line number will be added.
    			Spaces are placed between the arguments as with the
    			:echo command.
    			Example:
    		:echoerr "This script just failed!"
    			If you just want a highlighted message use |:echohl|.
    			And to get a beep:
    		:exe "normal \<Esc>"

    							*:exe* *:execute*
    :exe[cute] {expr1} ..	Executes the string that results from the evaluation
    			of {expr1} as an Ex command.  Multiple arguments are
    			concatenated, with a space in between.
    			Cannot be followed by a comment.
    			Examples:
    		:execute "buffer " nextbuf
    		:execute "normal " count . "w"

    			Execute can be used to append a next command to
    			commands that don't accept a '|'.  Example:
    		:execute '!ls' | echo "theend"

    			Execute is also a nice way to avoid having to type
    			control characters in a Vim script for a ":normal"
    			command:
    		:execute "normal ixxx\<Esc>"
    			This has an <Esc> character, see |expr-string|.

    			Note: The executed string may be any command-line, but
    			you cannot start or end a "while" or "if" command.
    			Thus this is illegal:
    		:execute 'while i > 5'
    		:execute 'echo "test" | break'

    			It is allowed to have a "while" or "if" command
    			completely in the executed string:
    		:execute 'while i < 5 | echo i | let i = i + 1 | endwhile'

    							*:comment*
    			":execute", ":echo" and ":echon" cannot be followed by
    			a comment directly, because they see the '"' as the
    			start of a string.  But, you can use '|' followed by a
    			comment.  Example:
    		:echo "foo" | "this is a comment

    8. Examples						*eval-examples*

    Printing in Hex

      :" The function Nr2Hex() returns the Hex string of a number.
      :func Nr2Hex(nr)
      :  let n = a:nr
      :  let r = ""
      :  while n
      :    let r = '0123456789ABCDEF'[n % 16] . r
      :    let n = n / 16
      :  endwhile
      :  return r
      :endfunc

      :" The function String2Hex() converts each character in a string to a two
      :" character Hex string.
      :func String2Hex(str)
      :  let out = ''
      :  let ix = 0
      :  while ix < strlen(a:str)
      :    let out = out . Nr2Hex(char2nr(a:str[ix]))
      :    let ix = ix + 1
      :  endwhile
      :  return out
      :endfunc

    Example of its use:
      :echo Nr2Hex(32)
    result: "20"
      :echo String2Hex("32")
    result: "3332"

    Sorting lines (by Robert Webb)

    Here is a vim script to sort lines.  Highlight the lines in vim and type
    ":Sort".  This doesn't call any external programs so it'll work on any
    platform.  The function Sort() actually takes the name of a comparison
    function as its argument, like qsort() does in C.  So you could supply it
    with different comparison functions in order to sort according to date etc.

      :" Function for use with Sort(), to compare two strings.
      :func! Strcmp(str1, str2)
      :  if (a:str1 < a:str2)
      :	return -1
      :  elseif (a:str1 > a:str2)
      :	return 1
      :  else
      :	return 0
      :  endif
      :endfunction

      :" Sort lines.  SortR() is called recursively.
      :func! SortR(start, end, cmp)
      :  if (a:start >= a:end)
      :	return
      :  endif
      :  let partition = a:start - 1
      :  let middle = partition
      :  let partStr = getline((a:start + a:end) / 2)
      :  let i = a:start
      :  while (i <= a:end)
      :	let str = getline(i)
      :	exec "let result = " . a:cmp . "(str, partStr)"
      :	if (result <= 0)
      :	    " Need to put it before the partition.  Swap lines i and partition.
      :	    let partition = partition + 1
      :	    if (result == 0)
      :		let middle = partition
      :	    endif
      :	    if (i != partition)
      :		let str2 = getline(partition)
      :		call setline(i, str2)
      :		call setline(partition, str)
      :	    endif
      :	endif
      :	let i = i + 1
      :  endwhile

      :  " Now we have a pointer to the "middle" element, as far as partitioning
      :  " goes, which could be anywhere before the partition.  Make sure it is at
      :  " the end of the partition.
      :  if (middle != partition)
      :	let str = getline(middle)
      :	let str2 = getline(partition)
      :	call setline(middle, str2)
      :	call setline(partition, str)
      :  endif
      :  call SortR(a:start, partition - 1, a:cmp)
      :  call SortR(partition + 1, a:end, a:cmp)
      :endfunc

      :" To Sort a range of lines, pass the range to Sort() along with the name of a
      :" function that will compare two lines.
      :func! Sort(cmp) range
      :  call SortR(a:firstline, a:lastline, a:cmp)
      :endfunc

      :" :Sort takes a range of lines and sorts them.
      :command! -nargs=0 -range Sort <line1>,<line2>call Sort("Strcmp")

    							*sscanf*
    There is no sscanf() function in Vim.  If you need to extract parts from a
    line, you can use matchstr() and substitute() to do it  This example shows
    how to get the file name, line number and column number out of a line like
    "foobar.txt, 123, 45".
       :" Set up the match bit
       :let mx='\(\f\+\),\s*\(\d\+\),\s*\(\d\+\)'
       :"get the part matching the whole expression
       :let l = matchstr(line, mx)
       :"get each item out of the match
       :let file = substitute(l, mx, '\1', '')
       :let lnum = substitute(l, mx, '\2', '')
       :let col = substitute(l, mx, '\3', '')

    The input is in the variable "line", the results in the variables "file",
    "lnum" and "col". (idea from Michael Geddes)

    9. No +eval feature				*no-eval-feature*

    When the |+eval| feature was disabled at compile time, none of the expression
    evaluation commands are available.  To prevent this from causing Vim scripts
    to generate all kinds of errors, the ":if" and ":endif" commands are still
    recognized, though the argument of the ":if" and everything between the ":if"
    and the matching ":endif" is ignored.  Nesting of ":if" blocks is allowed, but
    only if the commands are at the start of the line.  The ":else" command is not
    recognized.

    Example of how to avoid executing commands when the |+eval| feature is
    missing:

    	:if 1
    	:  echo "Expression evaluation is compiled in"
    	:else
    	:  echo "You will _never_ see this message"
    	:endif

    10. The sandbox					*eval-sandbox* *sandbox* *E48*

    The 'foldexpr', 'includeexpr', 'indentexpr', 'statusline' and 'foldtext'
    options are evaluated in a sandbox.  This means that you are protected from
    these expression having nasty side effects.  This gives some safety for when
    these options are set from a modeline.  It is also used when the command from
    a tags file is executed.
    This is not guaranteed 100% secure, but it should block most attacks.

    These items are not allowed in the sandbox:
    	- changing the buffer text
    	- defining or changing mapping, autocommands, functions, user commands
    	- setting an option with ":set"
    	- executing a shell command
    	- reading or writing a file
    	- jumping to another buffer or editing a file

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

Generated by vim2html on Tue Apr 16 08:10:03 UTC 2002