Return the absolute value of {expr}. When {expr} evaluates to a |Float| abs() returns a |Float|. When {expr} can be converted to a |Number| abs() returns a |Number|. Otherwise abs() gives an error message and returns -1. Examples: echo abs(1.456) 1.456 echo abs(-5.456) 5.456 echo abs(-4) 4 Can also be used as a |method|: Compute()->abs() {only available when compiled with the |+float| feature}

Return the arc cosine of {expr} measured in radians, as a |Float| in the range of [0, pi]. {expr} must evaluate to a |Float| or a |Number| in the range [-1, 1]. Examples: :echo acos(0) 1.570796 :echo acos(-0.5) 2.094395 Can also be used as a |method|: Compute()->acos() {only available when compiled with the |+float| feature}

Append the item {expr} to |List| or |Blob| {object}. Returns the resulting |List| or |Blob|. Examples: :let alist = add([1, 2, 3], item) :call add(mylist, "woodstock") Note that when {expr} is a |List| it is appended as a single item. Use |extend()| to concatenate |Lists|. When {object} is a |Blob| then {expr} must be a number. Use |insert()| to add an item at another position. Can also be used as a |method|: mylist->add(val1)->add(val2)

Bitwise AND on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Example: :let flag = and(bits, 0x80) Can also be used as a |method|: :let flag = bits->and(0x80)

When {text} is a |List|: Append each item of the |List| as a text line below line {lnum} in the current buffer. Otherwise append {text} as one text line below line {lnum} in the current buffer. Any type of item is accepted and converted to a String. {lnum} can be zero to insert a line before the first one. Returns 1 for failure ({lnum} out of range or out of memory), 0 for success. Example: :let failed = append(line('$'), "# THE END") :let failed = append(0, ["Chapter 1", "the beginning"]) Can also be used as a |method| after a List, the base is passed as the second argument: mylist->append(lnum)

The result is the number of files in the argument list. See |arglist|. If {winid} is not supplied, the argument list of the current window is used. If {winid} is -1, the global argument list is used. Otherwise {winid} specifies the window of which the argument list is used: either the window number or the window ID. Returns -1 if the {winid} argument is invalid.

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

Return the argument list ID. This is a number which identifies the argument list being used. Zero is used for the global argument list. See |arglist|. Returns -1 if the arguments are invalid. Without arguments use the current window. With {winnr} only use this window in the current tab page. With {winnr} and {tabnr} use the window in the specified tab page. {winnr} can be the window number or the |window-ID|.

The result is the {nr}th file in the argument list. See |arglist|. "argv(0)" is the first one. Example: :let i = 0 :while i < argc() : let f = escape(fnameescape(argv(i)), '.') : exe 'amenu Arg.' . f . ' :e ' . f . '' : let i = i + 1 :endwhile Without the {nr} argument, or when {nr} is -1, a |List| with the whole |arglist| is returned. The {winid} argument specifies the window ID, see |argc()|. For the Vim command line arguments see |v:argv|.

Return the arc sine of {expr} measured in radians, as a |Float| in the range of [-pi/2, pi/2]. {expr} must evaluate to a |Float| or a |Number| in the range [-1, 1]. Examples: :echo asin(0.8) 0.927295 :echo asin(-0.5) -0.523599 Can also be used as a |method|: Compute()->asin() {only available when compiled with the |+float| feature}

Assert if x is Position by raising an AssertError when it's not.

Assert if x is ScreenPos by raising an AssertError when it's not.

Return the principal value of the arc tangent of {expr}, in the range [-pi/2, +pi/2] radians, as a |Float|. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo atan(100) 1.560797 :echo atan(-4.01) -1.326405 Can also be used as a |method|: Compute()->atan() {only available when compiled with the |+float| feature}

Return the arc tangent of {expr1} / {expr2}, measured in radians, as a |Float| in the range [-pi, pi]. {expr1} and {expr2} must evaluate to a |Float| or a |Number|. Examples: :echo atan2(-1, 1) -0.785398 :echo atan2(1, -1) 2.356194 Can also be used as a |method|: Compute()->atan(1) {only available when compiled with the |+float| feature}

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

Put up a directory requester. This only works when "has("browse")" returns |TRUE| (only in some GUI versions). On systems where a directory browser is not supported a file browser is used. In that case: select a file in the directory to be used. The input fields are: {title} title for the requester {initdir} directory to start browsing in When the "Cancel" button is hit, something went wrong, or browsing is not possible, an empty string is returned.

Add a buffer to the buffer list with {name}. If a buffer for file {name} already exists, return that buffer number. Otherwise return the buffer number of the newly created buffer. When {name} is an empty string then a new buffer is always created. The buffer will not have' 'buflisted' set.

The result is a Number, which is |TRUE| if a buffer called {expr} exists. If the {expr} argument is a number, buffer numbers are used. Number zero is the alternate buffer for the current window.

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

Ensure the buffer {expr} is loaded. When the buffer name refers to an existing file then the file is read. Otherwise the buffer will be empty. If the buffer was already loaded then there is no change. If there is an existing swap file for the file of the buffer, there will be no dialog, the buffer will be loaded anyway. The {expr} argument is used like with |bufexists()|.

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

The result is the name of a buffer, as it is displayed by the ":ls" command. If {expr} is omitted the current buffer is used. 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 |file-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. If you only want a full match then put "^" at the start and "$" at the end of the pattern. Listed buffers are found first. If there is a single match with a listed buffer, that one is returned. Next unlisted buffers are searched for. If the {expr} is a String, but you want to use it as a buffer number, force it to be a Number by adding zero to it: > :echo bufname("3" + 0) If the buffer doesn't exist, or doesn't have a name, an empty string is returned. bufname("#") alternate buffer name bufname(3) name of buffer 3 bufname("%") name of current buffer bufname("file2") name of buffer where "file2" matches.

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. Or, if the {create} argument is present and not zero, a new, unlisted, buffer is created and its number is returned. bufnr("$") is the last buffer: :let last_buffer = bufnr("$") The result is a Number, which is the highest buffer number of existing buffers. Note that not all buffers with a smaller number necessarily exist, because ":bwipeout" may have removed them. Use bufexists() to test for the existence of a buffer.

The result is a Number, which is the |window-ID| 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: >

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: >

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|. Can also be used as a |method|: GetOffset()->byte2line() {not available when compiled without the |+byte_offset| feature}

Like byteidx(), except that a composing character is counted as a separate character. Example: let s = 'e' . nr2char(0x301) echo byteidx(s, 1) echo byteidxcomp(s, 1) echo byteidxcomp(s, 2) The first and third echo result in 3 ('e' plus composing character is 3 bytes), the second echo results in 1 ('e' is one byte). Only works differently from byteidx() when 'encoding' is set to a Unicode encoding. Can also be used as a |method|: GetName()->byteidxcomp(idx)

Call function {func} with the items in |List| {arglist} as arguments. {func} can either be a |Funcref| or the name of a function. a:firstline and a:lastline are set to the cursor line. Returns the return value of the called function. {dict} is for functions with the "dict" attribute. It will be used to set the local variable "self". |Dictionary-function| Can also be used as a |method|: GetFunc()->call([arg, arg], dict)

Return the smallest integral value greater than or equal to {expr} as a |Float| (round up). {expr} must evaluate to a |Float| or a |Number|. Examples: echo ceil(1.456) 2.0 echo ceil(-5.456) -5.0 echo ceil(4.0) 4.0 Can also be used as a |method|: Compute()->ceil() {only available when compiled with the |+float| feature}

Return the number of the most recent change. This is the same number as what is displayed with |:undolist| and can be used with the |:undo| command. When a change was made it is the number of that change. After redo it is the number of the redone change. After undo it is one less than the number of the undone change.

Return number value of the first char in {expr}. Examples: char2nr(" ") returns 32 char2nr("ABC") returns 65 When {utf8} is omitted or zero, the current 'encoding' is used. Example for "utf-8": char2nr("á") returns 225 char2nr("á"[0]) returns 195 With {utf8} set to TRUE, always treat as utf-8 characters. A combining character is a separate character. |nr2char()| does the opposite. To turn a string into a list of character numbers: let str = "ABC" let list = map(split(str, '\zs'), {_, val -> char2nr(val)}) Result: [65, 66, 67] Can also be used as a |method|: GetChar()->char2nr()

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. See |C-indenting|. Can also be used as a |method|: GetLnum()->cindent()

Clears all matches previously defined for the current window by |matchadd()| and the |:match| commands. If {win} is specified, use the window with this number or window ID instead of the current window. Can also be used as a |method|: GetWin()->clearmatches()

The result is a Number, which is the byte index of the column position given with {expr}. The accepted positions are: . the cursor position $ the end of the cursor line (the result is the number of bytes in the cursor line plus one) 'x position of mark x (if the mark is not set, 0 is returned) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from |'<| in that it's updated right away. Additionally {expr} can be [lnum, col]: a |List| with the line and column number. Most useful when the column is "$", to get the last column of a specific line. When "lnum" or "col" is out of range then col() returns zero. To get the line number use |line()|. To get both use |getpos()|. For the screen column position use |virtcol()|. Note that only marks in the current file can be used. Examples: col(".") column of cursor col("$") length of cursor line plus one col("'t") column of mark t col("'" . markname) column of mark markname The first column is 1. 0 is returned for an error. For an uppercase mark the column may actually be in another buffer. 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 :let save_ve = &ve<CR <C-O>:set ve=all<CR <C-O>:echo col(".") . "\n" <Bar \let &ve = save_ve<CR GetPos()->col()

