Implements a mutex lock for Promise. Not thread-safe.

{only available when compiled with the |+rightleft| feature} The ASCII code for the first letter of the Hebrew alphabet. The routine that maps the keyboard in Hebrew mode, both in Insert mode (when hkmap is set) and on the command-line (when hitting CTRL-_) outputs the Hebrew characters in the range [aleph..aleph+26]. aleph=128 applies to PC code, and aleph=224 applies to ISO 8859-8. See |rileft.txt|.

{only available when compiled with the |+rightleft| feature} Allow CTRL-_ in Insert and Command-line mode. This is default off, to avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get into reverse Insert mode, and don't know how to get out. See 'revins'. NOTE: This option is reset when 'compatible' is set.

Only effective when 'encoding' is "utf-8" or another Unicode encoding. Tells Vim what to do with characters with East Asian Width Class Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek letters, Cyrillic letters).

{only available when compiled with the |+arabic| feature} This option can be set to start editing Arabic text. Setting this option will:

• Set the 'rightleft' option, unless 'termbidi' is set.
• Set the 'arabicshape' option, unless 'termbidi' is set.
• Set the 'keymap' option to "arabic"; in Insert mode CTRL-^ toggles between typing English and Arabic key mapping.
• Set the 'delcombine' option Note that 'encoding' must be "utf-8" for working with Arabic text.

{only available when compiled with the |+arabic| feature} When on and 'termbidi' is off, the required visual character corrections that need to take place for displaying the Arabic language take effect. Shaping, in essence, gets enabled; the term is a broad one which encompasses: a) the changing/morphing of characters based on their location within a word (initial, medial, final and stand-alone). b) the enabling of the ability to compose characters c) the enabling of the required combining of some characters When disabled the display shows each character's true stand-alone form. Arabic is a complex language which requires other settings, for further details see |arabic.txt|. NOTE: This option is set when 'compatible' is set.

{only available when compiled with it, use exists("+autochdir") to check} When on, Vim will change the current working directory whenever you open a file, switch buffers, delete a buffer or open/close a window. It will change to the directory containing the file which was opened or selected. Note: When this option is on some plugins may not work.

Copy indent from current line when starting a new line (typing in Insert mode or when using the "o" or "O" command). If you do not type anything on the new line except or CTRL-D and then type , CTRL-O or , the indent is deleted again. Moving the cursor to another line has the same effect, unless the 'I' flag is included in 'cpoptions'. When autoindent is on, formatting (with the "gq" command or when you reach 'textwidth' in Insert mode) uses the indentation of the first line. When 'smartindent' or 'cindent' is on the indent is changed in a different way. The 'autoindent' option is reset when the 'paste' option is set and restored when 'paste' is reset.

When a file has been detected to have been changed outside of Vim and it has not been changed inside of Vim, automatically read it again. When the file has been deleted this is not done, so you have the text from before it was deleted. When it appears again then it is read. |timestamp| If this option has a local value, use this command to switch back to using the global value: > :set autoread< <

Write the contents of the file, if it has been modified, on each :next, :rewind, :last, :first, :previous, :stop, :suspend, :tag, :!, :make, CTRL-] and CTRL-^ command; and when a :buffer, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one to another file. Note that for some commands the 'autowrite' option is not used, see 'autowriteall' for that. Some buffers will not be written, specifically when 'buftype' is "nowrite", "nofile", "terminal" or "prompt".

Like 'autowrite', but also used for commands ":edit", ":enew", ":quit", ":qall", ":exit", ":xit", ":recover" and closing the Vim window. Setting this option also implies that Vim behaves like 'autowrite' has been set.

When set to "dark", Vim will try to use colors that look good on a dark background. When set to "light", Vim will try to use colors that look good on a light background. Any other value is illegal. Vim tries to set the default value according to the terminal used. This will not always be correct. Setting this option does not change the background color, it tells Vim what the background color looks like. For changing the background color, see |:hi-normal|.

Influences the working of , , CTRL-W and CTRL-U in Insert mode. This is a list of items, separated by commas. Each item allows a way to backspace over something: value effect ~ indent allow backspacing over autoindent eol allow backspacing over line breaks (join lines) start allow backspacing over the start of insert; CTRL-W and CTRL-U stop once at the start of insert. nostop like start, except CTRL-W and CTRL-U do not stop at the start of insert.

Make a backup before overwriting a file. Leave it around after the file has been successfully written. If you do not want to keep the backup file, but you do want a backup while the file is being written, reset this option and set the 'writebackup' option (this is the default). If you do not want a backup file at all reset both options (use this if your file system is almost full). See the |backup-table| for more explanations. When the 'backupskip' pattern matches, a backup is not made anyway. When 'patchmode' is set, the backup may be renamed to become the oldest version of a file. NOTE: This option is reset when 'compatible' is set.

When writing a file and a backup is made, this option tells how it's done. This is a comma separated list of words.

List of directories for the backup file, separated with commas.

• The backup file will be created in the first directory in the list where this is possible. The directory must exist, Vim will not create it for you.
• Empty means that no backup file will be created ('patchmode' is impossible!). Writing may fail because of this.
• A directory "." means to put the backup file in the same directory as the edited file.
• A directory starting with "./" (or "." for MS-Windows) means to put the backup file relative to where the edited file is. The leading "." is replaced with the path name of the edited file. ("." inside a directory name has no special meaning).
• Spaces after the comma are ignored, other spaces are considered part of the directory name. To have a space at the start of a directory name, precede it with a backslash.
• To include a comma in a directory name precede it with a backslash.
• A directory name may end in an '/'.
• For Unix and Win32, if a directory ends in two path separators "//", the backup file name will be built from the complete path to the file with all path separators changed to percent '%' signs. This will ensure file name uniqueness in the backup directory. On Win32, it is also possible to end with "\". However, When a separating comma is following, you must use "//", since "\" will include the comma in the file name. Therefore it is recommended to use '//', instead of '\'.
• Environment variables are expanded |:set_env|.
• Careful with '' characters, type one before a space, type two to get one in the option (see |option-backslash|), for example: > :set bdir=c:\tmp,\ dir\,with\,commas,\\ dir\ with\ spaces < - For backwards compatibility with Vim version 3.0 a '>' at the start of the option is removed. See also 'backup' and 'writebackup' options. If you want to hide your backup files on Unix, consider this value: > :set backupdir=./.backup,~/.backup,.,/tmp < You must create a ".backup" directory in each directory and in your home directory for this to work properly. The use of |:set+=| and |:set-=| is preferred when adding or removing directories from the list. This avoids problems when a future version uses another default. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

String which is appended to a file name to make the name of the backup file. The default is quite unusual, because this avoids accidentally overwriting existing files with a backup file. You might prefer using ".bak", but make sure that you don't have files with ".bak" that you want to keep. Only normal file name characters can be used, "/*?[|<>" are illegal.

{not available when compiled without the |+wildignore| feature} A list of file patterns. When one of the patterns matches with the name of the file which is written, no backup file is created. Both the specified file name and the full path name of the file are used. The pattern is used like with |:autocmd|, see |autocmd-patterns|. Watch out for special characters, see |option-backslash|. When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the default value. "/tmp/*" is only used for Unix.

{only available when compiled with the |+balloon_eval| feature} Delay in milliseconds before a balloon may pop up. See |balloon-eval|.

{only available when compiled with the |+balloon_eval| feature} Switch on the |balloon-eval| functionality for the GUI.

{only available when compiled with the |+balloon_eval| feature} Expression for text to show in evaluation balloon. It is only used when 'ballooneval' or 'balloonevalterm' is on. These variables can be used:

Specifies for which events the bell will not be rung. It is a comma separated list of items. For each item that is present, the bell will be silenced. This is most useful to specify specific events in insert mode to be silenced.

This option should be set before editing a binary file. You can also use the |-b| Vim argument. When this option is switched on a few options will be changed (also when it already was on): 'textwidth' will be set to 0 'wrapmargin' will be set to 0 'modeline' will be off 'expandtab' will be off Also, 'fileformat' and 'fileformats' options will not be used, the file is read and written like 'fileformat' was "unix" (a single separates lines). The 'fileencoding' and 'fileencodings' options will not be used, the file is read without conversion. NOTE: When you start editing a(nother) file while the 'bin' option is on, settings from autocommands may change the settings again (e.g., 'textwidth'), causing trouble when editing. You might want to set 'bin' again when the file has been loaded. The previous values of these options are remembered and restored when 'bin' is switched from on to off. Each buffer has its own set of saved option values. To edit a file with 'binary' set you can use the |++bin| argument. This avoids you have to do ":set bin", which would have effect for all files you edit. When writing a file the for the last line is only written if there was one in the original file (normally Vim appends an to the last line if there is none; this would make the file longer). See the 'endofline' option.

{not available when compiled without the |+linebreak| feature} This option lets you choose which characters might cause a line break if 'linebreak' is on. Only works for ASCII and also for 8-bit characters when 'encoding' is an 8-bit encoding.

{not available when compiled without the |+linebreak| feature} Every wrapped line will continue visually indented (same amount of space as the beginning of that line), thus preserving horizontal blocks of text. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+linebreak| feature} Settings for 'breakindent'. It can consist of the following optional items and must be separated by a comma: min:{n} Minimum text width that will be kept after applying 'breakindent', even if the resulting text should normally be narrower. This prevents text indented almost to the right window border occupying lot of vertical space when broken. shift:{n} After applying 'breakindent', the wrapped line's beginning will be shifted by the given number of characters. It permits dynamic French paragraph indentation (negative) or emphasizing the line continuation (positive). sbr Display the 'showbreak' value before applying the additional indent. list:{n} Adds an additional indent for lines that match a numbered or bulleted list (using the 'formatlistpat' setting). list:-1 Uses the length of a match with 'formatlistpat' for indentation. The default value for min is 20, shift and list is 0.

{only for Motif, Athena, GTK, Mac and Win32 GUI} Which directory to use for the file browser: last Use same directory as with last file browser, where a file was opened or saved. buffer Use the directory of the related buffer. current Use the current directory. {path} Use the specified directory

This option specifies what happens when a buffer is no longer displayed in a window: follow the global 'hidden' option hide hide the buffer (don't unload it), also when 'hidden' is not set unload unload the buffer, also when 'hidden' is set or using |:hide| delete delete the buffer from the buffer list, also when 'hidden' is set or using |:hide|, like using |:bdelete| wipe wipe out the buffer from the buffer list, also when 'hidden' is set or using |:hide|, like using |:bwipeout|

When this option is set, the buffer shows up in the buffer list. If it is reset it is not used for ":bnext", "ls", the Buffers menu, etc. This option is reset by Vim for buffers that are only used to remember a file name or marks. Vim sets it when starting to edit a buffer. But not when moving to a buffer with ":buffer".

The value of this option specifies the type of a buffer: normal buffer nofile buffer which is not related to a file and will not be written nowrite buffer which will not be written acwrite buffer which will always be written with BufWriteCmd autocommands. quickfix quickfix buffer, contains list of errors |:cwindow| or list of locations |:lwindow| help help buffer (you are not supposed to set this manually) terminal buffer for a |terminal| (you are not supposed to set this manually) prompt buffer where only the last line can be edited, meant to be used by a plugin, see |prompt-buffer| {only when compiled with the |+channel| feature} popup buffer used in a popup window, see |popup|. {only when compiled with the |+textprop| feature}

Specifies details about changing the case of letters. It may contain these words, separated by a comma: internal Use internal case mapping functions, the current locale does not change the case mapping. This only matters when 'encoding' is a Unicode encoding, "latin1" or "iso-8859-15". When "internal" is omitted, the towupper() and towlower() system library functions are used when available. keepascii For the ASCII characters (0x00 to 0x7f) use the US case mapping, the current locale is not effective. This probably only matters for Turkish.

{not available when compiled without the |+file_in_path| feature} This is a list of directories which will be searched when using the |:cd|, |:tcd| and |:lcd| commands, provided that the directory being searched for has a relative path, not an absolute part starting with "/", "./" or "../", the 'cdpath' option is not used then. The 'cdpath' option's value has the same form and semantics as |'path'|. Also see |file-searching|. The default value is taken from $CDPATH, with a "," prepended to look in the current directory first. If the default value taken from $CDPATH is not what you want, include a modified version of the following command in your vimrc file to override it: > :let &cdpath = ',' . substitute(substitute($CDPATH, '[, ]', '\\0', 'g'), ':', ',', 'g') < This option cannot be set from a |modeline| or in the |sandbox|, for security reasons. (parts of 'cdpath' can be passed to the shell to expand file names).

{only available when compiled with the |+eval| feature} An expression that is used for character encoding conversion. It is evaluated when a file that is to be read or has been written has a different encoding from what is desired. 'charconvert' is not used when the internal iconv() function is supported and is able to do the conversion. Using iconv() is preferred, because it is much faster. 'charconvert' is not used when reading stdin |--|, because there is no file to convert from. You will have to save the text in a file first. The expression must return zero or an empty string for success, non-zero for failure. The possible encoding names encountered are in 'encoding'. Additionally, names given in 'fileencodings' and 'fileencoding' are used. Conversion between "latin1", "unicode", "ucs-2", "ucs-4" and "utf-8" is done internally by Vim, 'charconvert' is not used for this. 'charconvert' is also used to convert the viminfo file, if the 'c' flag is present in 'viminfo'. Also used for Unicode conversion. Example: > set charconvert=CharConvert() fun CharConvert() system("recode " \ . v:charconvert_from . ".." . v:charconvert_to \ . " <" . v:fname_in . " >" v:fname_out) return v:shell_error endfun < The related Vim variables are: v:charconvert_from name of the current encoding v:charconvert_to name of the desired encoding v:fname_in name of the input file v:fname_out name of the output file Note that v:fname_in and v:fname_out will never be the same. Note that v:charconvert_from and v:charconvert_to may be different from 'encoding'. Vim internally uses UTF-8 instead of UCS-2 or UCS-4. Encryption is not done by Vim when using 'charconvert'. If you want to encrypt the file after conversion, 'charconvert' should take care of this. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+cindent| feature} Enables automatic C program indenting. See 'cinkeys' to set the keys that trigger reindenting in insert mode and 'cinoptions' to set your preferred indent style. If 'indentexpr' is not empty, it overrules 'cindent'. If 'lisp' is not on and both 'indentexpr' and 'equalprg' are empty, the "=" operator indents using this algorithm rather than calling an external program. See |C-indenting|. When you don't like the way 'cindent' works, try the 'smartindent' option or 'indentexpr'. This option is not used when 'paste' is set. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+cindent| feature} A list of keys that, when typed in Insert mode, cause reindenting of the current line. Only used if 'cindent' is on and 'indentexpr' is empty. For the format of this option see |cinkeys-format|. See |C-indenting|.

{not available when compiled without the |+cindent| feature} The 'cinoptions' affect the way 'cindent' reindents lines in a C program. See |cinoptions-values| for the values of this option, and |C-indenting| for info on C indenting in general.

{not available when compiled without both the |+cindent| and the |+smartindent| features} These keywords start an extra indent in the next line when 'smartindent' or 'cindent' is set. For 'cindent' this is only done at an appropriate place (inside {}). Note that 'ignorecase' isn't used for 'cinwords'. If case doesn't matter, include the keyword both the uppercase and lowercase: "if,If,IF".

{only in GUI versions or when the |+xterm_clipboard| feature is included} This option is a list of comma separated names. Note: if one of the items is "exclude:", then you can't add an item after that. Therefore do append an item with += but use ^{= to prepend, e.g.: > set clipboard}=unnamed < These names are recognized:

Number of screen lines to use for the command-line. Helps avoiding |hit-enter| prompts. The value of this option is stored with the tab page, so that each tab page can have a different value.

Number of screen lines to use for the command-line window. |cmdwin|

{not available when compiled without the |+syntax| feature} 'colorcolumn' is a comma separated list of screen columns that are highlighted with ColorColumn |hl-ColorColumn|. Useful to align text. Will make screen redrawing slower. The screen column can be an absolute number, or a number preceded with '+' or '-', which is added to or subtracted from 'textwidth'. >

Number of columns of the screen. Normally this is set by the terminal initialization and does not have to be set by hand. Also see |posix-screen-size|. When Vim is running in the GUI or in a resizable window, setting this option will cause the window size to be changed. When you only want to use the size for the GUI, put the command in your |gvimrc| file. When you set this option and Vim is unable to change the physical number of columns of the display, the display may be messed up. For the GUI it is always possible and Vim limits the number of columns to what fits on the screen. You can use this command to get the widest window possible: > :set columns=9999 < Minimum value is 12, maximum value is 10000.

A comma separated list of strings that can start a comment line. See |format-comments|. See |option-backslash| about using backslashes to insert a space.

{not available when compiled without the |+folding| feature} A template for a comment. The "%s" in the value is replaced with the comment text. Currently only used to add markers for folding, see |fold-marker|.

