diff options
Diffstat (limited to 'runtime/doc')
62 files changed, 10287 insertions, 9234 deletions
diff --git a/runtime/doc/api.txt b/runtime/doc/api.txt index 8fb6290e50..fe5f9eaf35 100644 --- a/runtime/doc/api.txt +++ b/runtime/doc/api.txt @@ -45,7 +45,7 @@ start with a TCP/IP socket instead, use |--listen| with a TCP-style address: > More endpoints can be started with |serverstart()|. Note that localhost TCP sockets are generally less secure than named pipes, -and can lead to vunerabilities like remote code execution. +and can lead to vulnerabilities like remote code execution. Connecting to the socket is the easiest way a programmer can test the API, which can be done through any msgpack-rpc client library or full-featured @@ -186,7 +186,7 @@ About the `functions` map: a type name, e.g. `nvim_buf_get_lines` is the `get_lines` method of a Buffer instance. |dev-api| - Global functions have the "method=false" flag and are prefixed with just - `nvim_`, e.g. `nvim_get_buffers`. + `nvim_`, e.g. `nvim_list_bufs`. *api-mapping* External programs (clients) can use the metadata to discover the API, using @@ -198,7 +198,7 @@ any of these approaches: 2. Start Nvim with |--api-info|. Useful for statically-compiled clients. Example (requires Python "pyyaml" and "msgpack-python" modules): > - nvim --api-info | python -c 'import msgpack, sys, yaml; print yaml.dump(msgpack.unpackb(sys.stdin.read()))' + nvim --api-info | python -c 'import msgpack, sys, yaml; yaml.dump(msgpack.unpackb(sys.stdin.buffer.read()), sys.stdout)' < 3. Use the |api_info()| Vimscript function. > :lua print(vim.inspect(vim.fn.api_info())) @@ -361,7 +361,7 @@ UTF-32 and UTF-16 sizes of the deleted region is also passed as additional arguments {old_utf32_size} and {old_utf16_size}. "on_changedtick" is invoked when |b:changedtick| was incremented but no text -was changed. The parameters recieved are ("changedtick", {buf}, {changedtick}). +was changed. The parameters received are ("changedtick", {buf}, {changedtick}). *api-lua-detach* In-process Lua callbacks can detach by returning `true`. This will detach all @@ -468,7 +468,7 @@ extmark position and enter some text, the extmark migrates forward. > f o o z|b a r line (| = cursor) 4 extmark (after typing "z") -If an extmark is on the last index of a line and you inputsa newline at that +If an extmark is on the last index of a line and you inputs a newline at that point, the extmark will accordingly migrate to the next line: > f o o z b a r| line (| = cursor) @@ -626,6 +626,62 @@ nvim__stats() *nvim__stats()* Return: ~ Map of various internal stats. + *nvim_add_user_command()* +nvim_add_user_command({name}, {command}, {*opts}) + Create a new user command |user-commands| + + {name} is the name of the new command. The name must begin + with an uppercase letter. + + {command} is the replacement text or Lua function to execute. + + Example: > + :call nvim_add_user_command('SayHello', 'echo "Hello world!"', {}) + :SayHello + Hello world! +< + + Parameters: ~ + {name} Name of the new user command. Must begin with + an uppercase letter. + {command} Replacement command to execute when this user + command is executed. When called from Lua, the + command can also be a Lua function. The + function is called with a single table argument + that contains the following keys: + • args: (string) The args passed to the + command, if any |<args>| + • fargs: (table) The args split by unescaped + whitespace (when more than one argument is + allowed), if any |<f-args>| + • bang: (boolean) "true" if the command was + executed with a ! modifier |<bang>| + • line1: (number) The starting line of the + command range |<line1>| + • line2: (number) The final line of the command + range |<line2>| + • range: (number) The number of items in the + command range: 0, 1, or 2 |<range>| + • count: (number) Any count supplied |<count>| + • reg: (string) The optional register, if + specified |<reg>| + • mods: (string) Command modifiers, if any + |<mods>| + {opts} Optional command attributes. See + |command-attributes| for more details. To use + boolean attributes (such as |:command-bang| or + |:command-bar|) set the value to "true". In + addition to the string options listed in + |:command-complete|, the "complete" key also + accepts a Lua function which works like the + "customlist" completion mode + |:command-completion-customlist|. Additional + parameters: + • desc: (string) Used for listing the command + when a Lua function is used for {command}. + • force: (boolean, default true) Override any + previous definition. + nvim_call_atomic({calls}) *nvim_call_atomic()* Calls many API methods atomically. @@ -634,7 +690,7 @@ nvim_call_atomic({calls}) *nvim_call_atomic()* atomically, i.e. without interleaving redraws, RPC requests from other clients, or user interactions (however API methods may trigger autocommands or event processing which - have such side-effects, e.g. |:sleep| may wake timers). + have such side effects, e.g. |:sleep| may wake timers). 2. To minimize RPC overhead (roundtrips) of a sequence of many requests. @@ -656,8 +712,8 @@ nvim_chan_send({chan}, {data}) *nvim_chan_send()* Send data to channel `id` . For a job, it writes it to the stdin of the process. For the stdio channel |channel-stdio|, it writes to Nvim's stdout. For an internal terminal instance - (|nvim_open_term()|) it writes directly to terimal output. See - |channel-bytes| for more information. + (|nvim_open_term()|) it writes directly to terminal output. + See |channel-bytes| for more information. This function writes raw data, not RPC messages. If the channel was created with `rpc=true` then the channel expects @@ -698,7 +754,7 @@ nvim_del_keymap({mode}, {lhs}) *nvim_del_keymap()* |nvim_set_keymap()| nvim_del_mark({name}) *nvim_del_mark()* - Deletes a uppercase/file named mark. See |mark-motions|. + Deletes an uppercase/file named mark. See |mark-motions|. Note: fails with error if a lowercase or buffer local named mark @@ -714,6 +770,12 @@ nvim_del_mark({name}) *nvim_del_mark()* |nvim_buf_del_mark()| |nvim_get_mark()| +nvim_del_user_command({name}) *nvim_del_user_command()* + Delete a user-defined command. + + Parameters: ~ + {name} Name of the command to delete. + nvim_del_var({name}) *nvim_del_var()* Removes a global (g:) variable. @@ -796,7 +858,7 @@ nvim_exec_lua({code}, {args}) *nvim_exec_lua()* Return: ~ Return value of Lua code if present or NIL. -nvim_feedkeys({keys}, {mode}, {escape_csi}) *nvim_feedkeys()* +nvim_feedkeys({keys}, {mode}, {escape_ks}) *nvim_feedkeys()* Sends input-keys to Nvim, subject to various quirks controlled by `mode` flags. This is a blocking call, unlike |nvim_input()|. @@ -804,23 +866,25 @@ nvim_feedkeys({keys}, {mode}, {escape_csi}) *nvim_feedkeys()* On execution error: does not fail, but updates v:errmsg. To input sequences like <C-o> use |nvim_replace_termcodes()| - (typically with escape_csi=true) to replace |keycodes|, then + (typically with escape_ks=false) to replace |keycodes|, then pass the result to nvim_feedkeys(). Example: > :let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true) - :call nvim_feedkeys(key, 'n', v:true) + :call nvim_feedkeys(key, 'n', v:false) < Parameters: ~ - {keys} to be typed - {mode} behavior flags, see |feedkeys()| - {escape_csi} If true, escape K_SPECIAL/CSI bytes in - `keys` + {keys} to be typed + {mode} behavior flags, see |feedkeys()| + {escape_ks} If true, escape K_SPECIAL bytes in `keys` + This should be false if you already used + |nvim_replace_termcodes()|, and true + otherwise. See also: ~ feedkeys() - vim_strsave_escape_csi + vim_strsave_escape_ks nvim_get_all_options_info() *nvim_get_all_options_info()* Gets the option information for all options. @@ -1061,7 +1125,7 @@ nvim_get_option_value({name}, {*opts}) *nvim_get_option_value()* Parameters: ~ {name} Option name {opts} Optional parameters - • scope: One of 'global' or 'local'. Analagous to + • scope: One of 'global' or 'local'. Analogous to |:setglobal| and |:setlocal|, respectively. Return: ~ @@ -1346,7 +1410,7 @@ nvim_replace_termcodes({str}, {from_part}, {do_lt}, {special}) {from_part} Legacy Vim parameter. Usually true. {do_lt} Also translate <lt>. Ignored if `special` is false. - {special} Replace |keycodes|, e.g. <CR> becomes a "\n" + {special} Replace |keycodes|, e.g. <CR> becomes a "\r" char. See also: ~ @@ -1479,14 +1543,13 @@ nvim_set_current_win({window}) *nvim_set_current_win()* Parameters: ~ {window} Window handle -nvim_set_hl({ns_id}, {name}, {val}) *nvim_set_hl()* +nvim_set_hl({ns_id}, {name}, {*val}) *nvim_set_hl()* Set a highlight group. - TODO: ns_id = 0, should modify :highlight namespace TODO val - should take update vs reset flag - Parameters: ~ - {ns_id} number of namespace for this highlight + {ns_id} number of namespace for this highlight. Use value + 0 to set a highlight group in the global ( + `:highlight` ) namespace. {name} highlight group name, like ErrorMsg {val} highlight definition map, like |nvim_get_hl_by_name|. in addition the following @@ -1524,8 +1587,11 @@ nvim_set_keymap({mode}, {lhs}, {rhs}, {*opts}) *nvim_set_keymap()* {rhs} Right-hand-side |{rhs}| of the mapping. {opts} Optional parameters map. Accepts all |:map-arguments| as keys excluding |<buffer>| but - including |noremap|. Values are Booleans. Unknown - key is an error. + including |noremap| and "desc". "desc" can be used + to give a description to keymap. When called from + Lua, also accepts a "callback" key that takes a + Lua function to call when the mapping is executed. + Values are Booleans. Unknown key is an error. nvim_set_option({name}, {value}) *nvim_set_option()* Sets the global value of an option. @@ -1545,7 +1611,7 @@ nvim_set_option_value({name}, {value}, {*opts}) {name} Option name {value} New option value {opts} Optional parameters - • scope: One of 'global' or 'local'. Analagous to + • scope: One of 'global' or 'local'. Analogous to |:setglobal| and |:setlocal|, respectively. nvim_set_var({name}, {value}) *nvim_set_var()* @@ -1790,6 +1856,16 @@ nvim__buf_redraw_range({buffer}, {first}, {last}) nvim__buf_stats({buffer}) *nvim__buf_stats()* TODO: Documentation + *nvim_buf_add_user_command()* +nvim_buf_add_user_command({buffer}, {name}, {command}, {*opts}) + Create a new user command |user-commands| in the given buffer. + + Parameters: ~ + {buffer} Buffer handle, or 0 for current buffer. + + See also: ~ + nvim_add_user_command + nvim_buf_attach({buffer}, {send_buffer}, {opts}) *nvim_buf_attach()* Activates buffer-update events on a channel, or as Lua callbacks. @@ -1925,6 +2001,18 @@ nvim_buf_del_mark({buffer}, {name}) *nvim_buf_del_mark()* |nvim_buf_set_mark()| |nvim_del_mark()| + *nvim_buf_del_user_command()* +nvim_buf_del_user_command({buffer}, {name}) + Delete a buffer-local user-defined command. + + Only commands created with |:command-buffer| or + |nvim_buf_add_user_command()| can be deleted with this + function. + + Parameters: ~ + {buffer} Buffer handle, or 0 for current buffer. + {name} Name of the command to delete. + nvim_buf_del_var({buffer}, {name}) *nvim_buf_del_var()* Removes a buffer-scoped (b:) variable @@ -2067,6 +2155,29 @@ nvim_buf_get_option({buffer}, {name}) *nvim_buf_get_option()* Return: ~ Option value + *nvim_buf_get_text()* +nvim_buf_get_text({buffer}, {start_row}, {start_col}, {end_row}, {end_col}, + {opts}) + Gets a range from the buffer. + + This differs from |nvim_buf_get_lines()| in that it allows + retrieving only portions of a line. + + Indexing is zero-based. Column indices are end-exclusive. + + Prefer |nvim_buf_get_lines()| when retrieving entire lines. + + Parameters: ~ + {buffer} Buffer handle, or 0 for current buffer + {start_row} First line index + {start_col} Starting byte offset of first line + {end_row} Last line index + {end_col} Ending byte offset of last line (exclusive) + {opts} Optional parameters. Currently unused. + + Return: ~ + Array of lines, or empty array for unloaded buffer. + nvim_buf_get_var({buffer}, {name}) *nvim_buf_get_var()* Gets a buffer-scoped (b:) variable. @@ -2464,6 +2575,10 @@ nvim_buf_set_extmark({buffer}, {ns_id}, {line}, {col}, {*opts}) • priority: a priority value for the highlight group. For example treesitter highlighting uses a value of 100. + • strict: boolean that indicates extmark should + not be placed if the line or column value is + past the end of the buffer or end of the line + respectively. Defaults to true. Return: ~ Id of the created/updated extmark @@ -2687,7 +2802,7 @@ nvim_win_is_valid({window}) *nvim_win_is_valid()* true if the window is valid, false otherwise nvim_win_set_buf({window}, {buffer}) *nvim_win_set_buf()* - Sets the current buffer in a window, without side-effects + Sets the current buffer in a window, without side effects Attributes: ~ not allowed when |textlock| is active @@ -2994,6 +3109,130 @@ nvim_tabpage_set_var({tabpage}, {name}, {value}) ============================================================================== +Autocmd Functions *api-autocmd* + +nvim_create_augroup({name}, {*opts}) *nvim_create_augroup()* + Create or get an augroup. + + To get an existing augroup ID, do: > + local id = vim.api.nvim_create_augroup(name, { + clear = false + }) +< + + Parameters: ~ + {name} String: The name of the augroup to create + {opts} Parameters + • clear (bool): Whether to clear existing commands + or not. Defaults to true. See |autocmd-groups| + + Return: ~ + opaque value to use with nvim_del_augroup_by_id + +nvim_create_autocmd({event}, {*opts}) *nvim_create_autocmd()* + Create an autocmd. + + Examples: + • event: "pat1,pat2,pat3", + • event: "pat1" + • event: { "pat1" } + • event: { "pat1", "pat2", "pat3" } + + Parameters: ~ + {event} The event or events to register this autocmd + Required keys: event: string | ArrayOf(string) + + Parameters: ~ + {opts} Optional Parameters: + • callback: (string|function) + • (string): The name of the viml function to + execute when triggering this autocmd + • (function): The lua function to execute when + triggering this autocmd + • NOTE: Cannot be used with {command} + + • command: (string) command + • vimscript command + • NOTE: Cannot be used with {callback} Eg. + command = "let g:value_set = v:true" + + • pattern: (string|table) + • pattern or patterns to match against + • defaults to "*". + • NOTE: Cannot be used with {buffer} + + • buffer: (bufnr) + • create a |autocmd-buflocal| autocmd. + • NOTE: Cannot be used with {pattern} + + • group: (string) The augroup name + • once: (boolean) - See |autocmd-once| + • nested: (boolean) - See |autocmd-nested| + • desc: (string) - Description of the autocmd + + Return: ~ + opaque value to use with nvim_del_autocmd + +nvim_del_augroup_by_id({id}) *nvim_del_augroup_by_id()* + Delete an augroup by {id}. {id} can only be returned when + augroup was created with |nvim_create_augroup|. + + NOTE: behavior differs from augroup-delete. + + When deleting an augroup, autocmds contained by this augroup + will also be deleted and cleared. This augroup will no longer + exist + +nvim_del_augroup_by_name({name}) *nvim_del_augroup_by_name()* + Delete an augroup by {name}. + + NOTE: behavior differs from augroup-delete. + + When deleting an augroup, autocmds contained by this augroup + will also be deleted and cleared. This augroup will no longer + exist + +nvim_del_autocmd({id}) *nvim_del_autocmd()* + Delete an autocmd by {id}. Autocmds only return IDs when + created via the API. Will not error if called and no autocmds + match the {id}. + + Parameters: ~ + {id} Integer The ID returned by nvim_create_autocmd + +nvim_do_autocmd({event}, {*opts}) *nvim_do_autocmd()* + Do one autocmd. + + Parameters: ~ + {event} The event or events to execute + {opts} Optional Parameters: + • buffer (number) - buffer number + • NOTE: Cannot be used with {pattern} + + • pattern (string|table) - optional, defaults to + "*". + • NOTE: Cannot be used with {buffer} + + • group (string) - autocmd group name + • modeline (boolean) - Default true, see + |<nomodeline>| + +nvim_get_autocmds({*opts}) *nvim_get_autocmds()* + Get autocmds that match the requirements passed to {opts}. + + Parameters: ~ + {opts} Optional Parameters: + • event : Name or list of name of events to match + against + • group (string): Name of group to match against + • pattern: Pattern or list of patterns to match + against + + Return: ~ + A list of autocmds that match + + +============================================================================== UI Functions *api-ui* nvim_ui_attach({width}, {height}, {options}) *nvim_ui_attach()* diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt index 0cd0d1ce0e..4b8c07fde4 100644 --- a/runtime/doc/autocmd.txt +++ b/runtime/doc/autocmd.txt @@ -40,10 +40,10 @@ effects. Be careful not to destroy your text. 2. Defining autocommands *autocmd-define* *:au* *:autocmd* -:au[tocmd] [group] {event} {pat} [++once] [++nested] {cmd} +:au[tocmd] [group] {event} {aupat} [++once] [++nested] {cmd} Add {cmd} to the list of commands that Vim will execute automatically on {event} for a file matching - {pat} |autocmd-pattern|. + {aupat} |autocmd-pattern|. Note: A quote character is seen as argument to the :autocmd and won't start a comment. Nvim always adds {cmd} after existing autocommands so @@ -119,19 +119,19 @@ prompt. When one command outputs two messages this can happen anyway. ============================================================================== 3. Removing autocommands *autocmd-remove* -:au[tocmd]! [group] {event} {pat} [++once] [++nested] {cmd} +:au[tocmd]! [group] {event} {aupat} [++once] [++nested] {cmd} Remove all autocommands associated with {event} and - {pat}, and add the command {cmd}. + {aupat}, and add the command {cmd}. See |autocmd-once| for [++once]. See |autocmd-nested| for [++nested]. -:au[tocmd]! [group] {event} {pat} +:au[tocmd]! [group] {event} {aupat} Remove all autocommands associated with {event} and - {pat}. + {aupat}. -:au[tocmd]! [group] * {pat} - Remove all autocommands associated with {pat} for all - events. +:au[tocmd]! [group] * {aupat} + Remove all autocommands associated with {aupat} for + all events. :au[tocmd]! [group] {event} Remove ALL autocommands for {event}. @@ -151,12 +151,12 @@ with ":augroup"); otherwise, Vim uses the group defined with [group]. ============================================================================== 4. Listing autocommands *autocmd-list* -:au[tocmd] [group] {event} {pat} +:au[tocmd] [group] {event} {aupat} Show the autocommands associated with {event} and - {pat}. + {aupat}. -:au[tocmd] [group] * {pat} - Show the autocommands associated with {pat} for all +:au[tocmd] [group] * {aupat} + Show the autocommands associated with {aupat} for all events. :au[tocmd] [group] {event} @@ -525,8 +525,19 @@ DirChanged After the |current-directory| was changed. "global" to trigger on `:cd` "auto" to trigger on 'autochdir'. Sets these |v:event| keys: - cwd: current working directory - scope: "global", "tab", "window" + cwd: current working directory + scope: "global", "tabpage", "window" + changed_window: v:true if we fired the event + switching window (or tab) + <afile> is set to the new directory name. + Non-recursive (event cannot trigger itself). + *DirChangedPre* +DirChangedPre When the |current-directory| is going to be + changed, as with |DirChanged|. + The pattern is like with |DirChanged|. + Sets these |v:event| keys: + directory: new working directory + scope: "global", "tabpage", "window" changed_window: v:true if we fired the event switching window (or tab) <afile> is set to the new directory name. @@ -844,6 +855,9 @@ RecordingLeave When a macro stops recording. register. |reg_recorded()| is only updated after this event. + Sets these |v:event| keys: + regcontents + regname *SessionLoadPost* SessionLoadPost After loading the session file created using the |:mksession| command. @@ -1076,16 +1090,16 @@ WinScrolled After scrolling the viewport of the current ============================================================================== -6. Patterns *autocmd-pattern* *{pat}* +6. Patterns *autocmd-pattern* *{aupat}* -The {pat} argument can be a comma separated list. This works as if the -command was given with each pattern separately. Thus this command: > +The {aupat} argument of `:autocmd` can be a comma separated list. This works +as if the command was given with each pattern separately. Thus this command: > :autocmd BufRead *.txt,*.info set et Is equivalent to: > :autocmd BufRead *.txt set et :autocmd BufRead *.info set et -The file pattern {pat} is tested for a match against the file name in one of +The file pattern {aupat} is tested for a match against the file name in one of two ways: 1. When there is no '/' in the pattern, Vim checks for a match against only the tail part of the file name (without its leading directory path). @@ -1396,7 +1410,7 @@ Examples for reading and writing compressed files: > : autocmd BufReadPre,FileReadPre *.gz set bin : autocmd BufReadPost,FileReadPost *.gz '[,']!gunzip : autocmd BufReadPost,FileReadPost *.gz set nobin - : autocmd BufReadPost,FileReadPost *.gz execute ":doautocmd BufReadPost " . expand("%:r") + : autocmd BufReadPost,FileReadPost *.gz execute ":doautocmd BufReadPost " .. expand("%:r") : autocmd BufWritePost,FileWritePost *.gz !mv <afile> <afile>:r : autocmd BufWritePost,FileWritePost *.gz !gzip <afile>:r @@ -1495,7 +1509,7 @@ To insert the current date and time in a *.html file when writing it: > : else : let l = line("$") : endif - : exe "1," . l . "g/Last modified: /s/Last modified: .*/Last modified: " . + : exe "1," .. l .. "g/Last modified: /s/Last modified: .*/Last modified: " .. : \ strftime("%Y %b %d") :endfun diff --git a/runtime/doc/builtin.txt b/runtime/doc/builtin.txt new file mode 100644 index 0000000000..03a5f98c6d --- /dev/null +++ b/runtime/doc/builtin.txt @@ -0,0 +1,8974 @@ +*builtin.txt* Nvim + + + VIM REFERENCE MANUAL by Bram Moolenaar + + +Builtin functions *builtin-functions* + +1. Overview |builtin-function-list| +2. Details |builtin-function-details| +3. Matching a pattern in a String |string-match| + +============================================================================== +1. Overview *builtin-function-list* + +Use CTRL-] on the function name to jump to the full explanation. + +USAGE RESULT DESCRIPTION ~ + +abs({expr}) Float or Number absolute value of {expr} +acos({expr}) Float arc cosine of {expr} +add({object}, {item}) List/Blob append {item} to {object} +and({expr}, {expr}) Number bitwise AND +api_info() Dict api metadata +append({lnum}, {text}) Number append {text} below line {lnum} +appendbufline({expr}, {lnum}, {text}) + Number append {text} below line {lnum} + in buffer {expr} +argc([{winid}]) Number number of files in the argument list +argidx() Number current index in the argument list +arglistid([{winnr} [, {tabnr}]]) Number argument list id +argv({nr} [, {winid}]) String {nr} entry of the argument list +argv([-1, {winid}]) List the argument list +asin({expr}) Float arc sine of {expr} +assert_beeps({cmd}) Number assert {cmd} causes a beep +assert_equal({exp}, {act} [, {msg}]) + Number assert {exp} is equal to {act} +assert_equalfile({fname-one}, {fname-two} [, {msg}]) + Number assert file contents are equal +assert_exception({error} [, {msg}]) + Number assert {error} is in v:exception +assert_fails({cmd} [, {error}]) Number assert {cmd} fails +assert_false({actual} [, {msg}]) + Number assert {actual} is false +assert_inrange({lower}, {upper}, {actual} [, {msg}]) + Number assert {actual} is inside the range +assert_match({pat}, {text} [, {msg}]) + Number assert {pat} matches {text} +assert_nobeep({cmd}) Number assert {cmd} does not cause a beep +assert_notequal({exp}, {act} [, {msg}]) + Number assert {exp} is not equal {act} +assert_notmatch({pat}, {text} [, {msg}]) + Number assert {pat} not matches {text} +assert_report({msg}) Number report a test failure +assert_true({actual} [, {msg}]) Number assert {actual} is true +atan({expr}) Float arc tangent of {expr} +atan2({expr1}, {expr2}) Float arc tangent of {expr1} / {expr2} +browse({save}, {title}, {initdir}, {default}) + String put up a file requester +browsedir({title}, {initdir}) String put up a directory requester +bufadd({name}) Number add a buffer to the buffer list +bufexists({expr}) Number |TRUE| if buffer {expr} exists +buflisted({expr}) Number |TRUE| if buffer {expr} is listed +bufload({expr}) Number load buffer {expr} if not loaded yet +bufloaded({expr}) Number |TRUE| if buffer {expr} is loaded +bufname([{expr}]) String Name of the buffer {expr} +bufnr([{expr} [, {create}]]) Number Number of the buffer {expr} +bufwinid({expr}) Number |window-ID| of buffer {expr} +bufwinnr({expr}) Number window number of buffer {expr} +byte2line({byte}) Number line number at byte count {byte} +byteidx({expr}, {nr}) Number byte index of {nr}'th char in {expr} +byteidxcomp({expr}, {nr}) Number byte index of {nr}'th char in {expr} +call({func}, {arglist} [, {dict}]) + any call {func} with arguments {arglist} +ceil({expr}) Float round {expr} up +changenr() Number current change number +chanclose({id} [, {stream}]) Number Closes a channel or one of its streams +chansend({id}, {data}) Number Writes {data} to channel +char2nr({expr} [, {utf8}]) Number ASCII/UTF-8 value of first char in {expr} +charcol({expr}) Number column number of cursor or mark +charidx({string}, {idx} [, {countcc}]) + Number char index of byte {idx} in {string} +chdir({dir}) String change current working directory +cindent({lnum}) Number C indent for line {lnum} +clearmatches([{win}]) none clear all matches +col({expr}) Number column byte index of cursor or mark +complete({startcol}, {matches}) none set Insert mode completion +complete_add({expr}) Number add completion match +complete_check() Number check for key typed during completion +complete_info([{what}]) Dict get current completion information +confirm({msg} [, {choices} [, {default} [, {type}]]]) + Number number of choice picked by user +copy({expr}) any make a shallow copy of {expr} +cos({expr}) Float cosine of {expr} +cosh({expr}) Float hyperbolic cosine of {expr} +count({comp}, {expr} [, {ic} [, {start}]]) + Number count how many {expr} are in {comp} +cscope_connection([{num}, {dbpath} [, {prepend}]]) + Number checks existence of cscope connection +ctxget([{index}]) Dict return the |context| dict at {index} +ctxpop() none pop and restore |context| from the + |context-stack| +ctxpush([{types}]) none push the current |context| to the + |context-stack| +ctxset({context} [, {index}]) none set |context| at {index} +ctxsize() Number return |context-stack| size +cursor({lnum}, {col} [, {off}]) + Number move cursor to {lnum}, {col}, {off} +cursor({list}) Number move cursor to position in {list} +debugbreak({pid}) Number interrupt process being debugged +deepcopy({expr} [, {noref}]) any make a full copy of {expr} +delete({fname} [, {flags}]) Number delete the file or directory {fname} +deletebufline({buf}, {first} [, {last}]) + Number delete lines from buffer {buf} +dictwatcheradd({dict}, {pattern}, {callback}) + Start watching a dictionary +dictwatcherdel({dict}, {pattern}, {callback}) + Stop watching a dictionary +did_filetype() Number |TRUE| if FileType autocommand event used +diff_filler({lnum}) Number diff filler lines about {lnum} +diff_hlID({lnum}, {col}) Number diff highlighting at {lnum}/{col} +empty({expr}) Number |TRUE| if {expr} is empty +environ() Dict return environment variables +escape({string}, {chars}) String escape {chars} in {string} with '\' +eval({string}) any evaluate {string} into its value +eventhandler() Number |TRUE| if inside an event handler +executable({expr}) Number 1 if executable {expr} exists +execute({command}) String execute and capture output of {command} +exepath({expr}) String full path of the command {expr} +exists({expr}) Number |TRUE| if {expr} exists +extend({expr1}, {expr2} [, {expr3}]) + List/Dict insert items of {expr2} into {expr1} +exp({expr}) Float exponential of {expr} +expand({expr} [, {nosuf} [, {list}]]) + any expand special keywords in {expr} +expandcmd({expr}) String expand {expr} like with `:edit` +feedkeys({string} [, {mode}]) Number add key sequence to typeahead buffer +filereadable({file}) Number |TRUE| if {file} is a readable file +filewritable({file}) Number |TRUE| if {file} is a writable file +filter({expr1}, {expr2}) List/Dict remove items from {expr1} where + {expr2} is 0 +finddir({name} [, {path} [, {count}]]) + String find directory {name} in {path} +findfile({name} [, {path} [, {count}]]) + String find file {name} in {path} +flatten({list} [, {maxdepth}]) List flatten {list} up to {maxdepth} levels +float2nr({expr}) Number convert Float {expr} to a Number +floor({expr}) Float round {expr} down +fmod({expr1}, {expr2}) Float remainder of {expr1} / {expr2} +fnameescape({fname}) String escape special characters in {fname} +fnamemodify({fname}, {mods}) String modify file name +foldclosed({lnum}) Number first line of fold at {lnum} if closed +foldclosedend({lnum}) Number last line of fold at {lnum} if closed +foldlevel({lnum}) Number fold level at {lnum} +foldtext() String line displayed for closed fold +foldtextresult({lnum}) String text for closed fold at {lnum} +foreground() Number bring the Vim window to the foreground +fullcommand({name}) String get full command from {name} +funcref({name} [, {arglist}] [, {dict}]) + Funcref reference to function {name} +function({name} [, {arglist}] [, {dict}]) + Funcref named reference to function {name} +garbagecollect([{atexit}]) none free memory, breaking cyclic references +get({list}, {idx} [, {def}]) any get item {idx} from {list} or {def} +get({dict}, {key} [, {def}]) any get item {key} from {dict} or {def} +get({func}, {what}) any get property of funcref/partial {func} +getbufinfo([{buf}]) List information about buffers +getbufline({buf}, {lnum} [, {end}]) + List lines {lnum} to {end} of buffer {buf} +getbufvar({buf}, {varname} [, {def}]) + any variable {varname} in buffer {buf} +getchangelist([{buf}]) List list of change list items +getchar([expr]) Number or String + get one character from the user +getcharmod() Number modifiers for the last typed character +getcharpos({expr}) List position of cursor, mark, etc. +getcharsearch() Dict last character search +getcharstr([expr]) String get one character from the user +getcmdline() String return the current command-line +getcmdpos() Number return cursor position in command-line +getcmdtype() String return current command-line type +getcmdwintype() String return current command-line window type +getcompletion({pat}, {type} [, {filtered}]) + List list of cmdline completion matches +getcurpos([{winnr}]) List position of the cursor +getcursorcharpos([{winnr}]) List character position of the cursor +getcwd([{winnr} [, {tabnr}]]) String get the current working directory +getenv({name}) String return environment variable +getfontname([{name}]) String name of font being used +getfperm({fname}) String file permissions of file {fname} +getfsize({fname}) Number size in bytes of file {fname} +getftime({fname}) Number last modification time of file +getftype({fname}) String description of type of file {fname} +getjumplist([{winnr} [, {tabnr}]]) + List list of jump list items +getline({lnum}) String line {lnum} of current buffer +getline({lnum}, {end}) List lines {lnum} to {end} of current buffer +getloclist({nr}) List list of location list items +getloclist({nr}, {what}) Dict get specific location list properties +getmarklist([{buf}]) List list of global/local marks +getmatches([{win}]) List list of current matches +getmousepos() Dict last known mouse position +getpid() Number process ID of Vim +getpos({expr}) List position of cursor, mark, etc. +getqflist() List list of quickfix items +getqflist({what}) Dict get specific quickfix list properties +getreg([{regname} [, 1 [, {list}]]]) + String or List contents of a register +getreginfo([{regname}]) Dict information about a register +getregtype([{regname}]) String type of a register +gettabinfo([{expr}]) List list of tab pages +gettabvar({nr}, {varname} [, {def}]) + any variable {varname} in tab {nr} or {def} +gettabwinvar({tabnr}, {winnr}, {name} [, {def}]) + any {name} in {winnr} in tab page {tabnr} +gettagstack([{nr}]) Dict get the tag stack of window {nr} +getwininfo([{winid}]) List list of info about each window +getwinpos([{timeout}]) List X and Y coord in pixels of the Vim window +getwinposx() Number X coord in pixels of Vim window +getwinposy() Number Y coord in pixels of Vim window +getwinvar({nr}, {varname} [, {def}]) + any variable {varname} in window {nr} +glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) + any expand file wildcards in {expr} +glob2regpat({expr}) String convert a glob pat into a search pat +globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]]) + String do glob({expr}) for all dirs in {path} +has({feature}) Number |TRUE| if feature {feature} supported +has_key({dict}, {key}) Number |TRUE| if {dict} has entry {key} +haslocaldir([{winnr} [, {tabnr}]]) + Number |TRUE| if the window executed |:lcd| or + the tab executed |:tcd| +hasmapto({what} [, {mode} [, {abbr}]]) + Number |TRUE| if mapping to {what} exists +histadd({history}, {item}) String add an item to a history +histdel({history} [, {item}]) String remove an item from a history +histget({history} [, {index}]) String get the item {index} from a history +histnr({history}) Number highest index of a history +hlexists({name}) Number |TRUE| if highlight group {name} exists +hlID({name}) Number syntax ID of highlight group {name} +hostname() String name of the machine Vim is running on +iconv({expr}, {from}, {to}) String convert encoding of {expr} +indent({lnum}) Number indent of line {lnum} +index({object}, {expr} [, {start} [, {ic}]]) + Number index in {object} where {expr} appears +input({prompt} [, {text} [, {completion}]]) + String get input from the user +inputlist({textlist}) Number let the user pick from a choice list +inputrestore() Number restore typeahead +inputsave() Number save and clear typeahead +inputsecret({prompt} [, {text}]) + String like input() but hiding the text +insert({object}, {item} [, {idx}]) + List insert {item} in {object} [before {idx}] +interrupt() none interrupt script execution +invert({expr}) Number bitwise invert +isdirectory({directory}) Number |TRUE| if {directory} is a directory +isinf({expr}) Number determine if {expr} is infinity value + (positive or negative) +islocked({expr}) Number |TRUE| if {expr} is locked +isnan({expr}) Number |TRUE| if {expr} is NaN +id({expr}) String identifier of the container +items({dict}) List key-value pairs in {dict} +jobpid({id}) Number Returns pid of a job. +jobresize({id}, {width}, {height}) + Number Resize pseudo terminal window of a job +jobstart({cmd} [, {opts}]) Number Spawns {cmd} as a job +jobstop({id}) Number Stops a job +jobwait({ids} [, {timeout}]) Number Wait for a set of jobs +join({list} [, {sep}]) String join {list} items into one String +json_decode({expr}) any Convert {expr} from JSON +json_encode({expr}) String Convert {expr} to JSON +keys({dict}) List keys in {dict} +len({expr}) Number the length of {expr} +libcall({lib}, {func}, {arg}) String call {func} in library {lib} with {arg} +libcallnr({lib}, {func}, {arg}) Number idem, but return a Number +line({expr} [, {winid}]) Number line nr of cursor, last line or mark +line2byte({lnum}) Number byte count of line {lnum} +lispindent({lnum}) Number Lisp indent for line {lnum} +list2str({list} [, {utf8}]) String turn numbers in {list} into a String +localtime() Number current time +log({expr}) Float natural logarithm (base e) of {expr} +log10({expr}) Float logarithm of Float {expr} to base 10 +luaeval({expr} [, {expr}]) any evaluate |Lua| expression +map({expr1}, {expr2}) List/Dict change each item in {expr1} to {expr} +maparg({name} [, {mode} [, {abbr} [, {dict}]]]) + String or Dict + rhs of mapping {name} in mode {mode} +mapcheck({name} [, {mode} [, {abbr}]]) + String check for mappings matching {name} +match({expr}, {pat} [, {start} [, {count}]]) + Number position where {pat} matches in {expr} +matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]]) + Number highlight {pattern} with {group} +matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]]) + Number highlight positions with {group} +matcharg({nr}) List arguments of |:match| +matchdelete({id} [, {win}]) Number delete match identified by {id} +matchend({expr}, {pat} [, {start} [, {count}]]) + Number position where {pat} ends in {expr} +matchfuzzy({list}, {str} [, {dict}]) + List fuzzy match {str} in {list} +matchfuzzypos({list}, {str} [, {dict}]) + List fuzzy match {str} in {list} +matchlist({expr}, {pat} [, {start} [, {count}]]) + List match and submatches of {pat} in {expr} +matchstr({expr}, {pat} [, {start} [, {count}]]) + String {count}'th match of {pat} in {expr} +matchstrpos({expr}, {pat} [, {start} [, {count}]]) + List {count}'th match of {pat} in {expr} +max({expr}) Number maximum value of items in {expr} +menu_get({path} [, {modes}]) List description of |menus| matched by {path} +min({expr}) Number minimum value of items in {expr} +mkdir({name} [, {path} [, {prot}]]) + Number create directory {name} +mode([expr]) String current editing mode +msgpackdump({list} [, {type}]) List/Blob dump objects to msgpack +msgpackparse({data}) List parse msgpack to a list of objects +nextnonblank({lnum}) Number line nr of non-blank line >= {lnum} +nr2char({expr} [, {utf8}]) String single char with ASCII/UTF-8 value {expr} +nvim_...({args}...) any call nvim |api| functions +or({expr}, {expr}) Number bitwise OR +pathshorten({expr} [, {len}]) String shorten directory names in a path +perleval({expr}) any evaluate |perl| expression +pow({x}, {y}) Float {x} to the power of {y} +prevnonblank({lnum}) Number line nr of non-blank line <= {lnum} +printf({fmt}, {expr1}...) String format text +prompt_getprompt({buf}) String get prompt text +prompt_setcallback({buf}, {expr}) none set prompt callback function +prompt_setinterrupt({buf}, {text}) none set prompt interrupt function +prompt_setprompt({buf}, {text}) none set prompt text +pum_getpos() Dict position and size of pum if visible +pumvisible() Number whether popup menu is visible +pyeval({expr}) any evaluate |Python| expression +py3eval({expr}) any evaluate |python3| expression +pyxeval({expr}) any evaluate |python_x| expression +rand([{expr}]) Number get pseudo-random number +range({expr} [, {max} [, {stride}]]) + List items from {expr} to {max} +readdir({dir} [, {expr}]) List file names in {dir} selected by {expr} +readfile({fname} [, {type} [, {max}]]) + List get list of lines from file {fname} +reduce({object}, {func} [, {initial}]) + any reduce {object} using {func} +reg_executing() String get the executing register name +reg_recorded() String get the last recorded register name +reg_recording() String get the recording register name +reltime([{start} [, {end}]]) List get time value +reltimefloat({time}) Float turn the time value into a Float +reltimestr({time}) String turn time value into a String +remote_expr({server}, {string} [, {idvar} [, {timeout}]]) + String send expression +remote_foreground({server}) Number bring Vim server to the foreground +remote_peek({serverid} [, {retvar}]) + Number check for reply string +remote_read({serverid} [, {timeout}]) + String read reply string +remote_send({server}, {string} [, {idvar}]) + String send key sequence +remote_startserver({name}) none become server {name} +remove({list}, {idx} [, {end}]) any/List + remove items {idx}-{end} from {list} +remove({blob}, {idx} [, {end}]) Number/Blob + remove bytes {idx}-{end} from {blob} +remove({dict}, {key}) any remove entry {key} from {dict} +rename({from}, {to}) Number rename (move) file from {from} to {to} +repeat({expr}, {count}) String repeat {expr} {count} times +resolve({filename}) String get filename a shortcut points to +reverse({list}) List reverse {list} in-place +round({expr}) Float round off {expr} +rubyeval({expr}) any evaluate |Ruby| expression +rpcnotify({channel}, {event} [, {args}...]) + Sends an |RPC| notification to {channel} +rpcrequest({channel}, {method} [, {args}...]) + Sends an |RPC| request to {channel} +screenattr({row}, {col}) Number attribute at screen position +screenchar({row}, {col}) Number character at screen position +screenchars({row}, {col}) List List of characters at screen position +screencol() Number current cursor column +screenpos({winid}, {lnum}, {col}) Dict screen row and col of a text character +screenrow() Number current cursor row +screenstring({row}, {col}) String characters at screen position +search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) + Number search for {pattern} +searchcount([{options}]) Dict Get or update the last search count +searchdecl({name} [, {global} [, {thisblock}]]) + Number search for variable declaration +searchpair({start}, {middle}, {end} [, {flags} [, {skip} [...]]]) + Number search for other end of start/end pair +searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [...]]]) + List search for other end of start/end pair +searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) + List search for {pattern} +server2client({clientid}, {string}) + Number send reply string +serverlist() String get a list of available servers +setbufline({expr}, {lnum}, {text}) + Number set line {lnum} to {text} in buffer + {expr} +setbufvar({buf}, {varname}, {val}) set {varname} in buffer {buf} to {val} +setcharpos({expr}, {list}) Number set the {expr} position to {list} +setcharsearch({dict}) Dict set character search from {dict} +setcmdpos({pos}) Number set cursor position in command-line +setcursorcharpos({list}) Number move cursor to position in {list} +setenv({name}, {val}) none set environment variable +setfperm({fname}, {mode} Number set {fname} file permissions to {mode} +setline({lnum}, {line}) Number set line {lnum} to {line} +setloclist({nr}, {list} [, {action}]) + Number modify location list using {list} +setloclist({nr}, {list}, {action}, {what}) + Number modify specific location list props +setmatches({list} [, {win}]) Number restore a list of matches +setpos({expr}, {list}) Number set the {expr} position to {list} +setqflist({list} [, {action}]) Number modify quickfix list using {list} +setqflist({list}, {action}, {what}) + Number modify specific quickfix list props +setreg({n}, {v} [, {opt}]) Number set register to value and type +settabvar({nr}, {varname}, {val}) set {varname} in tab page {nr} to {val} +settabwinvar({tabnr}, {winnr}, {varname}, {val}) set {varname} in window + {winnr} in tab page {tabnr} to {val} +settagstack({nr}, {dict} [, {action}]) + Number modify tag stack using {dict} +setwinvar({nr}, {varname}, {val}) set {varname} in window {nr} to {val} +sha256({string}) String SHA256 checksum of {string} +shellescape({string} [, {special}]) + String escape {string} for use as shell + command argument +shiftwidth([{col}]) Number effective value of 'shiftwidth' +sign_define({name} [, {dict}]) Number define or update a sign +sign_define({list}) List define or update a list of signs +sign_getdefined([{name}]) List get a list of defined signs +sign_getplaced([{buf} [, {dict}]]) + List get a list of placed signs +sign_jump({id}, {group}, {buf}) + Number jump to a sign +sign_place({id}, {group}, {name}, {buf} [, {dict}]) + Number place a sign +sign_placelist({list}) List place a list of signs +sign_undefine([{name}]) Number undefine a sign +sign_undefine({list}) List undefine a list of signs +sign_unplace({group} [, {dict}]) + Number unplace a sign +sign_unplacelist({list}) List unplace a list of signs +simplify({filename}) String simplify filename as much as possible +sin({expr}) Float sine of {expr} +sinh({expr}) Float hyperbolic sine of {expr} +sockconnect({mode}, {address} [, {opts}]) + Number Connects to socket +sort({list} [, {func} [, {dict}]]) + List sort {list}, using {func} to compare +soundfold({word}) String sound-fold {word} +spellbadword() String badly spelled word at cursor +spellsuggest({word} [, {max} [, {capital}]]) + List spelling suggestions +split({expr} [, {pat} [, {keepempty}]]) + List make |List| from {pat} separated {expr} +sqrt({expr}) Float square root of {expr} +srand([{expr}]) List get seed for |rand()| +stdioopen({dict}) Number open stdio in a headless instance. +stdpath({what}) String/List returns the standard path(s) for {what} +str2float({expr} [, {quoted}]) Float convert String to Float +str2list({expr} [, {utf8}]) List convert each character of {expr} to + ASCII/UTF-8 value +str2nr({expr} [, {base} [, {quoted}]]) + Number convert String to Number +strchars({expr} [, {skipcc}]) Number character length of the String {expr} +strcharpart({str}, {start} [, {len}]) + String {len} characters of {str} at + character {start} +strdisplaywidth({expr} [, {col}]) Number display length of the String {expr} +strftime({format} [, {time}]) String format time with a specified format +strgetchar({str}, {index}) Number get char {index} from {str} +stridx({haystack}, {needle} [, {start}]) + Number index of {needle} in {haystack} +string({expr}) String String representation of {expr} value +strlen({expr}) Number length of the String {expr} +strpart({str}, {start} [, {len} [, {chars}]]) + String {len} bytes/chars of {str} at + byte {start} +strptime({format}, {timestring}) + Number Convert {timestring} to unix timestamp +strridx({haystack}, {needle} [, {start}]) + Number last index of {needle} in {haystack} +strtrans({expr}) String translate string to make it printable +strwidth({expr}) Number display cell length of the String {expr} +submatch({nr} [, {list}]) String or List + specific match in ":s" or substitute() +substitute({expr}, {pat}, {sub}, {flags}) + String all {pat} in {expr} replaced with {sub} +swapinfo({fname}) Dict information about swap file {fname} +swapname({buf}) String swap file of buffer {buf} +synID({lnum}, {col}, {trans}) Number syntax ID at {lnum} and {col} +synIDattr({synID}, {what} [, {mode}]) + String attribute {what} of syntax ID {synID} +synIDtrans({synID}) Number translated syntax ID of {synID} +synconcealed({lnum}, {col}) List info about concealing +synstack({lnum}, {col}) List stack of syntax IDs at {lnum} and {col} +system({cmd} [, {input}]) String output of shell command/filter {cmd} +systemlist({cmd} [, {input}]) List output of shell command/filter {cmd} +tabpagebuflist([{arg}]) List list of buffer numbers in tab page +tabpagenr([{arg}]) Number number of current or last tab page +tabpagewinnr({tabarg} [, {arg}]) + Number number of current window in tab page +taglist({expr} [, {filename}]) List list of tags matching {expr} +tagfiles() List tags files used +tan({expr}) Float tangent of {expr} +tanh({expr}) Float hyperbolic tangent of {expr} +tempname() String name for a temporary file +test_garbagecollect_now() none free memory right now for testing +timer_info([{id}]) List information about timers +timer_pause({id}, {pause}) none pause or unpause a timer +timer_start({time}, {callback} [, {options}]) + Number create a timer +timer_stop({timer}) none stop a timer +timer_stopall() none stop all timers +tolower({expr}) String the String {expr} switched to lowercase +toupper({expr}) String the String {expr} switched to uppercase +tr({src}, {fromstr}, {tostr}) String translate chars of {src} in {fromstr} + to chars in {tostr} +trim({text} [, {mask} [, {dir}]]) + String trim characters in {mask} from {text} +trunc({expr}) Float truncate Float {expr} +type({name}) Number type of variable {name} +undofile({name}) String undo file name for {name} +undotree() List undo file tree +uniq({list} [, {func} [, {dict}]]) + List remove adjacent duplicates from a list +values({dict}) List values in {dict} +virtcol({expr}) Number screen column of cursor or mark +visualmode([expr]) String last visual mode used +wait({timeout}, {condition} [, {interval}]) + Number Wait until {condition} is satisfied +wildmenumode() Number whether 'wildmenu' mode is active +win_execute({id}, {command} [, {silent}]) + String execute {command} in window {id} +win_findbuf({bufnr}) List find windows containing {bufnr} +win_getid([{win} [, {tab}]]) Number get |window-ID| for {win} in {tab} +win_gettype([{nr}]) String type of window {nr} +win_gotoid({expr}) Number go to |window-ID| {expr} +win_id2tabwin({expr}) List get tab and window nr from |window-ID| +win_id2win({expr}) Number get window nr from |window-ID| +win_move_separator({nr}) Number move window vertical separator +win_move_statusline({nr}) Number move window status line +win_screenpos({nr}) List get screen position of window {nr} +win_splitmove({nr}, {target} [, {options}]) + Number move window {nr} to split of {target} +winbufnr({nr}) Number buffer number of window {nr} +wincol() Number window column of the cursor +windowsversion() String MS-Windows OS version +winheight({nr}) Number height of window {nr} +winlayout([{tabnr}]) List layout of windows in tab {tabnr} +winline() Number window line of the cursor +winnr([{expr}]) Number number of current window +winrestcmd() String returns command to restore window sizes +winrestview({dict}) none restore view of current window +winsaveview() Dict save view of current window +winwidth({nr}) Number width of window {nr} +wordcount() Dict get byte/char/word statistics +writefile({object}, {fname} [, {flags}]) + Number write |Blob| or |List| of lines to file +xor({expr}, {expr}) Number bitwise XOR + +============================================================================== +2. Details *builtin-function-details* + +Not all functions are here, some have been moved to a help file covering the +specific functionality. + +abs({expr}) *abs()* + 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() + +acos({expr}) *acos()* + 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() + +add({object}, {expr}) *add()* + 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) + +and({expr}, {expr}) *and()* + 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) + +api_info() *api_info()* + Returns Dictionary of |api-metadata|. + + View it in a nice human-readable format: > + :lua print(vim.inspect(vim.fn.api_info())) + +append({lnum}, {text}) *append()* + 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. + {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: > + mylist->append(lnum) + +appendbufline({buf}, {lnum}, {text}) *appendbufline()* + Like |append()| but append the text in buffer {expr}. + + 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: > + mylist->appendbufline(buf, lnum) + +argc([{winid}]) *argc()* + 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. + + *argidx()* +argidx() The result is the current index in the argument list. 0 is + the first file. argc() - 1 is the last one. See |arglist|. + + *arglistid()* +arglistid([{winnr} [, {tabnr}]]) + 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|. + + *argv()* +argv([{nr} [, {winid}]]) + 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 .. '<CR>' + : 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|. + +asin({expr}) *asin()* + 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() + + +assert_ functions are documented here: |assert-functions-details| + + +atan({expr}) *atan()* + 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() + +atan2({expr1}, {expr2}) *atan2()* + 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) + + *browse()* +browse({save}, {title}, {initdir}, {default}) + 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. + + *browsedir()* +browsedir({title}, {initdir}) + 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. + +bufadd({name}) *bufadd()* + Add a buffer to the buffer list with String {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 and not be loaded + yet. To add some text to the buffer use this: > + let bufnr = bufadd('someName') + call bufload(bufnr) + call setbufline(bufnr, 1, ['some', 'text']) +< Can also be used as a |method|: > + let bufnr = 'somename'->bufadd() + +bufexists({buf}) *bufexists()* + The result is a Number, which is |TRUE| if a buffer called + {buf} exists. + If the {buf} argument is a number, buffer numbers are used. + Number zero is the alternate buffer for the current window. + + If the {buf} argument is a string it must match a buffer name + exactly. The name can be: + - Relative to the current directory. + - A full path. + - The name of a buffer with 'buftype' set to "nofile". + - A URL name. + Unlisted buffers will be found. + Note that help files are listed by their short name in the + output of |:buffers|, but bufexists() requires using their + long name to be able to find them. + bufexists() may report a buffer exists, but to use the name + with a |:buffer| command you may need to use |expand()|. Esp + for MS-Windows 8.3 names in the form "c:\DOCUME~1" + Use "bufexists(0)" to test for the existence of an alternate + file name. + + Can also be used as a |method|: > + let exists = 'somename'->bufexists() + +buflisted({buf}) *buflisted()* + The result is a Number, which is |TRUE| if a buffer called + {buf} exists and is listed (has the 'buflisted' option set). + The {buf} argument is used like with |bufexists()|. + + Can also be used as a |method|: > + let listed = 'somename'->buflisted() + +bufload({buf}) *bufload()* + Ensure the buffer {buf} 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 {buf} argument is used like with |bufexists()|. + + Can also be used as a |method|: > + eval 'somename'->bufload() + +bufloaded({buf}) *bufloaded()* + The result is a Number, which is |TRUE| if a buffer called + {buf} exists and is loaded (shown in a window or hidden). + The {buf} argument is used like with |bufexists()|. + + Can also be used as a |method|: > + let loaded = 'somename'->bufloaded() + +bufname([{buf}]) *bufname()* + The result is the name of a buffer. Mostly as it is displayed + by the `:ls` command, but not using special names such as + "[No Name]". + If {buf} is omitted the current buffer is used. + If {buf} is a Number, that buffer number's name is given. + Number zero is the alternate buffer for the current window. + If {buf} 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 {buf} 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) +< Can also be used as a |method|: > + echo bufnr->bufname() + +< 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. +< + *bufnr()* +bufnr([{buf} [, {create}]]) + The result is the number of a buffer, as it is displayed by + the `:ls` command. For the use of {buf}, see |bufname()| + above. + If the buffer doesn't exist, -1 is returned. Or, if the + {create} argument is present and TRUE, 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. + + Can also be used as a |method|: > + echo bufref->bufnr() + +bufwinid({buf}) *bufwinid()* + The result is a Number, which is the |window-ID| of the first + window associated with buffer {buf}. For the use of {buf}, + see |bufname()| above. If buffer {buf} doesn't exist or + there is no such window, -1 is returned. Example: > + + echo "A window containing buffer 1 is " .. (bufwinid(1)) +< + Only deals with the current tab page. + + Can also be used as a |method|: > + FindBuffer()->bufwinid() + +bufwinnr({buf}) *bufwinnr()* + Like |bufwinid()| but return the window number instead of the + |window-ID|. + If buffer {buf} doesn't exist or there is no such window, -1 + is returned. Example: > + + echo "A window containing buffer 1 is " .. (bufwinnr(1)) + +< The number can be used with |CTRL-W_w| and ":wincmd w" + |:wincmd|. + + Can also be used as a |method|: > + FindBuffer()->bufwinnr() + +byte2line({byte}) *byte2line()* + Return the line number that contains the character at byte + count {byte} in the current buffer. This includes the + end-of-line character, depending on the 'fileformat' option + for the current buffer. The first character has byte count + one. + Also see |line2byte()|, |go| and |:goto|. + + Can also be used as a |method|: > + GetOffset()->byte2line() + +byteidx({expr}, {nr}) *byteidx()* + 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) + +byteidxcomp({expr}, {nr}) *byteidxcomp()* + 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({func}, {arglist} [, {dict}]) *call()* *E699* + 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) + +ceil({expr}) *ceil()* + 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() + +changenr() *changenr()* + 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. + +chanclose({id} [, {stream}]) *chanclose()* + Close a channel or a specific stream associated with it. + For a job, {stream} can be one of "stdin", "stdout", + "stderr" or "rpc" (closes stdin/stdout for a job started + with `"rpc":v:true`) If {stream} is omitted, all streams + are closed. If the channel is a pty, this will then close the + pty master, sending SIGHUP to the job process. + For a socket, there is only one stream, and {stream} should be + ommited. + +chansend({id}, {data}) *chansend()* + Send data to channel {id}. For a job, it writes it to the + stdin of the process. For the stdio channel |channel-stdio|, + it writes to Nvim's stdout. Returns the number of bytes + written if the write succeeded, 0 otherwise. + See |channel-bytes| for more information. + + {data} may be a string, string convertible, |Blob|, or a list. + If {data} is a list, the items will be joined by newlines; any + newlines in an item will be sent as NUL. To send a final + newline, include a final empty string. Example: > + :call chansend(id, ["abc", "123\n456", ""]) +< will send "abc<NL>123<NUL>456<NL>". + + chansend() writes raw data, not RPC messages. If the channel + was created with `"rpc":v:true` then the channel expects RPC + messages, use |rpcnotify()| and |rpcrequest()| instead. + + +char2nr({string} [, {utf8}]) *char2nr()* + Return number value of the first char in {string}. + Examples: > + char2nr(" ") returns 32 + char2nr("ABC") returns 65 + char2nr("á") returns 225 + char2nr("á"[0]) returns 195 + char2nr("\<M-x>") returns 128 +< Non-ASCII characters are always treated as UTF-8 characters. + {utf8} is ignored, it exists only for backwards-compatibility. + A combining character is a separate character. + |nr2char()| does the opposite. + + Can also be used as a |method|: > + GetChar()->char2nr() +< + *charcol()* +charcol({expr}) Same as |col()| but returns the character index of the column + position given with {expr} instead of the byte position. + + Example: + With the cursor on '세' in line 5 with text "여보세요": > + charcol('.') returns 3 + col('.') returns 7 + +< Can also be used as a |method|: > + GetPos()->col() +< + *charidx()* +charidx({string}, {idx} [, {countcc}]) + 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) + +chdir({dir}) *chdir()* + 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. + 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 +< +cindent({lnum}) *cindent()* + Get the amount of indent for line {lnum} according the C + indenting rules, as with 'cindent'. + The indent is counted in spaces, the value of 'tabstop' is + relevant. {lnum} is used just like in |getline()|. + When {lnum} is invalid -1 is returned. + See |C-indenting|. + + Can also be used as a |method|: > + GetLnum()->cindent() + +clearmatches([{win}]) *clearmatches()* + 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() +< + *col()* +col({expr}) 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()|. For the + character position use |charcol()|. + 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 <F2> <C-O>:let save_ve = &ve<CR> + \<C-O>:set ve=all<CR> + \<C-O>:echo col(".") .. "\n" <Bar> + \let &ve = save_ve<CR> + +< Can also be used as a |method|: > + GetPos()->col() +< + +complete({startcol}, {matches}) *complete()* *E785* + 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 <F5> <C-R>=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('.')) + +complete_add({expr}) *complete_add()* + 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() + +complete_check() *complete_check()* + 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. + + +complete_info([{what}]) *complete_info()* + 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 <Up> or + <Down> keys) + inserted Inserted string. [NOT IMPLEMENT YET] + + *complete_info_mode* + mode values are: + "" Not in completion mode + "keyword" Keyword completion |i_CTRL-X_CTRL-N| + "ctrl_x" Just pressed CTRL-X |i_CTRL-X| + "scroll" Scrolling with |i_CTRL-X_CTRL-E| or + |i_CTRL-X_CTRL-Y| + "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()* +confirm({msg} [, {choices} [, {default} [, {type}]]]) + Confirm() offers the user a dialog, from which a choice can be + made. It returns the number of the choice. For the first + choice this is 1. + + {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 {type} String argument gives the type of dialog. + 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. + + The optional {type} argument gives the type of dialog. This + is only used for the icon of the Win32 GUI. It can be one of + these values: "Error", "Question", "Info", "Warning" or + "Generic". Only the first character is relevant. + When {type} is omitted, "Generic" is used. + + If the user aborts the dialog by pressing <Esc>, CTRL-C, + or another valid interrupt key, confirm() returns 0. + + An example: > + :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2) + :if choice == 0 + : echo "make up your mind!" + :elseif choice == 3 + : echo "tasteful" + :else + : echo "I prefer bananas myself." + :endif +< In a GUI dialog, buttons are used. The layout of the buttons + depends on the 'v' flag in 'guioptions'. If it is included, + the buttons are always put vertically. Otherwise, confirm() + tries to put the buttons in one horizontal line. If they + don't fit, a vertical layout is used anyway. For some systems + the horizontal layout is always used. + + Can also be used as a |method|in: > + BuildMessage()->confirm("&Yes\n&No") +< + *copy()* +copy({expr}) 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() + +cos({expr}) *cos()* + 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() + +cosh({expr}) *cosh()* + 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() + +count({comp}, {expr} [, {ic} [, {start}]]) *count()* + 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) +< + *cscope_connection()* +cscope_connection([{num} , {dbpath} [, {prepend}]]) + Checks for the existence of a |cscope| connection. If no + parameters are specified, then the function returns: + 0, if 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 +< + +ctxget([{index}]) *ctxget()* + Returns a |Dictionary| representing the |context| at {index} + from the top of the |context-stack| (see |context-dict|). + If {index} is not given, it is assumed to be 0 (i.e.: top). + +ctxpop() *ctxpop()* + Pops and restores the |context| at the top of the + |context-stack|. + +ctxpush([{types}]) *ctxpush()* + Pushes the current editor state (|context|) on the + |context-stack|. + If {types} is given and is a |List| of |String|s, it specifies + which |context-types| to include in the pushed context. + Otherwise, all context types are included. + +ctxset({context} [, {index}]) *ctxset()* + Sets the |context| at {index} from the top of the + |context-stack| to that represented by {context}. + {context} is a Dictionary with context data (|context-dict|). + If {index} is not given, it is assumed to be 0 (i.e.: top). + +ctxsize() *ctxsize()* + Returns the size of the |context-stack|. + +cursor({lnum}, {col} [, {off}]) *cursor()* +cursor({list}) + 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. + + To position the cursor using the character count, use + |setcursorcharpos()|. + + 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 <Tab> or after the last character. + Returns 0 when the position could be set, -1 otherwise. + + Can also be used as a |method|: > + GetCursorPos()->cursor() + +deepcopy({expr} [, {noref}]) *deepcopy()* *E698* + 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|, a copy for it + is made, recursively. Thus changing an item in the copy does + not change the contents of the original |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. + *E724* + 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() + +delete({fname} [, {flags}]) *delete()* + Without {flags} or with {flags} empty: Deletes the file by the + name {fname}. This also works when {fname} is a symbolic link. + A symbolic link itself is deleted, not what it points to. + + 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. + + 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. + + Can also be used as a |method|: > + GetName()->delete() + +deletebufline({buf}, {first} [, {last}]) *deletebufline()* + 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) +< +dictwatcheradd({dict}, {pattern}, {callback}) *dictwatcheradd()* + Adds a watcher to a dictionary. A dictionary watcher is + identified by three components: + + - A dictionary({dict}); + - A key pattern({pattern}). + - A function({callback}). + + After this is called, every change on {dict} and on keys + matching {pattern} will result in {callback} being invoked. + + For example, to watch all global variables: > + silent! call dictwatcherdel(g:, '*', 'OnDictChanged') + function! OnDictChanged(d,k,z) + echomsg string(a:k) string(a:z) + endfunction + call dictwatcheradd(g:, '*', 'OnDictChanged') +< + For now {pattern} only accepts very simple patterns that can + contain a '*' at the end of the string, in which case it will + match every key that begins with the substring before the '*'. + That means if '*' is not the last character of {pattern}, only + keys that are exactly equal as {pattern} will be matched. + + The {callback} receives three arguments: + + - The dictionary being watched. + - The key which changed. + - A dictionary containing the new and old values for the key. + + The type of change can be determined by examining the keys + present on the third argument: + + - If contains both `old` and `new`, the key was updated. + - If it contains only `new`, the key was added. + - If it contains only `old`, the key was deleted. + + This function can be used by plugins to implement options with + validation and parsing logic. + +dictwatcherdel({dict}, {pattern}, {callback}) *dictwatcherdel()* + Removes a watcher added with |dictwatcheradd()|. All three + arguments must match the ones passed to |dictwatcheradd()| in + order for the watcher to be successfully deleted. + + *did_filetype()* +did_filetype() 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. + +diff_filler({lnum}) *diff_filler()* + 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() + +diff_hlID({lnum}, {col}) *diff_hlID()* + 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) + +empty({expr}) *empty()* + 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| and |v:null| are empty, |v:true| is not. + - A |Blob| is empty when its length is zero. + + Can also be used as a |method|: > + mylist->empty() + +environ() *environ()* + 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({string}, {chars}) *escape()* + Escape the characters in {chars} that occur in {string} with a + backslash. Example: > + :echo escape('c:\program files\vim', ' \') +< results in: > + c:\\program\ files\\vim +< Also see |shellescape()| and |fnameescape()|. + + Can also be used as a |method|: > + GetText()->escape(' \') +< + *eval()* +eval({string}) 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() + +eventhandler() *eventhandler()* + 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. + +executable({expr}) *executable()* + This function checks if an executable with the name {expr} + exists. {expr} must be the name of the program without any + arguments. + executable() uses the value of $PATH and/or the normal + searchpath for programs. *PATHEXT* + 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 ".exe;.com;.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 Windows an executable in the same directory as Vim is + always found (it is added to $PATH at |startup|). + 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({command} [, {silent}]) *execute()* + Execute {command} and capture its output. + If {command} is a |String|, returns {command} output. + If {command} is a |List|, returns concatenated outputs. + Examples: > + echo execute('echon "foo"') +< foo > + echo execute(['echon "foo"', 'echon "bar"']) +< foobar + + 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. + + To get a list of lines use |split()| on the result: > + split(execute('args'), "\n") + +< This function is not available in the |sandbox|. + Note: If nested, an outer execute() will not observe output of + the inner calls. + Note: Text attributes (highlights) are not captured. + To execute a command in another window than the current one + use `win_execute()`. + + Can also be used as a |method|: > + GetCommand()->execute() + +exepath({expr}) *exepath()* + Returns the full path of {expr} if it is an executable and + given as a (partial or full) path or is found in $PATH. + Returns empty string otherwise. + If {expr} starts with "./" the |current-directory| is used. + + Can also be used as a |method|: > + GetCommand()->exepath() +< + *exists()* +exists({expr}) The result is a Number, which is |TRUE| if {expr} is + defined, zero otherwise. + + For checking for a supported feature use |has()|. + For checking if a file exists use |filereadable()|. + + The {expr} argument is a string, which contains one of these: + varname internal variable (see + dict.key |internal-variables|). Also works + list[i] for |curly-braces-names|, |Dictionary| + entries, |List| items, etc. + Beware that evaluating an index may + cause an error message for an invalid + expression. E.g.: > + :let l = [1, 2, 3] + :echo exists("l[5]") +< 0 > + :echo exists("l[xx]") +< E121: Undefined variable: xx + 0 + &option-name Vim option (only checks if it exists, + not if it really works) + +option-name Vim option that works. + $ENVNAME environment variable (could also be + done by comparing with an empty + string) + *funcname built-in function (see |functions|) + or user defined function (see + |user-function|). Also works for a + variable that is a Funcref. + :cmdname Ex command: built-in command, user + command or command modifier |:command|. + Returns: + 1 for match with start of a command + 2 full match with a command + 3 matches several user commands + To check for a supported command + always check the return value to be 2. + :2match The |:2match| command. + :3match The |:3match| command. + #event autocommand defined for this event + #event#pattern autocommand defined for this event and + pattern (the pattern is taken + literally and compared to the + autocommand patterns character by + character) + #group autocommand group exists + #group#event autocommand defined for this group and + event. + #group#event#pattern + autocommand defined for this group, + event and pattern. + ##event autocommand for this event is + supported. + + Examples: > + exists("&mouse") + exists("$HOSTNAME") + exists("*strftime") + exists("*s:MyFunc") + exists("*MyFunc") + exists("bufcount") + exists(":Make") + exists("#CursorHold") + exists("#BufReadPre#*.gz") + exists("#filetypeindent") + exists("#filetypeindent#FileType") + exists("#filetypeindent#FileType#*") + exists("##ColorScheme") +< There must be no space between the symbol (&/$/*/#) and the + name. + There must be no extra characters after the name, although in + a few cases this is ignored. That may become more strict in + the future, thus don't count on it! + Working example: > + exists(":make") +< NOT working example: > + exists(":make install") + +< Note that the argument must be a string, not the name of the + variable itself. For example: > + exists(bufcount) +< This doesn't check for existence of the "bufcount" variable, + but gets the value of "bufcount", and checks if that exists. + + Can also be used as a |method|: > + Varname()->exists() + +exp({expr}) *exp()* + 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() + +debugbreak({pid}) *debugbreak()* + 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|. + {Sends a SIGINT to a process {pid} other than MS-Windows} + + Can also be used as a |method|: > + GetPid()->debugbreak() + +expand({string} [, {nosuf} [, {list}]]) *expand()* + 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 <NL> characters. + + 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 + <cfile> file name under the cursor + <afile> autocmd file name + <abuf> autocmd buffer number (as a String!) + <amatch> autocmd matched name + <sfile> sourced script file or function name + <slnum> sourced script line number or function + line number + <sflnum> script file line number, also when in + a function + <SID> "<SNR>123_" where "123" is the + current script ID |<SID>| + <cword> word under the cursor + <cWORD> WORD under the cursor + <client> the {clientid} of the last received + message |server2client()| + Modifiers: + :p expand to full path + :h head (last path component removed) + :t tail (last path component only) + :r root (one extension removed) + :e extension only + + Example: > + :let &tags = expand("%:p:h") .. "/tags" +< Note that when expanding a string that starts with '%', '#' or + '<', any following text is ignored. This does NOT work: > + :let doesntwork = expand("%:h.bak") +< Use this: > + :let doeswork = expand("%:h") .. ".bak" +< Also note that expanding "<cfile>" and others only returns the + referenced file name without further expansion. If "<cfile>" + is "~/.cshrc", you need to do another expand() to have the + "~/" expanded into the path of the home directory: > + :echo expand(expand("<cfile>")) +< + There cannot be white space between the variables and the + following modifier. The |fnamemodify()| function can be used + to modify normal file names. + + When using '%' or '#', and the current or alternate file name + is not defined, an empty string is used. Using "%:p" in a + buffer with no name, results in the current directory, with a + '/' added. + + When {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() + +expandcmd({string}) *expandcmd()* + 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() +< +extend({expr1}, {expr2} [, {expr3}]) *extend()* + {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 *E737* + 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) + +feedkeys({string} [, {mode}]) *feedkeys()* + 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 <Enter> key. But + feedkeys('\<CR>') pushes 5 characters. + The |<Ignore>| keycode may be used to exit the + wait-for-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. + '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 <Esc> 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 typehead 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() + +filereadable({file}) *filereadable()* + The result is a Number, which is |TRUE| when a file with the + name {file} exists, and can be read. If {file} doesn't exist, + or is a directory, the result is |FALSE|. {file} is any + expression, which is used as a String. + 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() + +filewritable({file}) *filewritable()* + The result is a Number, which is 1 when a file with the + name {file} exists, and can be written. If {file} doesn't + exist, or is not writable, the result is 0. If {file} is a + directory, and we can write to it, the result is 2. + + Can also be used as a |method|: > + GetName()->filewriteable() + +filter({expr1}, {expr2}) *filter()* + {expr1} must be a |List|, |Blob|, or a |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) + +finddir({name} [, {path} [, {count}]]) *finddir()* + 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`. + + Can also be used as a |method|: > + GetName()->finddir() + +findfile({name} [, {path} [, {count}]]) *findfile()* + 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} [, {maxdepth}]) *flatten()* + 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, make a copy first if you do + not want that. + *E900* + {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] + + Can also be used as a |method|: > + mylist->flatten() +< +float2nr({expr}) *float2nr()* + 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() + +floor({expr}) *floor()* + 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() + +fmod({expr1}, {expr2}) *fmod()* + 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) + +fnameescape({string}) *fnameescape()* + 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() + +fnamemodify({fname}, {mods}) *fnamemodify()* + Modify file name {fname} according to {mods}. {mods} is a + string of characters like it is used for file names on the + command line. See |filename-modifiers|. + Example: > + :echo fnamemodify("main.c", ":p:h") +< results in: > + /home/mool/vim/vim/src +< 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') + +foldclosed({lnum}) *foldclosed()* + The result is a Number. If the line {lnum} is in a closed + fold, the result is the number of the first line in that fold. + If the line {lnum} is not in a closed fold, -1 is returned. + {lnum} is used like with |getline()|. Thus "." is the current + line, "'m" mark m, etc. + + Can also be used as a |method|: > + GetLnum()->foldclosed() + +foldclosedend({lnum}) *foldclosedend()* + The result is a Number. If the line {lnum} is in a closed + fold, the result is the number of the last line in that fold. + If the line {lnum} is not in a closed fold, -1 is returned. + {lnum} is used like with |getline()|. Thus "." is the current + line, "'m" mark m, etc. + + Can also be used as a |method|: > + GetLnum()->foldclosedend() + +foldlevel({lnum}) *foldlevel()* + The result is a Number, which is the foldlevel of line {lnum} + in the current buffer. For nested folds the deepest level is + returned. If there is no fold at line {lnum}, zero is + returned. It doesn't matter if the folds are open or closed. + When used while updating folds (from 'foldexpr') -1 is + returned for lines where folds are still to be updated and the + foldlevel is unknown. 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() +< + *foldtext()* +foldtext() Returns a String, to be displayed for a closed fold. This is + the default function used for the 'foldtext' option and should + only be called from evaluating 'foldtext'. It uses the + |v:foldstart|, |v:foldend| and |v:folddashes| variables. + The returned string looks like this: > + +-- 45 lines: abcdef +< The number of 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. + +foldtextresult({lnum}) *foldtextresult()* + 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. + + Can also be used as a |method|: > + GetLnum()->foldtextresult() +< + *foreground()* +foreground() Move the Vim window to the foreground. Useful when sent from + a client to a Vim server. |remote_send()| + On Win32 systems this might not work, the OS does not always + allow a window to bring itself to the foreground. Use + |remote_foreground()| instead. + {only in the Win32 GUI and console version} + +fullcommand({name}) *fullcommand()* + Get the full command name from a short abbreviated command + name; see |20.2| for details on command abbreviations. + + The string argument {name} may start with a `:` and can + include a [range], these are skipped and not returned. + Returns an empty string if a command doesn't exist or if it's + ambiguous (for user-defined commands). + + For example `fullcommand('s')`, `fullcommand('sub')`, + `fullcommand(':%substitute')` all return "substitute". + + Can also be used as a |method|: > + GetName()->fullcommand() +< + *funcref()* +funcref({name} [, {arglist}] [, {dict}]) + 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. + It only works for an autoloaded function if it has already + been loaded (to avoid mistakenly loading the autoload script + when only intending to use the function name, use |function()| + instead). {name} cannot be a builtin function. + + Can also be used as a |method|: > + GetFuncname()->funcref([arg]) +< + *function()* *E700* *E922* *E923* +function({name} [, {arglist}] [, {dict}]) + Return a |Funcref| variable that refers to function {name}. + {name} can be 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') + +< 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 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]) + +garbagecollect([{atexit}]) *garbagecollect()* + Cleanup unused |Lists| and |Dictionaries| 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. + +get({list}, {idx} [, {default}]) *get()* + Get item {idx} from |List| {list}. When this item is not + available return {default}. Return zero when {default} is + omitted. + Can also be used as a |method|: > + mylist->get(idx) +get({blob}, {idx} [, {default}]) + Get byte {idx} from |Blob| {blob}. When this byte is not + available return {default}. Return -1 when {default} is + omitted. +get({dict}, {key} [, {default}]) + Get item with key {key} from |Dictionary| {dict}. When this + item is not available return {default}. Return zero when + {default} is omitted. Useful example: > + let val = get(g:, 'var_name', 'default') +< This gets the value of g:var_name if it exists, and uses + 'default' when it does not exist. +get({func}, {what}) + Get item {what} from Funcref {func}. Possible values for + {what} are: + "name" The function name + "func" The function + "dict" The dictionary + "args" The list with arguments + + *getbufinfo()* +getbufinfo([{buf}]) +getbufinfo([{dict}]) + 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. + 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 + + 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() +< + *getbufline()* +getbufline({buf}, {lnum} [, {end}]) + Return a |List| with the lines starting from {lnum} to {end} + (inclusive) in the buffer {buf}. If {end} is omitted, a + |List| with only the line {lnum} is returned. + + For the use of {buf}, see |bufname()| above. + + For {lnum} and {end} "$" can be used for the last line of the + buffer. Otherwise a number must be used. + + When {lnum} is smaller than 1 or bigger than the number of + lines in the buffer, an empty |List| is returned. + + When {end} is greater than the number of lines in the buffer, + it is treated as {end} is set to the number of lines in the + buffer. When {end} is before {lnum} an empty |List| is + returned. + + This function works only for loaded buffers. For unloaded and + non-existing buffers, an empty |List| is returned. + + Example: > + :let lines = getbufline(bufnr("myfile"), 1, "$") + +< Can also be used as a |method|: > + GetBufnr()->getbufline(lnum) + +getbufvar({buf}, {varname} [, {def}]) *getbufvar()* + 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) +< +getchangelist([{buf}]) *getchangelist()* + 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() + +getchar([expr]) *getchar()* + 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 +< + 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. + + There is no mapping for the character. + Key codes are replaced, thus when the user presses the <Del> + key you get the code for the <Del> key, not the raw character + sequence. Examples: > + getchar() == "\<Del>" + getchar() == "\<S-Left>" +< This example redefines "f" to ignore case: > + :nmap f :call FindChar()<CR> + :function FindChar() + : let c = nr2char(getchar()) + : while col('.') < col('$') - 1 + : normal l + : if getline('.')[col('.') - 1] ==? c + : break + : endif + : endwhile + :endfunction +< +getcharmod() *getcharmod()* + The result is a Number which is the state of the modifiers for + the last obtained character with getchar() or in another way. + These values are added together: + 2 shift + 4 control + 8 alt (meta) + 16 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. + + *getcharpos()* +getcharpos({expr}) + Get the position for String {expr}. Same as |getpos()| but the + column number in the returned List is a character index + instead of a byte index. + + Example: + With the cursor on '세' in line 5 with text "여보세요": > + getcharpos('.') returns [0, 5, 3, 0] + getpos('.') returns [0, 5, 7, 0] +< + Can also be used as a |method|: > + GetMark()->getcharpos() + +getcharsearch() *getcharsearch()* + 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 <expr> ; getcharsearch().forward ? ';' : ',' + :nnoremap <expr> , getcharsearch().forward ? ',' : ';' +< Also see |setcharsearch()|. + + +getcharstr([expr]) *getcharstr()* + 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. + + +getcmdline() *getcmdline()* + 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 <F7> <C-\>eescape(getcmdline(), ' \')<CR> +< Also see |getcmdtype()|, |getcmdpos()| and |setcmdpos()|. + Returns an empty string when entering a password or using + |inputsecret()|. + +getcmdpos() *getcmdpos()* + 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()|. + +getcmdtype() *getcmdtype()* + 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()|. + +getcmdwintype() *getcmdwintype()* + 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. + +getcompletion({pat}, {type} [, {filtered}]) *getcompletion()* + 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 + cmdline |cmdline-completion| result + color color schemes + command Ex command + 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') +< + *getcurpos()* +getcurpos([{winid}]) + Get the position of the cursor. This is like getpos('.'), but + includes an extra "curswant" in the list: + [0, lnum, col, off, curswant] ~ + The "curswant" number is the preferred column when moving the + cursor vertically. Also see |getcursorcharpos()| and + |getpos()|. + The first "bufnum" item is always zero. The byte position of + the cursor is returned in 'col'. To get the character + position, use |getcursorcharpos()|. + + The optional {winid} argument can specify the window. It can + be the window number or the |window-ID|. The last known + cursor position is returned, this may be invalid for the + current value of the buffer if it is not the current window. + If {winid} is invalid a list with zeroes is returned. + + 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. + + Can also be used as a |method|: > + GetWinid()->getcurpos() +< + *getcursorcharpos()* +getcursorcharpos([{winid}]) + Same as |getcurpos()| but the column number in the returned + List is a character index instead of a byte index. + + Example: + With the cursor on '보' in line 3 with text "여보세요": > + getcursorcharpos() returns [0, 3, 2, 0, 3] + getcurpos() returns [0, 3, 4, 0, 3] +< + Can also be used as a |method|: > + GetWinid()->getcursorcharpos() + +getcwd([{winnr} [, {tabnr}]]) *getcwd()* + With no arguments, returns the name of the effective + |current-directory|. With {winnr} or {tabnr} the working + directory of that scope is returned, and 'autochdir' is + ignored. + Tabs and windows are identified by their respective numbers, + 0 means current tab or window. Missing tab number implies 0. + Thus the following are equivalent: > + getcwd(0) + getcwd(0, 0) +< If {winnr} is -1 it is ignored, only the tab is resolved. + {winnr} can be the window number or the |window-ID|. + If both {winnr} and {tabnr} are -1 the global working + directory is returned. + Throw error if the arguments are invalid. |E5000| |E5001| |E5002| + + Can also be used as a |method|: > + GetWinnr()->getcwd() + +getenv({name}) *getenv()* + 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. + See also |expr-env|. + + Can also be used as a |method|: > + GetVarname()->getenv() + +getfontname([{name}]) *getfontname()* + 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. + +getfperm({fname}) *getfperm()* + 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("~/.config/nvim/init.vim")) +< 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()|. + +getfsize({fname}) *getfsize()* + The result is a Number, which is the size in bytes of the + given file {fname}. + If {fname} is a directory, 0 is returned. + If the file {fname} can't be found, -1 is returned. + 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() + +getftime({fname}) *getftime()* + The result is a Number, which is the last modification time of + the given file {fname}. The value is measured as seconds + since 1st Jan 1970, and may be passed to strftime(). See also + |localtime()| and |strftime()|. + If the file {fname} can't be found -1 is returned. + + Can also be used as a |method|: > + GetFilename()->getftime() + +getftype({fname}) *getftype()* + 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. + + Can also be used as a |method|: > + GetFilename()->getftype() + +getjumplist([{winnr} [, {tabnr}]]) *getjumplist()* + 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() + +< *getline()* +getline({lnum} [, {end}]) + 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 a number smaller than 1 or bigger than the + number of lines in the buffer, an empty string is returned. + + When {end} is given the result is a |List| where each item is + a line from the current buffer in the range {lnum} to {end}, + including line {end}. + {end} is used in the same way as {lnum}. + Non-existing lines are silently omitted. + When {end} is before {lnum} an empty |List| is returned. + Example: > + :let start = line('.') + :let end = search("^$") - 1 + :let lines = getline(start, end) + +< Can also be used as a |method|: > + ComputeLnum()->getline() + +< To get lines from another buffer see |getbufline()| + +getloclist({nr} [, {what}]) *getloclist()* + 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}. + If {what} contains 'filewinid', then returns the 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}) + + +getmarklist([{buf}]) *getmarklist()* + 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() + +getmatches([{win}]) *getmatches()* + 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 +< +getmousepos() *getmousepos()* + Returns a Dictionary with the last known position of the + mouse. This can be used in a mapping for a mouse click. 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 + separater 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 focusable floating 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. + + *getpid()* +getpid() Return a Number which is the process ID of the Vim process. + This is a unique number, until Vim exits. + + *getpos()* +getpos({expr}) Get the position for String {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 <Tab> 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. + The column number in the returned List is the byte position + within the line. To get the character position in the line, + use |getcharpos()|. + The column number can be very large, e.g. 2147483647, in which + case it means "after the end of the line". + 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 |getcharpos()|, |getcurpos()| and |setpos()|. + + Can also be used as a |method|: > + GetMark()->getpos() + +getqflist([{what}]) *getqflist()* + 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 + 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 + 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"]}) +< +getreg([{regname} [, 1 [, {list}]]]) *getreg()* + The result is a String, which is the contents of register + {regname}. Example: > + :let cliptext = getreg('*') +< When register {regname} was not set the result is an empty + string. + The {regname} argument must be 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. + + Can also be used as a |method|: > + GetRegname()->getreg() + +getreginfo([{regname}]) *getreginfo()* + 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()|. + + Can also be used as a |method|: > + GetRegname()->getreginfo() + +getregtype([{regname}]) *getregtype()* + The result is a String, which is type of register {regname}. + The value will be one of: + "v" for |charwise| text + "V" for |linewise| text + "<CTRL-V>{width}" for |blockwise-visual| text + "" for an empty or unknown register + <CTRL-V> is one character with value 0x16. + The {regname} argument is a string. If {regname} is not + specified, |v:register| is used. + + Can also be used as a |method|: > + GetRegname()->getregtype() + +gettabinfo([{tabnr}]) *gettabinfo()* + 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() + +gettabvar({tabnr}, {varname} [, {def}]) *gettabvar()* + 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) + +gettabwinvar({tabnr}, {winnr}, {varname} [, {def}]) *gettabwinvar()* + 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) + +gettagstack([{winnr}]) *gettagstack()* + 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() + +getwininfo([{winid}]) *getwininfo()* + 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 + quickfix 1 if quickfix or location list window + terminal 1 if a terminal window + 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()| + textoff number of columns occupied by any + 'foldcolumn', 'signcolumn' and line + number in front of the text + 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() + +getwinpos([{timeout}]) *getwinpos()* + 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() +< + *getwinposx()* +getwinposx() The result is a Number, which is the X coordinate in pixels of + the left hand side of the GUI Vim window. The result will be + -1 if the information is not available. + The value can be used with `:winpos`. + + *getwinposy()* +getwinposy() The result is a Number, which is the Y coordinate in pixels of + the top of the GUI Vim window. The result will be -1 if the + information is not available. + The value can be used with `:winpos`. + +getwinvar({winnr}, {varname} [, {def}]) *getwinvar()* + 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) +< +glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) *glob()* + 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 <NL> 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() + +glob2regpat({string}) *glob2regpat()* + 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() +< *globpath()* +globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]]) + 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 <NL> characters. Example: > + :echo globpath(&rtp, "syntax/c.vim", 0, 1) +< + {allinks} 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) +< + *has()* +has({feature}) 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()|. + + If the code has a syntax error, then Nvim may skip the rest + of the line and miss |:endif|. > + if has('feature') | let x = this->breaks->without->the->feature | endif +< + Put |:if| and |:endif| on separate lines to avoid the + syntax error. > + if has('feature') + let x = this->breaks->without->the->feature + endif +< + Vim's compile-time feature-names (prefixed with "+") are not + recognized because Nvim is always compiled with all possible + features. |feature-compile| + + Feature names can be: + 1. Nvim version. For example the "nvim-0.2.1" feature means + that Nvim is version 0.2.1 or later: > + :if has("nvim-0.2.1") + +< 2. Runtime condition or other pseudo-feature. For example the + "win32" feature checks if the current system is Windows: > + :if has("win32") +< *feature-list* + List of supported pseudo-feature names: + acl |ACL| support. + bsd BSD system (not macOS, use "mac" for that). + clipboard |clipboard| provider is available. + fname_case Case in file names matters (for Darwin and MS-Windows + this is not present). + iconv Can use |iconv()| for conversion. + linux Linux system. + mac MacOS system. + nvim This is Nvim. + python3 Legacy Vim |python3| interface. |has-python| + pythonx Legacy Vim |python_x| interface. |has-pythonx| + sun SunOS system. + ttyin input is a terminal (tty). + ttyout output is a terminal (tty). + unix Unix system. + *vim_starting* True during |startup|. + win32 Windows system (32 or 64 bit). + win64 Windows system (64 bit). + wsl WSL (Windows Subsystem for Linux) system. + + *has-patch* + 3. Vim patch. For example the "patch123" feature means that + Vim patch 123 at the current |v:version| was included: > + :if v:version > 602 || v:version == 602 && has("patch148") + +< 4. Vim version. For example the "patch-7.4.237" feature means + that Nvim is Vim-compatible to version 7.4.237 or later. > + :if has("patch-7.4.237") + + +has_key({dict}, {key}) *has_key()* + 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) + +haslocaldir([{winnr} [, {tabnr}]]) *haslocaldir()* + The result is a Number, which is 1 when the window has set a + local path via |:lcd| or when {winnr} is -1 and the tabpage + has set a local path via |:tcd|, otherwise 0. + + Tabs and windows are identified by their respective numbers, + 0 means current tab or window. Missing argument implies 0. + Thus the following are equivalent: > + haslocaldir() + haslocaldir(0) + haslocaldir(0, 0) +< With {winnr} use that window in the current tabpage. + With {winnr} and {tabnr} use the window in that tabpage. + {winnr} can be the window number or the |window-ID|. + If {winnr} is -1 it is ignored, only the tab is resolved. + Throw error if the arguments are invalid. |E5000| |E5001| |E5002| + + Can also be used as a |method|: > + GetWinnr()->haslocaldir() + +hasmapto({what} [, {mode} [, {abbr}]]) *hasmapto()* + 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 <Leader>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() + +histadd({history}, {item}) *histadd()* + Add the String {item} to the history {history} which can be + one of: *hist-names* + "cmd" or ":" command line history + "search" or "/" search pattern history + "expr" or "=" typed expression history + "input" or "@" input line history + "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') + +histdel({history} [, {item}]) *histdel()* + 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() + +histget({history} [, {index}]) *histget()* + The result is a String, the entry with Number {index} from + {history}. See |hist-names| for the possible values of + {history}, and |:history-indexing| for {index}. If there is + no such entry, an empty String is returned. When {index} is + omitted, the most recent item from the history is used. + + Examples: + Redo the second last search from history. > + :execute '/' .. histget("search", -2) + +< Define an Ex command ":H {num}" that supports re-execution of + the {num}th entry from the output of |:history|. > + :command -nargs=1 H execute histget("cmd", 0+<args>) +< + Can also be used as a |method|: > + GetHistory()->histget() + +histnr({history}) *histnr()* + The result is the Number of the current entry in {history}. + See |hist-names| for the possible values of {history}. + If an error occurred, -1 is returned. + + Example: > + :let inp_index = histnr("expr") + +< Can also be used as a |method|: > + GetHistory()->histnr() +< +hlexists({name}) *hlexists()* + 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. + + Can also be used as a |method|: > + GetName()->hlexists() +< + *hlID()* +hlID({name}) The result is a Number, which is the ID of the highlight group + with name {name}. When the highlight group doesn't exist, + zero is returned. + This can be used to retrieve information about the highlight + group. For example, to get the background color of the + "Comment" group: > + :echo synIDattr(synIDtrans(hlID("Comment")), "bg") +< + Can also be used as a |method|: > + GetName()->hlID() + +hostname() *hostname()* + The result is a String, which is the name of the machine on + which Vim is currently running. Machine names greater than + 256 characters long are truncated. + +iconv({string}, {from}, {to}) *iconv()* + 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". + 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') +< + *indent()* +indent({lnum}) The result is a Number, which is indent of line {lnum} in the + current buffer. The indent is counted in spaces, the value + of 'tabstop' is relevant. {lnum} is used just like in + |getline()|. + When {lnum} is invalid -1 is returned. + + Can also be used as a |method|: > + GetLnum()->indent() + +index({object}, {expr} [, {start} [, {ic}]]) *index()* + 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 a |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) + +input({prompt} [, {text} [, {completion}]]) *input()* +input({opts}) + 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. + + In the second form it accepts a single dictionary with the + following keys, any of which may be omitted: + + Key Default Description ~ + prompt "" Same as {prompt} in the first form. + default "" Same as {text} in the first form. + completion nothing Same as {completion} in the first form. + cancelreturn "" The value returned when the dialog is + cancelled. + highlight nothing Highlight handler: |Funcref|. + + 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") + +< *input()-highlight* *E5400* *E5402* + The optional `highlight` key allows specifying function which + will be used for highlighting user input. This function + receives user input as its only argument and must return + a list of 3-tuples [hl_start_col, hl_end_col + 1, hl_group] + where + hl_start_col is the first highlighted column, + hl_end_col is the last highlighted column (+ 1!), + hl_group is |:hi| group used for highlighting. + *E5403* *E5404* *E5405* *E5406* + Both hl_start_col and hl_end_col + 1 must point to the start + of the multibyte character (highlighting must not break + multibyte characters), hl_end_col + 1 may be equal to the + input length. Start column must be in range [0, len(input)), + end column must be in range (hl_start_col, len(input)], + sections must be ordered so that next hl_start_col is greater + then or equal to previous hl_end_col. + + Example (try some input with parentheses): > + highlight RBP1 guibg=Red ctermbg=red + highlight RBP2 guibg=Yellow ctermbg=yellow + highlight RBP3 guibg=Green ctermbg=green + highlight RBP4 guibg=Blue ctermbg=blue + let g:rainbow_levels = 4 + function! RainbowParens(cmdline) + let ret = [] + let i = 0 + let lvl = 0 + while i < len(a:cmdline) + if a:cmdline[i] is# '(' + call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)]) + let lvl += 1 + elseif a:cmdline[i] is# ')' + let lvl -= 1 + call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)]) + endif + let i += 1 + endwhile + return ret + endfunction + call input({'prompt':'>','highlight':'RainbowParens'}) +< + Highlight function is called at least once for each new + displayed input string, before command-line is redrawn. It is + expected that function is pure for the duration of one input() + call, i.e. it produces the same output for the same input, so + output may be memoized. Function is run like under |:silent| + modifier. If the function causes any errors, it will be + skipped for the duration of the current input() call. + + Highlighting is disabled if command-line contains arabic + characters. + + 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()<CR>: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() + +inputlist({textlist}) *inputlist()* + {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, if the mouse is enabled in the command line ('mouse' is + "a" or includes "c"). 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() + +inputrestore() *inputrestore()* + Restore typeahead that was saved with a previous |inputsave()|. + Should be called the same number of times inputsave() is + called. Calling it more often is harmless though. + Returns TRUE when there is nothing to restore, FALSE otherwise. + +inputsave() *inputsave()* + Preserve typeahead (also from mappings) and clear it, so that + a following prompt gets input from the user. Should be + followed by a matching inputrestore() after the prompt. Can + be used several times, in which case there must be just as + many inputrestore() calls. + Returns TRUE when out of memory, FALSE otherwise. + +inputsecret({prompt} [, {text}]) *inputsecret()* + This function acts much like the |input()| function with but + two exceptions: + a) the user's response will be displayed as a sequence of + asterisks ("*") thereby keeping the entry secret, and + b) the user's response will not be recorded on the input + |history| stack. + The result is a String, which is whatever the user actually + typed on the command-line in response to the issued prompt. + NOTE: Command-line completion is not supported. + + Can also be used as a |method|: > + GetPrompt()->inputsecret() + +insert({object}, {item} [, {idx}]) *insert()* + 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() *interrupt()* + 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('<amatch>')) + +invert({expr}) *invert()* + 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() + +isdirectory({directory}) *isdirectory()* + 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() + +isinf({expr}) *isinf()* + 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() + +islocked({expr}) *islocked()* *E786* + 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. + + Can also be used as a |method|: > + GetName()->islocked() + +id({expr}) *id()* + Returns a |String| which is a unique identifier of the + container type (|List|, |Dict|, |Blob| and |Partial|). It is + guaranteed that for the mentioned types `id(v1) ==# id(v2)` + returns true iff `type(v1) == type(v2) && v1 is v2`. + Note that |v:_null_string|, |v:_null_list|, |v:_null_dict| and + |v:_null_blob| have the same `id()` with different types + because they are internally represented as NULL pointers. + `id()` returns a hexadecimal representanion of the pointers to + the containers (i.e. like `0x994a40`), same as `printf("%p", + {expr})`, but it is advised against counting on the exact + format of the return value. + + It is not guaranteed that `id(no_longer_existing_container)` + will not be equal to some other `id()`: new containers may + reuse identifiers of the garbage-collected ones. + +items({dict}) *items()* + 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() + +isnan({expr}) *isnan()* + 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() + +jobpid({job}) *jobpid()* + Return the PID (process id) of |job-id| {job}. + +jobresize({job}, {width}, {height}) *jobresize()* + Resize the pseudo terminal window of |job-id| {job} to {width} + columns and {height} rows. + Fails if the job was not started with `"pty":v:true`. + +jobstart({cmd} [, {opts}]) *jobstart()* + Spawns {cmd} as a job. + If {cmd} is a List it runs directly (no 'shell'). + If {cmd} is a String it runs in the 'shell', like this: > + :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}']) +< (See |shell-unquoting| for details.) + + Example: > + :call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}}) +< + Returns |job-id| on success, 0 on invalid arguments (or job + table is full), -1 if {cmd}[0] or 'shell' is not executable. + The returned job-id is a valid |channel-id| representing the + job's stdio streams. Use |chansend()| (or |rpcnotify()| and + |rpcrequest()| if "rpc" was enabled) to send data to stdin and + |chanclose()| to close the streams without stopping the job. + + See |job-control| and |RPC|. + + NOTE: on Windows if {cmd} is a List: + - cmd[0] must be an executable (not a "built-in"). If it is + in $PATH it can be called by name, without an extension: > + :call jobstart(['ping', 'neovim.io']) +< If it is a full or partial path, extension is required: > + :call jobstart(['System32\ping.exe', 'neovim.io']) +< - {cmd} is collapsed to a string of quoted args as expected + by CommandLineToArgvW https://msdn.microsoft.com/bb776391 + unless cmd[0] is some form of "cmd.exe". + + *jobstart-options* + {opts} is a dictionary with these keys: + clear_env: (boolean) `env` defines the job environment + exactly, instead of merging current environment. + cwd: (string, default=|current-directory|) Working + directory of the job. + detach: (boolean) Detach the job process: it will not be + killed when Nvim exits. If the process exits + before Nvim, `on_exit` will be invoked. + env: (dict) Map of environment variable name:value + pairs extending (or replacing if |clear_env|) + the current environment. + height: (number) Height of the `pty` terminal. + |on_exit|: (function) Callback invoked when the job exits. + |on_stdout|: (function) Callback invoked when the job emits + stdout data. + |on_stderr|: (function) Callback invoked when the job emits + stderr data. + overlapped: (boolean) Set FILE_FLAG_OVERLAPPED for the + standard input/output passed to the child process. + Normally you do not need to set this. + (Only available on MS-Windows, On other + platforms, this option is silently ignored.) + pty: (boolean) Connect the job to a new pseudo + terminal, and its streams to the master file + descriptor. Then `on_stderr` is ignored, + `on_stdout` receives all output. + rpc: (boolean) Use |msgpack-rpc| to communicate with + the job over stdio. Then `on_stdout` is ignored, + but `on_stderr` can still be used. + stderr_buffered: (boolean) Collect data until EOF (stream closed) + before invoking `on_stderr`. |channel-buffered| + stdout_buffered: (boolean) Collect data until EOF (stream + closed) before invoking `on_stdout`. |channel-buffered| + stdin: (string) Either "pipe" (default) to connect the + job's stdin to a channel or "null" to disconnect + stdin. + width: (number) Width of the `pty` terminal. + + {opts} is passed as |self| dictionary to the callback; the + caller may set other keys to pass application-specific data. + + Returns: + - |channel-id| on success + - 0 on invalid arguments + - -1 if {cmd}[0] is not executable. + See also |job-control|, |channel|, |msgpack-rpc|. + +jobstop({id}) *jobstop()* + Stop |job-id| {id} by sending SIGTERM to the job process. If + the process does not terminate after a timeout then SIGKILL + will be sent. When the job terminates its |on_exit| handler + (if any) will be invoked. + See |job-control|. + + Returns 1 for valid job id, 0 for invalid id, including jobs have + exited or stopped. + +jobwait({jobs} [, {timeout}]) *jobwait()* + Waits for jobs and their |on_exit| handlers to complete. + + {jobs} is a List of |job-id|s to wait for. + {timeout} is the maximum waiting time in milliseconds. If + omitted or -1, wait forever. + + Timeout of 0 can be used to check the status of a job: > + let running = jobwait([{job-id}], 0)[0] == -1 +< + During jobwait() callbacks for jobs not in the {jobs} list may + be invoked. The screen will not redraw unless |:redraw| is + invoked by a callback. + + Returns a list of len({jobs}) integers, where each integer is + the status of the corresponding job: + Exit-code, if the job exited + -1 if the timeout was exceeded + -2 if the job was interrupted (by |CTRL-C|) + -3 if the job-id is invalid + +join({list} [, {sep}]) *join()* + 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() + +json_decode({expr}) *json_decode()* + Convert {expr} from JSON object. Accepts |readfile()|-style + list as the input, as well as regular string. May output any + Vim value. In the following cases it will output + |msgpack-special-dict|: + 1. Dictionary contains duplicate key. + 2. Dictionary contains empty key. + 3. String contains NUL byte. Two special dictionaries: for + dictionary and for string will be emitted in case string + with NUL byte was a dictionary key. + + Note: function treats its input as UTF-8 always. The JSON + standard allows only a few encodings, of which UTF-8 is + recommended and the only one required to be supported. + Non-UTF-8 characters are an error. + + Can also be used as a |method|: > + ReadObject()->json_decode() + +json_encode({expr}) *json_encode()* + Convert {expr} into a JSON string. Accepts + |msgpack-special-dict| as the input. Will not convert + |Funcref|s, mappings with non-string keys (can be created as + |msgpack-special-dict|), values with self-referencing + containers, strings which contain non-UTF-8 characters, + pseudo-UTF-8 strings which contain codepoints reserved for + surrogate pairs (such strings are not valid UTF-8 strings). + Non-printable characters are converted into "\u1234" escapes + or special escapes like "\t", other are dumped as-is. + |Blob|s are converted to arrays of the individual bytes. + + Can also be used as a |method|: > + GetObject()->json_encode() + +keys({dict}) *keys()* + 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() + +< *len()* *E701* +len({expr}) The result is a Number, which is the length of the argument. + 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() + +< *libcall()* *E364* *E368* +libcall({libname}, {funcname}, {argument}) + Call function {funcname} in the run-time library {libname} + with single argument {argument}. + This is useful to call functions in a library that you + especially made to be used with Vim. Since only one argument + is possible, calling standard library functions is rather + limited. + The result is the String returned by the function. If the + function returns NULL, this will appear as an empty string "" + to Vim. + If the function returns a number, use libcallnr()! + If {argument} is a number, it is passed to the function as an + int; if {argument} is a string, it is passed as a + null-terminated string. + + libcall() allows you to write your own 'plug-in' extensions to + Vim without having to recompile the program. It is NOT a + means to call system functions! If you try to do so Vim will + very probably crash. + + For Win32, the functions you write must be placed in a DLL + and use the normal C calling convention (NOT Pascal which is + used in Windows System DLLs). The function must take exactly + one parameter, either a character pointer or a long integer, + and must return a character pointer or NULL. The character + pointer returned must point to memory that will remain valid + after the function has returned (e.g. in static data in the + DLL). If it points to allocated memory, that memory will + leak away. Using a static buffer in the function should work, + it's then freed when the DLL is unloaded. + + WARNING: If the function returns a non-valid pointer, Vim may + crash! This also happens if the function returns a number, + because Vim thinks it's a pointer. + For Win32 systems, {libname} should be the filename of the DLL + without the ".DLL" suffix. A full path is only required if + the DLL is not in the usual places. + For Unix: When compiling your own plugins, remember that the + object code must be compiled as position-independent ('PIC'). + 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") +< + *libcallnr()* +libcallnr({libname}, {funcname}, {argument}) + Just like |libcall()|, but used for a function that returns an + int instead of a string. + 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") +< +line({expr} [, {winid}]) *line()* + The result is a Number, which is the line number of the file + position given with {expr}. The {expr} argument is a string. + 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()|. + With the optional {winid} argument the values are obtained for + that window instead of the current window. + Examples: > + line(".") line number of the cursor + line(".", winid) idem, in window "winid" + 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() + +line2byte({lnum}) *line2byte()* + Return the byte count from the start of the buffer for line + {lnum}. This includes the end-of-line character, depending on + the 'fileformat' option for the current buffer. The first + line returns 1. UTF-8 encoding is used, '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. {lnum} is used like with + |getline()|. When {lnum} is invalid -1 is returned. + Also see |byte2line()|, |go| and |:goto|. + + Can also be used as a |method|: > + GetLnum()->line2byte() + +lispindent({lnum}) *lispindent()* + Get the amount of indent for line {lnum} according the lisp + indenting rules, as with 'lisp'. + The indent is counted in spaces, the value of 'tabstop' is + relevant. {lnum} is used just like in |getline()|. + When {lnum} is invalid, -1 is returned. + + Can also be used as a |method|: > + GetLnum()->lispindent() + +list2str({list} [, {utf8}]) *list2str()* + 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. + + UTF-8 encoding is always used, {utf8} option has no effect, + and exists only for backwards-compatibility. + With UTF-8 composing characters work as expected: > + list2str([97, 769]) returns "á" +< + Can also be used as a |method|: > + GetList()->list2str() + +localtime() *localtime()* + Return the current time, measured as seconds since 1st Jan + 1970. See also |strftime()|, |strptime()| and |getftime()|. + + +log({expr}) *log()* + 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() + +log10({expr}) *log10()* + 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() + +luaeval({expr} [, {expr}]) + Evaluate Lua expression {expr} and return its result converted + to Vim data structures. See |lua-eval| for more details. + + Can also be used as a |method|: > + GetExpr()->luaeval() + +map({expr1}, {expr2}) *map()* + {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. + + {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) + +maparg({name} [, {mode} [, {abbr} [, {dict}]]]) *maparg()* + 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 "<Nop>" + 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 + "" 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. + "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 <script>. + "expr" 1 for an expression mapping (|:map-<expr>|). + "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 <sid> mappings + (|<SID>|). + "lnum" The line number in "sid", zero if unknown. + "nowait" Do not wait for other, longer mappings. + (|:map-<nowait>|). + + 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 <Tab> ==' .. maparg('<Tab>', 'n') + +< Can also be used as a |method|: > + GetKey()->maparg('n') + +mapcheck({name} [, {mode} [, {abbr}]]) *mapcheck()* + 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 non-zero 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 + "<Nop>" 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') + +match({expr}, {pat} [, {start} [, {count}]]) *match()* + 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. + *strpbrk()* + Vim doesn't have a strpbrk() function. But you can do: > + :let sepidx = match(line, '[.,;: \t]') +< *strcasestr()* + 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|: > + GetText()->match('word') + GetList()->match('word') +< + *matchadd()* *E798* *E799* *E801* *E957* +matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]]) + 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| highlighed + 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') +< + *matchaddpos()* +matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]]) + 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. + *E5030* *E5031* + {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. + + Entries with zero and negative line numbers are silently + ignored, as well as entries with negative column numbers and + lengths. + + 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]) + +matcharg({nr}) *matcharg()* + 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() + +matchdelete({id} [, {win}]) *matchdelete()* *E802* *E803* + 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() + +matchend({expr}, {pat} [, {start} [, {count}]]) *matchend()* + Same as |match()|, but return the index of first character + after the match. Example: > + :echo matchend("testing", "ing") +< results in "7". + *strspn()* *strcspn()* + 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') + +matchfuzzy({list}, {str} [, {dict}]) *matchfuzzy()* + If {list} is a list of strings, then returns a |List| with all + the strings in {list} that fuzzy match {str}. The strings in + the returned list are sorted based on the matching score. + + The optional {dict} argument always supports the following + items: + matchseq When this item is present and {str} contains + multiple words separated by white space, then + returns only matches that contain the words in + the given sequence. + + If {list} is a list of dictionaries, then the optional {dict} + argument supports the following additional items: + key key of the item which is fuzzy matched against + {str}. The value of this item should be a + string. + text_cb |Funcref| that will be called for every item + in {list} to get the text for fuzzy matching. + This should accept a dictionary item as the + argument and return the text for that item to + use for fuzzy matching. + + {str} is treated as a literal string and regular expression + matching is NOT supported. The maximum supported {str} length + is 256. + + When {str} has multiple words each separated by white space, + then the list of strings that have all the words is returned. + + If there are no matching strings or there is an error, then an + empty list is returned. If length of {str} is greater than + 256, then returns an empty list. + + Refer to |fuzzy-match| for more information about fuzzy + matching strings. + + Example: > + :echo matchfuzzy(["clay", "crow"], "cay") +< results in ["clay"]. > + :echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl") +< results in a list of buffer names fuzzy matching "ndl". > + :echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'}) +< results in a list of buffer information dicts with buffer + names fuzzy matching "ndl". > + :echo getbufinfo()->matchfuzzy("spl", + \ {'text_cb' : {v -> v.name}}) +< results in a list of buffer information dicts with buffer + names fuzzy matching "spl". > + :echo v:oldfiles->matchfuzzy("test") +< results in a list of file names fuzzy matching "test". > + :let l = readfile("buffer.c")->matchfuzzy("str") +< results in a list of lines in "buffer.c" fuzzy matching "str". > + :echo ['one two', 'two one']->matchfuzzy('two one') +< results in ['two one', 'one two']. > + :echo ['one two', 'two one']->matchfuzzy('two one', + \ {'matchseq': 1}) +< results in ['two one']. + +matchfuzzypos({list}, {str} [, {dict}]) *matchfuzzypos()* + Same as |matchfuzzy()|, but returns the list of matched + strings, the list of character positions where characters + in {str} matches and a list of matching scores. You can + use |byteidx()| to convert a character position to a byte + position. + + If {str} matches multiple times in a string, then only the + positions for the best match is returned. + + If there are no matching strings or there is an error, then a + list with three empty list items is returned. + + Example: > + :echo matchfuzzypos(['testing'], 'tsg') +< results in [['testing'], [[0, 2, 6]], [99]] > + :echo matchfuzzypos(['clay', 'lacy'], 'la') +< results in [['lacy', 'clay'], [[0, 1], [1, 2]], [153, 133]] > + :echo [{'text': 'hello', 'id' : 10}] + \ ->matchfuzzypos('ll', {'key' : 'text'}) +< results in [[{'id': 10, 'text': 'hello'}], [[2, 3]], [127]] + +matchlist({expr}, {pat} [, {start} [, {count}]]) *matchlist()* + 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. + + You can pass in a List, but that is not very useful. + + Can also be used as a |method|: > + GetText()->matchlist('word') + +matchstr({expr}, {pat} [, {start} [, {count}]]) *matchstr()* + Same as |match()|, but return the matched string. Example: > + :echo matchstr("testing", "ing") +< results in "ing". + When there is no match "" is returned. + The {start}, if given, has the same meaning as for |match()|. > + :echo matchstr("testing", "ing", 2) +< results in "ing". > + :echo matchstr("testing", "ing", 5) +< result is "". + 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') + +matchstrpos({expr}, {pat} [, {start} [, {count}]]) *matchstrpos()* + 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') +< + *max()* +max({expr}) 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() + +menu_get({path} [, {modes}]) *menu_get()* + Returns a |List| of |Dictionaries| describing |menus| (defined + by |:menu|, |:amenu|, …), including |hidden-menus|. + + {path} matches a menu by name, or all menus if {path} is an + empty string. Example: > + :echo menu_get('File','') + :echo menu_get('') +< + {modes} is a string of zero or more modes (see |maparg()| or + |creating-menus| for the list of modes). "a" means "all". + + Example: > + nnoremenu &Test.Test inormal + inoremenu Test.Test insert + vnoremenu Test.Test x + echo menu_get("") + +< returns something like this: > + + [ { + "hidden": 0, + "name": "Test", + "priority": 500, + "shortcut": 84, + "submenus": [ { + "hidden": 0, + "mappings": { + i": { + "enabled": 1, + "noremap": 1, + "rhs": "insert", + "sid": 1, + "silent": 0 + }, + n": { ... }, + s": { ... }, + v": { ... } + }, + "name": "Test", + "priority": 500, + "shortcut": 0 + } ] + } ] +< + + *min()* +min({expr}) Return the minimum value of all items in {expr}. Example: > + 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() + +< *mkdir()* *E739* +mkdir({name} [, {path} [, {prot}]]) + 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. + + {prot} is applied for all parts of {name}. Thus if you create + /tmp/foo/bar then /tmp/foo will be created with 0o700. Example: > + :call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700) + +< This function is not available in the |sandbox|. + + If you try to create an existing directory with {path} set to + "p" mkdir() will silently exit. + + The function result is a Number, which is TRUE if the call was + successful or FALSE if the directory creation failed or partly + failed. + + Can also be used as a |method|: > + GetName()->mkdir() +< + *mode()* +mode([expr]) 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. + + n Normal + no Operator-pending + nov Operator-pending (forced charwise |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| + nt Normal in |terminal-emulator| (insert goes to + Terminal mode) + v Visual by character + vs Visual by character using |v_CTRL-O| in Select mode + V Visual by line + Vs Visual by line using |v_CTRL-O| in Select mode + CTRL-V Visual blockwise + CTRL-Vs Visual blockwise using |v_CTRL-O| in Select mode + 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| + Rx Replace mode |i_CTRL-X| completion + Rv Virtual Replace |gR| + Rvc Virtual Replace mode completion |compl-generic| + Rvx Virtual Replace mode |i_CTRL-X| completion + c Command-line editing + cv Vim Ex mode |gQ| + r Hit-enter prompt + rm The -- more -- prompt + r? A |:confirm| query of some sort + ! Shell or external command is executing + t Terminal 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() + +msgpackdump({list} [, {type}]) *msgpackdump()* + Convert a list of VimL objects to msgpack. Returned value is a + |readfile()|-style list. When {type} contains "B", a |Blob| is + returned instead. Example: > + call writefile(msgpackdump([{}]), 'fname.mpack', 'b') +< or, using a |Blob|: > + call writefile(msgpackdump([{}], 'B'), 'fname.mpack') +< + This will write the single 0x80 byte to a `fname.mpack` file + (dictionary with zero items is represented by 0x80 byte in + messagepack). + + Limitations: *E5004* *E5005* + 1. |Funcref|s cannot be dumped. + 2. Containers that reference themselves cannot be dumped. + 3. Dictionary keys are always dumped as STR strings. + 4. Other strings and |Blob|s are always dumped as BIN strings. + 5. Points 3. and 4. do not apply to |msgpack-special-dict|s. + +msgpackparse({data}) *msgpackparse()* + Convert a |readfile()|-style list or a |Blob| to a list of + VimL objects. + Example: > + let fname = expand('~/.config/nvim/shada/main.shada') + let mpack = readfile(fname, 'b') + let shada_objects = msgpackparse(mpack) +< This will read ~/.config/nvim/shada/main.shada file to + `shada_objects` list. + + Limitations: + 1. Mapping ordering is not preserved unless messagepack + mapping is dumped using generic mapping + (|msgpack-special-map|). + 2. Since the parser aims to preserve all data untouched + (except for 1.) some strings are parsed to + |msgpack-special-dict| format which is not convenient to + use. + *msgpack-special-dict* + Some messagepack strings may be parsed to special + dictionaries. Special dictionaries are dictionaries which + + 1. Contain exactly two keys: `_TYPE` and `_VAL`. + 2. `_TYPE` key is one of the types found in |v:msgpack_types| + variable. + 3. Value for `_VAL` has the following format (Key column + contains name of the key from |v:msgpack_types|): + + Key Value ~ + nil Zero, ignored when dumping. Not returned by + |msgpackparse()| since |v:null| was introduced. + boolean One or zero. When dumping it is only checked that + value is a |Number|. Not returned by |msgpackparse()| + since |v:true| and |v:false| were introduced. + integer |List| with four numbers: sign (-1 or 1), highest two + bits, number with bits from 62nd to 31st, lowest 31 + bits. I.e. to get actual number one will need to use + code like > + _VAL[0] * ((_VAL[1] << 62) + & (_VAL[2] << 31) + & _VAL[3]) +< Special dictionary with this type will appear in + |msgpackparse()| output under one of the following + circumstances: + 1. |Number| is 32-bit and value is either above + INT32_MAX or below INT32_MIN. + 2. |Number| is 64-bit and value is above INT64_MAX. It + cannot possibly be below INT64_MIN because msgpack + C parser does not support such values. + float |Float|. This value cannot possibly appear in + |msgpackparse()| output. + string |readfile()|-style list of strings. This value will + appear in |msgpackparse()| output if string contains + zero byte or if string is a mapping key and mapping is + being represented as special dictionary for other + reasons. + binary |String|, or |Blob| if binary string contains zero + byte. This value cannot appear in |msgpackparse()| + output since blobs were introduced. + array |List|. This value cannot appear in |msgpackparse()| + output. + *msgpack-special-map* + map |List| of |List|s with two items (key and value) each. + This value will appear in |msgpackparse()| output if + parsed mapping contains one of the following keys: + 1. Any key that is not a string (including keys which + are binary strings). + 2. String with NUL byte inside. + 3. Duplicate key. + 4. Empty key. + ext |List| with two values: first is a signed integer + representing extension type. Second is + |readfile()|-style list of strings. + +nextnonblank({lnum}) *nextnonblank()* + Return the line number of the first line at or below {lnum} + that is not blank. Example: > + if getline(nextnonblank(1)) =~ "Java" +< When {lnum} is invalid or there is no non-blank line at or + below it, zero is returned. + {lnum} is used like with |getline()|. + See also |prevnonblank()|. + + Can also be used as a |method|: > + GetLnum()->nextnonblank() + +nr2char({expr} [, {utf8}]) *nr2char()* + Return a string with a single character, which has the number + value {expr}. Examples: > + nr2char(64) returns "@" + nr2char(32) returns " " +< Example for "utf-8": > + nr2char(300) returns I with bow character +< UTF-8 encoding is always used, {utf8} option has no effect, + and exists only for backwards-compatibility. + 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. + + Can also be used as a |method|: > + GetNumber()->nr2char() + +nvim_...({...}) *E5555* *nvim_...()* *eval-api* + Call nvim |api| functions. The type checking of arguments will + be stricter than for most other builtins. For instance, + if Integer is expected, a |Number| must be passed in, a + |String| will not be autoconverted. + Buffer numbers, as returned by |bufnr()| could be used as + first argument to nvim_buf_... functions. All functions + expecting an object (buffer, window or tabpage) can + also take the numerical value 0 to indicate the current + (focused) object. + +or({expr}, {expr}) *or()* + 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) + +pathshorten({expr} [, {len}]) *pathshorten()* + 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('~/.config/nvim/autoload/file1.vim') +< ~/.c/n/a/file1.vim ~ +> + :echo pathshorten('~/.config/nvim/autoload/file2.vim', 2) +< ~/.co/nv/au/file2.vim ~ + It doesn't matter if the path exists or not. + + Can also be used as a |method|: > + GetDirectories()->pathshorten() + +perleval({expr}) *perleval()* + Evaluate |perl| 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: If you want an array or hash, {expr} must return a + reference to it. + Example: > + :echo perleval('[1 .. 4]') +< [1, 2, 3, 4] + + Can also be used as a |method|: > + GetExpr()->perleval() + +pow({x}, {y}) *pow()* + 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) + +prevnonblank({lnum}) *prevnonblank()* + Return the line number of the first line at or above {lnum} + that is not blank. Example: > + let ind = indent(prevnonblank(v:lnum - 1)) +< When {lnum} is invalid or there is no non-blank line at or + above it, zero is returned. + {lnum} is used like with |getline()|. + Also see |nextnonblank()|. + + Can also be used as a |method|: > + GetLnum()->prevnonblank() + +printf({fmt}, {expr1} ...) *printf()* + 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 + %b binary number + %08b binary number padded with zeros to at least 8 characters + %B binary number using upper case letters + %x hex number + %04x hex number padded with zeros to at least 4 characters + %X hex number using upper case letters + %o octal number + %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 + %p representation of the pointer to the container + + 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 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, 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. For the S + conversion the count is in cells. + + .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, the maximum number of + bytes to be printed from a string for s conversions, + or the maximum number of cells 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: + + *printf-d* *printf-b* *printf-B* *printf-o* *printf-x* *printf-X* + 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 + + *printf-c* + c The Number argument is converted to a byte, and the + resulting character is written. + + *printf-s* + 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". + *printf-S* + S The text of the String argument is used. If a + precision is specified, no more display cells than the + number specified are used. + + *printf-f* *E807* + 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. + + *printf-e* *printf-E* + 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'. + + *printf-g* *printf-G* + 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. + + *printf-%* + % 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. + + *E766* *E767* + 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. + +prompt_getprompt({buf}) *prompt_getprompt()* + 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() + +prompt_setcallback({buf}, {expr}) *prompt_setcallback()* + 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) + +prompt_setinterrupt({buf}, {expr}) *prompt_setinterrupt()* + 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) + +prompt_setprompt({buf}, {text}) *prompt_setprompt()* + 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: ') + +pum_getpos() *pum_getpos()* + 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|. + +pumvisible() *pumvisible()* + 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. + +py3eval({expr}) *py3eval()* + 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 + UTF-8). + Lists are represented as Vim |List| type. + Dictionaries are represented as Vim |Dictionary| type with + keys converted to strings. + + Can also be used as a |method|: > + GetExpr()->py3eval() +< + *E858* *E859* +pyeval({expr}) *pyeval()* + Evaluate Python expression {expr} and return its result + converted to Vim data structures. + Numbers and strings are returned as they are (strings are + copied though). + Lists are represented as Vim |List| type. + Dictionaries are represented as Vim |Dictionary| type, + non-string keys result in error. + + Can also be used as a |method|: > + GetExpr()->pyeval() + +pyxeval({expr}) *pyxeval()* + 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() +< + *E726* *E727* +range({expr} [, {max} [, {stride}]]) *range()* + 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() +< +rand([{expr}]) *rand()* + Return a pseudo-random Number generated with an xoshiro128** + algorithm using seed {expr}. The returned number is 32 bits, + also on 64 bits systems, for consistency. + {expr} can be initialized by |srand()| and will be updated by + rand(). If {expr} is omitted, an internal seed value is used + and updated. + + Examples: > + :echo rand() + :let seed = srand() + :echo rand(seed) + :echo rand(seed) % 16 " random number 0 - 15 +< + Can also be used as a |method|: > + seed->rand() +< + *readdir()* +readdir({directory} [, {expr}]) + Return a list with file and directory names in {directory}. + + 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. + 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 !~ '^\.\|\~$'}) + +< 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() +< + *readfile()* +readfile({fname} [, {type} [, {max}]]) + 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. + When {type} contains "B" a |Blob| is returned with the binary + data of the file unmodified. + Otherwise: + - CR characters that appear before a NL are removed. + - Whether the last line ends in a NL or not does not matter. + - 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. + 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() + +reduce({object}, {func} [, {initial}]) *reduce()* *E998* + {func} is called for every item in {object}, which can be a + |List| or a |Blob|. {func} is called with two arguments: the + result so far and current item. After processing all items + the result is returned. + + {initial} is the initial result. When omitted, the first item + in {object} is used and {func} is first called for the second + item. If {initial} is not given and {object} is empty no + result can be computed, an E998 error is given. + + Examples: > + echo reduce([1, 3, 5], { acc, val -> acc + val }) + echo reduce(['x', 'y'], { acc, val -> acc .. val }, 'a') + echo reduce(0z1122, { acc, val -> 2 * acc + val }) +< + Can also be used as a |method|: > + echo mylist->reduce({ acc, val -> acc + val }, 0) + +reg_executing() *reg_executing()* + Returns the single letter name of the register being executed. + Returns an empty string when no register is being executed. + See |@|. + +reg_recorded() *reg_recorded()* + Returns the single letter name of the last recorded register. + Returns an empty string when nothing was recorded yet. + See |q| and |Q|. + +reg_recording() *reg_recording()* + Returns the single letter name of the register being recorded. + Returns an empty string when not recording. See |q|. + +reltime([{start} [, {end}]]) *reltime()* + Return an item that represents a time value. The item is a + list with items that depend on the system. + The item can be passed to |reltimestr()| to convert it to a + string or |reltimefloat()| to convert to a Float. + + Without an argument it returns the current "relative time", an + implementation-defined value meaningful only when used as an + argument to |reltime()|, |reltimestr()| and |reltimefloat()|. + + With one argument it returns the time passed since the time + specified in the argument. + With two arguments it returns the time passed between {start} + and {end}. + + The {start} and {end} arguments must be values returned by + reltime(). + + Can also be used as a |method|: > + GetStart()->reltime() +< + Note: |localtime()| returns the current (non-relative) time. + +reltimefloat({time}) *reltimefloat()* + Return a Float that represents the time value of {time}. + Unit of time is seconds. + 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 an empty string is returned + + Can also be used as a |method|: > + reltime(start)->reltimefloat() + +reltimestr({time}) *reltimestr()* + 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. + 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 + + Can also be used as a |method|: > + reltime(start)->reltimestr() +< + *remote_expr()* *E449* +remote_expr({server}, {string} [, {idvar} [, {timeout}]]) + Send the {string} to {server}. The {server} argument is a + string, also see |{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|. + 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") +< + +remote_foreground({server}) *remote_foreground()* + Move the Vim server with the name {server} to the foreground. + The {server} argument is a string, also see |{server}|. + 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|. + {only in the Win32 GUI and the Win32 console version} + + +remote_peek({serverid} [, {retvar}]) *remote_peek()* + Returns a positive number if there are available strings + from {serverid}. Copies any reply string into the variable + {retvar} if specified. {retvar} must be a string with the + name of a variable. + Returns zero if none are available. + Returns -1 if something is wrong. + See also |clientserver|. + This function is not available in the |sandbox|. + Examples: > + :let repl = "" + :echo "PEEK: " .. remote_peek(id, "repl") .. ": " .. repl + +remote_read({serverid}, [{timeout}]) *remote_read()* + 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|. + Example: > + :echo remote_read(id) +< + *remote_send()* *E241* +remote_send({server}, {string} [, {idvar}]) + Send the {string} to {server}. The {server} argument is a + string, also see |{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|. + + Note: Any errors will be reported in the server and may mess + up the display. + Examples: > + :echo remote_send("gvim", ":DropAndReply " .. file, "serverid") .. + \ remote_read(serverid) + + :autocmd NONE RemoteReply * + \ echo remote_read(expand("<amatch>")) + :echo remote_send("gvim", ":sleep 10 | echo " .. + \ 'server2client(expand("<client>"), "HELLO")<CR>') +< + *remote_startserver()* *E941* *E942* +remote_startserver({name}) + Become the server {name}. This fails if already running as a + server, when |v:servername| is not empty. + +remove({list}, {idx} [, {end}]) *remove()* + 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) + +remove({blob}, {idx} [, {end}]) + Without {end}: Remove the byte at {idx} from |Blob| {blob} and + return the byte. + With {end}: Remove bytes from {idx} to {end} (inclusive) and + return a |Blob| with these bytes. When {idx} points to the same + byte as {end} a |Blob| with one byte is returned. When {end} + points to a byte before {idx} this is an error. + Example: > + :echo "last byte: " .. remove(myblob, -1) + :call remove(mylist, 0, 9) + +remove({dict}, {key}) + Remove the entry from {dict} with key {key} and return it. + Example: > + :echo "removed " .. remove(dict, "one") +< If there is no {key} in {dict} this is an error. + +rename({from}, {to}) *rename()* + Rename the file by the name {from} to the name {to}. This + should also work to move files across file systems. The + result is a Number, which is 0 if the file was renamed + successfully, and non-zero when the renaming failed. + 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}) *repeat()* + 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) + +resolve({filename}) *resolve()* *E655* + On MS-Windows, when {filename} is a shortcut (a .lnk file), + returns the path the shortcut points to in a simplified form. + 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()* +reverse({object}) + 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({expr}) *round()* + 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() + +rpcnotify({channel}, {event} [, {args}...]) *rpcnotify()* + Sends {event} to {channel} via |RPC| and returns immediately. + If {channel} is 0, the event is broadcast to all channels. + Example: > + :au VimLeave call rpcnotify(0, "leaving") + +rpcrequest({channel}, {method} [, {args}...]) *rpcrequest()* + Sends a request to {channel} to invoke {method} via + |RPC| and blocks until a response is received. + Example: > + :let result = rpcrequest(rpc_chan, "func", 1, 2, 3) + +rpcstart({prog} [, {argv}]) *rpcstart()* + Deprecated. Replace > + :let id = rpcstart('prog', ['arg1', 'arg2']) +< with > + :let id = jobstart(['prog', 'arg1', 'arg2'], {'rpc': v:true}) + +rubyeval({expr}) *rubyeval()* + Evaluate Ruby expression {expr} and return its result + converted to Vim data structures. + Numbers, floats and strings are returned as they are (strings + are copied though). + Arrays are represented as Vim |List| type. + Hashes are represented as Vim |Dictionary| type. + Other objects are represented as strings resulted from their + "Object#to_s" method. + + Can also be used as a |method|: > + GetRubyExpr()->rubyeval() + +screenattr({row}, {col}) *screenattr()* + 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) + +screenchar({row}, {col}) *screenchar()* + 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) + +screenchars({row}, {col}) *screenchars()* + 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) + +screencol() *screencol()* + 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 <expr> GG ":echom " .. screencol() .. "\n" + nnoremap <silent> GG :echom screencol()<CR> + noremap GG <Cmd>echom screencol()<Cr> +< +screenpos({winid}, {lnum}, {col}) *screenpos()* + 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". + The |conceal| feature is ignored here, the column numbers are + as if 'conceallevel' is zero. You can set the cursor to the + right position and use |screencol()| to get the value with + |conceal| taken into account. + + Can also be used as a |method|: > + GetWinid()->screenpos(lnum, col) + +screenrow() *screenrow()* + 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()|. + +screenstring({row}, {col}) *screenstring()* + 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()* +search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) + 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. + + 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. + *search()-sub-match* + 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() + +searchcount([{options}]) *searchcount()* + 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 + result by |n|, |N|, or this + function is returned. + (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: 0) + pos |List| `[lnum, col, off]` value + when recomputing the result. + this changes "current" result + value. see |cursor()|, |getpos() + (default: cursor's position) + + Can also be used as a |method|: > + GetSearchOpts()->searchcount() +< +searchdecl({name} [, {global} [, {thisblock}]]) *searchdecl()* + 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() +< + *searchpair()* +searchpair({start}, {middle}, {end} [, {flags} [, {skip} + [, {stopline} [, {timeout}]]]]) + 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. + + 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 through 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"') +< + *searchpairpos()* +searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} + [, {stopline} [, {timeout}]]]]) + 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. + + *searchpos()* +searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) + 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() + +server2client({clientid}, {string}) *server2client()* + Send a reply string to {clientid}. The most recent {clientid} + that sent a string can be retrieved with expand("<client>"). + Note: + Returns zero for success, -1 for failure. + 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("<client>"), "HELLO") + +< Can also be used as a |method|: > + GetClientId()->server2client(string) +< +serverlist() *serverlist()* + Returns a list of server addresses, or empty if all servers + were stopped. |serverstart()| |serverstop()| + Example: > + :echo serverlist() + +serverstart([{address}]) *serverstart()* + Opens a socket or named pipe at {address} and listens for + |RPC| messages. Clients can send |API| commands to the address + to control Nvim. Returns the address string. + + If {address} does not contain a colon ":" it is interpreted as + a named pipe or Unix domain socket path. + + Example: > + if has('win32') + call serverstart('\\.\pipe\nvim-pipe-1234') + else + call serverstart('nvim.sock') + endif +< + If {address} contains a colon ":" it is interpreted as a TCP + address where the last ":" separates the host and port. + Assigns a random port if it is empty or 0. Supports IPv4/IPv6. + + Example: > + :call serverstart('::1:12345') +< + If no address is given, it is equivalent to: > + :call serverstart(tempname()) + +< |$NVIM_LISTEN_ADDRESS| is set to {address} if not already set. + +serverstop({address}) *serverstop()* + Closes the pipe or socket at {address}. + Returns TRUE if {address} is valid, else FALSE. + If |$NVIM_LISTEN_ADDRESS| is stopped it is unset. + If |v:servername| is stopped it is set to the next available + address returned by |serverlist()|. + +setbufline({buf}, {lnum}, {text}) *setbufline()* + Set line {lnum} to {text} in buffer {buf}. This works like + |setline()| for the specified buffer. + + This function works only for loaded buffers. First call + |bufload()| if needed. + + To insert lines use |appendbufline()|. + Any text properties in {lnum} are cleared. + + {text} can be a string to set one line, or a list of strings + to set multiple lines. If the list extends below the last + line then those lines are added. + + For the use of {buf}, see |bufname()| above. + + {lnum} is used like with |setline()|. + Use "$" to refer to the last line in buffer {buf}. + When {lnum} is just below the last line the {text} will be + added below the last line. + 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. + + Can also be used as a |method|, the base is passed as the + third argument: > + GetText()->setbufline(buf, lnum) + +setbufvar({buf}, {varname}, {val}) *setbufvar()* + 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) + +setcharpos({expr}, {list}) *setcharpos()* + Same as |setpos()| but uses the specified column number as the + character index instead of the byte index in the line. + + Example: + With the text "여보세요" in line 8: > + call setcharpos('.', [0, 8, 4, 0]) +< positions the cursor on the fourth character '요'. > + call setpos('.', [0, 8, 4, 0]) +< positions the cursor on the second character '보'. + + Can also be used as a |method|: > + GetPosition()->setcharpos('.') + +setcharsearch({dict}) *setcharsearch()* + 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() + +setcmdpos({pos}) *setcmdpos()* + 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() + +setcursorcharpos({lnum}, {col} [, {off}]) *setcursorcharpos()* +setcursorcharpos({list}) + Same as |cursor()| but uses the specified column number as the + character index instead of the byte index in the line. + + Example: + With the text "여보세요" in line 4: > + call setcursorcharpos(4, 3) +< positions the cursor on the third character '세'. > + call cursor(4, 3) +< positions the cursor on the first character '여'. + + Can also be used as a |method|: > + GetCursorPos()->setcursorcharpos() + +setenv({name}, {val}) *setenv()* + 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') + +setfperm({fname}, {mode}) *setfperm()* *chmod* + 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()|. + +setline({lnum}, {text}) *setline()* + Set line {lnum} of the current buffer to {text}. To insert + lines use |append()|. To set lines in another buffer use + |setbufline()|. + + {lnum} is used like with |getline()|. + When {lnum} is just below the last line the {text} will be + added below the last line. + + If this succeeds, FALSE is returned. If this fails (most likely + because {lnum} is invalid) TRUE is returned. + + Example: > + :call setline(5, strftime("%c")) + +< When {text} is a |List| then line {lnum} and following lines + will be set to the items in the list. Example: > + :call setline(5, ['aaa', 'bbb', 'ccc']) +< This is equivalent to: > + :for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']] + : call setline(n, l) + :endfor + +< Note: The '[ and '] marks are not set. + + Can also be used as a |method|, the base is passed as the + second argument: > + GetText()->setline(lnum) + +setloclist({nr}, {list} [, {action} [, {what}]]) *setloclist()* + 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) + +setmatches({list} [, {win}]) *setmatches()* + 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() +< + *setpos()* +setpos({expr}, {list}) + Set the position for String {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. To use the character count + instead of the byte count, use |setcharpos()|. + + 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 <Tab> 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 |setcharpos()|, |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('.') + +setqflist({list} [, {action} [, {what}]]) *setqflist()* + 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}. + *setqflist-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: *setqflist-action* *E927* + '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() +< + *setreg()* +setreg({regname}, {value} [, {options}]) + Set the register {regname} to {value}. + The {regname} argument is a string. + + {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" |charwise| mode + "l" or "V" |linewise| mode + "b" or "<CTRL-V>" |blockwise-visual| mode + If a number immediately follows "b" or "<CTRL-V>" 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 <Tab> as 1 character). + If {options} contains "u" or '"', then the unnamed register is + set to point to register {regname}. + + If {options} contains no register settings, then the default + is to use character mode unless {value} ends in a <NL> for + string {value} and linewise mode for list {value}. Blockwise + mode is never selected automatically. + Returns zero for success, non-zero for failure. + + *E883* + 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') + +settabvar({tabnr}, {varname}, {val}) *settabvar()* + Set tab-local variable {varname} to {val} in tab page {tabnr}. + |t:var| + The {varname} argument is a string. + 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) + +settabwinvar({tabnr}, {winnr}, {varname}, {val}) *settabwinvar()* + 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. + 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()->settabwinvar(tab, winnr, name) + +settagstack({nr}, {dict} [, {action}]) *settagstack()* + 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. + *E962* + 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) + +setwinvar({nr}, {varname}, {val}) *setwinvar()* + 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) + +sha256({string}) *sha256()* + Returns a String with 64 hex characters, which is the SHA256 + checksum of {string}. + + Can also be used as a |method|: > + GetText()->sha256() + +shellescape({string} [, {special}]) *shellescape()* + Escape {string} for use as a shell command argument. + + On Windows when 'shellslash' is not set, encloses {string} in + double-quotes and doubles all double-quotes within {string}. + Otherwise encloses {string} in single-quotes and replaces all + "'" with "'\''". + + If {special} is a |non-zero-arg|: + - Special items such as "!", "%", "#" and "<cword>" will be + preceded by a backslash. The backslash will be removed again + by the |:!| command. + - The <NL> character is escaped. + + If 'shell' contains "csh" in the tail: + - The "!" character will be escaped. This is because csh and + tcsh use "!" for history replacement even in single-quotes. + - The <NL> character is escaped (twice if {special} is + a |non-zero-arg|). + + If 'shell' contains "fish" in the tail, the "\" character will + be escaped because in fish it is used as an escape character + inside single quotes. + + Example of use with a |:!| command: > + :exe '!dir ' .. shellescape(expand('<cfile>'), 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() + +shiftwidth([{col}]) *shiftwidth()* + Returns the effective value of 'shiftwidth'. This is the + 'shiftwidth' value unless it is zero, in which case it is the + 'tabstop' value. To be backwards compatible in indent + plugins, use this: > + if exists('*shiftwidth') + func s:sw() + return shiftwidth() + endfunc + else + func s:sw() + return &sw + endfunc + endif +< And then use s:sw() instead of &sw. + + 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 no {col} argument is given, column 1 + will be assumed. + + Can also be used as a |method|: > + GetColumn()->shiftwidth() + +sign_ functions are documented here: |sign-functions-details| + +simplify({filename}) *simplify()* + 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() + +sin({expr}) *sin()* + 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() + +sinh({expr}) *sinh()* + 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() + +sockconnect({mode}, {address} [, {opts}]) *sockconnect()* + Connect a socket to an address. If {mode} is "pipe" then + {address} should be the path of a named pipe. If {mode} is + "tcp" then {address} should be of the form "host:port" where + the host should be an ip adderess or host name, and port the + port number. + + Returns a |channel| ID. Close the socket with |chanclose()|. + Use |chansend()| to send data over a bytes socket, and + |rpcrequest()| and |rpcnotify()| to communicate with a RPC + socket. + + {opts} is an optional dictionary with these keys: + |on_data| : callback invoked when data was read from socket + data_buffered : read socket data in |channel-buffered| mode. + rpc : If set, |msgpack-rpc| will be used to communicate + over the socket. + Returns: + - The channel ID on success (greater than zero) + - 0 on invalid arguments or connection failure. + +sort({list} [, {func} [, {dict}]]) *sort()* *E702* + 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}) +< + *soundfold()* +soundfold({word}) + 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() +< + *spellbadword()* +spellbadword([{sentence}]) + 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() +< + *spellsuggest()* +spellsuggest({word} [, {max} [, {capital}]]) + 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() + +split({string} [, {pattern} [, {keepempty}]]) *split()* + 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() + +sqrt({expr}) *sqrt()* + 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() + +srand([{expr}]) *srand()* + Initialize seed used by |rand()|: + - If {expr} is not given, seed values are initialized by + reading from /dev/urandom, if possible, or using time(NULL) + a.k.a. epoch time otherwise; this only has second accuracy. + - If {expr} is given it must be a Number. It is used to + initialize the seed values. This is useful for testing or + when a predictable sequence is intended. + + Examples: > + :let seed = srand() + :let seed = srand(userinput) + :echo rand(seed) +< + Can also be used as a |method|: > + userinput->srand() + +stdioopen({opts}) *stdioopen()* + With |--headless| this opens stdin and stdout as a |channel|. + May be called only once. See |channel-stdio|. stderr is not + handled by this function, see |v:stderr|. + + Close the stdio handles with |chanclose()|. Use |chansend()| + to send data to stdout, and |rpcrequest()| and |rpcnotify()| + to communicate over RPC. + + {opts} is a dictionary with these keys: + |on_stdin| : callback invoked when stdin is written to. + on_print : callback invoked when Nvim needs to print a + message, with the message (whose type is string) + as sole argument. + stdin_buffered : read stdin in |channel-buffered| mode. + rpc : If set, |msgpack-rpc| will be used to communicate + over stdio + Returns: + - |channel-id| on success (value is always 1) + - 0 on invalid arguments + + +stdpath({what}) *stdpath()* *E6100* + Returns |standard-path| locations of various default files and + directories. + + {what} Type Description ~ + cache String Cache directory. Arbitrary temporary + storage for plugins, etc. + config String User configuration directory. The + |init.vim| is stored here. + config_dirs List Additional configuration directories. + data String User data directory. The |shada-file| + is stored here. + data_dirs List Additional data directories. + + Example: > + :echo stdpath("config") + + +str2float({string} [, {quoted}]) *str2float()* + 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() + +str2list({string} [, {utf8}]) *str2list()* + 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. + + UTF-8 encoding is always used, {utf8} option has no effect, + and exists only for backwards-compatibility. + With UTF-8 composing characters are handled properly: > + str2list("á") returns [97, 769] + +< Can also be used as a |method|: > + GetString()->str2list() + +str2nr({string} [, {base}]) *str2nr()* + 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() + +strcharpart({src}, {start} [, {len}]) *strcharpart()* + Like |strpart()| but using character index and length instead + of byte index and length. Composing characters are counted + separately. + When a character index is used where a character does not + exist it is assumed to be one character. For example: > + strcharpart('abc', -1, 2) +< results in 'a'. + + Can also be used as a |method|: > + GetText()->strcharpart(5) + +strchars({string} [, {skipcc}]) *strchars()* + 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. + 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() + +strdisplaywidth({string} [, {col}]) *strdisplaywidth()* + 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() + +strftime({format} [, {time}]) *strftime()* + The result is a String, which is a formatted date and time, as + specified by the {format} string. The given {time} is used, + or the current time if no time is given. The accepted + {format} depends on your system, thus this is not portable! + See the manual page of the C function strftime() for the + format. The maximum length of the result is 80 characters. + See also |localtime()|, |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. + +< Can also be used as a |method|: > + GetFormat()->strftime() + +strgetchar({str}, {index}) *strgetchar()* + 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) + +stridx({haystack}, {needle} [, {start}]) *stridx()* + 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 +< *strstr()* *strchr()* + 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) + + *string()* +string({expr}) 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' + Number 123 + Float 123.123456 or 1.123456e8 or + `str2float('inf')` + Funcref `function('name')` + Blob 0z00112233.44556677.8899 + List [item, item] + Dictionary {key: value, key: value} + Note that in String values the ' character is doubled. + Also see |strtrans()|. + Note 2: Output format is mostly compatible with YAML, except + for infinite and NaN floating-point values representations + which use |str2float()|. Strings are also dumped literally, + only single quote is escaped, which does not allow using YAML + for parsing back binary strings. |eval()| should always work for + strings and floats though and this is the only official + method, use |msgpackdump()| or |json_encode()| if you need to + share data with other application. + + Can also be used as a |method|: > + mylist->string() + +strlen({string}) *strlen()* + 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() + +strpart({src}, {start} [, {len} [, {chars}]]) *strpart()* + 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) + +strptime({format}, {timestring}) *strptime()* + 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 + + Can also be used as a |method|: > + GetFormat()->strptime(timestring) +< +strridx({haystack}, {needle} [, {start}]) *strridx()* + 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 +< *strrchr()* + When used with a single character it works similar to the C + function strrchr(). + + Can also be used as a |method|: > + GetHaystack()->strridx(needle) + +strtrans({string}) *strtrans()* + 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() + +strwidth({string}) *strwidth()* + 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() + +submatch({nr} [, {list}]) *submatch()* *E935* + 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() + +substitute({string}, {pat}, {sub}, {flags}) *substitute()* + 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) + +swapinfo({fname}) *swapinfo()* + 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 + 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() + +swapname({buf}) *swapname()* + The result is the swap file path of the buffer {buf}. + 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() + +synID({lnum}, {col}, {trans}) *synID()* + 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") +< + +synIDattr({synID}, {what} [, {mode}]) *synIDattr()* + The result is a String, which is the {what} attribute of + syntax ID {synID}. This can be used to obtain information + about a syntax item. + {mode} can be "gui", "cterm" or "term", to get the attributes + for that mode. When {mode} is omitted, or an invalid value is + used, the attributes for the currently active highlighting are + used (GUI, cterm or term). + Use synIDtrans() to follow linked highlight groups. + {what} result + "name" the name of the syntax item + "fg" foreground color (GUI: color name 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 (as with "fg") |highlight-guisp| + "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 + "strikethrough" "1" if struckthrough + + 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") + +synIDtrans({synID}) *synIDtrans()* + The result is a Number, which is the translated syntax ID of + {synID}. This is the syntax group ID of what is being used to + highlight the character. Highlight links given with + ":highlight link" are followed. + + Can also be used as a |method|: > + :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg") + +synconcealed({lnum}, {col}) *synconcealed()* + 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] + + +synstack({lnum}, {col}) *synstack()* + 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. + +system({cmd} [, {input}]) *system()* *E677* + Gets the output of {cmd} as a |string| (|systemlist()| returns + a |List|) and sets |v:shell_error| to the error code. + {cmd} is treated as in |jobstart()|: + If {cmd} is a List it runs directly (no 'shell'). + If {cmd} is a String it runs in the 'shell', like this: > + :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}']) + +< Not to be used for interactive commands. + + Result is a String, filtered to avoid platform-specific quirks: + - <CR><NL> is replaced with <NL> + - NUL characters are replaced with SOH (0x01) + + Example: > + :echo system(['ls', expand('%:h')]) + +< If {input} is a string it is written to a pipe and passed as + stdin to the command. The string is written as-is, line + separators are not changed. + If {input} is a |List| it is written to the pipe as + |writefile()| does with {binary} set to "b" (i.e. with + a newline between each list item, and newlines inside list + items converted to NULs). + When {input} is given and is a valid buffer id, the content of + the buffer is written to the file line by line, each line + terminated by NL (and NUL where the text has NL). + *E5677* + Note: system() cannot write to or read from backgrounded ("&") + shell commands, e.g.: > + :echo system("cat - &", "foo") +< which is equivalent to: > + $ echo foo | bash -c 'cat - &' +< The pipes are disconnected (unless overridden by shell + redirection syntax) before input can reach it. Use + |jobstart()| instead. + + Note: Use |shellescape()| or |::S| with |expand()| or + |fnamemodify()| to escape special characters in a command + argument. 'shellquote' and 'shellxquote' must be properly + configured. Example: > + :echo system('ls '..shellescape(expand('%:h'))) + :echo system('ls '..expand('%:h:S')) + +< 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() + +systemlist({cmd} [, {input} [, {keepempty}]]) *systemlist()* + 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 a final newline is not preserved, + unless {keepempty} is non-zero. + 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 split(system('echo hello'), '\n', 1) +< + Returns an empty string on error. + + Can also be used as a |method|: > + :echo GetCmd()->systemlist() + +tabpagebuflist([{arg}]) *tabpagebuflist()* + 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() + +tabpagenr([{arg}]) *tabpagenr()* + 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<Tab>| goes to). If there is no previous + tab page, 0 is returned. + The number can be used with the |:tab| command. + + +tabpagewinnr({tabarg} [, {arg}]) *tabpagewinnr()* + 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() +< + *tagfiles()* +tagfiles() Returns a |List| with the file names used to search for tags + for the current buffer. This is the 'tags' option expanded. + + +taglist({expr} [, {filename}]) *taglist()* + 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() + +tempname() *tempname()* *temp-file-name* + The result is a String, which is the name of a file that + doesn't exist. It can be used for a temporary file. 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 '-'. + +termopen({cmd} [, {opts}]) *termopen()* + Spawns {cmd} in a new pseudo-terminal session connected + to the current buffer. {cmd} is the same as the one passed to + |jobstart()|. This function fails if the current buffer is + modified (all buffer contents are destroyed). + + The {opts} dict is similar to the one passed to |jobstart()|, + but the `pty`, `width`, `height`, and `TERM` fields are + ignored: `height`/`width` are taken from the current window + and `$TERM` is set to "xterm-256color". + Returns the same values as |jobstart()|. + + See |terminal| for more information. + +test_ functions are documented here: |test-functions-details| + +tan({expr}) *tan()* + 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() + +tanh({expr}) *tanh()* + 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() +< + *timer_info()* +timer_info([{id}]) + 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 + "repeat" number of times the timer will still fire; + -1 means forever + "callback" the callback + + Can also be used as a |method|: > + GetTimer()->timer_info() +< +timer_pause({timer}, {paused}) *timer_pause()* + 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) +< + *timer_start()* *timer* *timers* +timer_start({time}, {callback} [, {options}]) + 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. + + {options} is a dictionary. Supported entries: + "repeat" Number of times to repeat the callback. + -1 means forever. Default is 1. + If the timer causes an error three times in a + row the repeat is cancelled. + + Example: > + func MyHandler(timer) + echo 'Handler called' + endfunc + let timer = timer_start(500, 'MyHandler', + \ {'repeat': 3}) +< This invokes MyHandler() three times at 500 msec intervals. + + Can also be used as a |method|: > + GetMsec()->timer_start(callback) + +< Not available in the |sandbox|. + +timer_stop({timer}) *timer_stop()* + 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() +< +timer_stopall() *timer_stopall()* + Stop all timers. The timer callbacks will no longer be + invoked. Useful if some timers is misbehaving. If there are + no timers there is no error. + +tolower({expr}) *tolower()* + The result is a copy of the String given, with all uppercase + characters turned into lowercase (just like applying |gu| to + the string). + + Can also be used as a |method|: > + GetText()->tolower() + +toupper({expr}) *toupper()* + The result is a copy of the String given, with all lowercase + characters turned into uppercase (just like applying |gU| to + the string). + + Can also be used as a |method|: > + GetText()->toupper() + +tr({src}, {fromstr}, {tostr}) *tr()* + 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("<blob>", "<>", "{}") +< returns "{blob}" + + Can also be used as a |method|: > + GetText()->tr(from, to) + +trim({text} [, {mask} [, {dir}]]) *trim()* + 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() + +trunc({expr}) *trunc()* + 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() + +type({expr}) *type()* + 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:true| and |v:false|) + Null: 7 (|v:null|) + 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:true) +< In place of checking for |v:null| type it is better to check + for |v:null| directly as it is the only value of this type: > + :if myvar is v:null +< To check if the v:t_ variables exist use this: > + :if exists('v:t_number') + +< Can also be used as a |method|: > + mylist->type() + +undofile({name}) *undofile()* + 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|. + + Can also be used as a |method|: > + GetFilename()->undofile() + +undotree() *undotree()* + 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. + +uniq({list} [, {func} [, {dict}]]) *uniq()* *E882* + 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() + +values({dict}) *values()* + 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() + +virtcol({expr}) *virtcol()* + The result is a Number, which is the screen column of the file + position given with {expr}. That is, the last screen position + occupied by the character at that position, when the screen + would be of unlimited width. When there is a <Tab> at the + position, the returned Number will be the column at the end of + the <Tab>. For example, for a <Tab> in column 1, with 'ts' + set to 8, it returns 8. |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 <Tab> 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() + +visualmode([{expr}]) *visualmode()* + 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 "<CTRL-V>" (a single CTRL-V character) for + character-wise, line-wise, or block-wise Visual mode + respectively. + Example: > + :exe "normal " .. visualmode() +< This enters the same Visual mode as before. It is also useful + in scripts if you wish to act differently depending on the + Visual mode that was used. + 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|. + +wait({timeout}, {condition} [, {interval}]) *wait()* + Waits until {condition} evaluates to |TRUE|, where {condition} + is a |Funcref| or |string| containing an expression. + + {timeout} is the maximum waiting time in milliseconds, -1 + means forever. + + Condition is evaluated on user events, internal events, and + every {interval} milliseconds (default: 200). + + Returns a status integer: + 0 if the condition was satisfied before timeout + -1 if the timeout was exceeded + -2 if the function was interrupted (by |CTRL-C|) + -3 if an error occurred + +wildmenumode() *wildmenumode()* + 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 <c-j> work like <down> in wildmode, use: > + :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>" +< + (Note, this needs the 'wildcharm' option set appropriately). + +win_execute({id}, {command} [, {silent}]) *win_execute()* + Like `execute()` but in the context of window {id}. + The window will temporarily be made the current window, + without triggering autocommands or changing directory. When + executing {command} autocommands will be triggered, this may + have unexpected side effects. Use |:noautocmd| if needed. + Example: > + call win_execute(winid, 'syntax enable') +< + Can also be used as a |method|, the base is passed as the + second argument: > + GetCommand()->win_execute(winid) + +win_findbuf({bufnr}) *win_findbuf()* + 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() + +win_getid([{win} [, {tab}]]) *win_getid()* + 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() + +win_gettype([{nr}]) *win_gettype()* + 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". + + Can also be used as a |method|: > + GetWinid()->win_gettype() +< +win_gotoid({expr}) *win_gotoid()* + 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() + +win_id2tabwin({expr}) *win_id2tabwin()* + 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() + +win_id2win({expr}) *win_id2win()* + 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() + +win_move_separator({nr}, {offset}) *win_move_separator()* + Move window {nr}'s vertical separator (i.e., the right border) + by {offset} columns, as if being dragged by the mouse. {nr} + can be a window number or |window-ID|. A positive {offset} + moves right and a negative {offset} moves left. Moving a + window's vertical separator will change the width of the + window and the width of other windows adjacent to the vertical + separator. The magnitude of movement may be smaller than + specified (e.g., as a consequence of maintaining + 'winminwidth'). Returns TRUE if the window can be found and + FALSE otherwise. + + Can also be used as a |method|: > + GetWinnr()->win_move_separator(offset) + +win_move_statusline({nr}, {offset}) *win_move_statusline()* + Move window {nr}'s status line (i.e., the bottom border) by + {offset} rows, as if being dragged by the mouse. {nr} can be a + window number or |window-ID|. A positive {offset} moves down + and a negative {offset} moves up. Moving a window's status + line will change the height of the window and the height of + other windows adjacent to the status line. The magnitude of + movement may be smaller than specified (e.g., as a consequence + of maintaining 'winminheight'). Returns TRUE if the window can + be found and FALSE otherwise. + + Can also be used as a |method|: > + GetWinnr()->win_move_statusline(offset) + +win_screenpos({nr}) *win_screenpos()* + 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() +< +win_splitmove({nr}, {target} [, {options}]) *win_splitmove()* + 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) +< + *winbufnr()* +winbufnr({nr}) 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() +< + *wincol()* +wincol() The result is a Number, which is the virtual column of the + cursor in the window. This is counting screen cells from the + left side of the window. The leftmost column is one. + + *windowsversion()* +windowsversion() + 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. + +winheight({nr}) *winheight()* + 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() +< +winlayout([{tabnr}]) *winlayout()* + 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() +< + *winline()* +winline() The result is a Number, which is the screen line of the cursor + in the window. This is counting screen lines from the top of + the window. The first line is one. + If the cursor was moved the view on the file will be updated + first, this may cause a scroll. + + *winnr()* +winnr([{arg}]) 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() +< + *winrestcmd()* +winrestcmd() 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 +< + *winrestview()* +winrestview({dict}) + 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() +< + *winsaveview()* +winsaveview() 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. + + +winwidth({nr}) *winwidth()* + 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() + +wordcount() *wordcount()* + 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) + + + *writefile()* +writefile({object}, {fname} [, {flags}]) + 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" fsync() call is not used, with "s" + it is used, 'fsync' option applies by default. No fsync() + means that writefile() will finish faster, but writes may be + left in OS buffers and not yet written to disk. Such changes + will disappear if system crashes before OS does writing. + + 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") + +xor({expr}, {expr}) *xor()* + 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) +< +============================================================================== +3. Matching a pattern in a String *string-match* + +This is common between several functions. A regexp pattern as explained at +|pattern| is normally used to find a match in the buffer lines. When a +pattern is used to find a match in a String, almost everything works in the +same way. The difference is that a String is handled like it is one line. +When it contains a "\n" character, this is not seen as a line break for the +pattern. It can be matched with a "\n" in the pattern, or with ".". Example: +> + :let a = "aaaa\nxxxx" + :echo matchstr(a, "..\n..") + aa + xx + :echo matchstr(a, "a.x") + a + x + +Don't forget that "^" will only match at the first character of the String and +"$" at the last character of the string. They don't match after or before a +"\n". + + vim:tw=78:ts=8:noet:ft=help:norl: diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt index ffdd8427f9..b170f7cf65 100644 --- a/runtime/doc/change.txt +++ b/runtime/doc/change.txt @@ -906,7 +906,7 @@ Consider using a character like "@" or ":". There is no problem if the result of the expression contains the separation character. Examples: > - :s@\n@\="\r" . expand("$HOME") . "\r"@ + :s@\n@\="\r" .. expand("$HOME") .. "\r"@ This replaces an end-of-line with a new line containing the value of $HOME. > s/E/\="\<Char-0x20ac>"/g @@ -1065,7 +1065,7 @@ inside of strings can change! Also see 'softtabstop' option. > the command. You need to escape the '|' and '"' characters to prevent them from terminating the command. Example: > - :put ='path' . \",/test\" + :put ='path' .. \",/test\" < If there is no expression after '=', Vim uses the previous expression. You can see it with ":dis =". @@ -1118,10 +1118,13 @@ register. With blockwise selection it also depends on the size of the block and whether the corners are on an existing character. (Implementation detail: it actually works by first putting the register after the selection and then deleting the selection.) -The previously selected text is put in the unnamed register. If you want to -put the same text into a Visual selection several times you need to use +With 'p' the previously selected text is put in the unnamed register. This is +useful if you want to put that text somewhere else. But you cannot repeat the +same change. +With 'P' the unnamed register is not changed, you can repeat the same change. +But the deleted text cannot be used. If you do need it you can use 'p' with another register. E.g., yank the text to copy, Visually select the text to -replace and use "0p . You can repeat this as many times as you like, the +replace and use "0p . You can repeat this as many times as you like, and the unnamed register will be changed each time. When you use a blockwise Visual mode command and yank only a single line into @@ -1595,7 +1598,8 @@ r Automatically insert the current comment leader after hitting <Enter> in Insert mode. *fo-o* o Automatically insert the current comment leader after hitting 'o' or - 'O' in Normal mode. + 'O' in Normal mode. In case comment is unwanted in a specific place + use CTRL-U to quickly delete it. |i_CTRL-U| *fo-q* q Allow formatting of comments with "gq". Note that formatting will not change blank lines or lines containing diff --git a/runtime/doc/channel.txt b/runtime/doc/channel.txt index 5f376a600e..e14427494d 100644 --- a/runtime/doc/channel.txt +++ b/runtime/doc/channel.txt @@ -44,7 +44,7 @@ functions like |chansend()| consume channel ids. 2. Reading and writing raw bytes *channel-bytes* Channels opened by Vimscript functions operate with raw bytes by default. For -a job channel using RPC, bytes can still be read over its stderr. Similarily, +a job channel using RPC, bytes can still be read over its stderr. Similarly, only bytes can be written to Nvim's own stderr. *channel-callback* diff --git a/runtime/doc/cmdline.txt b/runtime/doc/cmdline.txt index 7716af25bd..c6e4bf003f 100644 --- a/runtime/doc/cmdline.txt +++ b/runtime/doc/cmdline.txt @@ -207,7 +207,7 @@ CTRL-\ e {expr} *c_CTRL-\_e* Example: > :cmap <F7> <C-\>eAppendSome()<CR> :func AppendSome() - :let cmd = getcmdline() . " Some()" + :let cmd = getcmdline() .. " Some()" :" place the cursor on the ) :call setcmdpos(strlen(cmd)) :return cmd @@ -697,7 +697,8 @@ Line numbers may be specified with: *:range* *{address}* Each may be followed (several times) by '+' or '-' and an optional number. This number is added or subtracted from the preceding line number. If the -number is omitted, 1 is used. +number is omitted, 1 is used. If there is nothing before the '+' or '-' then +the current line is used. The "/" and "?" after {pattern} are required to separate the pattern from anything that follows. @@ -727,7 +728,7 @@ Some commands allow for a count after the command. This count is used as the number of lines to be used, starting with the line given in the last line specifier (the default is the cursor line). The commands that accept a count are the ones that use a range but do not have a file name argument (because -a file name can also be a number). +a file name can also be a number). The count cannot be negative. Examples: > :s/x/X/g 5 substitute 'x' by 'X' in the current line and four @@ -907,8 +908,7 @@ These modifiers can be given, in this order: directory. :. Reduce file name to be relative to current directory, if possible. File name is unmodified if it is not below the - current directory, but on MS-Windows the drive is removed if - it is the current drive. + current directory. For maximum shortness, use ":~:.". :h Head of the file name (the last component and any separators removed). Cannot be used with :e, :r or :t. diff --git a/runtime/doc/develop.txt b/runtime/doc/develop.txt index 7127c74134..178b0dc62b 100644 --- a/runtime/doc/develop.txt +++ b/runtime/doc/develop.txt @@ -105,7 +105,7 @@ in eval.c: - eval_call_provider(name, method, arguments, discard): calls provider#{name}#Call with the method and arguments. If discard is true, any - value returned by the provider will be discarded and and empty value be + value returned by the provider will be discarded and empty value will be returned. - eval_has_provider(name): Checks the `g:loaded_{name}_provider` variable which must be set to 2 by the provider script to indicate that it is diff --git a/runtime/doc/diagnostic.txt b/runtime/doc/diagnostic.txt index a825435179..19db3158be 100644 --- a/runtime/doc/diagnostic.txt +++ b/runtime/doc/diagnostic.txt @@ -132,7 +132,7 @@ with |vim.notify()|: > In this example, there is nothing to do when diagnostics are hidden, so we omit the "hide" function. -Existing handlers can be overriden. For example, use the following to only +Existing handlers can be overridden. For example, use the following to only show a sign for the highest severity diagnostic on a given line: > -- Create a custom namespace. This will aggregate signs from all other @@ -177,8 +177,9 @@ All highlights defined for diagnostics begin with `Diagnostic` followed by the type of highlight (e.g., `Sign`, `Underline`, etc.) and the severity (e.g. `Error`, `Warn`, etc.) -Sign, underline and virtual text highlights (by default) are linked to their -corresponding default highlight. +By default, highlights for signs, floating windows, and virtual text are linked to the +corresponding default highlight. Underline highlights are not linked and use their +own default highlight groups. For example, the default highlighting for |hl-DiagnosticSignError| is linked to |hl-DiagnosticError|. To change the default (and therefore the linked @@ -298,7 +299,6 @@ Example: > autocmd DiagnosticChanged * lua vim.diagnostic.setqflist({open = false }) < ============================================================================== -============================================================================== Lua module: vim.diagnostic *diagnostic-api* config({opts}, {namespace}) *vim.diagnostic.config()* @@ -334,8 +334,9 @@ config({opts}, {namespace}) *vim.diagnostic.config()* that returns any of the above. Parameters: ~ - {opts} table Configuration table with the following - keys: + {opts} table|nil When omitted or "nil", retrieve the + current configuration. Otherwise, a + configuration table with the following keys: • underline: (default true) Use underline for diagnostics. Options: • severity: Only underline diagnostics @@ -343,7 +344,10 @@ config({opts}, {namespace}) *vim.diagnostic.config()* |diagnostic-severity| • virtual_text: (default true) Use virtual - text for diagnostics. Options: + text for diagnostics. If multiple + diagnostics are set for a namespace, one + prefix per diagnostic + the last diagnostic + message are shown. Options: • severity: Only show virtual text for diagnostics matching the given severity |diagnostic-severity| @@ -353,6 +357,11 @@ config({opts}, {namespace}) *vim.diagnostic.config()* is more than one diagnostic source in the buffer. Otherwise, any truthy value means to always show the diagnostic source. + • spacing: (number) Amount of empty spaces + inserted at the beginning of the virtual + text. + • prefix: (string) Prepend diagnostic + message with prefix. • format: (function) A function that takes a diagnostic as input and returns a string. The return value is the text used diff --git a/runtime/doc/diff.txt b/runtime/doc/diff.txt index 6115a5d235..9c5792dd43 100644 --- a/runtime/doc/diff.txt +++ b/runtime/doc/diff.txt @@ -324,8 +324,9 @@ After setting this variable, reload the syntax script: > FINDING THE DIFFERENCES *diff-diffexpr* -The 'diffexpr' option can be set to use something else than the standard -"diff" program to compare two files and find the differences. *E959* +The 'diffexpr' option can be set to use something else than the internal diff +support or the standard "diff" program to compare two files and find the +differences. When 'diffexpr' is empty, Vim uses this command to find the differences between file1 and file2: > @@ -358,7 +359,7 @@ format mentioned. These variables are set to the file names used: v:fname_in original file v:fname_new new version of the same file - v:fname_out resulting diff file + v:fname_out where to write the resulting diff file Additionally, 'diffexpr' should take care of "icase" and "iwhite" in the 'diffopt' option. 'diffexpr' cannot change the value of 'lines' and @@ -370,13 +371,13 @@ Example (this does almost the same as 'diffexpr' being empty): > function MyDiff() let opt = "" if &diffopt =~ "icase" - let opt = opt . "-i " + let opt = opt .. "-i " endif if &diffopt =~ "iwhite" - let opt = opt . "-b " + let opt = opt .. "-b " endif - silent execute "!diff -a --binary " . opt . v:fname_in . " " . v:fname_new . - \ " > " . v:fname_out + silent execute "!diff -a --binary " .. opt .. v:fname_in .. " " .. v:fname_new .. + \ " > " .. v:fname_out redraw! endfunction @@ -426,8 +427,8 @@ Example (this does the same as 'patchexpr' being empty): > set patchexpr=MyPatch() function MyPatch() - :call system("patch -o " . v:fname_out . " " . v:fname_in . - \ " < " . v:fname_diff) + :call system("patch -o " .. v:fname_out .. " " .. v:fname_in .. + \ " < " .. v:fname_diff) endfunction Make sure that using the "patch" program doesn't have unwanted side effects. diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt index 14df41e6c8..bfa01f45a7 100644 --- a/runtime/doc/editing.txt +++ b/runtime/doc/editing.txt @@ -196,7 +196,7 @@ If you want to keep the changed buffer without saving it, switch on the Edit {file} always. Discard any changes to the current buffer. Also see |++opt| and |+cmd|. - + *:edit_#* *:e#* :e[dit] [++opt] [+cmd] #[count] Edit the [count]th buffer (as shown by |:files|). This command does the same as [count] CTRL-^. But ":e @@ -356,7 +356,7 @@ as a wildcard when "[" is in the 'isfname' option. A simple way to avoid this is to use "path\[[]abc]", this matches the file "path\[abc]". *starstar-wildcard* -Expanding "**" is possible on Unix, Win32, Mac OS/X and a few other systems. +Expanding "**" is possible on Unix, Win32, macOS and a few other systems. This allows searching a directory tree. This goes up to 100 directories deep. Note there are some commands where this works slightly differently, see |file-searching|. @@ -411,9 +411,9 @@ does apply like to other wildcards. Environment variables in the expression are expanded when evaluating the expression, thus this works: > - :e `=$HOME . '/.vimrc'` + :e `=$HOME .. '/.vimrc'` This does not work, $HOME is inside a string and used literally: > - :e `='$HOME' . '/.vimrc'` + :e `='$HOME' .. '/.vimrc'` If the expression returns a string then names are to be separated with line breaks. When the result is a |List| then each item is used as a name. Line @@ -845,7 +845,7 @@ Note: When the 'write' option is off, you are not able to write any file. *:w* *:write* *E502* *E503* *E504* *E505* - *E512* *E514* *E667* *E796* *E949* + *E512* *E514* *E667* *E949* :w[rite] [++opt] Write the whole buffer to the current file. This is the normal way to save changes to a file. It fails when the 'readonly' option is set or when there is @@ -1331,6 +1331,7 @@ current directory for that window. Windows where the |:lcd| command has not been used stick to the global or tab-local directory. When jumping to another window the current directory is changed to the last specified local current directory. If none was specified, the global or tab-local directory is used. +When creating a new window it inherits the local directory of the current window. When changing tabs the same behaviour applies. If the current tab has no local working directory the global working directory is used. @@ -1449,6 +1450,11 @@ If you don't get warned often enough you can use the following command. if it exists now. Once a file has been checked the timestamp is reset, you will not be warned again. + Syntax highlighting, marks, diff status, + 'fileencoding', 'fileformat' and 'binary' options + are not changed. See |v:fcs_choice| to reload these + too (for example, if a code formatting tools has + changed the file). :[N]checkt[ime] {filename} :[N]checkt[ime] [N] @@ -1489,7 +1495,7 @@ which version of the file you want to keep. The accuracy of the time check depends on the filesystem. On Unix it is usually sub-second. With old file sytems and on MS-Windows it is normally one -second. Use has('nanotime') check if sub-second time stamp checks are +second. Use `has('nanotime')` to check if sub-second time stamp checks are available. There is one situation where you get the message while there is nothing wrong: @@ -1568,6 +1574,12 @@ There are three different types of searching: /u/user_x/work/include /u/user_x/include +< Note: If your 'path' setting includes a non-existing directory, Vim will + skip the non-existing directory, but continues searching in the parent of + the non-existing directory if upwards searching is used. E.g. when + searching "../include" and that doesn't exist, and upward searching is + used, also searches in "..". + 3) Combined up/downward search: If Vim's current path is /u/user_x/work/release and you do > set path=**;/u/user_x diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt index 63f6c5628a..3015e232a7 100644 --- a/runtime/doc/eval.txt +++ b/runtime/doc/eval.txt @@ -111,7 +111,7 @@ When mixing Number and Float the Number is converted to Float. Otherwise there is no automatic conversion of Float. You can use str2float() for String to Float, printf() for Float to String and float2nr() for Float to Number. - *E891* *E892* *E893* *E894* + *E362* *E891* *E892* *E893* *E894* *E907* When expecting a Float a Number can also be used, but nothing else. *no-type-checking* @@ -372,8 +372,8 @@ Changing the order of items in a list: > For loop ~ -The |:for| loop executes commands for each item in a |List| or |Blob|. -A variable is set to each item in the sequence. Example with a List: > +The |:for| loop executes commands for each item in a |List|, |String| or |Blob|. +A variable is set to each item in sequence. Example with a List: > :for item in mylist : call Doit(item) :endfor @@ -390,7 +390,7 @@ If all you want to do is modify each item in the list then the |map()| function will be a simpler method than a for loop. Just like the |:let| command, |:for| also accepts a list of variables. This -requires the argument to be a list of lists. > +requires the argument to be a List of Lists. > :for [lnum, col] in [[1, 3], [2, 8], [3, 0]] : call Doit(lnum, col) :endfor @@ -402,12 +402,18 @@ It is also possible to put remaining items in a List variable: > :for [i, j; rest] in listlist : call Doit(i, j) : if !empty(rest) - : echo "remainder: " . string(rest) + : echo "remainder: " .. string(rest) : endif :endfor For a Blob one byte at a time is used. +For a String one character, including any composing characters, is used as a +String. Example: > + for c in text + echo 'This character is ' .. c + endfor + List functions ~ *E714* @@ -424,11 +430,11 @@ Functions that are useful with a List: > :let list = split("a b c") " create list from items in a string :let string = join(list, ', ') " create string from list items :let s = string(list) " String representation of list - :call map(list, '">> " . v:val') " prepend ">> " to each item + :call map(list, '">> " .. v:val') " prepend ">> " to each item Don't forget that a combination of features can make things simple. For example, to add up all the numbers in a list: > - :exe 'let sum = ' . join(nrlist, '+') + :exe 'let sum = ' .. join(nrlist, '+') 1.4 Dictionaries ~ @@ -490,7 +496,7 @@ turn the Dictionary into a List and pass it to |:for|. Most often you want to loop over the keys, using the |keys()| function: > :for key in keys(mydict) - : echo key . ': ' . mydict[key] + : echo key .. ': ' .. mydict[key] :endfor The List of keys is unsorted. You may want to sort them first: > @@ -498,13 +504,13 @@ The List of keys is unsorted. You may want to sort them first: > To loop over the values use the |values()| function: > :for v in values(mydict) - : echo "value: " . v + : echo "value: " .. v :endfor If you want both the key and the value use the |items()| function. It returns a List in which each item is a List with two items, the key and the value: > :for [key, value] in items(mydict) - : echo key . ': ' . value + : echo key .. ': ' .. value :endfor @@ -599,7 +605,7 @@ Functions that can be used with a Dictionary: > :let small = min(dict) " minimum value in dict :let xs = count(dict, 'x') " count nr of times 'x' appears in dict :let s = string(dict) " String representation of dict - :call map(dict, '">> " . v:val') " prepend ">> " to each item + :call map(dict, '">> " .. v:val') " prepend ">> " to each item 1.5 Blobs ~ @@ -676,7 +682,7 @@ similar to -1. > :let otherblob = myblob[:] " make a copy of the Blob If the first index is beyond the last byte of the Blob or the second byte is -before the first byte, the result is an empty Blob. There is no error +before the first index, the result is an empty Blob. There is no error message. If the second index is equal to or greater than the length of the Blob the @@ -834,7 +840,7 @@ Example: > All expressions within one level are parsed from left to right. -expr1 *expr1* *trinary* *E109* +expr1 *expr1* *ternary* *E109* ----- expr2 ? expr1 : expr1 @@ -1066,7 +1072,7 @@ expr7 *expr7* For '!' |TRUE| becomes |FALSE|, |FALSE| becomes |TRUE| (one). For '-' the sign of the number is changed. -For '+' the number is unchanged. +For '+' the number is unchanged. Note: "++" has no effect. A String will be converted to a Number first. @@ -1195,6 +1201,7 @@ When expr8 is a |Funcref| type variable, invoke the function it refers to. expr8->name([args]) method call *method* *->* expr8->{lambda}([args]) + *E260* *E276* For methods that are also available as global functions this is the same as: > name(expr8 [, args]) There can also be methods specifically for the type of "expr8". @@ -1227,8 +1234,8 @@ And NOT: > number ------ number number constant *expr-number* - *hex-number* *octal-number* *binary-number* + *0x* *hex-number* *0o* *octal-number* *binary-number* Decimal, Hexadecimal (starting with 0x or 0X), Binary (starting with 0b or 0B) and Octal (starting with 0, 0o or 0O). @@ -1355,7 +1362,7 @@ option *expr-option* *E112* *E113* &l:option local option value Examples: > - echo "tabstop is " . &tabstop + echo "tabstop is " .. &tabstop if &insertmode Any option name can be used here. See |options|. When using the local value @@ -1450,7 +1457,7 @@ the function returns: > :let Bar = Foo(4) :echo Bar(6) < 5 -Note that the variables must exist in the outer scope before the lamba is +Note that the variables must exist in the outer scope before the lambda is defined for this to work. See also |:func-closure|. Lambda and closure support can be checked with: > @@ -1485,7 +1492,7 @@ Notice how execute() is used to execute an Ex command. That's ugly though. Lambda expressions have internal names like '<lambda>42'. If you get an error for a lambda expression, you can find what it is with the following command: > - :function {'<lambda>42'} + :function <lambda>42 See also: |numbered-function| ============================================================================== @@ -1630,7 +1637,7 @@ maintain a counter: > echo "script executed for the first time" else let s:counter = s:counter + 1 - echo "script executed " . s:counter . " times now" + echo "script executed " .. s:counter .. " times now" endif Note that this means that filetype plugins don't get a different set of script @@ -1729,7 +1736,7 @@ v:completed_item *v:count* *count-variable* v:count The count given for the last Normal mode command. Can be used to get the count before a mapping. Read-only. Example: > - :map _x :<C-U>echo "the count is " . v:count<CR> + :map _x :<C-U>echo "the count is " .. v:count<CR> < Note: The <C-U> is required to remove the line range that you get when typing ':' after a count. When there are two counts, as in "3d2w", they are multiplied, @@ -1875,6 +1882,11 @@ v:fcs_choice What should happen after a |FileChangedShell| event was do with the affected buffer: reload Reload the buffer (does not work if the file was deleted). + edit Reload the buffer and detect the + values for options such as + 'fileformat', 'fileencoding', 'binary' + (does not work if the file was + deleted). ask Ask the user what to do, as if there was no autocommand. Except that when only the timestamp changed nothing @@ -2266,8654 +2278,13 @@ v:windowid Application-specific window "handle" which may be set by any ============================================================================== 4. Builtin Functions *vim-function* *functions* -The Vimscript subsystem (referred to as "eval" internally) provides the -following builtin functions. Scripts can also define |user-function|s. +The Vimscript subsystem (referred to as "eval" internally) provides builtin +functions. Scripts can also define |user-function|s. See |function-list| to browse functions by topic. -(Use CTRL-] on the function name to jump to the full explanation.) - -USAGE RESULT DESCRIPTION ~ - -abs({expr}) Float or Number absolute value of {expr} -acos({expr}) Float arc cosine of {expr} -add({object}, {item}) List/Blob append {item} to {object} -and({expr}, {expr}) Number bitwise AND -api_info() Dict api metadata -append({lnum}, {string}) Number append {string} below line {lnum} -append({lnum}, {list}) Number append lines {list} below line {lnum} -argc([{winid}]) Number number of files in the argument list -argidx() Number current index in the argument list -arglistid([{winnr} [, {tabnr}]]) Number argument list id -argv({nr} [, {winid}]) String {nr} entry of the argument list -argv([-1, {winid}]) List the argument list -asin({expr}) Float arc sine of {expr} -assert_beeps({cmd}) Number assert {cmd} causes a beep -assert_equal({exp}, {act} [, {msg}]) - Number assert {exp} is equal to {act} -assert_equalfile({fname-one}, {fname-two} [, {msg}]) - Number assert file contents are equal -assert_exception({error} [, {msg}]) - Number assert {error} is in v:exception -assert_fails({cmd} [, {error}]) Number assert {cmd} fails -assert_false({actual} [, {msg}]) - Number assert {actual} is false -assert_inrange({lower}, {upper}, {actual} [, {msg}]) - Number assert {actual} is inside the range -assert_match({pat}, {text} [, {msg}]) - Number assert {pat} matches {text} -assert_nobeep({cmd}) Number assert {cmd} does not cause a beep -assert_notequal({exp}, {act} [, {msg}]) - Number assert {exp} is not equal {act} -assert_notmatch({pat}, {text} [, {msg}]) - Number assert {pat} not matches {text} -assert_report({msg}) Number report a test failure -assert_true({actual} [, {msg}]) Number assert {actual} is true -atan({expr}) Float arc tangent of {expr} -atan2({expr}, {expr}) Float arc tangent of {expr1} / {expr2} -browse({save}, {title}, {initdir}, {default}) - String put up a file requester -browsedir({title}, {initdir}) String put up a directory requester -bufadd({name}) Number add a buffer to the buffer list -bufexists({expr}) Number |TRUE| if buffer {expr} exists -buflisted({expr}) Number |TRUE| if buffer {expr} is listed -bufload({expr}) Number load buffer {expr} if not loaded yet -bufloaded({expr}) Number |TRUE| if buffer {expr} is loaded -bufname([{expr}]) String Name of the buffer {expr} -bufnr([{expr} [, {create}]]) Number Number of the buffer {expr} -bufwinid({expr}) Number |window-ID| of buffer {expr} -bufwinnr({expr}) Number window number of buffer {expr} -byte2line({byte}) Number line number at byte count {byte} -byteidx({expr}, {nr}) Number byte index of {nr}'th char in {expr} -byteidxcomp({expr}, {nr}) Number byte index of {nr}'th char in {expr} -call({func}, {arglist} [, {dict}]) - any call {func} with arguments {arglist} -ceil({expr}) Float round {expr} up -changenr() Number current change number -chanclose({id}[, {stream}]) Number Closes a channel or one of its streams -chansend({id}, {data}) Number Writes {data} to channel -char2nr({expr}[, {utf8}]) Number ASCII/UTF-8 value of first char in {expr} -charidx({string}, {idx} [, {countcc}]) - Number char index of byte {idx} in {string} -chdir({dir}) String change current working directory -cindent({lnum}) Number C indent for line {lnum} -clearmatches([{win}]) none clear all matches -col({expr}) Number column nr of cursor or mark -complete({startcol}, {matches}) none set Insert mode completion -complete_add({expr}) Number add completion match -complete_check() Number check for key typed during completion -complete_info([{what}]) Dict get current completion information -confirm({msg} [, {choices} [, {default} [, {type}]]]) - Number number of choice picked by user -copy({expr}) any make a shallow copy of {expr} -cos({expr}) Float cosine of {expr} -cosh({expr}) Float hyperbolic cosine of {expr} -count({list}, {expr} [, {ic} [, {start}]]) - Number count how many {expr} are in {list} -cscope_connection([{num}, {dbpath} [, {prepend}]]) - Number checks existence of cscope connection -ctxget([{index}]) Dict return the |context| dict at {index} -ctxpop() none pop and restore |context| from the - |context-stack| -ctxpush([{types}]) none push the current |context| to the - |context-stack| -ctxset({context}[, {index}]) none set |context| at {index} -ctxsize() Number return |context-stack| size -cursor({lnum}, {col} [, {off}]) - Number move cursor to {lnum}, {col}, {off} -cursor({list}) Number move cursor to position in {list} -debugbreak({pid}) Number interrupt process being debugged -deepcopy({expr} [, {noref}]) any make a full copy of {expr} -delete({fname} [, {flags}]) Number delete the file or directory {fname} -deletebufline({buf}, {first}[, {last}]) - Number delete lines from buffer {buf} -dictwatcheradd({dict}, {pattern}, {callback}) - Start watching a dictionary -dictwatcherdel({dict}, {pattern}, {callback}) - Stop watching a dictionary -did_filetype() Number |TRUE| if FileType autocommand event used -diff_filler({lnum}) Number diff filler lines about {lnum} -diff_hlID({lnum}, {col}) Number diff highlighting at {lnum}/{col} -empty({expr}) Number |TRUE| if {expr} is empty -environ() Dict return environment variables -escape({string}, {chars}) String escape {chars} in {string} with '\' -eval({string}) any evaluate {string} into its value -eventhandler() Number |TRUE| if inside an event handler -executable({expr}) Number 1 if executable {expr} exists -execute({command}) String execute and capture output of {command} -exepath({expr}) String full path of the command {expr} -exists({expr}) Number |TRUE| if {expr} exists -extend({expr1}, {expr2} [, {expr3}]) - List/Dict insert items of {expr2} into {expr1} -exp({expr}) Float exponential of {expr} -expand({expr} [, {nosuf} [, {list}]]) - any expand special keywords in {expr} -expandcmd({expr}) String expand {expr} like with `:edit` -feedkeys({string} [, {mode}]) Number add key sequence to typeahead buffer -filereadable({file}) Number |TRUE| if {file} is a readable file -filewritable({file}) Number |TRUE| if {file} is a writable file -filter({expr1}, {expr2}) List/Dict remove items from {expr1} where - {expr2} is 0 -finddir({name} [, {path} [, {count}]]) - String find directory {name} in {path} -findfile({name} [, {path} [, {count}]]) - String find file {name} in {path} -flatten({list} [, {maxdepth}]) List flatten {list} up to {maxdepth} levels -float2nr({expr}) Number convert Float {expr} to a Number -floor({expr}) Float round {expr} down -fmod({expr1}, {expr2}) Float remainder of {expr1} / {expr2} -fnameescape({fname}) String escape special characters in {fname} -fnamemodify({fname}, {mods}) String modify file name -foldclosed({lnum}) Number first line of fold at {lnum} if closed -foldclosedend({lnum}) Number last line of fold at {lnum} if closed -foldlevel({lnum}) Number fold level at {lnum} -foldtext() String line displayed for closed fold -foldtextresult({lnum}) String text for closed fold at {lnum} -foreground() Number bring the Vim window to the foreground -fullcommand({name}) String get full command from {name} -funcref({name} [, {arglist}] [, {dict}]) - Funcref reference to function {name} -function({name} [, {arglist}] [, {dict}]) - Funcref named reference to function {name} -garbagecollect([{atexit}]) none free memory, breaking cyclic references -get({list}, {idx} [, {def}]) any get item {idx} from {list} or {def} -get({dict}, {key} [, {def}]) any get item {key} from {dict} or {def} -get({func}, {what}) any get property of funcref/partial {func} -getbufinfo([{buf}]) List information about buffers -getbufline({buf}, {lnum} [, {end}]) - List lines {lnum} to {end} of buffer {buf} -getbufvar({buf}, {varname} [, {def}]) - any variable {varname} in buffer {buf} -getchangelist([{buf}]) List list of change list items -getchar([expr]) Number or String - get one character from the user -getcharmod() Number modifiers for the last typed character -getcharsearch() Dict last character search -getcharstr([expr]) String get one character from the user -getcmdline() String return the current command-line -getcmdpos() Number return cursor position in command-line -getcmdtype() String return current command-line type -getcmdwintype() String return current command-line window type -getcompletion({pat}, {type} [, {filtered}]) - List list of cmdline completion matches -getcurpos() List position of the cursor -getcwd([{winnr} [, {tabnr}]]) String get the current working directory -getenv({name}) String return environment variable -getfontname([{name}]) String name of font being used -getfperm({fname}) String file permissions of file {fname} -getfsize({fname}) Number size in bytes of file {fname} -getftime({fname}) Number last modification time of file -getftype({fname}) String description of type of file {fname} -getjumplist([{winnr} [, {tabnr}]]) - List list of jump list items -getline({lnum}) String line {lnum} of current buffer -getline({lnum}, {end}) List lines {lnum} to {end} of current buffer -getloclist({nr}) List list of location list items -getloclist({nr}, {what}) Dict get specific location list properties -getmarklist([{buf}]) List list of global/local marks -getmatches([{win}]) List list of current matches -getmousepos() Dict last known mouse position -getpid() Number process ID of Vim -getpos({expr}) List position of cursor, mark, etc. -getqflist() List list of quickfix items -getqflist({what}) Dict get specific quickfix list properties -getreg([{regname} [, 1 [, {list}]]]) - String or List contents of a register -getreginfo([{regname}]) Dict information about a register -getregtype([{regname}]) String type of a register -gettabinfo([{expr}]) List list of tab pages -gettabvar({nr}, {varname} [, {def}]) - any variable {varname} in tab {nr} or {def} -gettabwinvar({tabnr}, {winnr}, {name} [, {def}]) - any {name} in {winnr} in tab page {tabnr} -gettagstack([{nr}]) Dict get the tag stack of window {nr} -getwininfo([{winid}]) List list of windows -getwinpos([{timeout}]) List X and Y coord in pixels of the Vim window -getwinposx() Number X coord in pixels of Vim window -getwinposy() Number Y coord in pixels of Vim window -getwinvar({nr}, {varname} [, {def}]) - any variable {varname} in window {nr} -glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) - any expand file wildcards in {expr} -glob2regpat({expr}) String convert a glob pat into a search pat -globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]]) - String do glob({expr}) for all dirs in {path} -has({feature}) Number |TRUE| if feature {feature} supported -has_key({dict}, {key}) Number |TRUE| if {dict} has entry {key} -haslocaldir([{winnr} [, {tabnr}]]) - Number |TRUE| if the window executed |:lcd| or - the tab executed |:tcd| -hasmapto({what} [, {mode} [, {abbr}]]) - Number |TRUE| if mapping to {what} exists -histadd({history}, {item}) String add an item to a history -histdel({history} [, {item}]) String remove an item from a history -histget({history} [, {index}]) String get the item {index} from a history -histnr({history}) Number highest index of a history -hlexists({name}) Number |TRUE| if highlight group {name} exists -hlID({name}) Number syntax ID of highlight group {name} -hostname() String name of the machine Vim is running on -iconv({expr}, {from}, {to}) String convert encoding of {expr} -indent({lnum}) Number indent of line {lnum} -index({object}, {expr} [, {start} [, {ic}]]) - Number index in {object} where {expr} appears -input({prompt} [, {text} [, {completion}]]) - String get input from the user -inputlist({textlist}) Number let the user pick from a choice list -inputrestore() Number restore typeahead -inputsave() Number save and clear typeahead -inputsecret({prompt} [, {text}]) - String like input() but hiding the text -insert({object}, {item} [, {idx}]) - List insert {item} in {object} [before {idx}] -interrupt() none interrupt script execution -invert({expr}) Number bitwise invert -isdirectory({directory}) Number |TRUE| if {directory} is a directory -isinf({expr}) Number determine if {expr} is infinity value - (positive or negative) -islocked({expr}) Number |TRUE| if {expr} is locked -isnan({expr}) Number |TRUE| if {expr} is NaN -id({expr}) String identifier of the container -items({dict}) List key-value pairs in {dict} -jobpid({id}) Number Returns pid of a job. -jobresize({id}, {width}, {height}) - Number Resize pseudo terminal window of a job -jobstart({cmd}[, {opts}]) Number Spawns {cmd} as a job -jobstop({id}) Number Stops a job -jobwait({ids}[, {timeout}]) Number Wait for a set of jobs -join({list} [, {sep}]) String join {list} items into one String -json_decode({expr}) any Convert {expr} from JSON -json_encode({expr}) String Convert {expr} to JSON -keys({dict}) List keys in {dict} -len({expr}) Number the length of {expr} -libcall({lib}, {func}, {arg}) String call {func} in library {lib} with {arg} -libcallnr({lib}, {func}, {arg}) Number idem, but return a Number -line({expr} [, {winid}]) Number line nr of cursor, last line or mark -line2byte({lnum}) Number byte count of line {lnum} -lispindent({lnum}) Number Lisp indent for line {lnum} -list2str({list} [, {utf8}]) String turn numbers in {list} into a String -localtime() Number current time -log({expr}) Float natural logarithm (base e) of {expr} -log10({expr}) Float logarithm of Float {expr} to base 10 -luaeval({expr}[, {expr}]) any evaluate Lua expression -map({expr1}, {expr2}) List/Dict change each item in {expr1} to {expr} -maparg({name}[, {mode} [, {abbr} [, {dict}]]]) - String or Dict - rhs of mapping {name} in mode {mode} -mapcheck({name}[, {mode} [, {abbr}]]) - String check for mappings matching {name} -match({expr}, {pat}[, {start}[, {count}]]) - Number position where {pat} matches in {expr} -matchadd({group}, {pattern}[, {priority}[, {id}]]) - Number highlight {pattern} with {group} -matchaddpos({group}, {list}[, {priority}[, {id}]]) - Number highlight positions with {group} -matcharg({nr}) List arguments of |:match| -matchdelete({id} [, {win}]) Number delete match identified by {id} -matchend({expr}, {pat}[, {start}[, {count}]]) - Number position where {pat} ends in {expr} -matchlist({expr}, {pat}[, {start}[, {count}]]) - List match and submatches of {pat} in {expr} -matchstr({expr}, {pat}[, {start}[, {count}]]) - String {count}'th match of {pat} in {expr} -matchstrpos({expr}, {pat}[, {start}[, {count}]]) - List {count}'th match of {pat} in {expr} -max({expr}) Number maximum value of items in {expr} -menu_get({path} [, {modes}]) List description of |menus| matched by {path} -min({expr}) Number minimum value of items in {expr} -mkdir({name} [, {path} [, {prot}]]) - Number create directory {name} -mode([expr]) String current editing mode -msgpackdump({list} [, {type}]) List/Blob dump objects to msgpack -msgpackparse({data}) List parse msgpack to a list of objects -nextnonblank({lnum}) Number line nr of non-blank line >= {lnum} -nr2char({expr}[, {utf8}]) String single char with ASCII/UTF-8 value {expr} -nvim_...({args}...) any call nvim |api| functions -or({expr}, {expr}) Number bitwise OR -pathshorten({expr}) String shorten directory names in a path -perleval({expr}) any evaluate |perl| expression -pow({x}, {y}) Float {x} to the power of {y} -prevnonblank({lnum}) Number line nr of non-blank line <= {lnum} -printf({fmt}, {expr1}...) String format text -prompt_getprompt({buf}) String get prompt text -prompt_setcallback({buf}, {expr}) none set prompt callback function -prompt_setinterrupt({buf}, {text}) none set prompt interrupt function -prompt_setprompt({buf}, {text}) none set prompt text -pum_getpos() Dict position and size of pum if visible -pumvisible() Number whether popup menu is visible -pyeval({expr}) any evaluate |Python| expression -py3eval({expr}) any evaluate |python3| expression -pyxeval({expr}) any evaluate |python_x| expression -range({expr} [, {max} [, {stride}]]) - List items from {expr} to {max} -readdir({dir} [, {expr}]) List file names in {dir} selected by {expr} -readfile({fname} [, {type} [, {max}]]) - List get list of lines from file {fname} -reg_executing() String get the executing register name -reg_recorded() String get the last recorded register name -reg_recording() String get the recording register name -reltime([{start} [, {end}]]) List get time value -reltimefloat({time}) Float turn the time value into a Float -reltimestr({time}) String turn time value into a String -remote_expr({server}, {string} [, {idvar} [, {timeout}]]) - String send expression -remote_foreground({server}) Number bring Vim server to the foreground -remote_peek({serverid} [, {retvar}]) - Number check for reply string -remote_read({serverid} [, {timeout}]) - String read reply string -remote_send({server}, {string} [, {idvar}]) - String send key sequence -remote_startserver({name}) none become server {name} -remove({list}, {idx} [, {end}]) any/List - remove items {idx}-{end} from {list} -remove({blob}, {idx} [, {end}]) Number/Blob - remove bytes {idx}-{end} from {blob} -remove({dict}, {key}) any remove entry {key} from {dict} -rename({from}, {to}) Number rename (move) file from {from} to {to} -repeat({expr}, {count}) String repeat {expr} {count} times -resolve({filename}) String get filename a shortcut points to -reverse({list}) List reverse {list} in-place -round({expr}) Float round off {expr} -rubyeval({expr}) any evaluate |Ruby| expression -rpcnotify({channel}, {event}[, {args}...]) - Sends an |RPC| notification to {channel} -rpcrequest({channel}, {method}[, {args}...]) - Sends an |RPC| request to {channel} -screenattr({row}, {col}) Number attribute at screen position -screenchar({row}, {col}) Number character at screen position -screenchars({row}, {col}) List List of characters at screen position -screencol() Number current cursor column -screenpos({winid}, {lnum}, {col}) Dict screen row and col of a text character -screenrow() Number current cursor row -screenstring({row}, {col}) String characters at screen position -search({pattern} [, {flags} [, {stopline} [, {timeout}]]]) - Number search for {pattern} -searchcount([{options}]) Dict Get or update the last search count -searchdecl({name} [, {global} [, {thisblock}]]) - Number search for variable declaration -searchpair({start}, {middle}, {end} [, {flags} [, {skip} [...]]]) - Number search for other end of start/end pair -searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [...]]]) - List search for other end of start/end pair -searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]]) - List search for {pattern} -server2client({clientid}, {string}) - Number send reply string -serverlist() String get a list of available servers -setbufline( {expr}, {lnum}, {line}) - Number set line {lnum} to {line} in buffer - {expr} -setbufvar({buf}, {varname}, {val}) set {varname} in buffer {buf} to {val} -setcharsearch({dict}) Dict set character search from {dict} -setcmdpos({pos}) Number set cursor position in command-line -setenv({name}, {val}) none set environment variable -setfperm({fname}, {mode} Number set {fname} file permissions to {mode} -setline({lnum}, {line}) Number set line {lnum} to {line} -setloclist({nr}, {list} [, {action}]) - Number modify location list using {list} -setloclist({nr}, {list}, {action}, {what}) - Number modify specific location list props -setmatches({list} [, {win}]) Number restore a list of matches -setpos({expr}, {list}) Number set the {expr} position to {list} -setqflist({list} [, {action}]) Number modify quickfix list using {list} -setqflist({list}, {action}, {what}) - Number modify specific quickfix list props -setreg({n}, {v}[, {opt}]) Number set register to value and type -settabvar({nr}, {varname}, {val}) set {varname} in tab page {nr} to {val} -settabwinvar({tabnr}, {winnr}, {varname}, {val}) set {varname} in window - {winnr} in tab page {tabnr} to {val} -settagstack({nr}, {dict} [, {action}]) - Number modify tag stack using {dict} -setwinvar({nr}, {varname}, {val}) set {varname} in window {nr} to {val} -sha256({string}) String SHA256 checksum of {string} -shellescape({string} [, {special}]) - String escape {string} for use as shell - command argument -shiftwidth([{col}]) Number effective value of 'shiftwidth' -sign_define({name} [, {dict}]) Number define or update a sign -sign_define({list}) List define or update a list of signs -sign_getdefined([{name}]) List get a list of defined signs -sign_getplaced([{buf} [, {dict}]]) - List get a list of placed signs -sign_jump({id}, {group}, {buf}) - Number jump to a sign -sign_place({id}, {group}, {name}, {buf} [, {dict}]) - Number place a sign -sign_placelist({list}) List place a list of signs -sign_undefine([{name}]) Number undefine a sign -sign_undefine({list}) List undefine a list of signs -sign_unplace({group} [, {dict}]) - Number unplace a sign -sign_unplacelist({list}) List unplace a list of signs -simplify({filename}) String simplify filename as much as possible -sin({expr}) Float sine of {expr} -sinh({expr}) Float hyperbolic sine of {expr} -sockconnect({mode}, {address} [, {opts}]) - Number Connects to socket -sort({list} [, {func} [, {dict}]]) - List sort {list}, using {func} to compare -soundfold({word}) String sound-fold {word} -spellbadword() String badly spelled word at cursor -spellsuggest({word} [, {max} [, {capital}]]) - List spelling suggestions -split({expr} [, {pat} [, {keepempty}]]) - List make |List| from {pat} separated {expr} -sqrt({expr}) Float square root of {expr} -stdioopen({dict}) Number open stdio in a headless instance. -stdpath({what}) String/List returns the standard path(s) for {what} -str2float({expr} [, {quoted}]) Float convert String to Float -str2list({expr} [, {utf8}]) List convert each character of {expr} to - ASCII/UTF-8 value -str2nr({expr} [, {base} [, {quoted}]]) - Number convert String to Number -strchars({expr} [, {skipcc}]) Number character length of the String {expr} -strcharpart({str}, {start} [, {len}]) - String {len} characters of {str} at - character {start} -strdisplaywidth({expr} [, {col}]) Number display length of the String {expr} -strftime({format} [, {time}]) String format time with a specified format -strgetchar({str}, {index}) Number get char {index} from {str} -stridx({haystack}, {needle} [, {start}]) - Number index of {needle} in {haystack} -string({expr}) String String representation of {expr} value -strlen({expr}) Number length of the String {expr} -strpart({str}, {start} [, {len} [, {chars}]]) - String {len} bytes/chars of {str} at - byte {start} -strptime({format}, {timestring}) - Number Convert {timestring} to unix timestamp -strridx({haystack}, {needle} [, {start}]) - Number last index of {needle} in {haystack} -strtrans({expr}) String translate string to make it printable -strwidth({expr}) Number display cell length of the String {expr} -submatch({nr} [, {list}]) String or List - specific match in ":s" or substitute() -substitute({expr}, {pat}, {sub}, {flags}) - String all {pat} in {expr} replaced with {sub} -swapinfo({fname}) Dict information about swap file {fname} -swapname({buf}) String swap file of buffer {buf} -synID({lnum}, {col}, {trans}) Number syntax ID at {lnum} and {col} -synIDattr({synID}, {what} [, {mode}]) - String attribute {what} of syntax ID {synID} -synIDtrans({synID}) Number translated syntax ID of {synID} -synconcealed({lnum}, {col}) List info about concealing -synstack({lnum}, {col}) List stack of syntax IDs at {lnum} and {col} -system({cmd} [, {input}]) String output of shell command/filter {cmd} -systemlist({cmd} [, {input}]) List output of shell command/filter {cmd} -tabpagebuflist([{arg}]) List list of buffer numbers in tab page -tabpagenr([{arg}]) Number number of current or last tab page -tabpagewinnr({tabarg}[, {arg}]) - Number number of current window in tab page -taglist({expr}[, {filename}]) List list of tags matching {expr} -tagfiles() List tags files used -tan({expr}) Float tangent of {expr} -tanh({expr}) Float hyperbolic tangent of {expr} -tempname() String name for a temporary file -test_garbagecollect_now() none free memory right now for testing -timer_info([{id}]) List information about timers -timer_pause({id}, {pause}) none pause or unpause a timer -timer_start({time}, {callback} [, {options}]) - Number create a timer -timer_stop({timer}) none stop a timer -timer_stopall() none stop all timers -tolower({expr}) String the String {expr} switched to lowercase -toupper({expr}) String the String {expr} switched to uppercase -tr({src}, {fromstr}, {tostr}) String translate chars of {src} in {fromstr} - to chars in {tostr} -trim({text} [, {mask} [, {dir}]]) - String trim characters in {mask} from {text} -trunc({expr}) Float truncate Float {expr} -type({name}) Number type of variable {name} -undofile({name}) String undo file name for {name} -undotree() List undo file tree -uniq({list} [, {func} [, {dict}]]) - List remove adjacent duplicates from a list -values({dict}) List values in {dict} -virtcol({expr}) Number screen column of cursor or mark -visualmode([expr]) String last visual mode used -wait({timeout}, {condition}[, {interval}]) - Number Wait until {condition} is satisfied -wildmenumode() Number whether 'wildmenu' mode is active -win_execute({id}, {command} [, {silent}]) - String execute {command} in window {id} -win_findbuf({bufnr}) List find windows containing {bufnr} -win_getid([{win} [, {tab}]]) Number get |window-ID| for {win} in {tab} -win_gettype([{nr}]) String type of window {nr} -win_gotoid({expr}) Number go to |window-ID| {expr} -win_id2tabwin({expr}) List get tab and window nr from |window-ID| -win_id2win({expr}) Number get window nr from |window-ID| -win_screenpos({nr}) List get screen position of window {nr} -win_splitmove({nr}, {target} [, {options}]) - Number move window {nr} to split of {target} -winbufnr({nr}) Number buffer number of window {nr} -wincol() Number window column of the cursor -windowsversion() String MS-Windows OS version -winheight({nr}) Number height of window {nr} -winlayout([{tabnr}]) List layout of windows in tab {tabnr} -winline() Number window line of the cursor -winnr([{expr}]) Number number of current window -winrestcmd() String returns command to restore window sizes -winrestview({dict}) none restore view of current window -winsaveview() Dict save view of current window -winwidth({nr}) Number width of window {nr} -wordcount() Dict get byte/char/word statistics -writefile({object}, {fname} [, {flags}]) - Number write |Blob| or |List| of lines to file -xor({expr}, {expr}) Number bitwise XOR - - -abs({expr}) *abs()* - 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() - -acos({expr}) *acos()* - 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() - -add({object}, {expr}) *add()* - 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) - -and({expr}, {expr}) *and()* - 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) - -api_info() *api_info()* - Returns Dictionary of |api-metadata|. - - View it in a nice human-readable format: > - :lua print(vim.inspect(vim.fn.api_info())) - -append({lnum}, {text}) *append()* - 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. - {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: > - mylist->append(lnum) - -appendbufline({buf}, {lnum}, {text}) *appendbufline()* - Like |append()| but append the text in buffer {expr}. - - 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: > - mylist->appendbufline(buf, lnum) - -argc([{winid}]) *argc()* - 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. - - *argidx()* -argidx() The result is the current index in the argument list. 0 is - the first file. argc() - 1 is the last one. See |arglist|. - - *arglistid()* -arglistid([{winnr} [, {tabnr}]]) - 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|. - - *argv()* -argv([{nr} [, {winid}]]) - 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 . '<CR>' - : 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|. - -asin({expr}) *asin()* - 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() - - -assert_ functions are documented here: |assert-functions-details| - - -atan({expr}) *atan()* - 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() - -atan2({expr1}, {expr2}) *atan2()* - 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) - - *browse()* -browse({save}, {title}, {initdir}, {default}) - 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. - - *browsedir()* -browsedir({title}, {initdir}) - 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. - -bufadd({name}) *bufadd()* - Add a buffer to the buffer list with String {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 and not be loaded - yet. To add some text to the buffer use this: > - let bufnr = bufadd('someName') - call bufload(bufnr) - call setbufline(bufnr, 1, ['some', 'text']) -< Can also be used as a |method|: > - let bufnr = 'somename'->bufadd() - -bufexists({buf}) *bufexists()* - The result is a Number, which is |TRUE| if a buffer called - {buf} exists. - If the {buf} argument is a number, buffer numbers are used. - Number zero is the alternate buffer for the current window. - - If the {buf} argument is a string it must match a buffer name - exactly. The name can be: - - Relative to the current directory. - - A full path. - - The name of a buffer with 'buftype' set to "nofile". - - A URL name. - Unlisted buffers will be found. - Note that help files are listed by their short name in the - output of |:buffers|, but bufexists() requires using their - long name to be able to find them. - bufexists() may report a buffer exists, but to use the name - with a |:buffer| command you may need to use |expand()|. Esp - for MS-Windows 8.3 names in the form "c:\DOCUME~1" - Use "bufexists(0)" to test for the existence of an alternate - file name. - - Can also be used as a |method|: > - let exists = 'somename'->bufexists() - -buflisted({buf}) *buflisted()* - The result is a Number, which is |TRUE| if a buffer called - {buf} exists and is listed (has the 'buflisted' option set). - The {buf} argument is used like with |bufexists()|. - - Can also be used as a |method|: > - let listed = 'somename'->buflisted() - -bufload({buf}) *bufload()* - Ensure the buffer {buf} 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 {buf} argument is used like with |bufexists()|. - - Can also be used as a |method|: > - eval 'somename'->bufload() - -bufloaded({buf}) *bufloaded()* - The result is a Number, which is |TRUE| if a buffer called - {buf} exists and is loaded (shown in a window or hidden). - The {buf} argument is used like with |bufexists()|. - - Can also be used as a |method|: > - let loaded = 'somename'->bufloaded() - -bufname([{buf}]) *bufname()* - The result is the name of a buffer. Mostly as it is displayed - by the `:ls` command, but not using special names such as - "[No Name]". - If {buf} is omitted the current buffer is used. - If {buf} is a Number, that buffer number's name is given. - Number zero is the alternate buffer for the current window. - If {buf} 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 {buf} 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) -< Can also be used as a |method|: > - echo bufnr->bufname() - -< 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. -< - *bufnr()* -bufnr([{buf} [, {create}]]) - The result is the number of a buffer, as it is displayed by - the `:ls` command. For the use of {buf}, see |bufname()| - above. - If the buffer doesn't exist, -1 is returned. Or, if the - {create} argument is present and TRUE, 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. - - Can also be used as a |method|: > - echo bufref->bufnr() - -bufwinid({buf}) *bufwinid()* - The result is a Number, which is the |window-ID| of the first - window associated with buffer {buf}. For the use of {buf}, - see |bufname()| above. If buffer {buf} doesn't exist or - there is no such window, -1 is returned. Example: > - - echo "A window containing buffer 1 is " . (bufwinid(1)) -< - Only deals with the current tab page. - - Can also be used as a |method|: > - FindBuffer()->bufwinid() - -bufwinnr({buf}) *bufwinnr()* - Like |bufwinid()| but return the window number instead of the - |window-ID|. - If buffer {buf} doesn't exist or there is no such window, -1 - is returned. Example: > - - echo "A window containing buffer 1 is " . (bufwinnr(1)) - -< The number can be used with |CTRL-W_w| and ":wincmd w" - |:wincmd|. - - Can also be used as a |method|: > - FindBuffer()->bufwinnr() - -byte2line({byte}) *byte2line()* - Return the line number that contains the character at byte - count {byte} in the current buffer. This includes the - end-of-line character, depending on the 'fileformat' option - for the current buffer. The first character has byte count - one. - Also see |line2byte()|, |go| and |:goto|. - - Can also be used as a |method|: > - GetOffset()->byte2line() - -byteidx({expr}, {nr}) *byteidx()* - 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) - -byteidxcomp({expr}, {nr}) *byteidxcomp()* - 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({func}, {arglist} [, {dict}]) *call()* *E699* - 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) - -ceil({expr}) *ceil()* - 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() - -changenr() *changenr()* - 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. - -chanclose({id}[, {stream}]) *chanclose()* - Close a channel or a specific stream associated with it. - For a job, {stream} can be one of "stdin", "stdout", - "stderr" or "rpc" (closes stdin/stdout for a job started - with `"rpc":v:true`) If {stream} is omitted, all streams - are closed. If the channel is a pty, this will then close the - pty master, sending SIGHUP to the job process. - For a socket, there is only one stream, and {stream} should be - ommited. - -chansend({id}, {data}) *chansend()* - Send data to channel {id}. For a job, it writes it to the - stdin of the process. For the stdio channel |channel-stdio|, - it writes to Nvim's stdout. Returns the number of bytes - written if the write succeeded, 0 otherwise. - See |channel-bytes| for more information. - - {data} may be a string, string convertible, |Blob|, or a list. - If {data} is a list, the items will be joined by newlines; any - newlines in an item will be sent as NUL. To send a final - newline, include a final empty string. Example: > - :call chansend(id, ["abc", "123\n456", ""]) -< will send "abc<NL>123<NUL>456<NL>". - - chansend() writes raw data, not RPC messages. If the channel - was created with `"rpc":v:true` then the channel expects RPC - messages, use |rpcnotify()| and |rpcrequest()| instead. - - -char2nr({string} [, {utf8}]) *char2nr()* - Return number value of the first char in {string}. - Examples: > - char2nr(" ") returns 32 - char2nr("ABC") returns 65 - char2nr("á") returns 225 - char2nr("á"[0]) returns 195 - char2nr("\<M-x>") returns 128 -< Non-ASCII characters are always treated as UTF-8 characters. - {utf8} is ignored, it exists only for backwards-compatibility. - A combining character is a separate character. - |nr2char()| does the opposite. - - Can also be used as a |method|: > - GetChar()->char2nr() -< - *charidx()* -charidx({string}, {idx} [, {countcc}]) - 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) - -chdir({dir}) *chdir()* - 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. - 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 -< -cindent({lnum}) *cindent()* - Get the amount of indent for line {lnum} according the C - indenting rules, as with 'cindent'. - The indent is counted in spaces, the value of 'tabstop' is - relevant. {lnum} is used just like in |getline()|. - When {lnum} is invalid -1 is returned. - See |C-indenting|. - - Can also be used as a |method|: > - GetLnum()->cindent() - -clearmatches([{win}]) *clearmatches()* - 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() -< - *col()* -col({expr}) 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 <F2> <C-O>:let save_ve = &ve<CR> - \<C-O>:set ve=all<CR> - \<C-O>:echo col(".") . "\n" <Bar> - \let &ve = save_ve<CR> - -< Can also be used as a |method|: > - GetPos()->col() -< - -complete({startcol}, {matches}) *complete()* *E785* - 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 <F5> <C-R>=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('.')) - -complete_add({expr}) *complete_add()* - 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() - -complete_check() *complete_check()* - 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. - - -complete_info([{what}]) *complete_info()* - 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 <Up> or - <Down> keys) - inserted Inserted string. [NOT IMPLEMENT YET] - - *complete_info_mode* - mode values are: - "" Not in completion mode - "keyword" Keyword completion |i_CTRL-X_CTRL-N| - "ctrl_x" Just pressed CTRL-X |i_CTRL-X| - "scroll" Scrolling with |i_CTRL-X_CTRL-E| or - |i_CTRL-X_CTRL-Y| - "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()* -confirm({msg} [, {choices} [, {default} [, {type}]]]) - Confirm() offers the user a dialog, from which a choice can be - made. It returns the number of the choice. For the first - choice this is 1. - - {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 {type} String argument gives the type of dialog. - 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. - - The optional {type} argument gives the type of dialog. This - is only used for the icon of the Win32 GUI. It can be one of - these values: "Error", "Question", "Info", "Warning" or - "Generic". Only the first character is relevant. - When {type} is omitted, "Generic" is used. - - If the user aborts the dialog by pressing <Esc>, CTRL-C, - or another valid interrupt key, confirm() returns 0. - - An example: > - :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2) - :if choice == 0 - : echo "make up your mind!" - :elseif choice == 3 - : echo "tasteful" - :else - : echo "I prefer bananas myself." - :endif -< In a GUI dialog, buttons are used. The layout of the buttons - depends on the 'v' flag in 'guioptions'. If it is included, - the buttons are always put vertically. Otherwise, confirm() - tries to put the buttons in one horizontal line. If they - don't fit, a vertical layout is used anyway. For some systems - the horizontal layout is always used. - - Can also be used as a |method|in: > - BuildMessage()->confirm("&Yes\n&No") -< - *copy()* -copy({expr}) 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() - -cos({expr}) *cos()* - 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() - -cosh({expr}) *cosh()* - 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() - -count({comp}, {expr} [, {ic} [, {start}]]) *count()* - 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) -< - *cscope_connection()* -cscope_connection([{num} , {dbpath} [, {prepend}]]) - Checks for the existence of a |cscope| connection. If no - parameters are specified, then the function returns: - 0, if 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 -< - -ctxget([{index}]) *ctxget()* - Returns a |Dictionary| representing the |context| at {index} - from the top of the |context-stack| (see |context-dict|). - If {index} is not given, it is assumed to be 0 (i.e.: top). - -ctxpop() *ctxpop()* - Pops and restores the |context| at the top of the - |context-stack|. - -ctxpush([{types}]) *ctxpush()* - Pushes the current editor state (|context|) on the - |context-stack|. - If {types} is given and is a |List| of |String|s, it specifies - which |context-types| to include in the pushed context. - Otherwise, all context types are included. - -ctxset({context}[, {index}]) *ctxset()* - Sets the |context| at {index} from the top of the - |context-stack| to that represented by {context}. - {context} is a Dictionary with context data (|context-dict|). - If {index} is not given, it is assumed to be 0 (i.e.: top). - -ctxsize() *ctxsize()* - Returns the size of the |context-stack|. - -cursor({lnum}, {col} [, {off}]) *cursor()* -cursor({list}) - 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 <Tab> or after the last character. - Returns 0 when the position could be set, -1 otherwise. - - Can also be used as a |method|: > - GetCursorPos()->cursor() - -deepcopy({expr}[, {noref}]) *deepcopy()* *E698* - 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|, a copy for it - is made, recursively. Thus changing an item in the copy does - not change the contents of the original |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. - *E724* - 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() - -delete({fname} [, {flags}]) *delete()* - Without {flags} or with {flags} empty: Deletes the file by the - name {fname}. This also works when {fname} is a symbolic link. - A symbolic link itself is deleted, not what it points to. - - 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. - - 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. - - Can also be used as a |method|: > - GetName()->delete() - -deletebufline({buf}, {first}[, {last}]) *deletebufline()* - 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 |setline()|. 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) -< -dictwatcheradd({dict}, {pattern}, {callback}) *dictwatcheradd()* - Adds a watcher to a dictionary. A dictionary watcher is - identified by three components: - - - A dictionary({dict}); - - A key pattern({pattern}). - - A function({callback}). - - After this is called, every change on {dict} and on keys - matching {pattern} will result in {callback} being invoked. - - For example, to watch all global variables: > - silent! call dictwatcherdel(g:, '*', 'OnDictChanged') - function! OnDictChanged(d,k,z) - echomsg string(a:k) string(a:z) - endfunction - call dictwatcheradd(g:, '*', 'OnDictChanged') -< - For now {pattern} only accepts very simple patterns that can - contain a '*' at the end of the string, in which case it will - match every key that begins with the substring before the '*'. - That means if '*' is not the last character of {pattern}, only - keys that are exactly equal as {pattern} will be matched. - - The {callback} receives three arguments: - - - The dictionary being watched. - - The key which changed. - - A dictionary containing the new and old values for the key. - - The type of change can be determined by examining the keys - present on the third argument: - - - If contains both `old` and `new`, the key was updated. - - If it contains only `new`, the key was added. - - If it contains only `old`, the key was deleted. - - This function can be used by plugins to implement options with - validation and parsing logic. - -dictwatcherdel({dict}, {pattern}, {callback}) *dictwatcherdel()* - Removes a watcher added with |dictwatcheradd()|. All three - arguments must match the ones passed to |dictwatcheradd()| in - order for the watcher to be successfully deleted. - - *did_filetype()* -did_filetype() 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. - -diff_filler({lnum}) *diff_filler()* - 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() - -diff_hlID({lnum}, {col}) *diff_hlID()* - 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) - -empty({expr}) *empty()* - 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| and |v:null| are empty, |v:true| is not. - - A |Blob| is empty when its length is zero. - - Can also be used as a |method|: > - mylist->empty() - -environ() *environ()* - 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({string}, {chars}) *escape()* - Escape the characters in {chars} that occur in {string} with a - backslash. Example: > - :echo escape('c:\program files\vim', ' \') -< results in: > - c:\\program\ files\\vim -< Also see |shellescape()| and |fnameescape()|. - - Can also be used as a |method|: > - GetText()->escape(' \') -< - *eval()* -eval({string}) 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() - -eventhandler() *eventhandler()* - 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. - -executable({expr}) *executable()* - This function checks if an executable with the name {expr} - exists. {expr} must be the name of the program without any - arguments. - executable() uses the value of $PATH and/or the normal - searchpath for programs. *PATHEXT* - 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 ".exe;.com;.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 Windows an executable in the same directory as Vim is - always found (it is added to $PATH at |startup|). - 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({command} [, {silent}]) *execute()* - Execute {command} and capture its output. - If {command} is a |String|, returns {command} output. - If {command} is a |List|, returns concatenated outputs. - Examples: > - echo execute('echon "foo"') -< foo > - echo execute(['echon "foo"', 'echon "bar"']) -< foobar - - 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. - - To get a list of lines use |split()| on the result: > - split(execute('args'), "\n") - -< This function is not available in the |sandbox|. - Note: If nested, an outer execute() will not observe output of - the inner calls. - Note: Text attributes (highlights) are not captured. - To execute a command in another window than the current one - use `win_execute()`. - - Can also be used as a |method|: > - GetCommand()->execute() - -exepath({expr}) *exepath()* - Returns the full path of {expr} if it is an executable and - given as a (partial or full) path or is found in $PATH. - Returns empty string otherwise. - If {expr} starts with "./" the |current-directory| is used. - - Can also be used as a |method|: > - GetCommand()->exepath() -< - *exists()* -exists({expr}) The result is a Number, which is |TRUE| if {expr} is - defined, zero otherwise. - - For checking for a supported feature use |has()|. - For checking if a file exists use |filereadable()|. - - The {expr} argument is a string, which contains one of these: - &option-name Vim option (only checks if it exists, - not if it really works) - +option-name Vim option that works. - $ENVNAME environment variable (could also be - done by comparing with an empty - string) - *funcname built-in function (see |functions|) - or user defined function (see - |user-function|). Also works for a - variable that is a Funcref. - varname internal variable (see - |internal-variables|). Also works - for |curly-braces-names|, |Dictionary| - entries, |List| items, etc. Beware - that evaluating an index may cause an - error message for an invalid - expression. E.g.: > - :let l = [1, 2, 3] - :echo exists("l[5]") -< 0 > - :echo exists("l[xx]") -< E121: Undefined variable: xx - 0 - :cmdname Ex command: built-in command, user - command or command modifier |:command|. - Returns: - 1 for match with start of a command - 2 full match with a command - 3 matches several user commands - To check for a supported command - always check the return value to be 2. - :2match The |:2match| command. - :3match The |:3match| command. - #event autocommand defined for this event - #event#pattern autocommand defined for this event and - pattern (the pattern is taken - literally and compared to the - autocommand patterns character by - character) - #group autocommand group exists - #group#event autocommand defined for this group and - event. - #group#event#pattern - autocommand defined for this group, - event and pattern. - ##event autocommand for this event is - supported. - - Examples: > - exists("&mouse") - exists("$HOSTNAME") - exists("*strftime") - exists("*s:MyFunc") - exists("bufcount") - exists(":Make") - exists("#CursorHold") - exists("#BufReadPre#*.gz") - exists("#filetypeindent") - exists("#filetypeindent#FileType") - exists("#filetypeindent#FileType#*") - exists("##ColorScheme") -< There must be no space between the symbol (&/$/*/#) and the - name. - There must be no extra characters after the name, although in - a few cases this is ignored. That may become more strict in - the future, thus don't count on it! - Working example: > - exists(":make") -< NOT working example: > - exists(":make install") - -< Note that the argument must be a string, not the name of the - variable itself. For example: > - exists(bufcount) -< This doesn't check for existence of the "bufcount" variable, - but gets the value of "bufcount", and checks if that exists. - - Can also be used as a |method|: > - Varname()->exists() - -exp({expr}) *exp()* - 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() - -debugbreak({pid}) *debugbreak()* - 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|. - {Sends a SIGINT to a process {pid} other than MS-Windows} - - Can also be used as a |method|: > - GetPid()->debugbreak() - -expand({string} [, {nosuf} [, {list}]]) *expand()* - 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 <NL> characters. - - 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 - <cfile> file name under the cursor - <afile> autocmd file name - <abuf> autocmd buffer number (as a String!) - <amatch> autocmd matched name - <sfile> sourced script file or function name - <slnum> sourced script line number or function - line number - <sflnum> script file line number, also when in - a function - <SID> "<SNR>123_" where "123" is the - current script ID |<SID>| - <cword> word under the cursor - <cWORD> WORD under the cursor - <client> the {clientid} of the last received - message |server2client()| - Modifiers: - :p expand to full path - :h head (last path component removed) - :t tail (last path component only) - :r root (one extension removed) - :e extension only - - Example: > - :let &tags = expand("%:p:h") . "/tags" -< Note that when expanding a string that starts with '%', '#' or - '<', any following text is ignored. This does NOT work: > - :let doesntwork = expand("%:h.bak") -< Use this: > - :let doeswork = expand("%:h") . ".bak" -< Also note that expanding "<cfile>" and others only returns the - referenced file name without further expansion. If "<cfile>" - is "~/.cshrc", you need to do another expand() to have the - "~/" expanded into the path of the home directory: > - :echo expand(expand("<cfile>")) -< - There cannot be white space between the variables and the - following modifier. The |fnamemodify()| function can be used - to modify normal file names. - - When using '%' or '#', and the current or alternate file name - is not defined, an empty string is used. Using "%:p" in a - buffer with no name, results in the current directory, with a - '/' added. - - When {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() - -expandcmd({string}) *expandcmd()* - 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() -< -extend({expr1}, {expr2} [, {expr3}]) *extend()* - {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 *E737* - 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) - -feedkeys({string} [, {mode}]) *feedkeys()* - 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 <Enter> key. But - feedkeys('\<CR>') pushes 5 characters. - The |<Ignore>| keycode may be used to exit the - wait-for-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. - '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 <Esc> 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 typehead 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() - -filereadable({file}) *filereadable()* - The result is a Number, which is |TRUE| when a file with the - name {file} exists, and can be read. If {file} doesn't exist, - or is a directory, the result is |FALSE|. {file} is any - expression, which is used as a String. - 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() - -filewritable({file}) *filewritable()* - The result is a Number, which is 1 when a file with the - name {file} exists, and can be written. If {file} doesn't - exist, or is not writable, the result is 0. If {file} is a - directory, and we can write to it, the result is 2. - - Can also be used as a |method|: > - GetName()->filewriteable() - -filter({expr1}, {expr2}) *filter()* - {expr1} must be a |List|, |Blob|, or a |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) - -finddir({name} [, {path} [, {count}]]) *finddir()* - 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`. - - Can also be used as a |method|: > - GetName()->finddir() - -findfile({name} [, {path} [, {count}]]) *findfile()* - 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} [, {maxdepth}]) *flatten()* - 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, make a copy first if you do - not want that. - *E900* - {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] - - Can also be used as a |method|: > - mylist->flatten() -< -float2nr({expr}) *float2nr()* - 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() - -floor({expr}) *floor()* - 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() - -fmod({expr1}, {expr2}) *fmod()* - 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) - -fnameescape({string}) *fnameescape()* - 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() - -fnamemodify({fname}, {mods}) *fnamemodify()* - Modify file name {fname} according to {mods}. {mods} is a - string of characters like it is used for file names on the - command line. See |filename-modifiers|. - Example: > - :echo fnamemodify("main.c", ":p:h") -< results in: > - /home/mool/vim/vim/src -< 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') - -foldclosed({lnum}) *foldclosed()* - The result is a Number. If the line {lnum} is in a closed - fold, the result is the number of the first line in that fold. - If the line {lnum} is not in a closed fold, -1 is returned. - {lnum} is used like with |getline()|. Thus "." is the current - line, "'m" mark m, etc. - - Can also be used as a |method|: > - GetLnum()->foldclosed() - -foldclosedend({lnum}) *foldclosedend()* - The result is a Number. If the line {lnum} is in a closed - fold, the result is the number of the last line in that fold. - If the line {lnum} is not in a closed fold, -1 is returned. - {lnum} is used like with |getline()|. Thus "." is the current - line, "'m" mark m, etc. - - Can also be used as a |method|: > - GetLnum()->foldclosedend() - -foldlevel({lnum}) *foldlevel()* - The result is a Number, which is the foldlevel of line {lnum} - in the current buffer. For nested folds the deepest level is - returned. If there is no fold at line {lnum}, zero is - returned. It doesn't matter if the folds are open or closed. - When used while updating folds (from 'foldexpr') -1 is - returned for lines where folds are still to be updated and the - foldlevel is unknown. 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() -< - *foldtext()* -foldtext() Returns a String, to be displayed for a closed fold. This is - the default function used for the 'foldtext' option and should - only be called from evaluating 'foldtext'. It uses the - |v:foldstart|, |v:foldend| and |v:folddashes| variables. - The returned string looks like this: > - +-- 45 lines: abcdef -< The number of 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. - -foldtextresult({lnum}) *foldtextresult()* - 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. - - Can also be used as a |method|: > - GetLnum()->foldtextresult() -< - *foreground()* -foreground() Move the Vim window to the foreground. Useful when sent from - a client to a Vim server. |remote_send()| - On Win32 systems this might not work, the OS does not always - allow a window to bring itself to the foreground. Use - |remote_foreground()| instead. - {only in the Win32 GUI and console version} - -fullcommand({name}) *fullcommand()* - Get the full command name from a short abbreviated command - name; see |20.2| for details on command abbreviations. - - The string argument {name} may start with a `:` and can - include a [range], these are skipped and not returned. - Returns an empty string if a command doesn't exist or if it's - ambiguous (for user-defined commands). - - For example `fullcommand('s')`, `fullcommand('sub')`, - `fullcommand(':%substitute')` all return "substitute". - - Can also be used as a |method|: > - GetName()->fullcommand() -< - *funcref()* -funcref({name} [, {arglist}] [, {dict}]) - 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]) -< - *function()* *E700* *E922* *E923* -function({name} [, {arglist}] [, {dict}]) - Return a |Funcref| variable that refers to function {name}. - {name} can be 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') - -< 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 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]) - -garbagecollect([{atexit}]) *garbagecollect()* - Cleanup unused |Lists| and |Dictionaries| 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. - -get({list}, {idx} [, {default}]) *get()* - Get item {idx} from |List| {list}. When this item is not - available return {default}. Return zero when {default} is - omitted. - Can also be used as a |method|: > - mylist->get(idx) -get({blob}, {idx} [, {default}]) - Get byte {idx} from |Blob| {blob}. When this byte is not - available return {default}. Return -1 when {default} is - omitted. -get({dict}, {key} [, {default}]) - Get item with key {key} from |Dictionary| {dict}. When this - item is not available return {default}. Return zero when - {default} is omitted. Useful example: > - let val = get(g:, 'var_name', 'default') -< This gets the value of g:var_name if it exists, and uses - 'default' when it does not exist. -get({func}, {what}) - Get item {what} from Funcref {func}. Possible values for - {what} are: - "name" The function name - "func" The function - "dict" The dictionary - "args" The list with arguments - - *getbufinfo()* -getbufinfo([{buf}]) -getbufinfo([{dict}]) - 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. - 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 - - 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() -< - *getbufline()* -getbufline({buf}, {lnum} [, {end}]) - Return a |List| with the lines starting from {lnum} to {end} - (inclusive) in the buffer {buf}. If {end} is omitted, a - |List| with only the line {lnum} is returned. - - For the use of {buf}, see |bufname()| above. - - For {lnum} and {end} "$" can be used for the last line of the - buffer. Otherwise a number must be used. - - When {lnum} is smaller than 1 or bigger than the number of - lines in the buffer, an empty |List| is returned. - - When {end} is greater than the number of lines in the buffer, - it is treated as {end} is set to the number of lines in the - buffer. When {end} is before {lnum} an empty |List| is - returned. - - This function works only for loaded buffers. For unloaded and - non-existing buffers, an empty |List| is returned. - - Example: > - :let lines = getbufline(bufnr("myfile"), 1, "$") - -< Can also be used as a |method|: > - GetBufnr()->getbufline(lnum) - -getbufvar({buf}, {varname} [, {def}]) *getbufvar()* - 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) -< -getchangelist([{buf}]) *getchangelist()* - 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() - -getchar([expr]) *getchar()* - 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 -< - 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. - - There is no mapping for the character. - Key codes are replaced, thus when the user presses the <Del> - key you get the code for the <Del> key, not the raw character - sequence. Examples: > - getchar() == "\<Del>" - getchar() == "\<S-Left>" -< This example redefines "f" to ignore case: > - :nmap f :call FindChar()<CR> - :function FindChar() - : let c = nr2char(getchar()) - : while col('.') < col('$') - 1 - : normal l - : if getline('.')[col('.') - 1] ==? c - : break - : endif - : endwhile - :endfunction -< -getcharmod() *getcharmod()* - The result is a Number which is the state of the modifiers for - the last obtained character with getchar() or in another way. - These values are added together: - 2 shift - 4 control - 8 alt (meta) - 16 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. - -getcharsearch() *getcharsearch()* - 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 <expr> ; getcharsearch().forward ? ';' : ',' - :nnoremap <expr> , getcharsearch().forward ? ',' : ';' -< Also see |setcharsearch()|. - - -getcharstr([expr]) *getcharstr()* - 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. - - -getcmdline() *getcmdline()* - 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 <F7> <C-\>eescape(getcmdline(), ' \')<CR> -< Also see |getcmdtype()|, |getcmdpos()| and |setcmdpos()|. - Returns an empty string when entering a password or using - |inputsecret()|. - -getcmdpos() *getcmdpos()* - 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()|. - -getcmdtype() *getcmdtype()* - 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()|. - -getcmdwintype() *getcmdwintype()* - 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. - -getcompletion({pat}, {type} [, {filtered}]) *getcompletion()* - 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 - cmdline |cmdline-completion| result - color color schemes - command Ex command - 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') -< - *getcurpos()* -getcurpos() Get the position of the cursor. This is like getpos('.'), but - includes an extra "curswant" in the list: - [0, lnum, col, off, curswant] ~ - The "curswant" number is the preferred column when moving the - cursor vertically. Also see |getpos()|. - The first "bufnum" item is always zero. - - 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. - -getcwd([{winnr}[, {tabnr}]]) *getcwd()* - With no arguments, returns the name of the effective - |current-directory|. With {winnr} or {tabnr} the working - directory of that scope is returned, and 'autochdir' is - ignored. - Tabs and windows are identified by their respective numbers, - 0 means current tab or window. Missing tab number implies 0. - Thus the following are equivalent: > - getcwd(0) - getcwd(0, 0) -< If {winnr} is -1 it is ignored, only the tab is resolved. - {winnr} can be the window number or the |window-ID|. - If both {winnr} and {tabnr} are -1 the global working - directory is returned. - Throw error if the arguments are invalid. |E5000| |E5001| |E5002| - - Can also be used as a |method|: > - GetWinnr()->getcwd() - -getenv({name}) *getenv()* - 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. - See also |expr-env|. - - Can also be used as a |method|: > - GetVarname()->getenv() - -getfontname([{name}]) *getfontname()* - 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. - -getfperm({fname}) *getfperm()* - 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("~/.config/nvim/init.vim")) -< 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()|. - -getfsize({fname}) *getfsize()* - The result is a Number, which is the size in bytes of the - given file {fname}. - If {fname} is a directory, 0 is returned. - If the file {fname} can't be found, -1 is returned. - 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() - -getftime({fname}) *getftime()* - The result is a Number, which is the last modification time of - the given file {fname}. The value is measured as seconds - since 1st Jan 1970, and may be passed to strftime(). See also - |localtime()| and |strftime()|. - If the file {fname} can't be found -1 is returned. - - Can also be used as a |method|: > - GetFilename()->getftime() - -getftype({fname}) *getftype()* - 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. - - Can also be used as a |method|: > - GetFilename()->getftype() - -getjumplist([{winnr} [, {tabnr}]]) *getjumplist()* - 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() - -< *getline()* -getline({lnum} [, {end}]) - 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 a number smaller than 1 or bigger than the - number of lines in the buffer, an empty string is returned. - - When {end} is given the result is a |List| where each item is - a line from the current buffer in the range {lnum} to {end}, - including line {end}. - {end} is used in the same way as {lnum}. - Non-existing lines are silently omitted. - When {end} is before {lnum} an empty |List| is returned. - Example: > - :let start = line('.') - :let end = search("^$") - 1 - :let lines = getline(start, end) - -< Can also be used as a |method|: > - ComputeLnum()->getline() - -< To get lines from another buffer see |getbufline()| - -getloclist({nr},[, {what}]) *getloclist()* - 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}. - If {what} contains 'filewinid', then returns the 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}) - - -getmarklist([{buf}]) *getmarklist()* - 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() - -getmatches([{win}]) *getmatches()* - 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 -< -getmousepos() *getmousepos()* - Returns a Dictionary with the last known position of the - mouse. This can be used in a mapping for a mouse click. 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 - separater 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 focusable floating 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. - - *getpid()* -getpid() Return a Number which is the process ID of the Vim process. - This is a unique number, until Vim exits. - - *getpos()* -getpos({expr}) Get the position for String {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 <Tab> 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. - The column number in the returned List is the byte position - within the line. - The column number can be very large, e.g. 2147483647, in which - case it means "after the end of the line". - 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() - -getqflist([{what}]) *getqflist()* - 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 - 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 - 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"]}) -< -getreg([{regname} [, 1 [, {list}]]]) *getreg()* - The result is a String, which is the contents of register - {regname}. Example: > - :let cliptext = getreg('*') -< When register {regname} was not set the result is an empty - string. - The {regname} argument must be 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. - - Can also be used as a |method|: > - GetRegname()->getreg() - -getreginfo([{regname}]) *getreginfo()* - 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()|. - - Can also be used as a |method|: > - GetRegname()->getreginfo() - -getregtype([{regname}]) *getregtype()* - The result is a String, which is type of register {regname}. - The value will be one of: - "v" for |charwise| text - "V" for |linewise| text - "<CTRL-V>{width}" for |blockwise-visual| text - "" for an empty or unknown register - <CTRL-V> is one character with value 0x16. - The {regname} argument is a string. If {regname} is not - specified, |v:register| is used. - - Can also be used as a |method|: > - GetRegname()->getregtype() - -gettabinfo([{tabnr}]) *gettabinfo()* - 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() - -gettabvar({tabnr}, {varname} [, {def}]) *gettabvar()* - 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) - -gettabwinvar({tabnr}, {winnr}, {varname} [, {def}]) *gettabwinvar()* - 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) - -gettagstack([{winnr}]) *gettagstack()* - 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() - -getwininfo([{winid}]) *getwininfo()* - 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 - quickfix 1 if quickfix or location list window - terminal 1 if a terminal window - 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()| - textoff number of columns occupied by any - 'foldcolumn', 'signcolumn' and line - number in front of the text - 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() - -getwinpos([{timeout}]) *getwinpos()* - 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() -< - *getwinposx()* -getwinposx() The result is a Number, which is the X coordinate in pixels of - the left hand side of the GUI Vim window. The result will be - -1 if the information is not available. - The value can be used with `:winpos`. - - *getwinposy()* -getwinposy() The result is a Number, which is the Y coordinate in pixels of - the top of the GUI Vim window. The result will be -1 if the - information is not available. - The value can be used with `:winpos`. - -getwinvar({winnr}, {varname} [, {def}]) *getwinvar()* - 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) -< -glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) *glob()* - 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 <NL> 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() - -glob2regpat({string}) *glob2regpat()* - 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() -< *globpath()* -globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]]) - 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 <NL> characters. Example: > - :echo globpath(&rtp, "syntax/c.vim", 0, 1) -< - {allinks} 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) -< - *has()* -has({feature}) 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()|. - - If the code has a syntax error, then Nvim may skip the rest - of the line and miss |:endif|. > - if has('feature') | let x = this->breaks->without->the->feature | endif -< - Put |:if| and |:endif| on separate lines to avoid the - syntax error. > - if has('feature') - let x = this->breaks->without->the->feature - endif -< - Vim's compile-time feature-names (prefixed with "+") are not - recognized because Nvim is always compiled with all possible - features. |feature-compile| - - Feature names can be: - 1. Nvim version. For example the "nvim-0.2.1" feature means - that Nvim is version 0.2.1 or later: > - :if has("nvim-0.2.1") - -< 2. Runtime condition or other pseudo-feature. For example the - "win32" feature checks if the current system is Windows: > - :if has("win32") -< *feature-list* - List of supported pseudo-feature names: - acl |ACL| support - bsd BSD system (not macOS, use "mac" for that). - iconv Can use |iconv()| for conversion. - +shellslash Can use backslashes in filenames (Windows) - clipboard |clipboard| provider is available. - fname_case Case in file names matters (for Darwin and MS-Windows - this is not present). - mac MacOS system. - nvim This is Nvim. - python2 Legacy Vim |python2| interface. |has-python| - python3 Legacy Vim |python3| interface. |has-python| - pythonx Legacy Vim |python_x| interface. |has-pythonx| - ttyin input is a terminal (tty) - ttyout output is a terminal (tty) - unix Unix system. - *vim_starting* True during |startup|. - win32 Windows system (32 or 64 bit). - win64 Windows system (64 bit). - wsl WSL (Windows Subsystem for Linux) system - - *has-patch* - 3. Vim patch. For example the "patch123" feature means that - Vim patch 123 at the current |v:version| was included: > - :if v:version > 602 || v:version == 602 && has("patch148") - -< 4. Vim version. For example the "patch-7.4.237" feature means - that Nvim is Vim-compatible to version 7.4.237 or later. > - :if has("patch-7.4.237") - - -has_key({dict}, {key}) *has_key()* - 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) - -haslocaldir([{winnr}[, {tabnr}]]) *haslocaldir()* - The result is a Number, which is 1 when the window has set a - local path via |:lcd| or when {winnr} is -1 and the tabpage - has set a local path via |:tcd|, otherwise 0. - - Tabs and windows are identified by their respective numbers, - 0 means current tab or window. Missing argument implies 0. - Thus the following are equivalent: > - haslocaldir() - haslocaldir(0) - haslocaldir(0, 0) -< With {winnr} use that window in the current tabpage. - With {winnr} and {tabnr} use the window in that tabpage. - {winnr} can be the window number or the |window-ID|. - If {winnr} is -1 it is ignored, only the tab is resolved. - Throw error if the arguments are invalid. |E5000| |E5001| |E5002| - - Can also be used as a |method|: > - GetWinnr()->haslocaldir() - -hasmapto({what} [, {mode} [, {abbr}]]) *hasmapto()* - 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 <Leader>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() - -histadd({history}, {item}) *histadd()* - Add the String {item} to the history {history} which can be - one of: *hist-names* - "cmd" or ":" command line history - "search" or "/" search pattern history - "expr" or "=" typed expression history - "input" or "@" input line history - "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') - -histdel({history} [, {item}]) *histdel()* - 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() - -histget({history} [, {index}]) *histget()* - The result is a String, the entry with Number {index} from - {history}. See |hist-names| for the possible values of - {history}, and |:history-indexing| for {index}. If there is - no such entry, an empty String is returned. When {index} is - omitted, the most recent item from the history is used. - - Examples: - Redo the second last search from history. > - :execute '/' . histget("search", -2) - -< Define an Ex command ":H {num}" that supports re-execution of - the {num}th entry from the output of |:history|. > - :command -nargs=1 H execute histget("cmd", 0+<args>) -< - Can also be used as a |method|: > - GetHistory()->histget() - -histnr({history}) *histnr()* - The result is the Number of the current entry in {history}. - See |hist-names| for the possible values of {history}. - If an error occurred, -1 is returned. - - Example: > - :let inp_index = histnr("expr") - -< Can also be used as a |method|: > - GetHistory()->histnr() -< -hlexists({name}) *hlexists()* - 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. - - Can also be used as a |method|: > - GetName()->hlexists() -< - *hlID()* -hlID({name}) The result is a Number, which is the ID of the highlight group - with name {name}. When the highlight group doesn't exist, - zero is returned. - This can be used to retrieve information about the highlight - group. For example, to get the background color of the - "Comment" group: > - :echo synIDattr(synIDtrans(hlID("Comment")), "bg") -< - Can also be used as a |method|: > - GetName()->hlID() - -hostname() *hostname()* - The result is a String, which is the name of the machine on - which Vim is currently running. Machine names greater than - 256 characters long are truncated. - -iconv({string}, {from}, {to}) *iconv()* - 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". - 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') -< - *indent()* -indent({lnum}) The result is a Number, which is indent of line {lnum} in the - current buffer. The indent is counted in spaces, the value - of 'tabstop' is relevant. {lnum} is used just like in - |getline()|. - When {lnum} is invalid -1 is returned. - - Can also be used as a |method|: > - GetLnum()->indent() - -index({object}, {expr} [, {start} [, {ic}]]) *index()* - 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 a |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) - -input({prompt} [, {text} [, {completion}]]) *input()* -input({opts}) - 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. - - In the second form it accepts a single dictionary with the - following keys, any of which may be omitted: - - Key Default Description ~ - prompt "" Same as {prompt} in the first form. - default "" Same as {text} in the first form. - completion nothing Same as {completion} in the first form. - cancelreturn "" The value returned when the dialog is - cancelled. - highlight nothing Highlight handler: |Funcref|. - - 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") - -< *input()-highlight* *E5400* *E5402* - The optional `highlight` key allows specifying function which - will be used for highlighting user input. This function - receives user input as its only argument and must return - a list of 3-tuples [hl_start_col, hl_end_col + 1, hl_group] - where - hl_start_col is the first highlighted column, - hl_end_col is the last highlighted column (+ 1!), - hl_group is |:hi| group used for highlighting. - *E5403* *E5404* *E5405* *E5406* - Both hl_start_col and hl_end_col + 1 must point to the start - of the multibyte character (highlighting must not break - multibyte characters), hl_end_col + 1 may be equal to the - input length. Start column must be in range [0, len(input)), - end column must be in range (hl_start_col, len(input)], - sections must be ordered so that next hl_start_col is greater - then or equal to previous hl_end_col. - - Example (try some input with parentheses): > - highlight RBP1 guibg=Red ctermbg=red - highlight RBP2 guibg=Yellow ctermbg=yellow - highlight RBP3 guibg=Green ctermbg=green - highlight RBP4 guibg=Blue ctermbg=blue - let g:rainbow_levels = 4 - function! RainbowParens(cmdline) - let ret = [] - let i = 0 - let lvl = 0 - while i < len(a:cmdline) - if a:cmdline[i] is# '(' - call add(ret, [i, i + 1, 'RBP' . ((lvl % g:rainbow_levels) + 1)]) - let lvl += 1 - elseif a:cmdline[i] is# ')' - let lvl -= 1 - call add(ret, [i, i + 1, 'RBP' . ((lvl % g:rainbow_levels) + 1)]) - endif - let i += 1 - endwhile - return ret - endfunction - call input({'prompt':'>','highlight':'RainbowParens'}) -< - Highlight function is called at least once for each new - displayed input string, before command-line is redrawn. It is - expected that function is pure for the duration of one input() - call, i.e. it produces the same output for the same input, so - output may be memoized. Function is run like under |:silent| - modifier. If the function causes any errors, it will be - skipped for the duration of the current input() call. - - Highlighting is disabled if command-line contains arabic - characters. - - 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()<CR>: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() - -inputlist({textlist}) *inputlist()* - {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, if the mouse is enabled in the command line ('mouse' is - "a" or includes "c"). 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() - -inputrestore() *inputrestore()* - Restore typeahead that was saved with a previous |inputsave()|. - Should be called the same number of times inputsave() is - called. Calling it more often is harmless though. - Returns TRUE when there is nothing to restore, FALSE otherwise. - -inputsave() *inputsave()* - Preserve typeahead (also from mappings) and clear it, so that - a following prompt gets input from the user. Should be - followed by a matching inputrestore() after the prompt. Can - be used several times, in which case there must be just as - many inputrestore() calls. - Returns TRUE when out of memory, FALSE otherwise. - -inputsecret({prompt} [, {text}]) *inputsecret()* - This function acts much like the |input()| function with but - two exceptions: - a) the user's response will be displayed as a sequence of - asterisks ("*") thereby keeping the entry secret, and - b) the user's response will not be recorded on the input - |history| stack. - The result is a String, which is whatever the user actually - typed on the command-line in response to the issued prompt. - NOTE: Command-line completion is not supported. - - Can also be used as a |method|: > - GetPrompt()->inputsecret() - -insert({object}, {item} [, {idx}]) *insert()* - 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() *interrupt()* - 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('<amatch>')) - -invert({expr}) *invert()* - 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() - -isdirectory({directory}) *isdirectory()* - 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() - -isinf({expr}) *isinf()* - 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() - -islocked({expr}) *islocked()* *E786* - 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. - - Can also be used as a |method|: > - GetName()->islocked() - -id({expr}) *id()* - Returns a |String| which is a unique identifier of the - container type (|List|, |Dict|, |Blob| and |Partial|). It is - guaranteed that for the mentioned types `id(v1) ==# id(v2)` - returns true iff `type(v1) == type(v2) && v1 is v2`. - Note that |v:_null_string|, |v:_null_list|, |v:_null_dict| and - |v:_null_blob| have the same `id()` with different types - because they are internally represented as NULL pointers. - `id()` returns a hexadecimal representanion of the pointers to - the containers (i.e. like `0x994a40`), same as `printf("%p", - {expr})`, but it is advised against counting on the exact - format of the return value. - - It is not guaranteed that `id(no_longer_existing_container)` - will not be equal to some other `id()`: new containers may - reuse identifiers of the garbage-collected ones. - -items({dict}) *items()* - 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() - -isnan({expr}) *isnan()* - 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() - -jobpid({job}) *jobpid()* - Return the PID (process id) of |job-id| {job}. - -jobresize({job}, {width}, {height}) *jobresize()* - Resize the pseudo terminal window of |job-id| {job} to {width} - columns and {height} rows. - Fails if the job was not started with `"pty":v:true`. - -jobstart({cmd}[, {opts}]) *jobstart()* - Spawns {cmd} as a job. - If {cmd} is a List it runs directly (no 'shell'). - If {cmd} is a String it runs in the 'shell', like this: > - :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}']) -< (See |shell-unquoting| for details.) - - Example: > - :call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}}) -< - Returns |job-id| on success, 0 on invalid arguments (or job - table is full), -1 if {cmd}[0] or 'shell' is not executable. - The returned job-id is a valid |channel-id| representing the - job's stdio streams. Use |chansend()| (or |rpcnotify()| and - |rpcrequest()| if "rpc" was enabled) to send data to stdin and - |chanclose()| to close the streams without stopping the job. - - See |job-control| and |RPC|. - - NOTE: on Windows if {cmd} is a List: - - cmd[0] must be an executable (not a "built-in"). If it is - in $PATH it can be called by name, without an extension: > - :call jobstart(['ping', 'neovim.io']) -< If it is a full or partial path, extension is required: > - :call jobstart(['System32\ping.exe', 'neovim.io']) -< - {cmd} is collapsed to a string of quoted args as expected - by CommandLineToArgvW https://msdn.microsoft.com/bb776391 - unless cmd[0] is some form of "cmd.exe". - - *jobstart-options* - {opts} is a dictionary with these keys: - clear_env: (boolean) `env` defines the job environment - exactly, instead of merging current environment. - cwd: (string, default=|current-directory|) Working - directory of the job. - detach: (boolean) Detach the job process: it will not be - killed when Nvim exits. If the process exits - before Nvim, `on_exit` will be invoked. - env: (dict) Map of environment variable name:value - pairs extending (or replacing if |clear_env|) - the current environment. - height: (number) Height of the `pty` terminal. - |on_exit|: (function) Callback invoked when the job exits. - |on_stdout|: (function) Callback invoked when the job emits - stdout data. - |on_stderr|: (function) Callback invoked when the job emits - stderr data. - overlapped: (boolean) Set FILE_FLAG_OVERLAPPED for the - standard input/output passed to the child process. - Normally you do not need to set this. - (Only available on MS-Windows, On other - platforms, this option is silently ignored.) - pty: (boolean) Connect the job to a new pseudo - terminal, and its streams to the master file - descriptor. Then `on_stderr` is ignored, - `on_stdout` receives all output. - rpc: (boolean) Use |msgpack-rpc| to communicate with - the job over stdio. Then `on_stdout` is ignored, - but `on_stderr` can still be used. - stderr_buffered: (boolean) Collect data until EOF (stream closed) - before invoking `on_stderr`. |channel-buffered| - stdout_buffered: (boolean) Collect data until EOF (stream - closed) before invoking `on_stdout`. |channel-buffered| - stdin: (string) Either "pipe" (default) to connect the - job's stdin to a channel or "null" to disconnect - stdin. - width: (number) Width of the `pty` terminal. - - {opts} is passed as |self| dictionary to the callback; the - caller may set other keys to pass application-specific data. - - Returns: - - |channel-id| on success - - 0 on invalid arguments - - -1 if {cmd}[0] is not executable. - See also |job-control|, |channel|, |msgpack-rpc|. - -jobstop({id}) *jobstop()* - Stop |job-id| {id} by sending SIGTERM to the job process. If - the process does not terminate after a timeout then SIGKILL - will be sent. When the job terminates its |on_exit| handler - (if any) will be invoked. - See |job-control|. - - Returns 1 for valid job id, 0 for invalid id, including jobs have - exited or stopped. - -jobwait({jobs}[, {timeout}]) *jobwait()* - Waits for jobs and their |on_exit| handlers to complete. - - {jobs} is a List of |job-id|s to wait for. - {timeout} is the maximum waiting time in milliseconds. If - omitted or -1, wait forever. - - Timeout of 0 can be used to check the status of a job: > - let running = jobwait([{job-id}], 0)[0] == -1 -< - During jobwait() callbacks for jobs not in the {jobs} list may - be invoked. The screen will not redraw unless |:redraw| is - invoked by a callback. - - Returns a list of len({jobs}) integers, where each integer is - the status of the corresponding job: - Exit-code, if the job exited - -1 if the timeout was exceeded - -2 if the job was interrupted (by |CTRL-C|) - -3 if the job-id is invalid - -join({list} [, {sep}]) *join()* - 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() - -json_decode({expr}) *json_decode()* - Convert {expr} from JSON object. Accepts |readfile()|-style - list as the input, as well as regular string. May output any - Vim value. In the following cases it will output - |msgpack-special-dict|: - 1. Dictionary contains duplicate key. - 2. Dictionary contains empty key. - 3. String contains NUL byte. Two special dictionaries: for - dictionary and for string will be emitted in case string - with NUL byte was a dictionary key. - - Note: function treats its input as UTF-8 always. The JSON - standard allows only a few encodings, of which UTF-8 is - recommended and the only one required to be supported. - Non-UTF-8 characters are an error. - - Can also be used as a |method|: > - ReadObject()->json_decode() - -json_encode({expr}) *json_encode()* - Convert {expr} into a JSON string. Accepts - |msgpack-special-dict| as the input. Will not convert - |Funcref|s, mappings with non-string keys (can be created as - |msgpack-special-dict|), values with self-referencing - containers, strings which contain non-UTF-8 characters, - pseudo-UTF-8 strings which contain codepoints reserved for - surrogate pairs (such strings are not valid UTF-8 strings). - Non-printable characters are converted into "\u1234" escapes - or special escapes like "\t", other are dumped as-is. - |Blob|s are converted to arrays of the individual bytes. - - Can also be used as a |method|: > - GetObject()->json_encode() - -keys({dict}) *keys()* - 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() - -< *len()* *E701* -len({expr}) The result is a Number, which is the length of the argument. - 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() - -< *libcall()* *E364* *E368* -libcall({libname}, {funcname}, {argument}) - Call function {funcname} in the run-time library {libname} - with single argument {argument}. - This is useful to call functions in a library that you - especially made to be used with Vim. Since only one argument - is possible, calling standard library functions is rather - limited. - The result is the String returned by the function. If the - function returns NULL, this will appear as an empty string "" - to Vim. - If the function returns a number, use libcallnr()! - If {argument} is a number, it is passed to the function as an - int; if {argument} is a string, it is passed as a - null-terminated string. - - libcall() allows you to write your own 'plug-in' extensions to - Vim without having to recompile the program. It is NOT a - means to call system functions! If you try to do so Vim will - very probably crash. - - For Win32, the functions you write must be placed in a DLL - and use the normal C calling convention (NOT Pascal which is - used in Windows System DLLs). The function must take exactly - one parameter, either a character pointer or a long integer, - and must return a character pointer or NULL. The character - pointer returned must point to memory that will remain valid - after the function has returned (e.g. in static data in the - DLL). If it points to allocated memory, that memory will - leak away. Using a static buffer in the function should work, - it's then freed when the DLL is unloaded. - - WARNING: If the function returns a non-valid pointer, Vim may - crash! This also happens if the function returns a number, - because Vim thinks it's a pointer. - For Win32 systems, {libname} should be the filename of the DLL - without the ".DLL" suffix. A full path is only required if - the DLL is not in the usual places. - For Unix: When compiling your own plugins, remember that the - object code must be compiled as position-independent ('PIC'). - 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") -< - *libcallnr()* -libcallnr({libname}, {funcname}, {argument}) - Just like |libcall()|, but used for a function that returns an - int instead of a string. - 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") -< -line({expr} [, {winid}]) *line()* - The result is a Number, which is the line number of the file - position given with {expr}. The {expr} argument is a string. - 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()|. - With the optional {winid} argument the values are obtained for - that window instead of the current window. - Examples: > - line(".") line number of the cursor - line(".", winid) idem, in window "winid" - line("'t") line number of mark t - line("'" . marker) line number of mark marker -< - Can also be used as a |method|: > - GetValue()->line() - -line2byte({lnum}) *line2byte()* - Return the byte count from the start of the buffer for line - {lnum}. This includes the end-of-line character, depending on - the 'fileformat' option for the current buffer. The first - line returns 1. UTF-8 encoding is used, '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. {lnum} is used like with - |getline()|. When {lnum} is invalid -1 is returned. - Also see |byte2line()|, |go| and |:goto|. - - Can also be used as a |method|: > - GetLnum()->line2byte() - -lispindent({lnum}) *lispindent()* - Get the amount of indent for line {lnum} according the lisp - indenting rules, as with 'lisp'. - The indent is counted in spaces, the value of 'tabstop' is - relevant. {lnum} is used just like in |getline()|. - When {lnum} is invalid, -1 is returned. - - Can also be used as a |method|: > - GetLnum()->lispindent() - -list2str({list} [, {utf8}]) *list2str()* - 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. - - UTF-8 encoding is always used, {utf8} option has no effect, - and exists only for backwards-compatibility. - With UTF-8 composing characters work as expected: > - list2str([97, 769]) returns "á" -< - Can also be used as a |method|: > - GetList()->list2str() - -localtime() *localtime()* - Return the current time, measured as seconds since 1st Jan - 1970. See also |strftime()|, |strptime()| and |getftime()|. - - -log({expr}) *log()* - 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() - -log10({expr}) *log10()* - 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() - -luaeval({expr}[, {expr}]) - Evaluate Lua expression {expr} and return its result converted - to Vim data structures. See |lua-eval| for more details. - - Can also be used as a |method|: > - GetExpr()->luaeval() - -map({expr1}, {expr2}) *map()* - {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. - - {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) - -maparg({name} [, {mode} [, {abbr} [, {dict}]]]) *maparg()* - 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 "<Nop>" - 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 - "" 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. - "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 <script>. - "expr" 1 for an expression mapping (|:map-<expr>|). - "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 <sid> mappings - (|<SID>|). - "lnum" The line number in "sid", zero if unknown. - "nowait" Do not wait for other, longer mappings. - (|:map-<nowait>|). - - 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 <Tab> ==' . maparg('<Tab>', 'n') - -< Can also be used as a |method|: > - GetKey()->maparg('n') - -mapcheck({name} [, {mode} [, {abbr}]]) *mapcheck()* - 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 non-zero 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 - "<Nop>" 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') - -match({expr}, {pat} [, {start} [, {count}]]) *match()* - 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. - *strpbrk()* - Vim doesn't have a strpbrk() function. But you can do: > - :let sepidx = match(line, '[.,;: \t]') -< *strcasestr()* - 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|: > - GetText()->match('word') - GetList()->match('word') -< - *matchadd()* *E798* *E799* *E801* *E957* -matchadd({group}, {pattern}[, {priority}[, {id} [, {dict}]]]) - 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| highlighed - 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') -< - *matchaddpos()* -matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]]) - 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. - *E5030* *E5031* - {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. - - Entries with zero and negative line numbers are silently - ignored, as well as entries with negative column numbers and - lengths. - - 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]) - -matcharg({nr}) *matcharg()* - 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() - -matchdelete({id} [, {win}]) *matchdelete()* *E802* *E803* - 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() - -matchend({expr}, {pat} [, {start} [, {count}]]) *matchend()* - Same as |match()|, but return the index of first character - after the match. Example: > - :echo matchend("testing", "ing") -< results in "7". - *strspn()* *strcspn()* - 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') - -matchlist({expr}, {pat} [, {start} [, {count}]]) *matchlist()* - 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. - - You can pass in a List, but that is not very useful. - - Can also be used as a |method|: > - GetText()->matchlist('word') - -matchstr({expr}, {pat} [, {start} [, {count}]]) *matchstr()* - Same as |match()|, but return the matched string. Example: > - :echo matchstr("testing", "ing") -< results in "ing". - When there is no match "" is returned. - The {start}, if given, has the same meaning as for |match()|. > - :echo matchstr("testing", "ing", 2) -< results in "ing". > - :echo matchstr("testing", "ing", 5) -< result is "". - 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') - -matchstrpos({expr}, {pat} [, {start} [, {count}]]) *matchstrpos()* - 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') -< - *max()* -max({expr}) Return the maximum value of all items in {expr}. - {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() - -menu_get({path} [, {modes}]) *menu_get()* - Returns a |List| of |Dictionaries| describing |menus| (defined - by |:menu|, |:amenu|, …), including |hidden-menus|. - - {path} matches a menu by name, or all menus if {path} is an - empty string. Example: > - :echo menu_get('File','') - :echo menu_get('') -< - {modes} is a string of zero or more modes (see |maparg()| or - |creating-menus| for the list of modes). "a" means "all". - - Example: > - nnoremenu &Test.Test inormal - inoremenu Test.Test insert - vnoremenu Test.Test x - echo menu_get("") - -< returns something like this: > - - [ { - "hidden": 0, - "name": "Test", - "priority": 500, - "shortcut": 84, - "submenus": [ { - "hidden": 0, - "mappings": { - i": { - "enabled": 1, - "noremap": 1, - "rhs": "insert", - "sid": 1, - "silent": 0 - }, - n": { ... }, - s": { ... }, - v": { ... } - }, - "name": "Test", - "priority": 500, - "shortcut": 0 - } ] - } ] -< - - *min()* -min({expr}) Return the minimum value of all items in {expr}. - {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() - -< *mkdir()* *E739* -mkdir({name} [, {path} [, {prot}]]) - 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. - - {prot} is applied for all parts of {name}. Thus if you create - /tmp/foo/bar then /tmp/foo will be created with 0700. Example: > - :call mkdir($HOME . "/tmp/foo/bar", "p", 0700) -< This function is not available in the |sandbox|. - - If you try to create an existing directory with {path} set to - "p" mkdir() will silently exit. - - The function result is a Number, which is TRUE if the call was - successful or FALSE if the directory creation failed or partly - failed. - - Can also be used as a |method|: > - GetName()->mkdir() -< - *mode()* -mode([expr]) 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. - - n Normal - no Operator-pending - nov Operator-pending (forced charwise |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| - nt Normal in |terminal-emulator| (insert goes to - Terminal mode) - v Visual by character - vs Visual by character using |v_CTRL-O| in Select mode - V Visual by line - Vs Visual by line using |v_CTRL-O| in Select mode - CTRL-V Visual blockwise - CTRL-Vs Visual blockwise using |v_CTRL-O| in Select mode - 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| - Rx Replace mode |i_CTRL-X| completion - Rv Virtual Replace |gR| - Rvc Virtual Replace mode completion |compl-generic| - Rvx Virtual Replace mode |i_CTRL-X| completion - c Command-line editing - cv Vim Ex mode |gQ| - r Hit-enter prompt - rm The -- more -- prompt - r? A |:confirm| query of some sort - ! Shell or external command is executing - t Terminal 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() - -msgpackdump({list} [, {type}]) *msgpackdump()* - Convert a list of VimL objects to msgpack. Returned value is a - |readfile()|-style list. When {type} contains "B", a |Blob| is - returned instead. Example: > - call writefile(msgpackdump([{}]), 'fname.mpack', 'b') -< or, using a |Blob|: > - call writefile(msgpackdump([{}], 'B'), 'fname.mpack') -< - This will write the single 0x80 byte to a `fname.mpack` file - (dictionary with zero items is represented by 0x80 byte in - messagepack). - - Limitations: *E5004* *E5005* - 1. |Funcref|s cannot be dumped. - 2. Containers that reference themselves cannot be dumped. - 3. Dictionary keys are always dumped as STR strings. - 4. Other strings and |Blob|s are always dumped as BIN strings. - 5. Points 3. and 4. do not apply to |msgpack-special-dict|s. - -msgpackparse({data}) *msgpackparse()* - Convert a |readfile()|-style list or a |Blob| to a list of - VimL objects. - Example: > - let fname = expand('~/.config/nvim/shada/main.shada') - let mpack = readfile(fname, 'b') - let shada_objects = msgpackparse(mpack) -< This will read ~/.config/nvim/shada/main.shada file to - `shada_objects` list. - - Limitations: - 1. Mapping ordering is not preserved unless messagepack - mapping is dumped using generic mapping - (|msgpack-special-map|). - 2. Since the parser aims to preserve all data untouched - (except for 1.) some strings are parsed to - |msgpack-special-dict| format which is not convenient to - use. - *msgpack-special-dict* - Some messagepack strings may be parsed to special - dictionaries. Special dictionaries are dictionaries which - - 1. Contain exactly two keys: `_TYPE` and `_VAL`. - 2. `_TYPE` key is one of the types found in |v:msgpack_types| - variable. - 3. Value for `_VAL` has the following format (Key column - contains name of the key from |v:msgpack_types|): - - Key Value ~ - nil Zero, ignored when dumping. Not returned by - |msgpackparse()| since |v:null| was introduced. - boolean One or zero. When dumping it is only checked that - value is a |Number|. Not returned by |msgpackparse()| - since |v:true| and |v:false| were introduced. - integer |List| with four numbers: sign (-1 or 1), highest two - bits, number with bits from 62nd to 31st, lowest 31 - bits. I.e. to get actual number one will need to use - code like > - _VAL[0] * ((_VAL[1] << 62) - & (_VAL[2] << 31) - & _VAL[3]) -< Special dictionary with this type will appear in - |msgpackparse()| output under one of the following - circumstances: - 1. |Number| is 32-bit and value is either above - INT32_MAX or below INT32_MIN. - 2. |Number| is 64-bit and value is above INT64_MAX. It - cannot possibly be below INT64_MIN because msgpack - C parser does not support such values. - float |Float|. This value cannot possibly appear in - |msgpackparse()| output. - string |readfile()|-style list of strings. This value will - appear in |msgpackparse()| output if string contains - zero byte or if string is a mapping key and mapping is - being represented as special dictionary for other - reasons. - binary |String|, or |Blob| if binary string contains zero - byte. This value cannot appear in |msgpackparse()| - output since blobs were introduced. - array |List|. This value cannot appear in |msgpackparse()| - output. - *msgpack-special-map* - map |List| of |List|s with two items (key and value) each. - This value will appear in |msgpackparse()| output if - parsed mapping contains one of the following keys: - 1. Any key that is not a string (including keys which - are binary strings). - 2. String with NUL byte inside. - 3. Duplicate key. - 4. Empty key. - ext |List| with two values: first is a signed integer - representing extension type. Second is - |readfile()|-style list of strings. - -nextnonblank({lnum}) *nextnonblank()* - Return the line number of the first line at or below {lnum} - that is not blank. Example: > - if getline(nextnonblank(1)) =~ "Java" -< When {lnum} is invalid or there is no non-blank line at or - below it, zero is returned. - {lnum} is used like with |getline()|. - See also |prevnonblank()|. - - Can also be used as a |method|: > - GetLnum()->nextnonblank() - -nr2char({expr} [, {utf8}]) *nr2char()* - Return a string with a single character, which has the number - value {expr}. Examples: > - nr2char(64) returns "@" - nr2char(32) returns " " -< Example for "utf-8": > - nr2char(300) returns I with bow character -< UTF-8 encoding is always used, {utf8} option has no effect, - and exists only for backwards-compatibility. - 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. - - Can also be used as a |method|: > - GetNumber()->nr2char() - -nvim_...({...}) *E5555* *nvim_...()* *eval-api* - Call nvim |api| functions. The type checking of arguments will - be stricter than for most other builtins. For instance, - if Integer is expected, a |Number| must be passed in, a - |String| will not be autoconverted. - Buffer numbers, as returned by |bufnr()| could be used as - first argument to nvim_buf_... functions. All functions - expecting an object (buffer, window or tabpage) can - also take the numerical value 0 to indicate the current - (focused) object. - -or({expr}, {expr}) *or()* - 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) - -pathshorten({path}) *pathshorten()* - 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 single letters. Leading - '~' and '.' characters are kept. Example: > - :echo pathshorten('~/.config/nvim/autoload/file1.vim') -< ~/.c/n/a/file1.vim ~ - It doesn't matter if the path exists or not. - - Can also be used as a |method|: > - GetDirectories()->pathshorten() - -perleval({expr}) *perleval()* - Evaluate |perl| 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: If you want an array or hash, {expr} must return a - reference to it. - Example: > - :echo perleval('[1 .. 4]') -< [1, 2, 3, 4] - - Can also be used as a |method|: > - GetExpr()->perleval() - -pow({x}, {y}) *pow()* - 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) - -prevnonblank({lnum}) *prevnonblank()* - Return the line number of the first line at or above {lnum} - that is not blank. Example: > - let ind = indent(prevnonblank(v:lnum - 1)) -< When {lnum} is invalid or there is no non-blank line at or - above it, zero is returned. - {lnum} is used like with |getline()|. - Also see |nextnonblank()|. - - Can also be used as a |method|: > - GetLnum()->prevnonblank() - -printf({fmt}, {expr1} ...) *printf()* - 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 - %b binary number - %08b binary number padded with zeros to at least 8 characters - %B binary number using upper case letters - %x hex number - %04x hex number padded with zeros to at least 4 characters - %X hex number using upper case letters - %o octal number - %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 - %p representation of the pointer to the container - - 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 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, 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. For the S - conversion the count is in cells. - - .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, the maximum number of - bytes to be printed from a string for s conversions, - or the maximum number of cells 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: - - *printf-d* *printf-b* *printf-B* *printf-o* *printf-x* *printf-X* - 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 - - *printf-c* - c The Number argument is converted to a byte, and the - resulting character is written. - - *printf-s* - 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". - *printf-S* - S The text of the String argument is used. If a - precision is specified, no more display cells than the - number specified are used. - - *printf-f* *E807* - 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. - - *printf-e* *printf-E* - 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'. - - *printf-g* *printf-G* - 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. - - *printf-%* - % 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. - - *E766* *E767* - 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. - -prompt_getprompt({buf}) *prompt_getprompt()* - 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() - -prompt_setcallback({buf}, {expr}) *prompt_setcallback()* - 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) - -prompt_setinterrupt({buf}, {expr}) *prompt_setinterrupt()* - 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) - -prompt_setprompt({buf}, {text}) *prompt_setprompt()* - 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: ') - -pum_getpos() *pum_getpos()* - 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|. - -pumvisible() *pumvisible()* - 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. - -py3eval({expr}) *py3eval()* - 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 - UTF-8). - Lists are represented as Vim |List| type. - Dictionaries are represented as Vim |Dictionary| type with - keys converted to strings. - - Can also be used as a |method|: > - GetExpr()->py3eval() -< - *E858* *E859* -pyeval({expr}) *pyeval()* - Evaluate Python expression {expr} and return its result - converted to Vim data structures. - Numbers and strings are returned as they are (strings are - copied though). - Lists are represented as Vim |List| type. - Dictionaries are represented as Vim |Dictionary| type, - non-string keys result in error. - - Can also be used as a |method|: > - GetExpr()->pyeval() - -pyxeval({expr}) *pyxeval()* - 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() -< - *E726* *E727* -range({expr} [, {max} [, {stride}]]) *range()* - 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() -< - *readdir()* -readdir({directory} [, {expr}]) - Return a list with file and directory names in {directory}. - - 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. - 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 !~ '^\.\|\~$'}) - -< 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() -< - *readfile()* -readfile({fname} [, {type} [, {max}]]) - 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. - When {type} contains "B" a |Blob| is returned with the binary - data of the file unmodified. - Otherwise: - - CR characters that appear before a NL are removed. - - Whether the last line ends in a NL or not does not matter. - - 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. - 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() - -reg_executing() *reg_executing()* - Returns the single letter name of the register being executed. - Returns an empty string when no register is being executed. - See |@|. - -reg_recorded() *reg_recorded()* - Returns the single letter name of the last recorded register. - Returns an empty string string when nothing was recorded yet. - See |q| and |Q|. - -reg_recording() *reg_recording()* - Returns the single letter name of the register being recorded. - Returns an empty string string when not recording. See |q|. - -reltime([{start} [, {end}]]) *reltime()* - Return an item that represents a time value. The item is a - list with items that depend on the system. - The item can be passed to |reltimestr()| to convert it to a - string or |reltimefloat()| to convert to a Float. - - Without an argument it returns the current "relative time", an - implementation-defined value meaningful only when used as an - argument to |reltime()|, |reltimestr()| and |reltimefloat()|. - - With one argument it returns the time passed since the time - specified in the argument. - With two arguments it returns the time passed between {start} - and {end}. - - The {start} and {end} arguments must be values returned by - reltime(). - - Can also be used as a |method|: > - GetStart()->reltime() -< - Note: |localtime()| returns the current (non-relative) time. - -reltimefloat({time}) *reltimefloat()* - Return a Float that represents the time value of {time}. - Unit of time is seconds. - 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 an empty string is returned - - Can also be used as a |method|: > - reltime(start)->reltimefloat() - -reltimestr({time}) *reltimestr()* - 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. - 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 - - Can also be used as a |method|: > - reltime(start)->reltimestr() -< - *remote_expr()* *E449* -remote_expr({server}, {string} [, {idvar} [, {timeout}]]) - 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|. - 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") -< - -remote_foreground({server}) *remote_foreground()* - 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|. - {only in the Win32 GUI and the Win32 console version} - - -remote_peek({serverid} [, {retvar}]) *remote_peek()* - Returns a positive number if there are available strings - from {serverid}. Copies any reply string into the variable - {retvar} if specified. {retvar} must be a string with the - name of a variable. - Returns zero if none are available. - Returns -1 if something is wrong. - See also |clientserver|. - This function is not available in the |sandbox|. - Examples: > - :let repl = "" - :echo "PEEK: ".remote_peek(id, "repl").": ".repl - -remote_read({serverid}, [{timeout}]) *remote_read()* - 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|. - Example: > - :echo remote_read(id) -< - *remote_send()* *E241* -remote_send({server}, {string} [, {idvar}]) - Send the {string} to {server}. The string is sent as input - keys and the function returns immediately. 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|. - - Note: Any errors will be reported in the server and may mess - up the display. - Examples: > - :echo remote_send("gvim", ":DropAndReply ".file, "serverid"). - \ remote_read(serverid) - - :autocmd NONE RemoteReply * - \ echo remote_read(expand("<amatch>")) - :echo remote_send("gvim", ":sleep 10 | echo ". - \ 'server2client(expand("<client>"), "HELLO")<CR>') -< - *remote_startserver()* *E941* *E942* -remote_startserver({name}) - Become the server {name}. This fails if already running as a - server, when |v:servername| is not empty. - -remove({list}, {idx} [, {end}]) *remove()* - 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) - -< Can also be used as a |method|: > - mylist->remove(idx) - -remove({blob}, {idx} [, {end}]) - Without {end}: Remove the byte at {idx} from |Blob| {blob} and - return the byte. - With {end}: Remove bytes from {idx} to {end} (inclusive) and - return a |Blob| with these bytes. When {idx} points to the same - byte as {end} a |Blob| with one byte is returned. When {end} - points to a byte before {idx} this is an error. - Example: > - :echo "last byte: " . remove(myblob, -1) - :call remove(mylist, 0, 9) - -remove({dict}, {key}) - Remove the entry from {dict} with key {key} and return it. - Example: > - :echo "removed " . remove(dict, "one") -< If there is no {key} in {dict} this is an error. - - Use |delete()| to remove a file. - -rename({from}, {to}) *rename()* - Rename the file by the name {from} to the name {to}. This - should also work to move files across file systems. The - result is a Number, which is 0 if the file was renamed - successfully, and non-zero when the renaming failed. - 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}) *repeat()* - 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) - -resolve({filename}) *resolve()* *E655* - On MS-Windows, when {filename} is a shortcut (a .lnk file), - returns the path the shortcut points to in a simplified form. - 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()* -reverse({object}) - 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({expr}) *round()* - 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() - -rpcnotify({channel}, {event}[, {args}...]) *rpcnotify()* - Sends {event} to {channel} via |RPC| and returns immediately. - If {channel} is 0, the event is broadcast to all channels. - Example: > - :au VimLeave call rpcnotify(0, "leaving") - -rpcrequest({channel}, {method}[, {args}...]) *rpcrequest()* - Sends a request to {channel} to invoke {method} via - |RPC| and blocks until a response is received. - Example: > - :let result = rpcrequest(rpc_chan, "func", 1, 2, 3) - -rpcstart({prog}[, {argv}]) *rpcstart()* - Deprecated. Replace > - :let id = rpcstart('prog', ['arg1', 'arg2']) -< with > - :let id = jobstart(['prog', 'arg1', 'arg2'], {'rpc': v:true}) - -rubyeval({expr}) *rubyeval()* - Evaluate Ruby expression {expr} and return its result - converted to Vim data structures. - Numbers, floats and strings are returned as they are (strings - are copied though). - Arrays are represented as Vim |List| type. - Hashes are represented as Vim |Dictionary| type. - Other objects are represented as strings resulted from their - "Object#to_s" method. - - Can also be used as a |method|: > - GetRubyExpr()->rubyeval() - -screenattr({row}, {col}) *screenattr()* - 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) - -screenchar({row}, {col}) *screenchar()* - 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) - -screenchars({row}, {col}) *screenchars()* - 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) - -screencol() *screencol()* - 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 <expr> GG ":echom ".screencol()."\n" - nnoremap <silent> GG :echom screencol()<CR> - noremap GG <Cmd>echom screencol()<Cr> -< -screenpos({winid}, {lnum}, {col}) *screenpos()* - 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". - The |conceal| feature is ignored here, the column numbers are - as if 'conceallevel' is zero. You can set the cursor to the - right position and use |screencol()| to get the value with - |conceal| taken into account. - - Can also be used as a |method|: > - GetWinid()->screenpos(lnum, col) - -screenrow() *screenrow()* - 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()|. - -screenstring({row}, {col}) *screenstring()* - 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({pattern} [, {flags} [, {stopline} [, {timeout}]]]) *search()* - 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. - - *search()-sub-match* - 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() - -searchcount([{options}]) *searchcount()* - 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 - result by |n|, |N|, or this - function is returned. - (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: 0) - pos |List| `[lnum, col, off]` value - when recomputing the result. - this changes "current" result - value. see |cursor()|, |getpos() - (default: cursor's position) - - Can also be used as a |method|: > - GetSearchOpts()->searchcount() -< -searchdecl({name} [, {global} [, {thisblock}]]) *searchdecl()* - 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() -< - *searchpair()* -searchpair({start}, {middle}, {end} [, {flags} [, {skip} - [, {stopline} [, {timeout}]]]]) - 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. - - 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 through 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"') -< - *searchpairpos()* -searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} - [, {stopline} [, {timeout}]]]]) - 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. - -searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]]) *searchpos()* - 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() - -server2client({clientid}, {string}) *server2client()* - Send a reply string to {clientid}. The most recent {clientid} - that sent a string can be retrieved with expand("<client>"). - Note: - Returns zero for success, -1 for failure. - 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("<client>"), "HELLO") - -< Can also be used as a |method|: > - GetClientId()->server2client(string) -< -serverlist() *serverlist()* - Returns a list of server addresses, or empty if all servers - were stopped. |serverstart()| |serverstop()| - Example: > - :echo serverlist() - -serverstart([{address}]) *serverstart()* - Opens a socket or named pipe at {address} and listens for - |RPC| messages. Clients can send |API| commands to the address - to control Nvim. Returns the address string. - - If {address} does not contain a colon ":" it is interpreted as - a named pipe or Unix domain socket path. - - Example: > - if has('win32') - call serverstart('\\.\pipe\nvim-pipe-1234') - else - call serverstart('nvim.sock') - endif -< - If {address} contains a colon ":" it is interpreted as a TCP - address where the last ":" separates the host and port. - Assigns a random port if it is empty or 0. Supports IPv4/IPv6. - - Example: > - :call serverstart('::1:12345') -< - If no address is given, it is equivalent to: > - :call serverstart(tempname()) - -< |$NVIM_LISTEN_ADDRESS| is set to {address} if not already set. - -serverstop({address}) *serverstop()* - Closes the pipe or socket at {address}. - Returns TRUE if {address} is valid, else FALSE. - If |$NVIM_LISTEN_ADDRESS| is stopped it is unset. - If |v:servername| is stopped it is set to the next available - address returned by |serverlist()|. - -setbufline({buf}, {lnum}, {text}) *setbufline()* - Set line {lnum} to {text} in buffer {buf}. This works like - |setline()| for the specified buffer. - - This function works only for loaded buffers. First call - |bufload()| if needed. - - To insert lines use |appendbufline()|. - Any text properties in {lnum} are cleared. - - {text} can be a string to set one line, or a list of strings - to set multiple lines. If the list extends below the last - line then those lines are added. - - For the use of {buf}, see |bufname()| above. - - {lnum} is used like with |setline()|. - Use "$" to refer to the last line in buffer {buf}. - When {lnum} is just below the last line the {text} will be - added below the last line. - 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. - - Can also be used as a |method|, the base is passed as the - third argument: > - GetText()->setbufline(buf, lnum) - -setbufvar({buf}, {varname}, {val}) *setbufvar()* - 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) - -setcharsearch({dict}) *setcharsearch()* - 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() - -setcmdpos({pos}) *setcmdpos()* - 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() - -setenv({name}, {val}) *setenv()* - 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') - -setfperm({fname}, {mode}) *setfperm()* *chmod* - 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()|. - -setline({lnum}, {text}) *setline()* - Set line {lnum} of the current buffer to {text}. To insert - lines use |append()|. To set lines in another buffer use - |setbufline()|. - - {lnum} is used like with |getline()|. - When {lnum} is just below the last line the {text} will be - added below the last line. - - If this succeeds, FALSE is returned. If this fails (most likely - because {lnum} is invalid) TRUE is returned. - - Example: > - :call setline(5, strftime("%c")) - -< When {text} is a |List| then line {lnum} and following lines - will be set to the items in the list. Example: > - :call setline(5, ['aaa', 'bbb', 'ccc']) -< This is equivalent to: > - :for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']] - : call setline(n, l) - :endfor - -< Note: The '[ and '] marks are not set. - - Can also be used as a |method|, the base is passed as the - second argument: > - GetText()->setline(lnum) - -setloclist({nr}, {list} [, {action} [, {what}]]) *setloclist()* - 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) - -setmatches({list} [, {win}]) *setmatches()* - 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() -< - *setpos()* -setpos({expr}, {list}) - Set the position for String {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 <Tab> 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('.') - -setqflist({list} [, {action} [, {what}]]) *setqflist()* - 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}. - *setqflist-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: *setqflist-action* *E927* - '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() -< - *setreg()* -setreg({regname}, {value} [, {options}]) - Set the register {regname} to {value}. - The {regname} argument is a string. - - {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" |charwise| mode - "l" or "V" |linewise| mode - "b" or "<CTRL-V>" |blockwise-visual| mode - If a number immediately follows "b" or "<CTRL-V>" 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 <Tab> as 1 character). - If {options} contains "u" or '"', then the unnamed register is - set to point to register {regname}. - - If {options} contains no register settings, then the default - is to use character mode unless {value} ends in a <NL> for - string {value} and linewise mode for list {value}. Blockwise - mode is never selected automatically. - Returns zero for success, non-zero for failure. - - *E883* - 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') - -settabvar({tabnr}, {varname}, {val}) *settabvar()* - Set tab-local variable {varname} to {val} in tab page {tabnr}. - |t:var| - The {varname} argument is a string. - 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) - -settabwinvar({tabnr}, {winnr}, {varname}, {val}) *settabwinvar()* - 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. - 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()->settabwinvar(tab, winnr, name) - -settagstack({nr}, {dict} [, {action}]) *settagstack()* - 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. - *E962* - 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) - -setwinvar({nr}, {varname}, {val}) *setwinvar()* - 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) - -sha256({string}) *sha256()* - Returns a String with 64 hex characters, which is the SHA256 - checksum of {string}. - - Can also be used as a |method|: > - GetText()->sha256() - -shellescape({string} [, {special}]) *shellescape()* - Escape {string} for use as a shell command argument. - - On Windows when 'shellslash' is not set, encloses {string} in - double-quotes and doubles all double-quotes within {string}. - Otherwise encloses {string} in single-quotes and replaces all - "'" with "'\''". - - If {special} is a |non-zero-arg|: - - Special items such as "!", "%", "#" and "<cword>" will be - preceded by a backslash. The backslash will be removed again - by the |:!| command. - - The <NL> character is escaped. - - If 'shell' contains "csh" in the tail: - - The "!" character will be escaped. This is because csh and - tcsh use "!" for history replacement even in single-quotes. - - The <NL> character is escaped (twice if {special} is - a |non-zero-arg|). - - If 'shell' contains "fish" in the tail, the "\" character will - be escaped because in fish it is used as an escape character - inside single quotes. - - Example of use with a |:!| command: > - :exe '!dir ' . shellescape(expand('<cfile>'), 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() - -shiftwidth([{col}]) *shiftwidth()* - Returns the effective value of 'shiftwidth'. This is the - 'shiftwidth' value unless it is zero, in which case it is the - 'tabstop' value. To be backwards compatible in indent - plugins, use this: > - if exists('*shiftwidth') - func s:sw() - return shiftwidth() - endfunc - else - func s:sw() - return &sw - endfunc - endif -< And then use s:sw() instead of &sw. - - 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 no {col} argument is given, column 1 - will be assumed. - - Can also be used as a |method|: > - GetColumn()->shiftwidth() - -sign_ functions are documented here: |sign-functions-details| - -simplify({filename}) *simplify()* - 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() - -sin({expr}) *sin()* - 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() - -sinh({expr}) *sinh()* - 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() - -sockconnect({mode}, {address} [, {opts}]) *sockconnect()* - Connect a socket to an address. If {mode} is "pipe" then - {address} should be the path of a named pipe. If {mode} is - "tcp" then {address} should be of the form "host:port" where - the host should be an ip adderess or host name, and port the - port number. - - Returns a |channel| ID. Close the socket with |chanclose()|. - Use |chansend()| to send data over a bytes socket, and - |rpcrequest()| and |rpcnotify()| to communicate with a RPC - socket. - - {opts} is an optional dictionary with these keys: - |on_data| : callback invoked when data was read from socket - data_buffered : read socket data in |channel-buffered| mode. - rpc : If set, |msgpack-rpc| will be used to communicate - over the socket. - Returns: - - The channel ID on success (greater than zero) - - 0 on invalid arguments or connection failure. - -sort({list} [, {func} [, {dict}]]) *sort()* *E702* - 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}) -< - *soundfold()* -soundfold({word}) - 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() -< - *spellbadword()* -spellbadword([{sentence}]) - 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() -< - *spellsuggest()* -spellsuggest({word} [, {max} [, {capital}]]) - 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() - -split({string} [, {pattern} [, {keepempty}]]) *split()* - 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() - -sqrt({expr}) *sqrt()* - 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() - -stdioopen({opts}) *stdioopen()* - With |--headless| this opens stdin and stdout as a |channel|. - May be called only once. See |channel-stdio|. stderr is not - handled by this function, see |v:stderr|. - - Close the stdio handles with |chanclose()|. Use |chansend()| - to send data to stdout, and |rpcrequest()| and |rpcnotify()| - to communicate over RPC. - - {opts} is a dictionary with these keys: - |on_stdin| : callback invoked when stdin is written to. - stdin_buffered : read stdin in |channel-buffered| mode. - rpc : If set, |msgpack-rpc| will be used to communicate - over stdio - Returns: - - |channel-id| on success (value is always 1) - - 0 on invalid arguments - - -stdpath({what}) *stdpath()* *E6100* - Returns |standard-path| locations of various default files and - directories. - - {what} Type Description ~ - cache String Cache directory. Arbitrary temporary - storage for plugins, etc. - config String User configuration directory. The - |init.vim| is stored here. - config_dirs List Additional configuration directories. - data String User data directory. The |shada-file| - is stored here. - data_dirs List Additional data directories. - - Example: > - :echo stdpath("config") - - -str2float({string} [, {quoted}]) *str2float()* - 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() - -str2list({string} [, {utf8}]) *str2list()* - 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. - - UTF-8 encoding is always used, {utf8} option has no effect, - and exists only for backwards-compatibility. - With UTF-8 composing characters are handled properly: > - str2list("á") returns [97, 769] - -< Can also be used as a |method|: > - GetString()->str2list() - -str2nr({string} [, {base}]) *str2nr()* - 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() - -strcharpart({src}, {start} [, {len}]) *strcharpart()* - Like |strpart()| but using character index and length instead - of byte index and length. Composing characters are counted - separately. - When a character index is used where a character does not - exist it is assumed to be one character. For example: > - strcharpart('abc', -1, 2) -< results in 'a'. - - Can also be used as a |method|: > - GetText()->strcharpart(5) - -strchars({string} [, {skipcc}]) *strchars()* - 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. - 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() - -strdisplaywidth({string} [, {col}]) *strdisplaywidth()* - 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() - -strftime({format} [, {time}]) *strftime()* - The result is a String, which is a formatted date and time, as - specified by the {format} string. The given {time} is used, - or the current time if no time is given. The accepted - {format} depends on your system, thus this is not portable! - See the manual page of the C function strftime() for the - format. The maximum length of the result is 80 characters. - See also |localtime()|, |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. - -< Can also be used as a |method|: > - GetFormat()->strftime() - -strgetchar({str}, {index}) *strgetchar()* - 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) - -stridx({haystack}, {needle} [, {start}]) *stridx()* - 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 -< *strstr()* *strchr()* - 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) - - *string()* -string({expr}) 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' - Number 123 - Float 123.123456 or 1.123456e8 or - `str2float('inf')` - Funcref `function('name')` - Blob 0z00112233.44556677.8899 - List [item, item] - Dictionary {key: value, key: value} - Note that in String values the ' character is doubled. - Also see |strtrans()|. - Note 2: Output format is mostly compatible with YAML, except - for infinite and NaN floating-point values representations - which use |str2float()|. Strings are also dumped literally, - only single quote is escaped, which does not allow using YAML - for parsing back binary strings. |eval()| should always work for - strings and floats though and this is the only official - method, use |msgpackdump()| or |json_encode()| if you need to - share data with other application. - - Can also be used as a |method|: > - mylist->string() - -strlen({string}) *strlen()* - 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() - -strpart({src}, {start} [, {len} [, {chars}]]) *strpart()* - 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) - -strptime({format}, {timestring}) *strptime()* - 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 - - Can also be used as a |method|: > - GetFormat()->strptime(timestring) -< -strridx({haystack}, {needle} [, {start}]) *strridx()* - 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 -< *strrchr()* - When used with a single character it works similar to the C - function strrchr(). - - Can also be used as a |method|: > - GetHaystack()->strridx(needle) - -strtrans({string}) *strtrans()* - 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() - -strwidth({string}) *strwidth()* - 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() - -submatch({nr} [, {list}]) *submatch()* *E935* - 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() - -substitute({string}, {pat}, {sub}, {flags}) *substitute()* - 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) - -swapinfo({fname}) *swapinfo()* - 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 - 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() - -swapname({buf}) *swapname()* - The result is the swap file path of the buffer {buf}. - 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() - -synID({lnum}, {col}, {trans}) *synID()* - 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") -< - -synIDattr({synID}, {what} [, {mode}]) *synIDattr()* - The result is a String, which is the {what} attribute of - syntax ID {synID}. This can be used to obtain information - about a syntax item. - {mode} can be "gui", "cterm" or "term", to get the attributes - for that mode. When {mode} is omitted, or an invalid value is - used, the attributes for the currently active highlighting are - used (GUI, cterm or term). - Use synIDtrans() to follow linked highlight groups. - {what} result - "name" the name of the syntax item - "fg" foreground color (GUI: color name 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 (as with "fg") |highlight-guisp| - "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 - "strikethrough" "1" if struckthrough - - 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") - -synIDtrans({synID}) *synIDtrans()* - The result is a Number, which is the translated syntax ID of - {synID}. This is the syntax group ID of what is being used to - highlight the character. Highlight links given with - ":highlight link" are followed. - - Can also be used as a |method|: > - :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg") - -synconcealed({lnum}, {col}) *synconcealed()* - 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] - - -synstack({lnum}, {col}) *synstack()* - 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. - -system({cmd} [, {input}]) *system()* *E677* - Gets the output of {cmd} as a |string| (|systemlist()| returns - a |List|) and sets |v:shell_error| to the error code. - {cmd} is treated as in |jobstart()|: - If {cmd} is a List it runs directly (no 'shell'). - If {cmd} is a String it runs in the 'shell', like this: > - :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}']) - -< Not to be used for interactive commands. - - Result is a String, filtered to avoid platform-specific quirks: - - <CR><NL> is replaced with <NL> - - NUL characters are replaced with SOH (0x01) - - Example: > - :echo system(['ls', expand('%:h')]) - -< If {input} is a string it is written to a pipe and passed as - stdin to the command. The string is written as-is, line - separators are not changed. - If {input} is a |List| it is written to the pipe as - |writefile()| does with {binary} set to "b" (i.e. with - a newline between each list item, and newlines inside list - items converted to NULs). - When {input} is given and is a valid buffer id, the content of - the buffer is written to the file line by line, each line - terminated by NL (and NUL where the text has NL). - *E5677* - Note: system() cannot write to or read from backgrounded ("&") - shell commands, e.g.: > - :echo system("cat - &", "foo") -< which is equivalent to: > - $ echo foo | bash -c 'cat - &' -< The pipes are disconnected (unless overridden by shell - redirection syntax) before input can reach it. Use - |jobstart()| instead. - - Note: Use |shellescape()| or |::S| with |expand()| or - |fnamemodify()| to escape special characters in a command - argument. 'shellquote' and 'shellxquote' must be properly - configured. Example: > - :echo system('ls '..shellescape(expand('%:h'))) - :echo system('ls '..expand('%:h:S')) - -< 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() - -systemlist({cmd} [, {input} [, {keepempty}]]) *systemlist()* - 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 a final newline is not preserved, - unless {keepempty} is non-zero. - 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 split(system('echo hello'), '\n', 1) -< - Returns an empty string on error. - - Can also be used as a |method|: > - :echo GetCmd()->systemlist() - -tabpagebuflist([{arg}]) *tabpagebuflist()* - 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() - -tabpagenr([{arg}]) *tabpagenr()* - 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<Tab>| goes to). If there is no previous - tab page, 0 is returned. - The number can be used with the |:tab| command. - - -tabpagewinnr({tabarg} [, {arg}]) *tabpagewinnr()* - 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() -< - *tagfiles()* -tagfiles() Returns a |List| with the file names used to search for tags - for the current buffer. This is the 'tags' option expanded. - - -taglist({expr} [, {filename}]) *taglist()* - 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() - -tempname() *tempname()* *temp-file-name* - The result is a String, which is the name of a file that - doesn't exist. It can be used for a temporary file. 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 '-'. - -termopen({cmd}[, {opts}]) *termopen()* - Spawns {cmd} in a new pseudo-terminal session connected - to the current buffer. {cmd} is the same as the one passed to - |jobstart()|. This function fails if the current buffer is - modified (all buffer contents are destroyed). - - The {opts} dict is similar to the one passed to |jobstart()|, - but the `pty`, `width`, `height`, and `TERM` fields are - ignored: `height`/`width` are taken from the current window - and `$TERM` is set to "xterm-256color". - Returns the same values as |jobstart()|. - - See |terminal| for more information. - -test_ functions are documented here: |test-functions-details| - -tan({expr}) *tan()* - 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() - -tanh({expr}) *tanh()* - 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() -< - *timer_info()* -timer_info([{id}]) - 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 - "repeat" number of times the timer will still fire; - -1 means forever - "callback" the callback - - Can also be used as a |method|: > - GetTimer()->timer_info() -< -timer_pause({timer}, {paused}) *timer_pause()* - 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) -< - *timer_start()* *timer* *timers* -timer_start({time}, {callback} [, {options}]) - 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. - - {options} is a dictionary. Supported entries: - "repeat" Number of times to repeat the callback. - -1 means forever. Default is 1. - If the timer causes an error three times in a - row the repeat is cancelled. - - Example: > - func MyHandler(timer) - echo 'Handler called' - endfunc - let timer = timer_start(500, 'MyHandler', - \ {'repeat': 3}) -< This invokes MyHandler() three times at 500 msec intervals. - - Can also be used as a |method|: > - GetMsec()->timer_start(callback) - -< Not available in the |sandbox|. - -timer_stop({timer}) *timer_stop()* - 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() -< -timer_stopall() *timer_stopall()* - Stop all timers. The timer callbacks will no longer be - invoked. Useful if some timers is misbehaving. If there are - no timers there is no error. - -tolower({expr}) *tolower()* - The result is a copy of the String given, with all uppercase - characters turned into lowercase (just like applying |gu| to - the string). - - Can also be used as a |method|: > - GetText()->tolower() - -toupper({expr}) *toupper()* - The result is a copy of the String given, with all lowercase - characters turned into uppercase (just like applying |gU| to - the string). - - Can also be used as a |method|: > - GetText()->toupper() - -tr({src}, {fromstr}, {tostr}) *tr()* - 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("<blob>", "<>", "{}") -< returns "{blob}" - - Can also be used as a |method|: > - GetText()->tr(from, to) - -trim({text} [, {mask} [, {dir}]]) *trim()* - 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() - -trunc({expr}) *trunc()* - 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() - -type({expr}) *type()* - 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:true| and |v:false|) - Null: 7 (|v:null|) - 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:true) -< In place of checking for |v:null| type it is better to check - for |v:null| directly as it is the only value of this type: > - :if myvar is v:null -< To check if the v:t_ variables exist use this: > - :if exists('v:t_number') - -< Can also be used as a |method|: > - mylist->type() - -undofile({name}) *undofile()* - 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|. - - Can also be used as a |method|: > - GetFilename()->undofile() - -undotree() *undotree()* - 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. - -uniq({list} [, {func} [, {dict}]]) *uniq()* *E882* - 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() - -values({dict}) *values()* - 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() - -virtcol({expr}) *virtcol()* - The result is a Number, which is the screen column of the file - position given with {expr}. That is, the last screen position - occupied by the character at that position, when the screen - would be of unlimited width. When there is a <Tab> at the - position, the returned Number will be the column at the end of - the <Tab>. For example, for a <Tab> in column 1, with 'ts' - set to 8, it returns 8. |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 <Tab> 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() - -visualmode([{expr}]) *visualmode()* - 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 "<CTRL-V>" (a single CTRL-V character) for - character-wise, line-wise, or block-wise Visual mode - respectively. - Example: > - :exe "normal " . visualmode() -< This enters the same Visual mode as before. It is also useful - in scripts if you wish to act differently depending on the - Visual mode that was used. - 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|. - -wait({timeout}, {condition}[, {interval}]) *wait()* - Waits until {condition} evaluates to |TRUE|, where {condition} - is a |Funcref| or |string| containing an expression. - - {timeout} is the maximum waiting time in milliseconds, -1 - means forever. - - Condition is evaluated on user events, internal events, and - every {interval} milliseconds (default: 200). - - Returns a status integer: - 0 if the condition was satisfied before timeout - -1 if the timeout was exceeded - -2 if the function was interrupted (by |CTRL-C|) - -3 if an error occurred - -wildmenumode() *wildmenumode()* - 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 <c-j> work like <down> in wildmode, use: > - :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>" -< - (Note, this needs the 'wildcharm' option set appropriately). - -win_execute({id}, {command} [, {silent}]) *win_execute()* - Like `execute()` but in the context of window {id}. - The window will temporarily be made the current window, - without triggering autocommands or changing directory. When - executing {command} autocommands will be triggered, this may - have unexpected side effects. Use |:noautocmd| if needed. - Example: > - call win_execute(winid, 'syntax enable') -< - Can also be used as a |method|, the base is passed as the - second argument: > - GetCommand()->win_execute(winid) - -win_findbuf({bufnr}) *win_findbuf()* - 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() - -win_getid([{win} [, {tab}]]) *win_getid()* - 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() - -win_gettype([{nr}]) *win_gettype()* - 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". - - Can also be used as a |method|: > - GetWinid()->win_gettype() -< -win_gotoid({expr}) *win_gotoid()* - 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() - -win_id2tabwin({expr}) *win_id2tabwin()* - 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() - -win_id2win({expr}) *win_id2win()* - 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() - -win_screenpos({nr}) *win_screenpos()* - 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() -< -win_splitmove({nr}, {target} [, {options}]) *win_splitmove()* - 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) -< - *winbufnr()* -winbufnr({nr}) 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() -< - *wincol()* -wincol() The result is a Number, which is the virtual column of the - cursor in the window. This is counting screen cells from the - left side of the window. The leftmost column is one. - - *windowsversion()* -windowsversion() - 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. - -winheight({nr}) *winheight()* - 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() -< -winlayout([{tabnr}]) *winlayout()* - 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() -< - *winline()* -winline() The result is a Number, which is the screen line of the cursor - in the window. This is counting screen lines from the top of - the window. The first line is one. - If the cursor was moved the view on the file will be updated - first, this may cause a scroll. - - *winnr()* -winnr([{arg}]) 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() -< - *winrestcmd()* -winrestcmd() 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 -< - *winrestview()* -winrestview({dict}) - 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() -< - *winsaveview()* -winsaveview() 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. - - -winwidth({nr}) *winwidth()* - 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() - -wordcount() *wordcount()* - 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) - - - *writefile()* -writefile({object}, {fname} [, {flags}]) - 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" fsync() call is not used, with "s" - it is used, 'fsync' option applies by default. No fsync() - means that writefile() will finish faster, but writes may be - left in OS buffers and not yet written to disk. Such changes - will disappear if system crashes before OS does writing. - - 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") - -xor({expr}, {expr}) *xor()* - 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) -< - - *string-match* -Matching a pattern in a String - -A regexp pattern as explained at |pattern| is normally used to find a match in -the buffer lines. When a pattern is used to find a match in a String, almost -everything works in the same way. The difference is that a String is handled -like it is one line. When it contains a "\n" character, this is not seen as a -line break for the pattern. It can be matched with a "\n" in the pattern, or -with ".". Example: > - :let a = "aaaa\nxxxx" - :echo matchstr(a, "..\n..") - aa - xx - :echo matchstr(a, "a.x") - a - x - -Don't forget that "^" will only match at the first character of the String and -"$" at the last character of the string. They don't match after or before a -"\n". +The alphabetic list of all builtin functions and details are in a separate +help file: |builtin-functions|. ============================================================================== 5. Defining functions *user-function* @@ -11063,7 +2434,7 @@ See |:verbose-cmd| for more information. command, use line breaks instead of |:bar|: > :exe "func Foo()\necho 'foo'\nendfunc" < - *:delf* *:delfunction* *E130* *E131* *E933* + *:delf* *:delfunction* *E131* *E933* :delf[unction][!] {name} Delete function {name}. {name} can also be a |Dictionary| entry that is a @@ -11160,9 +2531,9 @@ Example: > : echohl Title : echo a:title : echohl None - : echo a:0 . " items:" + : echo a:0 .. " items:" : for s in a:000 - : echon ' ' . s + : echon ' ' .. s : endfor :endfunction @@ -11201,7 +2572,7 @@ This function can then be called with: > this works: *function-range-example* > :function Mynumber(arg) - : echo line(".") . " " . a:arg + : echo line(".") .. " " .. a:arg :endfunction :1,5call Mynumber(getline(".")) < @@ -11212,7 +2583,7 @@ This function can then be called with: > Example of a function that handles the range itself: > :function Cont() range - : execute (a:firstline + 1) . "," . a:lastline . 's/^/\t\\ ' + : execute (a:firstline + 1) .. "," .. a:lastline .. 's/^/\t\\ ' :endfunction :4,8call Cont() < @@ -11374,7 +2745,7 @@ This does NOT work: > This cannot be used to add an item to a |List|. This cannot be used to set a byte in a String. You can do that like this: > - :let var = var[0:2] . 'X' . var[4:] + :let var = var[0:2] .. 'X' .. var[4:] < When {var-name} is a |Blob| then {idx} can be the length of the blob, in which case one byte is appended. @@ -11436,7 +2807,7 @@ This does NOT work: > is just like using the |:set| command: both the local value and the global value are changed. Example: > - :let &path = &path . ',/usr/local/include' + :let &path = &path .. ',/usr/local/include' :let &{option-name} .= {expr1} For a string option: Append {expr1} to the value. @@ -11693,6 +3064,8 @@ text... :if {expr1} *:if* *:end* *:endif* *:en* *E171* *E579* *E580* :en[dif] Execute the commands until the next matching ":else" or ":endif" if {expr1} evaluates to non-zero. + Although the short forms work, it is recommended to + always use `:endif` to avoid confusion. From Vim version 4.5 until 5.0, every Ex command in between the ":if" and ":endif" is ignored. These two @@ -12290,7 +3663,7 @@ exception most recently caught as long it is not finished. :function! Caught() : if v:exception != "" - : echo 'Caught "' . v:exception . '" in ' . v:throwpoint + : echo 'Caught "' .. v:exception .. '" in ' .. v:throwpoint : else : echo 'Nothing caught' : endif @@ -12693,8 +4066,8 @@ a script in order to catch unexpected things. :catch /^Vim:Interrupt$/ : echo "Script interrupted" :catch /.*/ - : echo "Internal error (" . v:exception . ")" - : echo " - occurred at " . v:throwpoint + : echo "Internal error (" .. v:exception .. ")" + : echo " - occurred at " .. v:throwpoint :endtry :" end of script @@ -12890,7 +4263,7 @@ parentheses can be cut out from |v:exception| with the ":substitute" command. :function! CheckRange(a, func) : if a:a < 0 - : throw "EXCEPT:MATHERR:RANGE(" . a:func . ")" + : throw "EXCEPT:MATHERR:RANGE(" .. a:func .. ")" : endif :endfunction : @@ -12917,7 +4290,7 @@ parentheses can be cut out from |v:exception| with the ":substitute" command. : try : execute "write" fnameescape(a:file) : catch /^Vim(write):/ - : throw "EXCEPT:IO(" . getcwd() . ", " . a:file . "):WRITEERR" + : throw "EXCEPT:IO(" .. getcwd() .. ", " .. a:file .. "):WRITEERR" : endtry :endfunction : @@ -12936,9 +4309,9 @@ parentheses can be cut out from |v:exception| with the ":substitute" command. : let dir = substitute(v:exception, '.*(\(.\+\),\s*.\+).*', '\1', "") : let file = substitute(v:exception, '.*(.\+,\s*\(.\+\)).*', '\1', "") : if file !~ '^/' - : let file = dir . "/" . file + : let file = dir .. "/" .. file : endif - : echo 'I/O error for "' . file . '"' + : echo 'I/O error for "' .. file .. '"' : :catch /^EXCEPT/ : echo "Unspecified error" @@ -13006,7 +4379,7 @@ clauses, however, is executed. : echo "inner finally" : endtry :catch - : echo 'outer catch-all caught "' . v:exception . '"' + : echo 'outer catch-all caught "' .. v:exception .. '"' : finally : echo "outer finally" :endtry @@ -13068,7 +4441,7 @@ Printing in Binary ~ : let n = a:nr : let r = "" : while n - : let r = '01'[n % 2] . r + : let r = '01'[n % 2] .. r : let n = n / 2 : endwhile : return r @@ -13079,7 +4452,7 @@ Printing in Binary ~ :func String2Bin(str) : let out = '' : for ix in range(strlen(a:str)) - : let out = out . '-' . Nr2Bin(char2nr(a:str[ix])) + : let out = out .. '-' .. Nr2Bin(char2nr(a:str[ix])) : endfor : return out[1:] :endfunc @@ -13153,7 +4526,7 @@ code can be used: > unlet scriptnames_output ============================================================================== -The sandbox *eval-sandbox* *sandbox* *E48* +The sandbox *eval-sandbox* *sandbox* The 'foldexpr', 'formatexpr', 'includeexpr', 'indentexpr', 'statusline' and 'foldtext' options may be evaluated in a sandbox. This means that you are @@ -13162,6 +4535,7 @@ safety for when these options are set from a modeline. It is also used when the command from a tags file is executed and for CTRL-R = in the command line. The sandbox is also used for the |:sandbox| command. + *E48* These items are not allowed in the sandbox: - changing the buffer text - defining or changing mapping, autocommands, user commands diff --git a/runtime/doc/filetype.txt b/runtime/doc/filetype.txt index bbbe71ec3a..5486c87af9 100644 --- a/runtime/doc/filetype.txt +++ b/runtime/doc/filetype.txt @@ -24,12 +24,21 @@ Each time a new or existing file is edited, Vim will try to recognize the type of the file and set the 'filetype' option. This will trigger the FileType event, which can be used to set the syntax highlighting, set options, etc. -Detail: The ":filetype on" command will load this file: +Detail: The ":filetype on" command will load these files: + $VIMRUNTIME/filetype.lua $VIMRUNTIME/filetype.vim - This file is a Vim script that defines autocommands for the - BufNewFile and BufRead events. If the file type is not found by the - name, the file $VIMRUNTIME/scripts.vim is used to detect it from the - contents of the file. + filetype.lua creates an autocommand that fires for all BufNewFile and + BufRead events. It tries to detect the filetype based off of the + file's extension or name. + + filetype.vim is a Vim script that defines autocommands for the + BufNewFile and BufRead events. In contrast to filetype.lua, this + file creates separate BufNewFile and BufRead events for each filetype + pattern. + + If the file type is not found by the name, the file + $VIMRUNTIME/scripts.vim is used to detect it from the contents of the + file. When the GUI is running or will start soon, the |menu.vim| script is also sourced. See |'go-M'| about avoiding that. @@ -122,14 +131,15 @@ shell script: "#!/bin/csh". argument was used. *filetype-overrule* -When the same extension is used for two filetypes, Vim tries to guess what -kind of file it is. This doesn't always work. A number of global variables -can be used to overrule the filetype used for certain extensions: +When the same extension is used for multiple filetypes, Vim tries to guess +what kind of file it is. This doesn't always work. A number of global +variables can be used to overrule the filetype used for certain extensions: file name variable ~ *.asa g:filetype_asa |ft-aspvbs-syntax| |ft-aspperl-syntax| *.asm g:asmsyntax |ft-asm-syntax| *.asp g:filetype_asp |ft-aspvbs-syntax| |ft-aspperl-syntax| + *.bas g:filetype_bas |ft-basic-syntax| *.fs g:filetype_fs |ft-forth-syntax| *.i g:filetype_i |ft-progress-syntax| *.inc g:filetype_inc @@ -149,9 +159,10 @@ is used. The default value is set like this: > This means that the contents of compressed files are not inspected. *new-filetype* -If a file type that you want to use is not detected yet, there are four ways -to add it. In any way, it's better not to modify the $VIMRUNTIME/filetype.vim -file. It will be overwritten when installing a new version of Vim. +If a file type that you want to use is not detected yet, there are a few ways +to add it. In any way, it's better not to modify the $VIMRUNTIME/filetype.lua +or $VIMRUNTIME/filetype.vim files. They will be overwritten when installing a +new version of Nvim. A. If you want to overrule all default file type checks. This works by writing one file for each filetype. The disadvantage is that @@ -191,7 +202,7 @@ B. If you want to detect your file after the default file type checks. au BufRead,BufNewFile * if &ft == 'pascal' | set ft=mypascal | endif -C. If your file type can be detected by the file name. +C. If your file type can be detected by the file name or extension. 1. Create your user runtime directory. You would normally use the first item of the 'runtimepath' option. Example for Unix: > :!mkdir -p ~/.config/nvim @@ -206,9 +217,38 @@ C. If your file type can be detected by the file name. au! BufRead,BufNewFile *.mine setfiletype mine au! BufRead,BufNewFile *.xyz setfiletype drawing augroup END -< Write this file as "filetype.vim" in your user runtime directory. For +< + Write this file as "filetype.vim" in your user runtime directory. For example, for Unix: > :w ~/.config/nvim/filetype.vim +< + Alternatively, create a file called "filetype.lua" that adds new + filetypes. + Example: > + vim.filetype.add({ + extension = { + foo = "fooscript", + }, + filename = { + [".foorc"] = "foorc", + }, + pattern = { + [".*/etc/foo/.*%.conf"] = "foorc", + }, + }) +< + See |vim.filetype.add()|. + *g:do_filetype_lua* + For now, Lua filetype detection is opt-in. You can enable it by adding + the following to your |init.vim|: > + let g:do_filetype_lua = 1 +< *g:did_load_filetypes* + In either case, the builtin filetype detection provided by Nvim can be + disabled by setting the did_load_filetypes global variable. If this + variable exists, $VIMRUNTIME/filetype.vim will not run. + Example: > + " Disable filetype.vim + let g:did_load_filetypes = 1 < 3. To use the new filetype detection you must restart Vim. @@ -245,9 +285,9 @@ D. If your filetype can only be detected by inspecting the contents of the $VIMRUNTIME/scripts.vim. *remove-filetype* -If a file type is detected that is wrong for you, install a filetype.vim or -scripts.vim to catch it (see above). You can set 'filetype' to a non-existing -name to avoid that it will be set later anyway: > +If a file type is detected that is wrong for you, install a filetype.lua, +filetype.vim or scripts.vim to catch it (see above). You can set 'filetype' to +a non-existing name to avoid that it will be set later anyway: > :set filetype=ignored If you are setting up a system with many users, and you don't want each user @@ -314,12 +354,12 @@ define yourself. There are a few ways to avoid this: You need to define your own mapping before the plugin is loaded (before editing a file of that type). The plugin will then skip installing the default mapping. - *no_mail_maps* + *no_mail_maps* *g:no_mail_maps* 3. Disable defining mappings for a specific filetype by setting a variable, which contains the name of the filetype. For the "mail" filetype this would be: > :let no_mail_maps = 1 -< *no_plugin_maps* +< *no_plugin_maps* *g:no_plugin_maps* 4. Disable defining mappings for all filetypes by setting a variable: > :let no_plugin_maps = 1 < diff --git a/runtime/doc/fold.txt b/runtime/doc/fold.txt index 80c934d13b..9e3d78faff 100644 --- a/runtime/doc/fold.txt +++ b/runtime/doc/fold.txt @@ -497,11 +497,13 @@ Note the use of backslashes to avoid some characters to be interpreted by the :function MyFoldText() : let line = getline(v:foldstart) : let sub = substitute(line, '/\*\|\*/\|{{{\d\=', '', 'g') - : return v:folddashes . sub + : return v:folddashes .. sub :endfunction Evaluating 'foldtext' is done in the |sandbox|. The current window is set to -the window that displays the line. Errors are ignored. +the window that displays the line. + +Errors are ignored. For debugging set the 'debug' option to "throw". The default value is |foldtext()|. This returns a reasonable text for most types of folding. If you don't like it, you can specify your own 'foldtext' diff --git a/runtime/doc/ft_raku.txt b/runtime/doc/ft_raku.txt index 00b140ee9c..3d1179ed4e 100644 --- a/runtime/doc/ft_raku.txt +++ b/runtime/doc/ft_raku.txt @@ -47,20 +47,20 @@ Numbers, subscripts and superscripts are available with 's' and 'S': But some don't come defined by default. Those are digraph definitions you can add in your ~/.vimrc file. > - exec 'digraph \\ '.char2nr('∖') - exec 'digraph \< '.char2nr('≼') - exec 'digraph \> '.char2nr('≽') - exec 'digraph (L '.char2nr('⊈') - exec 'digraph )L '.char2nr('⊉') - exec 'digraph (/ '.char2nr('⊄') - exec 'digraph )/ '.char2nr('⊅') - exec 'digraph )/ '.char2nr('⊅') - exec 'digraph U+ '.char2nr('⊎') - exec 'digraph 0- '.char2nr('⊖') + exec 'digraph \\ ' .. char2nr('∖') + exec 'digraph \< ' .. char2nr('≼') + exec 'digraph \> ' .. char2nr('≽') + exec 'digraph (L ' .. char2nr('⊈') + exec 'digraph )L ' .. char2nr('⊉') + exec 'digraph (/ ' .. char2nr('⊄') + exec 'digraph )/ ' .. char2nr('⊅') + exec 'digraph )/ ' .. char2nr('⊅') + exec 'digraph U+ ' .. char2nr('⊎') + exec 'digraph 0- ' .. char2nr('⊖') " Euler's constant - exec 'digraph ne '.char2nr('𝑒') + exec 'digraph ne ' .. char2nr('𝑒') " Raku's atomic operations marker - exec 'digraph @@ '.char2nr('⚛') + exec 'digraph @@ ' .. char2nr('⚛') Alternatively, you can write Insert mode abbreviations that convert ASCII- based operators into their single-character Unicode equivalent. > diff --git a/runtime/doc/ft_rust.txt b/runtime/doc/ft_rust.txt index ff2e0ca56f..5c8782ec7a 100644 --- a/runtime/doc/ft_rust.txt +++ b/runtime/doc/ft_rust.txt @@ -26,7 +26,7 @@ behavior of the plugin. g:rustc_path~ Set this option to the path to rustc for use in the |:RustRun| and |:RustExpand| commands. If unset, "rustc" will be located in $PATH: > - let g:rustc_path = $HOME."/bin/rustc" + let g:rustc_path = $HOME .. "/bin/rustc" < *g:rustc_makeprg_no_percent* @@ -87,7 +87,7 @@ g:rust_bang_comment_leader~ g:ftplugin_rust_source_path~ Set this option to a path that should be prepended to 'path' for Rust source files: > - let g:ftplugin_rust_source_path = $HOME.'/dev/rust' + let g:ftplugin_rust_source_path = $HOME .. '/dev/rust' < *g:rustfmt_command* diff --git a/runtime/doc/ft_sql.txt b/runtime/doc/ft_sql.txt index 53a99a9e1d..fccbbce17f 100644 --- a/runtime/doc/ft_sql.txt +++ b/runtime/doc/ft_sql.txt @@ -109,8 +109,8 @@ must be configurable. The filetype plugin attempts to define many of the standard objects, plus many additional ones. In order to make this as flexible as possible, you can override the list of objects from within your |vimrc| with the following: > - let g:ftplugin_sql_objects = 'function,procedure,event,table,trigger' . - \ ',schema,service,publication,database,datatype,domain' . + let g:ftplugin_sql_objects = 'function,procedure,event,table,trigger' .. + \ ',schema,service,publication,database,datatype,domain' .. \ ',index,subscription,synchronization,view,variable' The following |Normal| mode and |Visual| mode maps have been created which use @@ -131,10 +131,10 @@ Repeatedly pressing ]} will cycle through each of these create statements: > create index i1 on t1 (c1); The default setting for g:ftplugin_sql_objects is: > - let g:ftplugin_sql_objects = 'function,procedure,event,' . - \ '\\(existing\\\\|global\\s\\+temporary\\s\\+\\)\\\{,1}' . - \ 'table,trigger' . - \ ',schema,service,publication,database,datatype,domain' . + let g:ftplugin_sql_objects = 'function,procedure,event,' .. + \ '\\(existing\\\\|global\\s\\+temporary\\s\\+\\)\\\{,1}' .. + \ 'table,trigger' .. + \ ',schema,service,publication,database,datatype,domain' .. \ ',index,subscription,synchronization,view,variable' The above will also handle these cases: > diff --git a/runtime/doc/help.txt b/runtime/doc/help.txt index 173d3c0cdf..b97c9a2e3f 100644 --- a/runtime/doc/help.txt +++ b/runtime/doc/help.txt @@ -129,6 +129,7 @@ Advanced editing ~ |diff.txt| working with two to eight versions of the same file |autocmd.txt| automatically executing commands on an event |eval.txt| expression evaluation, conditional commands +|builtin.txt| builtin functions |fold.txt| hide (fold) ranges of lines |lua.txt| Lua API |api.txt| Nvim API via RPC, Lua and VimL diff --git a/runtime/doc/helphelp.txt b/runtime/doc/helphelp.txt index 9cc7d063a8..569995d319 100644 --- a/runtime/doc/helphelp.txt +++ b/runtime/doc/helphelp.txt @@ -219,7 +219,7 @@ command: > < *:helpt* *:helptags* - *E154* *E150* *E151* *E152* *E153* *E670* *E856* + *E150* *E151* *E152* *E153* *E154* *E670* *E856* :helpt[ags] [++t] {dir} Generate the help tags file(s) for directory {dir}. When {dir} is ALL then all "doc" directories in @@ -358,7 +358,7 @@ When referring to a Vim option in the help file, place the option name between two single quotes, eg. 'statusline' When referring to any other technical term, such as a filename or function -parameter, surround it in backticks (`), eg. `~/.path/to/init.vim`. +parameter, surround it in backticks, eg. `~/.path/to/init.vim`. HIGHLIGHTING diff --git a/runtime/doc/if_cscop.txt b/runtime/doc/if_cscop.txt index f05b3bb8ed..8947aefc1b 100644 --- a/runtime/doc/if_cscop.txt +++ b/runtime/doc/if_cscop.txt @@ -40,7 +40,7 @@ See |cscope-usage| to get started. ============================================================================== Cscope commands *cscope-commands* - *:cscope* *:cs* *:scs* *:scscope* *E259* *E262* *E561* *E560* + *:cscope* *:cs* *:scs* *:scscope* *E259* *E262* *E560* *E561* All cscope commands are accessed through suboptions to the cscope commands. `:cscope` or `:cs` is the main command `:scscope` or `:scs` does the same and splits the window diff --git a/runtime/doc/if_pyth.txt b/runtime/doc/if_pyth.txt index fea47de220..9b434e61d7 100644 --- a/runtime/doc/if_pyth.txt +++ b/runtime/doc/if_pyth.txt @@ -1,10 +1,10 @@ *if_pyth.txt* Nvim - VIM REFERENCE MANUAL by Paul Moore + NVIM REFERENCE MANUAL -The Python Interface to Vim *if_pyth* *python* *Python* +The Python Interface to NVim *if_pyth* *python* *Python* See |provider-python| for more information. @@ -134,7 +134,7 @@ Instead, put the Python command in a function and call that function: Note that "EOF" must be at the start of the line. ============================================================================== -The vim module *python-vim* *python2* +The vim module *python-vim* Python code gets all of its access to vim (with one exception - see |python-output| below) via the "vim" module. The vim module implements two @@ -322,14 +322,13 @@ Output from Python *python-output* supported, and may cause the program to crash. This should probably be fixed. - *python2-directory* *python3-directory* *pythonx-directory* + *python3-directory* *pythonx-directory* Python 'runtimepath' handling *python-special-path* In python vim.VIM_SPECIAL_PATH special directory is used as a replacement for the list of paths found in 'runtimepath': with this directory in sys.path and vim.path_hooks in sys.path_hooks python will try to load module from -{rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for -each {rtp} found in 'runtimepath'. +{rtp}/python3 and {rtp}/pythonx for each {rtp} found in 'runtimepath'. Implementation is similar to the following, but written in C: > @@ -401,8 +400,8 @@ vim._get_paths *python-_get_paths* hook. You should not rely on this method being present in future versions, but can use it for debugging. - It returns a list of {rtp}/python2 (or {rtp}/python3) and - {rtp}/pythonx directories for each {rtp} in 'runtimepath'. + It returns a list of {rtp}/python3 and {rtp}/pythonx + directories for each {rtp} in 'runtimepath'. ============================================================================== Buffer objects *python-buffer* @@ -590,6 +589,11 @@ functions to evaluate Python expressions and pass their values to Vim script. ============================================================================== Python 3 *python3* +As Python 3 is the only supported version in Nvim, "python" is synonymous +with "python3" in the current version. However, code that aims to support older +versions of Neovim, as well as Vim, should prefer to use "python3" +variants explicitly if Python 3 is required. + *:py3* *:python3* :[range]py3 {stmt} :[range]py3 << [endmarker] @@ -619,31 +623,26 @@ Raising SystemExit exception in python isn't endorsed way to quit vim, use: > :py vim.command("qall!") < *has-python* -You can test what Python version is available with: > - if has('python') - echo 'there is Python 2.x' +You can test if Python is available with: > + if has('pythonx') + echo 'there is Python' endif if has('python3') echo 'there is Python 3.x' endif +Python 2 is no longer supported. Thus `has('python')` always returns +zero for backwards compatibility reasons. + ============================================================================== Python X *python_x* *pythonx* -Because most python code can be written so that it works with Python 2.6+ and -Python 3, the pyx* functions and commands have been written. They work the -same as the Python 2 and 3 variants, but select the Python version using the -'pyxversion' setting. - -Set 'pyxversion' in your |vimrc| to prefer Python 2 or Python 3 for Python -commands. Changing this setting at runtime risks losing the state of plugins -(such as initialization). - -If you want to use a module, you can put it in the {rtp}/pythonx directory. -See |pythonx-directory|. +The "pythonx" and "pyx" prefixes were introduced for python code which +works with Python 2.6+ and Python 3. As Nvim only supports Python 3, +all these commands are now synonymous to their "python3" equivalents. *:pyx* *:pythonx* -`:pyx` and `:pythonx` work similar to `:python`. To check if `:pyx` works: > +`:pyx` and `:pythonx` work the same as `:python3`. To check if `:pyx` works: > :pyx print("Hello") To see what version of Python is being used: > @@ -651,33 +650,15 @@ To see what version of Python is being used: > :pyx print(sys.version) < *:pyxfile* *python_x-special-comments* -`:pyxfile` works similar to `:pyfile`. But you can add a "shebang" comment to -force Vim to use `:pyfile` or `:py3file`: > - #!/any string/python2 " Shebang. Must be the first line of the file. - #!/any string/python3 " Shebang. Must be the first line of the file. - # requires python 2.x " Maximum lines depend on 'modelines'. - # requires python 3.x " Maximum lines depend on 'modelines'. -Unlike normal modelines, the bottom of the file is not checked. -If none of them are found, the 'pyxversion' option is used. - *W20* *W21* -If Vim does not support the selected Python version a silent message will be -printed. Use `:messages` to read them. +`:pyxfile` works the same as `:py3file`. *:pyxdo* -`:pyxdo` works similar to `:pydo`. +`:pyxdo` works the same as `:py3do`. *has-pythonx* -To check if pyx* functions and commands are available: > +To check if `pyx*` functions and commands are available: > if has('pythonx') - echo 'pyx* commands are available. (Python ' . &pyx . ')' - endif - -If you prefer Python 2 and want to fallback to Python 3, set 'pyxversion' -explicitly in your |.vimrc|. Example: > - if has('python') - set pyx=2 - elseif has('python3') - set pyx=3 + echo 'pyx* commands are available. (Python ' .. &pyx .. ')' endif ============================================================================== diff --git a/runtime/doc/indent.txt b/runtime/doc/indent.txt index 1b42092616..d0d4ddad32 100644 --- a/runtime/doc/indent.txt +++ b/runtime/doc/indent.txt @@ -771,6 +771,15 @@ You can set the indent for the first line after <script> and <style> "auto" auto indent (same indent as the blocktag) "inc" auto indent + one indent step +You can set the indent for attributes after an open <tag line: > + + :let g:html_indent_attribute = 1 +< + VALUE MEANING ~ + 1 auto indent, one indent step more than <tag + 2 auto indent, two indent steps (default) + > 2 auto indent, more indent steps + Many tags increase the indent for what follows per default (see "Add Indent Tags" in the script). You can add further tags with: > @@ -872,7 +881,7 @@ For example, with N = 1, this will give: *PHP_outdentphpescape* To indent PHP escape tags as the surrounding non-PHP code (only affects the PHP escape tags): > -:let g:PHP_outdentphpescape = 0 + :let g:PHP_outdentphpescape = 0 ------------- *PHP_removeCRwhenUnix* @@ -1199,7 +1208,7 @@ comments will be indented according to the correctly indented code. VIM *ft-vim-indent* - + *g:vim_indent_cont* For indenting Vim scripts there is one variable that specifies the amount of indent for a continuation line, a line that starts with a backslash: > diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt index d8689e2c65..d02ab1b759 100644 --- a/runtime/doc/index.txt +++ b/runtime/doc/index.txt @@ -353,6 +353,7 @@ tag char note action in Normal mode ~ register x] |Y| ["x]Y yank N lines [into register x]; synonym for "yy" + Note: Mapped to "y$" by default. |default-mappings| |ZZ| ZZ write if buffer changed and close window |ZQ| ZQ close window without writing |[| [{char} square bracket command (see |[| below) @@ -923,7 +924,9 @@ tag command note action in Visual mode ~ before the highlighted area |v_J| J 2 join the highlighted lines |v_K| K run 'keywordprg' on the highlighted area -|v_O| O Move horizontally to other corner of area. +|v_O| O move horizontally to other corner of area +|v_P| P replace highlighted area with register + contents; unnamed register is unchanged Q does not start Ex mode |v_R| R 2 delete the highlighted lines and start insert @@ -986,6 +989,8 @@ tag command note action in Visual mode ~ |v_i{| i{ same as iB |v_i}| i} same as iB |v_o| o move cursor to other corner of area +|v_p| p replace highlighted area with register + contents; deleted text in unnamed register |v_r| r 2 replace highlighted area with a character |v_s| s 2 delete highlighted area and start insert |v_u| u 2 make highlighted area lowercase diff --git a/runtime/doc/insert.txt b/runtime/doc/insert.txt index fd1d0f8ea6..39682a2ab2 100644 --- a/runtime/doc/insert.txt +++ b/runtime/doc/insert.txt @@ -76,6 +76,8 @@ CTRL-U Delete all entered characters before the cursor in the current line. If there are no newly entered characters and 'backspace' is not empty, delete all characters before the cursor in the current line. + If C-indenting is enabled the indent will be adjusted if the + line becomes blank. See |i_backspacing| about joining lines. *i_CTRL-U-default* By default, sets a new undo point before deleting. @@ -828,7 +830,7 @@ space is preferred). Maximum line length is 510 bytes. For an example, imagine the 'thesaurus' file has a line like this: > angry furious mad enraged -<Placing the cursor after the letters "ang" and typing CTRL-X CTRL-T would +Placing the cursor after the letters "ang" and typing CTRL-X CTRL-T would complete the word "angry"; subsequent presses would change the word to "furious", "mad" etc. @@ -840,7 +842,7 @@ https://github.com/vim/vim/issues/629#issuecomment-443293282 Unpack thesaurus_pkg.zip, put the thesaurus.txt file somewhere, e.g. ~/.vim/thesaurus/english.txt, and the 'thesaurus' option to this file name. - + Completing keywords with 'thesaurusfunc' *compl-thesaurusfunc* If the 'thesaurusfunc' option is set, then the user specified function is @@ -862,7 +864,7 @@ Groß): > else let res = [] let h = '' - for l in split(system('aiksaurus '.shellescape(a:base)), '\n') + for l in split(system('aiksaurus ' .. shellescape(a:base)), '\n') if l[:3] == '=== ' let h = substitute(l[4:], ' =*$', '', '') elseif l[0] =~ '\a' @@ -1197,7 +1199,7 @@ An example that completes the names of the months: > " find months matching with "a:base" let res = [] for m in split("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec") - if m =~ '^' . a:base + if m =~ '^' .. a:base call add(res, m) endif endfor @@ -1219,7 +1221,7 @@ The same, but now pretending searching for matches is slow: > else " find months matching with "a:base" for m in split("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec") - if m =~ '^' . a:base + if m =~ '^' .. a:base call complete_add(m) endif sleep 300m " simulate searching for next match @@ -1878,6 +1880,9 @@ When 'autoindent' is on, the indent for a new line is obtained from the previous line. When 'smartindent' or 'cindent' is on, the indent for a line is automatically adjusted for C programs. +'formatoptions' can be set to copy the comment leader when opening a new +line. + 'textwidth' can be set to the maximum width for a line. When a line becomes too long when appending characters a line break is automatically inserted. diff --git a/runtime/doc/intro.txt b/runtime/doc/intro.txt index 0e0156ac6b..54999fa163 100644 --- a/runtime/doc/intro.txt +++ b/runtime/doc/intro.txt @@ -322,7 +322,6 @@ notation meaning equivalent decimal value(s) ~ <Bar> vertical bar | 124 *<Bar>* <Del> delete 127 <CSI> command sequence intro ALT-Esc 155 *<CSI>* -<xCSI> CSI when typed in the GUI *<xCSI>* <EOL> end-of-line (can be <CR>, <NL> or <CR><NL>, depends on system and 'fileformat') *<EOL>* diff --git a/runtime/doc/lsp-extension.txt b/runtime/doc/lsp-extension.txt index d13303ada6..6e9ad940c7 100644 --- a/runtime/doc/lsp-extension.txt +++ b/runtime/doc/lsp-extension.txt @@ -60,7 +60,7 @@ The example will: return nil end local dir = bufname - -- Just in case our algo is buggy, don't infinite loop. + -- Just in case our algorithm is buggy, don't infinite loop. for _ = 1, 100 do local did_change dir, did_change = dirname(dir) diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index a3929aeab9..d717759444 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -214,7 +214,7 @@ For |lsp-request|, each |lsp-handler| has this signature: > request, a table with information about the error is sent. Otherwise, it is `nil`. See |lsp-response|. {result} (Result | Params | nil) - When the language server is able to succesfully + When the language server is able to successfully complete a request, this contains the `result` key of the response. See |lsp-response|. {ctx} (table) @@ -236,7 +236,7 @@ For |lsp-request|, each |lsp-handler| has this signature: > {config} (table) Configuration for the handler. - Each handler can define it's own configuration + Each handler can define its own configuration table that allows users to customize the behavior of a particular handler. @@ -274,7 +274,7 @@ For |lsp-notification|, each |lsp-handler| has this signature: > {config} (table) Configuration for the handler. - Each handler can define it's own configuration + Each handler can define its own configuration table that allows users to customize the behavior of a particular handler. @@ -369,7 +369,7 @@ Handlers can be set by: For example: > vim.lsp.start_client { - ..., -- Other configuration ommitted. + ..., -- Other configuration omitted. handlers = { ["textDocument/definition"] = my_custom_server_definition }, @@ -394,6 +394,9 @@ in the following order: 2. Handler defined in |vim.lsp.start_client()|, if any. 3. Handler defined in |vim.lsp.handlers|, if any. + *vim.lsp.log_levels* +Log levels are defined in |vim.log.levels| + VIM.LSP.PROTOCOL *vim.lsp.protocol* @@ -444,7 +447,7 @@ LspCodeLens |nvim_buf_set_extmark()|. LspCodeLensSeparator *hl-LspCodeLensSeparator* - Used to color the seperator between two or more code lens. + Used to color the separator between two or more code lens. *lsp-highlight-signature* @@ -746,8 +749,8 @@ omnifunc({findstart}, {base}) *vim.lsp.omnifunc()* set_log_level({level}) *vim.lsp.set_log_level()* Sets the global log level for LSP logging. - Levels by name: "trace", "debug", "info", "warn", "error" - Level numbers begin with "trace" at 0 + Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR" + Level numbers begin with "TRACE" at 0 Use `lsp.log_levels` for reverse lookup. @@ -835,10 +838,10 @@ start_client({config}) *vim.lsp.start_client()* throws an error. `code` is a number describing the error. Other arguments may be passed depending on the error - kind. See |vim.lsp.client_errors| for - possible errors. Use - `vim.lsp.client_errors[code]` to get - human-friendly name. + kind. See |vim.lsp.rpc.client_errors| + for possible errors. Use + `vim.lsp.rpc.client_errors[code]` to + get human-friendly name. {before_init} Callback with parameters (initialize_params, config) invoked before the LSP "initialize" phase, @@ -1005,7 +1008,7 @@ document_highlight() *vim.lsp.buf.document_highlight()* Send request to the server to resolve document highlights for the current text document position. This request can be triggered by a key mapping or by events such as `CursorHold` , - eg: + e.g.: > autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight() autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight() @@ -1021,11 +1024,12 @@ document_symbol() *vim.lsp.buf.document_symbol()* Lists all symbols in the current buffer in the quickfix window. -execute_command({command}) *vim.lsp.buf.execute_command()* +execute_command({command_params}) *vim.lsp.buf.execute_command()* Executes an LSP server command. Parameters: ~ - {command} A valid `ExecuteCommandParams` object + {command_params} table A valid `ExecuteCommandParams` + object See also: ~ https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand @@ -1221,8 +1225,8 @@ on_publish_diagnostics({_}, {result}, {ctx}, {config}) }, -- Use a function to dynamically turn signs off -- and on, using buffer local variables - signs = function(bufnr, client_id) - return vim.bo[bufnr].show_signs == false + signs = function(namespace, bufnr) + return vim.b[bufnr].show_signs == true end, -- Disable a feature update_in_insert = false, @@ -1301,7 +1305,7 @@ hover({_}, {result}, {ctx}, {config}) *vim.lsp.handlers.hover()* {config} table Configuration table. • border: (default=nil) • Add borders to the floating window - • See |vim.api.nvim_open_win()| + • See |nvim_open_win()| *vim.lsp.handlers.signature_help()* signature_help({_}, {result}, {ctx}, {config}) @@ -1328,7 +1332,7 @@ signature_help({_}, {result}, {ctx}, {config}) Lua module: vim.lsp.util *lsp-util* *vim.lsp.util.apply_text_document_edit()* -apply_text_document_edit({text_document_edit}, {index}) +apply_text_document_edit({text_document_edit}, {index}, {offset_encoding}) Applies a `TextDocumentEdit` , which is a list of changes to a single document. @@ -1348,18 +1352,19 @@ apply_text_edits({text_edits}, {bufnr}, {offset_encoding}) Parameters: ~ {text_edits} table list of `TextEdit` objects {bufnr} number Buffer id - {offset_encoding} string utf-8|utf-16|utf-32|nil defaults - to encoding of first client of `bufnr` + {offset_encoding} string utf-8|utf-16|utf-32 defaults to + encoding of first client of `bufnr` See also: ~ https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit *vim.lsp.util.apply_workspace_edit()* -apply_workspace_edit({workspace_edit}) +apply_workspace_edit({workspace_edit}, {offset_encoding}) Applies a `WorkspaceEdit` . Parameters: ~ - {workspace_edit} (table) `WorkspaceEdit` + {workspace_edit} table `WorkspaceEdit` + {offset_encoding} string utf-8|utf-16|utf-32 (required) buf_clear_references({bufnr}) *vim.lsp.util.buf_clear_references()* Removes document highlights from a buffer. @@ -1376,9 +1381,7 @@ buf_highlight_references({bufnr}, {references}, {offset_encoding}) {references} table List of `DocumentHighlight` objects to highlight {offset_encoding} string One of "utf-8", "utf-16", - "utf-32", or nil. Defaults to - `offset_encoding` of first client of - `bufnr` + "utf-32". See also: ~ https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#documentHighlight @@ -1467,16 +1470,19 @@ get_effective_tabstop({bufnr}) *vim.lsp.util.get_effective_tabstop()* See also: ~ |softtabstop| -jump_to_location({location}) *vim.lsp.util.jump_to_location()* + *vim.lsp.util.jump_to_location()* +jump_to_location({location}, {offset_encoding}) Jumps to a location. Parameters: ~ - {location} ( `Location` | `LocationLink` ) + {location} table ( `Location` | `LocationLink` ) + {offset_encoding} string utf-8|utf-16|utf-32 (required) Return: ~ `true` if the jump succeeded -locations_to_items({locations}) *vim.lsp.util.locations_to_items()* + *vim.lsp.util.locations_to_items()* +locations_to_items({locations}, {offset_encoding}) Returns the items with the byte position calculated correctly and in sorted order, for display in quickfix and location lists. @@ -1485,8 +1491,10 @@ locations_to_items({locations}) *vim.lsp.util.locations_to_items()* |setqflist()| or |setloclist()|. Parameters: ~ - {locations} (table) list of `Location` s or - `LocationLink` s + {locations} table list of `Location` s or + `LocationLink` s + {offset_encoding} string offset_encoding for locations + utf-8|utf-16|utf-32 Return: ~ (table) list of items diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt index 97062e5986..98af84e1cb 100644 --- a/runtime/doc/lua.txt +++ b/runtime/doc/lua.txt @@ -17,9 +17,9 @@ an idea of what lurks beneath: > :lua print(vim.inspect(package.loaded)) Nvim includes a "standard library" |lua-stdlib| for Lua. It complements the -"editor stdlib" (|functions| and Ex commands) and the |API|, all of which can -be used from Lua code. A good overview of using Lua in neovim is given by -https://github.com/nanotee/nvim-lua-guide. +"editor stdlib" (|builtin-functions| and Ex commands) and the |API|, all of +which can be used from Lua code. A good overview of using Lua in neovim is +given by https://github.com/nanotee/nvim-lua-guide. Module conflicts are resolved by "last wins". For example if both of these are on 'runtimepath': @@ -249,13 +249,15 @@ arguments separated by " " (space) instead of "\t" (tab). *:lua* :[range]lua {chunk} Executes Lua chunk {chunk}. - + if {chunk} starts with "=" the rest of the chunk is + evaluated as an expression and printed. `:lua =expr` + is equivalent to `:lua print(vim.inspect(expr))` Examples: > :lua vim.api.nvim_command('echo "Hello, Nvim!"') < To see the Lua version: > :lua print(_VERSION) < To see the LuaJIT version: > - :lua print(jit.version) + :lua =jit.version < *:lua-heredoc* :[range]lua << [endmarker] @@ -272,7 +274,7 @@ arguments separated by " " (space) instead of "\t" (tab). lua << EOF local linenr = vim.api.nvim_win_get_cursor(0)[1] local curline = vim.api.nvim_buf_get_lines( - 0, linenr, linenr + 1, false)[1] + 0, linenr - 1, linenr, false)[1] print(string.format("Current line [%d] has %d bytes", linenr, #curline)) EOF @@ -566,6 +568,26 @@ Example: TCP echo-server *tcp-server* end) print('TCP echo-server listening on port: '..server:getsockname().port) + +Multithreading *lua-loop-threading* + +Plugins can perform work in separate (os-level) threads using the threading +APIs in luv, for instance `vim.loop.new_thread`. Note that every thread +gets its own separate lua interpreter state, with no access to lua globals +in the main thread. Neither can the state of the editor (buffers, windows, +etc) be directly accessed from threads. + +A subset of the `vim.*` API is available in threads. This includes: + +- `vim.loop` with a separate event loop per thread. +- `vim.mpack` and `vim.json` (useful for serializing messages between threads) +- `require` in threads can use lua packages from the global |lua-package-path| +- `print()` and `vim.inspect` +- `vim.diff` +- most utility functions in `vim.*` for working with pure lua values + like `vim.split`, `vim.tbl_*`, `vim.list_*`, and so on. +- `vim.is_thread()` returns true from a non-main thread. + ------------------------------------------------------------------------------ VIM.HIGHLIGHT *lua-highlight* @@ -593,13 +615,33 @@ vim.highlight.on_yank({opts}) *vim.highlight.on_yank()* - {on_visual} highlight when yanking visual selection (default `true`) - {event} event structure (default |v:event|) -vim.highlight.range({bufnr}, {ns}, {higroup}, {start}, {finish}, {rtype}, {inclusive}) +vim.highlight.range({bufnr}, {ns}, {hlgroup}, {start}, {finish}, {opts}) *vim.highlight.range()* - Highlights the range between {start} and {finish} (tuples of {line,col}) - in buffer {bufnr} with the highlight group {higroup} using the namespace - {ns}. Optional arguments are the type of range (characterwise, linewise, - or blockwise, see |setreg|; default to characterwise) and whether the - range is inclusive (default false). + + Apply highlight group to range of text. + + Parameters: ~ + {bufnr} buffer number + {ns} namespace for highlights + {hlgroup} highlight group name + {start} starting position (tuple {line,col}) + {finish} finish position (tuple {line,col}) + {opts} optional parameters: + • `regtype`: type of range (characterwise, linewise, + or blockwise, see |setreg|), default `'v'` + • `inclusive`: range includes end position, default + `false` + • `priority`: priority of highlight, default + `vim.highlight.user` (see below) + +vim.highlight.priorities *vim.highlight.priorities* + + Table with default priorities used for highlighting: + • `syntax`: `50`, used for standard syntax highlighting + • `treesitter`: `100`, used for tree-sitter-based highlighting + • `diagnostics`: `150`, used for code analysis such as diagnostics + • `user`: `200`, used for user-triggered highlights such as LSP + document symbols or `on_yank` autocommands ------------------------------------------------------------------------------ VIM.REGEX *lua-regex* @@ -791,9 +833,9 @@ vim.stricmp({a}, {b}) *vim.stricmp()* respectively. vim.str_utfindex({str}[, {index}]) *vim.str_utfindex()* - Convert byte index to UTF-32 and UTF-16 indicies. If {index} is not - supplied, the length of the string is used. All indicies are zero-based. - Returns two values: the UTF-32 and UTF-16 indicies respectively. + Convert byte index to UTF-32 and UTF-16 indices. If {index} is not + supplied, the length of the string is used. All indices are zero-based. + Returns two values: the UTF-32 and UTF-16 indices respectively. Embedded NUL bytes are treated as terminating the string. Invalid UTF-8 bytes, and embedded surrogates are counted as one code @@ -913,6 +955,15 @@ vim.types *vim.types* `vim.types.dictionary` will not change or that `vim.types` table will only contain values for these three types. + *log_levels* *vim.log.levels* +Log levels are one of the values defined in `vim.log.levels`: + + vim.log.levels.DEBUG + vim.log.levels.ERROR + vim.log.levels.INFO + vim.log.levels.TRACE + vim.log.levels.WARN + ------------------------------------------------------------------------------ LUA-VIMSCRIPT BRIDGE *lua-vimscript* @@ -1229,19 +1280,32 @@ inspect({object}, {options}) *vim.inspect()* https://github.com/kikito/inspect.lua https://github.com/mpeterv/vinspect -notify({msg}, {log_level}, {opts}) *vim.notify()* - Notification provider +notify({msg}, {level}, {opts}) *vim.notify()* + Display a notification to the user. - Without a runtime, writes to :Messages + This function can be overridden by plugins to display + notifications using a custom provider (such as the system + notification provider). By default, writes to |:messages|. Parameters: ~ - {msg} string Content of the notification to show to - the user - {log_level} number|nil enum from vim.log.levels - {opts} table|nil additional options (timeout, etc) + {msg} string Content of the notification to show to the + user. + {level} number|nil One of the values from + |vim.log.levels|. + {opts} table|nil Optional parameters. Unused by default. - See also: ~ - :help nvim_notify +notify_once({msg}, {level}, {opts}) *vim.notify_once()* + Display a notification only one time. + + Like |vim.notify()|, but subsequent calls with the same + message will not display a notification. + + Parameters: ~ + {msg} string Content of the notification to show to the + user. + {level} number|nil One of the values from + |vim.log.levels|. + {opts} table|nil Optional parameters. Unused by default. on_key({fn}, {ns_id}) *vim.on_key()* Adds Lua function {fn} with namespace id {ns_id} as a listener @@ -1305,6 +1369,18 @@ paste({lines}, {phase}) *vim.paste()* See also: ~ |paste| +pretty_print({...}) *vim.pretty_print()* + Prints given arguments in human-readable format. Example: > + -- Print highlight group Normal and store it's contents in a variable. + local hl_normal = vim.pretty_print(vim.api.nvim_get_hl_by_name("Normal", true)) +< + + Return: ~ + given arguments. + + See also: ~ + |vim.inspect()| + region({bufnr}, {pos1}, {pos2}, {regtype}, {inclusive}) *vim.region()* Get a table of lines with start, end columns for a region marked by two points @@ -1647,16 +1723,25 @@ validate({opt}) *vim.validate()* => error('arg1: expected even number, got 3') < + If multiple types are valid they can be given as a list. > + + vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}} + => NOP (success) + + vim.validate{arg1={1, {'string', table'}}} + => error('arg1: expected string|table, got number') +< + Parameters: ~ - {opt} Map of parameter names to validations. Each key is - a parameter name; each value is a tuple in one of - these forms: + {opt} table of parameter names to validations. Each key + is a parameter name; each value is a tuple in one + of these forms: 1. (arg_value, type_name, optional) • arg_value: argument value - • type_name: string type name, one of: ("table", - "t", "string", "s", "number", "n", "boolean", - "b", "function", "f", "nil", "thread", - "userdata") + • type_name: string|table type name, one of: + ("table", "t", "string", "s", "number", "n", + "boolean", "b", "function", "f", "nil", + "thread", "userdata") or list of them. • optional: (optional) boolean, if true, `nil` is valid @@ -1718,6 +1803,13 @@ Lua module: ui *lua-ui* input({opts}, {on_confirm}) *vim.ui.input()* Prompts the user for input + Example: > + + vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input) + vim.o.shiftwidth = tonumber(input) + end) +< + Parameters: ~ {opts} table Additional options. See |input()| • prompt (string|nil) Text of the prompt. @@ -1741,6 +1833,22 @@ select({items}, {opts}, {on_choice}) *vim.ui.select()* Prompts the user to pick a single item from a collection of entries + Example: > + + vim.ui.select({ 'tabs', 'spaces' }, { + prompt = 'Select tabs or spaces:', + format_item = function(item) + return "I'd like to choose " .. item + end, + }, function(choice) + if choice == 'spaces' then + vim.o.expandtab = true + else + vim.o.expandtab = false + end + end) +< + Parameters: ~ {items} table Arbitrary items {opts} table Additional options @@ -1760,4 +1868,155 @@ select({items}, {opts}, {on_choice}) *vim.ui.select()* 1-based index of `item` within `item` . `nil` if the user aborted the dialog. + +============================================================================== +Lua module: filetype *lua-filetype* + +add({filetypes}) *vim.filetype.add()* + Add new filetype mappings. + + Filetype mappings can be added either by extension or by + filename (either the "tail" or the full file path). The full + file path is checked first, followed by the file name. If a + match is not found using the filename, then the filename is + matched against the list of patterns (sorted by priority) + until a match is found. Lastly, if pattern matching does not + find a filetype, then the file extension is used. + + The filetype can be either a string (in which case it is used + as the filetype directly) or a function. If a function, it + takes the full path and buffer number of the file as arguments + (along with captures from the matched pattern, if any) and + should return a string that will be used as the buffer's + filetype. + + Filename patterns can specify an optional priority to resolve + cases when a file path matches multiple patterns. Higher + priorities are matched first. When omitted, the priority + defaults to 0. + + See $VIMRUNTIME/lua/vim/filetype.lua for more examples. + + Note that Lua filetype detection is only enabled when + |g:do_filetype_lua| is set to 1. + + Example: > + + vim.filetype.add({ + extension = { + foo = "fooscript", + bar = function(path, bufnr) + if some_condition() then + return "barscript" + end + return "bar" + end, + }, + filename = { + [".foorc"] = "toml", + ["/etc/foo/config"] = "toml", + }, + pattern = { + [".*‍/etc/foo/.*"] = "fooscript", + -- Using an optional priority + [".*‍/etc/foo/.*%.conf"] = { "dosini", { priority = 10 } }, + ["README.(%a+)$"] = function(path, bufnr, ext) + if ext == "md" then + return "markdown" + elseif ext == "rst" then + return "rst" + end + end, + }, + }) +< + + Parameters: ~ + {filetypes} table A table containing new filetype maps + (see example). + +match({name}, {bufnr}) *vim.filetype.match()* + Set the filetype for the given buffer from a file name. + + Parameters: ~ + {name} string File name (can be an absolute or relative + path) + {bufnr} number|nil The buffer to set the filetype for. + Defaults to the current buffer. + + +============================================================================== +Lua module: keymap *lua-keymap* + +del({modes}, {lhs}, {opts}) *vim.keymap.del()* + Remove an existing mapping. Examples: > + + vim.keymap.del('n', 'lhs') + + vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 }) +< + + Parameters: ~ + {opts} table A table of optional arguments: + • buffer: (number or boolean) Remove a mapping + from the given buffer. When "true" or 0, use the + current buffer. + + See also: ~ + |vim.keymap.set()| + +set({mode}, {lhs}, {rhs}, {opts}) *vim.keymap.set()* + Add a new |mapping|. Examples: > + + -- Can add mapping to Lua functions + vim.keymap.set('n', 'lhs', function() print("real lua function") end) + + -- Can use it to map multiple modes + vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer=true }) + + -- Can add mapping for specific buffer + vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 }) + + -- Expr mappings + vim.keymap.set('i', '<Tab>', function() + return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>" + end, { expr = true }) + -- <Plug> mappings + vim.keymap.set('n', '[%', '<Plug>(MatchitNormalMultiBackward)') +< + + Note that in a mapping like: > + + vim.keymap.set('n', 'asdf', require('jkl').my_fun) +< + + the require('jkl') gets evaluated during this call in order to + access the function. If you want to avoid this cost at startup + you can wrap it in a function, for example: > + + vim.keymap.set('n', 'asdf', function() return require('jkl').my_fun() end) +< + + Parameters: ~ + {mode} string|table Same mode short names as + |nvim_set_keymap()|. Can also be list of modes to + create mapping on multiple modes. + {lhs} string Left-hand side |{lhs}| of the mapping. + {rhs} string|function Right-hand side |{rhs}| of the + mapping. Can also be a Lua function. + {opts} table A table of |:map-arguments| such as + "silent". In addition to the options listed in + |nvim_set_keymap()|, this table also accepts the + following keys: + • replace_keycodes: (boolean, default true) When + both this and expr is "true", + |nvim_replace_termcodes()| is applied to the + result of Lua expr maps. + • remap: (boolean) Make the mapping recursive. + This is the inverse of the "noremap" option from + |nvim_set_keymap()|. Default `false` . + + See also: ~ + |nvim_set_keymap()| + vim:tw=78:ts=8:ft=help:norl: diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt index 238ef39bd3..8715c3231c 100644 --- a/runtime/doc/map.txt +++ b/runtime/doc/map.txt @@ -65,6 +65,8 @@ modes. where the map command applies. Disallow mapping of {rhs}, to avoid nested and recursive mappings. Often used to redefine a command. + Note: A mapping whose {lhs} starts with <Plug> is + always applied even if mapping is disallowed. :unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap* @@ -82,8 +84,7 @@ modes. map command applies. The mapping may remain defined for other modes where it applies. It also works when {lhs} matches the {rhs} of a - mapping. This is for when when an abbreviation - applied. + mapping. This is for when an abbreviation applied. Note: Trailing spaces are included in the {lhs}. This unmap does NOT work: > :map @@ foo @@ -245,7 +246,7 @@ go through the main loop (e.g. to update the display), return "\<Ignore>". This is similar to "nothing" but makes Vim return from the loop that waits for input. -Also, keep in mind that the expression may be evaluated when looking for +Keep in mind that the expression may be evaluated when looking for typeahead, before the previous command has been executed. For example: > func StoreColumn() let g:column = col('.') @@ -286,7 +287,7 @@ Here is an example that inserts a list number that increases: > func ListItem() let g:counter += 1 - return g:counter . '. ' + return g:counter .. '. ' endfunc func ListReset() @@ -503,7 +504,9 @@ Note: When using mappings for Visual mode, you can use the "'<" mark, which is the start of the last selected Visual area in the current buffer |'<|. The |:filter| command can be used to select what mappings to list. The -pattern is matched against the {lhs} and {rhs} in the raw form. +pattern is matched against the {lhs} and {rhs} in the raw form. If a +description was added using |nvim_set_keymap()| or |nvim_buf_set_keymap()| +then the pattern is also matched against it. *:map-verbose* When 'verbose' is non-zero, listing a key map will also display where it was @@ -1218,7 +1221,7 @@ scripts. *:command-verbose* When 'verbose' is non-zero, listing a command will also display where it was -last defined. Example: > +last defined and any completion argument. Example: > :verbose command TOhtml < Name Args Range Complete Definition ~ @@ -1242,13 +1245,17 @@ See |:verbose-cmd| for more information. :delc[ommand] {cmd} *:delc* *:delcommand* *E184* Delete the user-defined command {cmd}. +:delc[ommand] -buffer {cmd} *E1237* + Delete the user-defined command {cmd} that was defined + for the current buffer. + :comc[lear] *:comc* *:comclear* Delete all user-defined commands. Command attributes ~ - -User-defined commands are treated by Vim just like any other Ex commands. They + *command-attributes* +User-defined commands are treated by Nvim just like any other Ex commands. They can have arguments, or have a range specified. Arguments are subject to completion as filenames, buffers, etc. Exactly how this works depends upon the command's attributes, which are specified when the command is defined. @@ -1333,6 +1340,8 @@ completion can be enabled: -complete=custom,{func} custom completion, defined via {func} -complete=customlist,{func} custom completion, defined via {func} +If you specify completion while there is nothing to complete (-nargs=0, the +default) then you get error *E1208* . Note: That some completion methods might expand environment variables. @@ -1435,6 +1444,9 @@ There are some special cases as well: -register The first argument to the command can be an optional register name (like :del, :put, :yank). -buffer The command will only be available in the current buffer. + -keepscript Do not use the location of where the user command was + defined for verbose messages, use the location of where + the user command was invoked. In the cases of the -count and -register attributes, if the optional argument is supplied, it is removed from the argument list and is available to the @@ -1479,12 +1491,12 @@ The valid escape sequences are Examples: > command! -nargs=+ -complete=file MyEdit \ for f in expand(<q-args>, 0, 1) | - \ exe '<mods> split ' . f | + \ exe '<mods> split ' .. f | \ endfor function! SpecialEdit(files, mods) for f in expand(a:files, 0, 1) - exe a:mods . ' split ' . f + exe a:mods .. ' split ' .. f endfor endfunction command! -nargs=+ -complete=file Sedit @@ -1560,7 +1572,7 @@ This will invoke: > : let i = 0 : while i < argc() : if filereadable(argv(i)) - : execute "e " . argv(i) + : execute "e " .. argv(i) : execute a:command : endif : let i = i + 1 diff --git a/runtime/doc/mbyte.txt b/runtime/doc/mbyte.txt index 3bbf36c642..2aa49cee1e 100644 --- a/runtime/doc/mbyte.txt +++ b/runtime/doc/mbyte.txt @@ -489,8 +489,8 @@ Use the RPM or port for your system. window specific to the input method. -USING XIM *multibyte-input* *E284* *E286* *E287* *E288* - *E285* *E289* +USING XIM *multibyte-input* *E284* *E285* *E286* *E287* + *E288* *E289* Note that Display and Input are independent. It is possible to see your language even though you have no input method for it. But when your Display diff --git a/runtime/doc/message.txt b/runtime/doc/message.txt index 6fbd9ec922..fa1bc6f7da 100644 --- a/runtime/doc/message.txt +++ b/runtime/doc/message.txt @@ -27,8 +27,7 @@ depends on the 'shortmess' option. Clear messages, keeping only the {count} most recent ones. -The number of remembered messages is fixed at 20 for the tiny version and 200 -for other versions. +The number of remembered messages is fixed at 200. *g<* The "g<" command can be used to see the last page of previous command output. @@ -112,7 +111,8 @@ wiped out a buffer which contains a mark or is referenced in another way. *E95* > Buffer with this name already exists -You cannot have two buffers with the same name. +You cannot have two buffers with exactly the same name. This includes the +path leading to the file. *E72* > Close error on swap file @@ -513,10 +513,10 @@ If you type "gq", it will execute this mapping, which will call "gq" again. *E22* > Scripts nested too deep -Scripts can be read with the "-s" command-line argument and with the ":source" -command. The script can then again read another script. This can continue -for about 14 levels. When more nesting is done, Vim assumes that there is a -recursive loop somewhere and stops with this error message. +Scripts can be read with the "-s" command-line argument and with the +`:source!` command. The script can then again read another script. This can +continue for about 14 levels. When more nesting is done, Vim assumes that +there is a recursive loop and stops with this error message. *E300* > Swap file already exists (symlink attack?) @@ -686,6 +686,7 @@ Ex command or function was given an invalid argument. Or |jobstart()| or Trailing characters An argument was given to an Ex command that does not permit one. +Or the argument has invalid characters and has not been recognized. *E477* *E478* > No ! allowed diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt index c473244827..20033bd76a 100644 --- a/runtime/doc/motion.txt +++ b/runtime/doc/motion.txt @@ -993,7 +993,7 @@ These commands are not marks themselves, but jump to a mark: :let lnum = line(".") :keepjumps normal gg :call SetLastChange() - :keepjumps exe "normal " . lnum . "G" + :keepjumps exe "normal " .. lnum .. "G" < Note that ":keepjumps" must be used for every command. When invoking a function the commands in that function diff --git a/runtime/doc/nvim_terminal_emulator.txt b/runtime/doc/nvim_terminal_emulator.txt index e1ae138d90..f322764ecf 100644 --- a/runtime/doc/nvim_terminal_emulator.txt +++ b/runtime/doc/nvim_terminal_emulator.txt @@ -90,7 +90,7 @@ Mouse input has the following behavior: - If another window is clicked, terminal focus will be lost and nvim will jump to the clicked window - If the mouse wheel is used while the mouse is positioned in another window, - the terminal wont lose focus and the hovered window will be scrolled. + the terminal won't lose focus and the hovered window will be scrolled. ============================================================================== Configuration *terminal-config* @@ -162,12 +162,11 @@ command name, for example: > This opens two windows: gdb window A terminal window in which "gdb vim" is executed. Here you - can directly interact with gdb. The buffer name is "!gdb". + can directly interact with gdb. program window A terminal window for the executed program. When "run" is used in gdb the program I/O will happen in this window, so - that it does not interfere with controlling gdb. The buffer - name is "gdb program". + that it does not interfere with controlling gdb. The current window is used to show the source code. When gdb pauses the source file location will be displayed, if possible. A sign is used to @@ -428,7 +427,7 @@ When 'background' is "dark": hi debugBreakpoint term=reverse ctermbg=red guibg=red -Shorcuts *termdebug_shortcuts* +Shortcuts *termdebug_shortcuts* You can define your own shortcuts (mappings) to control gdb, that can work in any window, using the TermDebugSendCommand() function. Example: > diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt index c929178f5a..82214a2527 100644 --- a/runtime/doc/options.txt +++ b/runtime/doc/options.txt @@ -20,9 +20,13 @@ achieve special effects. These options come in three forms: 1. Setting options *set-option* *E764* *:se* *:set* -:se[t] Show all options that differ from their default value. +:se[t][!] Show all options that differ from their default value. + When [!] is present every option is on a separate + line. -:se[t] all Show all options. +:se[t][!] all Show all options. + When [!] is present every option is on a separate + line. *E518* *E519* :se[t] {option}? Show value of {option}. @@ -235,7 +239,7 @@ happens when the buffer is not loaded, but they are lost when the buffer is wiped out |:bwipe|. *:setl* *:setlocal* -:setl[ocal] ... Like ":set" but set only the value local to the +:setl[ocal][!] ... Like ":set" but set only the value local to the current buffer or window. Not all options have a local value. If the option does not have a local value the global value is set. @@ -257,7 +261,7 @@ wiped out |:bwipe|. {option}, so that the global value will be used. *:setg* *:setglobal* -:setg[lobal] ... Like ":set" but set only the global value for a local +:setg[lobal][!] ... Like ":set" but set only the global value for a local option without changing the local value. When displaying an option, the global value is shown. With the "all" argument: display global values for all @@ -304,7 +308,7 @@ value to the local value, it doesn't switch back to using the global value This will make the local value of 'path' empty, so that the global value is used. Thus it does the same as: > :setlocal path= -Note: In the future more global options can be made global-local. Using +Note: In the future more global options can be made |global-local|. Using ":setlocal" on a global option might work differently then. @@ -686,10 +690,10 @@ A jump table for the options with a short description can be found at |Q_op|. 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 + a `:buffer`, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one to another file. A buffer is not written if it becomes hidden, e.g. when 'bufhidden' is - set to "hide" and `:next` is used + set to "hide" and `:next` is used. 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 @@ -893,7 +897,7 @@ A jump table for the options with a short description can be found at |Q_op|. If you like to keep a lot of backups, you could use a BufWritePre autocommand to change 'backupext' just before writing the file to include a timestamp. > - :au BufWritePre * let &bex = '-' . strftime("%Y%b%d%X") . '~' + :au BufWritePre * let &bex = '-' .. strftime("%Y%b%d%X") .. '~' < Use 'backupdir' to put the backup in a different directory. *'backupskip'* *'bsk'* @@ -916,7 +920,7 @@ A jump table for the options with a short description can be found at |Q_op|. Note that environment variables are not expanded. If you want to use $HOME you must expand it explicitly, e.g.: > - :let backupskip = escape(expand('$HOME'), '\') . '/tmp/*' + :let backupskip = escape(expand('$HOME'), '\') .. '/tmp/*' < Note that the default also makes sure that "crontab -e" works (when a backup would be made by renaming the original file crontab won't see @@ -1181,7 +1185,7 @@ A jump table for the options with a short description can be found at |Q_op|. 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') + :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). @@ -1216,8 +1220,8 @@ A jump table for the options with a short description can be found at |Q_op|. 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 expression must return zero, false or an empty string for success, + non-zero or true for failure. See |encoding-names| for possible encoding names. Additionally, names given in 'fileencodings' and 'fileencoding' are used. @@ -1228,8 +1232,8 @@ A jump table for the options with a short description can be found at |Q_op|. set charconvert=CharConvert() fun CharConvert() system("recode " - \ . v:charconvert_from . ".." . v:charconvert_to - \ . " <" . v:fname_in . " >" v:fname_out) + \ .. v:charconvert_from .. ".." .. v:charconvert_to + \ .. " <" .. v:fname_in .. " >" .. v:fname_out) return v:shell_error endfun < The related Vim variables are: @@ -2458,7 +2462,8 @@ A jump table for the options with a short description can be found at |Q_op|. < This is similar to the default, except that these characters will also be used when there is highlighting. - for "stl" and "stlnc" only single-byte values are supported. + For "stl" and "stlnc" single-byte and multibyte characters are + supported. But double-width characters are not supported. The highlighting used for these items: item highlight group ~ @@ -3035,7 +3040,7 @@ A jump table for the options with a short description can be found at |Q_op|. *'guitablabel'* *'gtl'* 'guitablabel' 'gtl' string (default empty) global - When nonempty describes the text to use in a label of the GUI tab + When non-empty 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. @@ -3052,7 +3057,7 @@ A jump table for the options with a short description can be found at |Q_op|. *'guitabtooltip'* *'gtt'* 'guitabtooltip' 'gtt' string (default empty) global - When nonempty describes the text to use in a tooltip for the GUI tab + When non-empty 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|: > @@ -3615,7 +3620,7 @@ A jump table for the options with a short description can be found at |Q_op|. global Language to use for menu translation. Tells which file is loaded from the "lang" directory in 'runtimepath': > - "lang/menu_" . &langmenu . ".vim" + "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 @@ -4517,7 +4522,7 @@ A jump table for the options with a short description can be found at |Q_op|. < 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') + :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. @@ -4633,26 +4638,11 @@ A jump table for the options with a short description can be found at |Q_op|. nudged to fit on the screen. *'pyxversion'* *'pyx'* -'pyxversion' 'pyx' number (default depends on the build) +'pyxversion' 'pyx' number (default 3) global Specifies the python version used for pyx* functions and commands - |python_x|. The default value is as follows: - - |provider| installed Default ~ - |+python| and |+python3| 0 - only |+python| 2 - only |+python3| 3 - - Available values are 0, 2 and 3. - If 'pyxversion' is 0, it is set to 2 or 3 after the first execution of - any python2/3 commands or functions. E.g. `:py` sets to 2, and `:py3` - sets to 3. `:pyx` sets it to 3 if Python 3 is available, otherwise sets - to 2 if Python 2 is available. - See also: |has-pythonx| - - If only |+python| or |+python3| are available, - 'pyxversion' has no effect. The pyx* functions and commands are - always the same as the installed version. + |python_x|. As only Python 3 is supported, this always has the value + `3`. Setting any other value is an error. This option cannot be set from a |modeline| or in the |sandbox|, for security reasons. @@ -5131,7 +5121,8 @@ A jump table for the options with a short description can be found at |Q_op|. Don't include both "curdir" and "sesdir". When neither is included filenames are stored as absolute paths. - + If you leave out "options" many things won't work well after restoring + the session. *'shada'* *'sd'* *E526* *E527* *E528* 'shada' 'sd' string (Vim default for Win32: !,'100,<50,s10,h,rA:,rB: @@ -5471,7 +5462,7 @@ A jump table for the options with a short description can be found at |Q_op|. 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, 888C" instead of "999 lines, 888 characters" + 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]" @@ -5656,7 +5647,7 @@ A jump table for the options with a short description can be found at |Q_op|. Note regarding 'orphaned signs': with signcolumn numbers higher than 1, deleting lines will also remove the associated signs automatically, in contrast to the default Vim behavior of keeping and grouping them. - This is done in order for the signcolumn appearence not appear weird + This is done in order for the signcolumn appearance not appear weird during line deletion. @@ -5915,7 +5906,7 @@ A jump table for the options with a short description can be found at |Q_op|. *'statusline'* *'stl'* *E540* *E542* 'statusline' 'stl' string (default empty) global or local to window |global-local| - When nonempty, this option determines the content of the status line. + When non-empty, this option determines the content of the status line. Also see |status-line|. The option consists of printf style '%' items interspersed with @@ -6231,7 +6222,7 @@ A jump table for the options with a short description can be found at |Q_op|. *'tabline'* *'tal'* 'tabline' 'tal' string (default empty) global - When nonempty, this option determines the content of the tab pages + When non-empty, 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. @@ -6264,10 +6255,11 @@ A jump table for the options with a short description can be found at |Q_op|. 'tabstop' 'ts' number (default 8) local to buffer Number of spaces that a <Tab> in the file counts for. Also see - |:retab| command, and 'softtabstop' option. + the |:retab| command, and the 'softtabstop' option. Note: Setting 'tabstop' to any other value than 8 can make your file - appear wrong in many places (e.g., when printing it). + appear wrong in many places, e.g., when printing it. + The value must be more than 0 and less than 10000. There are four main ways to use tabs in Vim: 1. Always keep 'tabstop' at 8, set 'softtabstop' and 'shiftwidth' to 4 @@ -6578,7 +6570,7 @@ A jump table for the options with a short description can be found at |Q_op|. This option cannot be set in a modeline when 'modelineexpr' is off. Example: > - :auto BufEnter * let &titlestring = hostname() . "/" . expand("%:p") + :auto BufEnter * let &titlestring = hostname() .. "/" .. expand("%:p") :set title titlestring=%<%F%=%l/%L-%P titlelen=70 < The value of 'titlelen' is used to align items in the middle or right of the available space. @@ -6724,8 +6716,8 @@ A jump table for the options with a short description can be found at |Q_op|. global When bigger than zero, Vim will give messages about what it is doing. Currently, these messages are given: - >= 1 When the shada file is read or written. - >= 2 When a file is ":source"'ed. + >= 1 Lua assignments to options,keymaps etc. + >= 2 When a file is ":source"'ed and when the shada file is read or written.. >= 3 UI info, terminal capabilities >= 4 Shell commands. >= 5 Every searched tags file and include file. @@ -6781,12 +6773,16 @@ A jump table for the options with a short description can be found at |Q_op|. *'virtualedit'* *'ve'* 'virtualedit' 've' string (default "") - global + global or local to window |global-local| 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". Virtual editing means that the cursor can be positioned where there is no actual character. This can be halfway into a tab or beyond the end diff --git a/runtime/doc/pattern.txt b/runtime/doc/pattern.txt index dfed39dba6..c3bd5baff2 100644 --- a/runtime/doc/pattern.txt +++ b/runtime/doc/pattern.txt @@ -304,7 +304,7 @@ the pattern. ============================================================================== 2. The definition of a pattern *search-pattern* *pattern* *[pattern]* *regular-expression* *regexp* *Pattern* - *E76* *E383* *E476* + *E383* *E476* For starters, read chapter 27 of the user manual |usr_27.txt|. @@ -923,7 +923,7 @@ $ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on): update the matches. This means Syntax highlighting quickly becomes wrong. Example, to highlight the line where the cursor currently is: > - :exe '/\%' . line(".") . 'l.*' + :exe '/\%' .. line(".") .. 'l.*' < When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not. @@ -939,7 +939,7 @@ $ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on): update the matches. This means Syntax highlighting quickly becomes wrong. Example, to highlight the column where the cursor currently is: > - :exe '/\%' . col(".") . 'c' + :exe '/\%' .. col(".") .. 'c' < When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not. Example for matching a single byte in column 44: > @@ -1036,6 +1036,8 @@ match ASCII characters, as indicated by the range. \(\) A pattern enclosed by escaped parentheses. */\(* */\(\)* */\)* E.g., "\(^a\)" matches 'a' at the start of a line. + There can only be ten of these. You can use "\%(" to add more, but + not counting it as a sub-expression. *E51* *E54* *E55* *E872* *E873* \1 Matches the same string that was matched by */\1* *E65* @@ -1058,7 +1060,7 @@ x A single character, with no special meaning, matches itself \x A backslash followed by a single character, with no special meaning, is reserved for future expansions -[] (with 'nomagic': \[]) */[]* */\[]* */\_[]* */collection* +[] (with 'nomagic': \[]) */[]* */\[]* */\_[]* */collection* *E76* \_[] A collection. This is a sequence of characters enclosed in square brackets. It matches any single character in the collection. @@ -1419,5 +1421,38 @@ Finally, these constructs are unique to Perl: are suggested to use ":match" for manual matching and ":2match" for another plugin. +============================================================================== +11. Fuzzy matching *fuzzy-match* + +Fuzzy matching refers to matching strings using a non-exact search string. +Fuzzy matching will match a string, if all the characters in the search string +are present anywhere in the string in the same order. Case is ignored. In a +matched string, other characters can be present between two consecutive +characters in the search string. If the search string has multiple words, then +each word is matched separately. So the words in the search string can be +present in any order in a string. + +Fuzzy matching assigns a score for each matched string based on the following +criteria: + - The number of sequentially matching characters. + - The number of characters (distance) between two consecutive matching + characters. + - Matches at the beginning of a word + - Matches at a camel case character (e.g. Case in CamelCase) + - Matches after a path separator or a hyphen. + - The number of unmatched characters in a string. +The matching string with the highest score is returned first. + +For example, when you search for the "get pat" string using fuzzy matching, it +will match the strings "GetPattern", "PatternGet", "getPattern", "patGetter", +"getSomePattern", "MatchpatternGet" etc. + +The functions |matchfuzzy()| and |matchfuzzypos()| can be used to fuzzy search +a string in a List of strings. The matchfuzzy() function returns a List of +matching strings. The matchfuzzypos() functions returns the List of matches, +the matching positions and the fuzzy match scores. + +The "f" flag of `:vimgrep` enables fuzzy matching. + vim:tw=78:ts=8:noet:ft=help:norl: diff --git a/runtime/doc/pi_msgpack.txt b/runtime/doc/pi_msgpack.txt index 1dbd268038..801c56e49f 100644 --- a/runtime/doc/pi_msgpack.txt +++ b/runtime/doc/pi_msgpack.txt @@ -88,7 +88,7 @@ msgpack#type({msgpack-value}) *msgpack#type()* Returns name of the key in |v:msgpack_types| that represents {msgpack-value} type. Never returns zero: this function returns msgpack type which will be dumped by |msgpackdump()| should it receive - a list with singe {msgpack-value} as input. + a list with single {msgpack-value} as input. msgpack#deepcopy({msgpack-value}) *msgpack#deepcopy()* Like |deepcopy()|, but works correctly with |msgpack-special-dict| diff --git a/runtime/doc/pi_netrw.txt b/runtime/doc/pi_netrw.txt index 3ac61be6f2..8257152b11 100644 --- a/runtime/doc/pi_netrw.txt +++ b/runtime/doc/pi_netrw.txt @@ -968,7 +968,7 @@ itself: fun! NetReadFixup(method, line1, line2) if method == 3 " ftp (no <.netrc>) let fourblanklines= line2 - 3 - silent fourblanklines.",".line2."g/^\s*/d" + silent fourblanklines .. "," .. line2 .. "g/^\s*/d" endif endfunction endif @@ -1975,7 +1975,7 @@ To use this function, simply assign its output to |g:netrw_list_hide| option. > Example: let g:netrw_list_hide= netrw_gitignore#Hide('my_gitignore_file') Function can take additional files with git-ignore patterns. - Example: g:netrw_list_hide= netrw_gitignore#Hide() . '.*\.swp$' + Example: let g:netrw_list_hide= netrw_gitignore#Hide() .. '.*\.swp$' Combining 'netrw_gitignore#Hide' with custom patterns. < @@ -2824,7 +2824,7 @@ your browsing preferences. (see also: |netrw-settings|) Examples: let g:netrw_list_hide= '.*\.swp$' - let g:netrw_list_hide= netrw_gitignore#Hide().'.*\.swp$' + let g:netrw_list_hide= netrw_gitignore#Hide() .. '.*\.swp$' default: "" *g:netrw_localcopycmd* ="cp" Linux/Unix/MacOS/Cygwin diff --git a/runtime/doc/print.txt b/runtime/doc/print.txt index f54d0429a6..924fab175e 100644 --- a/runtime/doc/print.txt +++ b/runtime/doc/print.txt @@ -127,21 +127,21 @@ file: > system(['lpr'] + (empty(&printdevice)?[]:['-P', &printdevice]) + [v:fname_in]) - . delete(v:fname_in) + .. delete(v:fname_in) + v:shell_error On MS-Dos and MS-Windows machines the default is to copy the file to the currently specified printdevice: > system(['copy', v:fname_in, empty(&printdevice)?'LPT1':&printdevice]) - . delete(v:fname_in) + .. delete(v:fname_in) If you change this option, using a function is an easy way to avoid having to escape all the spaces. Example: > :set printexpr=PrintFile(v:fname_in) :function PrintFile(fname) - : call system("ghostview " . a:fname) + : call system("ghostview " .. a:fname) : call delete(a:fname) : return v:shell_error :endfunc diff --git a/runtime/doc/provider.txt b/runtime/doc/provider.txt index b785010699..9fd35f19c5 100644 --- a/runtime/doc/provider.txt +++ b/runtime/doc/provider.txt @@ -20,11 +20,12 @@ Run the |:checkhealth| command, and review the sections below. ============================================================================== Python integration *provider-python* -Nvim supports Python |remote-plugin|s and the Vim legacy |python2| and -|python3| interfaces (which are implemented as remote-plugins). +Nvim supports Python |remote-plugin|s and the Vim legacy |python3| and +|pythonx| interfaces (which are implemented as remote-plugins). Note: Only the Vim 7.3 legacy interface is supported, not later features such -as |python-bindeval| (Vim 7.4); use the Nvim API instead. +as |python-bindeval| (Vim 7.4); use the Nvim API instead. Python 2 is not +supported. PYTHON QUICKSTART ~ @@ -38,11 +39,6 @@ For Python 3 plugins: 2. Install the module (try "python" if "python3" is missing): > python3 -m pip install --user --upgrade pynvim -For Python 2 plugins: -1. Make sure Python 2.7 is available in your $PATH. -2. Install the module (try "python" if "python2" is missing): > - python2 -m pip install --user --upgrade pynvim - The pip `--upgrade` flag ensures that you get the latest version even if a previous version was already installed. @@ -56,22 +52,12 @@ If you run into problems, uninstall _both_ then install "pynvim" again: > PYTHON PROVIDER CONFIGURATION ~ - *g:python_host_prog* -Command to start Python 2 (executable, not directory). Setting this makes -startup faster. Useful for working with virtualenvs. Must be set before any -check for has("python2"). > - let g:python_host_prog = '/path/to/python' -< *g:python3_host_prog* Command to start Python 3 (executable, not directory). Setting this makes startup faster. Useful for working with virtualenvs. Must be set before any check for has("python3"). > let g:python3_host_prog = '/path/to/python3' < - *g:loaded_python_provider* -To disable Python 2 support: > - let g:loaded_python_provider = 0 -< *g:loaded_python3_provider* To disable Python 3 support: > let g:loaded_python3_provider = 0 @@ -81,8 +67,8 @@ PYTHON VIRTUALENVS ~ *python-virtualenv* If you plan to use per-project virtualenvs often, you should assign one virtualenv for Neovim and hard-code the interpreter path via -|g:python3_host_prog| (or |g:python_host_prog|) so that the "pynvim" package -is not required for each virtualenv. +|g:python3_host_prog| so that the "pynvim" package is not required +for each virtualenv. Example using pyenv: > pyenv install 3.4.4 diff --git a/runtime/doc/quickfix.txt b/runtime/doc/quickfix.txt index ba1da209f7..601384a71f 100644 --- a/runtime/doc/quickfix.txt +++ b/runtime/doc/quickfix.txt @@ -232,7 +232,7 @@ processing a quickfix or location list command, it will be aborted. ":qall!" |:qall|, except that Nvim exits non-zero or [count]. - *:cf* *:cfile* + *:cf* *:cfi* *:cfile* :cf[ile][!] [errorfile] Read the error file and jump to the first error. This is done automatically when Vim is started with the -q option. You can use this command when you @@ -341,7 +341,7 @@ processing a quickfix or location list command, it will be aborted. cursor position will not be changed. See |:cexpr| for more information. Example: > - :g/mypattern/caddexpr expand("%") . ":" . line(".") . ":" . getline(".") + :g/mypattern/caddexpr expand("%") .. ":" .. line(".") .. ":" .. getline(".") < *:lad* *:addd* *:laddexpr* :lad[dexpr] {expr} Same as ":caddexpr", except the location list for the @@ -641,6 +641,24 @@ quickfix window. If there already is a window for that file, it is used instead. If the buffer in the used window has changed, and the error is in another file, jumping to the error will fail. You will first have to make sure the window contains a buffer which can be abandoned. + +The following steps are used to find a window to open the file selected from +the quickfix window: +1. If 'switchbuf' contains "usetab", then find a window in any tabpage + (starting with the first tabpage) that has the selected file and jump to + it. +2. Otherwise find a window displaying the selected file in the current tab + page (starting with the window before the quickfix window) and use it. +3. Otherwise find a window displaying a normal buffer ('buftype' is empty) + starting with the window before the quickfix window. If a window is found, + open the file in that window. +4. If a usable window is not found and 'switchbuf' contains "uselast", then + open the file in the last used window. +5. Otherwise open the file in the window before the quickfix window. If there + is no previous window, then open the file in the next window. +6. If a usable window is not found in the above steps, then create a new + horizontally split window above the quickfix window and open the file. + *CTRL-W_<Enter>* *CTRL-W_<CR>* You can use CTRL-W <Enter> to open a new window and jump to the error there. @@ -650,7 +668,7 @@ FileType event (also see |qf.vim|). Then the BufReadPost event is triggered, using "quickfix" for the buffer name. This can be used to perform some action on the listed errors. Example: > au BufReadPost quickfix setlocal modifiable - \ | silent exe 'g/^/s//\=line(".")." "/' + \ | silent exe 'g/^/s//\=line(".") .. " "/' \ | setlocal nomodifiable This prepends the line number to each line. Note the use of "\=" in the substitute string of the ":s" command, which is used to evaluate an @@ -989,7 +1007,7 @@ commands can be combined to create a NewGrep command: > 5.1 using Vim's internal grep *:vim* *:vimgrep* *E682* *E683* -:vim[grep][!] /{pattern}/[g][j] {file} ... +:vim[grep][!] /{pattern}/[g][j][f] {file} ... Search for {pattern} in the files {file} ... and set the error list to the matches. Files matching 'wildignore' are ignored; files in 'suffixes' are @@ -1014,6 +1032,13 @@ commands can be combined to create a NewGrep command: > updated. With the [!] any changes in the current buffer are abandoned. + 'f' When the 'f' flag is specified, fuzzy string + matching is used to find matching lines. In this + case, {pattern} is treated as a literal string + instead of a regular expression. See + |fuzzy-match| for more information about fuzzy + matching strings. + |QuickFixCmdPre| and |QuickFixCmdPost| are triggered. A file that is opened for matching may use a buffer number, but it is reused if possible to avoid @@ -1042,20 +1067,20 @@ commands can be combined to create a NewGrep command: > :vimgrep Error *.c < *:lv* *:lvimgrep* -:lv[imgrep][!] /{pattern}/[g][j] {file} ... +:lv[imgrep][!] /{pattern}/[g][j][f] {file} ... :lv[imgrep][!] {pattern} {file} ... Same as ":vimgrep", except the location list for the current window is used instead of the quickfix list. *:vimgrepa* *:vimgrepadd* -:vimgrepa[dd][!] /{pattern}/[g][j] {file} ... +:vimgrepa[dd][!] /{pattern}/[g][j][f] {file} ... :vimgrepa[dd][!] {pattern} {file} ... Just like ":vimgrep", but instead of making a new list of errors the matches are appended to the current list. *:lvimgrepa* *:lvimgrepadd* -:lvimgrepa[dd][!] /{pattern}/[g][j] {file} ... +:lvimgrepa[dd][!] /{pattern}/[g][j][f] {file} ... :lvimgrepa[dd][!] {pattern} {file} ... Same as ":vimgrepadd", except the location list for the current window is used instead of the quickfix @@ -1332,12 +1357,17 @@ Basic items %f file name (finds a string) %o module name (finds a string) %l line number (finds a number) + %e end line number (finds a number) %c column number (finds a number representing character column of the error, byte index, a <tab> is 1 character column) %v virtual column number (finds a number representing screen column of the error (1 <tab> == 8 screen columns)) + %k end column number (finds a number representing + the character column of the error, byte index, or a + number representing screen end column of the error if + it's used with %v) %t error type (finds a single character): e - error message w - warning message @@ -1446,7 +1476,7 @@ error message (line numbers are not part of the actual output): 4 Traceback (most recent call last): 5 File "unittests/dbfacadeTest.py", line 89, in testFoo 6 self.assertEquals(34, dtid) - 7 File "/usr/lib/python2.2/unittest.py", line 286, in + 7 File "/usr/lib/python3.8/unittest.py", line 286, in 8 failUnlessEqual 9 raise self.failureException, \ 10 AssertionError: 34 != 33 diff --git a/runtime/doc/quickref.txt b/runtime/doc/quickref.txt index af8301f1a0..e36eb2359f 100644 --- a/runtime/doc/quickref.txt +++ b/runtime/doc/quickref.txt @@ -356,6 +356,7 @@ In Insert or Command-line mode: |v_y| {visual}y yank the highlighted text into a register |yy| N yy yank N lines into a register |Y| N Y yank N lines into a register + Note: Mapped to "y$" by default. |default-mappings| |p| N p put a register after the cursor position (N times) |P| N P put a register before the cursor position (N times) |]p| N ]p like p, but adjust indent to current line diff --git a/runtime/doc/repeat.txt b/runtime/doc/repeat.txt index c7481ad290..05529dc90a 100644 --- a/runtime/doc/repeat.txt +++ b/runtime/doc/repeat.txt @@ -253,21 +253,22 @@ For writing a Vim script, see chapter 41 of the user manual |usr_41.txt|. below "plugin", just like with plugins in 'runtimepath'. - If the filetype detection was not enabled yet (this + If the filetype detection was already enabled (this is usually done with a "syntax enable" or "filetype - on" command in your .vimrc file), this will also look + on" command in your |init.vim|, or automatically during + |initialization|), and the package was found in + "pack/*/opt/{name}", this command will also look for "{name}/ftdetect/*.vim" files. When the optional ! is added no plugin files or ftdetect scripts are loaded, only the matching directories are added to 'runtimepath'. This is - useful in your .vimrc. The plugins will then be - loaded during initialization, see |load-plugins| (note + useful in your |init.vim|. The plugins will then be + loaded during |initialization|, see |load-plugins| (note that the loading order will be reversed, because each - directory is inserted before others). - Note that for ftdetect scripts to be loaded - you will need to write `filetype plugin indent on` - AFTER all `packadd!` commands. + directory is inserted before others). In this case, the + ftdetect scripts will be loaded during |initialization|, + before the |load-plugins| step. Also see |pack-add|. @@ -465,8 +466,8 @@ flag when defining the function, it is not relevant when executing it. > :set cpo-=C < *line-continuation-comment* -To add a comment in between the lines start with '\" '. Notice the space -after the double quote. Example: > +To add a comment in between the lines start with '"\ '. Notice the space +after the backslash. Example: > let array = [ "\ first entry comment \ 'first', diff --git a/runtime/doc/sign.txt b/runtime/doc/sign.txt index 5cfa06c33c..a2a5645baa 100644 --- a/runtime/doc/sign.txt +++ b/runtime/doc/sign.txt @@ -87,7 +87,7 @@ the delete is undone the sign does not move back. Here is an example that places a sign "piet", displayed with the text ">>", in line 23 of the current file: > :sign define piet text=>> texthl=Search - :exe ":sign place 2 line=23 name=piet file=" . expand("%:p") + :exe ":sign place 2 line=23 name=piet file=" .. expand("%:p") And here is the command to delete it again: > :sign unplace 2 diff --git a/runtime/doc/spell.txt b/runtime/doc/spell.txt index 03c00c8495..bc45b0e511 100644 --- a/runtime/doc/spell.txt +++ b/runtime/doc/spell.txt @@ -120,8 +120,8 @@ zuG Undo |zW| and |zG|, remove the word from the internal rare as this is a fairly uncommon command and all intuitive commands for this are already taken. If you want you can add mappings with e.g.: > - nnoremap z? :exe ':spellrare ' . expand('<cWORD>')<CR> - nnoremap z/ :exe ':spellrare! ' . expand('<cWORD>')<CR> + nnoremap z? :exe ':spellrare ' .. expand('<cWORD>')<CR> + nnoremap z/ :exe ':spellrare! ' .. expand('<cWORD>')<CR> < |:spellundo|, |zuw|, or |zuW| can be used to undo this. :spellr[rare]! {word} Add {word} as a rare word to the internal word diff --git a/runtime/doc/starting.txt b/runtime/doc/starting.txt index bb775ec884..1d3fa6c2ca 100644 --- a/runtime/doc/starting.txt +++ b/runtime/doc/starting.txt @@ -188,7 +188,7 @@ argument. changes and writing. -e *-e* *-E* --E Start Nvim in Ex mode |gQ|. +-E Start Nvim in Ex mode |gQ|, see |Ex-mode|. If stdin is not a TTY: -e reads/executes stdin as Ex commands. @@ -409,7 +409,12 @@ accordingly, proceeding as follows: 4. Setup |default-mappings| and |default-autocmds|. -5. Load user config (execute Ex commands from files, environment, …). +5. Enable filetype and indent plugins. + This does the same as the command: > + :runtime! ftplugin.vim indent.vim +< Skipped if the "-u NONE" command line argument was given. + +6. Load user config (execute Ex commands from files, environment, …). $VIMINIT environment variable is read as one Ex command line (separate multiple commands with '|' or <NL>). *config* *init.vim* *init.lua* *vimrc* *exrc* @@ -453,21 +458,19 @@ accordingly, proceeding as follows: - The file ".nvimrc" - The file ".exrc" -6. Enable filetype and indent plugins. - This does the same as the commands: > - :runtime! filetype.vim - :runtime! ftplugin.vim - :runtime! indent.vim -< Skipped if ":filetype … off" was called or if the "-u NONE" command - line argument was given. +7. Enable filetype detection. + This does the same as the command: > + :runtime! filetype.lua filetype.vim +< Skipped if ":filetype off" was called or if the "-u NONE" command line + argument was given. -7. Enable syntax highlighting. +8. Enable syntax highlighting. This does the same as the command: > :runtime! syntax/syntax.vim < Skipped if ":syntax off" was called or if the "-u NONE" command line argument was given. -8. Load the plugin scripts. *load-plugins* +9. Load the plugin scripts. *load-plugins* This does the same as the command: > :runtime! plugin/**/*.vim :runtime! plugin/**/*.lua @@ -497,21 +500,21 @@ accordingly, proceeding as follows: if packages have been found, but that should not add a directory ending in "after". -9. Set 'shellpipe' and 'shellredir' +10. Set 'shellpipe' and 'shellredir' The 'shellpipe' and 'shellredir' options are set according to the value of the 'shell' option, unless they have been set before. This means that Nvim will figure out the values of 'shellpipe' and 'shellredir' for you, unless you have set them yourself. -10. Set 'updatecount' to zero, if "-n" command argument used +11. Set 'updatecount' to zero, if "-n" command argument used -11. Set binary options if the |-b| flag was given. +12. Set binary options if the |-b| flag was given. -12. Read the |shada-file|. +13. Read the |shada-file|. -13. Read the quickfix file if the |-q| flag was given, or exit on failure. +14. Read the quickfix file if the |-q| flag was given, or exit on failure. -14. Open all windows +15. Open all windows When the |-o| flag was given, windows will be opened (but not displayed yet). When the |-p| flag was given, tab pages will be created (but not @@ -521,7 +524,7 @@ accordingly, proceeding as follows: Buffers for all windows will be loaded, without triggering |BufAdd| autocommands. -15. Execute startup commands +16. Execute startup commands If a |-t| flag was given, the tag is jumped to. Commands given with |-c| and |+cmd| are executed. If the 'insertmode' option is set, Insert mode is entered. @@ -797,7 +800,7 @@ resulting file, when executed with a ":source" command: After restoring the Session, the full filename of your current Session is available in the internal variable |v:this_session|. An example mapping: > - :nmap <F2> :wa<Bar>exe "mksession! " . v:this_session<CR>:so ~/sessions/ + :nmap <F2> :wa<Bar>exe "mksession! " .. v:this_session<CR>:so ~/sessions/ This saves the current Session, and starts off the command to load another. A session includes all tab pages, unless "tabpages" was removed from diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt index 0fd481cd83..778f829a4e 100644 --- a/runtime/doc/syntax.txt +++ b/runtime/doc/syntax.txt @@ -616,7 +616,7 @@ evaluate to get a unique string to append to each ID used in a given document, so that the full IDs will be unique even when combined with other content in a larger HTML document. Example, to append _ and the buffer number to each ID: > - :let g:html_id_expr = '"_".bufnr("%")' + :let g:html_id_expr = '"_" .. bufnr("%")' < To append a string "_mystring" to the end of each ID: > @@ -920,12 +920,16 @@ in .../after/syntax/baan.vim (see |after-directory|). Eg: > BASIC *basic.vim* *vb.vim* *ft-basic-syntax* *ft-vb-syntax* -Both Visual Basic and "normal" basic use the extension ".bas". To detect +Both Visual Basic and "normal" BASIC use the extension ".bas". To detect which one should be used, Vim checks for the string "VB_Name" in the first five lines of the file. If it is not found, filetype will be "basic", otherwise "vb". Files with the ".frm" extension will always be seen as Visual Basic. +If the automatic detection doesn't work for you or you only edit, for +example, FreeBASIC files, use this in your startup vimrc: > + :let filetype_bas = "freebasic" + C *c.vim* *ft-c-syntax* @@ -1406,7 +1410,7 @@ add the following line to your startup file: > :let g:filetype_euphoria = "euphoria4" -Elixir and Euphoria share the *.ex file extension. If the filetype is +Elixir and Euphoria share the *.ex file extension. If the filetype is specifically set as Euphoria with the g:filetype_euphoria variable, or the file is determined to be Euphoria based on keywords in the file, then the filetype will be set as Euphoria. Otherwise, the filetype will default to @@ -1437,7 +1441,7 @@ The following file extensions are auto-detected as Elixir file types: *.ex, *.exs, *.eex, *.leex, *.lock -Elixir and Euphoria share the *.ex file extension. If the filetype is +Elixir and Euphoria share the *.ex file extension. If the filetype is specifically set as Euphoria with the g:filetype_euphoria variable, or the file is determined to be Euphoria based on keywords in the file, then the filetype will be set as Euphoria. Otherwise, the filetype will default to @@ -3546,8 +3550,8 @@ Do you want to draw with the mouse? Try the following: > :function! GetPixel() : let c = getline(".")[col(".") - 1] : echo c - : exe "noremap <LeftMouse> <LeftMouse>r".c - : exe "noremap <LeftDrag> <LeftMouse>r".c + : exe "noremap <LeftMouse> <LeftMouse>r" .. c + : exe "noremap <LeftDrag> <LeftMouse>r" .. c :endfunction :noremap <RightMouse> <LeftMouse>:call GetPixel()<CR> :set guicursor=n:hor20 " to see the color beneath the cursor @@ -5359,9 +5363,9 @@ types.vim: *.[ch] And put these lines in your vimrc: > " load the types.vim highlighting file, if it exists - autocmd BufRead,BufNewFile *.[ch] let fname = expand('<afile>:p:h') . '/types.vim' + autocmd BufRead,BufNewFile *.[ch] let fname = expand('<afile>:p:h') .. '/types.vim' autocmd BufRead,BufNewFile *.[ch] if filereadable(fname) - autocmd BufRead,BufNewFile *.[ch] exe 'so ' . fname + autocmd BufRead,BufNewFile *.[ch] exe 'so ' .. fname autocmd BufRead,BufNewFile *.[ch] endif ============================================================================== @@ -5402,7 +5406,7 @@ To test your color setup, a file has been included in the Vim distribution. To use it, execute this command: > :runtime syntax/colortest.vim -Nvim uses 256-color and |true-color| terminal capabilities whereever possible. +Nvim uses 256-color and |true-color| terminal capabilities wherever possible. ============================================================================== 18. When syntax is slow *:syntime* diff --git a/runtime/doc/tabpage.txt b/runtime/doc/tabpage.txt index 7f91fda9f4..c5b61e3a35 100644 --- a/runtime/doc/tabpage.txt +++ b/runtime/doc/tabpage.txt @@ -366,24 +366,24 @@ pages and define labels for them. Then get the label for each tab page. > for i in range(tabpagenr('$')) " select the highlighting if i + 1 == tabpagenr() - let s .= '%#TabLineSel#' + let s ..= '%#TabLineSel#' else - let s .= '%#TabLine#' + let s ..= '%#TabLine#' endif " set the tab page number (for mouse clicks) - let s .= '%' . (i + 1) . 'T' + let s ..= '%' .. (i + 1) .. 'T' " the label is made by MyTabLabel() - let s .= ' %{MyTabLabel(' . (i + 1) . ')} ' + let s ..= ' %{MyTabLabel(' .. (i + 1) .. ')} ' endfor " after the last tab fill with TabLineFill and reset tab page nr - let s .= '%#TabLineFill#%T' + let s ..= '%#TabLineFill#%T' " right-align the label to close the current tab page if tabpagenr('$') > 1 - let s .= '%=%#TabLine#%999Xclose' + let s ..= '%=%#TabLine#%999Xclose' endif return s @@ -446,14 +446,14 @@ windows in the tab page and a '+' if there is a modified buffer: > " Append the number of windows in the tab page if more than one let wincount = tabpagewinnr(v:lnum, '$') if wincount > 1 - let label .= wincount + let label ..= wincount endif if label != '' - let label .= ' ' + let label ..= ' ' endif " Append the buffer name - return label . bufname(bufnrlist[tabpagewinnr(v:lnum) - 1]) + return label .. bufname(bufnrlist[tabpagewinnr(v:lnum) - 1]) endfunction set guitablabel=%{GuiTabLabel()} diff --git a/runtime/doc/tagsrch.txt b/runtime/doc/tagsrch.txt index 4d938c4a23..5a0d16d6b8 100644 --- a/runtime/doc/tagsrch.txt +++ b/runtime/doc/tagsrch.txt @@ -705,7 +705,7 @@ matches the pattern "^# *define" it is not considered to be a comment. If you want to list matches, and then select one to jump to, you could use a mapping to do that for you. Here is an example: > - :map <F4> [I:let nr = input("Which one: ")<Bar>exe "normal " . nr ."[\t"<CR> + :map <F4> [I:let nr = input("Which one: ")<Bar>exe "normal " .. nr .. "[\t"<CR> < *[i* [i Display the first line that contains the keyword diff --git a/runtime/doc/term.txt b/runtime/doc/term.txt index 935d958729..f9b2271756 100644 --- a/runtime/doc/term.txt +++ b/runtime/doc/term.txt @@ -133,7 +133,7 @@ capabilities as if they had been in the terminfo definition. If terminfo does not (yet) have this flag, Nvim will fall back to $TERM and other environment variables. It will add constructed "setrgbf" and "setrgbb" -capabilities in the case of the the "rxvt", "linux", "st", "tmux", and "iterm" +capabilities in the case of the "rxvt", "linux", "st", "tmux", and "iterm" terminal types, or when Konsole, genuine Xterm, a libvte terminal emulator version 0.36 or later, or a terminal emulator that sets the COLORTERM environment variable to "truecolor" is detected. @@ -321,7 +321,7 @@ an #if/#else/#endif block, the selection becomes linewise. For MS-Windows and xterm the time for double clicking can be set with the 'mousetime' option. For the other systems this time is defined outside of Vim. An example, for using a double click to jump to the tag under the cursor: > - :map <2-LeftMouse> :exe "tag ". expand("<cword>")<CR> + :map <2-LeftMouse> :exe "tag " .. expand("<cword>")<CR> Dragging the mouse with a double click (button-down, button-up, button-down and then drag) will result in whole words to be selected. This continues diff --git a/runtime/doc/testing.txt b/runtime/doc/testing.txt index 8ec66d26a4..4e4a908d0f 100644 --- a/runtime/doc/testing.txt +++ b/runtime/doc/testing.txt @@ -12,7 +12,7 @@ and for testing plugins. 1. Testing Vim |testing| 2. Test functions |test-functions-details| -3. Assert funtions |assert-functions-details| +3. Assert functions |assert-functions-details| ============================================================================== 1. Testing Vim *testing* diff --git a/runtime/doc/tips.txt b/runtime/doc/tips.txt index b77c7d9a6d..d913b53c6b 100644 --- a/runtime/doc/tips.txt +++ b/runtime/doc/tips.txt @@ -84,14 +84,14 @@ What you need: create it with the shell command "mkid file1 file2 ..". Put this in your |init.vim|: > - map _u :call ID_search()<Bar>execute "/\\<" . g:word . "\\>"<CR> - map _n :n<Bar>execute "/\\<" . g:word . "\\>"<CR> + map _u :call ID_search()<Bar>execute "/\\<" .. g:word .. "\\>"<CR> + map _n :n<Bar>execute "/\\<" .. g:word .. "\\>"<CR> function! ID_search() let g:word = expand("<cword>") - let x = system("lid --key=none ". g:word) + let x = system("lid --key=none " .. g:word) let x = substitute(x, "\n", " ", "g") - execute "next " . x + execute "next " .. x endfun To use it, place the cursor on a word, type "_u" and vim will load the file @@ -285,13 +285,13 @@ This mapping will format any bullet list. It requires that there is an empty line above and below each list entry. The expression commands are used to be able to give comments to the parts of the mapping. > - :let m = ":map _f :set ai<CR>" " need 'autoindent' set - :let m = m . "{O<Esc>" " add empty line above item - :let m = m . "}{)^W" " move to text after bullet - :let m = m . "i <CR> <Esc>" " add space for indent - :let m = m . "gq}" " format text after the bullet - :let m = m . "{dd" " remove the empty line - :let m = m . "5lDJ" " put text after bullet + :let m = ":map _f :set ai<CR>" " need 'autoindent' set + :let m ..= "{O<Esc>" " add empty line above item + :let m ..= "}{)^W" " move to text after bullet + :let m ..= "i <CR> <Esc>" " add space for indent + :let m ..= "gq}" " format text after the bullet + :let m ..= "{dd" " remove the empty line + :let m ..= "5lDJ" " put text after bullet :execute m |" define the mapping (<> notation |<>|. Note that this is all typed literally. ^W is "^" "W", not @@ -429,15 +429,15 @@ A slightly more advanced version is used in the |matchparen| plugin. let c = '\[' let c2 = '\]' endif - let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' . + let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' .. \ '=~? "string\\|comment"' execute 'if' s_skip '| let s_skip = 0 | endif' let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip) if m_lnum > 0 && m_lnum >= line('w0') && m_lnum <= line('w$') - exe 'match Search /\(\%' . c_lnum . 'l\%' . c_col . - \ 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' + exe 'match Search /\(\%' .. c_lnum .. 'l\%' .. c_col .. + \ 'c\)\|\(\%' .. m_lnum .. 'l\%' .. m_col .. 'c\)/' let s:paren_hl_on = 1 endif endfunction diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt index 8f7241dd46..dbd8ec6fef 100644 --- a/runtime/doc/treesitter.txt +++ b/runtime/doc/treesitter.txt @@ -14,10 +14,12 @@ VIM.TREESITTER *lua-treesitter* Nvim integrates the tree-sitter library for incremental parsing of buffers. *vim.treesitter.language_version* -To check which language version is compiled with neovim, the number is stored -within `vim.treesitter.language_version`. This number is not too helpful -unless you are wondering about compatibility between different versions of -compiled grammars. +The latest parser ABI version that is supported by the bundled tree-sitter +library. + + *vim.treesitter.minimum_language_version* +The earliest parser ABI version that is supported by the bundled tree-sitter +library. Parser files *treesitter-parsers* @@ -49,10 +51,10 @@ Whenever you need to access the current syntax tree, parse the buffer: > tstree = parser:parse() -<This will return a table of immutable trees that represent the current state of the -buffer. When the plugin wants to access the state after a (possible) edit -it should call `parse()` again. If the buffer wasn't edited, the same tree will -be returned again without extra work. If the buffer was parsed before, +<This will return a table of immutable trees that represent the current state +of the buffer. When the plugin wants to access the state after a (possible) +edit it should call `parse()` again. If the buffer wasn't edited, the same tree +will be returned again without extra work. If the buffer was parsed before, incremental parsing will be done of the changed parts. Note: to use the parser directly inside a |nvim_buf_attach| Lua callback, you @@ -61,9 +63,10 @@ parsing shouldn't be done directly in the change callback anyway as they will be very frequent. Rather a plugin that does any kind of analysis on a tree should use a timer to throttle too frequent updates. -tsparser:set_included_regions({region_list}) *tsparser:set_included_regions()* +tsparser:set_included_regions({region_list}) *tsparser:set_included_regions()* Changes the regions the parser should consider. This is used for - language injection. {region_list} should be of the form (all zero-based): > + language injection. {region_list} should be of the form + (all zero-based): > { {node1, node2}, ... @@ -92,15 +95,15 @@ tsnode:next_sibling() *tsnode:next_sibling()* tsnode:prev_sibling() *tsnode:prev_sibling()* Get the node's previous sibling. -tsnode:next_named_sibling() *tsnode:next_named_sibling()* +tsnode:next_named_sibling() *tsnode:next_named_sibling()* Get the node's next named sibling. -tsnode:prev_named_sibling() *tsnode:prev_named_sibling()* +tsnode:prev_named_sibling() *tsnode:prev_named_sibling()* Get the node's previous named sibling. -tsnode:iter_children() *tsnode:iter_children()* +tsnode:iter_children() *tsnode:iter_children()* Iterates over all the direct children of {tsnode}, regardless of - wether they are named or not. + whether they are named or not. Returns the child node plus the eventual field name corresponding to this child node. @@ -114,10 +117,10 @@ tsnode:child({index}) *tsnode:child()* Get the node's child at the given {index}, where zero represents the first child. -tsnode:named_child_count() *tsnode:named_child_count()* +tsnode:named_child_count() *tsnode:named_child_count()* Get the node's number of named children. -tsnode:named_child({index}) *tsnode:named_child()* +tsnode:named_child({index}) *tsnode:named_child()* Get the node's named child at the given {index}, where zero represents the first named child. @@ -155,22 +158,22 @@ tsnode:sexpr() *tsnode:sexpr()* Get an S-expression representing the node as a string. tsnode:id() *tsnode:id()* - Get an unique identier for the node inside its own tree. + Get an unique identifier for the node inside its own tree. - No guarantees are made about this identifer's internal representation, - except for being a primitive lua type with value equality (so not a table). - Presently it is a (non-printable) string. + No guarantees are made about this identifier's internal + representation, except for being a primitive lua type with value + equality (so not a table). Presently it is a (non-printable) string. Note: the id is not guaranteed to be unique for nodes from different trees. + *tsnode:descendant_for_range()* tsnode:descendant_for_range({start_row}, {start_col}, {end_row}, {end_col}) - *tsnode:descendant_for_range()* Get the smallest node within this node that spans the given range of (row, column) positions + *tsnode:named_descendant_for_range()* tsnode:named_descendant_for_range({start_row}, {start_col}, {end_row}, {end_col}) - *tsnode:named_descendant_for_range()* Get the smallest named node within this node that spans the given range of (row, column) positions @@ -192,41 +195,41 @@ and predicates. A `capture` allows you to associate names with a specific node in a pattern. A `predicate` adds arbitrary metadata and conditional data to a match. -Treesitter Query Predicates *lua-treesitter-predicates* +Treesitter Query Predicates *lua-treesitter-predicates* When writing queries for treesitter, one might use `predicates`, that is, -special scheme nodes that are evaluted to verify things on a captured node for -example, the |eq?| predicate : > +special scheme nodes that are evaluated to verify things on a captured node +for example, the |eq?| predicate : > ((identifier) @foo (#eq? @foo "foo")) This will only match identifier corresponding to the `"foo"` text. Here is a list of built-in predicates : `eq?` *ts-predicate-eq?* - This predicate will check text correspondance between nodes or + This predicate will check text correspondence between nodes or strings : > ((identifier) @foo (#eq? @foo "foo")) ((node1) @left (node2) @right (#eq? @left @right)) < `match?` *ts-predicate-match?* - `vim-match?` *ts-predicate-vim-match?* - This will match if the provived vim regex matches the text + `vim-match?` *ts-predicate-vim-match?* + This will match if the provided vim regex matches the text corresponding to a node : > - ((idenfitier) @constant (#match? @constant "^[A-Z_]+$")) + ((identifier) @constant (#match? @constant "^[A-Z_]+$")) < Note: the `^` and `$` anchors will respectively match the start and end of the node's text. - `lua-match?` *ts-predicate-lua-match?* + `lua-match?` *ts-predicate-lua-match?* This will match the same way than |match?| but using lua regexes. - `contains?` *ts-predicate-contains?* + `contains?` *ts-predicate-contains?* Will check if any of the following arguments appears in the text corresponding to the node : > ((identifier) @foo (#contains? @foo "foo")) ((identifier) @foo-bar (#contains @foo-bar "foo" "bar")) < - `any-of?` *ts-predicate-any-of?* + `any-of?` *ts-predicate-any-of?* Will check if the text is the same as any of the following. This is the recommended way to check if the node matches one of many keywords for example, as it has been optimized for @@ -234,27 +237,27 @@ Here is a list of built-in predicates : arguments : > ((identifier) @foo (#any-of? @foo "foo" "bar")) < - *lua-treesitter-not-predicate* + *lua-treesitter-not-predicate* Each predicate has a `not-` prefixed predicate that is just the negation of the predicate. - *vim.treesitter.query.add_predicate()* + *vim.treesitter.query.add_predicate()* vim.treesitter.query.add_predicate({name}, {handler}) This adds a predicate with the name {name} to be used in queries. {handler} should be a function whose signature will be : > handler(match, pattern, bufnr, predicate) < - *vim.treesitter.query.list_predicates()* + *vim.treesitter.query.list_predicates()* vim.treesitter.query.list_predicates() This lists the currently available predicates to use in queries. -Treesitter Query Directive *lua-treesitter-directives* +Treesitter Query Directive *lua-treesitter-directives* -Treesitter queries can also contain `directives`. Directives store metadata for a node -or match and perform side effects. For example, the |set!| predicate sets metadata on -the match or node : > +Treesitter queries can also contain `directives`. Directives store metadata +for a node or match and perform side effects. For example, the |set!| +predicate sets metadata on the match or node : > ((identifier) @foo (#set! "type" "parameter")) Here is a list of built-in directives: @@ -267,9 +270,9 @@ Here is a list of built-in directives: `offset!` *ts-predicate-offset!* Takes the range of the captured node and applies the offsets to it's range : > - ((idenfitier) @constant (#offset! @constant 0 1 0 -1)) -< This will generate a range object for the captured node with the - offsets applied. The arguments are + ((identifier) @constant (#offset! @constant 0 1 0 -1)) +< This will generate a range object for the captured node with + the offsets applied. The arguments are `({capture_id}, {start_row}, {start_col}, {end_row}, {end_col}, {key?})` The default key is "offset". @@ -279,25 +282,25 @@ vim.treesitter.query.add_directive({name}, {handler}) This adds a directive with the name {name} to be used in queries. {handler} should be a function whose signature will be : > handler(match, pattern, bufnr, predicate, metadata) -Handlers can set match level data by setting directly on the metadata object `metadata.key = value` -Handlers can set node level data by using the capture id on the metadata table -`metadata[capture_id].key = value` +Handlers can set match level data by setting directly on the metadata object +`metadata.key = value` Handlers can set node level data by using the capture +id on the metadata table `metadata[capture_id].key = value` *vim.treesitter.query.list_directives()* vim.treesitter.query.list_directives() This lists the currently available directives to use in queries. -Treesitter syntax highlighting (WIP) *lua-treesitter-highlight* +Treesitter syntax highlighting (WIP) *lua-treesitter-highlight* NOTE: This is a partially implemented feature, and not usable as a default solution yet. What is documented here is a temporary interface intended for those who want to experiment with this feature and contribute to its development. -Highlights are defined in the same query format as in the tree-sitter highlight -crate, with some limitations and additions. Set a highlight query for a -buffer with this code: > +Highlights are defined in the same query format as in the tree-sitter +highlight crate, with some limitations and additions. Set a highlight query +for a buffer with this code: > local query = [[ "for" @keyword @@ -338,7 +341,8 @@ Treesitter Highlighting Priority *lua-treesitter-highlight-priority* Tree-sitter uses |nvim_buf_set_extmark()| to set highlights with a default priority of 100. This enables plugins to set a highlighting priority lower or higher than tree-sitter. It is also possible to change the priority of an -individual query pattern manually by setting its `"priority"` metadata attribute: > +individual query pattern manually by setting its `"priority"` metadata +attribute: > ( (super_important_node) @ImportantHighlight @@ -461,14 +465,15 @@ parse_query({lang}, {query}) *parse_query()* can be used to search nodes in the syntax tree for the patterns defined in {query} using `iter_*` methods below. - Exposes `info` and `captures` with additional information about the {query}. + Exposes `info` and `captures` with additional context about {query}. • `captures` contains the list of unique capture names defined in {query}. - `info.captures` also points to `captures` . • `info.patterns` contains information about predicates. Parameters: ~ - {lang} The language - {query} A string containing the query (s-expr syntax) + {lang} string The language + {query} string A string containing the query (s-expr + syntax) Return: ~ The query @@ -608,10 +613,9 @@ LanguageTree:children({self}) *LanguageTree:children()* {self} LanguageTree:contains({self}, {range}) *LanguageTree:contains()* - Determines whether This goes down the tree to recursively check children. + Determines whether {range} is contained in this language tree - Parameters: ~ - {range} is contained in this language tree + This goes down the tree to recursively check children. Parameters: ~ {range} A range, that is a `{ start_line, start_col, @@ -621,8 +625,9 @@ LanguageTree:contains({self}, {range}) *LanguageTree:contains()* LanguageTree:destroy({self}) *LanguageTree:destroy()* Destroys this language tree and all its children. - Any cleanup logic should be performed here. Note, this DOES - NOT remove this tree from a parent. `remove_child` must be called on the parent to remove it. + Any cleanup logic should be performed here. + + Note: This DOES NOT remove this tree from a parent. Instead, `remove_child` must be called on the parent to remove it. Parameters: ~ {self} @@ -665,7 +670,8 @@ LanguageTree:invalidate({self}, {reload}) *LanguageTree:invalidate()* {self} LanguageTree:is_valid({self}) *LanguageTree:is_valid()* - Determines whether this tree is valid. If the tree is invalid, `parse()` must be called to get the an updated tree. + Determines whether this tree is valid. If the tree is invalid, + call `parse()` . This will return the updated tree. Parameters: ~ {self} @@ -678,7 +684,7 @@ LanguageTree:lang({self}) *LanguageTree:lang()* *LanguageTree:language_for_range()* LanguageTree:language_for_range({self}, {range}) - Gets the appropriate language that contains + Gets the appropriate language that contains {range} Parameters: ~ {range} A text range, see |LanguageTree:contains| @@ -694,13 +700,22 @@ LanguageTree:parse({self}) *LanguageTree:parse()* {self} LanguageTree:register_cbs({self}, {cbs}) *LanguageTree:register_cbs()* - Registers callbacks for the parser - - Parameters: ~ - {cbs} An `nvim_buf_attach` -like table argument with the following keys : `on_bytes` : see `nvim_buf_attach` , but this will be called after the parsers callback. `on_changedtree` : a callback that will be called every time the - tree has syntactical changes. it will only be - passed one argument, that is a table of the ranges - (as node ranges) that changed. `on_child_added` : emitted when a child is added to the tree. `on_child_removed` : emitted when a child is removed from the tree. + Registers callbacks for the parser. + + Parameters: ~ + {cbs} table An |nvim_buf_attach()|-like table argument + with the following keys : + • `on_bytes` : see |nvim_buf_attach()|, but this will be + called after the parsers callback. + • `on_changedtree` : a callback that will be + called every time the tree has syntactical + changes. It will only be passed one argument, + which is a table of the ranges (as node ranges) + that changed. + • `on_child_added` : emitted when a child is added + to the tree. + • `on_child_removed` : emitted when a child is + removed from the tree. {self} LanguageTree:remove_child({self}, {lang}) *LanguageTree:remove_child()* diff --git a/runtime/doc/undo.txt b/runtime/doc/undo.txt index b11d7581ed..a853aea995 100644 --- a/runtime/doc/undo.txt +++ b/runtime/doc/undo.txt @@ -272,12 +272,12 @@ history file. E.g.: > au BufReadPost * call ReadUndo() au BufWritePost * call WriteUndo() func ReadUndo() - if filereadable(expand('%:h'). '/UNDO/' . expand('%:t')) + if filereadable(expand('%:h') .. '/UNDO/' .. expand('%:t')) rundo %:h/UNDO/%:t endif endfunc func WriteUndo() - let dirname = expand('%:h') . '/UNDO' + let dirname = expand('%:h') .. '/UNDO' if !isdirectory(dirname) call mkdir(dirname) endif diff --git a/runtime/doc/usr_04.txt b/runtime/doc/usr_04.txt index b2dd617542..c7c900274b 100644 --- a/runtime/doc/usr_04.txt +++ b/runtime/doc/usr_04.txt @@ -349,15 +349,17 @@ Notice that "yw" includes the white space after a word. If you don't want this, use "ye". The "yy" command yanks a whole line, just like "dd" deletes a whole line. -Unexpectedly, while "D" deletes from the cursor to the end of the line, "Y" -works like "yy", it yanks the whole line. Watch out for this inconsistency! -Use "y$" to yank to the end of the line. a text line yy a text line a text line line 2 line 2 p line 2 last line last line a text line last line +"Y" was originally equivalent to "yank the entire line", as opposed to "D" +which is "delete to end of the line". "Y" has thus been remapped to mean +"yank to end of the line" to make it consistent with the behavior of "D". +Mappings will be covered in later chapters. + ============================================================================== *04.7* Using the clipboard diff --git a/runtime/doc/usr_05.txt b/runtime/doc/usr_05.txt index 2edef0ca23..b1ef563e43 100644 --- a/runtime/doc/usr_05.txt +++ b/runtime/doc/usr_05.txt @@ -11,13 +11,12 @@ Vim's capabilities. Or define your own macros. |05.1| The vimrc file |05.2| The example vimrc file explained -|05.3| The defaults.vim file explained -|05.4| Simple mappings -|05.5| Adding a package -|05.6| Adding a plugin -|05.7| Adding a help file -|05.8| The option window -|05.9| Often used options +|05.3| Simple mappings +|05.4| Adding a package +|05.5| Adding a plugin +|05.6| Adding a help file +|05.7| The option window +|05.8| Often used options Next chapter: |usr_06.txt| Using syntax highlighting Previous chapter: |usr_04.txt| Making small changes @@ -132,7 +131,7 @@ it worked before Vim 5.0. Otherwise the "Q" command starts Ex mode, but you will not need it. > - vnoremap _g y:exe "grep /" . escape(@", '\\/') . "/ *.c *.h"<CR> + vnoremap _g y:exe "grep /" .. escape(@", '\\/') .. "/ *.c *.h"<CR> This mapping yanks the visually selected text and searches for it in C files. This is a complicated mapping. You can see that mappings can be used to do @@ -200,7 +199,7 @@ mapping. If set (default), this may break plugins (but it's backward compatible). See 'langremap'. ============================================================================== -*05.4* Simple mappings +*05.3* Simple mappings A mapping enables you to bind a set of Vim commands to a single key. Suppose, for example, that you need to surround certain words with curly braces. In @@ -247,7 +246,7 @@ The ":map" command (with no arguments) lists your current mappings. At least the ones for Normal mode. More about mappings in section |40.1|. ============================================================================== -*05.5* Adding a package *add-package* *vimball-install* +*05.4* Adding a package *add-package* *vimball-install* A package is a set of files that you can add to Vim. There are two kinds of packages: optional and automatically loaded on startup. @@ -287,7 +286,7 @@ an archive or as a repository. For an archive you can follow these steps: More information about packages can be found here: |packages|. ============================================================================== -*05.6* Adding a plugin *add-plugin* *plugin* +*05.5* Adding a plugin *add-plugin* *plugin* Vim's functionality can be extended by adding plugins. A plugin is nothing more than a Vim script file that is loaded automatically when Vim starts. You @@ -423,7 +422,7 @@ Further reading: |new-filetype| How to detect a new file type. ============================================================================== -*05.7* Adding a help file *add-local-help* +*05.6* Adding a help file *add-local-help* If you are lucky, the plugin you installed also comes with a help file. We will explain how to install the help file, so that you can easily find help @@ -456,7 +455,7 @@ them through the tag. For writing a local help file, see |write-local-help|. ============================================================================== -*05.8* The option window +*05.7* The option window If you are looking for an option that does what you want, you can search in the help files here: |options|. Another way is by using this command: > @@ -495,7 +494,7 @@ border. This is what the 'scrolloff' option does, it specifies an offset from the window border where scrolling starts. ============================================================================== -*05.9* Often used options +*05.8* Often used options There are an awful lot of options. Most of them you will hardly ever use. Some of the more useful ones will be mentioned here. Don't forget you can diff --git a/runtime/doc/usr_07.txt b/runtime/doc/usr_07.txt index 649be8d7ce..ebf5c3d7b8 100644 --- a/runtime/doc/usr_07.txt +++ b/runtime/doc/usr_07.txt @@ -336,7 +336,7 @@ there. > Of course you can use many other commands to yank the text. For example, to select whole lines start Visual mode with "V". Or use CTRL-V to select a -rectangular block. Or use "Y" to yank a single line, "yaw" to yank-a-word, +rectangular block. Or use "yy" to yank a single line, "yaw" to yank-a-word, etc. The "p" command puts the text after the cursor. Use "P" to put the text before the cursor. Notice that Vim remembers if you yanked a whole line or a @@ -359,7 +359,7 @@ the text should be placed in the f register. This must come just before the yank command. Now yank three whole lines to the l register (l for line): > - "l3Y + "l3yy The count could be before the "l just as well. To yank a block of text to the b (for block) register: > diff --git a/runtime/doc/usr_10.txt b/runtime/doc/usr_10.txt index 5365f90314..8844671e01 100644 --- a/runtime/doc/usr_10.txt +++ b/runtime/doc/usr_10.txt @@ -132,11 +132,11 @@ This works both with recording and with yank and delete commands. For example, you want to collect a sequence of lines into the a register. Yank the first line with: > - "aY + "ayy Now move to the second line, and type: > - "AY + "Ayy Repeat this command for all lines. The a register now contains all those lines, in the order you yanked them. diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt index 7e611a47f3..bf024315f6 100644 --- a/runtime/doc/usr_41.txt +++ b/runtime/doc/usr_41.txt @@ -549,7 +549,7 @@ A "&" character is prepended to "path", thus the argument to eval() is Vim defines many functions and provides a large amount of functionality that way. A few examples will be given in this section. You can find the whole -list here: |functions|. +list below: |function-list|. A function is called with the ":call" command. The parameters are passed in between parentheses separated by commas. Example: > @@ -588,8 +588,8 @@ after the substitute() call. FUNCTIONS *function-list* There are many functions. We will mention them here, grouped by what they are -used for. You can find an alphabetical list here: |functions|. Use CTRL-] on -the function name to jump to detailed help on it. +used for. You can find an alphabetical list here: |builtin-function-list|. +Use CTRL-] on the function name to jump to detailed help on it. String manipulation: *string-functions* nr2char() get a character by its number value @@ -608,6 +608,8 @@ String manipulation: *string-functions* toupper() turn a string to uppercase match() position where a pattern matches in a string matchend() position where a pattern match ends in a string + matchfuzzy() fuzzy matches a string in a list of strings + matchfuzzypos() fuzzy matches a string in a list of strings matchstr() match of a pattern in a string matchstrpos() match and positions of a pattern in a string matchlist() like matchstr() and also return submatches @@ -746,6 +748,11 @@ Cursor and mark position: *cursor-functions* *mark-functions* screenchar() get character code at a screen line/row screenchars() get character codes at a screen line/row screenstring() get string of characters at a screen line/row + charcol() character number of the cursor or a mark + getcharpos() get character position of cursor, mark, etc. + setcharpos() set character position of cursor, mark, etc. + getcursorcharpos() get character position of the cursor + setcursorcharpos() set character position of the cursor Working with text in the current buffer: *text-functions* getline() get a line or list of lines from the buffer @@ -837,6 +844,8 @@ Buffers, windows and the argument list: win_gotoid() go to window with ID win_id2tabwin() get tab and window nr from window ID win_id2win() get window nr from window ID + win_move_separator() move window vertical separator + win_move_statusline() move window status line getbufinfo() get a list with buffer information gettabinfo() get a list with tab page information getwininfo() get a list with window information diff --git a/runtime/doc/usr_toc.txt b/runtime/doc/usr_toc.txt index f466a8ece9..bf9c02882c 100644 --- a/runtime/doc/usr_toc.txt +++ b/runtime/doc/usr_toc.txt @@ -99,13 +99,12 @@ Read this from start to end to learn the essential commands. |usr_05.txt| Set your settings |05.1| The vimrc file |05.2| The example vimrc file explained - |05.3| The defaults.vim file explained - |05.4| Simple mappings - |05.5| Adding a package - |05.6| Adding a plugin - |05.7| Adding a help file - |05.8| The option window - |05.9| Often used options + |05.3| Simple mappings + |05.4| Adding a package + |05.5| Adding a plugin + |05.6| Adding a help file + |05.7| The option window + |05.8| Often used options |usr_06.txt| Using syntax highlighting |06.1| Switching it on diff --git a/runtime/doc/various.txt b/runtime/doc/various.txt index 8a4468a130..19e429fde2 100644 --- a/runtime/doc/various.txt +++ b/runtime/doc/various.txt @@ -249,7 +249,7 @@ g8 Print the hex values of the bytes used in the To enter |Terminal-mode| automatically: > autocmd TermOpen * startinsert < - *:!cmd* *:!* *E34* + *:!cmd* *:!* :!{cmd} Execute {cmd} with 'shell'. See also |:terminal|. The command runs in a non-interactive shell connected @@ -261,6 +261,7 @@ g8 Print the hex values of the bytes used in the Use |jobstart()| instead. > :call jobstart('foo', {'detach':1}) < + *E34* Any "!" in {cmd} is replaced with the previous external command (see also 'cpoptions'), unless escaped by a backslash. Example: ":!ls" followed by @@ -274,7 +275,7 @@ g8 Print the hex values of the bytes used in the Special characters are not escaped, use quotes or |shellescape()|: > :!ls "%" - :exe "!ls " . shellescape(expand("%")) + :exe "!ls " .. shellescape(expand("%")) < Newline character ends {cmd} unless a backslash precedes the newline. What follows is interpreted as @@ -357,19 +358,19 @@ g8 Print the hex values of the bytes used in the :redi[r] END End redirecting messages. *:filt* *:filter* -:filt[er][!] {pat} {command} -:filt[er][!] /{pat}/ {command} +:filt[er][!] {pattern} {command} +:filt[er][!] /{pattern}/ {command} Restrict the output of {command} to lines matching - with {pat}. For example, to list only xml files: > + with {pattern}. For example, to list only xml files: > :filter /\.xml$/ oldfiles < If the [!] is given, restrict the output of {command} - to lines that do NOT match {pat}. + to lines that do NOT match {pattern}. - {pat} is a Vim search pattern. Instead of enclosing + {pattern} is a Vim search pattern. Instead of enclosing it in / any non-ID character (see |'isident'|) can be - used, so long as it does not appear in {pat}. Without - the enclosing character the pattern cannot include the - bar character. 'ignorecase' is not used. + used, so long as it does not appear in {pattern}. + Without the enclosing character the pattern cannot + include the bar character. 'ignorecase' is not used. The pattern is matched against the relevant part of the output, not necessarily the whole line. Only some @@ -387,6 +388,8 @@ g8 Print the hex values of the bytes used in the |:marks| - filter by text in the current file, or file name for other files |:oldfiles| - filter by file name + |:registers| - filter by register contents + (does not work multi-line) |:set| - filter by option name Only normal messages are filtered, error messages are @@ -429,7 +432,7 @@ g8 Print the hex values of the bytes used in the used. In this example |:silent| is used to avoid the message about reading the file and |:unsilent| to be able to list the first line of each file. > - :silent argdo unsilent echo expand('%') . ": " . getline(1) + :silent argdo unsilent echo expand('%') .. ": " .. getline(1) < *:verb* *:verbose* @@ -458,10 +461,11 @@ g8 Print the hex values of the bytes used in the *:verbose-cmd* When 'verbose' is non-zero, listing the value of a Vim option or a key map or an abbreviation or a user-defined function or a command or a highlight group -or an autocommand will also display where it was last defined. If it was -defined manually then there will be no "Last set" message. When it was -defined while executing a function, user command or autocommand, the script in -which it was defined is reported. +or an autocommand will also display where it was last defined. If they were +defined in Lua they will only be located if 'verbose' is set. So Start +nvim with -V1 arg to see them. If it was defined manually then there +will be no "Last set" message. When it was defined while executing a function, +user command or autocommand, the script in which it was defined is reported. *K* [count]K Runs the program given by 'keywordprg' to lookup the diff --git a/runtime/doc/vim_diff.txt b/runtime/doc/vim_diff.txt index 4fcaf15717..90f56e2566 100644 --- a/runtime/doc/vim_diff.txt +++ b/runtime/doc/vim_diff.txt @@ -23,8 +23,10 @@ centralized reference of the differences. ============================================================================== 2. Defaults *nvim-defaults* -- Syntax highlighting is enabled by default -- ":filetype plugin indent on" is enabled by default +- Filetype detection is enabled by default. This can be disabled by adding + ":filetype off" to |init.vim|. +- Syntax highlighting is enabled by default. This can be disabled by adding + ":syntax off" to |init.vim|. - 'autoindent' is enabled - 'autoread' is enabled @@ -320,6 +322,8 @@ coerced to strings. See |id()| for more details, currently it uses |c_CTRL-R| pasting a non-special register into |cmdline| omits the last <CR>. +|CursorMoved| always triggers when moving between windows. + Lua interface (|lua.txt|): - `:lua print("a\0b")` will print `a^@b`, like with `:echomsg "a\nb"` . In Vim @@ -354,6 +358,10 @@ Macro/|recording| behavior macros and 'keymap' at the same time. This also means you can use |:imap| on the results of keys from 'keymap'. +Mappings: +- A mapping whose {lhs} starts with <Plug> is always applied even if mapping + is disallowed by |nore|. + Motion: The |jumplist| avoids useless/phantom jumps. @@ -429,7 +437,8 @@ Vimscript compatibility: `this_session` does not alias to |v:this_session| Working directory (Vim implemented some of these later than Nvim): -- |DirChanged| can be triggered when switching to another window. +- |DirChanged| and |DirChangedPre| can be triggered when switching to another + window or tab. - |getcwd()| and |haslocaldir()| may throw errors if the tab page or window cannot be found. *E5000* *E5001* *E5002* - |haslocaldir()| checks for tab-local directory if and only if -1 is passed as @@ -481,7 +490,6 @@ Commands: :tearoff Compile-time features: - EBCDIC Emacs tags support X11 integration (see |x11-selection|) @@ -490,6 +498,9 @@ Eval: *js_encode()* *js_decode()* *v:none* (used by Vim to represent JavaScript "undefined"); use |v:null| instead. + *v:sizeofint* + *v:sizeoflong* + *v:sizeofpointer* Events: *SigUSR1* Use |Signal| to detect `SIGUSR1` signal instead. @@ -572,6 +583,7 @@ Test functions: test_scrollbar() test_setmouse() test_settime() + test_srand_seed() TUI: *t_xx* *termcap-options* *t_AB* *t_Sb* *t_vb* *t_SI* diff --git a/runtime/doc/visual.txt b/runtime/doc/visual.txt index 4a69fc989b..4d5366a41a 100644 --- a/runtime/doc/visual.txt +++ b/runtime/doc/visual.txt @@ -255,6 +255,7 @@ Additionally the following commands can be used: X delete (2) |v_X| Y yank (2) |v_Y| p put |v_p| + P put without unnamed register overwrite |v_P| J join (1) |v_J| U make uppercase |v_U| u make lowercase |v_u| @@ -478,6 +479,10 @@ Commands in Select mode: - ESC stops Select mode. - CTRL-O switches to Visual mode for the duration of one command. *v_CTRL-O* - CTRL-G switches to Visual mode. +- CTRL-R {register} selects the register to be used for the text that is + deleted when typing text. *v_CTRL-R* + Unless you specify the "_" (black hole) register, the unnamed register is + also overwritten. Otherwise, typed characters are handled as in Visual mode. diff --git a/runtime/doc/windows.txt b/runtime/doc/windows.txt index bb31895c96..bd29cd1d7a 100644 --- a/runtime/doc/windows.txt +++ b/runtime/doc/windows.txt @@ -124,7 +124,7 @@ highlight group (|hl-EndOfBuffer|) can be used to change the highlighting of the filler characters. ============================================================================== -3. Opening and closing a window *opening-window* *E36* +3. Opening and closing a window *opening-window* CTRL-W s *CTRL-W_s* CTRL-W S *CTRL-W_S* @@ -223,6 +223,10 @@ CTRL-W ge *CTRL-W_ge* Note that the 'splitbelow' and 'splitright' options influence where a new window will appear. + *E36* +Creating a window will fail if there is not enough room. Every window needs +at least one screen line and column, sometimes more. Options 'winminheight' +and 'winminwidth' are relevant. *:vert* *:vertical* :vert[ical] {cmd} @@ -443,7 +447,7 @@ These commands can also be executed with ":wincmd": the |CursorHold| autocommand event). Or when a Normal mode command is inconvenient. The count can also be a window number. Example: > - :exe nr . "wincmd w" + :exe nr .. "wincmd w" < This goes to window "nr". ============================================================================== @@ -905,12 +909,12 @@ CTRL-W g } *CTRL-W_g}* cursor. This is less clever than using |:ptag|, but you don't need a tags file and it will also find matches in system include files. Example: > - :au! CursorHold *.[ch] ++nested exe "silent! psearch " . expand("<cword>") + :au! CursorHold *.[ch] ++nested exe "silent! psearch " .. expand("<cword>") < Warning: This can be slow. Example *CursorHold-example* > - :au! CursorHold *.[ch] ++nested exe "silent! ptag " . expand("<cword>") + :au! CursorHold *.[ch] ++nested exe "silent! ptag " .. expand("<cword>") This will cause a ":ptag" to be executed for the keyword under the cursor, when the cursor hasn't moved for the time set with 'updatetime'. "++nested" @@ -933,14 +937,14 @@ is no word under the cursor, and a few other things: > : : " Delete any existing highlight before showing another tag : silent! wincmd P " jump to preview window - : if &previewwindow " if we really get there... + : if &previewwindow " if we really get there... : match none " delete existing highlight : wincmd p " back to old window : endif : : " Try displaying a matching tag for the word under the cursor : try - : exe "ptag " . w + : exe "ptag " .. w : catch : return : endtry @@ -952,10 +956,10 @@ is no word under the cursor, and a few other things: > : endif : call search("$", "b") " to end of previous line : let w = substitute(w, '\\', '\\\\', "") - : call search('\<\V' . w . '\>') " position cursor on match + : call search('\<\V' .. w .. '\>') " position cursor on match : " Add a match highlight to the word at this position : hi previewWord term=bold ctermbg=green guibg=green - : exe 'match previewWord "\%' . line(".") . 'l\%' . col(".") . 'c\k*"' + : exe 'match previewWord "\%' .. line(".") .. 'l\%' .. col(".") .. 'c\k*"' : wincmd p " back to old window : endif : endif |