Add {expr} to the list of matches. Only to be used by the function specified with the 'completefunc' option. Returns 0 for failure (empty string or out of memory), 1 when the match was added, 2 when the match was already in the list. See |complete-functions| for an explanation of {expr}. It is the same as one item in the list that 'omnifunc' would return. Can also be used as a |method|: GetMoreMatches()->complete_add()

Check for a key typed while looking for completion matches. This is to be used when looking for matches takes some time. Returns |TRUE| when searching for matches is to be aborted, zero otherwise. Only to be used by the function specified with the 'completefunc' option.

Make a copy of {expr}. For Numbers and Strings this isn't different from using {expr} directly. When {expr} is a |List| a shallow copy is created. This means that the original |List| can be changed without changing the copy, and vice versa. But the items are identical, thus changing an item changes the contents of both |Lists|. A |Dictionary| is copied in a similar way as a |List|. Also see |deepcopy()|. Can also be used as a |method|: mylist->copy()

Return the cosine of {expr}, measured in radians, as a |Float|. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo cos(100) 0.862319 :echo cos(-4.01) -0.646043 Can also be used as a |method|: Compute()->cos() {only available when compiled with the |+float| feature}

Return the hyperbolic cosine of {expr} as a |Float| in the range [1, inf]. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo cosh(0.5) 1.127626 :echo cosh(-0.5) -1.127626 Can also be used as a |method|: Compute()->cosh() {only available when compiled with the |+float| feature}

Specifically used to interrupt a program being debugged. It will cause process {pid} to get a SIGTRAP. Behavior for other processes is undefined. See |terminal-debugger|. {only available on MS-Windows} Can also be used as a |method|: GetPid()->debugbreak()

Delete lines {first} to {last} (inclusive) from buffer {expr}. If {last} is omitted then delete line {first} only. On success 0 is returned, on failure 1 is returned. This function works only for loaded buffers. First call |bufload()| if needed. For the use of {expr}, see |bufname()| above. {first} and {last} are used like with |getline()|. Note that when using |line()| this refers to the current buffer. Use "$" to refer to the last line in buffer {expr}. Can also be used as a |method|: GetBuffer()->deletebufline(1)

Returns |TRUE| 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| Returns |FALSE| when :setf FALLBACK was used. 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 syntax file.

Returns the number of filler lines above line {lnum}. These are the lines that were inserted at this point in another diff'ed window. These filler lines are shown in the display but don't exist in the buffer. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. Returns 0 if the current window is not in diff mode. Can also be used as a |method|: GetLnum()->diff_filler()

Returns the highlight ID for diff mode at line {lnum} column {col} (byte index). When the current line does not have a diff change zero is returned. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. {col} is 1 for the leftmost column, {lnum} is 1 for the first line. The highlight ID can be used with |synIDattr()| to obtain syntax information about the highlighting. Can also be used as a |method|: GetLnum()->diff_hlID(col)

Return the Number 1 if {expr} is empty, zero otherwise.

• A |List| or |Dictionary| is empty when it does not have any items.
• A |String| is empty when its length is zero.
• A |Number| and |Float| are empty when their value is zero.
• |v:false|, |v:none| and |v:null| are empty, |v:true| is not.
• A |Job| is empty when it failed to start.
• A |Channel| is empty when it is closed.
• A |Blob| is empty when its length is zero. For a long |List| this is much faster than comparing the length with zero. Can also be used as a |method|: mylist->empty()

Ensure if x is Position by raising an AssertError when it's not.

Ensure if x is ScreenPos by raising an AssertError when it's not.

Return all of environment variables as dictionary. You can check if an environment variable exists like this: :echo has_key(environ(), 'HOME') Note that the variable name may be CamelCase; to ignore case use this: :echo index(keys(environ()), 'HOME', 0, 1) != -1

Escape the characters in {chars} that occur in {string} with a backslash. Example: :echo escape('c:\program files\vim', ' ') results in: c:\program\ files\vim Also see |shellescape()| and |fnameescape()|. Can also be used as a |method|: GetText()->escape(' ')

Evaluate {string} and return the result. Especially useful to turn the result of |string()| back into the original value. This works for Numbers, Floats, Strings, Blobs and composites of them. Also works for |Funcref|s that refer to existing functions. Can also be used as a |method|: argv->join()->eval()

Returns 1 when inside an event handler. That is that Vim got interrupted while waiting for the user to type a character, e.g., when dropping a file on Vim. This means interactive commands cannot be used. Otherwise zero is returned.

If {expr} is an executable and is either an absolute path, a relative path or found in $PATH, return the full path. Note that the current directory is used when {expr} starts with "./", which may be a problem for Vim: echo exepath(v:progpath) If {expr} cannot be found in $PATH or is not executable then an empty string is returned. Can also be used as a |method|: GetCommand()->exepath()

The result is a Number, which is |TRUE| if {expr} is defined, zero otherwise.

Return the exponential of {expr} as a |Float| in the range [0, inf]. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo exp(2) 7.389056 :echo exp(-1) 0.367879 Can also be used as a |method|: Compute()->exp() {only available when compiled with the |+float| feature}

Expand special items in {expr} like what is done for an Ex command such as :edit. This expands special keywords, like with |expand()|, and environment variables, anywhere in {expr}. "user" and "/path" are only expanded at the start. Returns the expanded string. Example: :echo expandcmd('make %<.o') Can also be used as a |method|: GetCommand()->expandcmd()

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. If you don't care about the file being readable you can use |glob()|. {file} is used as-is, you may want to expand wildcards first: echo filereadable('/.vimrc') 0 echo filereadable(expand('/.vimrc')) 1 Can also be used as a |method|: GetName()->filereadable() Obsolete name: file_readable().

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. Can also be used as a |method|: GetName()->filewritable()

Just like |finddir()|, but find a file instead of a directory. Uses 'suffixesadd'. Example: :echo findfile("tags.vim", ".;") Searches from the directory of the current file upwards until it finds the file "tags.vim". Can also be used as a |method|: GetName()->findfile()

Flatten {list} up to {maxdepth} levels. Without {maxdepth} the result is a |List| without nesting, as if {maxdepth} is a very large number. The {list} is changed in place, use |flattennew()| if you do not want that. In Vim9 script flatten() cannot be used, you must always use |flattennew()|. {maxdepth} means how deep in nested lists changes are made. {list} is not modified when {maxdepth} is 0. {maxdepth} must be positive number. If there is an error the number zero is returned. Example: :echo flatten([1, [2, [3, 4]], 5]) [1, 2, 3, 4, 5] :echo flatten([1, [2, [3, 4]], 5], 1) [1, 2, [3, 4], 5]

Convert {expr} to a Number by omitting the part after the decimal point. {expr} must evaluate to a |Float| or a Number. When the value of {expr} is out of range for a |Number| the result is truncated to 0x7fffffff or -0x7fffffff (or when 64-bit Number support is enabled, 0x7fffffffffffffff or -0x7fffffffffffffff). NaN results in -0x80000000 (or when 64-bit Number support is enabled, -0x8000000000000000). Examples: echo float2nr(3.95) 3 echo float2nr(-23.45) -23 echo float2nr(1.0e100) 2147483647 (or 9223372036854775807) echo float2nr(-1.0e150) -2147483647 (or -9223372036854775807) echo float2nr(1.0e-100) 0 Can also be used as a |method|: Compute()->float2nr() {only available when compiled with the |+float| feature}

Return the largest integral value less than or equal to {expr} as a |Float| (round down). {expr} must evaluate to a |Float| or a |Number|. Examples: echo floor(1.856) 1.0 echo floor(-5.456) -6.0 echo floor(4.0) 4.0 Can also be used as a |method|: Compute()->floor() {only available when compiled with the |+float| feature}

Return the remainder of {expr1} / {expr2}, even if the division is not representable. Returns {expr1} - i * {expr2} for some integer i such that if {expr2} is non-zero, the result has the same sign as {expr1} and magnitude less than the magnitude of {expr2}. If {expr2} is zero, the value returned is zero. The value returned is a |Float|. {expr1} and {expr2} must evaluate to a |Float| or a |Number|. Examples: :echo fmod(12.33, 1.22) 0.13 :echo fmod(-12.33, 1.22) -0.13 Can also be used as a |method|: Compute()->fmod(1.22) {only available when compiled with |+float| feature}

Escape {string} for use as file name command argument. All characters that have a special meaning, such as '%' and '|' are escaped with a backslash. For most systems the characters escaped are " \t\n*?[{`$\%#'"|!<". For systems where a backslash appears in a filename, it depends on the value of 'isfname'. A leading '+' and '>' is also escaped (special after |:edit| and |:write|). And a "-" by itself (special after |:cd|). Example: :let fname = '+some str%nge|name' :exe "edit " . fnameescape(fname) results in executing: edit +some\ str%nge|name Can also be used as a |method|: GetName()->fnameescape()

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

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. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. Can also be used as a |method|: GetLnum()->foldclosed()

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. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. Can also be used as a |method|: GetLnum()->foldclosedend()

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. As a special case the level of the previous line is usually available. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. Can also be used as a |method|: GetLnum()->foldlevel()