This option specifies how keyword completion |ins-completion| works when CTRL-P or CTRL-N are used. It is also used for whole-line completion |i_CTRL-X_CTRL-L|. It indicates the type of completion and the places to scan. It is a comma separated list of flags: . scan the current buffer ('wrapscan' is ignored) w scan buffers from other windows b scan other loaded buffers that are in the buffer list u scan the unloaded buffers that are in the buffer list U scan the buffers that are not in the buffer list k scan the files given with the 'dictionary' option kspell use the currently active spell checking |spell| k{dict} scan the file {dict}. Several "k" flags can be given, patterns are valid too. For example: > :set cpt=k/usr/dict/*,k~/spanish < s scan the files given with the 'thesaurus' option s{tsr} scan the file {tsr}. Several "s" flags can be given, patterns are valid too. i scan current and included files d scan current and included files for defined name or macro |i_CTRL-X_CTRL-D| ] tag completion t same as "]"

{not available when compiled without the |+eval| feature} This option specifies a function to be used for Insert mode completion with CTRL-X CTRL-U. |i_CTRL-X_CTRL-U| See |complete-functions| for an explanation of how the function is invoked and what it should return. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

A comma separated list of options for Insert mode completion |ins-completion|. The supported values are:

{only for MS-Windows} When this option is set it overrules 'shellslash' for completion:

• When this option is set to "slash", a forward slash is used for path completion in insert mode. This is useful when editing HTML tag, or Makefile with 'noshellslash' on MS-Windows.
• When this option is set to "backslash", backslash is used. This is useful when editing a batch file with 'shellslash' set on MS-Windows.
• When this option is empty, same character is used as for 'shellslash'. For Insert mode completion the buffer-local value is used. For command line completion the global value is used.

{not available when compiled without the |+conceal| feature} Sets the modes in which text in the cursor line can also be concealed. When the current mode is listed then concealing happens just like in other lines. n Normal mode v Visual mode i Insert mode c Command line editing, for 'incsearch'

{not available when compiled without the |+conceal| feature} Determine how text with the "conceal" syntax attribute |:syn-conceal| is shown:

When 'confirm' is on, certain operations that would normally fail because of unsaved changes to a buffer, e.g. ":q" and ":e", instead raise a |dialog| asking if you wish to save the current file(s). You can still use a ! to unconditionally |abandon| a buffer. If 'confirm' is off you can still activate confirmation for one command only (this is most useful in mappings) with the |:confirm| command. Also see the |confirm()| function and the 'v' flag in 'guioptions'.

Copy the structure of the existing lines indent when autoindenting a new line. Normally the new indent is reconstructed by a series of tabs followed by spaces as required (unless |'expandtab'| is enabled, in which case only spaces are used). Enabling this option makes the new line copy whatever characters were used for indenting on the existing line. 'expandtab' has no effect on these characters, a Tab remains a Tab. If the new indent is greater than on the existing line, the remaining space is filled in the normal manner. NOTE: This option is reset when 'compatible' is set. Also see 'preserveindent'.

A sequence of single character flags. When a character is present this indicates Vi-compatible behavior. This is used for things where not being Vi-compatible is mostly or sometimes preferred. 'cpoptions' stands for "compatible-options". Commas can be added for readability. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" |add-option-flags|. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset. NOTE: This option is set to the POSIX default value at startup when the Vi default value would be used and the $VIM_POSIX environment variable exists |posix|. This means Vim tries to behave like the POSIX specification.

{not available when compiled without the |+cscope| feature} Determines how many components of the path to show in a list of tags. See |cscopepathcomp|. NOTE: This option is set to 0 when 'compatible' is set.

{not available when compiled without the |+cscope| feature} Specifies the command to execute cscope. See |cscopeprg|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+cscope| or |+quickfix| features} Specifies whether to use quickfix window to show cscope results. See |cscopequickfix|.

{not available when compiled without the |+cscope| feature} In the absence of a prefix (-P) for cscope. setting this option enables to use the basename of cscope.out path as the prefix. See |cscoperelative|. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+cscope| feature} Use cscope for tag commands. See |cscope-options|. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+cscope| feature} Determines the order in which ":cstag" performs a search. See |cscopetagorder|. NOTE: This option is set to 0 when 'compatible' is set.

When this option is set, as the cursor in the current window moves other cursorbound windows (windows that also have this option set) move their cursors to the corresponding line and column. This option is useful for viewing the differences between two versions of a file (see 'diff'); in diff mode, inserted and deleted lines (though not characters within a line) are taken into account.

{not available when compiled without the |+syntax| feature} Highlight the screen column of the cursor with CursorColumn |hl-CursorColumn|. Useful to align text. Will make screen redrawing slower. If you only want the highlighting in the current window you can use these autocommands: > au WinLeave * set nocursorline nocursorcolumn au WinEnter * set cursorline cursorcolumn <

{not available when compiled without the |+syntax| feature} Highlight the text line of the cursor with CursorLine |hl-CursorLine|. Useful to easily spot the cursor. Will make screen redrawing slower. When Visual mode is active the highlighting isn't used to make it easier to see the selected text.

{not available when compiled without the |+syntax| feature} Comma separated list of settings for how 'cursorline' is displayed. Valid values: "line" Highlight the text line of the cursor with CursorLine |hl-CursorLine|. "screenline" Highlight only the screen line of the cursor with CursorLine |hl-CursorLine|. "number" Highlight the line number of the cursor with CursorLineNr |hl-CursorLineNr|.

Pattern to be used to find a macro definition. It is a search pattern, just like for the "/" command. This option is used for the commands like "[i" and "[d" |include-search|. The 'isident' option is used to recognize the defined name after the match: {match with 'define'}{non-ID chars}{defined name}{non-ID char} See |option-backslash| about inserting backslashes to include a space or backslash. The default value is for C programs. For C++ this value would be useful, to include const type declarations: > ^(#\s\s[a-z]) < You can also use "\ze" just before the name and continue the pattern to check what is following. E.g. for Javascript, if a function is defined with "func_name = function(args)": > ^\s=\sfunction( < If the function is defined with "func_name : function() {...": > ^{\s[:]\sfunction\s*( < When using the ":set" command, you need to double the backslashes! To avoid that use :let with a single quote string: > let &l:define = '}\s=\s*function(' <

If editing Unicode and this option is set, backspace and Normal mode "x" delete each combining character on its own. When it is off (the default) the character along with its combining characters are deleted. Note: When 'delcombine' is set "xx" may work differently from "2x"!

List of file names, separated by commas, that are used to lookup words for keyword completion commands |i_CTRL-X_CTRL-K|. Each file should contain a list of words. This can be one word per line, or several words per line, separated by non-keyword characters (white space is preferred). Maximum line length is 510 bytes.

{not available when compiled without the |+diff| feature} Expression which is evaluated to obtain a diff file (either ed-style or unified-style) from two versions of a file. See |diff-diffexpr|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+diff| feature} Option settings for diff mode. It can consist of the following items. All are optional. Items must be separated by a comma.

{not available when compiled without the |+digraphs| feature} Enable the entering of digraphs in Insert mode with {char1} {char2}. See |digraphs|. NOTE: This option is reset when 'compatible' is set.

List of directory names for the swap file, separated with commas. Recommended value: ".,/vimswap//" - this will put the swap file next to the edited file if possible, and in your personal swap directory otherwise. Make sure "/vimswap//" is only readable for you.

Change the way text is displayed. This is comma separated list of flags: lastline When included, as much as possible of the last line in a window will be displayed. "@@@" is put in the last columns of the last screen line to indicate the rest of the line is not displayed. truncate Like "lastline", but "@@@" is displayed in the first column of the last screen line. Overrules "lastline". uhex Show unprintable characters hexadecimal as instead of using ^C and ~C.

Tells when the 'equalalways' option applies: ver vertically, width of windows is not affected hor horizontally, height of windows is not affected both width and height of windows is affected

When on all Unicode emoji characters are considered to be full width. This excludes "text emoji" characters, which are normally displayed as single width. Unfortunately there is no good specification for this and it has been determined on trial-and-error basis. Use the |setcellwidths()| function to change the behavior.

Sets the character encoding used inside Vim. It applies to text in the buffers, registers, Strings in expressions, text stored in the viminfo file, etc. It sets the kind of characters which Vim can work with. See |encoding-names| for the possible values.

When writing a file and this option is off and the 'binary' option is on, or 'fixeol' option is off, no will be written for the last line in the file. This option is automatically set or reset when starting to edit a new file, depending on whether file has an for the last line in the file. Normally you don't have to set or reset this option. When 'binary' is off and 'fixeol' is on the value is not used when writing the file. When 'binary' is on or 'fixeol' is off it is used to remember the presence of a for the last line in the file, so that when you write the file the situation from the original file can be kept. But you can change it if you want to.

When on, all the windows are automatically made the same size after splitting or closing a window. This also happens the moment the option is switched on. When off, splitting a window will reduce the size of the current window and leave the other windows the same. When closing a window the extra lines are given to the window next to it (depending on 'splitbelow' and 'splitright'). When mixing vertically and horizontally split windows, a minimal size is computed and some windows may be larger if there is room. The 'eadirection' option tells in which direction the size is affected. Changing the height and width of a window can be avoided by setting 'winfixheight' and 'winfixwidth', respectively. If a window size is specified when creating a new window sizes are currently not equalized (it's complicated, but may be implemented in the future).

External program to use for "=" command. When this option is empty the internal formatting functions are used; either 'lisp', 'cindent' or 'indentexpr'. When Vim was compiled without internal formatting, the "indent" program is used. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Ring the bell (beep or screen flash) for error messages. This only makes a difference for error messages, the bell will be used always for a lot of errors without a message (e.g., hitting in Normal mode). See 'visualbell' on how to make the bell behave like a beep, screen flash or do nothing. See 'belloff' to finetune when to ring the bell.

{not available when compiled without the |+quickfix| feature} Name of the errorfile for the QuickFix mode (see |:cf|). When the "-q" command-line argument is used, 'errorfile' is set to the following argument. See |-q|. NOT used for the ":make" command. See 'makeef' for that. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+quickfix| feature} Scanf-like description of the format for the lines in the error file (see |errorformat|).

A list of autocommand event names, which are to be ignored. When set to "all" or when "all" is one of the items, all autocommand events are ignored, autocommands will not be executed. Otherwise this is a comma separated list of event names. Example: > :set ei=WinEnter,WinLeave <

In Insert mode: Use the appropriate number of spaces to insert a . Spaces are used in indents with the '>' and '<' commands and when 'autoindent' is on. To insert a real tab when 'expandtab' is on, use CTRL-V. See also |:retab| and |ins-expandtab|. This option is reset when the 'paste' option is set and restored when the 'paste' option is reset. NOTE: This option is reset when 'compatible' is set.

Sets the character encoding for the file of this buffer.

This is a list of character encodings considered when starting to edit an existing file. When a file is read, Vim tries to use the first mentioned character encoding. If an error is detected, the next one in the list is tried. When an encoding is found that works, 'fileencoding' is set to it. If all fail, 'fileencoding' is set to an empty string, which means the value of 'encoding' is used. WARNING: Conversion can cause loss of information! When 'encoding' is "utf-8" (or one of the other Unicode variants) conversion is most likely done in a way that the reverse conversion results in the same text. When 'encoding' is not "utf-8" some non-ASCII characters may be lost! You can use the |++bad| argument to specify what is done with characters that can't be converted. For an empty file or a file with only ASCII characters most encodings will work and the first entry of 'fileencodings' will be used (except "ucs-bom", which requires the BOM to be present). If you prefer another encoding use an BufReadPost autocommand event to test if your preferred encoding is to be used. Example: > au BufReadPost * if search('\S', 'w') == 0 | \ set fenc=iso-2022-jp | endif < This sets 'fileencoding' to "iso-2022-jp" if the file does not contain non-blank characters. When the |++enc| argument is used then the value of 'fileencodings' is not used. Note that 'fileencodings' is not used for a new file, the global value of 'fileencoding' is used instead. You can set it with: > :setglobal fenc=iso-8859-2 < This means that a non-existing file may get a different encoding than an empty file. The special value "ucs-bom" can be used to check for a Unicode BOM (Byte Order Mark) at the start of the file. It must not be preceded by "utf-8" or another Unicode encoding for this to work properly. An entry for an 8-bit encoding (e.g., "latin1") should be the last, because Vim cannot detect an error, thus the encoding is always accepted. The special value "default" can be used for the encoding from the environment. On MS-Windows this is the system encoding. Otherwise this is the default value for 'encoding'. It is useful when 'encoding' is set to "utf-8" and your environment uses a non-latin1 encoding, such as Russian. When 'encoding' is "utf-8" and a file contains an illegal byte sequence it won't be recognized as UTF-8. You can use the |8g8| command to find the illegal byte sequence. WRONG VALUES: WHAT'S WRONG: latin1,utf-8 "latin1" will always be used utf-8,ucs-bom,latin1 BOM won't be recognized in an utf-8 file cp1250,latin1 "cp1250" will always be used If 'fileencodings' is empty, 'fileencoding' is not modified. See 'fileencoding' for the possible values. Setting this option does not have an effect until the next time a file is read.

This gives the of the current buffer, which is used for reading/writing the buffer from/to a file: dos unix mac When "dos" is used, CTRL-Z at the end of a file is ignored. See |file-formats| and |file-read|. For the character encoding of the file see 'fileencoding'. When 'binary' is set, the value of 'fileformat' is ignored, file I/O works like it was set to "unix". This option is set automatically when starting to edit a file and 'fileformats' is not empty and 'binary' is off. When this option is set, after starting to edit a file, the 'modified' option is set, because the file would be different when written. This option can not be changed when 'modifiable' is off. For backwards compatibility: When this option is set to "dos", 'textmode' is set, otherwise 'textmode' is reset.

This gives the end-of-line () formats that will be tried when starting to edit a new buffer and when reading a file into an existing buffer:

• When empty, the format defined with 'fileformat' will be used always. It is not set automatically.
• When set to one name, that format will be used whenever a new buffer is opened. 'fileformat' is set accordingly for that buffer. The 'fileformats' name will be used when a file is read into an existing buffer, no matter what 'fileformat' for that buffer is set to.
• When more than one name is present, separated by commas, automatic detection will be done when reading a file. When starting to edit a file, a check is done for the :
  1. If all lines end in , and 'fileformats' includes "dos", 'fileformat' is set to "dos".
  2. If a is found and 'fileformats' includes "unix", 'fileformat' is set to "unix". Note that when a is found without a preceding , "unix" is preferred over "dos".
  3. If 'fileformat' has not yet been set, and if a is found, and if 'fileformats' includes "mac", 'fileformat' is set to "mac". This means that "mac" is only chosen when: "unix" is not present or no is found in the file, and "dos" is not present or no is found in the file. Except: if "unix" was chosen, but there is a before the first , and there appear to be more s than s in the first few lines, "mac" is used.
  4. If 'fileformat' is still not set, the first name from 'fileformats' is used. When reading a file into an existing buffer, the same is done, but this happens like 'fileformat' has been set appropriately for that file only, the option is not changed. When 'binary' is set, the value of 'fileformats' is not used.

When set case is ignored when using file names and directories. See 'wildignorecase' for only ignoring case when doing completion.

When this option is set, the FileType autocommand event is triggered. All autocommands that match with the value of this option will be executed. Thus the value of 'filetype' is used in place of the file name. Otherwise this option does not always reflect the current file type. This option is normally set when the file type is detected. To enable this use the ":filetype on" command. |:filetype| Setting this option to a different value is most useful in a modeline, for a file for which the file type is not automatically recognized. Example, for in an IDL file: // ~ |FileType| |filetypes| When a dot appears in the value then this separates two filetype names. Example: // ~ This will use the "c" filetype first, then the "doxygen" filetype. This works both for filetype plugins and for syntax files. More than one dot may appear. This option is not copied to another buffer, independent of the 's' or 'S' flag in 'cpoptions'. Only normal file name characters can be used, "/*?[|<>" are illegal.

{not available when compiled without the |+folding| feature} Characters to fill the statuslines and vertical separators. It is a comma separated list of items:

When writing a file and this option is on, at the end of file will be restored if missing. Turn this option off if you want to preserve the situation from the original file. When the 'binary' option is set the value of this option doesn't matter. See the 'endofline' option.

{not available when compiled without the |+folding| feature} When set to "all", a fold is closed when the cursor isn't in it and its level is higher than 'foldlevel'. Useful if you want folds to automatically close when moving out of them.

{not available when compiled without the |+folding| feature} When non-zero, a column with the specified width is shown at the side of the window which indicates open and closed folds. The maximum value is 12. See |folding|.

{not available when compiled without the |+folding| feature} When off, all folds are open. This option can be used to quickly switch between showing all text unfolded and viewing the text with folds (including manually opened or closed folds). It can be toggled with the |zi| command. The 'foldcolumn' will remain blank when 'foldenable' is off. This option is set by commands that create a new fold or close a fold. See |folding|.

{not available when compiled without the |+folding| or |+eval| features} The expression used for when 'foldmethod' is "expr". It is evaluated for each line to obtain its fold level. See |fold-expr|.

{not available when compiled without the |+folding| feature} Used only when 'foldmethod' is "indent". Lines starting with characters in 'foldignore' will get their fold level from surrounding lines. White space is skipped before checking for this character. The default "#" works well for C programs. See |fold-indent|.

{not available when compiled without the |+folding| feature} Sets the fold level: Folds with a higher level will be closed. Setting this option to zero will close all folds. Higher numbers will close fewer folds. This option is set by commands like |zm|, |zM| and |zR|. See |fold-foldlevel|.

{not available when compiled without the |+folding| feature} Sets 'foldlevel' when starting to edit another buffer in a window. Useful to always start editing with all folds closed (value zero), some folds closed (one) or no folds closed (99). This is done before reading any modeline, thus a setting in a modeline overrules this option. Starting to edit a file for |diff-mode| also ignores this option and closes all folds. It is also done before BufReadPre autocommands, to allow an autocmd to overrule the 'foldlevel' value for specific files. When the value is negative, it is not used.

{not available when compiled without the |+folding| feature} The start and end marker used when 'foldmethod' is "marker". There must be one comma, which separates the start and end marker. The marker is a literal string (a regular expression would be too slow). See |fold-marker|.

{not available when compiled without the |+folding| feature} The kind of folding used for the current window. Possible values: |fold-manual| manual Folds are created manually. |fold-indent| indent Lines with equal indent form a fold. |fold-expr| expr 'foldexpr' gives the fold level of a line. |fold-marker| marker Markers are used to specify folds. |fold-syntax| syntax Syntax highlighting items specify folds. |fold-diff| diff Fold text that is not changed.

{not available when compiled without the |+folding| feature} Sets the number of screen lines above which a fold can be displayed closed. Also for manually closed folds. With the default value of one a fold can only be closed if it takes up two or more screen lines. Set to zero to be able to close folds of just one screen line. Note that this only has an effect on what is displayed. After using "zc" to close a fold, which is displayed open because it's smaller than 'foldminlines', a following "zc" may close a containing fold.

{not available when compiled without the |+folding| feature} Sets the maximum nesting of folds for the "indent" and "syntax" methods. This avoids that too many folds will be created. Using more than 20 doesn't work, because the internal limit is 20.

{not available when compiled without the |+folding| feature} Specifies for which type of commands folds will be opened, if the command moves the cursor into a closed fold. It is a comma separated list of items. NOTE: When the command is part of a mapping this option is not used. Add the |zv| command to the mapping to get the same effect. (rationale: the mapping may want to control opening folds itself)

{not available when compiled without the |+folding| feature} An expression which is used to specify the text displayed for a closed fold. See |fold-foldtext|.

{not available when compiled without the |+eval| feature} Expression which is evaluated to format a range of lines for the |gq| operator or automatic formatting (see 'formatoptions'). When this option is empty 'formatprg' is used.

A pattern that is used to recognize a list header. This is used for the "n" flag in 'formatoptions'. The pattern must match exactly the text that will be the indent for the line below it. You can use |/\ze| to mark the end of the match while still checking more characters. There must be a character following the pattern, when it matches the whole line it is handled like there is no match. The default recognizes a number, followed by an optional punctuation character and white space.

This is a sequence of letters which describes how automatic formatting is to be done. See |fo-table|. When the 'paste' option is on, no formatting is done (like 'formatoptions' is empty). Commas can be inserted for readability. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" |add-option-flags|. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The name of an external program that will be used to format the lines selected with the |gq| operator. The program must take the input on stdin and produce the output on stdout. The Unix program "fmt" is such a program. If the 'formatexpr' option is not empty it will be used instead. Otherwise, if 'formatprg' option is an empty string, the internal format function will be used |C-indenting|. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

When on, the library function fsync() will be called after writing a file. This will flush a file to disk, ensuring that it is safely written even on filesystems which do metadata-only journaling. This will force the harddrive to spin up on Linux systems running in laptop mode, so it may be undesirable in some situations. Be warned that turning this off increases the chances of data loss after a crash. On systems without an fsync() implementation, this variable is always off. Also see 'swapsync' for controlling fsync() on swap files. 'fsync' also applies to |writefile()|, unless a flag is used to overrule it. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

When on, the ":substitute" flag 'g' is default on. This means that all matches in a line are substituted instead of one. When a 'g' flag is given to a ":substitute" command, this will toggle the substitution of all or one match. See |complex-change|.

Format to recognize for the ":grep" command output. This is a scanf-like string that uses the same format as the 'errorformat' option: see |errorformat|.

Program to use for the |:grep| command. This option may contain '%' and '#' characters, which are expanded like when used in a command- line. The placeholder "$*" is allowed to specify where the arguments will be included. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. When your "grep" accepts the "-H" argument, use this to make ":grep" also work well with a single file: > :set grepprg=grep\ -nH < Special value: When 'grepprg' is set to "internal" the |:grep| command works like |:vimgrep|, |:lgrep| like |:lvimgrep|, |:grepadd| like |:vimgrepadd| and |:lgrepadd| like |:lvimgrepadd|. See also the section |:make_makeprg|, since most of the comments there apply equally to 'grepprg'. For Win32, the default is "findstr /n" if "findstr.exe" can be found, otherwise it's "grep -n". This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only available when compiled with GUI enabled, and for Win32 console} This option tells Vim what the cursor should look like in different modes. It fully works in the GUI. In a Win32 console, only the height of the cursor can be changed. This can be done by specifying a block cursor, or a percentage for a vertical or horizontal cursor. For a console the 't_SI', 't_SR', and 't_EI' escape sequences are used.

{only available when compiled with GUI enabled} This is a list of fonts which will be used for the GUI version of Vim. In its simplest form the value is just one font name. See |gui-font| for the details.

{only available when compiled with GUI enabled} When not empty, specifies a comma-separated list of fonts to be used for double-width characters. The first font that can be loaded is used. See |gui-fontwide|.

{only available when compiled with GUI enabled} This option only has an effect in the GUI version of Vim. It is a sequence of letters which describes what components and options of the GUI should be used. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" |add-option-flags|.

{only available when compiled with GUI enabled} When nonempty describes the text to use in a label of the GUI tab pages line. When empty and when the result is empty Vim will use a default label. See |setting-guitablabel| for more info.

{only available when compiled with GUI enabled} When nonempty describes the text to use in a tooltip for the GUI tab pages line. When empty Vim will use a default tooltip. This option is otherwise just like 'guitablabel' above. You can include a line break. Simplest method is to use |:let|: > :let &guitabtooltip = "line one\nline two" <

Name of the main help file. All distributed help files should be placed together in one directory. Additionally, all "doc" directories in 'runtimepath' will be used. Environment variables are expanded |:set_env|. For example: "$VIMRUNTIME/doc/help.txt". If $VIMRUNTIME is not set, $VIM is also tried. Also see |$VIMRUNTIME| and |option-backslash| about including spaces and backslashes. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Minimal initial height of the help window when it is opened with the ":help" command. The initial height of the help window is half of the current window, or (when the 'ea' option is on) the same as other windows. When the height is less than 'helpheight', the height is set to 'helpheight'. Set to zero to disable.

{only available when compiled with the |+multi_lang| feature} Comma separated list of languages. Vim will use the first language for which the desired help can be found. The English help will always be used as a last resort. You can add "en" to prefer English over another language, but that will only find tags that exist in that language and not in the English help. Example: > :set helplang=de,it < This will first search German, then Italian and finally English help files. When using |CTRL-]| and ":help!" in a non-English help file Vim will try to find the tag in the current language before using this option. See |help-translated|.

When off a buffer is unloaded when it is |abandon|ed. When on a buffer becomes hidden when it is |abandon|ed. If the buffer is still displayed in another window, it does not become hidden, of course. The commands that move through the buffer list sometimes make a buffer hidden although the 'hidden' option is off: When the buffer is modified, 'autowrite' is off or writing is not possible, and the '!' flag was used. See also |windows.txt|. To only make one buffer hidden use the 'bufhidden' option. This option is set for one command with ":hide {command}" |:hide|. WARNING: It's easy to forget that you have changes in hidden buffers. Think twice when using ":q!" or ":qa!".

A history of ":" commands, and a history of previous search patterns is remembered. This option decides how many entries may be stored in each of these histories (see |cmdline-editing|). The maximum value is 10000. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

{only available when compiled with the |+rightleft| feature} When on, the keyboard is mapped for the Hebrew character set. Normally you would set 'allowrevins' and use CTRL-_ in insert mode to toggle this option. See |rileft.txt|. NOTE: This option is reset when 'compatible' is set.

{only available when compiled with the |+rightleft| feature} When on, phonetic keyboard mapping is used. 'hkmap' must also be on. This is useful if you have a non-Hebrew keyboard. See |rileft.txt|. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+extra_search| feature} When there is a previous search pattern, highlight all its matches. The type of highlighting used can be set with the 'l' occasion in the 'highlight' option. This uses the "Search" highlight group by default. Note that only the matching text is highlighted, any offsets are not applied. See also: 'incsearch' and |:match|. When you get bored looking at the highlighted matches, you can turn it off with |:nohlsearch|. This does not change the option value, as soon as you use a search command, the highlighting comes back. 'redrawtime' specifies the maximum time spent on finding matches. When the search pattern can match an end-of-line, Vim will try to highlight all of the matched text. However, this depends on where the search starts. This will be the first line in the window or the first line below a closed fold. A match in a previous line which is not drawn may not continue in a newly drawn line. You can specify whether the highlight status is restored on startup with the 'h' flag in 'viminfo' |viminfo-h|. NOTE: This option is reset when 'compatible' is set.

Ignore case in search patterns. Also used when searching in the tags file. Also see 'smartcase' and 'tagcase'. Can be overruled by using "\c" or "\C" in the pattern, see |/ignorecase|.

When set the Input Method is always on when starting to edit a command line, unless entering a search pattern (see 'imsearch' for that). Setting this option is useful when your input method allows entering English characters directly, e.g., when it's used to type accented characters with dead keys.

When set the Input Method is never used. This is useful to disable the IM when it doesn't work properly. Currently this option is on by default for SGI/IRIX machines. This may change in later releases.

Specifies whether :lmap or an Input Method (IM) is to be used in Insert mode. Valid values: 0 :lmap is off and IM is off 1 :lmap is ON and IM is off 2 :lmap is off and IM is ON To always reset the option to zero when leaving Insert mode with this can be used: > :inoremap :set iminsert=0 < This makes :lmap and IM turn off automatically when leaving Insert mode. Note that this option changes when using CTRL-^ in Insert mode |i_CTRL-^|. The value is set to 1 when setting 'keymap' to a valid keymap name. It is also used for the argument of commands like "r" and "f". The value 0 may not work correctly with Athena and Motif with some XIM methods. Use 'imdisable' to disable XIM then.

Specifies whether :lmap or an Input Method (IM) is to be used when entering a search pattern. Valid values: -1 the value of 'iminsert' is used, makes it look like 'iminsert' is also used when typing a search pattern 0 :lmap is off and IM is off 1 :lmap is ON and IM is off 2 :lmap is off and IM is ON Note that this option changes when using CTRL-^ in Command-line mode |c_CTRL-^|. The value is set to 1 when it is not -1 and setting the 'keymap' option to a valid keymap name. The value 0 may not work correctly with Athena and Motif with some XIM methods. Use 'imdisable' to disable XIM then.

{not available when compiled without the |+find_in_path| feature} Pattern to be used to find an include command. It is a search pattern, just like for the "/" command (See |pattern|). The default value is for C programs. This option is used for the commands "[i", "]I", "[d", etc. Normally the 'isfname' option is used to recognize the file name that comes after the matched pattern. But if "\zs" appears in the pattern then the text matched from "\zs" to the end, or until "\ze" if it appears, is used as the file name. Use this to include characters that are not in 'isfname', such as a space. You can then use 'includeexpr' to process the matched text. See |option-backslash| about including spaces and backslashes.

{not available when compiled without the |+find_in_path| or |+eval| features} Expression to be used to transform the string found with the 'include' option to a file name. Mostly useful to change "." to "/" for Java: > :set includeexpr=substitute(v:fname,'\.','/','g') < The "v:fname" variable will be set to the file name that was detected.

{not available when compiled without the |+extra_search| features} While typing a search command, show where the pattern, as it was typed so far, matches. The matched string is highlighted. If the pattern is invalid or not found, nothing is shown. The screen will be updated often, this is only useful on fast terminals. Also applies to the pattern in commands: > :global :lvimgrep :lvimgrepadd :smagic :snomagic :sort :substitute :vglobal :vimgrep :vimgrepadd < Note that the match will be shown, but the cursor will return to its original position when no match is found and when pressing . You still need to finish the search command with to move the cursor to the match. You can use the CTRL-G and CTRL-T keys to move to the next and previous match. |c_CTRL-G| |c_CTRL-T| When compiled with the |+reltime| feature Vim only searches for about half a second. With a complicated pattern and/or a lot of text the match may not be found. This is to avoid that Vim hangs while you are typing the pattern. The highlighting can be set with the 'i' flag in 'highlight'. When 'hlsearch' is on, all matched strings are highlighted too while typing a search command. See also: 'hlsearch'. If you don't want to turn 'hlsearch' on, but want to highlight all matches while searching, you can turn on and off 'hlsearch' with autocmd. Example: > augroup vimrc-incsearch-highlight autocmd! autocmd CmdlineEnter /,? :set hlsearch autocmd CmdlineLeave /,? :set nohlsearch augroup END < CTRL-L can be used to add one character from after the current match to the command line. If 'ignorecase' and 'smartcase' are set and the command line has no uppercase characters, the added character is converted to lowercase. CTRL-R CTRL-W can be used to add the word at the end of the current match, excluding the characters that were already typed. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+cindent| or |+eval| features} Expression which is evaluated to obtain the proper indent for a line. It is used when a new line is created, for the |=| operator and in Insert mode as specified with the 'indentkeys' option. When this option is not empty, it overrules the 'cindent' and 'smartindent' indenting. When 'lisp' is set, this option is overridden by the Lisp indentation algorithm. When 'paste' is set this option is not used for indenting. The expression is evaluated with |v:lnum| set to the line number for which the indent is to be computed. The cursor is also in this line when the expression is evaluated (but it may be moved around). The expression must return the number of spaces worth of indent. It can return "-1" to keep the current indent (this means 'autoindent' is used for the indent). Functions useful for computing the indent are |indent()|, |cindent()| and |lispindent()|. The evaluation of the expression must not have side effects! It must not change the text, jump to another window, etc. Afterwards the cursor position is always restored, thus the cursor may be moved. Normally this option would be set to call a function: > :set indentexpr=GetMyIndent() < Error messages will be suppressed, unless the 'debug' option contains "msg". See |indent-expression|. NOTE: This option is set to "" when 'compatible' is set.

{not available when compiled without the |+cindent| feature} A list of keys that, when typed in Insert mode, cause reindenting of the current line. Only happens if 'indentexpr' isn't empty. The format is identical to 'cinkeys', see |indentkeys-format|. See |C-indenting| and |indent-expression|.

When doing keyword completion in insert mode |ins-completion|, and 'ignorecase' is also on, the case of the match is adjusted depending on the typed text. If the typed text contains a lowercase letter where the match has an upper case letter, the completed part is made lowercase. If the typed text has no lowercase letters and the match has a lowercase letter where the typed text has an uppercase letter, and there is a letter before it, the completed part is made uppercase. With 'noinfercase' the match is used as-is.

Makes Vim work in a way that Insert mode is the default mode. Useful if you want to use Vim as a modeless editor. Used for |evim|. These Insert mode commands will be useful:

• Use the cursor keys to move around.
• Use CTRL-O to execute one Normal mode command |i_CTRL-O|. When this is a mapping, it is executed as if 'insertmode' was off. Normal mode remains active until the mapping is finished.
• Use CTRL-L to execute a number of Normal mode commands, then use to get back to Insert mode. Note that CTRL-L moves the cursor left, like does when 'insertmode' isn't set. |i_CTRL-L|

The characters specified by this option are included in file names and path names. Filenames are used for commands like "gf", "[i" and in the tags file. It is also used for "\f" in a |pattern|. Multi-byte characters 256 and above are always included, only the characters up to 255 are specified with this option. For UTF-8 the characters 0xa0 to 0xff are included as well. Think twice before adding white space to this option. Although a space may appear inside a file name, the effect will be that Vim doesn't know where a file name starts or ends when doing completion. It most likely works better without a space in 'isfname'.

The characters given by this option are included in identifiers. Identifiers are used in recognizing environment variables and after a match of the 'define' option. It is also used for "\i" in a |pattern|. See 'isfname' for a description of the format of this option. For '@' only characters up to 255 are used. Careful: If you change this option, it might break expanding environment variables. E.g., when '/' is included and Vim tries to expand "$HOME/.viminfo". Maybe you should change 'iskeyword' instead.

Keywords are used in searching and recognizing with many commands: "w", "", "[i", etc. It is also used for "\k" in a |pattern|. See 'isfname' for a description of the format of this option. For '@' characters above 255 check the "word" character class (any character that is not white space or punctuation). For C programs you could use "a-z,A-Z,48-57,_,.,-,>". For a help file it is set to all non-blank printable characters except '', '"' and '|' (so that CTRL-] on a command finds the help for that command). When the 'lisp' option is on the '-' character is always included. This option also influences syntax highlighting, unless the syntax uses |:syn-iskeyword|. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The characters given by this option are displayed directly on the screen. It is also used for "\p" in a |pattern|. The characters from space (ASCII 32) to '~' (ASCII 126) are always displayed directly, even when they are not included in 'isprint' or excluded. See 'isfname' for a description of the format of this option.

Insert two spaces after a '.', '?' and '!' with a join command. When 'cpoptions' includes the 'j' flag, only do this after a '.'. Otherwise only one space is inserted. NOTE: This option is set when 'compatible' is set.

{only available when compiled with the |+keymap| feature} Name of a keyboard mapping. See |mbyte-keymap|. Setting this option to a valid keymap name has the side effect of setting 'iminsert' to one, so that the keymap becomes effective. 'imsearch' is also set to one, unless it was -1 Only normal file name characters can be used, "/*?[|<>" are illegal.

List of comma separated words, which enable special things that keys can do. These values can be used: startsel Using a shifted special key starts selection (either Select mode or Visual mode, depending on "key" being present in 'selectmode'). stopsel Using a not-shifted special key stops selection. Special keys in this context are the cursor keys, , , and . The 'keymodel' option is set by the |:behave| command.

Program to use for the |K| command. Environment variables are expanded |:set_env|. ":help" may be used to access the Vim internal help. (Note that previously setting the global option to the empty value did this, which is now deprecated.) When the first character is ":", the command is invoked as a Vim Ex command prefixed with [count]. When "man", "man -s" or an Ex command is used, Vim will automatically translate a count for the "K" command and pass it as the first argument. For "man -s" the "-s" is removed when there is no count. See |option-backslash| about including spaces and backslashes. Example: > :set keywordprg=man\ -s < This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only available when compiled with the |+langmap| feature} This option allows switching your keyboard into a special language mode. When you are typing text in Insert mode the characters are inserted directly. When in Normal mode the 'langmap' option takes care of translating these special characters to the original meaning of the key. This means you don't have to change the keyboard mode to be able to execute Normal mode commands. This is the opposite of the 'keymap' option, where characters are mapped in Insert mode. Also consider setting 'langremap' to off, to prevent 'langmap' from applying to characters resulting from a mapping. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only available when compiled with the |+menu| and |+multi_lang| features} Language to use for menu translation. Tells which file is loaded from the "lang" directory in 'runtimepath': > "lang/menu_" . &langmenu . ".vim" < (without the spaces). For example, to always use the Dutch menus, no matter what $LANG is set to: > :set langmenu=nl_NL.ISO_8859-1 < When 'langmenu' is empty, |v:lang| is used. Only normal file name characters can be used, "/*?[|<>" are illegal. If your $LANG is set to a non-English language but you do want to use the English menus: > :set langmenu=none < This option must be set before loading menus, switching on filetype detection or syntax highlighting. Once the menus are defined setting this option has no effect. But you could do this: > :source $VIMRUNTIME/delmenu.vim :set langmenu=de_DE.ISO_8859-1 :source $VIMRUNTIME/menu.vim < Warning: This deletes all menus that you defined yourself!

{only available when compiled with the |+langmap| feature} When off, setting 'langmap' does not apply to characters resulting from a mapping. This basically means, if you noticed that setting 'langmap' disables some of your mappings, try resetting this option. This option defaults to on for backwards compatibility. Set it off if that works for you to avoid mappings to break.

The value of this option influences when the last window will have a status line: 0: never 1: only if there are at least two windows 2: always The screen looks nicer with a status line if you have several windows, but it takes another screen line. |status-line|

When this option is set, the screen will not be redrawn while executing macros, registers and other commands that have not been typed. Also, updating the window title is postponed. To force an update use |:redraw|.

{not available when compiled without the |+linebreak| feature} If on, Vim will wrap long lines at a character in 'breakat' rather than at the last character that fits on the screen. Unlike 'wrapmargin' and 'textwidth', this does not insert s in the file, it only affects the way the file is displayed, not its contents. If 'breakindent' is set, line is visually indented. Then, the value of 'showbreak' is used to put in front of wrapped lines. This option is not used when the 'wrap' option is off. Note that characters after an are mostly not displayed with the right amount of white space.

{only in the GUI} Number of pixel lines inserted between characters. Useful if the font uses the full character cell height, making lines touch each other. When non-zero there is room for underlining. With some fonts there can be too much room between lines (to have space for ascents and descents). Then it makes sense to set 'linespace' to a negative value. This may cause display problems though!

{not available when compiled without the |+lispindent| feature} Comma separated list of words that influence the Lisp indenting. |'lisp'|

Strings to use in 'list' mode and for the |:list| command. It is a comma separated list of string settings. eol:c Character to show at the end of each line. When omitted, there is no extra character at the end of the line. tab:xy[z] Two or three characters to be used to show a tab. The third character is optional.

When on the plugin scripts are loaded when starting up |load-plugins|. This option can be reset in your |vimrc| file to disable the loading of plugins. Note that using the "-u NONE", "-u DEFAULTS" and "--noplugin" command line arguments reset this option. See |-u| and |--noplugin|.

{not available when compiled without the |+quickfix| feature} Name of the errorfile for the |:make| command (see |:make_makeprg|) and the |:grep| command. When it is empty, an internally generated temp file will be used. When "##" is included, it is replaced by a number to make the name unique. This makes sure that the ":make" command doesn't overwrite an existing file. NOT used for the ":cf" command. See 'errorfile' for that. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Encoding used for reading the output of external commands. When empty, encoding is not converted. This is used for :make, :lmake, :grep, :lgrep, :grepadd, :lgrepadd, :cfile, :cgetfile, :caddfile, :lfile, :lgetfile, and :laddfile.

Program to use for the ":make" command. See |:make_makeprg|. This option may contain '%' and '#' characters (see |:%| and |:#|), which are expanded to the current and alternate file name. Use |::S| to escape file names in case they contain special characters. Environment variables are expanded |:set_env|. See |option-backslash| about including spaces and backslashes. Note that a '|' must be escaped twice: once for ":set" and once for the interpretation of a command. When you use a filter called "myfilter" do it like this: > :set makeprg=gmake\ \|\ myfilter < The placeholder "$*" can be given (even multiple times) to specify where the arguments will be included, for example: > :set makeprg=latex\ \\nonstopmode\ \\input\{$*} < This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Characters that form pairs. The |%| command jumps from one to the other. Only character pairs are allowed that are different, thus you cannot jump between two double quotes. The characters must be separated by a colon. The pairs must be separated by a comma. Example for including '<' and '>' (for HTML): > :set mps+=<:>

Tenths of a second to show the matching paren, when 'showmatch' is set. Note that this is not in milliseconds, like other options that set a time. This is to be compatible with Nvi.

The maximum number of combining characters supported for displaying. Only used when 'encoding' is "utf-8". The default is OK for most languages. Hebrew may require 4. Maximum value is 6. Even when this option is set to 2 you can still edit text with more combining characters, you just can't see them. Use |g8| or |ga|. See |mbyte-combining|.

{not available when compiled without the |+eval| feature} Maximum depth of function calls for user functions. This normally catches endless recursion. When using a recursive function with more depth, set 'maxfuncdepth' to a bigger number. But this will use more memory, there is the danger of failing when memory is exhausted. Increasing this limit above 200 also changes the maximum for Ex command recursion, see |E169|. See also |:function|.

Maximum number of times a mapping is done without resulting in a character to be used. This normally catches endless mappings, like ":map x y" with ":map y x". It still does not catch ":map g wg", because the 'w' is used before the next mapping is done. See also |key-mapping|.

Maximum amount of memory (in Kbyte) to use for pattern matching. The maximum value is about 2000000. Use this to work without a limit. When Vim runs into the limit it gives an error message and mostly behaves like CTRL-C was typed. Running into the limit often means that the pattern is very inefficient or too complex. This may already happen with the pattern "(.)" works much better. Might also happen on redraw, when syntax rules try to match a complex text structure. Vim may run out of memory before hitting the 'maxmempattern' limit, in which case you get an "Out of memory" error instead.

{not available when compiled without the |+menu| feature} Maximum number of items to use in a menu. Used for menus that are generated from a list of items, e.g., the Buffers menu. Changing this option has no direct effect, the menu must be refreshed first.

{not available when compiled without the |+syntax| feature} Parameters for |:mkspell|. This tunes when to start compressing the word tree. Compression can be slow when there are many words, but it's needed to avoid running out of memory. The amount of memory used per word depends very much on how similar the words are, that's why this tuning is complicated.

If 'modeline' is on 'modelines' gives the number of lines that is checked for set commands. If 'modeline' is off or 'modelines' is zero no lines are checked. See |modeline|.

When on allow some options that are an expression to be set in the modeline. Check the option for whether it is affected by 'modelineexpr'. Also see |modeline|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

If 'modeline' is on 'modelines' gives the number of lines that is checked for set commands. If 'modeline' is off or 'modelines' is zero no lines are checked. See |modeline|. NOTE: 'modeline' is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

When off the buffer contents cannot be changed. The 'fileformat' and 'fileencoding' options also can't be changed. Can be reset on startup with the |-M| command line argument.

When on, the buffer is considered to be modified. This option is set when:

1. A change was made to the text since it was last written. Using the |undo| command to go back to the original text will reset the option. But undoing changes that were made before writing the buffer will set the option again, since the text is different from when it was written.
2. 'fileformat' or 'fileencoding' is different from its original value. The original value is set when the buffer is read or written. A ":set nomodified" command also resets the original values to the current values and the 'modified' option will be reset. Similarly for 'eol' and 'bomb'. This option is not set when a change is made to the buffer as the result of a BufNewFile, BufRead/BufReadPost, BufWritePost, FileAppendPost or VimLeave autocommand event. See |gzip-example| for an explanation. When 'buftype' is "nowrite" or "nofile" this option may be set, but will be ignored. Note that the text may actually be the same, e.g. 'modified' is set when using "rA" on an "A".

{only works in the GUI} The window that the mouse pointer is on is automatically activated. When changing the window layout or window focus in another way, the mouse pointer is moved to the window with keyboard focus. Off is the default because it makes using the pull down menus a little goofy, as a pointer transit may activate a window unintentionally. MS-Windows: Also see 'scrollfocus' for what window is scrolled when using the mouse scroll wheel.

{only works in the GUI} When on, the mouse pointer is hidden when characters are typed. The mouse pointer is restored when the mouse is moved.

Sets the model to use for the mouse. The name mostly specifies what the right mouse button is used for: extend Right mouse button extends a selection. This works like in an xterm. popup Right mouse button pops up a menu. The shifted left mouse button extends a selection. This works like with Microsoft Windows. popup_setpos Like "popup", but the cursor will be moved to the position where the mouse was clicked, and thus the selected operation will act upon the clicked object. If clicking inside a selection, that selection will be acted upon, i.e. no cursor move. This implies of course, that right clicking outside a selection will end Visual mode. Overview of what button does what for each model: mouse extend popup(_setpos) ~ left click place cursor place cursor left drag start selection start selection shift-left search word extend selection right click extend selection popup menu (place cursor) right drag extend selection - middle click paste paste

{only available when compiled with the |+mouseshape| feature} This option tells Vim what the mouse pointer should look like in different modes. The option is a comma separated list of parts, much like used for 'guicursor'. Each part consist of a mode/location-list and an argument-list: mode-list:shape,mode-list:shape,.. The mode-list is a dash separated list of these modes/locations: In a normal window: ~ n Normal mode v Visual mode ve Visual mode with 'selection' "exclusive" (same as 'v', if not specified) o Operator-pending mode i Insert mode r Replace mode

Only for GUI, Win32 and Unix with xterm. Defines the maximum time in msec between two mouse clicks for the second click to be recognized as a multi click.

This defines what bases Vim will consider for numbers when using the CTRL-A and CTRL-X commands for adding to and subtracting from a number respectively; see |CTRL-A| for more info on these commands. alpha If included, single alphabetical characters will be incremented or decremented. This is useful for a list with a letter index a), b), etc. octal If included, numbers that start with a zero will be considered to be octal. Example: Using CTRL-A on "007" results in "010". hex If included, numbers starting with "0x" or "0X" will be considered to be hexadecimal. Example: Using CTRL-X on "0x100" results in "0x0ff". bin If included, numbers starting with "0b" or "0B" will be considered to be binary. Example: Using CTRL-X on "0b1000" subtracts one, resulting in "0b0111". unsigned If included, numbers are recognized as unsigned. Thus a leading dash or negative sign won't be considered as part of the number. Examples: Using CTRL-X on "2020" in "9-2020" results in "9-2019" (without "unsigned" it would become "9-2021"). Using CTRL-A on "2020" in "9-2020" results in "9-2021" (without "unsigned" it would become "9-2019"). Using CTRL-X on "0" or CTRL-A on "18446744073709551615" (2^64 - 1) has no effect, overflow is prevented. Numbers which simply begin with a digit in the range 1-9 are always considered decimal. This also happens for numbers that are not recognized as octal or hex.

Print the line number in front of each line. When the 'n' option is excluded from 'cpoptions' a wrapped line will not use the column of line numbers (this is the default when 'compatible' isn't set). The 'numberwidth' option can be used to set the room used for the line number. When a long, wrapped line doesn't start with the first character, '-' characters are put before the number. See |hl-LineNr| and |hl-CursorLineNr| for the highlighting used for the number. The 'relativenumber' option changes the displayed number to be relative to the cursor. Together with 'number' there are these four combinations (cursor in line 3):

{only available when compiled with the |+linebreak| feature} Minimal number of columns to use for the line number. Only relevant when the 'number' or 'relativenumber' option is set or printing lines with a line number. Since one space is always between the number and the text, there is one less character for the number itself. The value is the minimum width. A bigger width is used when needed to fit the highest line number in the buffer respectively the number of rows in the window, depending on whether 'number' or 'relativenumber' is set. Thus with the Vim default of 4 there is room for a line number up to 999. When the buffer has 1000 lines five columns will be used. The minimum value is 1, the maximum value is 20. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

{not available when compiled without the |+eval| feature} This option specifies a function to be used for Insert mode omni completion with CTRL-X CTRL-O. |i_CTRL-X_CTRL-O| See |complete-functions| for an explanation of how the function is invoked and what it should return. This option is usually set by a filetype plugin: |:filetype-plugin-on| This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only for MS-Windows} Enable reading and writing from devices. This may get Vim stuck on a device that can be opened but doesn't actually do the I/O. Therefore it is off by default. Note that on MS-Windows editing "aux.h", "lpt1.txt" and the like also result in editing a device.

This option specifies a function to be called by the |g@| operator. See |:map-operator| for more info and an example.

Directories used to find packages. See |packages|.

Specifies the nroff macros that separate paragraphs. These are pairs of two letters (see |object-motions|).

When non-empty, specifies the key sequence that toggles the 'paste' option. This is like specifying a mapping: > :map {keys} :set invpaste < Where {keys} is the value of 'pastetoggle'. The difference is that it will work even when 'paste' is set. 'pastetoggle' works in Insert mode and Normal mode, but not in Command-line mode. Mappings are checked first, thus overrule 'pastetoggle'. However, when 'paste' is on mappings are ignored in Insert mode, thus you can do this: > :map :set paste :map :set nopaste :imap :set paste :imap :set pastetoggle= < This will make start paste mode and stop paste mode. Note that typing in paste mode inserts "", since in paste mode everything is inserted literally, except the 'pastetoggle' key sequence. When the value has several bytes 'ttimeoutlen' applies.

{not available when compiled without the |+diff| feature} Expression which is evaluated to apply a patch to a file and generate the resulting new version of the file. See |diff-patchexpr|.

When non-empty the oldest version of a file is kept. This can be used to keep the original version of a file if you are changing files in a source distribution. Only the first time that a file is written a copy of the original file will be kept. The name of the copy is the name of the original file with the string in the 'patchmode' option appended. This option should start with a dot. Use a string like ".orig" or ".org". 'backupdir' must not be empty for this to work (Detail: The backup file is renamed to the patchmode file after the new file has been successfully written, that's why it must be possible to write a backup file). If there was no file to be backed up, an empty file is created. When the 'backupskip' pattern matches, a patchmode file is not made. Using 'patchmode' for compressed files appends the extension at the end (e.g., "file.gz.orig"), thus the resulting name isn't always recognized as a compressed file. Only normal file name characters can be used, "/*?[|<>" are illegal.

This is a list of directories which will be searched when using the |gf|, [f, ]f, ^Wf, |:find|, |:sfind|, |:tabfind| and other commands, provided that the file being searched for has a relative path (not starting with "/", "./" or "../"). The directories in the 'path' option may be relative or absolute.

• Use commas to separate directory names: > :set path=.,/usr/local/include,/usr/include < - Spaces can also be used to separate directory names (for backwards compatibility with version 3.0). To have a space in a directory name, precede it with an extra backslash, and escape the space: > :set path=.,/dir/with\\ space < - To include a comma in a directory name precede it with an extra backslash: > :set path=.,/dir/with\,comma < - To search relative to the directory of the current file, use: > :set path=. < - To search in the current directory use an empty string between two commas: > :set path=,, < - A directory name may end in a ':' or '/'.
• Environment variables are expanded |:set_env|.
• When using |netrw.vim| URLs can be used. For example, adding "http://www.vim.org" will make ":find index.html" work.
• Search upwards and downwards in a directory tree using "*" and ";". See |file-searching| for info and syntax. {not available when compiled without the |+path_extra| feature}
• Careful with '' characters, type two to get one in the option: > :set path=.,c:\include < Or just use '/' instead: > :set path=.,c:/include < Don't forget "." or files won't even be found in the same directory as the file! The maximum length is limited. How much depends on the system, mostly it is something like 256 or 1024 characters. You can check if all the include files are found, using the value of 'path', see |:checkpath|. The use of |:set+=| and |:set-=| is preferred when adding or removing directories from the list. This avoids problems when a future version uses another default. To remove the current directory use: > :set path-= < To add the current directory use: > :set path+= < To use an environment variable, you probably need to replace the separator. Here is an example to append $INCL, in which directory names are separated with a semi-colon: > :let &path = &path . "," . substitute($INCL, ';', ',', 'g') < Replace the ';' with a ':' or whatever separator is used. Note that this doesn't work when $INCL contains a comma or white space.

When changing the indent of the current line, preserve as much of the indent structure as possible. Normally the indent is replaced by a series of tabs followed by spaces as required (unless |'expandtab'| is enabled, in which case only spaces are used). Enabling this option means the indent will preserve as many existing characters as possible for indenting, and only add additional tabs or spaces as required. 'expandtab' does not apply to the preserved white space, a Tab remains a Tab. NOTE: When using ">>" multiple times the resulting indent is a mix of tabs and spaces. You might not like this. NOTE: This option is reset when 'compatible' is set. Also see 'copyindent'. Use |:retab| to clean up white space.

{not available when compiled without the |+quickfix| feature} Default height for a preview window. Used for |:ptag| and associated commands. Used for |CTRL-W_}| when no count is given. Not used when 'previewpopup' is set.

{not available when compiled without the |+quickfix| feature} Identifies the preview window. Only one window can have this option set. It's normally not set directly, but by using one of the commands |:ptag|, |:pedit|, etc.

{only available when compiled with the |+printer| feature} The name of the printer to be used for |:hardcopy|. See |pdev-option|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only available when compiled with the |+printer| and |+postscript| features} Sets the character encoding used when printing. See |penc-option|.

{only available when compiled with the |+printer| and |+postscript| features} Expression used to print the PostScript produced with |:hardcopy|. See |pexpr-option|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only available when compiled with the |+printer| feature} The name of the font that will be used for |:hardcopy|. See |pfn-option|.

{only available when compiled with the |+printer| feature} The format of the header produced in |:hardcopy| output. See |pheader-option|.

{only available when compiled with the |+printer| and |+postscript| features} The CJK character set to be used for CJK output from |:hardcopy|. See |pmbcs-option|.

{only available when compiled with the |+printer| and |+postscript| features} List of font names to be used for CJK output from |:hardcopy|. See |pmbfn-option|.

{only available when compiled with |+printer| feature} List of items that control the format of the output of |:hardcopy|. See |popt-option|.

Determines the maximum number of items to show in the popup menu for Insert mode completion. When zero as much space as available is used. |ins-completion-menu|.

Determines the minimum width to use for the popup menu for Insert mode completion. |ins-completion-menu|.

{only available when compiled with the |+python| or the |+python3| feature} Specifies the python version used for pyx* functions and commands |python_x|. The default value is as follows:

{only available when compiled with the |+quickfix| feature} This option specifies a function to be used to get the text to display in the quickfix and location list windows. This can be used to customize the information displayed in the quickfix or location window for each entry in the corresponding quickfix or location list. See |quickfix-window-function| for an explanation of how to write the function and an example. The value can be the name of a function or a lambda.

The characters that are used to escape quotes in a string. Used for objects like a', a" and a` |a'|. When one of the characters in this option is found inside a string, the following character will be skipped. The default value makes the text "foo"bar\" considered to be one string.

If on, writes fail unless you use a '!'. Protects you from accidentally overwriting a file. Default on when Vim is started in read-only mode ("vim -R") or when the executable is called "view". When using ":w!" the 'readonly' option is reset for the current buffer, unless the 'Z' flag is in 'cpoptions'. When using the ":view" command the 'readonly' option is set for the newly edited buffer. See 'modifiable' for disallowing changes to the buffer.

{only available when compiled with the |+reltime| feature} The time in milliseconds for redrawing the display. This applies to searching for patterns for 'hlsearch', |:match| highlighting and syntax highlighting. When redrawing takes more than this many milliseconds no further matches will be highlighted. For syntax highlighting the time applies per window. When over the limit syntax highlighting is disabled until |CTRL-L| is used. This is used to avoid that Vim hangs when using a very complicated pattern.

This selects the default regexp engine. |two-engines| The possible values are: 0 automatic selection 1 old engine 2 NFA engine Note that when using the NFA engine and the pattern contains something that is not supported the pattern will not match. This is only useful for debugging the regexp engine. Using automatic selection enables Vim to switch the engine, if the default engine becomes too costly. E.g., when the NFA engine uses too many states. This should prevent Vim from hanging on a combination of a complex pattern with long text.

Show the line number relative to the line with the cursor in front of each line. Relative line numbers help you use the |count| you can precede some vertical motion commands (e.g. j k + -) with, without having to calculate it yourself. Especially useful in combination with other commands (e.g. y d c < > gq gw =). When the 'n' option is excluded from 'cpoptions' a wrapped line will not use the column of line numbers (this is the default when 'compatible' isn't set). The 'numberwidth' option can be used to set the room used for the line number. When a long, wrapped line doesn't start with the first character, '-' characters are put before the number. See |hl-LineNr| and |hl-CursorLineNr| for the highlighting used for the number.

{only available when compiled with the |+rightleft| feature} Inserting characters in Insert mode will work backwards. See "typing backwards" |ins-reverse|. This option can be toggled with the CTRL-_ command in Insert mode, when 'allowrevins' is set. NOTE: This option is reset when 'compatible' is set. This option is reset when 'paste' is set and restored when 'paste' is reset.

{only available when compiled with the |+rightleft| feature} When on, display orientation becomes right-to-left, i.e., characters that are stored in the file appear from the right to the left. Using this option, it is possible to edit files for languages that are written from the right to the left such as Hebrew and Arabic. This option is per window, so it is possible to edit mixed files simultaneously, or to view the same file in both ways (this is useful whenever you have a mixed text file with both right-to-left and left-to-right strings so that both sets are displayed properly in different windows). Also see |rileft.txt|.

{only available when compiled with the |+rightleft| feature} Each word in this option enables the command line editing to work in right-to-left mode for a group of commands:

{not available when compiled without the |+cmdline_info| feature} Show the line and column number of the cursor position, separated by a comma. When there is room, the relative position of the displayed text in the file is shown on the far right: Top first line is visible Bot last line is visible All first and last line are visible 45% relative position in the file If 'rulerformat' is set, it will determine the contents of the ruler. Each window has its own ruler. If a window has a status line, the ruler is shown there. Otherwise it is shown in the last line of the screen. If the statusline is given by 'statusline' (i.e. not empty), this option takes precedence over 'ruler' and 'rulerformat' If the number of characters displayed is different from the number of bytes in the text (e.g., for a TAB or a multibyte character), both the text column (byte number) and the screen column are shown, separated with a dash. For an empty line "0-1" is shown. For an empty buffer the line number will also be zero: "0,0-1". This option is reset when 'paste' is set and restored when 'paste' is reset. If you don't want to see the ruler all the time but want to know where you are, use "g CTRL-G" |g_CTRL-G|. NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+statusline| feature} When this option is not empty, it determines the content of the ruler string, as displayed for the 'ruler' option. The format of this option is like that of 'statusline'. This option cannot be set in a modeline when 'modelineexpr' is off.

This is a list of directories which will be searched for runtime files: filetype.vim filetypes by file name |new-filetype| scripts.vim filetypes by file contents |new-filetype-scripts| autoload/ automatically loaded scripts |autoload-functions| colors/ color scheme files |:colorscheme| compiler/ compiler files |:compiler| doc/ documentation |write-local-help| ftplugin/ filetype plugins |write-filetype-plugin| import/ files that are found by :import indent/ indent scripts |indent-expression| keymap/ key mapping files |mbyte-keymap| lang/ menu translations |:menutrans| menu.vim GUI menus |menu.vim| pack/ packages |:packadd| plugin/ plugin scripts |write-plugin| print/ files for printing |postscript-print-encoding| spell/ spell checking files |spell| syntax/ syntax files |mysyntaxfile| tutor/ files for vimtutor |tutor|

Number of lines to scroll with CTRL-U and CTRL-D commands. Will be set to half the number of lines in the window when the window size changes. This may happen when enabling the |status-line| or 'tabline' option after setting the 'scroll' option. If you give a count to the CTRL-U or CTRL-D command it will be used as the new value for 'scroll'. Reset to half the window height with ":set scroll=0".

See also |scroll-binding|. When this option is set, the current window scrolls as other scrollbind windows (windows that also have this option set) scroll. This option is useful for viewing the differences between two versions of a file, see 'diff'. See |'scrollopt'| for options that determine how this option should be interpreted. This option is mostly reset when splitting a window to edit another file. This means that ":split | edit file" results in two windows with scroll-binding, but ":split file" does not.

Minimal number of lines to scroll when the cursor gets off the screen (e.g., with "j"). Not used for scroll commands (e.g., CTRL-E, CTRL-D). Useful if your terminal scrolls very slowly. When set to a negative number from -1 to -100 this is used as the percentage of the window height. Thus -50 scrolls half the window height. NOTE: This option is set to 1 when 'compatible' is set.

Minimal number of screen lines to keep above and below the cursor. This will make some context visible around where you are working. If you set it to a very large value (999) the cursor line will always be in the middle of the window (except at the start or end of the file or when long lines wrap). After using the local value, go back the global value with one of these two: > setlocal scrolloff< setlocal scrolloff=-1 < For scrolling horizontally see 'sidescrolloff'. NOTE: This option is set to 0 when 'compatible' is set.

This is a comma-separated list of words that specifies how 'scrollbind' windows should behave. 'sbo' stands for ScrollBind Options. The following words are available: ver Bind vertical scrolling for 'scrollbind' windows hor Bind horizontal scrolling for 'scrollbind' windows jump Applies to the offset between two windows for vertical scrolling. This offset is the difference in the first displayed line of the bound windows. When moving around in a window, another 'scrollbind' window may reach a position before the start or after the end of the buffer. The offset is not changed though, when moving back the 'scrollbind' window will try to scroll to the desired position when possible. When now making that window the current one, two things can be done with the relative offset: 1. When "jump" is not included, the relative offset is adjusted for the scroll position in the new current window. When going back to the other window, the new relative offset will be used. 2. When "jump" is included, the other windows are scrolled to keep the same relative offset. When going back to the other window, it still uses the same relative offset. Also see |scroll-binding|. When 'diff' mode is active there always is vertical scroll binding, even when "ver" isn't there.

Specifies the nroff macros that separate sections. These are pairs of two letters (See |object-motions|). The default makes a section start at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh".

This option defines the behavior of the selection. It is only used in Visual and Select mode. Possible values: value past line inclusive ~ old no yes inclusive yes yes exclusive yes no "past line" means that the cursor is allowed to be positioned one character past the line. "inclusive" means that the last character of the selection is included in an operation. For example, when "x" is used to delete the selection. When "old" is used and 'virtualedit' allows the cursor to move past the end of line the line break still isn't included. Note that when "exclusive" is used and selecting from the end backwards, you cannot include the last character of a line, when starting in Normal mode and 'virtualedit' empty.

This is a comma separated list of words, which specifies when to start Select mode instead of Visual mode, when a selection is started. Possible values: mouse when using the mouse key when using shifted special keys cmd when using "v", "V" or CTRL-V See |Select-mode|. The 'selectmode' option is set by the |:behave| command.

{not available when compiled without the |+mksession| feature} Changes the effect of the |:mksession| command. It is a comma separated list of words. Each word enables saving and restoring something: word save and restore ~ blank empty windows buffers hidden and unloaded buffers, not just those in windows curdir the current directory folds manually created folds, opened/closed folds and local fold options globals global variables that start with an uppercase letter and contain at least one lowercase letter. Only String and Number types are stored. help the help window localoptions options and mappings local to a window or buffer (not global values for local options) options all options and mappings (also global values for local options) skiprtp exclude 'runtimepath' and 'packpath' from the options resize size of the Vim window: 'lines' and 'columns' sesdir the directory in which the session file is located will become the current directory (useful with projects accessed over a network from different systems) slash backslashes in file names replaced with forward slashes tabpages all tab pages; without this only the current tab page is restored, so that you can make a session for each tab page separately terminal include terminal windows where the command can be restored unix with Unix end-of-line format (single ), even when on Windows or DOS winpos position of the whole Vim window winsize window sizes

Name of the shell to use for ! and :! commands. When changing the value also check these options: 'shelltype', 'shellpipe', 'shellslash' 'shellredir', 'shellquote', 'shellxquote' and 'shellcmdflag'. It is allowed to give an argument to the command, e.g. "csh -f". See |option-backslash| about including spaces and backslashes. Environment variables are expanded |:set_env|.

Flag passed to the shell to execute "!" and ":!" commands; e.g., "bash.exe -c ls", "powershell.exe -Command dir", or "cmd.exe /c dir". For MS-Windows, the default is set according to the value of 'shell', to reduce the need to set this option by the user. On Unix it can have more than one flag. Each white space separated part is passed as an argument to the shell command. See |option-backslash| about including spaces and backslashes. Also see |dos-shell| and |dos-powershell| for MS-Windows. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+quickfix| feature} String to be used to put the output of the ":make" command in the error file. See also |:make_makeprg|. See |option-backslash| about including spaces and backslashes. The name of the temporary file can be represented by "%s" if necessary (the file name is appended automatically if no %s appears in the value of this option). For the Amiga the default is ">". For MS-Windows using powershell the default is "2>&1 | Out-File -Encoding default", otherwise the default is ">%s 2>&1". The output is directly saved in a file and not echoed to the screen. For Unix the default is "| tee". The stdout of the compiler is saved in a file and echoed to the screen. If the 'shell' option is "csh" or "tcsh" after initializations, the default becomes "|& tee". If the 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", "bash", "fish", "ash" or "dash" the default becomes "2>&1| tee". This means that stderr is also included. Before using the 'shell' option a path is removed, thus "/bin/sh" uses "sh". For Unix and MS-Windows, when the 'shell' option is "pwsh" the default becomes ">%s 2>&1" and the output is not echoed to the screen. The initialization of this option is done after reading the ".vimrc" and the other initializations, so that when the 'shell' option is set there, the 'shellpipe' option changes automatically, unless it was explicitly set before. When 'shellpipe' is set to an empty string, no redirection of the ":make" output will be done. This is useful if you use a 'makeprg' that writes to 'makeef' by itself. If you want no piping, but do want to include the 'makeef', set 'shellpipe' to a single space. Don't forget to precede the space with a backslash: ":set sp=\ ". In the future pipes may be used for filtering and this option will become obsolete (at least for Unix). This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Quoting character(s), put around the command passed to the shell, for the "!" and ":!" commands. The redirection is kept outside of the quoting. See 'shellxquote' to include the redirection. It's probably not useful to set both options. This is an empty string by default. Only known to be useful for third-party shells on MS-Windows-like systems, such as the MKS Korn Shell or bash, where it should be """. See |dos-shell|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

String to be used to put the output of a filter command in a temporary file. See also |:!|. See |option-backslash| about including spaces and backslashes. The name of the temporary file can be represented by "%s" if necessary (the file name is appended automatically if no %s appears in the value of this option). The default is ">". For Unix, if the 'shell' option is "csh" or "tcsh" during initializations, the default becomes ">&". If the 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", "bash", "fish", or "pwsh", the default becomes ">%s 2>&1". This means that stderr is also included. For Win32, the Unix checks are done and additionally "cmd" is checked for, which makes the default ">%s 2>&1", and "powershell" is checked for which makes the default "2>&1 | Out-File -Encoding default" (see |dos-powershell|). Also, the same names with ".exe" appended are checked for. The initialization of this option is done after reading the ".vimrc" and the other initializations, so that when the 'shell' option is set there, the 'shellredir' option changes automatically unless it was explicitly set before. In the future pipes may be used for filtering and this option will become obsolete (at least for Unix). This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only for MS-Windows} When set, a forward slash is used when expanding file names. This is useful when a Unix-like shell is used instead of cmd.exe, pwsh.exe, or powershell.exe. Backward slashes can still be typed, but they are changed to forward slashes by Vim. Note that setting or resetting this option has no effect for some existing file names, thus this option needs to be set before opening any file for best results. This might change in the future. 'shellslash' only works when a backslash can be used as a path separator. To test if this is so use: > if exists('+shellslash') < Also see 'completeslash'.

When on, use temp files for shell commands. When off use a pipe. When using a pipe is not possible temp files are used anyway. Currently a pipe is only supported on Unix and MS-Windows 2K and later. You can check it with: > :if has("filterpipe") < The advantage of using a pipe is that nobody can read the temp file and the 'shell' command does not need to support redirection. The advantage of using a temp file is that the file type and encoding can be detected. The |FilterReadPre|, |FilterReadPost| and |FilterWritePre|, |FilterWritePost| autocommands event are not triggered when 'shelltemp' is off. The system() function does not respect this option and always uses temp files. NOTE: This option is set to the Vim default value when 'compatible' is reset.

When 'shellxquote' is set to "(" then the characters listed in this option will be escaped with a '^' character. This makes it possible to execute most external commands with cmd.exe.

Quoting character(s), put around the command passed to the shell, for the "!" and ":!" commands. Includes the redirection. See 'shellquote' to exclude the redirection. It's probably not useful to set both options. When the value is '(' then ')' is appended. When the value is '"(' then ')"' is appended. When the value is '(' then also see 'shellxescape'. This is an empty string by default on most systems, but is known to be useful for on Win32 version, either for cmd.exe, powershell.exe, or pwsh.exe which automatically strips off the first and last quote on a command, or 3rd-party shells such as the MKS Korn Shell or bash, where it should be """. The default is adjusted according the value of 'shell', to reduce the need to set this option by the user. See |dos-shell|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

Round indent to multiple of 'shiftwidth'. Applies to > and < commands. CTRL-T and CTRL-D in Insert mode always round the indent to a multiple of 'shiftwidth' (this is Vi compatible). NOTE: This option is reset when 'compatible' is set.

Number of spaces to use for each step of (auto)indent. Used for |'cindent'|, |>>|, |<<|, etc. When zero the 'ts' value will be used. Use the |shiftwidth()| function to get the effective shiftwidth value.

This option helps to avoid all the |hit-enter| prompts caused by file messages, for example with CTRL-G, and to avoid some other messages. It is a list of flags: flag meaning when present ~ f use "(3 of 5)" instead of "(file 3 of 5)" i use "[noeol]" instead of "[Incomplete last line]" l use "999L, 888B" instead of "999 lines, 888 bytes" m use "[+]" instead of "[Modified]" n use "[New]" instead of "[New File]" r use "[RO]" instead of "[readonly]" w use "[w]" instead of "written" for file write message and "[a]" instead of "appended" for ':w >> file' command x use "[dos]" instead of "[dos format]", "[unix]" instead of "[unix format]" and "[mac]" instead of "[mac format]". a all of the above abbreviations

{not available when compiled without the |+linebreak| feature} String to put at the start of lines that have been wrapped. Useful values are "> " or "+++ ": > :set showbreak=>
< Note the backslash to escape the trailing space. It's easier like this: > :let &showbreak = '+++ ' < Only printable single-cell characters are allowed, excluding and comma (in a future version the comma might be used to separate the part that is shown at the end and at the start of a line). The characters are highlighted according to the '@' flag in 'highlight'. Note that tabs after the showbreak will be displayed differently. If you want the 'showbreak' to appear in between line numbers, add the "n" flag to 'cpoptions'. A window-local value overrules a global value. If the global value is set and you want no value in the current window use NONE: > :setlocal showbreak=NONE <

{not available when compiled without the |+cmdline_info| feature} Show (partial) command in the last line of the screen. Set this option off if your terminal is slow. In Visual mode the size of the selected area is shown:

• When selecting characters within a line, the number of characters. If the number of bytes is different it is also displayed: "2-6" means two characters and six bytes.
• When selecting more than one line, the number of lines.
• When selecting a block, the size in screen characters: {lines}x{columns}. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

When completing a word in insert mode (see |ins-completion|) from the tags file, show both the tag name and a tidied-up form of the search pattern (if there is one) as possible matches. Thus, if you have matched a C function, you can see a template for what arguments are required (coding style permitting). Note that this doesn't work well together with having "longest" in 'completeopt', because the completion from the search pattern may not match the typed text.

When a bracket is inserted, briefly jump to the matching one. The jump is only done if the match can be seen on the screen. The time to show the match can be set with 'matchtime'. A Beep is given if there is no match (no matter if the match can be seen or not). This option is reset when 'paste' is set and restored when 'paste' is reset. When the 'm' flag is not included in 'cpoptions', typing a character will immediately move the cursor back to where it belongs. See the "sm" field in 'guicursor' for setting the cursor shape and blinking when showing the match. The 'matchpairs' option can be used to specify the characters to show matches for. 'rightleft' and 'revins' are used to look for opposite matches. Also see the matchparen plugin for highlighting the match when moving around |pi_paren.txt|. Note: Use of the short form is rated PG.

If in Insert, Replace or Visual mode put a message on the last line. Use the 'M' flag in 'highlight' to set the type of highlighting for this message. When |XIM| may be used the message will include "XIM". But this doesn't mean XIM is really active, especially when 'imactivatekey' is not set. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The value of this option specifies when the line with tab page labels will be displayed: 0: never 1: only if there are at least two tab pages 2: always This is both for the GUI and non-GUI implementation of the tab pages line. See |tab-page| for more information about tab pages.

The minimal number of columns to scroll horizontally. Used only when the 'wrap' option is off and the cursor is moved off of the screen. When it is zero the cursor will be put in the middle of the screen. When using a slow terminal set it to a large number or 0. When using a fast terminal use a small number or 1. Not used for "zh" and "zl" commands.

The minimal number of screen columns to keep to the left and to the right of the cursor if 'nowrap' is set. Setting this option to a value greater than 0 while having |'sidescroll'| also at a non-zero value makes some context visible in the line you are scrolling in horizontally (except at beginning of the line). Setting this option to a large value (like 999) has the effect of keeping the cursor horizontally centered in the window, as long as one does not come too close to the beginning of the line. After using the local value, go back the global value with one of these two: > setlocal sidescrolloff< setlocal sidescrolloff=-1 < NOTE: This option is set to 0 when 'compatible' is set.

{not available when compiled without the |+signs| feature} Whether or not to draw the signcolumn. Valid values are: "auto" only when there is a sign to display "no" never "yes" always "number" display signs in the 'number' column. If the number column is not present, then behaves like "auto".

Override the 'ignorecase' option if the search pattern contains upper case characters. Only used when the search pattern is typed and 'ignorecase' option is on. Used for the commands "/", "?", "n", "N", ":g" and ":s". Not used for "", "#", "gd", tag search, etc. After "" and "#" you can make 'smartcase' used by doing a "/" command, recalling the search pattern from history and hitting . NOTE: This option is reset when 'compatible' is set.

{not available when compiled without the |+smartindent| feature} Do smart autoindenting when starting a new line. Works for C-like programs, but can also be used for other languages. 'cindent' does something like this, works better in most cases, but is more strict, see |C-indenting|. When 'cindent' is on or 'indentexpr' is set, setting 'si' has no effect. 'indentexpr' is a more advanced alternative. Normally 'autoindent' should also be on when using 'smartindent'. An indent is automatically inserted:

• After a line ending in '{'.
• After a line starting with a keyword from 'cinwords'.
• Before a line starting with '}' (only with the "O" command). When typing '}' as the first character in a new line, that line is given the same indent as the matching '{'. When typing '#' as the first character in a new line, the indent for that line is removed, the '#' is put in the first column. The indent is restored for the next line. If you don't want this, use this mapping: ":inoremap # X^H#", where ^H is entered with CTRL-V CTRL-H. When using the ">>" command, lines starting with '#' are not shifted right. NOTE: This option is reset when 'compatible' is set. This option is reset when 'paste' is set and restored when 'paste' is reset.

When on, a in front of a line inserts blanks according to 'shiftwidth'. 'tabstop' or 'softtabstop' is used in other places. A will delete a 'shiftwidth' worth of space at the start of the line. When off, a always inserts blanks according to 'tabstop' or 'softtabstop'. 'shiftwidth' is only used for shifting text left or right |shift-left-right|. What gets inserted (a or spaces) depends on the 'expandtab' option. Also see |ins-expandtab|. When 'expandtab' is not set, the number of spaces is minimized by using s. This option is reset when 'paste' is set and restored when 'paste' is reset. NOTE: This option is reset when 'compatible' is set.

Number of spaces that a counts for while performing editing operations, like inserting a or using . It "feels" like s are being inserted, while in fact a mix of spaces and s is used. This is useful to keep the 'ts' setting at its standard value of 8, while being able to edit like it is set to 'sts'. However, commands like "x" still work on the actual characters. When 'sts' is zero, this feature is off. When 'sts' is negative, the value of 'shiftwidth' is used. 'softtabstop' is set to 0 when the 'paste' option is set and restored when 'paste' is reset. See also |ins-expandtab|. When 'expandtab' is not set, the number of spaces is minimized by using s. The 'L' flag in 'cpoptions' changes how tabs are used when 'list' is set. NOTE: This option is set to 0 when 'compatible' is set.

{not available when compiled without the |+syntax| feature} Pattern to locate the end of a sentence. The following word will be checked to start with a capital letter. If not then it is highlighted with SpellCap |hl-SpellCap| (unless the word is also badly spelled). When this check is not wanted make this option empty. Only used when 'spell' is set. Be careful with special characters, see |option-backslash| about including spaces and backslashes. To set this option automatically depending on the language, see |set-spc-auto|.

{not available when compiled without the |+syntax| feature} Name of the word list file where words are added for the |zg| and |zw| commands. It must end in ".{encoding}.add". You need to include the path, otherwise the file is placed in the current directory. It may also be a comma separated list of names. A count before the |zg| and |zw| commands can be used to access each. This allows using a personal word list file and a project word list file. When a word is added while this option is empty Vim will set it for you: Using the first directory in 'runtimepath' that is writable. If there is no "spell" directory yet it will be created. For the file name the first language name that appears in 'spelllang' is used, ignoring the region. The resulting ".spl" file will be used for spell checking, it does not have to appear in 'spelllang'. Normally one file is used for all regions, but you can add the region name if you want to. However, it will then only be used when 'spellfile' is set to it, for entries in 'spelllang' only files without region name will be found. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+syntax| feature} A comma separated list of word list names. When the 'spell' option is on spellchecking will be done for these languages. Example: > set spelllang=en_us,nl,medical < This means US English, Dutch and medical words are recognized. Words that are not recognized will be highlighted. The word list name must consist of alphanumeric characters, a dash or an underscore. It should not include a comma or dot. Using a dash is recommended to separate the two letter language name from a specification. Thus "en-rare" is used for rare English words. A region name must come last and have the form "_xx", where "xx" is the two-letter, lower case region name. You can use more than one region by listing them: "en_us,en_ca" supports both US and Canadian English, but not words specific for Australia, New Zealand or Great Britain. (Note: currently en_au and en_nz dictionaries are older than en_ca, en_gb and en_us). If the name "cjk" is included East Asian characters are excluded from spell checking. This is useful when editing text that also has Asian words. Note that the "medical" dictionary does not exist, it is just an example of a longer name. As a special case the name of a .spl file can be given as-is. The first "_xx" in the name is removed and used as the region name (_xx is an underscore, two letters and followed by a non-letter). This is mainly for testing purposes. You must make sure the correct encoding is used, Vim doesn't check it. When 'encoding' is set the word lists are reloaded. Thus it's a good idea to set 'spelllang' after setting 'encoding' to avoid loading the files twice. How the related spell files are found is explained here: |spell-load|.

{not available when compiled without the |+syntax| feature} A comma separated list of options for spell checking: camel When a word is CamelCased, assume "Cased" is a separate word: every upper-case character in a word that comes after a lower case character indicates the start of a new word.

{not available when compiled without the |+syntax| feature} Methods used for spelling suggestions. Both for the |z=| command and the |spellsuggest()| function. This is a comma-separated list of items:

When on, splitting a window will put the new window below the current one. |:split|

When on, splitting a window will put the new window right of the current one. |:vsplit|

When "on" the commands listed below move the cursor to the first non-blank of the line. When off the cursor is kept in the same column (if possible). This applies to the commands: CTRL-D, CTRL-U, CTRL-B, CTRL-F, "G", "H", "M", "L", gg, and to the commands "d", "<<" and ">>" with a linewise operator, with "%" with a count and to buffer changing commands (CTRL-^, :bnext, :bNext, etc.). Also for an Ex command that only has a line number, e.g., ":25" or ":+". In case of buffer changing commands the cursor is placed at the column where it was the last time the buffer was edited. NOTE: This option is set when 'compatible' is set.

{not available when compiled without the |+statusline| feature} When nonempty, this option determines the content of the status line. Also see |status-line|.

Files with these suffixes get a lower priority when multiple files match a wildcard. See |suffixes|. Commas can be used to separate the suffixes. Spaces after the comma are ignored. A dot is also seen as the start of a suffix. To avoid a dot or comma being recognized as a separator, precede it with a backslash (see |option-backslash| about including spaces and backslashes). See 'wildignore' for completely ignoring files. The use of |:set+=| and |:set-=| is preferred when adding or removing suffixes from the list. This avoids problems when a future version uses another default.

{not available when compiled without the |+file_in_path| feature} Comma separated list of suffixes, which are used when searching for a file for the "gf", "[I", etc. commands. Example: > :set suffixesadd=.java <

Use a swapfile for the buffer. This option can be reset when a swapfile is not wanted for a specific buffer. For example, with confidential information that even root must not be able to access. Careful: All text will be in memory: - Don't use this for big files. - Recovery will be impossible! A swapfile will only be present when |'updatecount'| is non-zero and 'swapfile' is set. When 'swapfile' is reset, the swap file for the current buffer is immediately deleted. When 'swapfile' is set, and 'updatecount' is non-zero, a swap file is immediately created. Also see |swap-file| and |'swapsync'|. If you want to open a new buffer without creating a swap file for it, use the |:noswapfile| modifier. See 'directory' for where the swap file is created.

This option controls the behavior when switching between buffers. Mostly for |quickfix| commands some values are also used for other commands, as mentioned below. Possible values (comma separated list): useopen If included, jump to the first open window that contains the specified buffer (if there is one). Otherwise: Do not examine other windows. This setting is checked with |quickfix| commands, when jumping to errors (":cc", ":cn", "cp", etc.). It is also used in all buffer related split commands, for example ":sbuffer", ":sbnext", or ":sbrewind". usetab Like "useopen", but also consider windows in other tab pages. split If included, split the current window before loading a buffer for a |quickfix| command that display errors. Otherwise: do not split, use current window (when used in the quickfix window: the previously used window or split if there is no other window). vsplit Just like "split" but split vertically. newtab Like "split", but open a new tab page. Overrules "split" when both are present. uselast If included, jump to the previously used window when jumping to errors with |quickfix| commands.

{not available when compiled without the |+syntax| feature} Maximum column in which to search for syntax items. In long lines the text after this column is not highlighted and following lines may not be highlighted correctly, because the syntax state is cleared. This helps to avoid very slow redrawing for an XML file that is one long line. Set to zero to remove the limit.

{not available when compiled without the |+syntax| feature} When this option is set, the syntax with this name is loaded, unless syntax highlighting has been switched off with ":syntax off". Otherwise this option does not always reflect the current syntax (the b:current_syntax variable does). This option is most useful in a modeline, for a file which syntax is not automatically recognized. Example, in an IDL file: // ~ When a dot appears in the value then this separates two filetype names. Example: // ~ This will use the "c" syntax first, then the "doxygen" syntax. Note that the second one must be prepared to be loaded as an addition, otherwise it will be skipped. More than one dot may appear. To switch off syntax highlighting for the current file, use: > :set syntax=OFF < To switch syntax highlighting on according to the current value of the 'filetype' option: > :set syntax=ON < What actually happens when setting the 'syntax' option is that the Syntax autocommand event is triggered with the value as argument. This option is not copied to another buffer, independent of the 's' or 'S' flag in 'cpoptions'. Only normal file name characters can be used, "/*?[|<>" are illegal.

When nonempty, this option determines the content of the tab pages line at the top of the Vim window. When empty Vim will use a default tab pages line. See |setting-tabline| for more info.

Maximum number of tab pages to be opened by the |-p| command line argument or the ":tab all" command. |tabpage|

Number of spaces that a in the file counts for. Also see |:retab| command, and 'softtabstop' option.

When searching for a tag (e.g., for the |:ta| command), Vim can either use a binary search or a linear search in a tags file. Binary searching makes searching for a tag a LOT faster, but a linear search will find more tags if the tags file wasn't properly sorted. Vim normally assumes that your tags files are sorted, or indicate that they are not sorted. Only when this is not the case does the 'tagbsearch' option need to be switched off.

This option specifies how case is handled when searching the tags file: followic Follow the 'ignorecase' option followscs Follow the 'smartcase' and 'ignorecase' options ignore Ignore case match Match case smart Ignore case unless an upper case letter is used NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

{not available when compiled without the |+eval| feature} This option specifies a function to be used to perform tag searches. The function gets the tag pattern and should return a List of matching tags. See |tag-function| for an explanation of how to write the function and an example.

If non-zero, tags are significant up to this number of characters.

If on and using a tags file in another directory, file names in that tags file are relative to the directory where the tags file is. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

Filenames for the tag command, separated by spaces or commas. To include a space or comma in a file name, precede it with a backslash (see |option-backslash| about including spaces and backslashes). When a file name starts with "./", the '.' is replaced with the path of the current file. But only when the 'd' flag is not included in 'cpoptions'. Environment variables are expanded |:set_env|. Also see |tags-option|. "*" and other wildcards can be used to search for tags files in a directory tree. See |file-searching|. E.g., "/lib/** /tags" will find all files named "tags" below "/lib". The filename itself cannot contain wildcards, it is used as-is. E.g., "/lib/** /tags?" will find files called "tags?". {not available when compiled without the |+path_extra| feature} The |tagfiles()| function can be used to get a list of the file names actually used. If Vim was compiled with the |+emacs_tags| feature, Emacs-style tag files are also supported. They are automatically recognized. The default value becomes "./tags,./TAGS,tags,TAGS", unless case differences are ignored (MS-Windows). |emacs-tags| The use of |:set+=| and |:set-=| is preferred when adding or removing file names from the list. This avoids problems when a future version uses another default.

When on, the |tagstack| is used normally. When off, a ":tag" or ":tselect" command with an argument will not push the tag onto the tagstack. A following ":tag" without an argument, a ":pop" command or any other command that uses the tagstack will use the unmodified tagstack, but does change the pointer to the active entry. Resetting this option is useful when using a ":tag" command in a mapping which should not change the tagstack.

{only available when compiled with the |+arabic| feature} The terminal is in charge of Bi-directionality of text (as specified by Unicode). The terminal is also expected to do the required shaping that some languages (such as Arabic) require. Setting this option implies that 'rightleft' will not be set when 'arabic' is set and the value of 'arabicshape' will be ignored. Note that setting 'termbidi' has the immediate effect that 'arabicshape' is ignored, but 'rightleft' isn't changed automatically. This option is reset when the GUI is started. For further details see |arabic.txt|.

{not available when compiled without the |+termguicolors| feature} When on, uses |highlight-guifg| and |highlight-guibg| attributes in the terminal (thus using 24-bit color).

Maximum width of text that is being inserted. A longer line will be broken after white space to get this width. A zero value disables this. 'textwidth' is set to 0 when the 'paste' option is set and restored when 'paste' is reset. When 'textwidth' is zero, 'wrapmargin' may be used. See also 'formatoptions' and |ins-textwidth|. When 'formatexpr' is set it will be used to break the line. NOTE: This option is set to 0 when 'compatible' is set.

List of file names, separated by commas, that are used to lookup words for thesaurus completion commands |i_CTRL-X_CTRL-T|.

When on: The tilde command "~" behaves like an operator. NOTE: This option is reset when 'compatible' is set.

global

global

The time in milliseconds that is waited for a key code or mapped key sequence to complete. Also used for CTRL-\ CTRL-N and CTRL-\ CTRL-G when part of a command has been typed. Normally only 'timeoutlen' is used and 'ttimeoutlen' is -1. When a different timeout value for key codes is desired set 'ttimeoutlen' to a non-negative number.

Indicates a fast terminal connection. More characters will be sent to the screen for redrawing, instead of using insert/delete line commands. Improves smoothness of redrawing when there are multiple windows and the terminal does not support a scrolling region. Also enables the extra writing of characters at the end of each screen line for lines that wrap. This helps when using copy/paste with the mouse in an xterm and other terminals.

{only when compiled with the |+persistent_undo| feature} List of directory names for undo files, separated with commas. See |'backupdir'| for details of the format. "." means using the directory of the file. The undo file name for "file.txt" is ".file.txt.un~". For other directories the file name is the full path of the edited file, with path separators replaced with "%". When writing: The first directory that exists is used. "." always works, no directories after "." will be used for writing. When reading all entries are tried to find an undo file. The first undo file that exists is used. When it cannot be read an error is given, no further entry is used. See |undo-persistence|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{only when compiled with the |+persistent_undo| feature} When on, Vim automatically saves undo history to an undo file when writing a buffer to a file, and restores undo history from the same file on buffer read. The directory where the undo file is stored is specified by 'undodir'. For more information about this feature see |undo-persistence|. The undo file is not read when 'undoreload' causes the buffer from before a reload to be saved for undo. When 'undofile' is turned off the undo file is NOT deleted. NOTE: This option is reset when 'compatible' is set.

Maximum number of changes that can be undone. Since undo information is kept in memory, higher numbers will cause more memory to be used. Nevertheless, a single change can already use a large amount of memory. Set to 0 for Vi compatibility: One level of undo and "u" undoes itself: > set ul=0 < But you can also get Vi compatibility by including the 'u' flag in 'cpoptions', and still be able to use CTRL-R to repeat undo. Also see |undo-two-ways|. Set to -1 for no undo at all. You might want to do this only for the current buffer: > setlocal ul=-1 < This helps when you run out of memory for a single change.

Save the whole buffer for undo when reloading it. This applies to the ":e!" command and reloading for when the buffer changed outside of Vim. |FileChangedShell| The save only happens when this option is negative or when the number of lines is smaller than the value of this option. Set this option to zero to disable undo for a reload.

After typing this many characters the swap file will be written to disk. When zero, no swap file will be created at all (see chapter on recovery |crash-recovery|). 'updatecount' is set to zero by starting Vim with the "-n" option, see |startup|. When editing in readonly mode this option will be initialized to 10000. The swapfile can be disabled per buffer with |'swapfile'|. When 'updatecount' is set from zero to non-zero, swap files are created for all buffers that have 'swapfile' set. When 'updatecount' is set to zero, existing swap files are not deleted. Also see |'swapsync'|. This option has no meaning in buffers where |'buftype'| is "nofile" or "nowrite".

If this many milliseconds nothing is typed the swap file will be written to disk (see |crash-recovery|). Also used for the |CursorHold| autocommand event.

{only available when compiled with the |+vartabs| feature} A list of the number of spaces that a counts for while editing, such as inserting a or using . It "feels" like variable- width s are being inserted, while in fact a mixture of spaces and s is used. Tab widths are separated with commas, with the final value applying to all subsequent tabs.

{only available when compiled with the |+vartabs| feature} A list of the number of spaces that a in the file counts for, separated by commas. Each value corresponds to one tab, with the final value applying to all subsequent tabs. For example: > :set vartabstop=4,20,10,8 < This will make the first tab 4 spaces wide, the second 20 spaces, the third 10 spaces, and all following tabs 8 spaces.

When bigger than zero, Vim will give messages about what it is doing. Currently, these messages are given:

= 1 When the viminfo file is read or written. = 2 When a file is ":source"'ed. = 4 Shell commands. = 5 Every searched tags file and include file. = 8 Files for which a group of autocommands is executed. = 9 Every executed autocommand. = 11 Finding items in a path = 12 Every executed function. = 13 When an exception is thrown, caught, finished, or discarded. = 14 Anything pending in a ":finally" clause. = 15 Every executed Ex command from a script (truncated at 200 characters). = 16 Every executed Ex command.

When not empty all messages are written in a file with this name. When the file exists messages are appended. Writing to the file ends when Vim exits or when 'verbosefile' is made empty. Writes are buffered, thus may not show up for some time. Setting 'verbosefile' to a new value is like making it empty first. The difference with |:redir| is that verbose messages are not displayed when 'verbosefile' is set.

{not available when compiled without the |+mksession| feature} Name of the directory where to store files for |:mkview|. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons.

{not available when compiled without the |+mksession| feature} Changes the effect of the |:mkview| command. It is a comma separated list of words. Each word enables saving and restoring something: word save and restore ~ cursor cursor position in file and in window folds manually created folds, opened/closed folds and local fold options options options and mappings local to a window or buffer (not global values for local options) localoptions same as "options" slash backslashes in file names replaced with forward slashes unix with Unix end-of-line format (single ), even when on MS-Windows curdir the window-local directory, if set with :lcd

A comma separated list of these words: block Allow virtual editing in Visual block mode. insert Allow virtual editing in Insert mode. all Allow virtual editing in all modes. onemore Allow the cursor to move just past the end of the line none When used as the local value, do not allow virtual editing even when the global value is set. When used as the global value, "none" is the same as "". NONE Alternative spelling of "none".

Use a visual bell instead of beeping. The terminal code to display the visual bell is given with 't_vb'. When no beep or flash is wanted, use: > :set vb t_vb= < If you want a short flash, you can use this on many terminals: > :set vb t_vb=[?5h$<100>[?5l < Here $<100> specifies the time, you can use a smaller or bigger value to get a shorter or longer flash.

Allow specified keys that move the cursor left/right to move to the previous/next line when the cursor is on the first/last character in the line. Concatenate characters to allow this for these keys: char key mode ~ b Normal and Visual s Normal and Visual h "h" Normal and Visual (not recommended) l "l" Normal and Visual (not recommended) < Normal and Visual > Normal and Visual ~ "~" Normal [ Insert and Replace ] Insert and Replace For example: > :set ww=<,>,[,] < allows wrap only when cursor keys are used. When the movement keys are used in combination with a delete or change operator, the also counts for a character. This makes "3h" different from "3dh" when the cursor crosses the end of a line. This is also true for "x" and "X", because they do the same as "dl" and "dh". If you use this, you may also want to use the mapping ":map X" to make backspace delete the character in front of the cursor. When 'l' is included and it is used after an operator at the end of a line (not an empty line) then it will not move to the next line. This makes "dl", "cl", "yl" etc. work normally. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

Character you have to type to start wildcard expansion in the command-line, as specified with 'wildmode'. More info here: |cmdline-completion|. The character is not recognized when used inside a macro. See 'wildcharm' for that. Although 'wc' is a number option, you can set it to a special key: > :set wc= < NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

'wildcharm' works exactly like 'wildchar', except that it is recognized when used inside a macro. You can find "spare" command-line keys suitable for this option by looking at |ex-edit-index|. Normally you'll never actually type 'wildcharm', just use it in mappings that automatically invoke completion mode, e.g.: > :set wcm= :cnoremap ss so $vim/sessions/*.vim < Then after typing :ss you can use CTRL-P & CTRL-N.

{not available when compiled without the |+wildignore| feature} A list of file patterns. A file that matches with one of these patterns is ignored when expanding |wildcards|, completing file or directory names, and influences the result of |expand()|, |glob()| and |globpath()| unless a flag is passed to disable this. The pattern is used like with |:autocmd|, see |autocmd-patterns|. Also see 'suffixes'. Example: > :set wildignore=.obj < The use of |:set+=| and |:set-=| is preferred when adding or removing a pattern from the list. This avoids problems when a future version uses another default.

When set case is ignored when completing file names and directories. Has no effect when 'fileignorecase' is set. Does not apply when the shell is used to expand wildcards, which happens when there are special characters.

{not available if compiled without the |+wildmenu| feature} When 'wildmenu' is on, command-line completion operates in an enhanced mode. On pressing 'wildchar' (usually ) to invoke completion, the possible matches are shown just above the command line, with the first match highlighted (overwriting the status line, if there is one). Keys that show the previous/next match, such as or CTRL-P/CTRL-N, cause the highlight to move to the appropriate match. When 'wildmode' is used, "wildmenu" mode is used where "full" is specified. "longest" and "list" do not start "wildmenu" mode. You can check the current mode with |wildmenumode()|. If there are more matches than can fit in the line, a ">" is shown on the right and/or a "<" is shown on the left. The status line scrolls as needed. The "wildmenu" mode is abandoned when a key is hit that is not used for selecting a completion. While the "wildmenu" is active the following keys have special meanings:

Completion mode that is used for the character specified with 'wildchar'. It is a comma separated list of up to four parts. Each part specifies what to do for each consecutive use of 'wildchar'. The first part specifies the behavior for the first use of 'wildchar', The second part for the second use, etc.

{not available when compiled without the |+wildignore| feature} A list of words that change how command line completion is done. Currently only one word is allowed: tagfile When using CTRL-D to list matching tags, the kind of tag and the file of the tag is listed. Only one match is displayed per line. Often used tag kinds are: d #define f function Also see |cmdline-completion|.

{only used in Win32, Motif, GTK and Photon GUI} Some GUI versions allow the access to menu entries by using the ALT key in combination with a character that appears underlined in the menu. This conflicts with the use of the ALT key for mappings and entering special characters. This option tells what to do: no Don't use ALT keys for menus. ALT key combinations can be mapped, but there is no automatic handling. This can then be done with the |:simalt| command. yes ALT key handling is done by the windowing system. ALT key combinations cannot be mapped. menu Using ALT in combination with a character that is a menu shortcut key, will be handled by the windowing system. Other keys can be mapped. If the menu is disabled by excluding 'm' from 'guioptions', the ALT key is never used for the menu. This option is not used for ; on Win32 and with GTK will select the menu, unless it has been mapped.

Window height used for |CTRL-F| and |CTRL-B| when there is only one window and the value is smaller than 'lines' minus one. The screen will scroll 'window' minus two lines, with a minimum of one. When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll in a much smarter way, taking care of wrapping lines. When resizing the Vim window, the value is smaller than 1 or more than or equal to 'lines' it will be set to 'lines' minus 1. Note: Do not confuse this with the height of the Vim window, use 'lines' for that.

Keep the window height when windows are opened or closed and 'equalalways' is set. Also for |CTRL-W_=|. Set by default for the |preview-window| and |quickfix-window|. The height may be changed anyway when running out of room.

Keep the window width when windows are opened or closed and 'equalalways' is set. Also for |CTRL-W_=|. The width may be changed anyway when running out of room.

Minimal number of lines for the current window. This is not a hard minimum, Vim will use fewer lines if there is not enough room. If the focus goes to a window that is smaller, its size is increased, at the cost of the height of other windows. Set 'winheight' to a small number for normal editing. Set it to 999 to make the current window fill most of the screen. Other windows will be only 'winminheight' high. This has the drawback that ":all" will create only two windows. To avoid "vim -o 1 2 3 4" to create only two windows, set the option after startup is done, using the |VimEnter| event: > au VimEnter * set winheight=999 < Minimum value is 1. The height is not adjusted after one of the commands that change the height of the current window. 'winheight' applies to the current window. Use 'winminheight' to set the minimal height for other windows.

The minimal height of a window, when it's not the current window. This is a hard minimum, windows will never become smaller. When set to zero, windows may be "squashed" to zero lines (i.e. just a status bar) if necessary. They will return to at least one line when they become active (since the cursor has to have somewhere to go.) Use 'winheight' to set the minimal height of the current window. This option is only checked when making a window smaller. Don't use a large number, it will cause errors when opening more than a few windows. A value of 0 to 3 is reasonable.

The minimal width of a window, when it's not the current window. This is a hard minimum, windows will never become smaller. When set to zero, windows may be "squashed" to zero columns (i.e. just a vertical separator) if necessary. They will return to at least one line when they become active (since the cursor has to have somewhere to go.) Use 'winwidth' to set the minimal width of the current window. This option is only checked when making a window smaller. Don't use a large number, it will cause errors when opening more than a few windows. A value of 0 to 12 is reasonable.

Minimal number of columns for the current window. This is not a hard minimum, Vim will use fewer columns if there is not enough room. If the current window is smaller, its size is increased, at the cost of the width of other windows. Set it to 999 to make the current window always fill the screen. Set it to a small number for normal editing. The width is not adjusted after one of the commands to change the width of the current window. 'winwidth' applies to the current window. Use 'winminwidth' to set the minimal width for other windows.

Number of characters from the right window border where wrapping starts. When typing text beyond this limit, an will be inserted and inserting continues on the next line. Options that add a margin, such as 'number' and 'foldcolumn', cause the text width to be further reduced. This is Vi compatible. When 'textwidth' is non-zero, this option is not used. This option is set to 0 when 'paste' is set and restored when 'paste' is reset. See also 'formatoptions' and |ins-textwidth|.

Searches wrap around the end of the file. Also applies to |]s| and |[s|, searching for spelling mistakes.

Allows writing to any file with no need for "!" override.

Make a backup before overwriting a file. The backup is removed after the file was successfully written, unless the 'backup' option is also on. WARNING: Switching this option off means that when Vim fails to write your buffer correctly and then, for whatever reason, Vim exits, you lose both the original file and what you were writing. Only reset this option if your file system is almost full and it makes the write fail (and make sure not to exit Vim until the write was successful). See |backup-table| for another explanation. When the 'backupskip' pattern matches, a backup is not made anyway. Depending on 'backupcopy' the backup is a new file or the original file renamed (and a new file is written). NOTE: This option is set to the default value when 'compatible' is set.

The number of milliseconds to wait for each character sent to the screen. When non-zero, characters are sent to the terminal one by one. For debugging purposes.

Buffer local variables

Environment variables

Global options

Global variables

Local options

Options

Register

Tabpage local variables

Vim variables

Window local variables

Make an assertion that actual and expected are equal, deeply. If not deeply equal, then throw.

Perform batch call

Create a promise which will be rejected with DeadlineError when a given delay is exceeded.

Echo message as like echo on Vim script.

Return x as-is if x is array or raise an EnsureError when it's not.

Return x as-is if x is object or raise an EnsureError when it's not.

Return x as-is if x is string or raise an EnsureError when it's not.

Deep equality comparison used in assertions

Execute Vim script directly

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. {lnum} is used like with |getline()|. 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)

Like |append()| but append the text in buffer {buf}. This function works only for loaded buffers. First call |bufload()| if needed. For the use of {buf}, see |bufname()|. {lnum} is used like with |append()|. Note that using |line()| would use the current buffer, not the one appending to. Use "$" to append at the end of the buffer. On success 0 is returned, on failure 1 is returned. If {buf} is not a valid buffer or {lnum} is not valid, an error message is given. Example: :let failed = appendbufline(13, 0, "# THE START") Can also be used as a |method| after a List, the base is passed as the second argument: mylist->appendbufline(buf, 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()->atan2(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}

Return byte index of the {nr}'th character in the String {expr}. Use zero for the first character, it then returns zero. If there are no multibyte characters the returned value is equal to {nr}. Composing characters are not counted separately, their byte length is added to the preceding base character. See |byteidxcomp()| below for counting composing characters separately. Example : echo matchstr(str, ".", byteidx(str, 3)) will display the fourth character. Another way to do the same: let s = strpart(str, byteidx(str, 3)) echo strpart(s, 0, byteidx(s, 1)) Also see |strgetchar()| and |strcharpart()|. If there are less than {nr} characters -1 is returned. If there are exactly {nr} characters the length of the string in bytes is returned. Can also be used as a |method|: GetName()->byteidx(idx)

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 {string}. 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()

Return the character index of the byte at {idx} in {string}. The index of the first character is zero. If there are no multibyte characters the returned value is equal to {idx}. When {countcc} is omitted or |FALSE|, then composing characters are not counted separately, their byte length is added to the preceding base character. When {countcc} is |TRUE|, then composing characters are counted as separate characters. Returns -1 if the arguments are invalid or if {idx} is greater than the index of the last byte in {string}. An error is given if the first argument is not a string, the second argument is not a number or when the third argument is present and is not zero or one. See |byteidx()| and |byteidxcomp()| for getting the byte index from the character index. Examples: echo charidx('áb́ć', 3) returns 1 echo charidx('áb́ć', 6, 1) returns 4 echo charidx('áb́ć', 16) returns -1 Can also be used as a |method|: GetName()->charidx(idx)

Change the current working directory to {dir}. The scope of the directory change depends on the directory of the current window: - If the current window has a window-local directory (|:lcd|), then changes the window local directory. - Otherwise, if the current tabpage has a local directory (|:tcd|) then changes the tabpage local directory. - Otherwise, changes the global directory. {dir} must be a String. If successful, returns the previous working directory. Pass this to another chdir() to restore the directory. On failure, returns an empty string. Example: let save_dir = chdir(newdir) if save_dir != "" " ... do some work call chdir(save_dir) endif Can also be used as a |method|: GetDir()->chdir()

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()

Set the matches for Insert mode completion. Can only be used in Insert mode. You need to use a mapping with CTRL-R = (see |i_CTRL-R|). It does not work after CTRL-O or with an expression mapping. {startcol} is the byte offset in the line where the completed text start. The text up to the cursor is the original text that will be replaced by the matches. Use col('.') for an empty string. "col('.') - 1" will replace one character by a match. {matches} must be a |List|. Each |List| item is one match. See |complete-items| for the kind of items that are possible. "longest" in 'completeopt' is ignored. Note that the after calling this function you need to avoid inserting anything that would cause completion to stop. The match can be selected with CTRL-N and CTRL-P as usual with Insert mode completion. The popup menu will appear if specified, see |ins-completion-menu|. Example: inoremap =ListMonths()<CR func! ListMonths() call complete(col('.'), ['January', 'February', 'March', \ 'April', 'May', 'June', 'July', 'August', 'September', \ 'October', 'November', 'December']) return '' endfunc This isn't very useful, but it shows how it works. Note that an empty string is returned to avoid a zero being inserted. Can also be used as a |method|, the base is passed as the second argument: GetMatches()->complete(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.

Returns a |Dictionary| with information about Insert mode completion. See |ins-completion|. The items are: mode Current completion mode name string. See |complete_info_mode| for the values. pum_visible |TRUE| if popup menu is visible. See |pumvisible()|. items List of completion matches. Each item is a dictionary containing the entries "word", "abbr", "menu", "kind", "info" and "user_data". See |complete-items|. selected Selected item index. First index is zero. Index is -1 if no item is selected (showing typed text only, or the last completion after no item is selected when using the or keys) inserted Inserted string. [NOT IMPLEMENT YET] mode values are: "" Not in completion mode "keyword" Keyword completion |i_CTRL-X_CTRL-N| "ctrl_x" Just pressed CTRL-X |i_CTRL-X| "whole_line" Whole lines |i_CTRL-X_CTRL-L| "files" File names |i_CTRL-X_CTRL-F| "tags" Tags |i_CTRL-X_CTRL-]| "path_defines" Definition completion |i_CTRL-X_CTRL-D| "path_patterns" Include completion |i_CTRL-X_CTRL-I| "dictionary" Dictionary |i_CTRL-X_CTRL-K| "thesaurus" Thesaurus |i_CTRL-X_CTRL-T| "cmdline" Vim Command line |i_CTRL-X_CTRL-V| "function" User defined completion |i_CTRL-X_CTRL-U| "omni" Omni completion |i_CTRL-X_CTRL-O| "spell" Spelling suggestions |i_CTRL-X_s| "eval" |complete()| completion "unknown" Other internal modes If the optional {what} list argument is supplied, then only the items listed in {what} are returned. Unsupported items in {what} are silently ignored. To get the position and size of the popup menu, see |pum_getpos()|. It's also available in |v:event| during the |CompleteChanged| event. Examples: " Get all items call complete_info() " Get only 'mode' call complete_info(['mode']) " Get only 'mode' and 'pum_visible' call complete_info(['mode', 'pum_visible']) Can also be used as a |method|: GetItems()->complete_info()

confirm() offers the user a dialog, from which a choice can be made. It returns the number of the choice. For the first choice this is 1. Note: confirm() is only supported when compiled with dialog support, see |+dialog_con| and |+dialog_gui|. {msg} is displayed in a |dialog| with {choices} as the alternatives. When {choices} is missing or empty, "&OK" is used (and translated). {msg} is a String, use '\n' to include a newline. Only on some systems the string is wrapped when it doesn't fit. {choices} is a String, with the individual choices separated by '\n', e.g. confirm("Save changes?", "&Yes\n&No\n&Cancel") The letter after the '&' is the shortcut key for that choice. Thus you can type 'c' to select "Cancel". The shortcut does not need to be the first letter: confirm("file has been modified", "&Save\nSave &All") For the console, the first letter of each choice is used as the default shortcut key. Case is ignored. The optional {default} argument is the number of the choice that is made if the user hits . Use 1 to make the first choice the default one. Use 0 to not set a default. If {default} is omitted, 1 is used. The optional {type} String argument gives the type of dialog. This is only used for the icon of the GTK, Mac, Motif and Win32 GUI. It can be one of these values: "Error", "Question", "Info", "Warning" or "Generic". Only the first character is relevant. When {type} is omitted, "Generic" is used. If the user aborts the dialog by pressing , CTRL-C, or another valid interrupt key, confirm() returns 0. An example: :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2) :if choice == 0 : echo "make up your mind!" :elseif choice == 3 : echo "tasteful" :else : echo "I prefer bananas myself." :endif In a GUI dialog, buttons are used. The layout of the buttons depends on the 'v' flag in 'guioptions'. If it is included, the buttons are always put vertically. Otherwise, confirm() tries to put the buttons in one horizontal line. If they don't fit, a vertical layout is used anyway. For some systems the horizontal layout is always used. Can also be used as a |method|in: BuildMessage()->confirm("&Yes\n&No")

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}

Return the number of times an item with value {expr} appears in |String|, |List| or |Dictionary| {comp}. If {start} is given then start with the item with this index. {start} can only be used with a |List|. When {ic} is given and it's |TRUE| then case is ignored. When {comp} is a string then the number of not overlapping occurrences of {expr} is returned. Zero is returned when {expr} is an empty string. Can also be used as a |method|: mylist->count(val)

Checks for the existence of a |cscope| connection. If no parameters are specified, then the function returns: 0, if cscope was not available (not compiled in), or if there are no cscope connections; 1, if there is at least one cscope connection. If parameters are specified, then the value of {num} determines how existence of a cscope connection is checked: {num} Description of existence check

0 Same as no parameters (e.g., "cscope_connection()"). 1 Ignore {prepend}, and use partial string matches for {dbpath}. 2 Ignore {prepend}, and use exact string matches for {dbpath}. 3 Use {prepend}, use partial string matches for both {dbpath} and {prepend}. 4 Use {prepend}, use exact string matches for both {dbpath} and {prepend}. Note: All string comparisons are case sensitive! Examples. Suppose we had the following (from ":cs show"):

pid database name prepend path

0 27664 cscope.out /usr/local Invocation Return Val ~

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

Positions the cursor at the column (byte count) {col} in the line {lnum}. The first column is one. When there is one argument {list} this is used as a |List| with two, three or four item: [{lnum}, {col}] [{lnum}, {col}, {off}] [{lnum}, {col}, {off}, {curswant}] This is like the return value of |getpos()| or |getcurpos()|, but without the first item. Does not change the jumplist. If {lnum} is greater than the number of lines in the buffer, the cursor will be positioned at the last line in the buffer. If {lnum} is zero, the cursor will stay in the current line. If {col} is greater than the number of bytes in the line, the cursor will be positioned at the last character in the line. If {col} is zero, the cursor will stay in the current column. If {curswant} is given it is used to set the preferred column for vertical movement. Otherwise {col} is used. When 'virtualedit' is used {off} specifies the offset in screen columns from the start of the character. E.g., a position within a or after the last character. Returns 0 when the position could be set, -1 otherwise. Can also be used as a |method|: GetCursorPos()->cursor()

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()

Make a copy of {expr}. For Numbers and Strings this isn't different from using {expr} directly. When {expr} is a |List| a full copy is created. This means that the original |List| can be changed without changing the copy, and vice versa. When an item is a |List| or |Dictionary|, a copy for it is made, recursively. Thus changing an item in the copy does not change the contents of the original |List|. A |Dictionary| is copied in a similar way as a |List|. When {noref} is omitted or zero a contained |List| or |Dictionary| is only copied once. All references point to this single copy. With {noref} set to 1 every occurrence of a |List| or |Dictionary| results in a new copy. This also means that a cyclic reference causes deepcopy() to fail. Nesting is possible up to 100 levels. When there is an item that refers back to a higher level making a deep copy with {noref} set to 1 will fail. Also see |copy()|. Can also be used as a |method|: GetObject()->deepcopy()

Without {flags} or with {flags} empty: Deletes the file by the name {fname}. This also works when {fname} is a symbolic link. When {flags} is "d": Deletes the directory by the name {fname}. This fails when directory {fname} is not empty. When {flags} is "rf": Deletes the directory by the name {fname} and everything in it, recursively. BE CAREFUL! Note: on MS-Windows it is not possible to delete a directory that is being used. A symbolic link itself is deleted, not what it points to. The result is a Number, which is 0/false if the delete operation was successful and -1/true when the deletion failed or partly failed. Use |remove()| to delete an item from a |List|. To delete a line from the buffer use |:delete| or |deletebufline()|. Can also be used as a |method|: GetName()->delete()

Delete lines {first} to {last} (inclusive) from buffer {buf}. 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 {buf}, 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 {buf}. 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.

This function checks if an executable with the name {expr} exists. {expr} must be the name of the program without any arguments. executable() uses the value of $PATH and/or the normal searchpath for programs. On MS-Windows the ".exe", ".bat", etc. can optionally be included. Then the extensions in $PATHEXT are tried. Thus if "foo.exe" does not exist, "foo.exe.bat" can be found. If $PATHEXT is not set then ".com;.exe;.bat;.cmd" is used. A dot by itself can be used in $PATHEXT to try using the name without an extension. When 'shell' looks like a Unix shell, then the name is also tried without adding an extension. On MS-Windows it only checks if the file exists and is not a directory, not if it's really executable. On MS-Windows an executable in the same directory as Vim is always found. Since this directory is added to $PATH it should also work to execute it |win32-PATH|. The result is a Number: 1 exists 0 does not exist -1 not implemented on this system |exepath()| can be used to get the full path of an executable. Can also be used as a |method|: GetCommand()->executable()

Execute an Ex command or commands and return the output as a string. {command} can be a string or a List. In case of a List the lines are executed one by one. This is equivalent to: redir => var {command} redir END The optional {silent} argument can have these values: "" no :silent used "silent" :silent used "silent!" :silent! used The default is "silent". Note that with "silent!", unlike :redir, error messages are dropped. When using an external command the screen may be messed up, use system() instead. It is not possible to use :redir anywhere in {command}. To get a list of lines use |split()| on the result: split(execute('args'), "\n") To execute a command in another window than the current one use win_execute(). When used recursively the output of the recursive call is not included in the output of the higher level call. Can also be used as a |method|: GetCommand()->execute()

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 wildcards and the following special keywords in {string}. 'wildignorecase' applies. If {list} is given and it is |TRUE|, a List will be returned. Otherwise the result is a String and when there are several matches, they are separated by characters. [Note: in version 5.0 a space was used, which caused problems when a file name contains a space] If the expansion fails, the result is an empty string. A name for a non-existing file is not included, unless {string} does not start with '%', '#' or '<', see below. When {string} starts with '%', '#' or '<', the expansion is done like for the |cmdline-special| variables with their associated modifiers. Here is a short overview: % current file name # alternate file name #n alternate file name n file name under the cursor autocmd file name autocmd buffer number (as a String!) autocmd matched name C expression under the cursor sourced script file or function name sourced script line number or function line number script file line number, also when in a function "123_" where "123" is the current script ID || call stack word under the cursor WORD under the cursor the {clientid} of the last received message |server2client()| Modifiers: :p expand to full path :h head (last path component removed) :t tail (last path component only) :r root (one extension removed) :e extension only Example: :let &tags = expand("%:p:h") . "/tags" Note that when expanding a string that starts with '%', '#' or '<', any following text is ignored. This does NOT work: :let doesntwork = expand("%:h.bak") Use this: :let doeswork = expand("%:h") . ".bak" Also note that expanding "" and others only returns the referenced file name without further expansion. If "" is "/.cshrc", you need to do another expand() to have the "/" expanded into the path of the home directory: :echo expand(expand("")) There cannot be white space between the variables and the following modifier. The |fnamemodify()| function can be used to modify normal file names. When using '%' or '#', and the current or alternate file name is not defined, an empty string is used. Using "%:p" in a buffer with no name, results in the current directory, with a '/' added. When {string} does not start with '%', '#' or '<', it is expanded like a file name is expanded on the command line. 'suffixes' and 'wildignore' are used, unless the optional {nosuf} argument is given and it is |TRUE|. Names for non-existing files are included. The "" item can be used to search in a directory tree. For example, to find all "README" files in the current directory and below: :echo expand(" /README") expand() can also be used to expand variables and environment variables that are only known in a shell. But this can be slow, because a shell may be used to do the expansion. See |expr-env-expand|. The expanded variable is still handled like a list of file names. When an environment variable cannot be expanded, it is left unchanged. Thus ":echo expand('$FOOBAR')" results in "$FOOBAR". See |glob()| for finding existing files. See |system()| for getting the raw output of an external command. Can also be used as a |method|: Getpattern()->expand()

Expand special items in String {string} like what is done for an Ex command such as :edit. This expands special keywords, like with |expand()|, and environment variables, anywhere in {string}. "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()

{expr1} and {expr2} must be both |Lists| or both |Dictionaries|. If they are |Lists|: Append {expr2} to {expr1}. If {expr3} is given insert the items of {expr2} before the item with index {expr3} in {expr1}. When {expr3} is zero insert before the first item. When {expr3} is equal to len({expr1}) then {expr2} is appended. Examples: :echo sort(extend(mylist, [7, 5])) :call extend(mylist, [2, 3], 1) When {expr1} is the same List as {expr2} then the number of items copied is equal to the original length of the List. E.g., when {expr3} is 1 you get N new copies of the first item (where N is the original length of the List). Use |add()| to concatenate one item to a list. To concatenate two lists into a new list use the + operator: :let newlist = [1, 2, 3] + [4, 5] If they are |Dictionaries|: Add all entries from {expr2} to {expr1}. If a key exists in both {expr1} and {expr2} then {expr3} is used to decide what to do: {expr3} = "keep": keep the value of {expr1} {expr3} = "force": use the value of {expr2} {expr3} = "error": give an error message When {expr3} is omitted then "force" is assumed. {expr1} is changed when {expr2} is not empty. If necessary make a copy of {expr1} first. {expr2} remains unchanged. When {expr1} is locked and {expr2} is not empty the operation fails. Returns {expr1}. Can also be used as a |method|: mylist->extend(otherlist)

Characters in {string} are queued for processing as if they come from a mapping or were typed by the user. By default the string is added to the end of the typeahead buffer, thus if a mapping is still being executed the characters come after them. Use the 'i' flag to insert before other characters, they will be executed next, before any characters from a mapping. The function does not wait for processing of keys contained in {string}. To include special keys into {string}, use double-quotes and "..." notation |expr-quote|. For example, feedkeys("<CR>") simulates pressing of the key. But feedkeys('<CR>') pushes 5 characters. A special code that might be useful is , it exits the wait for a character without doing anything. {mode} is a String, which can contain these character flags: 'm' Remap keys. This is default. If {mode} is absent, keys are remapped. 'n' Do not remap keys. 't' Handle keys as if typed; otherwise they are handled as if coming from a mapping. This matters for undo, opening folds, etc. 'L' Lowlevel input. Only works for Unix or when using the GUI. Keys are used as if they were coming from the terminal. Other flags are not used. When a CTRL-C interrupts and 't' is included it sets the internal "got_int" flag. 'i' Insert the string instead of appending (see above). 'x' Execute commands until typeahead is empty. This is similar to using ":normal!". You can call feedkeys() several times without 'x' and then one time with 'x' (possibly with an empty {string}) to execute all the typeahead. Note that when Vim ends in Insert mode it will behave as if is typed, to avoid getting stuck, waiting for a character to be typed before the script continues. Note that if you manage to call feedkeys() while executing commands, thus calling it recursively, then all typeahead will be consumed by the last call. '!' When used with 'x' will not end Insert mode. Can be used in a test when a timer is set to exit Insert mode a little later. Useful for testing CursorHoldI. Return value is always 0. Can also be used as a |method|: GetInput()->feedkeys()

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()

{expr1} must be a |List|, |Blob| or |Dictionary|. For each item in {expr1} evaluate {expr2} and when the result is zero remove the item from the |List| or |Dictionary|. For a |Blob| each byte is removed. {expr2} must be a |string| or |Funcref|. If {expr2} is a |string|, inside {expr2} |v:val| has the value of the current item. For a |Dictionary| |v:key| has the key of the current item and for a |List| |v:key| has the index of the current item. For a |Blob| |v:key| has the index of the current byte. Examples: call filter(mylist, 'v:val !~ "OLD"') Removes the items where "OLD" appears. call filter(mydict, 'v:key >= 8') Removes the items with a key below 8. call filter(var, 0) Removes all the items, thus clears the |List| or |Dictionary|. Note that {expr2} is the result of expression and is then used as an expression again. Often it is good to use a |literal-string| to avoid having to double backslashes. If {expr2} is a |Funcref| it must take two arguments: 1. the key or the index of the current item. 2. the value of the current item. The function must return |TRUE| if the item should be kept. Example that keeps the odd items of a list: func Odd(idx, val) return a:idx % 2 == 1 endfunc call filter(mylist, function('Odd')) It is shorter when using a |lambda|: call filter(myList, {idx, val -> idx * val <= 42}) If you do not use "val" you can leave it out: call filter(myList, {idx -> idx % 2 == 1}) The operation is done in-place. If you want a |List| or |Dictionary| to remain unmodified make a copy first: :let l = filter(copy(mylist), 'v:val =~ "KEEP"') Returns {expr1}, the |List| , |Blob| or |Dictionary| that was filtered. When an error is encountered while evaluating {expr2} no further items in {expr1} are processed. When {expr2} is a Funcref errors inside a function are ignored, unless it was defined with the "abort" flag. Can also be used as a |method|: mylist->filter(expr2)

Find directory {name} in {path}. Supports both downwards and upwards recursive directory searches. See |file-searching| for the syntax of {path}. Returns the path of the first found match. When the found directory is below the current directory a relative path is returned. Otherwise a full path is returned. If {path} is omitted or empty then 'path' is used. If the optional {count} is given, find {count}'s occurrence of {name} in {path} instead of the first one. When {count} is negative return all the matches in a |List|. This is quite similar to the ex-command :find. {only available when compiled with the |+file_in_path| feature} Can also be used as a |method|: GetName()->finddir()

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])

Return a |Funcref| variable that refers to function {name}. {name} can be the name of a user defined function or an internal function. {name} can also be a Funcref or a partial. When it is a partial the dict stored in it will be used and the {dict} argument is not allowed. E.g.: let FuncWithArg = function(dict.Func, [arg]) let Broken = function(dict.Func, [arg], dict) When using the Funcref the function will be found by {name}, also when it was redefined later. Use |funcref()| to keep the same function. When {arglist} or {dict} is present this creates a partial. That means the argument list and/or the dictionary is stored in the Funcref and will be used when the Funcref is called. The arguments are passed to the function in front of other arguments, but after any argument from |method|. Example: func Callback(arg1, arg2, name) ... let Partial = function('Callback', ['one', 'two']) ... call Partial('name') Invokes the function as with: call Callback('one', 'two', 'name') With a |method|: func Callback(one, two, three) ... let Partial = function('Callback', ['two']) ... eval 'one'->Partial('three') Invokes the function as with: call Callback('one', 'two', 'three') The function() call can be nested to add more arguments to the Funcref. The extra arguments are appended to the list of arguments. Example: func Callback(arg1, arg2, name) ... let Func = function('Callback', ['one']) let Func2 = function(Func, ['two']) ... call Func2('name') Invokes the function as with: call Callback('one', 'two', 'name') The Dictionary is only useful when calling a "dict" function. In that case the {dict} is passed in as "self". Example: function Callback() dict echo "called for " . self.name endfunction ... let context = {"name": "example"} let Func = function('Callback', context) ... call Func() " will echo: called for example The use of function() is not needed when there are no extra arguments, these two are equivalent: let Func = function('Callback', context) let Func = context.Callback The argument list and the Dictionary can be combined: function Callback(arg1, count) dict ... let context = {"name": "example"} let Func = function('Callback', ['one'], context) ... call Func(500) Invokes the function as with: call context.Callback('one', 500) Can also be used as a |method|: GetFuncname()->function([arg])

Cleanup unused |Lists|, |Dictionaries|, |Channels| and |Jobs| that have circular references. There is hardly ever a need to invoke this function, as it is automatically done when Vim runs out of memory or is waiting for the user to press a key after 'updatetime'. Items without circular references are always freed when they become unused. This is useful if you have deleted a very big |List| and/or |Dictionary| with circular references in a script that runs for a long time. When the optional {atexit} argument is one, garbage collection will also be done when exiting Vim, if it wasn't done before. This is useful when checking for memory leaks. The garbage collection is not done immediately but only when it's safe to perform. This is when waiting for the user to type a character. To force garbage collection immediately use |test_garbagecollect_now()|.

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)

Get information about buffers as a List of Dictionaries. Without an argument information about all the buffers is returned. When the argument is a |Dictionary| only the buffers matching the specified criteria are returned. The following keys can be specified in {dict}: buflisted include only listed buffers. bufloaded include only loaded buffers. bufmodified include only modified buffers. Otherwise, {buf} specifies a particular buffer to return information for. For the use of {buf}, see |bufname()| above. If the buffer is found the returned List has one item. Otherwise the result is an empty list. Each returned List item is a dictionary with the following entries: bufnr Buffer number. changed TRUE if the buffer is modified. changedtick Number of changes made to the buffer. hidden TRUE if the buffer is hidden. lastused Timestamp in seconds, like |localtime()|, when the buffer was last used. {only with the |+viminfo| feature} listed TRUE if the buffer is listed. lnum Line number used for the buffer when opened in the current window. Only valid if the buffer has been displayed in the window in the past. If you want the line number of the last known cursor position in a given window, use |line()|: :echo line('.', {winid}) linecount Number of lines in the buffer (only valid when loaded) loaded TRUE if the buffer is loaded. name Full path to the file in the buffer. signs List of signs placed in the buffer. Each list item is a dictionary with the following fields: id sign identifier lnum line number name sign name variables A reference to the dictionary with buffer-local variables. windows List of |window-ID|s that display this buffer popups List of popup |window-ID|s that display this buffer Examples: for buf in getbufinfo() echo buf.name endfor for buf in getbufinfo({'buflisted':1}) if buf.changed .... endif endfor To get buffer-local options use: getbufvar({bufnr}, '&option_name') Can also be used as a |method|: GetBufnr()->getbufinfo()

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.

The result is the value of option or local buffer variable {varname} in buffer {buf}. Note that the name without "b:" must be used. The {varname} argument is a string. When {varname} is empty returns a |Dictionary| with all the buffer-local variables. When {varname} is equal to "&" returns a |Dictionary| with all the buffer-local options. Otherwise, when {varname} starts with "&" returns the value of a buffer-local option. This also works for a global or buffer-local option, but it doesn't work for a global variable, window-local variable or window-local option. For the use of {buf}, see |bufname()| above. When the buffer or variable doesn't exist {def} or an empty string is returned, there is no error message. Examples: :let bufmodified = getbufvar(1, "&mod") :echo "todo myvar = " . getbufvar("todo", "myvar") Can also be used as a |method|: GetBufnr()->getbufvar(varname)

Returns the |changelist| for the buffer {buf}. For the use of {buf}, see |bufname()| above. If buffer {buf} 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 {buf} 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()

Get a single character from the user or input stream. If [expr] is omitted, wait until a character is available. If [expr] is 0, only get a character when one is available. Return zero otherwise. If [expr] is 1, only check if a character is available, it is not consumed. Return zero if no character available. If you prefer always getting a string use |getcharstr()|. Without [expr] and when [expr] is 0 a whole character or special key is returned. If it is a single character, the result is a number. Use nr2char() to convert it to a String. Otherwise a String is returned with the encoded character. For a special key it's a String with a sequence of bytes starting with 0x80 (decimal: 128). This is the same value as the String "<Key>", e.g., "<Left>". The returned value is also a String when a modifier (shift, control, alt) was used that is not included in the character. When [expr] is 0 and Esc is typed, there will be a short delay while Vim waits to see if this is the start of an escape sequence. When [expr] is 1 only the first byte is returned. For a one-byte character it is the character itself as a number. Use nr2char() to convert it to a String. Use getcharmod() to obtain any additional modifiers. When the user clicks a mouse button, the mouse event will be returned. The position can then be found in |v:mouse_col|, |v:mouse_lnum|, |v:mouse_winid| and |v:mouse_win|. |getmousepos()| can also be used. Mouse move events will be ignored. This example positions the mouse as it would normally happen: let c = getchar() if c == "<LeftMouse>" && v:mouse_win > 0 exe v:mouse_win . "wincmd w" exe v:mouse_lnum exe "normal " . v:mouse_col . "|" endif When using bracketed paste only the first character is returned, the rest of the pasted text is dropped. |xterm-bracketed-paste|. There is no prompt, you will somehow have to make clear to the user that a character has to be typed. The screen is not redrawn, e.g. when resizing the window. When using a popup window it should work better with a |popup-filter|. There is no mapping for the character. Key codes are replaced, thus when the user presses the <Del key you get the code for the key, not the raw character sequence. Examples: getchar() == "<Del>" getchar() == "<S-Left>" This example redefines "f" to ignore case: :nmap f :call FindChar()<CR :function FindChar() : let c = nr2char(getchar()) : while col('.') < col('$') - 1 : normal l : if getline('.')[col('.') - 1] ==? c : break : endif : endwhile :endfunction You may also receive synthetic characters, such as ||. Often you will want to ignore this and get another character: :function GetKey() : let c = getchar() : while c == "<CursorHold>" : let c = getchar() : endwhile : return c :endfunction

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()|.

Get a single character from the user or input stream as a string. If [expr] is omitted, wait until a character is available. If [expr] is 0 or false, only get a character when one is available. Return an empty string otherwise. If [expr] is 1 or true, only check if a character is available, it is not consumed. Return an empty string if no character is available. Otherwise this works like |getchar()|, except that a number result is converted to a string.

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.

Return a list of command-line completion matches. The String {type} argument specifies what for. The following completion types are supported: arglist file names in argument list augroup autocmd groups buffer buffer names behave :behave suboptions color color schemes command Ex command (and arguments) cmdline |cmdline-completion| result compiler compilers cscope |:cscope| suboptions diff_buffer |:diffget| and |:diffput| completion dir directory names environment environment variable names event autocommand events expression Vim expression file file and directory names file_in_path file and directory names in |'path'| filetype filetype names |'filetype'| function function name help help subjects highlight highlight groups history :history suboptions locale locale names (as output of locale -a) mapclear buffer argument mapping mapping name menu menus messages |:messages| suboptions option options packadd optional package |pack-add| names shellcmd Shell command sign |:sign| suboptions syntax syntax file names |'syntax'| syntime |:syntime| suboptions tag tags tag_listfiles tags, file names user user names var user variables If {pat} is an empty string, then all the matches are returned. Otherwise only items matching {pat} are returned. See |wildcards| for the use of special characters in {pat}. If the optional {filtered} flag is set to 1, then 'wildignore' is applied to filter the results. Otherwise all the matches are returned. The 'wildignorecase' option always applies. If {type} is "cmdline", then the |cmdline-completion| result is returned. For example, to complete the possible values after a ":call" command: echo getcompletion('call ', 'cmdline') If there are no matches, an empty list is returned. An invalid value for {type} produces an error. Can also be used as a |method|: GetPattern()->getcompletion('color')

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.

The result is a String, which is the name of the current working directory. With {winnr} return the local current directory of this window in the current tab page. {winnr} can be the window number or the |window-ID|. If {winnr} is -1 return the name of the global working directory. See also |haslocaldir()|. With {winnr} and {tabnr} return the local current directory of the window in the specified tab page. If {winnr} is -1 return the working directory of the tabpage. If {winnr} is zero use the current window, if {tabnr} is zero use the current tabpage. Without any arguments, return the working directory of the current window. Return an empty string if the arguments are invalid. Examples: " Get the working directory of the current window :echo getcwd() :echo getcwd(0) :echo getcwd(0, 0) " Get the working directory of window 3 in tabpage 2 :echo getcwd(3, 2) " Get the global working directory :echo getcwd(-1) " Get the working directory of tabpage 3 :echo getcwd(-1, 3) " Get the working directory of current tabpage :echo getcwd(-1, 0) Can also be used as a |method|: GetWinnr()->getcwd()

Return the value of environment variable {name}. The {name} argument is a string, without a leading '$'. Example: myHome = getenv('HOME') 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 String {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 {end} the result is a String, which is line {lnum} from the current buffer. Example: > getline(1) When {lnum} is a String that doesn't start with a digit, line() is called to translate the String into a Number. To get the line under the cursor: > getline(".") When {lnum} is smaller than 1 or bigger than the number of lines in the buffer, an empty string is returned.

Returns a |List| with all the entries in the location list for window {nr}. {nr} can be the window number or the |window-ID|. When {nr} is zero the current window is used. For a location list window, the displayed location list is returned. For an invalid window number {nr}, an empty list is returned. Otherwise, same as |getqflist()|. If the optional {what} dictionary argument is supplied, then returns the items listed in {what} as a dictionary. Refer to |getqflist()| for the supported items in {what}. In addition to the items supported by |getqflist()| in {what}, the following item is supported by |getloclist()|: filewinid id of the window used to display files from the location list. This field is applicable only when called from a location list window. See |location-list-file-window| for more details. Returns a |Dictionary| with default values if there is no location list for the window {nr}. Returns an empty Dictionary if window {nr} does not exist. Examples (See also |getqflist-examples|): :echo getloclist(3, {'all': 0}) :echo getloclist(5, {'filewinid': 0})

Without the {buf} argument returns a |List| with information about all the global marks. |mark| If the optional {buf} argument is specified, returns the local marks defined in buffer {buf}. For the use of {buf}, 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()

Returns a |List| with all matches previously defined for the current window by |matchadd()| and the |:match| commands. |getmatches()| is useful in combination with |setmatches()|, as |setmatches()| can restore a list of matches saved by |getmatches()|. If {win} is specified, use the window with this number or window ID instead of the current window. Example: :echo getmatches() [{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 10, 'id': 2}] :let m = getmatches() :call clearmatches() :echo getmatches() [] :call setmatches(m) :echo getmatches() [{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 10, 'id': 2}] :unlet m

Returns a |Dictionary| with the last known position of the mouse. This can be used in a mapping for a mouse click or in a filter of a popup window. The items are: screenrow screen row screencol screen column winid Window ID of the click winrow row inside "winid" wincol column inside "winid" line text line inside "winid" column text column inside "winid" All numbers are 1-based. If not over a window, e.g. when in the command line, then only "screenrow" and "screencol" are valid, the others are zero. When on the status line below a window or the vertical separator right of a window, the "line" and "column" values are zero. When the position is after the text then "column" is the length of the text in bytes plus one. If the mouse is over a popup window then that window is used. When using |getchar()| the Vim variables |v:mouse_lnum|, |v:mouse_col| and |v:mouse_winid| also provide these values.

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()

Returns a |List| with all the current quickfix errors. Each list item is a dictionary with these entries: bufnr number of buffer that has the file name, use bufname() to get the name module module name lnum line number in the buffer (first line is 1) end_lnum end of line number if the item is multiline col column number (first column is 1) end_col end of column number if the item has range vcol |TRUE|: "col" is visual column |FALSE|: "col" is byte index nr error number pattern search pattern used to locate the error text description of the error type type of the error, 'E', '1', etc. valid |TRUE|: recognized error message When there is no error list or it's empty, an empty list is returned. Quickfix list entries with a non-existing buffer number are returned with "bufnr" set to zero (Note: some functions accept buffer number zero for the alternate buffer, you may need to explicitly check for zero). Useful application: Find pattern matches in multiple files and do something with them: :vimgrep /theword/jg *.c :for d in getqflist() : echo bufname(d.bufnr) ':' d.lnum '=' d.text :endfor If the optional {what} dictionary argument is supplied, then returns only the items listed in {what} as a dictionary. The following string items are supported in {what}: changedtick get the total number of changes made to the list |quickfix-changedtick| context get the |quickfix-context| efm errorformat to use when parsing "lines". If not present, then the 'errorformat' option value is used. id get information for the quickfix list with |quickfix-ID|; zero means the id for the current list or the list specified by "nr" idx get information for the quickfix entry at this index in the list specified by 'id' or 'nr'. If set to zero, then uses the current entry. See |quickfix-index| items quickfix list entries lines parse a list of lines using 'efm' and return the resulting entries. Only a |List| type is accepted. The current quickfix list is not modified. See |quickfix-parse|. nr get information for this quickfix list; zero means the current quickfix list and "$" means the last quickfix list qfbufnr number of the buffer displayed in the quickfix window. Returns 0 if the quickfix buffer is not present. See |quickfix-buffer|. size number of entries in the quickfix list title get the list title |quickfix-title| winid get the quickfix |window-ID| all all of the above quickfix properties Non-string items in {what} are ignored. To get the value of a particular item, set it to zero. If "nr" is not present then the current quickfix list is used. If both "nr" and a non-zero "id" are specified, then the list specified by "id" is used. To get the number of lists in the quickfix stack, set "nr" to "$" in {what}. The "nr" value in the returned dictionary contains the quickfix stack size. When "lines" is specified, all the other items except "efm" are ignored. The returned dictionary contains the entry "items" with the list of entries. The returned dictionary contains the following entries: changedtick total number of changes made to the list |quickfix-changedtick| context quickfix list context. See |quickfix-context| If not present, set to "". id quickfix list ID |quickfix-ID|. If not present, set to 0. idx index of the quickfix entry in the list. If not present, set to 0. items quickfix list entries. If not present, set to an empty list. nr quickfix list number. If not present, set to 0 qfbufnr number of the buffer displayed in the quickfix window. If not present, set to 0. size number of entries in the quickfix list. If not present, set to 0. title quickfix list title text. If not present, set to "". winid quickfix |window-ID|. If not present, set to 0 Examples (See also |getqflist-examples|): :echo getqflist({'all': 1}) :echo getqflist({'nr': 2, 'title': 1}) :echo getqflist({'lines' : ["F1:10:L10"]})

The result is a String, which is the contents of register {regname}. Example: :let cliptext = getreg('*') When {regname} was not set the result is an empty string. The {regname} argument is a string. getreg('=') returns the last evaluated value of the expression register. (For use in maps.) getreg('=', 1) returns the expression itself, so that it can be restored with |setreg()|. For other registers the extra argument is ignored, thus you can always give it. If {list} is present and |TRUE|, the result type is changed to |List|. Each list item is one text line. Use it if you care about zero bytes possibly present inside register: without third argument both NLs and zero bytes are represented as NLs (see |NL-used-for-Nul|). When the register was not set an empty list is returned. 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()->getreg()

Returns detailed information about register {regname} as a Dictionary with the following entries: regcontents List of lines contained in register {regname}, like |getreg|({regname}, 1, 1). regtype the type of register {regname}, as in |getregtype()|. isunnamed Boolean flag, v:true if this register is currently pointed to by the unnamed register. points_to for the unnamed register, gives the single letter name of the register currently pointed to (see |quotequote|). For example, after deleting a line with dd, this field will be "1", which is the register that got the deleted text. The {regname} argument is a string. If {regname} is invalid or not set, an empty Dictionary will be returned. If {regname} is not specified, |v:register| is used. The returned Dictionary can be passed to |setreg()|. In |Vim9-script| {regname} must be one character. Can also be used as a |method|: GetRegname()->getreginfo()

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. The {regname} argument is a string. 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. The {varname} argument is a string. 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)

Get the value of window-local variable {varname} in window {winnr} in tab page {tabnr}. The {varname} argument is a string. When {varname} is empty a dictionary with all window-local variables is returned. When {varname} is equal to "&" get the values of all window-local options in a |Dictionary|. Otherwise, when {varname} starts with "&" get the value of a window-local option. Note that {varname} must be the name without "w:". Tabs are numbered starting with one. For the current tabpage use |getwinvar()|. {winnr} can be the window number or the |window-ID|. When {winnr} is zero the current window is used. This also works for a global option, buffer-local option and window-local option, but it doesn't work for a global variable or buffer-local variable. When the tab, window or variable doesn't exist {def} or an empty string is returned, there is no error message. Examples: :let list_is_on = gettabwinvar(1, 2, '&list') :echo "myvar = " . gettabwinvar(3, 1, 'myvar') To obtain all window-local variables use: gettabwinvar({tabnr}, {winnr}, '&') Can also be used as a |method|: GetTabnr()->gettabwinvar(winnr, varname)

The result is a Dict, which is the tag stack of window {winnr}. {winnr} can be the window number or the |window-ID|. When {winnr} is not specified, the current window is used. When window {winnr} doesn't exist, an empty Dict is returned. The returned dictionary contains the following entries: curidx Current index in the stack. When at top of the stack, set to (length + 1). Index of bottom of the stack is 1. items List of items in the stack. Each item is a dictionary containing the entries described below. length Number of entries in the stack. Each item in the stack is a dictionary with the following entries: bufnr buffer number of the current jump from cursor position before the tag jump. See |getpos()| for the format of the returned list. matchnr current matching tag number. Used when multiple matching tags are found for a name. tagname name of the tag See |tagstack| for more information about the tag stack. Can also be used as a |method|: GetWinnr()->gettagstack()

Returns information about windows as a |List| with Dictionaries. If {winid} is given Information about the window with that ID is returned, as a |List| with one item. If the window does not exist the result is an empty list. Without {winid} information about all the windows in all the tab pages is returned. Each List item is a |Dictionary| with the following entries: botline last complete displayed buffer line bufnr number of buffer in the window height window height (excluding winbar) loclist 1 if showing a location list {only with the +quickfix feature} quickfix 1 if quickfix or location list window {only with the +quickfix feature} terminal 1 if a terminal window {only with the +terminal feature} tabnr tab page number topline first displayed buffer line variables a reference to the dictionary with window-local variables width window width winbar 1 if the window has a toolbar, 0 otherwise wincol leftmost screen column of the window; "col" from |win_screenpos()| winid |window-ID| winnr window number winrow topmost screen line of the window; "row" from |win_screenpos()| Can also be used as a |method|: GetWinnr()->getwininfo()

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)

Expand the file wildcards in {expr}. See |wildcards| for the use of special characters. Unless the optional {nosuf} argument is given and is |TRUE|, the 'suffixes' and 'wildignore' options apply: Names matching one of the patterns in 'wildignore' will be skipped and 'suffixes' affect the ordering of matches. 'wildignorecase' always applies. When {list} is present and it is |TRUE| the result is a |List| with all matching files. The advantage of using a List is, you also get filenames containing newlines correctly. Otherwise the result is a String and when there are several matches, they are separated by characters. If the expansion fails, the result is an empty String or List. You can also use |readdir()| if you need to do complicated things, such as limiting the number of matches. A name for a non-existing file is not included. A symbolic link is only included if it points to an existing file. However, when the {alllinks} argument is present and it is |TRUE| then all symbolic links are included. For most systems backticks can be used to get files names from any external command. Example: :let tagfiles = glob("find . -name tags -print") :let &tags = substitute(tagfiles, "\n", ",", "g") The result of the program inside the backticks should be one item per line. Spaces inside an item are allowed. See |expand()| for expanding special Vim variables. See |system()| for getting the raw output of an external command. Can also be used as a |method|: GetExpr()->glob()

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 {string} 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()

Perform glob() for String {expr} on all directories in {path} and concatenate the results. Example: :echo globpath(&rtp, "syntax/c.vim") {path} is a comma-separated list of directory names. Each directory name is prepended to {expr} and expanded like with |glob()|. A path separator is inserted when needed. To add a comma inside a directory name escape it with a backslash. Note that on MS-Windows a directory may have a trailing backslash, remove it if you put a comma after it. If the expansion fails for one of the directories, there is no error message. Unless the optional {nosuf} argument is given and is |TRUE|, the 'suffixes' and 'wildignore' options apply: Names matching one of the patterns in 'wildignore' will be skipped and 'suffixes' affect the ordering of matches. When {list} is present and it is |TRUE| the result is a |List| with all matching files. The advantage of using a List is, you also get filenames containing newlines correctly. Otherwise the result is a String and when there are several matches, they are separated by characters. Example: :echo globpath(&rtp, "syntax/c.vim", 0, 1) {alllinks} is used as with |glob()|. The "" item can be used to search in a directory tree. For example, to find all "README.txt" files in the directories in 'runtimepath' and below: :echo globpath(&rtp, " /README.txt") Upwards search and limiting the depth of "**" is not supported, thus using 'path' will not always work properly. Can also be used as a |method|, the base is passed as the second argument: GetExpr()->globpath(&rtp)

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. The {key} argument is a string. Can also be used as a |method|: mydict->has_key(key)

The result is a Number: 1 when the window has set a local directory via |:lcd| 2 when the tab-page has set a local directory via |:tcd| 0 otherwise. Without arguments use the current window. With {winnr} 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|. If {winnr} is -1 it is ignored and only the tabpage is used. Return 0 if the arguments are invalid. Examples: if haslocaldir() == 1 " window local directory case elseif haslocaldir() == 2 " tab-local directory case else " global directory case endif " current window :echo haslocaldir() :echo haslocaldir(0) :echo haslocaldir(0, 0) " window n in current tab page :echo haslocaldir(n) :echo haslocaldir(n, 0) " window n in tab page m :echo haslocaldir(n, m) " tab page m :echo haslocaldir(-1, m) Can also be used as a |method|: GetWinnr()->haslocaldir()

The result is a Number, which is TRUE if there is a mapping that contains {what} in somewhere in the rhs (what it is mapped to) and this mapping exists in one of the modes indicated by {mode}. The arguments {what} and {mode} are strings. When {abbr} is there and it is |TRUE| use abbreviations instead of mappings. Don't forget to specify Insert and/or Command-line mode. Both the global mappings and the mappings local to the current buffer are checked for a match. If no matching mapping is found FALSE is returned. The following characters are recognized in {mode}: n Normal mode v Visual and Select mode x Visual mode s Select mode o Operator-pending mode i Insert mode l Language-Argument ("r", "f", "t", etc.) c Command-line mode When {mode} is omitted, "nvo" is used. This function is useful to check if a mapping already exists to a function in a Vim script. Example: :if !hasmapto('\ABCdoit') : map d \ABCdoit :endif This installs the mapping to "\ABCdoit" only if there isn't already a mapping to "\ABCdoit". Can also be used as a |method|: GetRHS()->hasmapto()

Add the String {item} to the history {history} which can be one of: "cmd" or ":" command line history "search" or "/" search pattern history "expr" or "=" typed expression history "input" or "@" input line history "debug" or ">" debug command history empty the current or last used history The {history} string does not need to be the whole name, one character is sufficient. If {item} does already exist in the history, it will be shifted to become the newest entry. The result is a Number: TRUE if the operation was successful, otherwise FALSE is returned. Example: :call histadd("input", strftime("%Y %b %d")) :let date=input("Enter date: ") This function is not available in the |sandbox|. Can also be used as a |method|, the base is passed as the second argument: GetHistory()->histadd('search')

Clear {history}, i.e. delete all its entries. See |hist-names| for the possible values of {history}. If the parameter {item} evaluates to a String, it is used as a regular expression. All entries matching that expression will be removed from the history (if there are any). Upper/lowercase must match, unless "\c" is used |/\c|. If {item} evaluates to a Number, it will be interpreted as an index, see |:history-indexing|. The respective entry will be removed if it exists. The result is TRUE for a successful operation, otherwise FALSE is returned. Examples: Clear expression register history: :call histdel("expr") Remove all entries starting with "*" from the search history: :call histdel("/", '^{*') The following three are equivalent: :call histdel("search", histnr("search")) :call histdel("search", -1) :call histdel("search", '}'.histget("search", -1).'$') To delete the last search pattern and use the last-but-one for the "n" command and 'hlsearch': :call histdel("search", -1) :let @/ = histget("search", -1) Can also be used as a |method|: GetHistory()->histdel()

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

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()

If {object} is a |List| return the lowest index where the item has a value equal to {expr}. There is no automatic conversion, so the String "4" is different from the Number 4. And the number 4 is different from the Float 4.0. The value of 'ignorecase' is not used here, case always matters. If {object} is |Blob| return the lowest index where the byte value is equal to {expr}. If {start} is given then start looking at the item with index {start} (may be negative for an item relative to the end). When {ic} is given and it is |TRUE|, ignore case. Otherwise case must match. -1 is returned when {expr} is not found in {object}. Example: :let idx = index(words, "the") :if index(numbers, 123) >= 0 Can also be used as a |method|: GetObject()->index(what)

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()

When {object} is a |List| or a |Blob| insert {item} at the start of it. If {idx} is specified insert {item} before the item with index {idx}. If {idx} is zero it goes before the first item, just like omitting {idx}. A negative {idx} is also possible, see |list-index|. -1 inserts just before the last item. Returns the resulting |List| or |Blob|. Examples: :let mylist = insert([2, 3, 5], 1) :call insert(mylist, 4, -1) :call insert(mylist, 6, len(mylist)) The last example can be done simpler with |add()|. Note that when {item} is a |List| it is inserted as a single item. Use |extend()| to concatenate |Lists|. Can also be used as a |method|: mylist->insert(item)

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. The string argument {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()

This parses a JSON formatted string and returns the equivalent in Vim values. See |json_encode()| for the relation between JSON and Vim values. The decoding is permissive:

• A trailing comma in an array and object is ignored, e.g. "[1, 2, ]" is the same as "[1, 2]".
• Integer keys are accepted in objects, e.g. {1:2} is the same as {"1":2}.
• More floating point numbers are recognized, e.g. "1." for "1.0", or "001.2" for "1.2". Special floating point values "Infinity", "-Infinity" and "NaN" (capitalization ignored) are accepted.
• Leading zeroes in integer numbers are ignored, e.g. "012" for "12" or "-012" for "-12".
• Capitalization is ignored in literal names null, true or false, e.g. "NULL" for "null", "True" for "true".
• Control characters U+0000 through U+001F which are not escaped in strings are accepted, e.g. " " (tab character in string) for "\t".
• An empty JSON expression or made of only spaces is accepted and results in v:none.
• Backslash in an invalid 2-character sequence escape is ignored, e.g. "\a" is decoded as "a".
• A correct surrogate pair in JSON strings should normally be a 12 character sequence such as "\uD834\uDD1E", but json_decode() silently accepts truncated surrogate pairs such as "\uD834" or "\uD834\u" A duplicate key in an object, valid in rfc7159, is not accepted by json_decode() as the result must be a valid Vim type, e.g. this fails: {"a":"b", "a":"c"} Can also be used as a |method|: ReadObject()->json_decode()

Encode {expr} as JSON and return this as a string. The encoding is specified in: https://tools.ietf.org/html/rfc7159.html Vim values are converted as follows: |Number| decimal number |Float| floating point number Float nan "NaN" Float inf "Infinity" Float -inf "-Infinity" |String| in double quotes (possibly null) |Funcref| not possible, error |List| as an array (possibly null); when used recursively: [] |Dict| as an object (possibly null); when used recursively: {} |Blob| as an array of the individual bytes v:false "false" v:true "true" v:none "null" v:null "null" Note that NaN and Infinity are passed on as values. This is missing in the JSON standard, but several implementations do allow it. If not then you will get an error. Can also be used as a |method|: GetObject()->json_encode()

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()

Call function {funcname} in the run-time library {libname} with single argument {argument}. This is useful to call functions in a library that you especially made to be used with Vim. Since only one argument is possible, calling standard library functions is rather limited. The result is the String returned by the function. If the function returns NULL, this will appear as an empty string "" to Vim. If the function returns a number, use libcallnr()! If {argument} is a number, it is passed to the function as an int; if {argument} is a string, it is passed as a null-terminated string. This function will fail in |restricted-mode|. libcall() allows you to write your own 'plug-in' extensions to Vim without having to recompile the program. It is NOT a means to call system functions! If you try to do so Vim will very probably crash. For Win32, the functions you write must be placed in a DLL and use the normal C calling convention (NOT Pascal which is used in Windows System DLLs). The function must take exactly one parameter, either a character pointer or a long integer, and must return a character pointer or NULL. The character pointer returned must point to memory that will remain valid after the function has returned (e.g. in static data in the DLL). If it points to allocated memory, that memory will leak away. Using a static buffer in the function should work, it's then freed when the DLL is unloaded. WARNING: If the function returns a non-valid pointer, Vim may crash! This also happens if the function returns a number, because Vim thinks it's a pointer. For Win32 systems, {libname} should be the filename of the DLL without the ".DLL" suffix. A full path is only required if the DLL is not in the usual places. For Unix: When compiling your own plugins, remember that the object code must be compiled as position-independent ('PIC'). {only in Win32 and some Unix versions, when the |+libcall| feature is present} Examples: :echo libcall("libc.so", "getenv", "HOME") Can also be used as a |method|, the base is passed as the third argument: GetValue()->libcall("libc.so", "getenv")

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}

{expr1} must be a |List|, |Blob| or |Dictionary|. Replace each item in {expr1} with the result of evaluating {expr2}. For a |Blob| each byte is replaced. If the item type changes you may want to use |mapnew()| to create a new List or Dictionary. This is required when using Vim9 script. {expr2} must be a |string| or |Funcref|. If {expr2} is a |string|, inside {expr2} |v:val| has the value of the current item. For a |Dictionary| |v:key| has the key of the current item and for a |List| |v:key| has the index of the current item. For a |Blob| |v:key| has the index of the current byte. Example: :call map(mylist, '"> " . v:val . " <"') This puts "> " before and " <" after each item in "mylist". Note that {expr2} is the result of an expression and is then used as an expression again. Often it is good to use a |literal-string| to avoid having to double backslashes. You still have to double ' quotes If {expr2} is a |Funcref| it is called with two arguments: 1. The key or the index of the current item. 2. the value of the current item. The function must return the new value of the item. Example that changes each value by "key-value": func KeyValue(key, val) return a:key . '-' . a:val endfunc call map(myDict, function('KeyValue')) It is shorter when using a |lambda|: call map(myDict, {key, val -> key . '-' . val}) If you do not use "val" you can leave it out: call map(myDict, {key -> 'item: ' . key}) If you do not use "key" you can use a short name: call map(myDict, {_, val -> 'item: ' . val}) The operation is done in-place. If you want a |List| or |Dictionary| to remain unmodified make a copy first: :let tlist = map(copy(mylist), ' v:val . "\t"') Returns {expr1}, the |List|, |Blob| or |Dictionary| that was filtered. When an error is encountered while evaluating {expr2} no further items in {expr1} are processed. When {expr2} is a Funcref errors inside a function are ignored, unless it was defined with the "abort" flag. Can also be used as a |method|: mylist->map(expr2)

When {dict} is omitted or zero: Return the rhs of mapping {name} in mode {mode}. The returned String has special characters translated like in the output of the ":map" command listing. When there is no mapping for {name}, an empty String is returned. When the mapping for {name} is empty, then "" is returned. The {name} can have special key names, like in the ":map" command. {mode} can be one of these strings: "n" Normal "v" Visual (including Select) "o" Operator-pending "i" Insert "c" Cmd-line "s" Select "x" Visual "l" langmap |language-mapping| "t" Terminal-Job "" Normal, Visual and Operator-pending When {mode} is omitted, the modes for "" are used. When {abbr} is there and it is |TRUE| use abbreviations instead of mappings. When {dict} is there and it is |TRUE| return a dictionary containing all the information of the mapping with the following items: "lhs" The {lhs} of the mapping as it would be typed "lhsraw" The {lhs} of the mapping as raw bytes "lhsrawalt" The {lhs} of the mapping as raw bytes, alternate form, only present when it differs from "lhsraw" "rhs" The {rhs} of the mapping as typed. "silent" 1 for a |:map-silent| mapping, else 0. "noremap" 1 if the {rhs} of the mapping is not remappable. "script" 1 if mapping was defined with . "expr" 1 for an expression mapping (|:map-|). "buffer" 1 for a buffer local mapping (|:map-local|). "mode" Modes for which the mapping is defined. In addition to the modes mentioned above, these characters will be used: " " Normal, Visual and Operator-pending "!" Insert and Commandline mode (|mapmode-ic|) "sid" The script local ID, used for mappings (||). "lnum" The line number in "sid", zero if unknown. "nowait" Do not wait for other, longer mappings. (|:map-|). The dictionary can be used to restore a mapping with |mapset()|. The mappings local to the current buffer are checked first, then the global mappings. This function can be used to map a key even when it's already mapped, and have it do the original mapping too. Sketch: exe 'nnoremap ==' . maparg('', 'n') Can also be used as a |method|: GetKey()->maparg('n')

Check if there is a mapping that matches with {name} in mode {mode}. See |maparg()| for {mode} and special names in {name}. When {abbr} is there and it is |TRUE| use abbreviations instead of mappings. A match happens with a mapping that starts with {name} and with a mapping which is equal to the start of {name}. matches mapping "a" "ab" "abc" ~ mapcheck("a") yes yes yes mapcheck("abc") yes yes yes mapcheck("ax") yes no no mapcheck("b") no no no The difference with maparg() is that mapcheck() finds a mapping that matches with {name}, while maparg() only finds a mapping for {name} exactly. When there is no mapping that starts with {name}, an empty String is returned. If there is one, the RHS of that mapping is returned. If there are several mappings that start with {name}, the RHS of one of them is returned. This will be "" if the RHS is empty. The mappings local to the current buffer are checked first, then the global mappings. This function can be used to check if a mapping can be added without being ambiguous. Example: :if mapcheck("_vv") == "" : map _vv :set guifont=7x13<CR :endif This avoids adding the "_vv" mapping when there already is a mapping for "_v" or for "_vvv". Can also be used as a |method|: GetKey()->mapcheck('n')

When {expr} is a |List| then this returns the index of the first item where {pat} matches. Each item is used as a String, |Lists| and |Dictionaries| are used as echoed. Otherwise, {expr} is used as a String. The result is a Number, which gives the index (byte offset) in {expr} where {pat} matches. A match at the first character or |List| item returns zero. If there is no match -1 is returned. For getting submatches see |matchlist()|. Example: :echo match("testing", "ing") " results in 4 :echo match([1, 'x'], '\a') " results in 1 See |string-match| for how {pat} is used. Vim doesn't have a strpbrk() function. But you can do: :let sepidx = match(line, '[.,;: \t]') Vim doesn't have a strcasestr() function. But you can add "\c" to the pattern to ignore case: :let idx = match(haystack, '\cneedle') If {start} is given, the search starts from byte index {start} in a String or item {start} in a |List|. The result, however, is still the index counted from the first character/item. Example: :echo match("testing", "ing", 2) result is again "4". :echo match("testing", "ing", 4) result is again "4". :echo match("testing", "t", 2) result is "3". For a String, if {start} > 0 then it is like the string starts {start} bytes later, thus "^" will match at {start}. Except when {count} is given, then it's like matches before the {start} byte are ignored (this is a bit complicated to keep it backwards compatible). For a String, if {start} < 0, it will be set to 0. For a list the index is counted from the end. If {start} is out of range ({start} > strlen({expr}) for a String or {start} > len({expr}) for a |List|) -1 is returned. When {count} is given use the {count}'th match. When a match is found in a String the search for the next one starts one character further. Thus this example results in 1: echo match("testing", "..", 0, 2) In a |List| the search continues in the next item. Note that when {count} is added the way {start} works changes, see above. See |pattern| for the patterns that are accepted. The 'ignorecase' option is used to set the ignore-caseness of the pattern. 'smartcase' is NOT used. The matching is always done like 'magic' is set and 'cpoptions' is empty. Note that a match at the start is preferred, thus when the pattern is using "*" (any number of matches) it tends to find zero matches at the start instead of a number of matches further down in the text. Can also be used as a |method|: GetList()->match('word')

Defines a pattern to be highlighted in the current window (a "match"). It will be highlighted with {group}. Returns an identification number (ID), which can be used to delete the match using |matchdelete()|. The ID is bound to the window. Matching is case sensitive and magic, unless case sensitivity or magicness are explicitly overridden in {pattern}. The 'magic', 'smartcase' and 'ignorecase' options are not used. The "Conceal" value is special, it causes the match to be concealed. The optional {priority} argument assigns a priority to the match. A match with a high priority will have its highlighting overrule that of a match with a lower priority. A priority is specified as an integer (negative numbers are no exception). If the {priority} argument is not specified, the default priority is 10. The priority of 'hlsearch' is zero, hence all matches with a priority greater than zero will overrule it. Syntax highlighting (see 'syntax') is a separate mechanism, and regardless of the chosen priority a match will always overrule syntax highlighting. The optional {id} argument allows the request for a specific match ID. If a specified ID is already taken, an error message will appear and the match will not be added. An ID is specified as a positive integer (zero excluded). IDs 1, 2 and 3 are reserved for |:match|, |:2match| and |:3match|, respectively. If the {id} argument is not specified or -1, |matchadd()| automatically chooses a free ID. The optional {dict} argument allows for further custom values. Currently this is used to specify a match specific conceal character that will be shown for |hl-Conceal| highlighted matches. The dict can have the following members: conceal Special character to show instead of the match (only for |hl-Conceal| highlighted matches, see |:syn-cchar|) window Instead of the current window use the window with this number or window ID. The number of matches is not limited, as it is the case with the |:match| commands. Example: :highlight MyGroup ctermbg=green guibg=green :let m = matchadd("MyGroup", "TODO") Deletion of the pattern: :call matchdelete(m) A list of matches defined by |matchadd()| and |:match| are available from |getmatches()|. All matches can be deleted in one operation by |clearmatches()|. Can also be used as a |method|: GetGroup()->matchadd('TODO')

Same as |matchadd()|, but requires a list of positions {pos} instead of a pattern. This command is faster than |matchadd()| because it does not require to handle regular expressions and sets buffer line boundaries to redraw screen. It is supposed to be used when fast match additions and deletions are required, for example to highlight matching parentheses. {pos} is a list of positions. Each position can be one of these:

• A number. This whole line will be highlighted. The first line has number 1.
• A list with one number, e.g., [23]. The whole line with this number will be highlighted.
• A list with two numbers, e.g., [23, 11]. The first number is the line number, the second one is the column number (first column is 1, the value must correspond to the byte index as |col()| would return). The character at this position will be highlighted.
• A list with three numbers, e.g., [23, 11, 3]. As above, but the third number gives the length of the highlight in bytes. The maximum number of positions in {pos} is 8. Example: :highlight MyGroup ctermbg=green guibg=green :let m = matchaddpos("MyGroup", [[23, 24], 34]) Deletion of the pattern: :call matchdelete(m) Matches added by |matchaddpos()| are returned by |getmatches()|. Can also be used as a |method|: GetGroup()->matchaddpos([23, 11])

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()

Same as |match()|, but return the index of first character after the match. Example: :echo matchend("testing", "ing") results in "7". Vim doesn't have a strspn() or strcspn() function, but you can 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')

Same as |match()|, but return a |List|. The first item in the list is the matched string, same as what matchstr() would return. Following items are submatches, like "\1", "\2", etc. in |:substitute|. When an optional submatch didn't match an empty string is used. Example: echo matchlist('acd', '(a)?(b)?(c)?(.*)') Results in: ['acd', 'a', '', 'c', 'd', '', '', '', '', ''] When there is no match an empty list is returned. Can also be used as a |method|: GetList()->matchlist('word')

Same as |match()|, but return the matched string. Example: :echo matchstr("testing", "ing") results in "ing". When there is no match "" is returned. The {start}, if given, has the same meaning as for |match()|. :echo matchstr("testing", "ing", 2) results in "ing". :echo matchstr("testing", "ing", 5) result is "". When {expr} is a |List| then the matching item is returned. The type isn't changed, it's not necessarily a String. Can also be used as a |method|: GetText()->matchstr('word')

Same as |matchstr()|, but return the matched string, the start position and the end position of the match. Example: :echo matchstrpos("testing", "ing") results in ["ing", 4, 7]. When there is no match ["", -1, -1] is returned. The {start}, if given, has the same meaning as for |match()|. :echo matchstrpos("testing", "ing", 2) results in ["ing", 4, 7]. :echo matchstrpos("testing", "ing", 5) result is ["", -1, -1]. When {expr} is a |List| then the matching item, the index of first item where {pat} matches, the start position and the end position of the match are returned. :echo matchstrpos([1, '__x'], '\a') result is ["x", 1, 2, 3]. The type isn't changed, it's not necessarily a String. Can also be used as a |method|: GetText()->matchstrpos('word')

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()

Create directory {name}. If {path} is "p" then intermediate directories are created as necessary. Otherwise it must be "". If {prot} is given it is used to set the protection bits of the new directory. The default is 0o755 (rwxr-xr-x: r/w for the user, readable for others). Use 0o700 to make it unreadable for others. This is only used for the last part of {name}. Thus if you create /tmp/foo/bar then /tmp/foo will be created with 0o755. Example: :call mkdir($HOME . "/tmp/foo/bar", "p", 0o700) This function is not available in the |sandbox|. There is no error if the directory already exists and the "p" flag is passed (since patch 8.0.1708). However, without the "p" option the call will fail. The function result is a Number, which is TRUE if the call was successful or FALSE if the directory creation failed or partly failed. Not available on all systems. To check use: :if exists("*mkdir") Can also be used as a |method|: GetName()->mkdir()

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. {lnum} is used like with |getline()|. See also |prevnonblank()|. Can also be used as a |method|: GetLnum()->nextnonblank()

Return a string with a single character, which has the number value {expr}. Examples: nr2char(64) returns "@" nr2char(32) returns " " When {utf8} is omitted or zero, the current 'encoding' is used. Example for "utf-8": nr2char(300) returns I with bow character With {utf8} set to 1, always return utf-8 characters. Note that a NUL character in the file is specified with nr2char(10), because NULs are represented with newline characters. nr2char(0) is a real NUL and terminates the string, thus results in an empty string. To turn a list of character numbers into a string: let list = [65, 66, 67] let str = join(map(list, {_, val -> nr2char(val)}), '') Result: "ABC" Can also be used as a |method|: GetNumber()->nr2char()

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 {path} 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] Note that in a :def function local variables are not visible to {expr}. 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. {lnum} is used like with |getline()|. Also see |nextnonblank()|. Can also be used as a |method|: GetLnum()->prevnonblank()

Return a String with {fmt}, where "%" items are replaced by the formatted form of their respective arguments. Example: printf("%4d: E%d %.30s", lnum, errno, msg) May result in: " 99: E42 asdfasdfasdfasdfasdfasdfasdfas" ~ When used as a |method| the base is passed as the second argument: Compute()->printf("result: %d") Often used items are: %s string %6S string right-aligned in 6 display cells %6s string right-aligned in 6 bytes %.9s string truncated to 9 bytes %c single byte %d decimal number %5d decimal number padded with spaces to 5 characters %x hex number %04x hex number padded with zeros to at least 4 characters %X hex number using upper case letters %o octal number %08b binary number padded with zeros to at least 8 chars %f floating point number as 12.23, inf, -inf or nan %F floating point number as 12.23, INF, -INF or NAN %e floating point number as 1.23e3, inf, -inf or nan %E floating point number as 1.23E3, INF, -INF or NAN %g floating point number, as %f or %e depending on value %G floating point number, as %F or %E depending on value %% the % character itself Conversion specifications start with '%' and end with the conversion type. All other characters are copied unchanged to the result. The "%" starts a conversion specification. The following arguments appear in sequence: % [flags] [field-width] [.precision] type flags Zero or more of the following flags: # The value should be converted to an "alternate form". For c, d, and s conversions, this option has no effect. For o conversions, the precision of the number is increased to force the first character of the output string to a zero (except if a zero value is printed with an explicit precision of zero). For b and B conversions, a non-zero result has the string "0b" (or "0B" for B conversions) prepended to it. For x and X conversions, a non-zero result has the string "0x" (or "0X" for X conversions) prepended to it. 0 (zero) Zero padding. For all conversions the converted value is padded on the left with zeros rather than blanks. If a precision is given with a numeric conversion (d, b, B, o, x, and X), the 0 flag is ignored. - A negative field width flag; the converted value is to be left adjusted on the field boundary. The converted value is padded on the right with blanks, rather than on the left with blanks or zeros. A - overrides a 0 if both are given. ' ' (space) A blank should be left before a positive number produced by a signed conversion (d). + A sign must always be placed before a number produced by a signed conversion. A + overrides a space if both are used. field-width An optional decimal digit string specifying a minimum field width. If the converted value has fewer bytes than the field width, it will be padded with spaces on the left (or right, if the left-adjustment flag has been given) to fill out the field width. .precision An optional precision, in the form of a period '.' followed by an optional digit string. If the digit string is omitted, the precision is taken as zero. This gives the minimum number of digits to appear for d, o, x, and X conversions, or the maximum number of bytes to be printed from a string for s conversions. For floating point it is the number of digits after the decimal point. type A character that specifies the type of conversion to be applied, see below. A field width or precision, or both, may be indicated by an asterisk '*' instead of a digit string. In this case, a Number argument supplies the field width or precision. A negative field width is treated as a left adjustment flag followed by a positive field width; a negative precision is treated as though it were missing. Example: :echo printf("%d: %.*s", nr, width, line) This limits the length of the text used from "line" to "width" bytes. The conversion specifiers and their meanings are: dbBoxX The Number argument is converted to signed decimal (d), unsigned binary (b and B), unsigned octal (o), or unsigned hexadecimal (x and X) notation. The letters "abcdef" are used for x conversions; the letters "ABCDEF" are used for X conversions. The precision, if any, gives the minimum number of digits that must appear; if the converted value requires fewer digits, it is padded on the left with zeros. In no case does a non-existent or small field width cause truncation of a numeric field; if the result of a conversion is wider than the field width, the field is expanded to contain the conversion result. The 'h' modifier indicates the argument is 16 bits. The 'l' modifier indicates the argument is 32 bits. The 'L' modifier indicates the argument is 64 bits. Generally, these modifiers are not useful. They are ignored when type is known from the argument. i alias for d D alias for ld U alias for lu O alias for lo c The Number argument is converted to a byte, and the resulting character is written. s The text of the String argument is used. If a precision is specified, no more bytes than the number specified are used. If the argument is not a String type, it is automatically converted to text with the same format as ":echo". S The text of the String argument is used. If a precision is specified, no more display cells than the number specified are used. f F The Float argument is converted into a string of the form 123.456. The precision specifies the number of digits after the decimal point. When the precision is zero the decimal point is omitted. When the precision is not specified 6 is used. A really big number (out of range or dividing by zero) results in "inf" or "-inf" with %f (INF or -INF with %F). "0.0 / 0.0" results in "nan" with %f (NAN with %F). Example: echo printf("%.2f", 12.115) 12.12 Note that roundoff depends on the system libraries. Use |round()| when in doubt. e E The Float argument is converted into a string of the form 1.234e+03 or 1.234E+03 when using 'E'. The precision specifies the number of digits after the decimal point, like with 'f'. g G The Float argument is converted like with 'f' if the value is between 0.001 (inclusive) and 10000000.0 (exclusive). Otherwise 'e' is used for 'g' and 'E' for 'G'. When no precision is specified superfluous zeroes and '+' signs are removed, except for the zero immediately after the decimal point. Thus 10000000.0 results in 1.0e7. % A '%' is written. No argument is converted. The complete conversion specification is "%%". When a Number argument is expected a String argument is also accepted and automatically converted. When a Float or String argument is expected a Number argument is also accepted and automatically converted. Any other argument type results in an error message. The number of {exprN} arguments must exactly match the number of "%" items. If there are not sufficient or too many arguments an error is given. Up to 18 arguments can be used.

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() {only available when compiled with the |+channel| feature}

Set prompt 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". The callback is invoked when pressing Enter. The current buffer will always be the prompt buffer. A new line for a prompt is added before invoking the callback, thus the prompt for which the callback was invoked will be in the last but one line. If the callback wants to add text to the buffer, it must insert it above the last line, since that is where the current prompt is. This can also be done asynchronously. The callback is invoked with one argument, which is the text that was entered at the prompt. This can be an empty string if the user only typed Enter. Example: call prompt_setcallback(bufnr(), function('s:TextEntered')) func s:TextEntered(text) if a:text == 'exit' || a:text == 'quit' stopinsert close else call append(line('$') - 1, 'Entered: "' . a:text . '"') " Reset 'modified' to allow the buffer to be closed. set nomodified endif endfunc Can also be used as a |method|: GetBuffer()->prompt_setcallback(callback) {only available when compiled with the |+channel| feature}

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) {only available when compiled with the |+channel| feature}

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: ') {only available when compiled with the |+channel| feature}

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. Note that in a :def function local variables are not visible to {expr}. 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. Note that in a :def function local variables are not visible to {expr}. 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 a |List| with Numbers:

• If only {expr} is specified: [0, 1, ..., {expr} - 1]
• If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
• If {stride} is specified: [{expr}, {expr} + {stride}, ..., {max}] (increasing {expr} with {stride} each time, not producing a value past {max}). When the maximum is one before the start the result is an empty list. When the maximum is more than one before the start this is an error. Examples: range(4) " [0, 1, 2, 3] range(2, 4) " [2, 3, 4] range(2, 9, 3) " [2, 5, 8] range(2, -2, -1) " [2, 1, 0, -1, -2] range(0) " [] range(2, 0) " error! Can also be used as a |method|: GetExpr()->range()

Return a list with file and directory names in {directory}. You can also use |glob()| if you don't need to do complicated things, such as limiting the number of matches. The list will be sorted (case sensitive), see the {dict} argument below for changing the sort order. When {expr} is omitted all entries are included. When {expr} is given, it is evaluated to check what to do: If {expr} results in -1 then no further entries will be handled. If {expr} results in 0 then this entry will not be added to the list. If {expr} results in 1 then this entry will be added to the list. The entries "." and ".." are always excluded. Each time {expr} is evaluated |v:val| is set to the entry name. When {expr} is a function the name is passed as the argument. For example, to get a list of files ending in ".txt": readdir(dirname, {n -> n =~ '.txt$'}) To skip hidden and backup files: readdir(dirname, {n -> n !~ '^.|~$'}) The optional {dict} argument allows for further custom values. Currently this is used to specify if and how sorting should be performed. The dict can have the following members: sort How to sort the result returned from the system. Valid values are: "none" do not sort (fastest method) "case" sort case sensitive (byte value of each character, technically, using strcmp()) (default) "icase" sort case insensitive (technically using strcasecmp()) "collate" sort using the collation order of the "POSIX" or "C" |locale| (technically using strcoll()) Other values are silently ignored. For example, to get a list of all files in the current directory without sorting the individual entries: readdir('.', '1', #{sort: 'none'}) If you want to get a directory tree: function! s:tree(dir) return {a:dir : map(readdir(a:dir), \ {_, x -> isdirectory(x) ? \ {x : s:tree(a:dir . '/' . x)} : x})} endfunction echo s:tree(".") Can also be used as a |method|: GetDirName()->readdir()

Read file {fname} and return a |List|, each line of the file as an item. Lines are broken at NL characters. Macintosh files separated with CR will result in a single long line (unless a NL appears somewhere). All NUL characters are replaced with a NL character. When {type} contains "b" binary mode is used:

• When the last line ends in a NL an extra empty list item is added.
• No CR characters are removed. Otherwise:
• CR characters that appear before a NL are removed.
• Whether the last line ends in a NL or not does not matter.
• When 'encoding' is Unicode any UTF-8 byte order mark is removed from the text. When {max} is given this specifies the maximum number of lines to be read. Useful if you only want to check the first ten lines of a file: :for line in readfile(fname, '', 10) : if line =~ 'Date' | echo line | endif :endfor When {max} is negative -{max} lines from the end of the file are returned, or as many as there are. When {max} is zero the result is an empty list. Note that without {max} the whole file is read into memory. Also note that there is no recognition of encoding. Read a file into a buffer if you need to. Deprecated (use |readblob()| instead): When {type} contains "B" a |Blob| is returned with the binary data of the file unmodified. When the file can't be opened an error message is given and the result is an empty list. Also see |writefile()|. Can also be used as a |method|: GetFileName()->readfile()

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(). If there is an error zero is returned in legacy script, in Vim9 script an error is given. 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|. If there is an error 0.0 is returned in legacy script, in Vim9 script an error is given. 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|. If there is an error an empty string is returned in legacy script, in Vim9 script an error is given. Can also be used as a |method|: reltime(start)->reltimestr() {only available when compiled with the |+reltime| feature}

Send the {string} to {server}. The string is sent as an expression and the result is returned after evaluation. The result must be a String or a |List|. A |List| is turned into a String by joining the items with a line break in between (not at the end), like with join(expr, "\n"). If {idvar} is present and not empty, it is taken as the name of a variable and a {serverid} for later use with |remote_read()| is stored there. If {timeout} is given the read times out after this many seconds. Otherwise a timeout of 600 seconds is used. See also |clientserver| |RemoteReply|. This function is not available in the |sandbox|. {only available when compiled with the |+clientserver| feature} Note: Any errors will cause a local error message to be issued and the result will be the empty string. Variables will be evaluated in the global namespace, independent of a function currently being active. Except when in debug mode, then local function variables and arguments can be evaluated. Examples: :echo remote_expr("gvim", "2+2") :echo remote_expr("gvim1", "b:current_syntax") Can also be used as a |method|: ServerName()->remote_expr(expr)

Move the Vim server with the name {server} to the foreground. The {server} argument is a string. 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()

Send the {string} to {server}. The string is sent as input keys and the function returns immediately. At the Vim server the keys are not mapped |:map|. If {idvar} is present, it is taken as the name of a variable and a {serverid} for later use with remote_read() is stored there. See also |clientserver| |RemoteReply|. This function is not available in the |sandbox|. {only available when compiled with the |+clientserver| feature} Note: Any errors will be reported in the server and may mess up the display. Examples: :echo remote_send("gvim", ":DropAndReply ".file, "serverid"). \ remote_read(serverid) :autocmd NONE RemoteReply * \ echo remote_read(expand("")) :echo remote_send("gvim", ":sleep 10 | echo ". \ 'server2client(expand(""), "HELLO")') Can also be used as a |method|: ServerName()->remote_send(keys)

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)

On MS-Windows, when {filename} is a shortcut (a .lnk file), returns the path the shortcut points to in a simplified form. When {filename} is a symbolic link or junction point, return the full path to the target. If the target of junction is removed, return {filename}. On Unix, repeat resolving symbolic links in all path components of {filename} and return the simplified result. To cope with link cycles, resolving of symbolic links is stopped after 100 iterations. On other systems, return the simplified {filename}. The simplification step is done as by |simplify()|. resolve() keeps a leading path component specifying the current directory (provided the result is still a relative path name) and also keeps a trailing path separator. Can also be used as a |method|: GetName()->resolve()

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. Note that in a :def function local variables are not visible to {expr}. 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 |List| of Numbers. The first number is the same as what |screenchar()| returns. Further numbers are composing characters on top of the base character. This is mainly to be used for testing. Returns an empty List when row or col is out of range. Can also be used as a |method|: GetRow()->screenchars(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()|.

The result is a String that contains the base character and any composing characters at position [row, col] on the screen. This is like |screenchars()| but returning a String with the characters. This is mainly to be used for testing. Returns an empty String when row or col is out of range. Can also be used as a |method|: GetRow()->screenstring(col)

Search for regexp pattern {pattern}. The search starts at the cursor position (you can use |cursor()| to set it). When a match has been found its line number is returned. If there is no match a 0 is returned and the cursor doesn't move. No error message is given. {flags} is a String, which can contain these character flags: 'b' search Backward instead of forward 'c' accept a match at the Cursor position 'e' move to the End of the match 'n' do Not move the cursor 'p' return number of matching sub-Pattern (see below) 's' Set the ' mark at the previous location of the cursor 'w' Wrap around the end of the file 'W' don't Wrap around the end of the file 'z' start searching at the cursor column instead of zero If neither 'w' or 'W' is given, the 'wrapscan' option applies. If the 's' flag is supplied, the ' mark is set, only if the cursor is moved. The 's' flag cannot be combined with the 'n' flag. 'ignorecase', 'smartcase' and 'magic' are used. When the 'z' flag is not given, forward searching always starts in column zero and then matches before the cursor are skipped. When the 'c' flag is present in 'cpo' the next search starts after the match. Without the 'c' flag the next search starts one column further. This matters for overlapping matches. When searching backwards and the 'z' flag is given then the search starts in column zero, thus no match in the current line will be found (unless wrapping around the end of the file). When the {stopline} argument is given then the search stops after searching this line. This is useful to restrict the search to a range of lines. Examples: let match = search('(', 'b', line("w0")) let end = search('END', '', line("w$")) When {stopline} is used and it is not zero this also implies that the search does not wrap around the end of the file. A zero value is equal to not giving the argument. When the {timeout} argument is given the search stops when more than this many milliseconds have passed. Thus when {timeout} is 500 the search stops after half a second. The value must not be negative. A zero value is like not giving the argument. {only available when compiled with the |+reltime| feature} If the {skip} expression is given it is evaluated with the cursor positioned on the start of a match. If it evaluates to non-zero this match is skipped. This can be used, for example, to skip a match in a comment or a string. {skip} can be a string, which is evaluated as an expression, a function reference or a lambda. When {skip} is omitted or empty, every match is accepted. When evaluating {skip} causes an error the search is aborted and -1 returned. With the 'p' flag the returned value is one more than the first sub-match in (). One if none of them matched but the whole pattern did match. To get the column number too use |searchpos()|. The cursor will be positioned at the match, unless the 'n' flag is used. Example (goes over all files in the argument list): :let n = 1 :while n <= argc() " loop over all files in arglist : exe "argument " . n : " start at the last char in the file and wrap for the : " first search to find match at start of file : normal G$ : let flags = "w" : while search("foo", flags) > 0 : s/foo/bar/g : let flags = "W" : endwhile : update " write the file if modified : let n = n + 1 :endwhile Example for using some flags: :echo search('<if|(else)|(endif)', 'ncpe') This will search for the keywords "if", "else", and "endif" under or after the cursor. Because of the 'p' flag, it returns 1, 2, or 3 depending on which keyword is found, or 0 if the search fails. With the cursor on the first word of the line: if (foo == 0) | let foo = foo + 1 | endif ~ the function returns 1. Without the 'c' flag, the function finds the "endif" and returns 3. The same thing happens without the 'e' flag if the cursor is on the "f" of "if". The 'n' flag tells the function not to move the cursor. Can also be used as a |method|: GetPattern()->search()

Get or update the last search count, like what is displayed without the "S" flag in 'shortmess'. This works even if 'shortmess' does contain the "S" flag. This returns a |Dictionary|. The dictionary is empty if the previous pattern was not set and "pattern" was not specified. key type meaning ~ current |Number| current position of match; 0 if the cursor position is before the first match exact_match |Boolean| 1 if "current" is matched on "pos", otherwise 0 total |Number| total count of matches found incomplete |Number| 0: search was fully completed 1: recomputing was timed out 2: max count exceeded For {options} see further down. To get the last search count when |n| or |N| was pressed, call this function with recompute: 0 . This sometimes returns wrong information because |n| and |N|'s maximum count is 99. If it exceeded 99 the result must be max count + 1 (100). If you want to get correct information, specify recompute: 1: " result == maxcount + 1 (100) when many matches let result = searchcount(#{recompute: 0}) " Below returns correct result (recompute defaults " to 1) let result = searchcount() The function is useful to add the count to |statusline|: function! LastSearchCount() abort let result = searchcount(#{recompute: 0}) if empty(result) return '' endif if result.incomplete ==# 1 " timed out return printf(' /%s [?/??]', @/) elseif result.incomplete ==# 2 " max count exceeded if result.total > result.maxcount && \ result.current > result.maxcount return printf(' /%s [>%d/>%d]', @/, \ result.current, result.total) elseif result.total > result.maxcount return printf(' /%s [%d/>%d]', @/, \ result.current, result.total) endif endif return printf(' /%s [%d/%d]', @/, \ result.current, result.total) endfunction let &statusline .= '%{LastSearchCount()}' " Or if you want to show the count only when " 'hlsearch' was on " let &statusline .= " \ '%{v:hlsearch ? LastSearchCount() : ""}' You can also update the search count, which can be useful in a |CursorMoved| or |CursorMovedI| autocommand: autocmd CursorMoved,CursorMovedI * \ let s:searchcount_timer = timer_start( \ 200, function('s:update_searchcount')) function! s:update_searchcount(timer) abort if a:timer ==# s:searchcount_timer call searchcount(#{ \ recompute: 1, maxcount: 0, timeout: 100}) redrawstatus endif endfunction This can also be used to count matched texts with specified pattern in the current buffer using "pattern": " Count '<foo>' in this buffer " (Note that it also updates search count) let result = searchcount(#{pattern: '<foo>'}) " To restore old search count by old pattern, " search again call searchcount() {options} must be a |Dictionary|. It can contain: key type meaning ~ recompute |Boolean| if |TRUE|, recompute the count like |n| or |N| was executed. otherwise returns the last computed result (when |n| or |N| was used when "S" is not in 'shortmess', or this function was called). (default: |TRUE|) pattern |String| recompute if this was given and different with |@/|. this works as same as the below command is executed before calling this function let @/ = pattern (default: |@/|) timeout |Number| 0 or negative number is no timeout. timeout milliseconds for recomputing the result (default: 0) maxcount |Number| 0 or negative number is no limit. max count of matched text while recomputing the result. if search exceeded total count, "total" value becomes maxcount + 1 (default: 99) pos |List| [lnum, col, off] value when recomputing the result. this changes "current" result value. see |cursor()|, |getpos()| (default: cursor's position)

Search for the declaration of {name}. With a non-zero {global} argument it works like |gD|, find first match in the file. Otherwise it works like |gd|, find first match in the function. With a non-zero {thisblock} argument matches in a {} block that ends before the cursor position are ignored. Avoids finding variable declarations only valid in another scope. Moves the cursor to the found match. Returns zero for success, non-zero for failure. Example: if searchdecl('myvar') == 0 echo getline('.') endif Can also be used as a |method|: GetName()->searchdecl()

Search for the match of a nested start-end pair. This can be used to find the "endif" that matches an "if", while other if/endif pairs in between are ignored. The search starts at the cursor. The default is to search forward, include 'b' in {flags} to search backward. If a match is found, the cursor is positioned at it and the line number is returned. If no match is found 0 or -1 is returned and the cursor doesn't move. No error message is given. {start}, {middle} and {end} are patterns, see |pattern|. They must not contain ( ) pairs. Use of %( ) is allowed. When {middle} is not empty, it is found when searching from either direction, but only when not in a nested start-end pair. A typical use is: searchpair('<if>', '<else>', '<endif>') By leaving {middle} empty the "else" is skipped. {flags} 'b', 'c', 'n', 's', 'w' and 'W' are used like with |search()|. Additionally: 'r' Repeat until no more matches found; will find the outer pair. Implies the 'W' flag. 'm' Return number of matches instead of line number with the match; will be > 1 when 'r' is used. Note: it's nearly always a good idea to use the 'W' flag, to avoid wrapping around the end of the file. When a match for {start}, {middle} or {end} is found, the {skip} expression is evaluated with the cursor positioned on the start of the match. It should return non-zero if this match is to be skipped. E.g., because it is inside a comment or a string. When {skip} is omitted or empty, every match is accepted. When evaluating {skip} causes an error the search is aborted and -1 returned. {skip} can be a string, a lambda, a funcref or a partial. Anything else makes the function fail. In a :def function when the {skip} argument is a string constant it is compiled into instructions. For {stopline} and {timeout} see |search()|. The value of 'ignorecase' is used. 'magic' is ignored, the patterns are used like it's on. The search starts exactly at the cursor. A match with {start}, {middle} or {end} at the next character, in the direction of searching, is the first one found. Example: if 1 if 2 endif 2 endif 1 When starting at the "if 2", with the cursor on the "i", and searching forwards, the "endif 2" is found. When starting on the character just before the "if 2", the "endif 1" will be found. That's because the "if 2" will be found first, and then this is considered to be a nested if/endif from "if 2" to "endif 2". When searching backwards and {end} is more than one character, it may be useful to put "\zs" at the end of the pattern, so that when the cursor is inside a match with the end it finds the matching start. Example, to find the "endif" command in a Vim script: :echo searchpair('<if>', '<el%[seif]>', '<en%[dif]>', 'W', \ 'getline(".") =~ "^\s*""') The cursor must be at or after the "if" for which a match is to be found. Note that single-quote strings are used to avoid having to double the backslashes. The skip expression only catches comments at the start of a line, not after a command. Also, a word "en" or "if" halfway a line is considered a match. Another example, to search for the matching "{" of a "}": :echo searchpair('{', '', '}', 'bW') This works when the cursor is at or before the "}" for which a match is to be found. To reject matches that syntax highlighting recognized as strings: :echo searchpair('{', '', '}', 'bW', \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')

Same as |searchpair()|, but returns a |List| with the line and column position of the match. The first element of the |List| is the line number and the second element is the byte index of the column position of the match. If no match is found, returns [0, 0]. :let [lnum,col] = searchpairpos('{', '', '}', 'n') See |match-parens| for a bigger and more useful example.

Same as |search()|, but returns a |List| with the line and column position of the match. The first element of the |List| is the line number and the second element is the byte index of the column position of the match. If no match is found, returns [0, 0]. Example: :let [lnum, col] = searchpos('mypattern', 'n') When the 'p' flag is given then there is an extra item with the sub-pattern match number |search()-sub-match|. Example: :let [lnum, col, submatch] = searchpos('(\l)|(\u)', 'np') In this example "submatch" is 2 when a lowercase letter is found |/\l|, 3 when an uppercase letter is found |/\u|. Can also be used as a |method|: GetPattern()->searchpos()

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 option or local variable {varname} in buffer {buf} to {val}. This also works for a global or local window option, but it doesn't work for a global or local window variable. For a local window option the global value is unchanged. For the use of {buf}, see |bufname()| above. The {varname} argument is a string. Note that the variable name without "b:" must be used. Examples: :call setbufvar(1, "&mod", 1) :call setbufvar("todo", "myvar", "foobar") This function is not available in the |sandbox|. Can also be used as a |method|, the base is passed as the third argument: GetValue()->setbufvar(buf, varname)

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}. Example: call setenv('HOME', '/home/myhome') 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 the file permissions for {fname} to {mode}. {mode} must be a string with 9 characters. It 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. A '-' character means the permission is off, any other character means on. Multi-byte characters are not supported. For example "rw-r-----" means read-write for the user, readable by the group, not accessible by others. "xx-x-----" would do the same thing. Returns non-zero for success, zero for failure. Can also be used as a |method|: GetFilename()->setfperm(mode) To read permissions see |getfperm()|.

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

Create or replace or add to the location list for window {nr}. {nr} can be the window number or the |window-ID|. When {nr} is zero the current window is used. For a location list window, the displayed location list is modified. For an invalid window number {nr}, -1 is returned. Otherwise, same as |setqflist()|. Also see |location-list|. For {action} see |setqflist-action|. If the optional {what} dictionary argument is supplied, then only the items listed in {what} are set. Refer to |setqflist()| for the list of supported keys in {what}. Can also be used as a |method|, the base is passed as the second argument: GetLoclist()->setloclist(winnr)

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('.')

Create or replace or add to the quickfix list. If the optional {what} dictionary argument is supplied, then only the items listed in {what} are set. The first {list} argument is ignored. See below for the supported items in {what}. When {what} is not present, the items in {list} are used. Each item must be a dictionary. Non-dictionary items in {list} are ignored. Each dictionary item can contain the following entries: bufnr buffer number; must be the number of a valid buffer filename name of a file; only used when "bufnr" is not present or it is invalid. module name of a module; if given it will be used in quickfix error window instead of the filename. lnum line number in the file pattern search pattern used to locate the error col column number vcol when non-zero: "col" is visual column when zero: "col" is byte index nr error number text description of the error type single-character error type, 'E', 'W', etc. valid recognized error message The "col", "vcol", "nr", "type" and "text" entries are optional. Either "lnum" or "pattern" entry can be used to locate a matching error line. If the "filename" and "bufnr" entries are not present or neither the "lnum" or "pattern" entries are present, then the item will not be handled as an error line. If both "pattern" and "lnum" are present then "pattern" will be used. If the "valid" entry is not supplied, then the valid flag is set when "bufnr" is a valid buffer or "filename" exists. If you supply an empty {list}, the quickfix list will be cleared. Note that the list is not exactly the same as what |getqflist()| returns. {action} values: 'a' The items from {list} are added to the existing quickfix list. If there is no existing list, then a new list is created. 'r' The items from the current quickfix list are replaced with the items from {list}. This can also be used to clear the list: :call setqflist([], 'r') 'f' All the quickfix lists in the quickfix stack are freed. If {action} is not present or is set to ' ', then a new list is created. The new quickfix list is added after the current quickfix list in the stack and all the following lists are freed. To add a new quickfix list at the end of the stack, set "nr" in {what} to "$". The following items can be specified in dictionary {what}: context quickfix list context. See |quickfix-context| efm errorformat to use when parsing text from "lines". If this is not present, then the 'errorformat' option value is used. See |quickfix-parse| id quickfix list identifier |quickfix-ID| idx index of the current entry in the quickfix list specified by 'id' or 'nr'. If set to '$', then the last entry in the list is set as the current entry. See |quickfix-index| items list of quickfix entries. Same as the {list} argument. lines use 'errorformat' to parse a list of lines and add the resulting entries to the quickfix list {nr} or {id}. Only a |List| value is supported. See |quickfix-parse| nr list number in the quickfix stack; zero means the current quickfix list and "$" means the last quickfix list. quickfixtextfunc function to get the text to display in the quickfix window. The value can be the name of a function or a funcref or a lambda. Refer to |quickfix-window-function| for an explanation of how to write the function and an example. title quickfix list title text. See |quickfix-title| Unsupported keys in {what} are ignored. If the "nr" item is not present, then the current quickfix list is modified. When creating a new quickfix list, "nr" can be set to a value one greater than the quickfix stack size. When modifying a quickfix list, to guarantee that the correct list is modified, "id" should be used instead of "nr" to specify the list. Examples (See also |setqflist-examples|): :call setqflist([], 'r', {'title': 'My search'}) :call setqflist([], 'r', {'nr': 2, 'title': 'Errors'}) :call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]}) Returns zero for success, -1 for failure. This function can be used to create a quickfix list independent of the 'errorformat' setting. Use a command like :cc 1 to jump to the first position. Can also be used as a |method|, the base is passed as the second argument: GetErrorlist()->setqflist()

Set the register {regname} to {value}. If {regname} is "" or "@", the unnamed register '"' is used. The {regname} argument is a string. In |Vim9-script| {regname} must be one character. {value} may be any value returned by |getreg()| or |getreginfo()|, including a |List| or |Dict|. If {options} contains "a" or {regname} is upper case, then the value is appended. {options} can also contain a register type specification: "c" or "v" |characterwise| mode "l" or "V" |linewise| mode "b" or "" |blockwise-visual| mode If a number immediately follows "b" or "" then this is used as the width of the selection - if it is not specified then the width of the block is set to the number of characters in the longest line (counting a as 1 character). If {options} contains no register settings, then the default is to use character mode unless {value} ends in a for string {value} and linewise mode for list {value}. Blockwise mode is never selected automatically. Returns zero for success, non-zero for failure. Note: you may not use |List| containing more than one item to set search and expression registers. Lists containing no items act like empty strings. Examples: :call setreg(v:register, @) :call setreg('', @%, 'ac') :call setreg('a', "1\n2\n3", 'b5') :call setreg('"', { 'points_to': 'a'}) This example shows using the functions to save and restore a register: :let var_a = getreginfo() :call setreg('a', var_a) or: :let var_a = getreg('a', 1, 1) :let var_amode = getregtype('a') .... :call setreg('a', var_a, var_amode) Note: you may not reliably restore register value without using the third argument to |getreg()| as without it newlines are represented as newlines AND Nul bytes are represented as newlines as well, see |NL-used-for-Nul|. You can also change the type of a register by appending nothing: :call setreg('a', '', 'al') Can also be used as a |method|, the base is passed as the second argument: GetText()->setreg('a')

Set tab-local variable {varname} to {val} in tab page {tabnr}. |t:var| The {varname} argument is a string. 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)

Set option or local variable {varname} in window {winnr} to {val}. Tabs are numbered starting with one. For the current tabpage use |setwinvar()|. {winnr} can be the window number or the |window-ID|. When {winnr} is zero the current window is used. Note that autocommands are blocked, side effects may not be triggered, e.g. when setting 'filetype' or 'syntax'. This also works for a global or local buffer option, but it doesn't work for a global or local buffer variable. For a local buffer option the global value is unchanged. Note that the variable name without "w:" must be used. Examples: :call settabwinvar(1, 1, "&list", 0) :call settabwinvar(3, 2, "myvar", "foobar") This function is not available in the |sandbox|. Can also be used as a |method|, the base is passed as the fourth argument: GetValue()->settabvar(tab, winnr, name)

Modify the tag stack of the window {nr} using {dict}. {nr} can be the window number or the |window-ID|. For a list of supported items in {dict}, refer to |gettagstack()|. "curidx" takes effect before changing the tag stack. How the tag stack is modified depends on the {action} argument:

• If {action} is not present or is set to 'r', then the tag stack is replaced.
• If {action} is set to 'a', then new entries from {dict} are pushed (added) onto the tag stack.
• If {action} is set to 't', then all the entries from the current entry in the tag stack or "curidx" in {dict} are removed and then new entries are pushed to the stack. The current index is set to one after the length of the tag stack after the modification. Returns zero for success, -1 for failure. Examples (for more examples see |tagstack-examples|): Empty the tag stack of window 3: call settagstack(3, {'items' : []}) Save and restore the tag stack: let stack = gettagstack(1003) " do something else call settagstack(1003, stack) unlet stack Can also be used as a |method|, the base is passed as the second argument: GetStack()->settagstack(winnr)

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}

Escape {string} for use as a shell command argument. When the 'shell' contains powershell (MS-Windows) or pwsh (MS-Windows, Linux, and MacOS) then it will enclose {string} in single quotes and will double up all internal single quotes. On MS-Windows, when 'shellslash' is not set, it will enclose {string} in double quotes and double all double quotes within {string}. Otherwise it will enclose {string} in single quotes and replace all "'" with "'''". When the {special} argument is present and it's a non-zero Number or a non-empty String (|non-zero-arg|), then special items such as "!", "%", "#" and "" will be preceded by a backslash. This backslash will be removed again by the |:!| command. The "!" character will be escaped (again with a |non-zero-arg| {special}) when 'shell' contains "csh" in the tail. That is because for csh and tcsh "!" is used for history replacement even when inside single quotes. With a |non-zero-arg| {special} the character is also escaped. When 'shell' containing "csh" in the tail it's escaped a second time. The "" character will be escaped when 'shell' contains "fish" in the tail. That is because for fish "" is used as an escape character inside single quotes. Example of use with a |:!| command: :exe '!dir ' . shellescape(expand(''), 1) This results in a directory listing for the file under the cursor. Example of use with |system()|: :call system("chmod +w -- " . shellescape(expand("%"))) See also |::S|. Can also be used as a |method|: GetCommand()->shellescape()

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()

Simplify the file name as much as possible without changing the meaning. Shortcuts (on MS-Windows) or symbolic links (on Unix) are not resolved. If the first path component in {filename} designates the current directory, this will be valid for the result as well. A trailing path separator is not removed either. On Unix "//path" is unchanged, but "///path" is simplified to "/path" (this follows the Posix standard). Example: simplify("./dir/.././/file/") == "./file/" Note: The combination "dir/.." is only removed if "dir" is a searchable directory or does not exist. On Unix, it is also removed when "dir" is a symbolic link within the same directory. In order to resolve all the involved symbolic links before simplifying the path name, use |resolve()|. Can also be used as a |method|: GetName()->simplify()

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}

Sort the items in {list} in-place. Returns {list}. If you want a list to remain unmodified make a copy first: :let sortedlist = sort(copy(mylist)) When {func} is omitted, is empty or zero, then sort() uses the string representation of each item to sort on. Numbers sort after Strings, |Lists| after Numbers. For sorting text in the current buffer use |:sort|. When {func} is given and it is '1' or 'i' then case is ignored. When {func} is given and it is 'l' then the current collation locale is used for ordering. Implementation details: strcoll() is used to compare strings. See |:language| check or set the collation locale. |v:collate| can also be used to check the current locale. Sorting using the locale typically ignores case. Example: " ö is sorted similarly to o with English locale. :language collate en_US.UTF8 :echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l') ['n', 'o', 'O', 'ö', 'p', 'z'] ~ " ö is sorted after z with Swedish locale. :language collate sv_SE.UTF8 :echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l') ['n', 'o', 'O', 'p', 'z', 'ö'] ~ This does not work properly on Mac. When {func} is given and it is 'n' then all items will be sorted numerical (Implementation detail: this uses the strtod() function to parse numbers, Strings, Lists, Dicts and Funcrefs will be considered as being 0). When {func} is given and it is 'N' then all items will be sorted numerical. This is like 'n' but a string containing digits will be used as the number they represent. When {func} is given and it is 'f' then all items will be sorted numerical. All values must be a Number or a Float. When {func} is a |Funcref| or a function name, this function is called to compare items. The function is invoked with two items as argument and must return zero if they are equal, 1 or bigger if the first one sorts after the second one, -1 or smaller if the first one sorts before the second one. {dict} is for functions with the "dict" attribute. It will be used to set the local variable "self". |Dictionary-function| The sort is stable, items which compare equal (as number or as string) will keep their relative position. E.g., when sorting on numbers, text strings will sort next to each other, in the same order as they were originally. Can also be used as a |method|: mylist->sort() Also see |uniq()|. Example: func MyCompare(i1, i2) return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1 endfunc eval mylist->sort("MyCompare") A shorter compare version for this specific simple case, which ignores overflow: func MyCompare(i1, i2) return a:i1 - a:i2 endfunc For a simple expression you can use a lambda: eval mylist->sort({i1, i2 -> i1 - i2})

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()

Without argument: The result is the badly spelled word under or after the cursor. The cursor is moved to the start of the bad word. When no bad word is found in the cursor line the result is an empty string and the cursor doesn't move. With argument: The result is the first word in {sentence} that is badly spelled. If there are no spelling mistakes the result is an empty string. The return value is a list with two items:

• The badly spelled word or an empty string.
• The type of the spelling error: "bad" spelling mistake "rare" rare word "local" word only valid in another region "caps" word should start with Capital Example: echo spellbadword("the quik brown fox") ['quik', 'bad'] ~ The spelling information for the current window and the value of 'spelllang' are used. Can also be used as a |method|: GetText()->spellbadword()

Return a |List| with spelling suggestions to replace {word}. When {max} is given up to this number of suggestions are returned. Otherwise up to 25 suggestions are returned. When the {capital} argument is given and it's non-zero only suggestions with a leading capital will be given. Use this after a match with 'spellcapcheck'. {word} can be a badly spelled word followed by other text. This allows for joining two words that were split. The suggestions also include the following text, thus you can replace a line. {word} may also be a good word. Similar words will then be returned. {word} itself is not included in the suggestions, although it may appear capitalized. The spelling information for the current window is used. The values of 'spelllang' and 'spellsuggest' are used. Can also be used as a |method|: GetWord()->spellsuggest()

Make a |List| out of {string}. When {pattern} is omitted or empty each white-separated sequence of characters becomes an item. Otherwise the string is split where {pattern} matches, removing the matched characters. 'ignorecase' is not used here, add \c to ignore case. |/\c| When the first or last item is empty it is omitted, unless the {keepempty} argument is given and it's non-zero. Other empty items are kept when {pattern} matches at least one character or when {keepempty} is non-zero. Example: :let words = split(getline('.'), '\W+') To split a string in individual characters: :for c in split(mystring, '\zs') If you want to keep the separator you can also use '\zs' at the end of the pattern: :echo split('abc:def:ghi', ':\zs') ['abc:', 'def:', 'ghi'] ~ Splitting a table where the first element can be empty: :let items = split(line, ':', 1) The opposite function is |join()|. Can also be used as a |method|: GetString()->split()

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 {string} 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. When {quoted} is present and non-zero then embedded single quotes before the dot are ignored, thus "1'000.0" is a thousand. 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 {string}. 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()

Convert string {string} to a number. {base} is the conversion base, it can be 2, 8, 10 or 16. When {quoted} is present and non-zero then embedded single quotes are ignored, thus "1'000'000" is a million. When {base} is omitted base 10 is used. This also means that a leading zero doesn't cause octal conversion to be used, as with the default String to Number conversion. Example: let nr = str2nr('0123') When {base} is 16 a leading "0x" or "0X" is ignored. With a different base the result will be zero. Similarly, when {base} is 8 a leading "0", "0o" or "0O" is ignored, and when {base} is 2 a leading "0b" or "0B" is ignored. Text after the number is silently ignored. Can also be used as a |method|: GetText()->str2nr()

Vim doesn't have a strcasestr() function. But you can add "\c" to the pattern to ignore case: :let idx = match(haystack, '\cneedle') If {start} is given, the search starts from byte index {start} in a String or item {start} in a |List|. The result, however, is still the index counted from the first character/item. Example: :echo match("testing", "ing", 2) result is again "4". :echo match("testing", "ing", 4) result is again "4". :echo match("testing", "t", 2) result is "3". For a String, if {start} > 0 then it is like the string starts {start} bytes later, thus "^" will match at {start}. Except when {count} is given, then it's like matches before the {start} byte are ignored (this is a bit complicated to keep it backwards compatible). For a String, if {start} < 0, it will be set to 0. For a list the index is counted from the end. If {start} is out of range ({start} > strlen({expr}) for a String or {start} > len({expr}) for a |List|) -1 is returned. When {count} is given use the {count}'th match. When a match is found in a String the search for the next one starts one character further. Thus this example results in 1: echo match("testing", "..", 0, 2) In a |List| the search continues in the next item. Note that when {count} is added the way {start} works changes, see above. See |pattern| for the patterns that are accepted. The 'ignorecase' option is used to set the ignore-caseness of the pattern. 'smartcase' is NOT used. The matching is always done like 'magic' is set and 'cpoptions' is empty. Note that a match at the start is preferred, thus when the pattern is using "*" (any number of matches) it tends to find zero matches at the start instead of a number of matches further down in the text. Can also be used as a |method|: GetList()->match('word')

Like |strpart()| but using character index and length instead of byte index and length. When {skipcc} is omitted or zero, composing characters are counted separately. When {skipcc} set to 1, Composing characters are ignored, similar to |slice()|. When a character index is used where a character does not exist it is omitted and counted as one character. For example: strcharpart('abc', -1, 2) results in 'a'. Can also be used as a |method|: GetText()->strcharpart(5)

The result is a Number, which is the number of characters in String {string}. When {skipcc} is omitted or zero, composing characters are counted separately. When {skipcc} set to 1, Composing characters are ignored. |strcharlen()| always does this. Also see |strlen()|, |strdisplaywidth()| and |strwidth()|. {skipcc} is only available after 7.4.755. For backward compatibility, you can define a wrapper function: if has("patch-7.4.755") function s:strchars(str, skipcc) return strchars(a:str, a:skipcc) endfunction else function s:strchars(str, skipcc) if a:skipcc return strlen(substitute(a:str, ".", "x", "g")) else return strchars(a:str) endif endfunction endif Can also be used as a |method|: GetText()->strchars()

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 {string} 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 {string} 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()

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

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)

The result is a Number, which gives the byte index in {haystack} of the first occurrence of the String {needle}. If {start} is specified, the search starts at index {start}. This can be used to find a second match: :let colon1 = stridx(line, ":") :let colon2 = stridx(line, ":", colon1 + 1) The search is done case-sensitive. For pattern searches use |match()|. -1 is returned if the {needle} does not occur in {haystack}. See also |strridx()|. Examples: :echo stridx("An Example", "Example") 3 :echo stridx("Starting point", "Start") 0 :echo stridx("Starting point", "start") -1 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)

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 {string} 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()

The result is a String, which is part of {src}, starting from byte {start}, with the byte length {len}. When {chars} is present and TRUE then {len} is the number of characters positions (composing characters are not counted separately, thus "1" means one base character and any following composing characters). To count {start} as characters instead of bytes use |strcharpart()|. When bytes are selected which do not exist, this doesn't result in an error, the bytes are simply omitted. If {len} is missing, the copy continues from {start} till the end of the {src}. strpart("abcdefg", 3, 2) == "de" strpart("abcdefg", -2, 4) == "ab" strpart("abcdefg", 5, 4) == "fg" strpart("abcdefg", 3) == "defg" Note: To get the first character, {start} must be 0. For example, to get the character under the cursor: strpart(getline("."), col(".") - 1, 1, v:true) Can also be used as a |method|: GetText()->strpart(5)

:let sepidx = match(line, '[.,;: \t]') Vim doesn't have a strcasestr() function. But you can add "\c" to the pattern to ignore case: :let idx = match(haystack, '\cneedle') If {start} is given, the search starts from byte index {start} in a String or item {start} in a |List|. The result, however, is still the index counted from the first character/item. Example: :echo match("testing", "ing", 2) result is again "4". :echo match("testing", "ing", 4) result is again "4". :echo match("testing", "t", 2) result is "3". For a String, if {start} > 0 then it is like the string starts {start} bytes later, thus "^" will match at {start}. Except when {count} is given, then it's like matches before the {start} byte are ignored (this is a bit complicated to keep it backwards compatible). For a String, if {start} < 0, it will be set to 0. For a list the index is counted from the end. If {start} is out of range ({start} > strlen({expr}) for a String or {start} > len({expr}) for a |List|) -1 is returned. When {count} is given use the {count}'th match. When a match is found in a String the search for the next one starts one character further. Thus this example results in 1: echo match("testing", "..", 0, 2) In a |List| the search continues in the next item. Note that when {count} is added the way {start} works changes, see above. See |pattern| for the patterns that are accepted. The 'ignorecase' option is used to set the ignore-caseness of the pattern. 'smartcase' is NOT used. The matching is always done like 'magic' is set and 'cpoptions' is empty. Note that a match at the start is preferred, thus when the pattern is using "*" (any number of matches) it tends to find zero matches at the start instead of a number of matches further down in the text. Can also be used as a |method|: GetList()->match('word')

The result is a Number, which is a unix timestamp representing the date and time in {timestring}, which is expected to match the format specified in {format}. The accepted {format} depends on your system, thus this is not portable! See the manual page of the C function strptime() for the format. Especially avoid "%c". The value of $TZ also matters. If the {timestring} cannot be parsed with {format} zero is returned. If you do not know the format of {timestring} you can try different {format} values until you get a non-zero result. See also |strftime()|. Examples: :echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23") 862156163 :echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55")) Sun Apr 27 11:53:55 1997 :echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600) Sun Apr 27 12:53:55 1997 Not available on all systems. To check use: :if exists("*strptime")

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

The result is a Number, which gives the byte index in {haystack} of the last occurrence of the String {needle}. When {start} is specified, matches beyond this index are ignored. This can be used to find a match before a previous match: :let lastcomma = strridx(line, ",") :let comma2 = strridx(line, ",", lastcomma - 1) The search is done case-sensitive. For pattern searches use |match()|. -1 is returned if the {needle} does not occur in {haystack}. If the {needle} is empty the length of {haystack} is returned. See also |stridx()|. Examples: :echo strridx("an angry armadillo", "an") 3 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 {string} 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 {string} occupies. A Tab character is counted as one cell, alternatively use |strdisplaywidth()|. When {string} 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()

Only for an expression in a |:substitute| command or substitute() function. Returns the {nr}'th submatch of the matched text. When {nr} is 0 the whole matched text is returned. Note that a NL in the string can stand for a line break of a multi-line match or a NUL character in the text. Also see |sub-replace-expression|. If {list} is present and non-zero then submatch() returns a list of strings, similar to |getline()| with two arguments. NL characters in the text represent NUL characters in the text. Only returns more than one item for |:substitute|, inside |substitute()| this list will always contain one or zero items, since there are no real line breaks. When substitute() is used recursively only the submatches in the current (deepest) call can be obtained. Examples: :s/\d+/=submatch(0) + 1/ :echo substitute(text, '\d+', '=submatch(0) + 1', '') This finds the first number in the line and adds one to it. A line break is included as a newline character. Can also be used as a |method|: GetNr()->submatch()

The result is a String, which is a copy of {string}, in which the first match of {pat} is replaced with {sub}. When {flags} is "g", all matches of {pat} in {string} are replaced. Otherwise {flags} should be "". This works like the ":substitute" command (without any flags). But the matching with {pat} is always done like the 'magic' option is set and 'cpoptions' is empty (to make scripts portable). 'ignorecase' is still relevant, use |/\c| or |/\C| if you want to ignore or match case and ignore 'ignorecase'. 'smartcase' is not used. See |string-match| for how {pat} is used. A "~" in {sub} is not replaced with the previous {sub}. Note that some codes in {sub} have a special meaning |sub-replace-special|. For example, to replace something with "\n" (two characters), use "\\n" or '\n'. When {pat} does not match in {string}, {string} is returned unmodified. Example: :let &path = substitute(&path, ",\=[^,]$", "", "") This removes the last component of the 'path' option. :echo substitute("testing", ".", "\U\0", "") results in "TESTING". When {sub} starts with "=", the remainder is interpreted as an expression. See |sub-replace-expression|. Example: :echo substitute(s, '%(\x\x)', \ '=nr2char("0x" . submatch(1))', 'g') When {sub} is a Funcref that function is called, with one optional argument. Example: :echo substitute(s, '%(\x\x)', SubNr, 'g') The optional argument is a list which contains the whole matched string and up to nine submatches, like what |submatch()| returns. Example: :echo substitute(s, '%(\x\x)', {m -> '0x' . m[1]}, 'g') Can also be used as a |method|: GetString()->substitute(pat, sub, flags)

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 {buf}, see |bufname()| above. If buffer {buf} is the current buffer, the result is equal to |:swapname| (unless there is no swap file). If buffer {buf} has no swap file, returns an empty string. Can also be used as a |method|: GetBufname()->swapname()

The result is a |List| with currently three items:

1. The first item in the list is 0 if the character at the position {lnum} and {col} is not part of a concealable region, 1 if it is. {lnum} is used like with |getline()|.
2. The second item in the list is a string. If the first item is 1, the second item contains the text which will be displayed in place of the concealed text, depending on the current setting of 'conceallevel' and 'listchars'.
3. The third and final item in the list is a number representing the specific syntax region matched in the line. When the character is not concealed the value is zero. This allows detection of the beginning of a new concealable region if there are two consecutive regions with the same replacement character. For an example, if the text is "123456" and both "23" and "45" are concealed and replaced by the character "X", then: call returns ~ synconcealed(lnum, 1) [0, '', 0] synconcealed(lnum, 2) [1, 'X', 1] synconcealed(lnum, 3) [1, 'X', 1] synconcealed(lnum, 4) [1, 'X', 2] synconcealed(lnum, 5) [1, 'X', 2] synconcealed(lnum, 6) [0, '', 0]

The result is a Number, which is the syntax ID at the position {lnum} and {col} in the current window. The syntax ID can be used with |synIDattr()| and |synIDtrans()| to obtain syntax information about text. {col} is 1 for the leftmost column, {lnum} is 1 for the first line. 'synmaxcol' applies, in a longer line zero is returned. Note that when the position is after the last character, that's where the cursor can be in Insert mode, synID() returns zero. {lnum} is used like with |getline()|. When {trans} is |TRUE|, transparent items are reduced to the item that they reveal. This is useful when wanting to know the effective color. When {trans} is |FALSE|, the transparent item is returned. This is useful when wanting to know which syntax item is effective (e.g. inside parens). Warning: This function can be very slow. Best speed is obtained by going through the file in forward direction. Example (echoes the name of the syntax item under the cursor): :echo synIDattr(synID(line("."), col("."), 1), "name")

The result is a String, which is the {what} attribute of syntax ID {synID}. This can be used to obtain information about a syntax item. {mode} can be "gui", "cterm" or "term", to get the attributes for that mode. When {mode} is omitted, or an invalid value is used, the attributes for the currently active highlighting are used (GUI, cterm or term). Use synIDtrans() to follow linked highlight groups. {what} result "name" the name of the syntax item "fg" foreground color (GUI: color name used to set the color, cterm: color number as a string, term: empty string) "bg" background color (as with "fg") "font" font name (only available in the GUI) |highlight-font| "sp" special color for the GUI (as with "fg") |highlight-guisp| "ul" underline color for cterm: number as a string "fg#" like "fg", but for the GUI and the GUI is running the name in "#RRGGBB" form "bg#" like "fg#" for "bg" "sp#" like "fg#" for "sp" "bold" "1" if bold "italic" "1" if italic "reverse" "1" if reverse "inverse" "1" if inverse (= reverse) "standout" "1" if standout "underline" "1" if underlined "undercurl" "1" if undercurled "strike" "1" if strikethrough Example (echoes the color of the syntax item under the cursor): :echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg") Can also be used as a |method|: :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")

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")

Return a |List|, which is the stack of syntax items at the position {lnum} and {col} in the current window. {lnum} is used like with |getline()|. Each item in the List is an ID like what |synID()| returns. The first item in the List is the outer region, following are items contained in that one. The last one is what |synID()| returns, unless not the whole item is highlighted or it is a transparent item. This function is useful for debugging a syntax file. Example that shows the syntax stack under the cursor: for id in synstack(line("."), col(".")) echo synIDattr(id, "name") endfor When the position specified with {lnum} and {col} is invalid nothing is returned. The position just after the last character in a line and the first column in an empty line are valid positions.

Get the output of the shell command {expr} as a string. See |systemlist()| to get the output as a |List|. When {input} is given and is a string this string is written to a file and passed as stdin to the command. The string is written as-is, you need to take care of using the correct line separators yourself. If {input} is given and is a |List| it is written to the file in a way |writefile()| does with {binary} set to "b" (i.e. with a newline between each list item with newlines inside list items converted to NULs). When {input} is given and is a number that is a valid id for an existing buffer then the content of the buffer is written to the file line by line, each line terminated by a NL and NULs characters where the text has a NL. Pipes are not used, the 'shelltemp' option is not used. When prepended by |:silent| the terminal will not be set to cooked mode. This is meant to be used for commands that do not need the user to type. It avoids stray characters showing up on the screen which require |CTRL-L| to remove. :silent let f = system('ls *.vim') Note: Use |shellescape()| or |::S| with |expand()| or |fnamemodify()| to escape special characters in a command argument. Newlines in {expr} may cause the command to fail. The characters in 'shellquote' and 'shellxquote' may also cause trouble. This is not to be used for interactive commands. The result is a String. Example: :let files = system("ls " . shellescape(expand('%:h'))) :let files = system('ls ' . expand('%:h:S')) To make the result more system-independent, the shell output is filtered to replace with for Macintosh, and with for DOS-like systems. To avoid the string being truncated at a NUL, all NUL characters are replaced with SOH (0x01). The command executed is constructed using several options: 'shell' 'shellcmdflag' 'shellxquote' {expr} 'shellredir' {tmp} 'shellxquote' ({tmp} is an automatically generated file name). For Unix, braces are put around {expr} to allow for concatenated commands. The command will be executed in "cooked" mode, so that a CTRL-C will interrupt the command (on Unix at least). The resulting error code can be found in |v:shell_error|. This function will fail in |restricted-mode|. Note that any wrong value in the options mentioned above may make the function fail. It has also been reported to fail when using a security agent application. Unlike ":!cmd" there is no automatic check for changed files. Use |:checktime| to force a check. Can also be used as a |method|: :echo GetCmd()->system()

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.

Returns a |List| of tags matching the regular expression {expr}. If {filename} is passed it is used to prioritize the results in the same way that |:tselect| does. See |tag-priority|. {filename} should be the full path of the file. Each list item is a dictionary with at least the following entries: name Name of the tag. filename Name of the file where the tag is defined. It is either relative to the current directory or a full path. cmd Ex command used to locate the tag in the file. kind Type of the tag. The value for this entry depends on the language specific kind values. Only available when using a tags file generated by Exuberant ctags or hdrtag. static A file specific tag. Refer to |static-tag| for more information. More entries may be present, depending on the content of the tags file: access, implementation, inherits and signature. Refer to the ctags documentation for information about these fields. For C code the fields "struct", "class" and "enum" may appear, they give the name of the entity the tag is contained in. The ex-command "cmd" can be either an ex search pattern, a line number or a line number followed by a byte number. If there are no matching tags, then an empty list is returned. To get an exact tag match, the anchors '^' and '$' should be used in {expr}. This also make the function work faster. Refer to |tag-regexp| for more information about the tag search regular expression pattern. Refer to |'tags'| for information about how the tags file is located by Vim. Refer to |tags-file-format| for the format of the tags file generated by the different ctags tools. Can also be used as a |method|: GetTagpattern()->taglist()

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}

Create a timer and return the timer ID. {time} is the waiting time in milliseconds. This is the minimum time before invoking the callback. When the system is busy or Vim is not waiting for input the time will be longer. {callback} is the function to call. It can be the name of a function or a |Funcref|. It is called with one argument, which is the timer ID. The callback is only invoked when Vim is waiting for input. If you want to show a message look at |popup_notification()| to avoid interfering with what the user is doing. {options} is a dictionary. Supported entries: "repeat" Number of times to repeat calling the callback. -1 means forever. When not present the callback will be called once. If the timer causes an error three times in a row the repeat is cancelled. This avoids that Vim becomes unusable because of all the error messages. Example: func MyHandler(timer) echo 'Handler called' endfunc let timer = timer_start(500, 'MyHandler', \ {'repeat': 3}) This will invoke MyHandler() three times at 500 msec intervals. Can also be used as a |method|: GetMsec()->timer_start(callback) Not available in the |sandbox|. {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 {text} as a String where any character in {mask} is removed from the beginning and/or end of {text}. If {mask} is not given, {mask} is all characters up to 0x20, which includes Tab, space, NL and CR, plus the non-breaking space character 0xa0. The optional {dir} argument specifies where to remove the characters: 0 remove from the beginning and end of {text} 1 remove only at the beginning of {text} 2 remove only at the end of {text} When omitted both ends are trimmed. This function deals with multibyte characters properly. Examples: echo trim(" some text ") returns "some text" echo trim(" \r\t\t\r RESERVE \t\n\x0B\xA0") . "_TAIL" returns "RESERVE_TAIL" echo trim("rm<Xrm<>X>rrm", "rm<>") returns "Xrm<>X" (characters in the middle are not removed) echo trim(" vim ", " ", 2) returns " vim" Can also be used as a |method|: GetText()->trim()

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}

The result is a Number representing the type of {expr}. Instead of using the number directly, it is better to use the v:t_ variable that has the value: Number: 0 |v:t_number| String: 1 |v:t_string| Funcref: 2 |v:t_func| List: 3 |v:t_list| Dictionary: 4 |v:t_dict| Float: 5 |v:t_float| Boolean: 6 |v:t_bool| (v:false and v:true) None: 7 |v:t_none| (v:null and v:none) Job: 8 |v:t_job| Channel: 9 |v:t_channel| Blob: 10 |v:t_blob| For backward compatibility, this method can be used: :if type(myvar) == type(0) :if type(myvar) == type("") :if type(myvar) == type(function("tr")) :if type(myvar) == type([]) :if type(myvar) == type({}) :if type(myvar) == type(0.0) :if type(myvar) == type(v:false) :if type(myvar) == type(v:none) To check if the v:t_ variables exist use this: :if exists('v:t_number') Can also be used as a |method|: mylist->type()

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()

Return the current state of the undo tree in a dictionary with the following items: "seq_last" The highest undo sequence number used. "seq_cur" The sequence number of the current position in the undo tree. This differs from "seq_last" when some changes were undone. "time_cur" Time last used for |:earlier| and related commands. Use |strftime()| to convert to something readable. "save_last" Number of the last file write. Zero when no write yet. "save_cur" Number of the current position in the undo tree. "synced" Non-zero when the last undo block was synced. This happens when waiting from input from the user. See |undo-blocks|. "entries" A list of dictionaries with information about undo blocks. The first item in the "entries" list is the oldest undo item. Each List item is a |Dictionary| with these items: "seq" Undo sequence number. Same as what appears in |:undolist|. "time" Timestamp when the change happened. Use |strftime()| to convert to something readable. "newhead" Only appears in the item that is the last one that was added. This marks the last change and where further changes will be added. "curhead" Only appears in the item that is the last one that was undone. This marks the current position in the undo tree, the block that will be used by a redo command. When nothing was undone after the last change this item will not appear anywhere. "save" Only appears on the last block before a file write. The number is the write count. The first write has number 1, the last one the "save_last" mentioned above. "alt" Alternate entry. This is again a List of undo blocks. Each item may again have an "alt" item.

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).

Like execute() but in the context of window {id}. The window will temporarily be made the current window, without triggering autocommands. When executing {command} autocommands will be triggered, this may have unexpected side effects. Use |:noautocmd| if needed. Example: call win_execute(winid, 'set syntax=python') Doing the same with setwinvar() would not trigger autocommands and not actually show syntax highlighting. Not all commands are allowed in popup windows. When window {id} does not exist then no error is given and an empty string is returned. Can also be used as a |method|, the base is passed as the second argument: GetCommand()->win_execute(winid)

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. "command" command-line window |cmdwin| (empty) normal window "loclist" |location-list-window| "popup" popup window |popup| "preview" preview window |preview-window| "quickfix" |quickfix-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. Returns [0, 0] if the window cannot be found in the current tabpage. Can also be used as a |method|: GetWinid()->win_screenpos()

Move the window {nr} to a new split of the window {target}. This is similar to moving to {target}, creating a new window using |:split| but having the same contents as window {nr}, and then closing {nr}. Both {nr} and {target} can be window numbers or |window-ID|s. Both must be in the current tab page. Returns zero for success, non-zero for failure. {options} is a |Dictionary| with the following optional entries: "vertical" When TRUE, the split is created vertically, like with |:vsplit|. "rightbelow" When TRUE, the split is made below or to the right (if vertical). When FALSE, it is done above or to the left (if vertical). When not present, the values of 'splitbelow' and 'splitright' are used. Can also be used as a |method|: GetWinid()->win_splitmove(target)

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 nested List containing the layout of windows in a tabpage. Without {tabnr} use the current tabpage, otherwise the tabpage with number {tabnr}. If the tabpage {tabnr} is not found, returns an empty list. For a leaf window, it returns: ['leaf', {winid}] For horizontally split windows, which form a column, it returns: ['col', [{nested list of windows}]] For vertically split windows, which form a row, it returns: ['row', [{nested list of windows}]] Example: " Only one window in the tab page :echo winlayout() ['leaf', 1000] " Two horizontally split windows :echo winlayout() ['col', [['leaf', 1000], ['leaf', 1001]]] " The second tab page, with three horizontally split " windows, with two vertically split windows in the " middle window :echo winlayout(2) ['col', [['leaf', 1002], ['row', [['leaf', 1003], ['leaf', 1001]]], ['leaf', 1000]]] Can also be used as a |method|: GetTabnr()->winlayout()

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.

The result is a Number, which is the number of the current window. The top window has number 1. Returns zero for a popup window. The optional argument {arg} supports the following values: $ the number of the last window (the window count). # the number of the last accessed window (where |CTRL-W_p| goes to). If there is no previous window or it is in another tab page 0 is returned. {N}j the number of the Nth window below the current window (where |CTRL-W_j| goes to). {N}k the number of the Nth window above the current window (where |CTRL-W_k| goes to). {N}h the number of the Nth window left of the current window (where |CTRL-W_h| goes to). {N}l the number of the Nth window right of the current window (where |CTRL-W_l| goes to). The number can be used with |CTRL-W_w| and ":wincmd w" |:wincmd|. Also see |tabpagewinnr()| and |win_getid()|. Examples: let window_count = winnr('$') let prev_window = winnr('#') let wnum = winnr('3k') Can also be used as a |method|: GetWinval()->winnr()

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)

When {object} is a |List| write it to file {fname}. Each list item is separated with a NL. Each list item must be a String or Number. When {flags} contains "b" then binary mode is used: There will not be a NL after the last list item. An empty item at the end does cause the last line in the file to end in a NL. When {object} is a |Blob| write the bytes to file {fname} unmodified. When {flags} contains "a" then append mode is used, lines are appended to the file: :call writefile(["foo"], "event.log", "a") :call writefile(["bar"], "event.log", "a") When {flags} contains "s" then fsync() is called after writing the file. This flushes the file to disk, if possible. This takes more time but avoids losing the file if the system crashes. When {flags} does not contain "S" or "s" then fsync() is called if the 'fsync' option is set. When {flags} contains "S" then fsync() is not called, even when 'fsync' is set. All NL characters are replaced with a NUL character. Inserting CR characters needs to be done before passing {list} to writefile(). An existing file is overwritten, if possible. When the write fails -1 is returned, otherwise 0. There is an error message if the file can't be created or when writing fails. Also see |readfile()|. To copy a file byte for byte: :let fl = readfile("foo", "b") :call writefile(fl, "foocopy", "b") Can also be used as a |method|: GetText()->writefile("thefile")

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)

Perform gather call

Denpos is a facade instance visible from each denops plugins.

Builtin completion

Type of getpos() or setpos() result.

Type of screenpos() result.