*eval.txt* For Vim version 6.1. Last change: 2003 Jan 28
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.txt|.
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.Notethat 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 wheremy_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:
Note that "&&" takes precedence over "||", so this has the meaning of:
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 caseequal == ==# ==? 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*Notethat 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>" forCTRL-W.Notethat "\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 " . &tabstopif &insertmodeAny 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()
let s:counter = 0
command Tick let s:counter = s:counter + 1 | echo s:counter
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
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. (UseCTRL-]on the function name to jump to the full explanation)USAGE RESULT DESCRIPTIONappend({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 inputrestore() Number restore typeahead inputsave() Number save and clear typeahead 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( [expr]) 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.Notethat 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 namebufname(3) name of buffer 3bufname("%") name of current bufferbufname("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.Notethat 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 32char2nr("ABC") returns 65< The current 'encoding' is used. Example for "utf-8":char2nr("�") returns 225char2nr("�"[0]) returns 195cindent({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)Notethat only marks in the current file can be used. Examples:col(".") column of cursorcol("$") length of cursor line plus onecol("'t") column of mark tcol("'" . markname) column of mark marknameThe 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*confirm()* confirm(<CR>{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.":endifIn 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 path0 27664 cscope.out /usr/localInvokation Return Val---------- ----------cscope_connection() 1cscope_connection(1, "out") 1cscope_connection(2, "out") 0cscope_connection(3, "out") 0cscope_connection(3, "out", "local") 1cscope_connection(4, "out") 0cscope_connection(4, "out", "local") 0cscope_connection(4, "cscope.out", "/usr/local") 1cursor({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\\vimeventhandler() *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) +option-name Vim option that 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.Notethat 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"Notethat 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"Alsonotethat 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("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<cfile>")){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/srcNote: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: abcdefThe 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() == "\< This example redefines "f" to ignore case:<S-Left>":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:endfunctiongetcharmod() *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.Notethat 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.Notethat 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:endifThis 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+histnr(<args>){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)Notethat 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).Note:When input() is called from within a mapping it will consume remaining characters from that mapping, because a mapping is handled like the characters were typed. Use |inputsave()| before input() and |inputrestore()| after input() to avoid that. Another solution is to avoid that further characters follow in the mapping, e.g., by using |:execute| or |:normal|. Example::if input("Coffee or beer? ") == "beer": echo "Cheers!":endif< Example with default text::let color = input("Color? ", "white")< Example with a mapping::nmap \x :call GetFoo()<CR>:exe "/" . Foo<CR>:function GetFoo(): call inputsave(): let g:Foo = input("enter search pattern: "): call inputrestore():endfunctioninputdialog({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:endifHitting<Enter>works like pressing the OK button. Hitting<Esc>works like pressing the Cancel button. inputrestore() *inputrestore()* Restore typeahead that was saved with a previous inputsave(). Should be called the same number of times inputsave() is called. Calling it more often is harmless though. Returns 1 when there is nothing to restore, 0 otherwise. inputsave() *inputsave()* Preserve typeahead (also from mappings) and clear it, so that a following prompt gets input from the user. Should be followed by a matching inputrestore() after the prompt. Can be used several times, in which case there must be just as many inputrestore() calls. Returns 1 when out of memory, 0 otherwise. 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)Notethat only marks in the current file can be used. Examples:line(".") line number of the cursorline("'t") line number of mark tline("'" . 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("$") |line2byte(exe "normal g'\""| endif{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>:endifThis 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 lineCTRL-VVisual blockwise s Select by character S Select by lineCTRL-SSelect 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 characterprevnonblank({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(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({server}, "foreground()"){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").": ".replremote_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 1if 2endif 2endif 1When 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.Notethat 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("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:<client>"), "HELLO"):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.Notethat 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.Notethat 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") 3strtrans({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}.Notethat 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 > " . tmpfileFor 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)Notethat only marks in the current file can be used. Examples:virtcol(".") with text "foo^Lbar", with cursor on the "^L", returns 5virtcol("$") with text "foo^Lbar", returns 9virtcol("'t") with text " there", with 't at 'h', returns 6The first column is 1. 0 is returned for an error. visualmode([expr]) *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 "<" (a singleCTRL-V>CTRL-Vcharacter) 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. If an expression is supplied that results in a non-zero number or a non-empty string, then the Visual mode will be cleared and the old value is returned.Notethat " " and "0" are also non-empty strings, thus cause the mode to be cleared. *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 forCTRL-Xexpansion 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. macunix Macintosh version of Vim, using Unix files (OS-X). 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). win32unix Win32 version of Vim, using Unix files (Cygwin) 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..")aaxx:echo matchstr(a, "a.x")axDon'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
let lines = Table("Table", "line1", "line2")
let lines = Table("Empty Table")
:function Compute(n1, n2, divname)
: if a:n2 == 0
: return "fail"
: endif
: exe "let g:" . a:divname . " = ". a:n1 / a:n2
: return "ok"
:endfunction
:let success = Compute(13, 1324, "div")
:if success == "ok"
: echo div
:endif
:function Foo()
: execute Bar()
: echo "line " . lnum . " column " . col
:endfunction
:function Bar()
: return "let lnum = " . line(".") . " | let col = " . col(".")
:endfunction
[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
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}_variableWhen 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 statementecho my_{&background}_messagewould 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_..or even nest them:{adverb}_{adjective}_messageecho my_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:{ad{end_of_word}}_message:let foo='a + b':echo c.. 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:{foo}d:let func_end='whizz':call my_func_This would call the function "my_func_whizz(parameter)"{func_end}(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:endifThe 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":endifNOTE: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" &shellA 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 |*:echon* :echonredraw| echo "there is a new window"{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 " &shellNotethe 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("%") --> filenameThis 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 |Don't forget to set the group back to "None", otherwise all following echo's will be highlighted. *:echom* *:echomsg* :echom[sg]echo "Don't panic!"| echohl None{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 \*:exe* *:execute* :exe[cute]<Esc>"{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\This has an<Esc>"<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 |*: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 i| let i = i + 1 | endwhile':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:endfuncExample 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*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".<line1>,<line2>call Sort("Strcmp"):" 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 Fri Apr 23 15:15:06 CST 2004