Returns a String, to be displayed for a closed fold. This is the default function used for the 'foldtext' option and should only be called from evaluating 'foldtext'. It uses the |v:foldstart|, |v:foldend| and |v:folddashes| variables. The returned string looks like this: +-- 45 lines: abcdef The number of leading 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. When used to draw the actual foldtext, the rest of the line will be filled with the fold char from the 'fillchars' setting. {not available when compiled without the |+folding| feature}

Returns the text that is displayed for the closed fold at line {lnum}. Evaluates 'foldtext' in the appropriate context. When there is no closed fold at {lnum} an empty string is returned. {lnum} is used like with |getline()|. Thus "." is the current line, "'m" mark m, etc. Useful when exporting folded text, e.g., to HTML. {not available when compiled without the |+folding| feature} Can also be used as a |method|: GetLnum()->foldtextresult()

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}

Just like |function()|, but the returned Funcref will lookup the function by reference, not by name. This matters when the function {name} is redefined later. Unlike |function()|, {name} must be an existing user function. Also for autoloaded functions. {name} cannot be a builtin function. Can also be used as a |method|: GetFuncname()->funcref([arg])

Get item {idx} from |List| {list}. When this item is not available return {default}. Return zero when {default} is omitted. Preferably used as a |method|: mylist->get(idx)

Return a |List| with the lines starting from {lnum} to {end} (inclusive) in the buffer {expr}. If {end} is omitted, a |List| with only the line {lnum} is returned.

Returns the |changelist| for the buffer {expr}. For the use of {expr}, see |bufname()| above. If buffer {expr} doesn't exist, an empty list is returned. The returned list contains two entries: a list with the change locations and the current position in the list. Each entry in the change list is a dictionary with the following entries: col column number coladd column offset for 'virtualedit' lnum line number If buffer {expr} is the current buffer, then the current position refers to the position in the list. For other buffers, it is set to the length of the list. Can also be used as a |method|: GetBufnr()->getchangelist()

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 meta (when it's different from ALT) 32 mouse double click 64 mouse triple click 96 mouse quadruple click (== 32 + 64) 128 command (Macintosh only) Only the modifiers that have not been included in the character itself are obtained. Thus Shift-a results in "A" without a modifier.

Return the current character search information as a {dict} with the following entries: char character previously used for a character search (|t|, |f|, |T|, or |F|); empty string if no character search has been performed forward direction of character search; 1 for forward, 0 for backward until type of character search; 1 for a |t| or |T| character search, 0 for an |f| or |F| character search This can be useful to always have |;| and |,| search forward/backward regardless of the direction of the previous character search: :nnoremap ; getcharsearch().forward ? ';' : ',' :nnoremap , getcharsearch().forward ? ',' : ';' Also see |setcharsearch()|.

Return the current command-line. Only works when the command line is being edited, thus requires use of |c_CTRL-_e| or |c_CTRL-R_=|. Example: :cmap <C->eescape(getcmdline(), ' ')<CR Returns an empty string when entering a password or using |inputsecret()|.

Return the position of the cursor in the command line as a byte count. The first column is 1. Only works when editing the command line, thus requires use of |c_CTRL-_e| or |c_CTRL-R_=| or an expression mapping. Returns 0 otherwise. Also see |getcmdtype()|, |setcmdpos()| and |getcmdline()|.

Return the current command-line type. Possible return values are: : normal Ex command > debug mode command |debug-mode| / forward search command ? backward search command @ |input()| command - |:insert| or |:append| command = |i_CTRL-R_=| Only works when editing the command line, thus requires use of |c_CTRL-_e| or |c_CTRL-R_=| or an expression mapping. Returns an empty string otherwise. Also see |getcmdpos()|, |setcmdpos()| and |getcmdline()|.

Return the current |command-line-window| type. Possible return values are the same as |getcmdtype()|. Returns an empty string when not in the command-line window.

Get the position of the cursor. This is like getpos('.'), but includes an extra item in the list: [bufnum, lnum, col, off, curswant] ~ The "curswant" number is the preferred column when moving the cursor vertically. Also see |getpos()|. This can be used to save and restore the cursor position: let save_cursor = getcurpos() MoveTheCursorAround call setpos('.', save_cursor) Note that this only works within the window. See |winrestview()| for restoring more state.

Return the value of environment variable {name}. When the variable does not exist |v:null| is returned. That is different from a variable set to an empty string, although some systems interpret the empty value as the variable being deleted. See also |expr-env|. Can also be used as a |method|: GetVarname()->getenv()

Without an argument returns the name of the normal font being used. Like what is used for the Normal highlight group |hl-Normal|. With an argument a check is done whether {name} is a valid font name. If not then an empty string is returned. Otherwise the actual font name is returned, or {name} if the GUI does not support obtaining the real name. Only works when the GUI is running, thus not in your vimrc or gvimrc file. Use the |GUIEnter| autocommand to use this function just after the GUI has started. Note that the GTK GUI accepts any font name, thus checking for a valid name does not work.

The result is a String, which is the read, write, and execute permissions of the given file {fname}. If {fname} does not exist or its directory cannot be read, an empty string is returned. The result is of the form "rwxrwxrwx", where each group of "rwx" flags represent, in turn, the permissions of the owner of the file, the group the file belongs to, and other users. If a user does not have a given permission the flag for this is replaced with the string "-". Examples: :echo getfperm("/etc/passwd") :echo getfperm(expand("~/.vimrc")) This will hopefully (from a security point of view) display the string "rw-r--r--" or even "rw-------". Can also be used as a |method|: GetFilename()->getfperm() For setting permissions use |setfperm()|.

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. If the size of {fname} is too big to fit in a Number then -2 is returned. Can also be used as a |method|: GetFilename()->getfsize()

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. Can also be used as a |method|: GetFilename()->getftime()

The result is a String, which is a description of the kind of file of the given file {fname}. If {fname} does not exist an empty string is returned. Here is a table over different kinds of files and their results: Normal file "file" Directory "dir" Symbolic link "link" Block device "bdev" Character device "cdev" Socket "socket" FIFO "fifo" All other "other" Example: getftype("/home") Note that a type such as "link" will only be returned on systems that support it. On some systems only "dir" and "file" are returned. On MS-Windows a symbolic link to a directory returns "dir" instead of "link". Can also be used as a |method|: GetFilename()->getftype()

Returns the |jumplist| for the specified window. Without arguments use the current window. With {winnr} only use this window in the current tab page. {winnr} can also be a |window-ID|. With {winnr} and {tabnr} use the window in the specified tab page. The returned list contains two entries: a list with the jump locations and the last used jump position number in the list. Each entry in the jump location list is a dictionary with the following entries: bufnr buffer number col column number coladd column offset for 'virtualedit' filename filename if available lnum line number Can also be used as a |method|: GetWinnr()->getjumplist()

Without the {expr} argument returns a |List| with information about all the global marks. |mark| If the optional {expr} argument is specified, returns the local marks defined in buffer {expr}. For the use of {expr}, see |bufname()|. Each item in the returned List is a |Dict| with the following: mark name of the mark prefixed by "'" pos a |List| with the position of the mark: [bufnum, lnum, col, off] Refer to |getpos()| for more information. file file name Refer to |getpos()| for getting information about a specific mark. Can also be used as a |method|: GetBufnr()->getmarklist()

Return a Number which is the process ID of the Vim process. On Unix and MS-Windows this is a unique number, until Vim exits.

Get the position for {expr}. For possible values of {expr} see |line()|. For getting the cursor position see |getcurpos()|. The result is a |List| with four numbers: [bufnum, lnum, col, off] "bufnum" is zero, unless a mark like '0 or 'A is used, then it is the buffer number of the mark. "lnum" and "col" are the position in the buffer. The first column is 1. The "off" number is zero, unless 'virtualedit' is used. Then it is the offset in screen columns from the start of the character. E.g., a position within a or after the last character. Note that for '< and '> Visual mode matters: when it is "V" (visual line mode) the column of '< is zero and the column of '> is a large number. This can be used to save and restore the position of a mark: let save_a_mark = getpos("'a") ... call setpos("'a", save_a_mark) Also see |getcurpos()| and |setpos()|. Can also be used as a |method|: GetMark()->getpos()

The result is a String, which is type of register {regname}. The value will be one of: "v" for |characterwise| text "V" for |linewise| text "{width}" for |blockwise-visual| text "" for an empty or unknown register is one character with value 0x16. If {regname} is not specified, |v:register| is used. In |Vim9-script| {regname} must be one character. Can also be used as a |method|: GetRegname()->getregtype()

If {tabnr} is not specified, then information about all the tab pages is returned as a |List|. Each List item is a |Dictionary|. Otherwise, {tabnr} specifies the tab page number and information about that one is returned. If the tab page does not exist an empty List is returned. Each List item is a |Dictionary| with the following entries: tabnr tab page number. variables a reference to the dictionary with tabpage-local variables windows List of |window-ID|s in the tab page. Can also be used as a |method|: GetTabnr()->gettabinfo()

Get the value of a tab-local variable {varname} in tab page {tabnr}. |t:var| Tabs are numbered starting with one. When {varname} is empty a dictionary with all tab-local variables is returned. Note that the name without "t:" must be used. When the tab or variable doesn't exist {def} or an empty string is returned, there is no error message. Can also be used as a |method|: GetTabnr()->gettabvar(varname)

The result is a |List| with two numbers, the result of |getwinposx()| and |getwinposy()| combined: [x-pos, y-pos] {timeout} can be used to specify how long to wait in msec for a response from the terminal. When omitted 100 msec is used. Use a longer time for a remote terminal. When using a value less than 10 and no response is received within that time, a previously reported position is returned, if available. This can be used to poll for the position and do some work in the meantime: while 1 let res = getwinpos(1) if res[0] >= 0 break endif " Do some work here endwhile Can also be used as a |method|: GetTimeout()->getwinpos()

The result is a Number, which is the X coordinate in pixels of the left hand side of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with :winpos.

The result is a Number, which is the Y coordinate in pixels of the top of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with :winpos.

Like |gettabwinvar()| for the current tabpage. Examples: :let list_is_on = getwinvar(2, '&list') :echo "myvar = " . getwinvar(1, 'myvar') Can also be used as a |method|: GetWinnr()->getwinvar(varname)

Convert a file pattern, as used by glob(), into a search pattern. The result can be used to match with a string that is a file name. E.g. if filename =~ glob2regpat('Make*.mak') This is equivalent to: if filename =~ '^Make.*.mak$' When {expr} is an empty string the result is "^$", match an empty string. Note that the result depends on the system. On MS-Windows a backslash usually means a path separator. Can also be used as a |method|: GetExpr()->glob2regpat()

Returns 1 if {feature} is supported, 0 otherwise. The {feature} argument is a feature name like "nvim-0.2.1" or "win32", see below. See also |exists()|.

The result is a Number, which is TRUE if |Dictionary| {dict} has an entry with key {key}. FALSE otherwise. Can also be used as a |method|: mydict->has_key(key)

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+) Can also be used as a |method|: GetHistory()->histget()

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") Can also be used as a |method|: GetHistory()->histnr()

The result is a Number, which is TRUE 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. Obsolete name: highlight_exists(). Can also be used as a |method|: GetName()->hlexists()

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") Obsolete name: highlightID(). Can also be used as a |method|: GetName()->hlID()

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.

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. Can also be used as a |method|: GetLnum()->indent()

The result is a String, which is whatever the user typed on the command-line. The {prompt} argument 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(). Example: :if input("Coffee or beer? ") == "beer" : echo "Cheers!" :endif If the optional {text} argument is present and not empty, this is used for the default reply, as if the user typed this. Example: :let color = input("Color? ", "white") The optional {completion} argument specifies the type of completion supported for the input. Without it completion is not performed. The supported completion types are the same as that can be supplied to a user-defined command using the "-complete=" argument. Refer to |:command-completion| for more information. Example: let fname = input("File: ", "", "file") NOTE: This function 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 with a mapping: :nmap \x :call GetFoo():exe "/" . Foo<CR :function GetFoo() : call inputsave() : let g:Foo = input("enter search pattern: ") : call inputrestore() :endfunction Can also be used as a |method|: GetPrompt()->input()

{textlist} must be a |List| of strings. This |List| is displayed, one string per line. The user will be prompted to enter a number, which is returned. The user can also select an item by clicking on it with the mouse. For the first string 0 is returned. When clicking above the first item a negative number is returned. When clicking on the prompt one more than the length of {textlist} is returned. Make sure {textlist} has less than 'lines' entries, otherwise it won't work. It's a good idea to put the entry number at the start of the string. And put a prompt in the first item. Example: let color = inputlist(['Select color:', '1. red', \ '2. green', '3. blue']) Can also be used as a |method|: GetChoices()->inputlist()

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.

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.

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. NOTE: Command-line completion is not supported. Can also be used as a |method|: GetPrompt()->inputsecret()

Interrupt script execution. It works more or less like the user typing CTRL-C, most commands won't execute and control returns to the user. This is useful to abort execution from lower down, e.g. in an autocommand. Example: :function s:check_typoname(file) : if fnamemodify(a:file, ':t') == '[' : echomsg 'Maybe typo' : call interrupt() : endif :endfunction :au BufWritePre * call s:check_typoname(expand(''))

Bitwise invert. The argument is converted to a number. A List, Dict or Float argument causes an error. Example: :let bits = invert(bits) Can also be used as a |method|: :let bits = bits->invert()

The result is a Number, which is |TRUE| 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. Can also be used as a |method|: GetName()->isdirectory()

Return 1 if {expr} is a positive infinity, or -1 a negative infinity, otherwise 0. :echo isinf(1.0 / 0.0) 1 :echo isinf(-1.0 / 0.0) -1 Can also be used as a |method|: Compute()->isinf() {only available when compiled with the |+float| feature}

The result is a Number, which is |TRUE| when {expr} is the name of a locked variable. {expr} must be the name of a variable, |List| item or |Dictionary| entry, not the variable itself! Example: :let alist = [0, ['a', 'b'], 2, 3] :lockvar 1 alist :echo islocked('alist') " 1 :echo islocked('alist[1]') " 0 When {expr} is a variable that does not exist you get an error message. Use |exists()| to check for existence. In Vim9 script it does not work for local variables. Can also be used as a |method|: GetName()->islocked()

Return |TRUE| if {expr} is a float with value NaN. echo isnan(0.0 / 0.0) 1 Can also be used as a |method|: Compute()->isnan() {only available when compiled with the |+float| feature}

Return true if the value is Position.

Return true if the value is ScreenPos.

Check if the value is valid BuiltinCompletion

Return a |List| with all the key-value pairs of {dict}. Each |List| item is a list with two items: the key of a {dict} entry and the value of this entry. The |List| is in arbitrary order. Also see |keys()| and |values()|. Example: for [key, value] in items(mydict) echo key . ': ' . value endfor Can also be used as a |method|: mydict->items()

Join the items in {list} together into one String. When {sep} is specified it is put in between the items. If {sep} is omitted a single space is used. Note that {sep} is not added at the end. You might want to add it there too: let lines = join(mylist, "\n") . "\n" String items are used as-is. |Lists| and |Dictionaries| are converted into a string like with |string()|. The opposite function is |split()|. Can also be used as a |method|: mylist->join()

Return a |List| with all the keys of {dict}. The |List| is in arbitrary order. Also see |items()| and |values()|. Can also be used as a |method|: mydict->keys()

When {expr} is a String or a Number the length in bytes is used, as with |strlen()|. When {expr} is a |List| the number of items in the |List| is returned. When {expr} is a |Blob| the number of bytes is returned. When {expr} is a |Dictionary| the number of entries in the |Dictionary| is returned. Otherwise an error is given. Can also be used as a |method|: mylist->len()

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} Examples: :echo libcallnr("/usr/lib/libc.so", "getpid", "") :call libcallnr("libc.so", "printf", "Hello World!\n") :call libcallnr("libc.so", "sleep", 10) Can also be used as a |method|, the base is passed as the third argument: GetValue()->libcallnr("libc.so", "printf")

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) w0 first line visible in current window (one if the display isn't updated, e.g. in silent Ex mode) w$ last line visible in current window (this is one less than "w0" if no lines are visible) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from |'<| in that it's updated right away. Note that a mark in another file can be used. The line number then applies to another buffer. To get the column number use |col()|. To get both use |getpos()|. Examples: line(".") line number of the cursor line("'t") line number of mark t line("'" . marker) line number of mark marker To jump to the last known position when opening a file see |last-position-jump|. Can also be used as a |method|: GetValue()->line()

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. 'encoding' matters, 'fileencoding' is ignored. This can also be used to get the byte count for the line just below the last line: line2byte(line("$") + 1) This is the buffer size plus one. If 'fileencoding' is empty it 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|. Can also be used as a |method|: GetLnum()->line2byte()

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. Can also be used as a |method|: GetLnum()->lispindent()

Convert each number in {list} to a character string can concatenate them all. Examples: list2str([32]) returns " " list2str([65, 66, 67]) returns "ABC" The same can be done (slowly) with: join(map(list, {nr, val -> nr2char(val)}), '') |str2list()| does the opposite. When {utf8} is omitted or zero, the current 'encoding' is used. With {utf8} is 1, always return utf-8 characters. With utf-8 composing characters work as expected: list2str([97, 769]) returns "á" Can also be used as a |method|: GetList()->list2str()

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

Return the natural logarithm (base e) of {expr} as a |Float|. {expr} must evaluate to a |Float| or a |Number| in the range (0, inf]. Examples: :echo log(10) 2.302585 :echo log(exp(5)) 5.0 Can also be used as a |method|: Compute()->log() {only available when compiled with the |+float| feature}

Return the logarithm of Float {expr} to base 10 as a |Float|. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo log10(1000) 3.0 :echo log10(0.01) -2.0 Can also be used as a |method|: Compute()->log10() {only available when compiled with the |+float| feature}

Selects the {nr} match item, as set with a |:match|, |:2match| or |:3match| command. Return a |List| with two elements: The name of the highlight group used The pattern used. When {nr} is not 1, 2 or 3 returns an empty |List|. When there is no match item set returns ['', '']. This is useful to save and restore a |:match|. Highlighting matches using the |:match| commands are limited to three matches. |matchadd()| does not have this limitation. Can also be used as a |method|: GetMatch()->matcharg()

Deletes a match with ID {id} previously defined by |matchadd()| or one of the |:match| commands. Returns 0 if successful, otherwise -1. See example for |matchadd()|. All matches can be deleted in one operation by |clearmatches()|. If {win} is specified, use the window with this number or window ID instead of the current window. Can also be used as a |method|: GetMatch()->matchdelete()

Return the maximum value of all items in {expr}. Example: echo max([apples, pears, oranges]) {expr} can be a |List| or a |Dictionary|. For a Dictionary, it returns the maximum of all values in the Dictionary. If {expr} is neither a List nor a Dictionary, or one of the items in {expr} cannot be used as a Number this results in an error. An empty |List| or |Dictionary| results in zero. Can also be used as a |method|: mylist->max()

echo min([apples, pears, oranges]) {expr} can be a |List| or a |Dictionary|. For a Dictionary, it returns the minimum of all values in the Dictionary. If {expr} is neither a List nor a Dictionary, or one of the items in {expr} cannot be used as a Number this results in an error. An empty |List| or |Dictionary| results in zero. Can also be used as a |method|: mylist->min()

Return a string that indicates the current mode. If [expr] is supplied and it evaluates to a non-zero Number or a non-empty String (|non-zero-arg|), then the full mode is returned, otherwise only the first letter is returned. Also see |state()|. n Normal, Terminal-Normal no Operator-pending nov Operator-pending (forced characterwise |o_v|) noV Operator-pending (forced linewise |o_V|) noCTRL-V Operator-pending (forced blockwise |o_CTRL-V|); CTRL-V is one character niI Normal using |i_CTRL-O| in |Insert-mode| niR Normal using |i_CTRL-O| in |Replace-mode| niV Normal using |i_CTRL-O| in |Virtual-Replace-mode| v Visual by character V Visual by line CTRL-V Visual blockwise s Select by character S Select by line CTRL-S Select blockwise i Insert ic Insert mode completion |compl-generic| ix Insert mode |i_CTRL-X| completion R Replace |R| Rc Replace mode completion |compl-generic| Rv Virtual Replace |gR| Rx Replace mode |i_CTRL-X| completion c Command-line editing cv Vim Ex mode |gQ| ce Normal Ex mode |Q| r Hit-enter prompt rm The -- more -- prompt r? A |:confirm| query of some sort ! Shell or external command is executing t Terminal-Job mode: keys go to the job This is useful in the 'statusline' option or when used with |remote_expr()| In most other places it always returns "c" or "n". Note that in the future more modes and more specific modes may be added. It's better not to compare the whole string but only the leading character(s). Also see |visualmode()|. Can also be used as a |method|: DoFull()->mode()

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()|. Can also be used as a |method|: GetLnum()->nextnonblank()

Bitwise OR on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Example: :let bits = or(bits, 0x80) Can also be used as a |method|: :let bits = bits->or(0x80)

Shorten directory names in the path {expr} and return the result. The tail, the file name, is kept as-is. The other components in the path are reduced to {len} letters in length. If {len} is omitted or smaller than 1 then 1 is used (single letters). Leading '' and '.' characters are kept. Examples: :echo pathshorten('/.vim/autoload/myfile.vim') /.v/a/myfile.vim ~ :echo pathshorten('/.vim/autoload/myfile.vim', 2) ~/.vi/au/myfile.vim ~ It doesn't matter if the path exists or not. Can also be used as a |method|: GetDirectories()->pathshorten()

Evaluate Perl expression {expr} in scalar context and return its result converted to Vim data structures. If value can't be converted, it is returned as a string Perl representation. Note: If you want an array or hash, {expr} must return a reference to it. Example: :echo perleval('[1 .. 4]') [1, 2, 3, 4] Can also be used as a |method|: GetExpr()->perleval() {only available when compiled with the |+perl| feature}

Return the power of {x} to the exponent {y} as a |Float|. {x} and {y} must evaluate to a |Float| or a |Number|. Examples: :echo pow(3, 3) 27.0 :echo pow(2, 16) 65536.0 :echo pow(32, 0.20) 2.0 Can also be used as a |method|: Compute()->pow(3) {only available when compiled with the |+float| feature}

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. Also see |nextnonblank()|. Can also be used as a |method|: GetLnum()->prevnonblank()

Returns the effective prompt text for buffer {buf}. {buf} can be a buffer name or number. See |prompt-buffer|. If the buffer doesn't exist or isn't a prompt buffer, an empty string is returned. Can also be used as a |method|: GetBuffer()->prompt_getprompt()

Set a callback for buffer {buf} to {expr}. When {expr} is an empty string the callback is removed. This has only effect if {buf} has 'buftype' set to "prompt". This callback will be invoked when pressing CTRL-C in Insert mode. Without setting a callback Vim will exit Insert mode, as in any buffer. Can also be used as a |method|: GetBuffer()->prompt_setinterrupt(callback)

Set prompt for buffer {buf} to {text}. You most likely want {text} to end in a space. The result is only visible if {buf} has 'buftype' set to "prompt". Example: call prompt_setprompt(bufnr(), 'command: ') Can also be used as a |method|: GetBuffer()->prompt_setprompt('command: ')

If the popup menu (see |ins-completion-menu|) is not visible, returns an empty |Dictionary|, otherwise, returns a |Dictionary| with the following keys: height nr of items visible width screen cells row top screen row (0 first row) col leftmost screen column (0 first col) size total nr of items scrollbar |TRUE| if scrollbar is visible The values are the same as in |v:event| during |CompleteChanged|.

Returns non-zero when the popup menu is visible, zero otherwise. See |ins-completion-menu|. This can be used to avoid some things that would remove the popup menu.

Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though, Unicode strings are additionally converted to 'encoding'). Lists are represented as Vim |List| type. Dictionaries are represented as Vim |Dictionary| type with keys converted to strings. Can also be used as a |method|: GetExpr()->py3eval() {only available when compiled with the |+python3| feature}

Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though). Lists are represented as Vim |List| type. Dictionaries are represented as Vim |Dictionary| type, non-string keys result in error. Can also be used as a |method|: GetExpr()->pyeval() {only available when compiled with the |+python| feature}

Evaluate Python expression {expr} and return its result converted to Vim data structures. Uses Python 2 or 3, see |python_x| and 'pyxversion'. See also: |pyeval()|, |py3eval()| Can also be used as a |method|: GetExpr()->pyxeval() {only available when compiled with the |+python| or the |+python3| feature}

Returns the single letter name of the register being executed. Returns an empty string when no register is being executed. See |@|.

Returns the single letter name of the register being recorded. Returns an empty string when not recording. See |q|.

Return an item that represents a time value. The item is a list with items that depend on the system. In Vim 9 script list can be used. The item can be passed to |reltimestr()| to convert it to a string or |reltimefloat()| to convert to a Float. Without an argument reltime() returns the current time. With one argument is returns the time passed since the time specified in the argument. With two arguments it returns the time passed between {start} and {end}. The {start} and {end} arguments must be values returned by reltime(). Can also be used as a |method|: GetStart()->reltime() {only available when compiled with the |+reltime| feature}

Return a Float that represents the time value of {time}. Example: let start = reltime() call MyFunction() let seconds = reltimefloat(reltime(start)) See the note of reltimestr() about overhead. Also see |profiling|. Can also be used as a |method|: reltime(start)->reltimefloat() {only available when compiled with the |+reltime| feature}

Return a String that represents the time value of {time}. This is the number of seconds, a dot and the number of microseconds. Example: let start = reltime() call MyFunction() echo reltimestr(reltime(start)) Note that overhead for the commands will be added to the time. The accuracy depends on the system. Leading spaces are used to make the string align nicely. You can use split() to remove it. echo split(reltimestr(reltime(start)))[0] Also see |profiling|. Can also be used as a |method|: reltime(start)->reltimestr() {only available when compiled with the |+reltime| feature}

Move the Vim server with the name {server} to the foreground. This works like: remote_expr({server}, "foreground()") Except that on Win32 systems the client does the work, to work around the problem that the OS doesn't always allow the server to bring itself to the foreground. Note: This does not restore the window if it was minimized, like foreground() does. This function is not available in the |sandbox|. Can also be used as a |method|: ServerName()->remote_foreground() {only in the Win32, Athena, Motif and GTK GUI versions and the Win32 console version}

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. Returns -1 if something is wrong. See also |clientserver|. This function is not available in the |sandbox|. {only available when compiled with the |+clientserver| feature} Examples: :let repl = "" :echo "PEEK: ".remote_peek(id, "repl").": ".repl Can also be used as a |method|: ServerId()->remote_peek()

Return the oldest available reply from {serverid} and consume it. Unless a {timeout} in seconds is given, it blocks until a reply is available. See also |clientserver|. This function is not available in the |sandbox|. {only available when compiled with the |+clientserver| feature} Example: :echo remote_read(id) Can also be used as a |method|: ServerId()->remote_read()

Become the server {name}. This fails if already running as a server, when |v:servername| is not empty. Can also be used as a |method|: ServerName()->remote_startserver() {only available when compiled with the |+clientserver| feature}

Without {end}: Remove the item at {idx} from |List| {list} and return the item. With {end}: Remove items from {idx} to {end} (inclusive) and return a |List| with these items. When {idx} points to the same item as {end} a list with one item is returned. When {end} points to an item before {idx} this is an error. See |list-index| for possible values of {idx} and {end}. Example: :echo "last item: " . remove(mylist, -1) :call remove(mylist, 0, 9) Use |delete()| to remove a file. Can also be used as a |method|: mylist->remove(idx)

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. NOTE: If {to} exists it is overwritten without warning. This function is not available in the |sandbox|. Can also be used as a |method|: GetOldName()->rename(newname)

Repeat {expr} {count} times and return the concatenated result. Example: :let separator = repeat('-', 80) When {count} is zero or negative the result is empty. When {expr} is a |List| the result is {expr} concatenated {count} times. Example: :let longlist = repeat(['a', 'b'], 3) Results in ['a', 'b', 'a', 'b', 'a', 'b']. Can also be used as a |method|: mylist->repeat(count)

Reverse the order of items in {object} in-place. {object} can be a |List| or a |Blob|. Returns {object}. If you want an object to remain unmodified make a copy first: :let revlist = reverse(copy(mylist)) Can also be used as a |method|: mylist->reverse()

Round off {expr} to the nearest integral value and return it as a |Float|. If {expr} lies halfway between two integral values, then use the larger one (away from zero). {expr} must evaluate to a |Float| or a |Number|. Examples: echo round(0.456) 0.0 echo round(4.5) 5.0 echo round(-4.5) -5.0 Can also be used as a |method|: Compute()->round() {only available when compiled with the |+float| feature}

Evaluate Ruby expression {expr} and return its result converted to Vim data structures. Numbers, floats and strings are returned as they are (strings are copied though). Arrays are represented as Vim |List| type. Hashes are represented as Vim |Dictionary| type. Other objects are represented as strings resulted from their "Object#to_s" method. Can also be used as a |method|: GetRubyExpr()->rubyeval() {only available when compiled with the |+ruby| feature}

Like |screenchar()|, but return the attribute. This is a rather arbitrary number that can only be used to compare to the attribute at other positions. Can also be used as a |method|: GetRow()->screenattr(col)

The result is a Number, which is the character at position [row, col] on the screen. This works for every possible screen position, also status lines, window separators and the command line. The top left position is row one, column one The character excludes composing characters. For double-byte encodings it may only be the first byte. This is mainly to be used for testing. Returns -1 when row or col is out of range. Can also be used as a |method|: GetRow()->screenchar(col)

The result is a Number, which is the current screen column of the cursor. The leftmost column has number 1. This function is mainly used for testing. Note: Always returns the current screen column, thus if used in a command (e.g. ":echo screencol()") it will return the column inside the command line, which is 1 when the command is executed. To get the cursor position in the file use one of the following mappings: nnoremap GG ":echom ".screencol()."\n" nnoremap GG :echom screencol()<CR nnoremap GG echom screencol()<CR

The result is a Dict with the screen position of the text character in window {winid} at buffer line {lnum} and column {col}. {col} is a one-based byte index. The Dict has these members: row screen row col first screen column endcol last screen column curscol cursor screen column If the specified position is not visible, all values are zero. The "endcol" value differs from "col" when the character occupies more than one screen cell. E.g. for a Tab "col" can be 1 and "endcol" can be 8. The "curscol" value is where the cursor would be placed. For a Tab it would be the same as "endcol", while for a double width character it would be the same as "col". Can also be used as a |method|: GetWinid()->screenpos(lnum, col)

The result is a Number, which is the current screen row of the cursor. The top line has number one. This function is mainly used for testing. Alternatively you can use |winline()|. Note: Same restrictions as with |screencol()|.

Send a reply string to {clientid}. The most recent {clientid} that sent a string can be retrieved with expand(""). {only available when compiled with the |+clientserver| feature} Returns zero for success, -1 for failure. Note: This id has to be stored before the next command can be received. I.e. before returning from the received command and before calling any commands that waits for input. See also |clientserver|. Example: :echo server2client(expand(""), "HELLO") Can also be used as a |method|: GetClientId()->server2client(string)

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

Set line {lnum} to {text} in buffer {expr}. To insert lines use |append()|.

Set the current character search information to {dict}, which contains one or more of the following entries: char character which will be used for a subsequent |,| or |;| command; an empty string clears the character search forward direction of character search; 1 for forward, 0 for backward until type of character search; 1 for a |t| or |T| character search, 0 for an |f| or |F| character search This can be useful to save/restore a user's character search from a script: :let prevsearch = getcharsearch() :" Perform a command which clobbers user's search :call setcharsearch(prevsearch) Also see |getcharsearch()|. Can also be used as a |method|: SavedSearch()->setcharsearch()

Set the cursor position in the command line to byte position {pos}. The first position is 1. Use |getcmdpos()| to obtain the current position. Only works while editing the command line, thus you must use |c_CTRL-_e|, |c_CTRL-R_=| or |c_CTRL-R_CTRL-R| with '='. For |c_CTRL-_e| and |c_CTRL-R_CTRL-R| with '=' the position is set after the command line is set to the expression. For |c_CTRL-R_=| it is set after evaluating the expression but before inserting the resulting text. When the number is too big the cursor is put at the end of the line. A number smaller than one has undefined results. Returns FALSE when successful, TRUE when not editing the command line. Can also be used as a |method|: GetPos()->setcmdpos()

Set environment variable {name} to {val}. When {val} is |v:null| the environment variable is deleted. See also |expr-env|. Can also be used as a |method|, the base is passed as the second argument: GetPath()->setenv('PATH')

Set line {lnum} of the current buffer to {text}. To insert lines use |append()|. To set lines in another buffer use |setbufline()|.

Restores a list of matches saved by |getmatches()| for the current window. Returns 0 if successful, otherwise -1. All current matches are cleared before the list is restored. See example for |getmatches()|. If {win} is specified, use the window with this number or window ID instead of the current window. Can also be used as a |method|: GetMatches()->setmatches()

Set the position for {expr}. Possible values: . the cursor 'x mark x {list} must be a |List| with four or five numbers: [bufnum, lnum, col, off] [bufnum, lnum, col, off, curswant] "bufnum" is the buffer number. Zero can be used for the current buffer. When setting an uppercase mark "bufnum" is used for the mark position. For other marks it specifies the buffer to set the mark in. You can use the |bufnr()| function to turn a file name into a buffer number. For setting the cursor and the ' mark "bufnum" is ignored, since these are associated with a window, not a buffer. Does not change the jumplist. "lnum" and "col" are the position in the buffer. The first column is 1. Use a zero "lnum" to delete a mark. If "col" is smaller than 1 then 1 is used. The "off" number is only used when 'virtualedit' is set. Then it is the offset in screen columns from the start of the character. E.g., a position within a or after the last character. The "curswant" number is only used when setting the cursor position. It sets the preferred column for when moving the cursor vertically. When the "curswant" number is missing the preferred column is not set. When it is present and setting a mark position it is not used. Note that for '< and '> changing the line number may result in the marks to be effectively be swapped, so that '< is always before '>. Returns 0 when the position could be set, -1 otherwise. An error message is given if {expr} is invalid. Also see |getpos()| and |getcurpos()|. This does not restore the preferred column for moving vertically; if you set the cursor position with this, |j| and |k| motions will jump to previous columns! Use |cursor()| to also set the preferred column. Also see the "curswant" key in |winrestview()|. Can also be used as a |method|: GetPosition()->setpos('.')

Set tab-local variable {varname} to {val} in tab page {tabnr}. |t:var| Note that autocommands are blocked, side effects may not be triggered, e.g. when setting 'filetype'. Note that the variable name without "t:" must be used. Tabs are numbered starting with one. This function is not available in the |sandbox|. Can also be used as a |method|, the base is passed as the third argument: GetValue()->settabvar(tab, name)

Like |settabwinvar()| for the current tab page. Examples: :call setwinvar(1, "&list", 0) :call setwinvar(2, "myvar", "foobar") Can also be used as a |method|, the base is passed as the third argument: GetValue()->setwinvar(winnr, name)

Returns a String with 64 hex characters, which is the SHA256 checksum of {string}. Can also be used as a |method|: GetText()->sha256() {only available when compiled with the |+cryptv| feature}

Returns the effective value of 'shiftwidth'. This is the 'shiftwidth' value unless it is zero, in which case it is the 'tabstop' value. This function was introduced with patch 7.3.694 in 2012, everybody should have it by now (however it did not allow for the optional {col} argument until 8.1.542). When there is one argument {col} this is used as column number for which to return the 'shiftwidth' value. This matters for the 'vartabstop' feature. If the 'vartabstop' setting is enabled and no {col} argument is given, column 1 will be assumed. Can also be used as a |method|: GetColumn()->shiftwidth()

Return the sine of {expr}, measured in radians, as a |Float|. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo sin(100) -0.506366 :echo sin(-4.01) 0.763301 Can also be used as a |method|: Compute()->sin() {only available when compiled with the |+float| feature}

Return the hyperbolic sine of {expr} as a |Float| in the range [-inf, inf]. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo sinh(0.5) 0.521095 :echo sinh(-0.9) -1.026517 Can also be used as a |method|: Compute()->sinh() {only available when compiled with the |+float| feature}

Return the sound-folded equivalent of {word}. Uses the first language in 'spelllang' for the current window that supports soundfolding. 'spell' must be set. When no sound folding is possible the {word} is returned unmodified. This can be used for making spelling suggestions. Note that the method can be quite slow. Can also be used as a |method|: GetWord()->soundfold()

Return the non-negative square root of Float {expr} as a |Float|. {expr} must evaluate to a |Float| or a |Number|. When {expr} is negative the result is NaN (Not a Number). Examples: :echo sqrt(100) 10.0 :echo sqrt(-4.01) nan "nan" may be different, it depends on system libraries. Can also be used as a |method|: Compute()->sqrt() {only available when compiled with the |+float| feature}

Convert String {expr} to a Float. This mostly works the same as when using a floating point number in an expression, see |floating-point-format|. But it's a bit more permissive. E.g., "1e40" is accepted, while in an expression you need to write "1.0e40". The hexadecimal form "0x123" is also accepted, but not others, like binary or octal. Text after the number is silently ignored. The decimal point is always '.', no matter what the locale is set to. A comma ends the number: "12,345.67" is converted to 12.0. You can strip out thousands separators with |substitute()|: let f = str2float(substitute(text, ',', '', 'g')) Can also be used as a |method|: let f = text->substitute(',', '', 'g')->str2float() {only available when compiled with the |+float| feature}

Return a list containing the number values which represent each character in String {expr}. Examples: str2list(" ") returns [32] str2list("ABC") returns [65, 66, 67] |list2str()| does the opposite. When {utf8} is omitted or zero, the current 'encoding' is used. With {utf8} set to 1, always treat the String as utf-8 characters. With utf-8 composing characters are handled properly: str2list("á") returns [97, 769] Can also be used as a |method|: GetString()->str2list()

stridx() works similar to the C function strstr(). When used with a single character it works similar to strchr(). Can also be used as a |method|: GetHaystack()->stridx(needle)

do it with matchend(): :let span = matchend(line, '[a-zA-Z]') :let span = matchend(line, '[^a-zA-Z]') Except that -1 is returned when there are no matches. 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". When {expr} is a |List| the result is equal to |match()|. Can also be used as a |method|: GetText()->matchend('word')

The result is a Number, which is the number of display cells String {expr} occupies on the screen when it starts at {col} (first column is zero). When {col} is omitted zero is used. Otherwise it is the screen column where to start. This matters for Tab characters. The option settings of the current window are used. This matters for anything that's displayed differently, such as 'tabstop' and 'display'. When {expr} contains characters with East Asian Width Class Ambiguous, this function's return value depends on 'ambiwidth'. Also see |strlen()|, |strwidth()| and |strchars()|. Can also be used as a |method|: GetText()->strdisplaywidth()

Get character {index} from {str}. This uses a character index, not a byte index. Composing characters are considered separate characters here. Also see |strcharpart()| and |strchars()|. Can also be used as a |method|: GetText()->strgetchar(5)

Return {expr} converted to a String. If {expr} is a Number, Float, String, Blob or a composition of them, then the result can be parsed back with |eval()|. {expr} type result ~ String 'string' (single quotes are doubled) Number 123 Float 123.123456 or 1.123456e8 Funcref function('name') Blob 0z00112233.44556677.8899 List [item, item] Dictionary {key: value, key: value} When a |List| or |Dictionary| has a recursive reference it is replaced by "[...]" or "{...}". Using eval() on the result will then fail. Can also be used as a |method|: mylist->string() Also see |strtrans()|.

The result is a Number, which is the length of the String {expr} in bytes. If the argument is a Number it is first converted to a String. For other types an error is given. If you want to count the number of multibyte characters use |strchars()|. Also see |len()|, |strdisplaywidth()| and |strwidth()|. Can also be used as a |method|: GetString()->strlen()

When used with a single character it works similar to the C function strrchr(). Can also be used as a |method|: GetHaystack()->strridx(needle)

do it with matchend(): :let span = matchend(line, '[a-zA-Z]') :let span = matchend(line, '[^a-zA-Z]') Except that -1 is returned when there are no matches. 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". When {expr} is a |List| the result is equal to |match()|. Can also be used as a |method|: GetText()->matchend('word')

stridx() works similar to the C function strstr(). When used with a single character it works similar to strchr(). Can also be used as a |method|: GetHaystack()->stridx(needle)

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. Can also be used as a |method|: GetString()->strtrans()

The result is a Number, which is the number of display cells String {expr} occupies. A Tab character is counted as one cell, alternatively use |strdisplaywidth()|. When {expr} contains characters with East Asian Width Class Ambiguous, this function's return value depends on 'ambiwidth'. Also see |strlen()|, |strdisplaywidth()| and |strchars()|. Can also be used as a |method|: GetString()->strwidth()

The result is a dictionary, which holds information about the swapfile {fname}. The available fields are: version Vim version user user name host host name fname original file name pid PID of the Vim process that created the swap file mtime last modification time in seconds inode Optional: INODE number of the file dirty 1 if file was modified, 0 if not Note that "user" and "host" are truncated to at most 39 bytes. In case of failure an "error" item is added with the reason: Cannot open file: file not found or in accessible Cannot read file: cannot read first block Not a swap file: does not contain correct block ID Magic number mismatch: Info in first block is invalid Can also be used as a |method|: GetFilename()->swapinfo()

The result is the swap file path of the buffer {expr}. For the use of {expr}, see |bufname()| above. If buffer {expr} is the current buffer, the result is equal to |:swapname| (unless there is no swap file). If buffer {expr} has no swap file, returns an empty string. Can also be used as a |method|: GetBufname()->swapname()

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. Can also be used as a |method|: :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")

Same as |system()|, but returns a |List| with lines (parts of output separated by NL) with NULs transformed into NLs. Output is the same as |readfile()| will output with {binary} argument set to "b", except that there is no extra empty item when the result ends in a NL. Note that on MS-Windows you may get trailing CR characters. To see the difference between "echo hello" and "echo -n hello" use |system()| and |split()|: echo system('echo hello')->split('\n', 1) Returns an empty string on error. Can also be used as a |method|: :echo GetCmd()->systemlist()

The result is a |List|, where each item is the number of the buffer associated with each window in the current tab page. {arg} specifies the number of the tab page to be used. When omitted the current tab page is used. When {arg} is invalid the number zero is returned. To get a list of all buffers in all tabs use this: let buflist = [] for i in range(tabpagenr('$')) call extend(buflist, tabpagebuflist(i + 1)) endfor Note that a buffer may appear in more than one window. Can also be used as a |method|: GetTabpage()->tabpagebuflist()

The result is a Number, which is the number of the current tab page. The first tab page has number 1. The optional argument {arg} supports the following values: $ the number of the last tab page (the tab page count). # the number of the last accessed tab page (where |g| goes to). if there is no previous tab page 0 is returned. The number can be used with the |:tab| command.

Like |winnr()| but for tab page {tabarg}. {tabarg} specifies the number of tab page to be used. {arg} is used like with |winnr()|:

• When omitted the current window number is returned. This is the window which will be used when going to this tab page.
• When "$" the number of windows is returned.
• When "#" the previous window nr is returned. Useful examples: tabpagewinnr(1) " current window of tab page 1 tabpagewinnr(4, '$') " number of windows in tab page 4 When {tabarg} is invalid zero is returned. Can also be used as a |method|: GetTabpage()->tabpagewinnr()

Returns a |List| with the file names used to search for tags for the current buffer. This is the 'tags' option expanded.

Return the tangent of {expr}, measured in radians, as a |Float| in the range [-inf, inf]. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo tan(10) 0.648361 :echo tan(-4.01) -1.181502 Can also be used as a |method|: Compute()->tan() {only available when compiled with the |+float| feature}

Return the hyperbolic tangent of {expr} as a |Float| in the range [-1, 1]. {expr} must evaluate to a |Float| or a |Number|. Examples: :echo tanh(0.5) 0.462117 :echo tanh(-1) -0.761594 Can also be used as a |method|: Compute()->tanh() {only available when compiled with the |+float| feature}

The result is a String, which is the name of a file that doesn't exist. It can be used for a temporary file. The name is different for at least 26 consecutive calls. Example: :let tmpfile = tempname() :exe "redir > " . tmpfile For Unix, the file will be in a private directory |tempfile|. For MS-Windows forward slashes are used when the 'shellslash' option is set, or when 'shellcmdflag' starts with '-' and 'shell' does not contain powershell or pwsh.

Return a list with information about timers. When {id} is given only information about this timer is returned. When timer {id} does not exist an empty list is returned. When {id} is omitted information about all timers is returned. For each timer the information is stored in a |Dictionary| with these items: "id" the timer ID "time" time the timer was started with "remaining" time until the timer fires "repeat" number of times the timer will still fire; -1 means forever "callback" the callback "paused" 1 if the timer is paused, 0 otherwise Can also be used as a |method|: GetTimer()->timer_info() {only available when compiled with the |+timers| feature}

Pause or unpause a timer. A paused timer does not invoke its callback when its time expires. Unpausing a timer may cause the callback to be invoked almost immediately if enough time has passed. Pausing a timer is useful to avoid the callback to be called for a short time. If {paused} evaluates to a non-zero Number or a non-empty String, then the timer is paused, otherwise it is unpaused. See |non-zero-arg|. Can also be used as a |method|: GetTimer()->timer_pause(1) {only available when compiled with the |+timers| feature}

Stop a timer. The timer callback will no longer be invoked. {timer} is an ID returned by timer_start(), thus it must be a Number. If {timer} does not exist there is no error. Can also be used as a |method|: GetTimer()->timer_stop() {only available when compiled with the |+timers| feature}

Stop all timers. The timer callbacks will no longer be invoked. Useful if a timer is misbehaving. If there are no timers there is no error. {only available when compiled with the |+timers| feature}

The result is a copy of the String given, with all uppercase characters turned into lowercase (just like applying |gu| to the string). Can also be used as a |method|: GetText()->tolower()

The result is a copy of the String given, with all lowercase characters turned into uppercase (just like applying |gU| to the string). Can also be used as a |method|: GetText()->toupper()

The result is a copy of the {src} string with all characters which appear in {fromstr} replaced by the character in that position in the {tostr} string. Thus the first character in {fromstr} is translated into the first character in {tostr} and so on. Exactly like the unix "tr" command. This code also deals with multibyte characters properly. Examples: echo tr("hello there", "ht", "HT") returns "Hello THere" echo tr("", "<>", "{}") returns "{blob}" Can also be used as a |method|: GetText()->tr(from, to)

Return the largest integral value with magnitude less than or equal to {expr} as a |Float| (truncate towards zero). {expr} must evaluate to a |Float| or a |Number|. Examples: echo trunc(1.456) 1.0 echo trunc(-5.456) -5.0 echo trunc(4.0) 4.0 Can also be used as a |method|: Compute()->trunc() {only available when compiled with the |+float| feature}

Return the name of the undo file that would be used for a file with name {name} when writing. This uses the 'undodir' option, finding directories that exist. It does not check if the undo file exists. {name} is always expanded to the full path, since that is what is used internally. If {name} is empty undofile() returns an empty string, since a buffer without a file name will not write an undo file. Useful in combination with |:wundo| and |:rundo|. When compiled without the |+persistent_undo| option this always returns an empty string. Can also be used as a |method|: GetFilename()->undofile()

Remove second and succeeding copies of repeated adjacent {list} items in-place. Returns {list}. If you want a list to remain unmodified make a copy first: :let newlist = uniq(copy(mylist)) The default compare function uses the string representation of each item. For the use of {func} and {dict} see |sort()|. Can also be used as a |method|: mylist->uniq()

Return a |List| with all the values of {dict}. The |List| is in arbitrary order. Also see |items()| and |keys()|. Can also be used as a |method|: mydict->values()

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 at the position, the returned Number will be the column at the end of the . For example, for a in column 1, with 'ts' set to 8, it returns 8. |conceal| is ignored. For the byte position use |col()|. For the use of {expr} see |col()|. When 'virtualedit' is used {expr} can be [lnum, col, off], where "off" is the offset in screen columns from the start of the character. E.g., a position within a or after the last character. When "off" is omitted zero is used. 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) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from |'<| in that it's updated right away. Note that only marks in the current file can be used. Examples: virtcol(".") with text "foo^Lbar", with cursor on the "^{L", returns 5 virtcol("$") with text "foo}Lbar", returns 9 virtcol("'t") with text " there", with 't at 'h', returns 6 The first column is 1. 0 is returned for an error. A more advanced example that echoes the maximum length of all lines: echo max(map(range(1, line('$')), "virtcol([v:val, '$'])")) Can also be used as a |method|: GetPos()->virtcol()

The result is a String, which describes the last Visual mode used in the current buffer. Initially it returns an empty string, but once Visual mode has been used, it returns "v", "V", or "" (a single CTRL-V character) for character-wise, line-wise, or block-wise Visual mode respectively. Example: :exe "normal " . visualmode() This enters the same Visual mode as before. It is also useful in scripts if you wish to act differently depending on the Visual mode that was used. If Visual mode is active, use |mode()| to get the Visual mode (e.g., in a |:vmap|). If {expr} is supplied and it evaluates to a non-zero Number or a non-empty String, then the Visual mode will be cleared and the old value is returned. See |non-zero-arg|.

Returns |TRUE| when the wildmenu is active and |FALSE| otherwise. See 'wildmenu' and 'wildmode'. This can be used in mappings to handle the 'wildcharm' option gracefully. (Makes only sense with |mapmode-c| mappings). For example to make work like in wildmode, use: :cnoremap wildmenumode() ? "<Down><Tab>" : "<c-j>" (Note, this needs the 'wildcharm' option set appropriately).

Returns a |List| with |window-ID|s for windows that contain buffer {bufnr}. When there is none the list is empty. Can also be used as a |method|: GetBufnr()->win_findbuf()

Get the |window-ID| for the specified window. When {win} is missing use the current window. With {win} this is the window number. The top window has number 1. Without {tab} use the current tab, otherwise the tab with number {tab}. The first tab has number one. Return zero if the window cannot be found. Can also be used as a |method|: GetWinnr()->win_getid()

Return the type of the window: "autocmd" autocommand window. Temporary window used to execute autocommands. "popup" popup window |popup| "preview" preview window |preview-window| "command" command-line window |cmdwin| (empty) normal window "unknown" window {nr} not found When {nr} is omitted return the type of the current window. When {nr} is given return the type of this window by number or |window-ID|. Also see the 'buftype' option. When running a terminal in a popup window then 'buftype' is "terminal" and win_gettype() returns "popup".

Go to window with ID {expr}. This may also change the current tabpage. Return TRUE if successful, FALSE if the window cannot be found. Can also be used as a |method|: GetWinid()->win_gotoid()

Return a list with the tab number and window number of window with ID {expr}: [tabnr, winnr]. Return [0, 0] if the window cannot be found. Can also be used as a |method|: GetWinid()->win_id2tabwin()

Return the window number of window with ID {expr}. Return 0 if the window cannot be found in the current tabpage. Can also be used as a |method|: GetWinid()->win_id2win()

Return the screen position of window {nr} as a list with two numbers: [row, col]. The first window always has position [1, 1], unless there is a tabline, then it is [2, 1]. {nr} can be the window number or the |window-ID|. Use zero for the current window. Return [0, 0] if the window cannot be found in the current tabpage. Can also be used as a |method|: GetWinid()->win_screenpos()

The result is a Number, which is the number of the buffer associated with window {nr}. {nr} can be the window number or the |window-ID|. 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)) Can also be used as a |method|: FindWindow()->winbufnr()->bufname()

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.

The result is a String. For MS-Windows it indicates the OS version. E.g, Windows 10 is "10.0", Windows 8 is "6.2", Windows XP is "5.1". For non-MS-Windows systems the result is an empty string.

The result is a Number, which is the height of window {nr}. {nr} can be the window number or the |window-ID|. 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. This excludes any window toolbar line. Examples: :echo "The current window has " . winheight(0) . " lines." Can also be used as a |method|: GetWinid()->winheight()

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. If the cursor was moved the view on the file will be updated first, this may cause a scroll.

Returns a sequence of |:resize| commands that should restore the current window sizes. Only works properly when no windows are opened or closed and the current window and tab page is unchanged. Example: :let cmd = winrestcmd() :call MessWithWindowSizes() :exe cmd

Uses the |Dictionary| returned by |winsaveview()| to restore the view of the current window. Note: The {dict} does not have to contain all values, that are returned by |winsaveview()|. If values are missing, those settings won't be restored. So you can use: :call winrestview({'curswant': 4}) This will only set the curswant value (the column the cursor wants to move on vertical movements) of the cursor to column 5 (yes, that is 5), while all other settings will remain the same. This is useful, if you set the cursor position manually. If you have changed the values the result is unpredictable. If the window size changed the result won't be the same. Can also be used as a |method|: GetView()->winrestview()

Returns a |Dictionary| that contains information to restore the view of the current window. Use |winrestview()| to restore the view. This is useful if you have a mapping that jumps around in the buffer and you want to go back to the original view. This does not save fold information. Use the 'foldenable' option to temporarily switch off folding, so that folds are not opened when moving around. This may have side effects. The return value includes: lnum cursor line number col cursor column (Note: the first column zero, as opposed to what getpos() returns) coladd cursor column offset for 'virtualedit' curswant column for vertical movement topline first line in the window topfill filler lines, only in diff mode leftcol first column displayed; only used when 'wrap' is off skipcol columns skipped Note that no option values are saved.

The result is a Number, which is the width of window {nr}. {nr} can be the window number or the |window-ID|. 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 : 50 wincmd | :endif For getting the terminal or screen size, see the 'columns' option. Can also be used as a |method|: GetWinid()->winwidth()

The result is a dictionary of byte/chars/word statistics for the current buffer. This is the same info as provided by |g_CTRL-G| The return value includes: bytes Number of bytes in the buffer chars Number of chars in the buffer words Number of words in the buffer cursor_bytes Number of bytes before cursor position (not in Visual mode) cursor_chars Number of chars before cursor position (not in Visual mode) cursor_words Number of words before cursor position (not in Visual mode) visual_bytes Number of bytes visually selected (only in Visual mode) visual_chars Number of chars visually selected (only in Visual mode) visual_words Number of words visually selected (only in Visual mode)

Bitwise XOR on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Example: :let bits = xor(bits, 0x80) Can also be used as a |method|: :let bits = bits->xor(0x80)

Builtin completion

Type of getpos() or setpos() result.

Type of screenpos() result.