blob: 314a3f863d04fdbe6f71f25b83f1439f68f83b15 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * evalfunc.c: Builtin functions
12 */
13#define USING_FLOAT_STUFF
14
15#include "vim.h"
16
17#if defined(FEAT_EVAL) || defined(PROTO)
18
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020019#ifdef VMS
20# include <float.h>
21#endif
22
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020023static void f_and(typval_T *argvars, typval_T *rettv);
Bram Moolenaar59716a22017-03-01 20:32:44 +010024#ifdef FEAT_BEVAL
Bram Moolenaarbe0a2592019-05-09 13:50:16 +020025static void f_balloon_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar59716a22017-03-01 20:32:44 +010026static void f_balloon_show(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010027# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +010028static void f_balloon_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010029# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +010030#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020031static void f_byte2line(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020032static void f_call(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020033static void f_changenr(typval_T *argvars, typval_T *rettv);
34static void f_char2nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010035static void f_charcol(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020036static void f_col(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020037static void f_confirm(typval_T *argvars, typval_T *rettv);
38static void f_copy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020039static void f_cursor(typval_T *argsvars, typval_T *rettv);
Bram Moolenaar4f974752019-02-17 17:44:42 +010040#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +020041static void f_debugbreak(typval_T *argvars, typval_T *rettv);
42#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020043static void f_deepcopy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020044static void f_did_filetype(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4132eb52020-02-14 16:53:00 +010045static void f_echoraw(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020046static void f_empty(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020047static void f_environ(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020048static void f_escape(typval_T *argvars, typval_T *rettv);
49static void f_eval(typval_T *argvars, typval_T *rettv);
50static void f_eventhandler(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020051static void f_execute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar26735992021-08-08 14:43:22 +020052static void f_exists_compiled(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020053static void f_expand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar80dad482019-06-09 17:22:31 +020054static void f_expandcmd(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020055static void f_feedkeys(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020056static void f_fnameescape(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020057static void f_foreground(typval_T *argvars, typval_T *rettv);
Bram Moolenaar437bafe2016-08-01 15:40:54 +020058static void f_funcref(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020059static void f_function(typval_T *argvars, typval_T *rettv);
60static void f_garbagecollect(typval_T *argvars, typval_T *rettv);
61static void f_get(typval_T *argvars, typval_T *rettv);
Bram Moolenaar07ad8162018-02-13 13:59:59 +010062static void f_getchangelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010063static void f_getcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020064static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020065static void f_getenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020066static void f_getfontname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4f505882018-02-10 21:06:32 +010067static void f_getjumplist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020068static void f_getpid(typval_T *argvars, typval_T *rettv);
69static void f_getcurpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010070static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020071static void f_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020072static void f_getreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020073static void f_getreginfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020074static void f_getregtype(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010075static void f_gettagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +020076static void f_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020077static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020078static void f_hlID(typval_T *argvars, typval_T *rettv);
79static void f_hlexists(typval_T *argvars, typval_T *rettv);
80static void f_hostname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020081static void f_index(typval_T *argvars, typval_T *rettv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +010082static void f_indexof(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020083static void f_input(typval_T *argvars, typval_T *rettv);
84static void f_inputdialog(typval_T *argvars, typval_T *rettv);
85static void f_inputlist(typval_T *argvars, typval_T *rettv);
86static void f_inputrestore(typval_T *argvars, typval_T *rettv);
87static void f_inputsave(typval_T *argvars, typval_T *rettv);
88static void f_inputsecret(typval_T *argvars, typval_T *rettv);
Bram Moolenaar67a2deb2019-11-25 00:05:32 +010089static void f_interrupt(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020090static void f_invert(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020091static void f_islocked(typval_T *argvars, typval_T *rettv);
zeertzjqcdc83932022-09-12 13:38:41 +010092static void f_keytrans(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020093static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020094static void f_libcall(typval_T *argvars, typval_T *rettv);
95static void f_libcallnr(typval_T *argvars, typval_T *rettv);
96static void f_line(typval_T *argvars, typval_T *rettv);
97static void f_line2byte(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020098#ifdef FEAT_LUA
99static void f_luaeval(typval_T *argvars, typval_T *rettv);
100#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200101static void f_match(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200102static void f_matchend(typval_T *argvars, typval_T *rettv);
103static void f_matchlist(typval_T *argvars, typval_T *rettv);
104static void f_matchstr(typval_T *argvars, typval_T *rettv);
105static void f_matchstrpos(typval_T *argvars, typval_T *rettv);
106static void f_max(typval_T *argvars, typval_T *rettv);
107static void f_min(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200108#ifdef FEAT_MZSCHEME
109static void f_mzeval(typval_T *argvars, typval_T *rettv);
110#endif
111static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
112static void f_nr2char(typval_T *argvars, typval_T *rettv);
113static void f_or(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200114#ifdef FEAT_PERL
115static void f_perleval(typval_T *argvars, typval_T *rettv);
116#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200117static void f_prevnonblank(typval_T *argvars, typval_T *rettv);
118static void f_printf(typval_T *argvars, typval_T *rettv);
Bram Moolenaare9bd5722019-08-17 19:36:06 +0200119static void f_pum_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200120static void f_pumvisible(typval_T *argvars, typval_T *rettv);
121#ifdef FEAT_PYTHON3
122static void f_py3eval(typval_T *argvars, typval_T *rettv);
123#endif
124#ifdef FEAT_PYTHON
125static void f_pyeval(typval_T *argvars, typval_T *rettv);
126#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100127#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
128static void f_pyxeval(typval_T *argvars, typval_T *rettv);
129#endif
Bram Moolenaar4f645c52020-02-08 16:40:39 +0100130static void f_test_srand_seed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100131static void f_rand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200132static void f_range(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200133static void f_reg_executing(typval_T *argvars, typval_T *rettv);
134static void f_reg_recording(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200135static void f_rename(typval_T *argvars, typval_T *rettv);
136static void f_repeat(typval_T *argvars, typval_T *rettv);
Bram Moolenaare99be0e2019-03-26 22:51:09 +0100137#ifdef FEAT_RUBY
138static void f_rubyeval(typval_T *argvars, typval_T *rettv);
139#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200140static void f_screenattr(typval_T *argvars, typval_T *rettv);
141static void f_screenchar(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100142static void f_screenchars(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200143static void f_screencol(typval_T *argvars, typval_T *rettv);
144static void f_screenrow(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100145static void f_screenstring(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200146static void f_search(typval_T *argvars, typval_T *rettv);
147static void f_searchdecl(typval_T *argvars, typval_T *rettv);
148static void f_searchpair(typval_T *argvars, typval_T *rettv);
149static void f_searchpairpos(typval_T *argvars, typval_T *rettv);
150static void f_searchpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100151static void f_setcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200152static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100153static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +0200154static void f_setenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200155static void f_setfperm(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200156static void f_setpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200157static void f_setreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100158static void f_settagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200159#ifdef FEAT_CRYPT
160static void f_sha256(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb005cd82019-09-04 15:54:55 +0200161#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200162static void f_shellescape(typval_T *argvars, typval_T *rettv);
163static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200164static void f_soundfold(typval_T *argvars, typval_T *rettv);
165static void f_spellbadword(typval_T *argvars, typval_T *rettv);
166static void f_spellsuggest(typval_T *argvars, typval_T *rettv);
167static void f_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100168static void f_srand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200169static void f_submatch(typval_T *argvars, typval_T *rettv);
170static void f_substitute(typval_T *argvars, typval_T *rettv);
Bram Moolenaarc216a7a2022-12-05 13:50:55 +0000171static void f_swapfilelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200172static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200173static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200174static void f_synID(typval_T *argvars, typval_T *rettv);
175static void f_synIDattr(typval_T *argvars, typval_T *rettv);
176static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
177static void f_synstack(typval_T *argvars, typval_T *rettv);
178static void f_synconcealed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200179static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200180static void f_taglist(typval_T *argvars, typval_T *rettv);
181static void f_tagfiles(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200182static void f_type(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200183static void f_virtcol(typval_T *argvars, typval_T *rettv);
184static void f_visualmode(typval_T *argvars, typval_T *rettv);
185static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0c1e3742019-12-27 13:49:24 +0100186static void f_windowsversion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200187static void f_wordcount(typval_T *argvars, typval_T *rettv);
188static void f_xor(typval_T *argvars, typval_T *rettv);
189
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100190
Bram Moolenaar94738d82020-10-21 14:25:07 +0200191/*
192 * Functions that check the argument type of a builtin function.
193 * Each function returns FAIL and gives an error message if the type is wrong.
194 */
195
196// Context passed to an arg_ function.
197typedef struct {
Bram Moolenaarca174532020-10-21 16:42:22 +0200198 int arg_count; // actual argument count
Bram Moolenaar078a4612022-01-04 15:17:03 +0000199 type2_T *arg_types; // list of argument types
Bram Moolenaarca174532020-10-21 16:42:22 +0200200 int arg_idx; // current argument index (first arg is zero)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100201 cctx_T *arg_cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +0200202} argcontext_T;
203
204// A function to check one argument type. The first argument is the type to
205// check. If needed, other argument types can be obtained with the context.
206// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.
Bram Moolenaar078a4612022-01-04 15:17:03 +0000207typedef int (*argcheck_T)(type_T *, type_T *, argcontext_T *);
Bram Moolenaar94738d82020-10-21 14:25:07 +0200208
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100209/*
Bram Moolenaar351ead02021-01-16 16:07:01 +0100210 * Call need_type() to check an argument type.
211 */
212 static int
213check_arg_type(
214 type_T *expected,
215 type_T *actual,
216 argcontext_T *context)
217{
Bram Moolenaarc6951a72022-12-29 20:56:24 +0000218 return need_type(actual, expected, FALSE,
Bram Moolenaar351ead02021-01-16 16:07:01 +0100219 context->arg_idx - context->arg_count, context->arg_idx + 1,
220 context->arg_cctx, FALSE, FALSE);
221}
222
223/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100224 * Call need_type() to check an argument type and that it is modifiable
225 */
226 static int
227check_arg_type_mod(
228 type_T *expected,
229 type_T *actual,
230 argcontext_T *context)
231{
Bram Moolenaarc6951a72022-12-29 20:56:24 +0000232 if (need_type(actual, expected, FALSE,
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100233 context->arg_idx - context->arg_count, context->arg_idx + 1,
234 context->arg_cctx, FALSE, FALSE) == FAIL)
235 return FAIL;
236 return arg_type_modifiable(actual, context->arg_idx + 1);
237}
238
239/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100240 * Give an error if "type" is a constant.
241 */
242 int
243arg_type_modifiable(type_T *type, int arg_idx)
244{
245 char *tofree;
246
247 if ((type->tt_flags & TTFLAG_CONST) == 0)
248 return OK;
249 semsg(_(e_argument_nr_trying_to_modify_const_str),
250 arg_idx, type_name(type, &tofree));
251 vim_free(tofree);
252 return FAIL;
253}
254
255/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100256 * Check "type" is a float or a number.
257 */
Bram Moolenaar94738d82020-10-21 14:25:07 +0200258 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000259arg_float_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200260{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100261 if (type->tt_type == VAR_FLOAT
262 || type->tt_type == VAR_NUMBER
263 || type_any_or_unknown(type))
Bram Moolenaar94738d82020-10-21 14:25:07 +0200264 return OK;
265 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
266 return FAIL;
267}
268
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100269/*
270 * Check "type" is a number.
271 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200272 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000273arg_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200274{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100275 return check_arg_type(&t_number, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200276}
277
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100278/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200279 * Check "type" is a dict of 'any'.
280 */
281 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000282arg_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200283{
284 return check_arg_type(&t_dict_any, type, context);
285}
286
287/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200288 * Check "type" is a list of 'any'.
289 */
290 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000291arg_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200292{
293 return check_arg_type(&t_list_any, type, context);
294}
295
296/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100297 * Check "type" is a list of 'any' and modifiable
298 */
299 static int
300arg_list_any_mod(
301 type_T *type,
302 type_T *decl_type UNUSED,
303 argcontext_T *context)
304{
305 return check_arg_type_mod(&t_list_any, type, context);
306}
307
308/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200309 * Check "type" is a list of numbers.
310 */
311 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000312arg_list_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200313{
314 return check_arg_type(&t_list_number, type, context);
315}
316
317/*
318 * Check "type" is a list of strings.
319 */
320 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000321arg_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200322{
323 return check_arg_type(&t_list_string, type, context);
324}
325
326/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100327 * Check "type" is a string.
328 */
329 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000330arg_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100331{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100332 return check_arg_type(&t_string, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100333}
334
335/*
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200336 * Check "type" is a blob
337 */
338 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000339arg_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200340{
341 return check_arg_type(&t_blob, type, context);
342}
343
344/*
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100345 * Check "type" is a bool or number 0 or 1.
346 */
347 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000348arg_bool(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100349{
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100350 return check_arg_type(&t_bool, type, context);
351}
352
353/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200354 * Check "type" is a list of 'any' or a blob.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100355 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200356 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000357arg_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200358{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100359 if (type->tt_type == VAR_LIST
360 || type->tt_type == VAR_BLOB
361 || type_any_or_unknown(type))
Bram Moolenaarca174532020-10-21 16:42:22 +0200362 return OK;
363 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
364 return FAIL;
365}
366
367/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100368 * Check "type" is a modifiable list of 'any' or a blob.
369 */
370 static int
371arg_list_or_blob_mod(
372 type_T *type,
373 type_T *decl_type,
374 argcontext_T *context)
375{
376 if (arg_list_or_blob(type, decl_type, context) == FAIL)
377 return FAIL;
378 return arg_type_modifiable(type, context->arg_idx + 1);
379}
380
381/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200382 * Check "type" is a string or a number
383 */
384 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000385arg_string_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200386{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100387 if (type->tt_type == VAR_STRING
388 || type->tt_type == VAR_NUMBER
389 || type_any_or_unknown(type))
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200390 return OK;
391 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
392 return FAIL;
393}
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200394
395/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200396 * Check "type" is a buffer (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200397 */
398 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000399arg_buffer(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200400{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100401 if (type->tt_type == VAR_STRING
402 || type->tt_type == VAR_NUMBER
403 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200404 return OK;
405 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
406 return FAIL;
407}
408
409/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200410 * Check "type" is a buffer or a dict of any
411 */
412 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000413arg_buffer_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200414{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100415 if (type->tt_type == VAR_STRING
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200416 || type->tt_type == VAR_NUMBER
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100417 || type->tt_type == VAR_DICT
418 || type_any_or_unknown(type))
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200419 return OK;
420 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
421 return FAIL;
422}
423
424/*
425 * Check "type" is a line (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200426 */
427 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000428arg_lnum(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200429{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100430 if (type->tt_type == VAR_STRING
431 || type->tt_type == VAR_NUMBER
432 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200433 return OK;
434 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
435 return FAIL;
436}
437
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200438/*
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200439 * Check "type" is a string or a list of strings.
440 */
441 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000442arg_string_or_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200443{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100444 if (type->tt_type == VAR_STRING
445 || type_any_or_unknown(type))
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200446 return OK;
447 if (type->tt_type != VAR_LIST)
448 {
449 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
450 return FAIL;
451 }
452 if (type->tt_member->tt_type == VAR_ANY
453 || type->tt_member->tt_type == VAR_STRING)
454 return OK;
455
456 arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);
457 return FAIL;
458}
459
460/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200461 * Check "type" is a string or a list of 'any'
462 */
463 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000464arg_string_or_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200465{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100466 if (type->tt_type == VAR_STRING
467 || type->tt_type == VAR_LIST
468 || type_any_or_unknown(type))
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200469 return OK;
470 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
471 return FAIL;
472}
473
474/*
Ernie Rael51d04d12022-05-04 15:40:22 +0100475 * Check "type" is a string or a dict of 'any'
476 */
477 static int
478arg_string_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
479{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100480 if (type->tt_type == VAR_STRING
481 || type->tt_type == VAR_DICT
482 || type_any_or_unknown(type))
Ernie Rael51d04d12022-05-04 15:40:22 +0100483 return OK;
484 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
485 return FAIL;
486}
487
488/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200489 * Check "type" is a string or a blob
490 */
491 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000492arg_string_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200493{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100494 if (type->tt_type == VAR_STRING
495 || type->tt_type == VAR_BLOB
496 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200497 return OK;
498 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
499 return FAIL;
500}
501
502/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200503 * Check "type" is a list of 'any' or a dict of 'any'.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100504 */
505 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000506arg_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100507{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100508 if (type->tt_type == VAR_LIST
509 || type->tt_type == VAR_DICT
510 || type_any_or_unknown(type))
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100511 return OK;
512 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
513 return FAIL;
514}
515
516/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100517 * Check "type" is a list of 'any' or a dict of 'any'. And modifiable.
518 */
519 static int
520arg_list_or_dict_mod(
521 type_T *type,
522 type_T *decl_type,
523 argcontext_T *context)
524{
525 if (arg_list_or_dict(type, decl_type, context) == FAIL)
526 return FAIL;
527 return arg_type_modifiable(type, context->arg_idx + 1);
528}
529
530/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200531 * Check "type" is a list of 'any' or a dict of 'any' or a blob.
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100532 * Also check if "type" is modifiable.
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200533 */
534 static int
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100535arg_list_or_dict_or_blob_mod(
536 type_T *type,
537 type_T *decl_type UNUSED,
538 argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200539{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100540 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000541 || type->tt_type == VAR_DICT
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100542 || type->tt_type == VAR_BLOB
543 || type_any_or_unknown(type))
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100544 return arg_type_modifiable(type, context->arg_idx + 1);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200545 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
546 return FAIL;
547}
548
549/*
Bram Moolenaar2d877592021-12-16 08:21:09 +0000550 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
551 */
552 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000553arg_list_or_dict_or_blob_or_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar2d877592021-12-16 08:21:09 +0000554{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100555 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000556 || type->tt_type == VAR_DICT
557 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100558 || type->tt_type == VAR_STRING
559 || type_any_or_unknown(type))
Bram Moolenaar2d877592021-12-16 08:21:09 +0000560 return OK;
561 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
562 return FAIL;
563}
564
565/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100566 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
567 * Also check the value is modifiable.
568 */
569 static int
570arg_list_or_dict_or_blob_or_string_mod(
571 type_T *type,
572 type_T *decl_type,
573 argcontext_T *context)
574{
575 if (arg_list_or_dict_or_blob_or_string(type, decl_type, context) == FAIL)
576 return FAIL;
577 return arg_type_modifiable(type, context->arg_idx + 1);
578}
579
580/*
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000581 * Check second argument of map() or filter().
582 */
583 static int
584check_map_filter_arg2(type_T *type, argcontext_T *context, int is_map)
585{
586 type_T *expected_member = NULL;
587 type_T *(args[2]);
588 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, NULL, args};
589
590 if (context->arg_types[0].type_curr->tt_type == VAR_LIST
591 || context->arg_types[0].type_curr->tt_type == VAR_DICT)
592 {
593 // Use the declared type if possible, so that an error is given if
594 // a declared list changes type, but not if a constant list changes
595 // type.
596 if (context->arg_types[0].type_decl->tt_type == VAR_LIST
597 || context->arg_types[0].type_decl->tt_type == VAR_DICT)
598 expected_member = context->arg_types[0].type_decl->tt_member;
599 else
600 expected_member = context->arg_types[0].type_curr->tt_member;
601 }
602 else if (context->arg_types[0].type_curr->tt_type == VAR_STRING)
603 expected_member = &t_string;
604 else if (context->arg_types[0].type_curr->tt_type == VAR_BLOB)
605 expected_member = &t_number;
606
607 args[0] = NULL;
608 args[1] = &t_unknown;
609 if (type->tt_argcount != -1)
610 {
611 if (!(type->tt_argcount == 2 || (type->tt_argcount == 1
612 && (type->tt_flags & TTFLAG_VARARGS))))
613 {
614 emsg(_(e_invalid_number_of_arguments));
615 return FAIL;
616 }
617 if (type->tt_flags & TTFLAG_VARARGS)
618 // check the argument types at runtime
619 t_func_exp.tt_argcount = -1;
620 else
621 {
622 if (context->arg_types[0].type_curr->tt_type == VAR_STRING
623 || context->arg_types[0].type_curr->tt_type == VAR_BLOB
624 || context->arg_types[0].type_curr->tt_type == VAR_LIST)
625 args[0] = &t_number;
626 else if (context->arg_types[0].type_decl->tt_type == VAR_DICT)
627 args[0] = &t_string;
628 if (args[0] != NULL)
629 args[1] = expected_member;
630 }
631 }
632
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100633 if (!type_any_or_unknown(type->tt_member) || args[0] != NULL)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000634 {
635 where_T where = WHERE_INIT;
636
637 if (is_map)
638 t_func_exp.tt_member = expected_member == NULL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100639 || type_any_or_unknown(type->tt_member)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000640 ? &t_any : expected_member;
641 else
642 t_func_exp.tt_member = &t_bool;
643 if (args[0] == NULL)
644 args[0] = &t_unknown;
Bram Moolenaar6e1a3872022-02-23 19:11:49 +0000645 if (type->tt_argcount == -1)
646 t_func_exp.tt_argcount = -1;
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000647
648 where.wt_index = 2;
649 return check_type(&t_func_exp, type, TRUE, where);
650 }
651 return OK;
652}
653
654/*
Bram Moolenaar18024052021-12-25 21:43:28 +0000655 * Check second argument of filter(): func must return a bool.
656 */
657 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000658arg_filter_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000659{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000660 if (type->tt_type == VAR_STRING
661 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100662 || type_any_or_unknown(type))
Bram Moolenaar1080c482022-01-26 18:26:21 +0000663 return OK;
664
665 if (type->tt_type == VAR_FUNC)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000666 return check_map_filter_arg2(type, context, FALSE);
667 semsg(_(e_string_or_function_required_for_argument_nr), 2);
668 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000669}
670
671/*
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000672 * Check second argument of map(), the function.
Bram Moolenaar18024052021-12-25 21:43:28 +0000673 */
674 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000675arg_map_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000676{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000677 if (type->tt_type == VAR_STRING
678 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100679 || type_any_or_unknown(type))
Bram Moolenaar1080c482022-01-26 18:26:21 +0000680 return OK;
681
682 if (type->tt_type == VAR_FUNC)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000683 return check_map_filter_arg2(type, context, TRUE);
684 semsg(_(e_string_or_function_required_for_argument_nr), 2);
685 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000686}
687
688/*
Bram Moolenaare843efc2022-02-22 21:54:44 +0000689 * Check second argument of sort() and uniq(), the "how" argument.
690 */
691 static int
692arg_sort_how(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
693{
694 if (type->tt_type == VAR_STRING
695 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100696 || type_any_or_unknown(type))
Bram Moolenaare843efc2022-02-22 21:54:44 +0000697 return OK;
698
699 if (type->tt_type == VAR_FUNC)
700 {
701 type_T *(args[2]);
702 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, &t_number, args};
703
704 if (context->arg_types[0].type_curr->tt_type == VAR_LIST)
705 args[0] = context->arg_types[0].type_curr->tt_member;
706 else
707 args[0] = &t_unknown;
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100708 if (!type_any_or_unknown(type->tt_member) || args[0] != &t_unknown)
Bram Moolenaare843efc2022-02-22 21:54:44 +0000709 {
710 where_T where = WHERE_INIT;
711
712 args[1] = args[0];
Bram Moolenaarfa026162022-02-23 21:03:32 +0000713 if (type->tt_argcount == -1)
714 t_func_exp.tt_argcount = -1;
Bram Moolenaare843efc2022-02-22 21:54:44 +0000715 where.wt_index = 2;
716 return check_type(&t_func_exp, type, TRUE, where);
717 }
718
719 return OK;
720 }
721 semsg(_(e_string_or_function_required_for_argument_nr), 2);
722 return FAIL;
723}
724
725/*
Bram Moolenaar73199812021-12-26 17:18:14 +0000726 * Check an expression argument, can be a string, funcref or partial.
727 * Also accept a bool, a constant resulting from compiling a string argument.
728 * Also accept a number, one and zero are accepted.
729 */
730 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000731arg_string_or_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar73199812021-12-26 17:18:14 +0000732{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100733 if (type->tt_type == VAR_STRING
Bram Moolenaar73199812021-12-26 17:18:14 +0000734 || type->tt_type == VAR_PARTIAL
735 || type->tt_type == VAR_FUNC
736 || type->tt_type == VAR_BOOL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100737 || type->tt_type == VAR_NUMBER
738 || type_any_or_unknown(type))
Bram Moolenaar73199812021-12-26 17:18:14 +0000739 return OK;
740 arg_type_mismatch(&t_func_any, type, context->arg_idx + 1);
741 return FAIL;
742}
743
744/*
rbtnn0ccb5842021-12-18 18:33:46 +0000745 * Check "type" is a list of 'any' or a blob or a string.
746 */
747 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000748arg_string_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
rbtnn0ccb5842021-12-18 18:33:46 +0000749{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100750 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000751 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100752 || type->tt_type == VAR_STRING
753 || type_any_or_unknown(type))
rbtnn0ccb5842021-12-18 18:33:46 +0000754 return OK;
755 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
756 return FAIL;
757}
758
759/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200760 * Check "type" is a job.
761 */
762 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000763arg_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200764{
765 return check_arg_type(&t_job, type, context);
766}
767
768/*
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200769 * Check "type" is a channel or a job.
770 */
771 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000772arg_chan_or_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200773{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100774 if (type->tt_type == VAR_CHANNEL
775 || type->tt_type == VAR_JOB
776 || type_any_or_unknown(type))
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200777 return OK;
778 arg_type_mismatch(&t_channel, type, context->arg_idx + 1);
779 return FAIL;
780}
781
782/*
Bram Moolenaar078a4612022-01-04 15:17:03 +0000783 * Check "type" can be used as the type_decl of the previous argument.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100784 * Must not be used for the first argcheck_T entry.
785 */
786 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000787arg_same_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100788{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000789 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_decl;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100790
Bram Moolenaar351ead02021-01-16 16:07:01 +0100791 return check_arg_type(prev_type, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100792}
793
794/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100795 * Check "type" is the same basic type as the previous argument, checks list or
796 * dict vs other type, but not member type.
797 * Must not be used for the first argcheck_T entry.
798 */
799 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000800arg_same_struct_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100801{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000802 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100803
Bram Moolenaar078a4612022-01-04 15:17:03 +0000804 if (prev_type->tt_type != context->arg_types[context->arg_idx].type_curr->tt_type)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100805 return check_arg_type(prev_type, type, context);
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100806 return OK;
807}
808
809/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100810 * Check "type" is an item of the list or blob of the previous arg.
Bram Moolenaarca174532020-10-21 16:42:22 +0200811 * Must not be used for the first argcheck_T entry.
812 */
813 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000814arg_item_of_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200815{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000816 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarca174532020-10-21 16:42:22 +0200817 type_T *expected;
818
819 if (prev_type->tt_type == VAR_LIST)
820 expected = prev_type->tt_member;
821 else if (prev_type->tt_type == VAR_BLOB)
822 expected = &t_number;
823 else
824 // probably VAR_ANY, can't check
825 return OK;
826
Bram Moolenaar351ead02021-01-16 16:07:01 +0100827 return check_arg_type(expected, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200828}
829
Bram Moolenaar94738d82020-10-21 14:25:07 +0200830/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200831 * Check "type" is a string or a number or a list
832 */
833 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000834arg_str_or_nr_or_list(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200835{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100836 if (type->tt_type == VAR_STRING
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000837 || type->tt_type == VAR_NUMBER
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100838 || type->tt_type == VAR_LIST
839 || type_any_or_unknown(type))
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200840 return OK;
841 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
842 return FAIL;
843}
844
845/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200846 * Check "type" is a dict of 'any' or a string
847 */
848 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000849arg_dict_any_or_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200850{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100851 if (type->tt_type == VAR_DICT
852 || type->tt_type == VAR_STRING
853 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200854 return OK;
855 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
856 return FAIL;
857}
858
859/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200860 * Check "type" which is the third argument of extend() (number or string or
861 * any)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100862 */
863 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000864arg_extend3(type_T *type, type_T *decl_type, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100865{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000866 type_T *first_type = context->arg_types[context->arg_idx - 2].type_curr;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100867
868 if (first_type->tt_type == VAR_LIST)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000869 return arg_number(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100870 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000871 return arg_string(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100872 return OK;
873}
874
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200875/*
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200876 * Check "type" which is the first argument of get() (blob or list or dict or
877 * funcref)
878 */
879 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000880arg_get1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200881{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100882 if (type->tt_type == VAR_BLOB
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200883 || type->tt_type == VAR_LIST
884 || type->tt_type == VAR_DICT
885 || type->tt_type == VAR_FUNC
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100886 || type->tt_type == VAR_PARTIAL
887 || type_any_or_unknown(type))
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200888 return OK;
889
890 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
891 return FAIL;
892}
893
894/*
895 * Check "type" which is the first argument of len() (number or string or
896 * blob or list or dict)
897 */
898 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000899arg_len1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200900{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100901 if (type->tt_type == VAR_STRING
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200902 || type->tt_type == VAR_NUMBER
903 || type->tt_type == VAR_BLOB
904 || type->tt_type == VAR_LIST
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100905 || type->tt_type == VAR_DICT
906 || type_any_or_unknown(type))
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200907 return OK;
908
909 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
910 return FAIL;
911}
912
913/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200914 * Check "type" which is the second argument of remove() (number or string or
915 * any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200916 */
917 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000918arg_remove2(type_T *type, type_T *decl_type, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200919{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000920 type_T *first_type = context->arg_types[context->arg_idx - 1].type_curr;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200921
922 if (first_type->tt_type == VAR_LIST || first_type->tt_type == VAR_BLOB)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000923 return arg_number(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200924 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000925 return arg_string_or_nr(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200926 return OK;
927}
928
929/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200930 * Check "type" which is the first argument of repeat() (string or number or
931 * list or any)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200932 */
933 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000934arg_repeat1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200935{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100936 if (type->tt_type == VAR_STRING
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200937 || type->tt_type == VAR_NUMBER
Bakudankun375141e2022-09-09 18:46:47 +0100938 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100939 || type->tt_type == VAR_LIST
940 || type_any_or_unknown(type))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200941 return OK;
942
943 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
944 return FAIL;
945}
946
947/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200948 * Check "type" which is the first argument of slice() (list or blob or string
949 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200950 */
951 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000952arg_slice1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200953{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100954 if (type->tt_type == VAR_LIST
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200955 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100956 || type->tt_type == VAR_STRING
957 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200958 return OK;
959
960 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
961 return FAIL;
962}
963
964/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200965 * Check "type" which is the first argument of count() (string or list or dict
966 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200967 */
968 static int
Bram Moolenaar3e518a82022-08-30 17:45:33 +0100969arg_string_or_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200970{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100971 if (type->tt_type == VAR_STRING
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200972 || type->tt_type == VAR_LIST
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100973 || type->tt_type == VAR_DICT
974 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200975 return OK;
976
Bram Moolenaar3e518a82022-08-30 17:45:33 +0100977 semsg(_(e_string_list_or_dict_required_for_argument_nr),
978 context->arg_idx + 1);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200979 return FAIL;
980}
981
982/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200983 * Check "type" which is the first argument of cursor() (number or string or
984 * list or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200985 */
986 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000987arg_cursor1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200988{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100989 if (type->tt_type == VAR_NUMBER
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200990 || type->tt_type == VAR_STRING
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100991 || type->tt_type == VAR_LIST
992 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200993 return OK;
994
995 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
996 return FAIL;
997}
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100998
999/*
Bram Moolenaar94738d82020-10-21 14:25:07 +02001000 * Lists of functions that check the argument types of a builtin function.
1001 */
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001002static argcheck_T arg1_blob[] = {arg_blob};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001003static argcheck_T arg1_bool[] = {arg_bool};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001004static argcheck_T arg1_buffer[] = {arg_buffer};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001005static argcheck_T arg1_buffer_or_dict_any[] = {arg_buffer_or_dict_any};
1006static argcheck_T arg1_chan_or_job[] = {arg_chan_or_job};
1007static argcheck_T arg1_dict_any[] = {arg_dict_any};
1008static argcheck_T arg1_dict_or_string[] = {arg_dict_any_or_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001009static argcheck_T arg1_float_or_nr[] = {arg_float_or_nr};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001010static argcheck_T arg1_job[] = {arg_job};
1011static argcheck_T arg1_list_any[] = {arg_list_any};
1012static argcheck_T arg1_list_number[] = {arg_list_number};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001013static argcheck_T arg1_list_or_blob_mod[] = {arg_list_or_blob_mod};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001014static argcheck_T arg1_list_or_dict[] = {arg_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001015static argcheck_T arg1_list_string[] = {arg_list_string};
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001016static argcheck_T arg1_string_or_list_or_dict[] = {arg_string_or_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001017static argcheck_T arg1_lnum[] = {arg_lnum};
1018static argcheck_T arg1_number[] = {arg_number};
1019static argcheck_T arg1_string[] = {arg_string};
1020static argcheck_T arg1_string_or_list_any[] = {arg_string_or_list_any};
1021static argcheck_T arg1_string_or_list_string[] = {arg_string_or_list_string};
1022static argcheck_T arg1_string_or_nr[] = {arg_string_or_nr};
1023static argcheck_T arg2_any_buffer[] = {NULL, arg_buffer};
1024static argcheck_T arg2_buffer_any[] = {arg_buffer, NULL};
1025static argcheck_T arg2_buffer_bool[] = {arg_buffer, arg_bool};
1026static argcheck_T arg2_buffer_list_any[] = {arg_buffer, arg_list_any};
1027static argcheck_T arg2_buffer_lnum[] = {arg_buffer, arg_lnum};
1028static argcheck_T arg2_buffer_number[] = {arg_buffer, arg_number};
1029static argcheck_T arg2_buffer_string[] = {arg_buffer, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001030static argcheck_T arg2_chan_or_job_dict[] = {arg_chan_or_job, arg_dict_any};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001031static argcheck_T arg2_chan_or_job_string[] = {arg_chan_or_job, arg_string};
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02001032static argcheck_T arg2_dict_any_list_any[] = {arg_dict_any, arg_list_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001033static argcheck_T arg2_dict_any_string_or_nr[] = {arg_dict_any, arg_string_or_nr};
1034static argcheck_T arg2_dict_string[] = {arg_dict_any, arg_string};
1035static argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr};
1036static argcheck_T arg2_job_dict[] = {arg_job, arg_dict_any};
1037static argcheck_T arg2_job_string_or_number[] = {arg_job, arg_string_or_nr};
1038static argcheck_T arg2_list_any_number[] = {arg_list_any, arg_number};
1039static argcheck_T arg2_list_any_string[] = {arg_list_any, arg_string};
1040static argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number};
1041static argcheck_T arg2_list_number_bool[] = {arg_list_number, arg_bool};
Bram Moolenaarfa103972022-09-29 19:14:42 +01001042static argcheck_T arg2_listblobmod_item[] = {arg_list_or_blob_mod, arg_item_of_prev};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001043static argcheck_T arg2_lnum[] = {arg_lnum, arg_lnum};
1044static argcheck_T arg2_lnum_number[] = {arg_lnum, arg_number};
1045static argcheck_T arg2_number[] = {arg_number, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001046static argcheck_T arg2_number_any[] = {arg_number, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001047static argcheck_T arg2_number_bool[] = {arg_number, arg_bool};
1048static argcheck_T arg2_number_dict_any[] = {arg_number, arg_dict_any};
1049static argcheck_T arg2_number_list[] = {arg_number, arg_list_any};
1050static argcheck_T arg2_number_string[] = {arg_number, arg_string};
1051static argcheck_T arg2_number_string_or_list[] = {arg_number, arg_string_or_list_any};
1052static argcheck_T arg2_str_or_nr_or_list_dict[] = {arg_str_or_nr_or_list, arg_dict_any};
1053static argcheck_T arg2_string[] = {arg_string, arg_string};
1054static argcheck_T arg2_string_any[] = {arg_string, NULL};
1055static argcheck_T arg2_string_bool[] = {arg_string, arg_bool};
1056static argcheck_T arg2_string_chan_or_job[] = {arg_string, arg_chan_or_job};
1057static argcheck_T arg2_string_dict[] = {arg_string, arg_dict_any};
1058static argcheck_T arg2_string_list_number[] = {arg_string, arg_list_number};
1059static argcheck_T arg2_string_number[] = {arg_string, arg_number};
1060static argcheck_T arg2_string_or_list_dict[] = {arg_string_or_list_any, arg_dict_any};
LemonBoy0f7a3e12022-05-26 12:10:37 +01001061static argcheck_T arg2_string_or_list_bool[] = {arg_string_or_list_any, arg_bool};
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001062static argcheck_T arg2_string_or_list_number[] = {arg_string_or_list_any, arg_number};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001063static argcheck_T arg2_string_string_or_number[] = {arg_string, arg_string_or_nr};
1064static argcheck_T arg3_any_list_dict[] = {NULL, arg_list_any, arg_dict_any};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001065static argcheck_T arg3_buffer_lnum_lnum[] = {arg_buffer, arg_lnum, arg_lnum};
1066static argcheck_T arg3_buffer_number_number[] = {arg_buffer, arg_number, arg_number};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001067static argcheck_T arg3_buffer_string_any[] = {arg_buffer, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001068static argcheck_T arg3_buffer_string_dict[] = {arg_buffer, arg_string, arg_dict_any};
1069static argcheck_T arg3_dict_number_number[] = {arg_dict_any, arg_number, arg_number};
1070static argcheck_T arg3_list_string_dict[] = {arg_list_any, arg_string, arg_dict_any};
1071static argcheck_T arg3_lnum_number_bool[] = {arg_lnum, arg_number, arg_bool};
1072static argcheck_T arg3_number[] = {arg_number, arg_number, arg_number};
1073static argcheck_T arg3_number_any_dict[] = {arg_number, NULL, arg_dict_any};
1074static argcheck_T arg3_number_number_dict[] = {arg_number, arg_number, arg_dict_any};
1075static argcheck_T arg3_number_string_any[] = {arg_number, arg_string, NULL};
1076static argcheck_T arg3_number_string_buffer[] = {arg_number, arg_string, arg_buffer};
1077static argcheck_T arg3_number_string_string[] = {arg_number, arg_string, arg_string};
1078static argcheck_T arg3_string[] = {arg_string, arg_string, arg_string};
1079static argcheck_T arg3_string_any_dict[] = {arg_string, NULL, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001080static argcheck_T arg3_string_any_string[] = {arg_string, NULL, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001081static argcheck_T arg3_string_bool_bool[] = {arg_string, arg_bool, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001082static argcheck_T arg3_string_number_bool[] = {arg_string, arg_number, arg_bool};
K.Takata11df3ae2022-10-19 14:02:40 +01001083static argcheck_T arg3_string_number_number[] = {arg_string, arg_number, arg_number};
Ernie Rael51d04d12022-05-04 15:40:22 +01001084static argcheck_T arg3_string_or_dict_bool_dict[] = {arg_string_or_dict_any, arg_bool, arg_dict_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001085static argcheck_T arg3_string_string_bool[] = {arg_string, arg_string, arg_bool};
1086static argcheck_T arg3_string_string_dict[] = {arg_string, arg_string, arg_dict_any};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001087static argcheck_T arg3_string_string_number[] = {arg_string, arg_string, arg_number};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001088static argcheck_T arg4_number_number_string_any[] = {arg_number, arg_number, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001089static argcheck_T arg4_string_string_any_string[] = {arg_string, arg_string, NULL, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001090static argcheck_T arg4_string_string_number_string[] = {arg_string, arg_string, arg_number, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001091/* Function specific argument types (not covered by the above) */
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001092static argcheck_T arg15_assert_fails[] = {arg_string_or_nr, arg_string_or_list_any, NULL, arg_number, arg_string};
1093static argcheck_T arg34_assert_inrange[] = {arg_float_or_nr, arg_float_or_nr, arg_float_or_nr, arg_string};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001094static argcheck_T arg4_browse[] = {arg_bool, arg_string, arg_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001095static argcheck_T arg23_chanexpr[] = {arg_chan_or_job, NULL, arg_dict_any};
1096static argcheck_T arg23_chanraw[] = {arg_chan_or_job, arg_string_or_blob, arg_dict_any};
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001097static argcheck_T arg24_count[] = {arg_string_or_list_or_dict, NULL, arg_bool, arg_number};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001098static argcheck_T arg13_cursor[] = {arg_cursor1, arg_number, arg_number};
1099static argcheck_T arg12_deepcopy[] = {NULL, arg_bool};
1100static argcheck_T arg12_execute[] = {arg_string_or_list_string, arg_string};
Bram Moolenaarfa103972022-09-29 19:14:42 +01001101static argcheck_T arg23_extend[] = {arg_list_or_dict_mod, arg_same_as_prev, arg_extend3};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001102static argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001103static argcheck_T arg23_get[] = {arg_get1, arg_string_or_nr, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001104static argcheck_T arg14_glob[] = {arg_string, arg_bool, arg_bool, arg_bool};
1105static argcheck_T arg25_globpath[] = {arg_string, arg_string, arg_bool, arg_bool, arg_bool};
1106static argcheck_T arg24_index[] = {arg_list_or_blob, arg_item_of_prev, arg_number, arg_bool};
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01001107static argcheck_T arg23_index[] = {arg_list_or_blob, arg_filter_func, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001108static argcheck_T arg23_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001109static argcheck_T arg1_len[] = {arg_len1};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001110static argcheck_T arg3_libcall[] = {arg_string, arg_string, arg_string_or_nr};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001111static argcheck_T arg14_maparg[] = {arg_string, arg_string, arg_bool, arg_bool};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001112static argcheck_T arg2_filter[] = {arg_list_or_dict_or_blob_or_string_mod, arg_filter_func};
1113static argcheck_T arg2_map[] = {arg_list_or_dict_or_blob_or_string_mod, arg_map_func};
Bram Moolenaar18024052021-12-25 21:43:28 +00001114static argcheck_T arg2_mapnew[] = {arg_list_or_dict_or_blob_or_string, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001115static argcheck_T arg25_matchadd[] = {arg_string, arg_string, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001116static argcheck_T arg25_matchaddpos[] = {arg_string, arg_list_any, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001117static argcheck_T arg119_printf[] = {arg_string_or_nr, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
rbtnn0ccb5842021-12-18 18:33:46 +00001118static argcheck_T arg23_reduce[] = {arg_string_list_or_blob, NULL, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001119static argcheck_T arg24_remote_expr[] = {arg_string, arg_string, arg_string, arg_number};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001120static argcheck_T arg23_remove[] = {arg_list_or_dict_or_blob_mod, arg_remove2, arg_number};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001121static argcheck_T arg2_repeat[] = {arg_repeat1, arg_number};
Bram Moolenaar73199812021-12-26 17:18:14 +00001122static argcheck_T arg15_search[] = {arg_string, arg_string, arg_number, arg_number, arg_string_or_func};
1123static argcheck_T arg37_searchpair[] = {arg_string, arg_string, arg_string, arg_string, arg_string_or_func, arg_number, arg_number};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001124static argcheck_T arg3_setbufline[] = {arg_buffer, arg_lnum, arg_str_or_nr_or_list};
1125static argcheck_T arg2_setline[] = {arg_lnum, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001126static argcheck_T arg24_setloclist[] = {arg_number, arg_list_any, arg_string, arg_dict_any};
1127static argcheck_T arg13_setqflist[] = {arg_list_any, arg_string, arg_dict_any};
1128static argcheck_T arg23_settagstack[] = {arg_number, arg_dict_any, arg_string};
1129static argcheck_T arg02_sign_getplaced[] = {arg_buffer, arg_dict_any};
1130static argcheck_T arg45_sign_place[] = {arg_number, arg_string, arg_string, arg_buffer, arg_dict_any};
1131static argcheck_T arg23_slice[] = {arg_slice1, arg_number, arg_number};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001132static argcheck_T arg13_sortuniq[] = {arg_list_any_mod, arg_sort_how, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001133static argcheck_T arg24_strpart[] = {arg_string, arg_number, arg_number, arg_bool};
1134static argcheck_T arg12_system[] = {arg_string, arg_str_or_nr_or_list};
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001135static argcheck_T arg23_win_execute[] = {arg_number, arg_string_or_list_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001136static argcheck_T arg23_writefile[] = {arg_list_or_blob, arg_string, arg_string};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001137static argcheck_T arg24_match_func[] = {arg_string_or_list_any, arg_string, arg_number, arg_number};
Bram Moolenaarcd268012021-07-22 19:11:08 +02001138
Bram Moolenaar94738d82020-10-21 14:25:07 +02001139
1140/*
1141 * Functions that return the return type of a builtin function.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001142 * Note that "argtypes" is NULL if "argcount" is zero.
Bram Moolenaar94738d82020-10-21 14:25:07 +02001143 */
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001144 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001145ret_void(int argcount UNUSED,
1146 type2_T *argtypes UNUSED,
1147 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001148{
1149 return &t_void;
1150}
1151 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001152ret_any(int argcount UNUSED,
1153 type2_T *argtypes UNUSED,
1154 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001155{
1156 return &t_any;
1157}
1158 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001159ret_bool(int argcount UNUSED,
1160 type2_T *argtypes UNUSED,
1161 type_T **decl_type UNUSED)
Bram Moolenaar403dc312020-10-17 19:29:51 +02001162{
1163 return &t_bool;
1164}
1165 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001166ret_number_bool(int argcount UNUSED,
1167 type2_T *argtypes UNUSED,
1168 type_T **decl_type UNUSED)
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001169{
1170 return &t_number_bool;
1171}
1172 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001173ret_number(int argcount UNUSED,
1174 type2_T *argtypes UNUSED,
1175 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001176{
1177 return &t_number;
1178}
1179 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001180ret_float(int argcount UNUSED,
1181 type2_T *argtypes UNUSED,
1182 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001183{
1184 return &t_float;
1185}
1186 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001187ret_string(int argcount UNUSED,
1188 type2_T *argtypes UNUSED,
1189 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001190{
1191 return &t_string;
1192}
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001193 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001194ret_list_any(int argcount UNUSED,
1195 type2_T *argtypes UNUSED,
1196 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001197{
1198 return &t_list_any;
1199}
1200 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001201ret_list_number(int argcount UNUSED,
1202 type2_T *argtypes UNUSED,
Bram Moolenaar81330182022-02-01 12:11:58 +00001203 type_T **decl_type)
1204{
Bram Moolenaar81330182022-02-01 12:11:58 +00001205 *decl_type = &t_list_any;
1206 return &t_list_number;
1207}
1208 static type_T *
1209ret_list_string(int argcount UNUSED,
1210 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001211 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001212{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001213 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001214 return &t_list_string;
1215}
1216 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001217ret_list_dict_any(int argcount UNUSED,
1218 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001219 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001220{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001221 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001222 return &t_list_dict_any;
1223}
1224 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001225ret_list_items(int argcount UNUSED,
1226 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001227 type_T **decl_type)
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001228{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001229 *decl_type = &t_list_any;
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001230 return &t_list_list_any;
1231}
mityu61065042021-07-19 20:07:21 +02001232
1233 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001234ret_list_string_items(int argcount UNUSED,
1235 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001236 type_T **decl_type)
mityu61065042021-07-19 20:07:21 +02001237{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001238 *decl_type = &t_list_any;
mityu61065042021-07-19 20:07:21 +02001239 return &t_list_list_string;
1240}
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001241 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001242ret_dict_any(int argcount UNUSED,
1243 type2_T *argtypes UNUSED,
1244 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001245{
1246 return &t_dict_any;
1247}
1248 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001249ret_job_info(int argcount,
1250 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001251 type_T **decl_type)
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001252{
1253 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001254 {
1255 *decl_type = &t_list_any;
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001256 return &t_list_job;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001257 }
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001258 return &t_dict_any;
1259}
1260 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001261ret_dict_number(int argcount UNUSED,
1262 type2_T *argtypes UNUSED,
1263 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001264{
1265 return &t_dict_number;
1266}
1267 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001268ret_dict_string(int argcount UNUSED,
1269 type2_T *argtypes UNUSED,
1270 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001271{
1272 return &t_dict_string;
1273}
1274 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001275ret_blob(int argcount UNUSED,
1276 type2_T *argtypes UNUSED,
1277 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001278{
1279 return &t_blob;
1280}
1281 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001282ret_func_any(int argcount UNUSED,
1283 type2_T *argtypes UNUSED,
1284 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001285{
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001286 return &t_func_any;
1287}
1288 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001289ret_func_unknown(int argcount UNUSED,
1290 type2_T *argtypes UNUSED,
1291 type_T **decl_type UNUSED)
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001292{
1293 return &t_func_unknown;
1294}
1295 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001296ret_channel(int argcount UNUSED,
1297 type2_T *argtypes UNUSED,
1298 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001299{
1300 return &t_channel;
1301}
1302 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001303ret_job(int argcount UNUSED,
1304 type2_T *argtypes UNUSED,
1305 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001306{
1307 return &t_job;
1308}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001309 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001310ret_first_arg(int argcount,
1311 type2_T *argtypes,
1312 type_T **decl_type)
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001313{
1314 if (argcount > 0)
Bram Moolenaar81330182022-02-01 12:11:58 +00001315 {
1316 *decl_type = argtypes[0].type_decl;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001317 return argtypes[0].type_curr;
Bram Moolenaar81330182022-02-01 12:11:58 +00001318 }
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001319 return &t_void;
1320}
Bram Moolenaar1780f082021-07-31 22:03:59 +02001321 static type_T *
Bram Moolenaar00eb9952022-02-05 19:23:18 +00001322ret_slice(int argcount,
1323 type2_T *argtypes,
1324 type_T **decl_type)
1325{
1326 if (argcount > 0)
1327 {
1328 if (argtypes[0].type_decl != NULL)
1329 {
1330 switch (argtypes[0].type_decl->tt_type)
1331 {
1332 case VAR_STRING: *decl_type = &t_string; break;
1333 case VAR_BLOB: *decl_type = &t_blob; break;
1334 case VAR_LIST: *decl_type = &t_list_any; break;
1335 default: break;
1336 }
1337 }
1338 return argtypes[0].type_curr;
1339 }
1340 return &t_void;
1341}
1342 static type_T *
Bram Moolenaar381692b2022-02-02 20:01:27 +00001343ret_copy(int argcount,
1344 type2_T *argtypes,
1345 type_T **decl_type)
1346{
1347 if (argcount > 0)
1348 {
1349 if (argtypes[0].type_decl != NULL)
1350 {
1351 if (argtypes[0].type_decl->tt_type == VAR_LIST)
1352 *decl_type = &t_list_any;
1353 else if (argtypes[0].type_decl->tt_type == VAR_DICT)
1354 *decl_type = &t_dict_any;
1355 else
1356 *decl_type = argtypes[0].type_decl;
1357 }
1358 if (argtypes[0].type_curr != NULL)
1359 {
1360 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1361 return &t_list_any;
1362 else if (argtypes[0].type_curr->tt_type == VAR_DICT)
1363 return &t_dict_any;
1364 }
1365 return argtypes[0].type_curr;
1366 }
1367 return &t_void;
1368}
1369 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001370ret_extend(int argcount,
1371 type2_T *argtypes,
1372 type_T **decl_type)
1373{
1374 if (argcount > 0)
1375 {
1376 *decl_type = argtypes[0].type_decl;
1377 // if the second argument has a different current type then the current
1378 // type is "any"
1379 if (argcount > 1 && !equal_type(argtypes[0].type_curr,
1380 argtypes[1].type_curr, 0))
1381 {
1382 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1383 return &t_list_any;
1384 if (argtypes[0].type_curr->tt_type == VAR_DICT)
1385 return &t_dict_any;
1386 }
1387 return argtypes[0].type_curr;
1388 }
1389 return &t_void;
1390}
1391 static type_T *
1392ret_repeat(int argcount,
1393 type2_T *argtypes,
1394 type_T **decl_type UNUSED)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001395{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001396 if (argcount == 0)
1397 return &t_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001398 if (argtypes[0].type_curr == &t_number)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001399 return &t_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001400 return argtypes[0].type_curr;
Bram Moolenaar1780f082021-07-31 22:03:59 +02001401}
Bram Moolenaarea696852020-11-09 18:31:39 +01001402// for map(): returns first argument but item type may differ
1403 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001404ret_first_cont(int argcount,
1405 type2_T *argtypes,
1406 type_T **decl_type UNUSED)
Bram Moolenaarea696852020-11-09 18:31:39 +01001407{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001408 if (argcount > 0)
1409 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001410 if (argtypes[0].type_curr->tt_type == VAR_LIST)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001411 return &t_list_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001412 if (argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001413 return &t_dict_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001414 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
1415 return argtypes[0].type_curr;
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001416 }
Bram Moolenaarea696852020-11-09 18:31:39 +01001417 return &t_any;
1418}
Bram Moolenaar078a4612022-01-04 15:17:03 +00001419// for getline()
1420 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001421ret_getline(int argcount,
1422 type2_T *argtypes UNUSED,
1423 type_T **decl_type UNUSED)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001424{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001425 if (argcount == 1)
1426 return &t_string;
1427 *decl_type = &t_list_any;
1428 return &t_list_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001429}
Bram Moolenaar08018222021-12-22 18:45:37 +00001430// for finddir()
1431 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001432ret_finddir(int argcount,
1433 type2_T *argtypes UNUSED,
1434 type_T **decl_type UNUSED)
Bram Moolenaar08018222021-12-22 18:45:37 +00001435{
1436 if (argcount < 3)
1437 return &t_string;
1438 // Depending on the count would be a string or a list of strings.
1439 return &t_any;
1440}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001441
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001442/*
1443 * Used for getqflist(): returns list if there is no argument, dict if there is
1444 * one.
1445 */
1446 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001447ret_list_or_dict_0(int argcount,
1448 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001449 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001450{
1451 if (argcount > 0)
1452 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001453 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001454 return &t_list_dict_any;
1455}
1456
1457/*
1458 * Used for getloclist(): returns list if there is one argument, dict if there
1459 * are two.
1460 */
1461 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001462ret_list_or_dict_1(int argcount,
1463 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001464 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001465{
1466 if (argcount > 1)
1467 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001468 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001469 return &t_list_dict_any;
1470}
1471
Bram Moolenaar846178a2020-07-05 17:04:13 +02001472 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001473ret_argv(int argcount,
1474 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001475 type_T **decl_type)
Bram Moolenaar846178a2020-07-05 17:04:13 +02001476{
1477 // argv() returns list of strings
1478 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001479 {
1480 *decl_type = &t_list_any;
Bram Moolenaar846178a2020-07-05 17:04:13 +02001481 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001482 }
Bram Moolenaar846178a2020-07-05 17:04:13 +02001483
1484 // argv(0) returns a string, but argv(-1] returns a list
1485 return &t_any;
1486}
1487
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001488 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001489ret_remove(int argcount,
1490 type2_T *argtypes,
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001491 type_T **decl_type)
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001492{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001493 if (argcount > 0)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001494 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001495 if (argtypes[0].type_curr->tt_type == VAR_LIST
1496 || argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaar81330182022-02-01 12:11:58 +00001497 {
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001498 if (argcount == 3)
1499 {
1500 *decl_type = argtypes[0].type_decl;
1501 return argtypes[0].type_curr;
1502 }
Bram Moolenaar81330182022-02-01 12:11:58 +00001503 if (argtypes[0].type_curr->tt_type
1504 == argtypes[0].type_decl->tt_type)
1505 *decl_type = argtypes[0].type_decl->tt_member;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001506 return argtypes[0].type_curr->tt_member;
Bram Moolenaar81330182022-02-01 12:11:58 +00001507 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001508 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001509 return &t_number;
1510 }
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001511 return &t_any;
1512}
1513
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001514 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001515ret_getreg(int argcount,
1516 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001517 type_T **decl_type)
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001518{
1519 // Assume that if the third argument is passed it's non-zero
1520 if (argcount == 3)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001521 {
1522 *decl_type = &t_list_any;
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001523 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001524 }
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001525 return &t_string;
1526}
1527
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001528 static type_T *
LemonBoy0f7a3e12022-05-26 12:10:37 +01001529ret_virtcol(int argcount,
1530 type2_T *argtypes UNUSED,
1531 type_T **decl_type)
1532{
1533 // Assume that if the second argument is passed it's non-zero
1534 if (argcount == 2)
1535 {
1536 *decl_type = &t_list_any;
1537 return &t_list_number;
1538 }
1539 return &t_number;
1540}
1541
1542 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001543ret_maparg(int argcount,
1544 type2_T *argtypes UNUSED,
1545 type_T **decl_type UNUSED)
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001546{
1547 // Assume that if the fourth argument is passed it's non-zero
1548 if (argcount == 4)
1549 return &t_dict_any;
1550 return &t_string;
1551}
1552
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001553/*
1554 * Array with names and number of arguments of all internal functions
1555 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
1556 */
Bram Moolenaarac92e252019-08-03 21:58:38 +02001557typedef struct
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001558{
Bram Moolenaar25e42232019-08-04 15:04:10 +02001559 char *f_name; // function name
1560 char f_min_argc; // minimal number of arguments
1561 char f_max_argc; // maximal number of arguments
1562 char f_argtype; // for method: FEARG_ values
Bram Moolenaar94738d82020-10-21 14:25:07 +02001563 argcheck_T *f_argcheck; // list of functions to check argument types
Bram Moolenaar81330182022-02-01 12:11:58 +00001564 type_T *(*f_retfunc)(int argcount, type2_T *argtypes,
1565 type_T **decl_type);
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001566 // return type function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001567 void (*f_func)(typval_T *args, typval_T *rvar);
Bram Moolenaar25e42232019-08-04 15:04:10 +02001568 // implementation of function
Bram Moolenaarac92e252019-08-03 21:58:38 +02001569} funcentry_T;
1570
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001571// values for f_argtype; zero means it cannot be used as a method
1572#define FEARG_1 1 // base is the first argument
1573#define FEARG_2 2 // base is the second argument
Bram Moolenaar24278d22019-08-16 21:49:22 +02001574#define FEARG_3 3 // base is the third argument
Bram Moolenaaraad222c2019-09-06 22:46:09 +02001575#define FEARG_4 4 // base is the fourth argument
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001576
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001577#if defined(HAVE_MATH_H)
Bram Moolenaar15c47602020-03-26 22:16:48 +01001578# define MATH_FUNC(name) name
1579#else
1580# define MATH_FUNC(name) NULL
1581#endif
1582#ifdef FEAT_TIMERS
1583# define TIMER_FUNC(name) name
1584#else
1585# define TIMER_FUNC(name) NULL
1586#endif
1587#ifdef FEAT_JOB_CHANNEL
1588# define JOB_FUNC(name) name
1589#else
1590# define JOB_FUNC(name) NULL
1591#endif
1592#ifdef FEAT_PROP_POPUP
1593# define PROP_FUNC(name) name
1594#else
1595# define PROP_FUNC(name) NULL
1596#endif
1597#ifdef FEAT_SIGNS
1598# define SIGN_FUNC(name) name
1599#else
1600# define SIGN_FUNC(name) NULL
1601#endif
1602#ifdef FEAT_SOUND
1603# define SOUND_FUNC(name) name
1604#else
1605# define SOUND_FUNC(name) NULL
1606#endif
1607#ifdef FEAT_TERMINAL
1608# define TERM_FUNC(name) name
1609#else
1610# define TERM_FUNC(name) NULL
1611#endif
1612
Bram Moolenaarac92e252019-08-03 21:58:38 +02001613static funcentry_T global_functions[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001614{
Bram Moolenaar94738d82020-10-21 14:25:07 +02001615 {"abs", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001616 ret_any, f_abs},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001617 {"acos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001618 ret_float, f_acos},
Bram Moolenaarfa103972022-09-29 19:14:42 +01001619 {"add", 2, 2, FEARG_1, arg2_listblobmod_item,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001620 ret_first_arg, f_add},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001621 {"and", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001622 ret_number, f_and},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001623 {"append", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001624 ret_number_bool, f_append},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001625 {"appendbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001626 ret_number_bool, f_appendbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001627 {"argc", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001628 ret_number, f_argc},
1629 {"argidx", 0, 0, 0, NULL,
1630 ret_number, f_argidx},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001631 {"arglistid", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001632 ret_number, f_arglistid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001633 {"argv", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001634 ret_argv, f_argv},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001635 {"asin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001636 ret_float, f_asin},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001637 {"assert_beeps", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001638 ret_number_bool, f_assert_beeps},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001639 {"assert_equal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001640 ret_number_bool, f_assert_equal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001641 {"assert_equalfile", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001642 ret_number_bool, f_assert_equalfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001643 {"assert_exception", 1, 2, 0, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001644 ret_number_bool, f_assert_exception},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001645 {"assert_fails", 1, 5, FEARG_1, arg15_assert_fails,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001646 ret_number_bool, f_assert_fails},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001647 {"assert_false", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001648 ret_number_bool, f_assert_false},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001649 {"assert_inrange", 3, 4, FEARG_3, arg34_assert_inrange,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001650 ret_number_bool, f_assert_inrange},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001651 {"assert_match", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001652 ret_number_bool, f_assert_match},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001653 {"assert_nobeep", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar5b8cabf2021-04-02 18:55:57 +02001654 ret_number_bool, f_assert_nobeep},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001655 {"assert_notequal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001656 ret_number_bool, f_assert_notequal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001657 {"assert_notmatch", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001658 ret_number_bool, f_assert_notmatch},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001659 {"assert_report", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001660 ret_number_bool, f_assert_report},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001661 {"assert_true", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001662 ret_number_bool, f_assert_true},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001663 {"atan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001664 ret_float, f_atan},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001665 {"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001666 ret_float, f_atan2},
Yegappan Lakshmanan1755a912022-05-19 10:31:47 +01001667 {"autocmd_add", 1, 1, FEARG_1, arg1_list_any,
1668 ret_number_bool, f_autocmd_add},
1669 {"autocmd_delete", 1, 1, FEARG_1, arg1_list_any,
1670 ret_number_bool, f_autocmd_delete},
1671 {"autocmd_get", 0, 1, FEARG_1, arg1_dict_any,
1672 ret_list_dict_any, f_autocmd_get},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001673 {"balloon_gettext", 0, 0, 0, NULL,
1674 ret_string,
Bram Moolenaar59716a22017-03-01 20:32:44 +01001675#ifdef FEAT_BEVAL
Bram Moolenaar15c47602020-03-26 22:16:48 +01001676 f_balloon_gettext
1677#else
1678 NULL
Bram Moolenaar59716a22017-03-01 20:32:44 +01001679#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001680 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001681 {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001682 ret_void,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001683#ifdef FEAT_BEVAL
1684 f_balloon_show
1685#else
1686 NULL
1687#endif
1688 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001689 {"balloon_split", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001690 ret_list_string,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001691#if defined(FEAT_BEVAL_TERM)
1692 f_balloon_split
1693#else
1694 NULL
1695#endif
1696 },
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001697 {"blob2list", 1, 1, FEARG_1, arg1_blob,
1698 ret_list_number, f_blob2list},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001699 {"browse", 4, 4, 0, arg4_browse,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001700 ret_string, f_browse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001701 {"browsedir", 2, 2, 0, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001702 ret_string, f_browsedir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001703 {"bufadd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001704 ret_number, f_bufadd},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001705 {"bufexists", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001706 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001707 {"buffer_exists", 1, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001708 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001709 {"buffer_name", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001710 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001711 {"buffer_number", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001712 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001713 {"buflisted", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001714 ret_number_bool, f_buflisted},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001715 {"bufload", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001716 ret_void, f_bufload},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001717 {"bufloaded", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001718 ret_number_bool, f_bufloaded},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001719 {"bufname", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001720 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001721 {"bufnr", 0, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001722 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001723 {"bufwinid", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001724 ret_number, f_bufwinid},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001725 {"bufwinnr", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001726 ret_number, f_bufwinnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001727 {"byte2line", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001728 ret_number, f_byte2line},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001729 {"byteidx", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001730 ret_number, f_byteidx},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001731 {"byteidxcomp", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001732 ret_number, f_byteidxcomp},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001733 {"call", 2, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001734 ret_any, f_call},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001735 {"ceil", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001736 ret_float, f_ceil},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001737 {"ch_canread", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001738 ret_number_bool, JOB_FUNC(f_ch_canread)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001739 {"ch_close", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001740 ret_void, JOB_FUNC(f_ch_close)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001741 {"ch_close_in", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001742 ret_void, JOB_FUNC(f_ch_close_in)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001743 {"ch_evalexpr", 2, 3, FEARG_1, arg23_chanexpr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001744 ret_any, JOB_FUNC(f_ch_evalexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001745 {"ch_evalraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001746 ret_any, JOB_FUNC(f_ch_evalraw)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001747 {"ch_getbufnr", 2, 2, FEARG_1, arg2_chan_or_job_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001748 ret_number, JOB_FUNC(f_ch_getbufnr)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001749 {"ch_getjob", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001750 ret_job, JOB_FUNC(f_ch_getjob)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001751 {"ch_info", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001752 ret_dict_any, JOB_FUNC(f_ch_info)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001753 {"ch_log", 1, 2, FEARG_1, arg2_string_chan_or_job,
Bram Moolenaar4c5678f2022-11-30 18:12:19 +00001754 ret_void, f_ch_log},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001755 {"ch_logfile", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar4c5678f2022-11-30 18:12:19 +00001756 ret_void, f_ch_logfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001757 {"ch_open", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001758 ret_channel, JOB_FUNC(f_ch_open)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001759 {"ch_read", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001760 ret_string, JOB_FUNC(f_ch_read)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001761 {"ch_readblob", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001762 ret_blob, JOB_FUNC(f_ch_readblob)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001763 {"ch_readraw", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001764 ret_string, JOB_FUNC(f_ch_readraw)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001765 {"ch_sendexpr", 2, 3, FEARG_1, arg23_chanexpr,
Yegappan Lakshmanan3b470ae2022-04-16 10:41:27 +01001766 ret_any, JOB_FUNC(f_ch_sendexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001767 {"ch_sendraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001768 ret_void, JOB_FUNC(f_ch_sendraw)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001769 {"ch_setoptions", 2, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001770 ret_void, JOB_FUNC(f_ch_setoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001771 {"ch_status", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001772 ret_string, JOB_FUNC(f_ch_status)},
1773 {"changenr", 0, 0, 0, NULL,
1774 ret_number, f_changenr},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001775 {"char2nr", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001776 ret_number, f_char2nr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001777 {"charclass", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001778 ret_number, f_charclass},
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001779 {"charcol", 1, 2, FEARG_1, arg2_string_or_list_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001780 ret_number, f_charcol},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001781 {"charidx", 2, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001782 ret_number, f_charidx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001783 {"chdir", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001784 ret_string, f_chdir},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001785 {"cindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001786 ret_number, f_cindent},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001787 {"clearmatches", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001788 ret_void, f_clearmatches},
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001789 {"col", 1, 2, FEARG_1, arg2_string_or_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001790 ret_number, f_col},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001791 {"complete", 2, 2, FEARG_2, arg2_number_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001792 ret_void, f_complete},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001793 {"complete_add", 1, 1, FEARG_1, arg1_dict_or_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001794 ret_number, f_complete_add},
1795 {"complete_check", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001796 ret_number_bool, f_complete_check},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001797 {"complete_info", 0, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001798 ret_dict_any, f_complete_info},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001799 {"confirm", 1, 4, FEARG_1, arg4_string_string_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001800 ret_number, f_confirm},
1801 {"copy", 1, 1, FEARG_1, NULL,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001802 ret_copy, f_copy},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001803 {"cos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001804 ret_float, f_cos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001805 {"cosh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001806 ret_float, f_cosh},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001807 {"count", 2, 4, FEARG_1, arg24_count,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001808 ret_number, f_count},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001809 {"cscope_connection",0,3, 0, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001810 ret_number, f_cscope_connection},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001811 {"cursor", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001812 ret_number, f_cursor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001813 {"debugbreak", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001814 ret_number,
Bram Moolenaar4f974752019-02-17 17:44:42 +01001815#ifdef MSWIN
Bram Moolenaar15c47602020-03-26 22:16:48 +01001816 f_debugbreak
1817#else
1818 NULL
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02001819#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001820 },
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001821 {"deepcopy", 1, 2, FEARG_1, arg12_deepcopy,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001822 ret_copy, f_deepcopy},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001823 {"delete", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001824 ret_number_bool, f_delete},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001825 {"deletebufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001826 ret_number_bool, f_deletebufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001827 {"did_filetype", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001828 ret_number_bool, f_did_filetype},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001829 {"diff_filler", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001830 ret_number, f_diff_filler},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001831 {"diff_hlID", 2, 2, FEARG_1, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001832 ret_number, f_diff_hlID},
h-east29b85712021-07-26 21:54:04 +02001833 {"digraph_get", 1, 1, FEARG_1, arg1_string,
1834 ret_string, f_digraph_get},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001835 {"digraph_getlist",0, 1, FEARG_1, arg1_bool,
h-east29b85712021-07-26 21:54:04 +02001836 ret_list_string_items, f_digraph_getlist},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001837 {"digraph_set", 2, 2, FEARG_1, arg2_string,
h-east29b85712021-07-26 21:54:04 +02001838 ret_bool, f_digraph_set},
1839 {"digraph_setlist",1, 1, FEARG_1, arg1_list_string,
1840 ret_bool, f_digraph_setlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001841 {"echoraw", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001842 ret_void, f_echoraw},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001843 {"empty", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001844 ret_number_bool, f_empty},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001845 {"environ", 0, 0, 0, NULL,
1846 ret_dict_string, f_environ},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001847 {"escape", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001848 ret_string, f_escape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001849 {"eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001850 ret_any, f_eval},
1851 {"eventhandler", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001852 ret_number_bool, f_eventhandler},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001853 {"executable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001854 ret_number, f_executable},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001855 {"execute", 1, 2, FEARG_1, arg12_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001856 ret_string, f_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001857 {"exepath", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001858 ret_string, f_exepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001859 {"exists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001860 ret_number_bool, f_exists},
Bram Moolenaar26735992021-08-08 14:43:22 +02001861 {"exists_compiled", 1, 1, FEARG_1, arg1_string,
1862 ret_number_bool, f_exists_compiled},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001863 {"exp", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001864 ret_float, f_exp},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001865 {"expand", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001866 ret_any, f_expand},
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01001867 {"expandcmd", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001868 ret_string, f_expandcmd},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +01001869 {"extend", 2, 3, FEARG_1, arg23_extend,
Bram Moolenaar81330182022-02-01 12:11:58 +00001870 ret_extend, f_extend},
Bram Moolenaarb0e6b512021-01-12 20:23:40 +01001871 {"extendnew", 2, 3, FEARG_1, arg23_extendnew,
1872 ret_first_cont, f_extendnew},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001873 {"feedkeys", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001874 ret_void, f_feedkeys},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001875 {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001876 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001877 {"filereadable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001878 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001879 {"filewritable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001880 ret_number, f_filewritable},
Bram Moolenaar18024052021-12-25 21:43:28 +00001881 {"filter", 2, 2, FEARG_1, arg2_filter,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001882 ret_first_arg, f_filter},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001883 {"finddir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar08018222021-12-22 18:45:37 +00001884 ret_finddir, f_finddir},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001885 {"findfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar10c83dd2021-09-04 14:49:56 +02001886 ret_any, f_findfile},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001887 {"flatten", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001888 ret_list_any, f_flatten},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001889 {"flattennew", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3b690062021-02-01 20:14:51 +01001890 ret_list_any, f_flattennew},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001891 {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001892 ret_number, f_float2nr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001893 {"floor", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001894 ret_float, f_floor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001895 {"fmod", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001896 ret_float, f_fmod},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001897 {"fnameescape", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001898 ret_string, f_fnameescape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001899 {"fnamemodify", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001900 ret_string, f_fnamemodify},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001901 {"foldclosed", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001902 ret_number, f_foldclosed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001903 {"foldclosedend", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001904 ret_number, f_foldclosedend},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001905 {"foldlevel", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001906 ret_number, f_foldlevel},
1907 {"foldtext", 0, 0, 0, NULL,
1908 ret_string, f_foldtext},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001909 {"foldtextresult", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001910 ret_string, f_foldtextresult},
1911 {"foreground", 0, 0, 0, NULL,
1912 ret_void, f_foreground},
Bram Moolenaardd44b582022-09-15 22:03:57 +01001913 {"fullcommand", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar038e09e2021-02-06 12:38:51 +01001914 ret_string, f_fullcommand},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001915 {"funcref", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001916 ret_func_unknown, f_funcref},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001917 {"function", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001918 ret_func_unknown, f_function},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001919 {"garbagecollect", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001920 ret_void, f_garbagecollect},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001921 {"get", 2, 3, FEARG_1, arg23_get,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001922 ret_any, f_get},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001923 {"getbufinfo", 0, 1, FEARG_1, arg1_buffer_or_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001924 ret_list_dict_any, f_getbufinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001925 {"getbufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001926 ret_list_string, f_getbufline},
Bram Moolenaarce30ccc2022-11-21 19:57:04 +00001927 {"getbufoneline", 2, 2, FEARG_1, arg2_buffer_lnum,
1928 ret_string, f_getbufoneline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001929 {"getbufvar", 2, 3, FEARG_1, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001930 ret_any, f_getbufvar},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001931 {"getchangelist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001932 ret_list_any, f_getchangelist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001933 {"getchar", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001934 ret_any, f_getchar},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001935 {"getcharmod", 0, 0, 0, NULL,
1936 ret_number, f_getcharmod},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001937 {"getcharpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001938 ret_list_number, f_getcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001939 {"getcharsearch", 0, 0, 0, NULL,
1940 ret_dict_any, f_getcharsearch},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001941 {"getcharstr", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001942 ret_string, f_getcharstr},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01001943 {"getcmdcompltype", 0, 0, 0, NULL,
1944 ret_string, f_getcmdcompltype},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001945 {"getcmdline", 0, 0, 0, NULL,
1946 ret_string, f_getcmdline},
1947 {"getcmdpos", 0, 0, 0, NULL,
1948 ret_number, f_getcmdpos},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01001949 {"getcmdscreenpos", 0, 0, 0, NULL,
1950 ret_number, f_getcmdscreenpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001951 {"getcmdtype", 0, 0, 0, NULL,
1952 ret_string, f_getcmdtype},
1953 {"getcmdwintype", 0, 0, 0, NULL,
1954 ret_string, f_getcmdwintype},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001955 {"getcompletion", 2, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001956 ret_list_string, f_getcompletion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001957 {"getcurpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001958 ret_list_number, f_getcurpos},
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001959 {"getcursorcharpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001960 ret_list_number, f_getcursorcharpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001961 {"getcwd", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001962 ret_string, f_getcwd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001963 {"getenv", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar7ad67d12021-03-10 16:08:26 +01001964 ret_any, f_getenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001965 {"getfontname", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001966 ret_string, f_getfontname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001967 {"getfperm", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001968 ret_string, f_getfperm},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001969 {"getfsize", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001970 ret_number, f_getfsize},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001971 {"getftime", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001972 ret_number, f_getftime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001973 {"getftype", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001974 ret_string, f_getftype},
1975 {"getimstatus", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001976 ret_number_bool, f_getimstatus},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001977 {"getjumplist", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001978 ret_list_any, f_getjumplist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001979 {"getline", 1, 2, FEARG_1, arg2_lnum,
Bram Moolenaar078a4612022-01-04 15:17:03 +00001980 ret_getline, f_getline},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001981 {"getloclist", 1, 2, 0, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001982 ret_list_or_dict_1, f_getloclist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001983 {"getmarklist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001984 ret_list_dict_any, f_getmarklist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001985 {"getmatches", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001986 ret_list_dict_any, f_getmatches},
1987 {"getmousepos", 0, 0, 0, NULL,
1988 ret_dict_number, f_getmousepos},
Bram Moolenaar24dc19c2022-11-14 19:49:15 +00001989 {"getmouseshape", 0, 0, 0, NULL,
1990 ret_string, f_getmouseshape},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001991 {"getpid", 0, 0, 0, NULL,
1992 ret_number, f_getpid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001993 {"getpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001994 ret_list_number, f_getpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001995 {"getqflist", 0, 1, 0, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001996 ret_list_or_dict_0, f_getqflist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001997 {"getreg", 0, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001998 ret_getreg, f_getreg},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001999 {"getreginfo", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002000 ret_dict_any, f_getreginfo},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002001 {"getregtype", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002002 ret_string, f_getregtype},
Yegappan Lakshmanan520f6ef2022-08-25 17:40:40 +01002003 {"getscriptinfo", 0, 1, 0, arg1_dict_any,
Yegappan Lakshmananf768c3d2022-08-22 13:15:13 +01002004 ret_list_dict_any, f_getscriptinfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002005 {"gettabinfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002006 ret_list_dict_any, f_gettabinfo},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002007 {"gettabvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002008 ret_any, f_gettabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002009 {"gettabwinvar", 3, 4, FEARG_1, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002010 ret_any, f_gettabwinvar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002011 {"gettagstack", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002012 ret_dict_any, f_gettagstack},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002013 {"gettext", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002014 ret_string, f_gettext},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002015 {"getwininfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002016 ret_list_dict_any, f_getwininfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002017 {"getwinpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002018 ret_list_number, f_getwinpos},
2019 {"getwinposx", 0, 0, 0, NULL,
2020 ret_number, f_getwinposx},
2021 {"getwinposy", 0, 0, 0, NULL,
2022 ret_number, f_getwinposy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002023 {"getwinvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002024 ret_any, f_getwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002025 {"glob", 1, 4, FEARG_1, arg14_glob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002026 ret_any, f_glob},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002027 {"glob2regpat", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002028 ret_string, f_glob2regpat},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002029 {"globpath", 2, 5, FEARG_2, arg25_globpath,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002030 ret_any, f_globpath},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002031 {"has", 1, 2, 0, arg2_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002032 ret_number_bool, f_has},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002033 {"has_key", 2, 2, FEARG_1, arg2_dict_any_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002034 ret_number_bool, f_has_key},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002035 {"haslocaldir", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002036 ret_number, f_haslocaldir},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002037 {"hasmapto", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002038 ret_number_bool, f_hasmapto},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002039 {"highlightID", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02002040 ret_number, f_hlID},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002041 {"highlight_exists",1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002042 ret_number_bool, f_hlexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002043 {"histadd", 2, 2, FEARG_2, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002044 ret_number_bool, f_histadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002045 {"histdel", 1, 2, FEARG_1, arg2_string_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002046 ret_number_bool, f_histdel},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002047 {"histget", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002048 ret_string, f_histget},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002049 {"histnr", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002050 ret_number, f_histnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002051 {"hlID", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002052 ret_number, f_hlID},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002053 {"hlexists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002054 ret_number_bool, f_hlexists},
Yegappan Lakshmanand1a8d652021-11-03 21:56:45 +00002055 {"hlget", 0, 2, FEARG_1, arg2_string_bool,
2056 ret_list_dict_any, f_hlget},
2057 {"hlset", 1, 1, FEARG_1, arg1_list_any,
2058 ret_number_bool, f_hlset},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002059 {"hostname", 0, 0, 0, NULL,
2060 ret_string, f_hostname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002061 {"iconv", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002062 ret_string, f_iconv},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002063 {"indent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002064 ret_number, f_indent},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002065 {"index", 2, 4, FEARG_1, arg24_index,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002066 ret_number, f_index},
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01002067 {"indexof", 2, 3, FEARG_1, arg23_index,
2068 ret_number, f_indexof},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002069 {"input", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002070 ret_string, f_input},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002071 {"inputdialog", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002072 ret_string, f_inputdialog},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002073 {"inputlist", 1, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002074 ret_number, f_inputlist},
2075 {"inputrestore", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002076 ret_number_bool, f_inputrestore},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002077 {"inputsave", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002078 ret_number_bool, f_inputsave},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002079 {"inputsecret", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002080 ret_string, f_inputsecret},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002081 {"insert", 2, 3, FEARG_1, arg23_insert,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002082 ret_first_arg, f_insert},
2083 {"interrupt", 0, 0, 0, NULL,
2084 ret_void, f_interrupt},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002085 {"invert", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002086 ret_number, f_invert},
LemonBoydca1d402022-04-28 15:26:33 +01002087 {"isabsolutepath", 1, 1, FEARG_1, arg1_string,
2088 ret_number_bool, f_isabsolutepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002089 {"isdirectory", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002090 ret_number_bool, f_isdirectory},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002091 {"isinf", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002092 ret_number, MATH_FUNC(f_isinf)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002093 {"islocked", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002094 ret_number_bool, f_islocked},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002095 {"isnan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002096 ret_number_bool, MATH_FUNC(f_isnan)},
Bram Moolenaar3e518a82022-08-30 17:45:33 +01002097 {"items", 1, 1, FEARG_1, arg1_string_or_list_or_dict,
Bram Moolenaarefc5db52021-07-07 21:21:30 +02002098 ret_list_items, f_items},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002099 {"job_getchannel", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002100 ret_channel, JOB_FUNC(f_job_getchannel)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002101 {"job_info", 0, 1, FEARG_1, arg1_job,
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01002102 ret_job_info, JOB_FUNC(f_job_info)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002103 {"job_setoptions", 2, 2, FEARG_1, arg2_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002104 ret_void, JOB_FUNC(f_job_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002105 {"job_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002106 ret_job, JOB_FUNC(f_job_start)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002107 {"job_status", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002108 ret_string, JOB_FUNC(f_job_status)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002109 {"job_stop", 1, 2, FEARG_1, arg2_job_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002110 ret_number_bool, JOB_FUNC(f_job_stop)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002111 {"join", 1, 2, FEARG_1, arg2_list_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002112 ret_string, f_join},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002113 {"js_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002114 ret_any, f_js_decode},
2115 {"js_encode", 1, 1, FEARG_1, NULL,
2116 ret_string, f_js_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002117 {"json_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002118 ret_any, f_json_decode},
2119 {"json_encode", 1, 1, FEARG_1, NULL,
2120 ret_string, f_json_encode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002121 {"keys", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002122 ret_list_string, f_keys},
zeertzjqcdc83932022-09-12 13:38:41 +01002123 {"keytrans", 1, 1, FEARG_1, arg1_string,
2124 ret_string, f_keytrans},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002125 {"last_buffer_nr", 0, 0, 0, NULL, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02002126 ret_number, f_last_buffer_nr},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002127 {"len", 1, 1, FEARG_1, arg1_len,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002128 ret_number, f_len},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002129 {"libcall", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002130 ret_string, f_libcall},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002131 {"libcallnr", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002132 ret_number, f_libcallnr},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002133 {"line", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002134 ret_number, f_line},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002135 {"line2byte", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002136 ret_number, f_line2byte},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002137 {"lispindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002138 ret_number, f_lispindent},
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02002139 {"list2blob", 1, 1, FEARG_1, arg1_list_number,
2140 ret_blob, f_list2blob},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002141 {"list2str", 1, 2, FEARG_1, arg2_list_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002142 ret_string, f_list2str},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002143 {"listener_add", 1, 2, FEARG_2, arg2_any_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002144 ret_number, f_listener_add},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002145 {"listener_flush", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002146 ret_void, f_listener_flush},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002147 {"listener_remove", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002148 ret_number_bool, f_listener_remove},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002149 {"localtime", 0, 0, 0, NULL,
2150 ret_number, f_localtime},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002151 {"log", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002152 ret_float, f_log},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002153 {"log10", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002154 ret_float, f_log10},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002155 {"luaeval", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002156 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002157#ifdef FEAT_LUA
Bram Moolenaar15c47602020-03-26 22:16:48 +01002158 f_luaeval
2159#else
2160 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002161#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002162 },
Bram Moolenaar18024052021-12-25 21:43:28 +00002163 {"map", 2, 2, FEARG_1, arg2_map,
Bram Moolenaarea696852020-11-09 18:31:39 +01002164 ret_first_cont, f_map},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002165 {"maparg", 1, 4, FEARG_1, arg14_maparg,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002166 ret_maparg, f_maparg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002167 {"mapcheck", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002168 ret_string, f_mapcheck},
Ernie Rael09661202022-04-25 14:40:44 +01002169 {"maplist", 0, 1, 0, arg1_bool,
2170 ret_list_dict_any, f_maplist},
Bram Moolenaar18024052021-12-25 21:43:28 +00002171 {"mapnew", 2, 2, FEARG_1, arg2_mapnew,
Bram Moolenaarea696852020-11-09 18:31:39 +01002172 ret_first_cont, f_mapnew},
Ernie Rael51d04d12022-05-04 15:40:22 +01002173 {"mapset", 1, 3, FEARG_1, arg3_string_or_dict_bool_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002174 ret_void, f_mapset},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002175 {"match", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002176 ret_any, f_match},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002177 {"matchadd", 2, 5, FEARG_1, arg25_matchadd,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002178 ret_number, f_matchadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002179 {"matchaddpos", 2, 5, FEARG_1, arg25_matchaddpos,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002180 ret_number, f_matchaddpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002181 {"matcharg", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002182 ret_list_string, f_matcharg},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002183 {"matchdelete", 1, 2, FEARG_1, arg2_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002184 ret_number_bool, f_matchdelete},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002185 {"matchend", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002186 ret_number, f_matchend},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002187 {"matchfuzzy", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002188 ret_list_string, f_matchfuzzy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002189 {"matchfuzzypos", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002190 ret_list_any, f_matchfuzzypos},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002191 {"matchlist", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002192 ret_list_string, f_matchlist},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002193 {"matchstr", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002194 ret_string, f_matchstr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002195 {"matchstrpos", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002196 ret_list_any, f_matchstrpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002197 {"max", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002198 ret_number, f_max},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002199 {"menu_info", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002200 ret_dict_any,
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002201#ifdef FEAT_MENU
Bram Moolenaar15c47602020-03-26 22:16:48 +01002202 f_menu_info
2203#else
2204 NULL
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002205#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002206 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002207 {"min", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002208 ret_number, f_min},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002209 {"mkdir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002210 ret_number_bool, f_mkdir},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002211 {"mode", 0, 1, FEARG_1, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002212 ret_string, f_mode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002213 {"mzeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002214 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002215#ifdef FEAT_MZSCHEME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002216 f_mzeval
2217#else
2218 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002219#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002220 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002221 {"nextnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002222 ret_number, f_nextnonblank},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002223 {"nr2char", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002224 ret_string, f_nr2char},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002225 {"or", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002226 ret_number, f_or},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002227 {"pathshorten", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002228 ret_string, f_pathshorten},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002229 {"perleval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002230 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002231#ifdef FEAT_PERL
Bram Moolenaar15c47602020-03-26 22:16:48 +01002232 f_perleval
2233#else
2234 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002235#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002236 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002237 {"popup_atcursor", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002238 ret_number, PROP_FUNC(f_popup_atcursor)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002239 {"popup_beval", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002240 ret_number, PROP_FUNC(f_popup_beval)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002241 {"popup_clear", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002242 ret_void, PROP_FUNC(f_popup_clear)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002243 {"popup_close", 1, 2, FEARG_1, arg2_number_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002244 ret_void, PROP_FUNC(f_popup_close)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002245 {"popup_create", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002246 ret_number, PROP_FUNC(f_popup_create)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002247 {"popup_dialog", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002248 ret_number, PROP_FUNC(f_popup_dialog)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002249 {"popup_filter_menu", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002250 ret_bool, PROP_FUNC(f_popup_filter_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002251 {"popup_filter_yesno", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002252 ret_bool, PROP_FUNC(f_popup_filter_yesno)},
Bram Moolenaarbdc09a12022-10-07 14:31:45 +01002253 {"popup_findecho", 0, 0, 0, NULL,
2254 ret_number, PROP_FUNC(f_popup_findecho)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002255 {"popup_findinfo", 0, 0, 0, NULL,
2256 ret_number, PROP_FUNC(f_popup_findinfo)},
2257 {"popup_findpreview", 0, 0, 0, NULL,
2258 ret_number, PROP_FUNC(f_popup_findpreview)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002259 {"popup_getoptions", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002260 ret_dict_any, PROP_FUNC(f_popup_getoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002261 {"popup_getpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002262 ret_dict_any, PROP_FUNC(f_popup_getpos)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002263 {"popup_hide", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002264 ret_void, PROP_FUNC(f_popup_hide)},
2265 {"popup_list", 0, 0, 0, NULL,
2266 ret_list_number, PROP_FUNC(f_popup_list)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002267 {"popup_locate", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002268 ret_number, PROP_FUNC(f_popup_locate)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002269 {"popup_menu", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002270 ret_number, PROP_FUNC(f_popup_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002271 {"popup_move", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002272 ret_void, PROP_FUNC(f_popup_move)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002273 {"popup_notification", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002274 ret_number, PROP_FUNC(f_popup_notification)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002275 {"popup_setoptions", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002276 ret_void, PROP_FUNC(f_popup_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002277 {"popup_settext", 2, 2, FEARG_1, arg2_number_string_or_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002278 ret_void, PROP_FUNC(f_popup_settext)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002279 {"popup_show", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002280 ret_void, PROP_FUNC(f_popup_show)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002281 {"pow", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002282 ret_float, f_pow},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002283 {"prevnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002284 ret_number, f_prevnonblank},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002285 {"printf", 1, 19, FEARG_2, arg119_printf,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002286 ret_string, f_printf},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002287 {"prompt_getprompt", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002288 ret_string, JOB_FUNC(f_prompt_getprompt)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002289 {"prompt_setcallback", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002290 ret_void, JOB_FUNC(f_prompt_setcallback)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002291 {"prompt_setinterrupt", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002292 ret_void, JOB_FUNC(f_prompt_setinterrupt)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002293 {"prompt_setprompt", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002294 ret_void, JOB_FUNC(f_prompt_setprompt)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002295 {"prop_add", 3, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01002296 ret_number, PROP_FUNC(f_prop_add)},
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02002297 {"prop_add_list", 2, 2, FEARG_1, arg2_dict_any_list_any,
2298 ret_void, PROP_FUNC(f_prop_add_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002299 {"prop_clear", 1, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002300 ret_void, PROP_FUNC(f_prop_clear)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002301 {"prop_find", 1, 2, FEARG_1, arg2_dict_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002302 ret_dict_any, PROP_FUNC(f_prop_find)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002303 {"prop_list", 1, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002304 ret_list_dict_any, PROP_FUNC(f_prop_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002305 {"prop_remove", 1, 3, FEARG_1, arg3_dict_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002306 ret_number, PROP_FUNC(f_prop_remove)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002307 {"prop_type_add", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002308 ret_void, PROP_FUNC(f_prop_type_add)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002309 {"prop_type_change", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002310 ret_void, PROP_FUNC(f_prop_type_change)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002311 {"prop_type_delete", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002312 ret_void, PROP_FUNC(f_prop_type_delete)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002313 {"prop_type_get", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002314 ret_dict_any, PROP_FUNC(f_prop_type_get)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002315 {"prop_type_list", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002316 ret_list_string, PROP_FUNC(f_prop_type_list)},
2317 {"pum_getpos", 0, 0, 0, NULL,
2318 ret_dict_number, f_pum_getpos},
2319 {"pumvisible", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002320 ret_number_bool, f_pumvisible},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002321 {"py3eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002322 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002323#ifdef FEAT_PYTHON3
Bram Moolenaar15c47602020-03-26 22:16:48 +01002324 f_py3eval
2325#else
2326 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002327#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002328 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002329 {"pyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002330 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002331#ifdef FEAT_PYTHON
Bram Moolenaar15c47602020-03-26 22:16:48 +01002332 f_pyeval
2333#else
2334 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002335#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002336 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002337 {"pyxeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002338 ret_any,
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002339#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar15c47602020-03-26 22:16:48 +01002340 f_pyxeval
2341#else
2342 NULL
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002343#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002344 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002345 {"rand", 0, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002346 ret_number, f_rand},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002347 {"range", 1, 3, FEARG_1, arg3_number,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00002348 ret_list_number, f_range},
K.Takata11df3ae2022-10-19 14:02:40 +01002349 {"readblob", 1, 3, FEARG_1, arg3_string_number_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002350 ret_blob, f_readblob},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002351 {"readdir", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002352 ret_list_string, f_readdir},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002353 {"readdirex", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002354 ret_list_dict_any, f_readdirex},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002355 {"readfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002356 ret_list_string, f_readfile},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002357 {"reduce", 2, 3, FEARG_1, arg23_reduce,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002358 ret_any, f_reduce},
2359 {"reg_executing", 0, 0, 0, NULL,
2360 ret_string, f_reg_executing},
2361 {"reg_recording", 0, 0, 0, NULL,
2362 ret_string, f_reg_recording},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002363 {"reltime", 0, 2, FEARG_1, arg2_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002364 ret_list_any, f_reltime},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002365 {"reltimefloat", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002366 ret_float, f_reltimefloat},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002367 {"reltimestr", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002368 ret_string, f_reltimestr},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002369 {"remote_expr", 2, 4, FEARG_1, arg24_remote_expr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002370 ret_string, f_remote_expr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002371 {"remote_foreground", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002372 ret_string, f_remote_foreground},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002373 {"remote_peek", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002374 ret_number, f_remote_peek},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002375 {"remote_read", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002376 ret_string, f_remote_read},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002377 {"remote_send", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002378 ret_string, f_remote_send},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002379 {"remote_startserver", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002380 ret_void, f_remote_startserver},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002381 {"remove", 2, 3, FEARG_1, arg23_remove,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002382 ret_remove, f_remove},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002383 {"rename", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002384 ret_number_bool, f_rename},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002385 {"repeat", 2, 2, FEARG_1, arg2_repeat,
Bram Moolenaar1780f082021-07-31 22:03:59 +02002386 ret_repeat, f_repeat},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002387 {"resolve", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002388 ret_string, f_resolve},
Bram Moolenaara5d1a672022-09-30 17:57:47 +01002389 {"reverse", 1, 1, FEARG_1, arg1_list_or_blob_mod,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002390 ret_first_arg, f_reverse},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002391 {"round", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002392 ret_float, f_round},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002393 {"rubyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002394 ret_any,
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002395#ifdef FEAT_RUBY
Bram Moolenaar15c47602020-03-26 22:16:48 +01002396 f_rubyeval
2397#else
2398 NULL
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002399#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002400 },
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002401 {"screenattr", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002402 ret_number, f_screenattr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002403 {"screenchar", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002404 ret_number, f_screenchar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002405 {"screenchars", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002406 ret_list_number, f_screenchars},
2407 {"screencol", 0, 0, 0, NULL,
2408 ret_number, f_screencol},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002409 {"screenpos", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002410 ret_dict_number, f_screenpos},
2411 {"screenrow", 0, 0, 0, NULL,
2412 ret_number, f_screenrow},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002413 {"screenstring", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002414 ret_string, f_screenstring},
Bram Moolenaarcd268012021-07-22 19:11:08 +02002415 {"search", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002416 ret_number, f_search},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002417 {"searchcount", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002418 ret_dict_any, f_searchcount},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002419 {"searchdecl", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002420 ret_number_bool, f_searchdecl},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002421 {"searchpair", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002422 ret_number, f_searchpair},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002423 {"searchpairpos", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002424 ret_list_number, f_searchpairpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002425 {"searchpos", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002426 ret_list_number, f_searchpos},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002427 {"server2client", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002428 ret_number_bool, f_server2client},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002429 {"serverlist", 0, 0, 0, NULL,
2430 ret_string, f_serverlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002431 {"setbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002432 ret_number_bool, f_setbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002433 {"setbufvar", 3, 3, FEARG_3, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002434 ret_void, f_setbufvar},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002435 {"setcellwidths", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002436 ret_void, f_setcellwidths},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002437 {"setcharpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002438 ret_number_bool, f_setcharpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002439 {"setcharsearch", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002440 ret_void, f_setcharsearch},
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01002441 {"setcmdline", 1, 2, FEARG_1, arg2_string_number,
2442 ret_number_bool, f_setcmdline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002443 {"setcmdpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002444 ret_number_bool, f_setcmdpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002445 {"setcursorcharpos", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002446 ret_number_bool, f_setcursorcharpos},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002447 {"setenv", 2, 2, FEARG_2, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002448 ret_void, f_setenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002449 {"setfperm", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002450 ret_number_bool, f_setfperm},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002451 {"setline", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002452 ret_number_bool, f_setline},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002453 {"setloclist", 2, 4, FEARG_2, arg24_setloclist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002454 ret_number_bool, f_setloclist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002455 {"setmatches", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002456 ret_number_bool, f_setmatches},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002457 {"setpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002458 ret_number_bool, f_setpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002459 {"setqflist", 1, 3, FEARG_1, arg13_setqflist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002460 ret_number_bool, f_setqflist},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002461 {"setreg", 2, 3, FEARG_2, arg3_string_any_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002462 ret_number_bool, f_setreg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002463 {"settabvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002464 ret_void, f_settabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002465 {"settabwinvar", 4, 4, FEARG_4, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002466 ret_void, f_settabwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002467 {"settagstack", 2, 3, FEARG_2, arg23_settagstack,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002468 ret_number_bool, f_settagstack},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002469 {"setwinvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002470 ret_void, f_setwinvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002471 {"sha256", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002472 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002473#ifdef FEAT_CRYPT
Bram Moolenaar15c47602020-03-26 22:16:48 +01002474 f_sha256
2475#else
2476 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002477#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002478 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002479 {"shellescape", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002480 ret_string, f_shellescape},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002481 {"shiftwidth", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002482 ret_number, f_shiftwidth},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002483 {"sign_define", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002484 ret_any, SIGN_FUNC(f_sign_define)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002485 {"sign_getdefined", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002486 ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002487 {"sign_getplaced", 0, 2, FEARG_1, arg02_sign_getplaced,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002488 ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002489 {"sign_jump", 3, 3, FEARG_1, arg3_number_string_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002490 ret_number, SIGN_FUNC(f_sign_jump)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002491 {"sign_place", 4, 5, FEARG_1, arg45_sign_place,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002492 ret_number, SIGN_FUNC(f_sign_place)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002493 {"sign_placelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002494 ret_list_number, SIGN_FUNC(f_sign_placelist)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002495 {"sign_undefine", 0, 1, FEARG_1, arg1_string_or_list_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002496 ret_number_bool, SIGN_FUNC(f_sign_undefine)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002497 {"sign_unplace", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002498 ret_number_bool, SIGN_FUNC(f_sign_unplace)},
Sean Dewara63780b2021-11-03 13:15:47 +00002499 {"sign_unplacelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002500 ret_list_number, SIGN_FUNC(f_sign_unplacelist)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002501 {"simplify", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002502 ret_string, f_simplify},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002503 {"sin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002504 ret_float, f_sin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002505 {"sinh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002506 ret_float, f_sinh},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002507 {"slice", 2, 3, FEARG_1, arg23_slice,
Bram Moolenaar00eb9952022-02-05 19:23:18 +00002508 ret_slice, f_slice},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002509 {"sort", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002510 ret_first_arg, f_sort},
2511 {"sound_clear", 0, 0, 0, NULL,
2512 ret_void, SOUND_FUNC(f_sound_clear)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002513 {"sound_playevent", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002514 ret_number, SOUND_FUNC(f_sound_playevent)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002515 {"sound_playfile", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002516 ret_number, SOUND_FUNC(f_sound_playfile)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002517 {"sound_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002518 ret_void, SOUND_FUNC(f_sound_stop)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002519 {"soundfold", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002520 ret_string, f_soundfold},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002521 {"spellbadword", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002522 ret_list_string, f_spellbadword},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002523 {"spellsuggest", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002524 ret_list_string, f_spellsuggest},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002525 {"split", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002526 ret_list_string, f_split},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002527 {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002528 ret_float, f_sqrt},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002529 {"srand", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002530 ret_list_number, f_srand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002531 {"state", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002532 ret_string, f_state},
Bram Moolenaar80a070c2021-08-08 15:51:10 +02002533 {"str2float", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002534 ret_float, f_str2float},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002535 {"str2list", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002536 ret_list_number, f_str2list},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002537 {"str2nr", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002538 ret_number, f_str2nr},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002539 {"strcharlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01002540 ret_number, f_strcharlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002541 {"strcharpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002542 ret_string, f_strcharpart},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002543 {"strchars", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002544 ret_number, f_strchars},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002545 {"strdisplaywidth", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002546 ret_number, f_strdisplaywidth},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002547 {"strftime", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002548 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002549#ifdef HAVE_STRFTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002550 f_strftime
2551#else
2552 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002553#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002554 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002555 {"strgetchar", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002556 ret_number, f_strgetchar},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002557 {"stridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002558 ret_number, f_stridx},
2559 {"string", 1, 1, FEARG_1, NULL,
2560 ret_string, f_string},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002561 {"strlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002562 ret_number, f_strlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002563 {"strpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002564 ret_string, f_strpart},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002565 {"strptime", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002566 ret_number,
Bram Moolenaar10455d42019-11-21 15:36:18 +01002567#ifdef HAVE_STRPTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002568 f_strptime
2569#else
2570 NULL
Bram Moolenaar10455d42019-11-21 15:36:18 +01002571#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002572 },
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002573 {"strridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002574 ret_number, f_strridx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002575 {"strtrans", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002576 ret_string, f_strtrans},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002577 {"strwidth", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002578 ret_number, f_strwidth},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002579 {"submatch", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002580 ret_string, f_submatch},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002581 {"substitute", 4, 4, FEARG_1, arg4_string_string_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002582 ret_string, f_substitute},
Bram Moolenaarc216a7a2022-12-05 13:50:55 +00002583 {"swapfilelist", 0, 0, 0, NULL,
2584 ret_list_string, f_swapfilelist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002585 {"swapinfo", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002586 ret_dict_any, f_swapinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002587 {"swapname", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002588 ret_string, f_swapname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002589 {"synID", 3, 3, 0, arg3_lnum_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002590 ret_number, f_synID},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002591 {"synIDattr", 2, 3, FEARG_1, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002592 ret_string, f_synIDattr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002593 {"synIDtrans", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002594 ret_number, f_synIDtrans},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002595 {"synconcealed", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002596 ret_list_any, f_synconcealed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002597 {"synstack", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002598 ret_list_number, f_synstack},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002599 {"system", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002600 ret_string, f_system},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002601 {"systemlist", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002602 ret_list_string, f_systemlist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002603 {"tabpagebuflist", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002604 ret_list_number, f_tabpagebuflist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002605 {"tabpagenr", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002606 ret_number, f_tabpagenr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002607 {"tabpagewinnr", 1, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002608 ret_number, f_tabpagewinnr},
2609 {"tagfiles", 0, 0, 0, NULL,
2610 ret_list_string, f_tagfiles},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002611 {"taglist", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002612 ret_list_dict_any, f_taglist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002613 {"tan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002614 ret_float, f_tan},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002615 {"tanh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002616 ret_float, f_tanh},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002617 {"tempname", 0, 0, 0, NULL,
2618 ret_string, f_tempname},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002619 {"term_dumpdiff", 2, 3, FEARG_1, arg3_string_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002620 ret_number, TERM_FUNC(f_term_dumpdiff)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002621 {"term_dumpload", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002622 ret_number, TERM_FUNC(f_term_dumpload)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002623 {"term_dumpwrite", 2, 3, FEARG_2, arg3_buffer_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002624 ret_void, TERM_FUNC(f_term_dumpwrite)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002625 {"term_getaltscreen", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002626 ret_number, TERM_FUNC(f_term_getaltscreen)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002627 {"term_getansicolors", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002628 ret_list_string,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002629#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002630 f_term_getansicolors
2631#else
2632 NULL
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02002633#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002634 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002635 {"term_getattr", 2, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002636 ret_number, TERM_FUNC(f_term_getattr)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002637 {"term_getcursor", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002638 ret_list_any, TERM_FUNC(f_term_getcursor)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002639 {"term_getjob", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002640 ret_job, TERM_FUNC(f_term_getjob)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002641 {"term_getline", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002642 ret_string, TERM_FUNC(f_term_getline)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002643 {"term_getscrolled", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002644 ret_number, TERM_FUNC(f_term_getscrolled)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002645 {"term_getsize", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002646 ret_list_number, TERM_FUNC(f_term_getsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002647 {"term_getstatus", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002648 ret_string, TERM_FUNC(f_term_getstatus)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002649 {"term_gettitle", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002650 ret_string, TERM_FUNC(f_term_gettitle)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002651 {"term_gettty", 1, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002652 ret_string, TERM_FUNC(f_term_gettty)},
2653 {"term_list", 0, 0, 0, NULL,
2654 ret_list_number, TERM_FUNC(f_term_list)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002655 {"term_scrape", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002656 ret_list_dict_any, TERM_FUNC(f_term_scrape)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002657 {"term_sendkeys", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002658 ret_void, TERM_FUNC(f_term_sendkeys)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002659 {"term_setansicolors", 2, 2, FEARG_1, arg2_buffer_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002660 ret_void,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002661#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002662 f_term_setansicolors
2663#else
2664 NULL
2665#endif
2666 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002667 {"term_setapi", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002668 ret_void, TERM_FUNC(f_term_setapi)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002669 {"term_setkill", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002670 ret_void, TERM_FUNC(f_term_setkill)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002671 {"term_setrestore", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002672 ret_void, TERM_FUNC(f_term_setrestore)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002673 {"term_setsize", 3, 3, FEARG_1, arg3_buffer_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002674 ret_void, TERM_FUNC(f_term_setsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002675 {"term_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002676 ret_number, TERM_FUNC(f_term_start)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002677 {"term_wait", 1, 2, FEARG_1, arg2_buffer_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002678 ret_void, TERM_FUNC(f_term_wait)},
2679 {"terminalprops", 0, 0, 0, NULL,
2680 ret_dict_string, f_terminalprops},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002681 {"test_alloc_fail", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002682 ret_void, f_test_alloc_fail},
2683 {"test_autochdir", 0, 0, 0, NULL,
2684 ret_void, f_test_autochdir},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002685 {"test_feedinput", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002686 ret_void, f_test_feedinput},
2687 {"test_garbagecollect_now", 0, 0, 0, NULL,
2688 ret_void, f_test_garbagecollect_now},
2689 {"test_garbagecollect_soon", 0, 0, 0, NULL,
2690 ret_void, f_test_garbagecollect_soon},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002691 {"test_getvalue", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002692 ret_number, f_test_getvalue},
Yegappan Lakshmanan06011e12022-01-30 12:37:29 +00002693 {"test_gui_event", 2, 2, FEARG_1, arg2_string_dict,
2694 ret_bool, f_test_gui_event},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002695 {"test_ignore_error", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002696 ret_void, f_test_ignore_error},
Christopher Plewright20b795e2022-12-20 20:01:58 +00002697 {"test_mswin_event", 2, 2, FEARG_1, arg2_string_dict,
2698 ret_number, f_test_mswin_event},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002699 {"test_null_blob", 0, 0, 0, NULL,
2700 ret_blob, f_test_null_blob},
2701 {"test_null_channel", 0, 0, 0, NULL,
2702 ret_channel, JOB_FUNC(f_test_null_channel)},
2703 {"test_null_dict", 0, 0, 0, NULL,
2704 ret_dict_any, f_test_null_dict},
2705 {"test_null_function", 0, 0, 0, NULL,
2706 ret_func_any, f_test_null_function},
2707 {"test_null_job", 0, 0, 0, NULL,
2708 ret_job, JOB_FUNC(f_test_null_job)},
2709 {"test_null_list", 0, 0, 0, NULL,
2710 ret_list_any, f_test_null_list},
2711 {"test_null_partial", 0, 0, 0, NULL,
2712 ret_func_any, f_test_null_partial},
2713 {"test_null_string", 0, 0, 0, NULL,
2714 ret_string, f_test_null_string},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002715 {"test_option_not_set", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002716 ret_void, f_test_option_not_set},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002717 {"test_override", 2, 2, FEARG_2, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002718 ret_void, f_test_override},
2719 {"test_refcount", 1, 1, FEARG_1, NULL,
2720 ret_number, f_test_refcount},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002721 {"test_setmouse", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002722 ret_void, f_test_setmouse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002723 {"test_settime", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002724 ret_void, f_test_settime},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002725 {"test_srand_seed", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002726 ret_void, f_test_srand_seed},
2727 {"test_unknown", 0, 0, 0, NULL,
2728 ret_any, f_test_unknown},
2729 {"test_void", 0, 0, 0, NULL,
2730 ret_void, f_test_void},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002731 {"timer_info", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002732 ret_list_dict_any, TIMER_FUNC(f_timer_info)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002733 {"timer_pause", 2, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002734 ret_void, TIMER_FUNC(f_timer_pause)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002735 {"timer_start", 2, 3, FEARG_1, arg3_number_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002736 ret_number, TIMER_FUNC(f_timer_start)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002737 {"timer_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002738 ret_void, TIMER_FUNC(f_timer_stop)},
2739 {"timer_stopall", 0, 0, 0, NULL,
2740 ret_void, TIMER_FUNC(f_timer_stopall)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002741 {"tolower", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002742 ret_string, f_tolower},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002743 {"toupper", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002744 ret_string, f_toupper},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002745 {"tr", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002746 ret_string, f_tr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002747 {"trim", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002748 ret_string, f_trim},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002749 {"trunc", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002750 ret_float, f_trunc},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002751 {"type", 1, 1, FEARG_1, NULL,
2752 ret_number, f_type},
Bram Moolenaara47e05f2021-01-12 21:49:00 +01002753 {"typename", 1, 1, FEARG_1, NULL,
2754 ret_string, f_typename},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002755 {"undofile", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002756 ret_string, f_undofile},
2757 {"undotree", 0, 0, 0, NULL,
2758 ret_dict_any, f_undotree},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002759 {"uniq", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar08018222021-12-22 18:45:37 +00002760 ret_first_arg, f_uniq},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002761 {"values", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002762 ret_list_any, f_values},
LemonBoy0f7a3e12022-05-26 12:10:37 +01002763 {"virtcol", 1, 2, FEARG_1, arg2_string_or_list_bool,
2764 ret_virtcol, f_virtcol},
Bram Moolenaar5a6ec102022-05-27 21:58:00 +01002765 {"virtcol2col", 3, 3, FEARG_1, arg3_number,
2766 ret_number, f_virtcol2col},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002767 {"visualmode", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002768 ret_string, f_visualmode},
2769 {"wildmenumode", 0, 0, 0, NULL,
2770 ret_number, f_wildmenumode},
Bram Moolenaar52312242021-07-11 18:23:19 +02002771 {"win_execute", 2, 3, FEARG_2, arg23_win_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002772 ret_string, f_win_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002773 {"win_findbuf", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002774 ret_list_number, f_win_findbuf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002775 {"win_getid", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002776 ret_number, f_win_getid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002777 {"win_gettype", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002778 ret_string, f_win_gettype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002779 {"win_gotoid", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002780 ret_number_bool, f_win_gotoid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002781 {"win_id2tabwin", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002782 ret_list_number, f_win_id2tabwin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002783 {"win_id2win", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002784 ret_number, f_win_id2win},
Daniel Steinbergee630312022-01-10 13:36:34 +00002785 {"win_move_separator", 2, 2, FEARG_1, arg2_number,
2786 ret_number_bool, f_win_move_separator},
2787 {"win_move_statusline", 2, 2, FEARG_1, arg2_number,
2788 ret_number_bool, f_win_move_statusline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002789 {"win_screenpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002790 ret_list_number, f_win_screenpos},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002791 {"win_splitmove", 2, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002792 ret_number_bool, f_win_splitmove},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002793 {"winbufnr", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002794 ret_number, f_winbufnr},
2795 {"wincol", 0, 0, 0, NULL,
2796 ret_number, f_wincol},
2797 {"windowsversion", 0, 0, 0, NULL,
2798 ret_string, f_windowsversion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002799 {"winheight", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002800 ret_number, f_winheight},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002801 {"winlayout", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002802 ret_list_any, f_winlayout},
2803 {"winline", 0, 0, 0, NULL,
2804 ret_number, f_winline},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002805 {"winnr", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002806 ret_number, f_winnr},
2807 {"winrestcmd", 0, 0, 0, NULL,
2808 ret_string, f_winrestcmd},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002809 {"winrestview", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002810 ret_void, f_winrestview},
2811 {"winsaveview", 0, 0, 0, NULL,
Bram Moolenaar43b69b32021-01-07 20:23:33 +01002812 ret_dict_number, f_winsaveview},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002813 {"winwidth", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002814 ret_number, f_winwidth},
2815 {"wordcount", 0, 0, 0, NULL,
2816 ret_dict_number, f_wordcount},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002817 {"writefile", 2, 3, FEARG_1, arg23_writefile,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002818 ret_number_bool, f_writefile},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002819 {"xor", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002820 ret_number, f_xor},
Bram Moolenaarac92e252019-08-03 21:58:38 +02002821};
2822
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002823/*
2824 * Function given to ExpandGeneric() to obtain the list of internal
2825 * or user defined function names.
2826 */
2827 char_u *
2828get_function_name(expand_T *xp, int idx)
2829{
2830 static int intidx = -1;
2831 char_u *name;
2832
2833 if (idx == 0)
2834 intidx = -1;
2835 if (intidx < 0)
2836 {
2837 name = get_user_func_name(xp, idx);
naohiro ono5aec7552021-08-19 21:20:41 +02002838 if (name != NULL)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002839 {
naohiro ono5aec7552021-08-19 21:20:41 +02002840 if (*name != NUL && *name != '<'
2841 && STRNCMP("g:", xp->xp_pattern, 2) == 0)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002842 return cat_prefix_varname('g', name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002843 return name;
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002844 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002845 }
K.Takataeeec2542021-06-02 13:28:16 +02002846 if (++intidx < (int)ARRAY_LENGTH(global_functions))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002847 {
Bram Moolenaarac92e252019-08-03 21:58:38 +02002848 STRCPY(IObuff, global_functions[intidx].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002849 STRCAT(IObuff, "(");
Bram Moolenaarac92e252019-08-03 21:58:38 +02002850 if (global_functions[intidx].f_max_argc == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002851 STRCAT(IObuff, ")");
2852 return IObuff;
2853 }
2854
2855 return NULL;
2856}
2857
2858/*
2859 * Function given to ExpandGeneric() to obtain the list of internal or
2860 * user defined variable or function names.
2861 */
2862 char_u *
2863get_expr_name(expand_T *xp, int idx)
2864{
2865 static int intidx = -1;
2866 char_u *name;
2867
2868 if (idx == 0)
2869 intidx = -1;
2870 if (intidx < 0)
2871 {
2872 name = get_function_name(xp, idx);
2873 if (name != NULL)
2874 return name;
2875 }
2876 return get_user_var_name(xp, ++intidx);
2877}
2878
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002879/*
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002880 * Find internal function "name" in table "global_functions".
Bram Moolenaar15c47602020-03-26 22:16:48 +01002881 * Return index, or -1 if not found or "implemented" is TRUE and the function
2882 * is not implemented.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002883 */
Bram Moolenaar15c47602020-03-26 22:16:48 +01002884 static int
2885find_internal_func_opt(char_u *name, int implemented)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002886{
2887 int first = 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002888 int last;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002889 int cmp;
2890 int x;
2891
K.Takataeeec2542021-06-02 13:28:16 +02002892 last = (int)ARRAY_LENGTH(global_functions) - 1;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002893
2894 // Find the function name in the table. Binary search.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002895 while (first <= last)
2896 {
2897 x = first + ((unsigned)(last - first) >> 1);
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002898 cmp = STRCMP(name, global_functions[x].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002899 if (cmp < 0)
2900 last = x - 1;
2901 else if (cmp > 0)
2902 first = x + 1;
Bram Moolenaar15c47602020-03-26 22:16:48 +01002903 else if (implemented && global_functions[x].f_func == NULL)
2904 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002905 else
2906 return x;
2907 }
2908 return -1;
2909}
2910
Bram Moolenaar15c47602020-03-26 22:16:48 +01002911/*
2912 * Find internal function "name" in table "global_functions".
2913 * Return index, or -1 if not found or the function is not implemented.
2914 */
2915 int
2916find_internal_func(char_u *name)
2917{
2918 return find_internal_func_opt(name, TRUE);
2919}
2920
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002921 int
Bram Moolenaarac92e252019-08-03 21:58:38 +02002922has_internal_func(char_u *name)
2923{
Bram Moolenaar15c47602020-03-26 22:16:48 +01002924 return find_internal_func_opt(name, TRUE) >= 0;
2925}
2926
2927 static int
2928has_internal_func_name(char_u *name)
2929{
2930 return find_internal_func_opt(name, FALSE) >= 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002931}
2932
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002933 char *
2934internal_func_name(int idx)
2935{
2936 return global_functions[idx].f_name;
2937}
2938
Bram Moolenaar94738d82020-10-21 14:25:07 +02002939/*
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002940 * Check the argument types for builtin function "idx".
Bram Moolenaar94738d82020-10-21 14:25:07 +02002941 * Uses the list of types on the type stack: "types".
2942 * Return FAIL and gives an error message when a type is wrong.
2943 */
2944 int
Bram Moolenaar351ead02021-01-16 16:07:01 +01002945internal_func_check_arg_types(
Bram Moolenaar078a4612022-01-04 15:17:03 +00002946 type2_T *types,
Bram Moolenaar351ead02021-01-16 16:07:01 +01002947 int idx,
2948 int argcount,
2949 cctx_T *cctx)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002950{
2951 argcheck_T *argchecks = global_functions[idx].f_argcheck;
Bram Moolenaar94738d82020-10-21 14:25:07 +02002952
2953 if (argchecks != NULL)
2954 {
2955 argcontext_T context;
2956
2957 context.arg_count = argcount;
Bram Moolenaarca174532020-10-21 16:42:22 +02002958 context.arg_types = types;
Bram Moolenaar351ead02021-01-16 16:07:01 +01002959 context.arg_cctx = cctx;
Bram Moolenaar848db572022-09-20 19:04:32 +01002960 for (int i = 0; i < argcount; ++i)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002961 if (argchecks[i] != NULL)
2962 {
2963 context.arg_idx = i;
Bram Moolenaar078a4612022-01-04 15:17:03 +00002964 if (argchecks[i](types[i].type_curr, types[i].type_decl,
2965 &context) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002966 return FAIL;
2967 }
2968 }
2969 return OK;
2970}
2971
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002972/*
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02002973 * Get the argument count for function "idx".
2974 * "argcount" is the total argument count, "min_argcount" the non-optional
2975 * argument count.
2976 */
2977 void
2978internal_func_get_argcount(int idx, int *argcount, int *min_argcount)
2979{
2980 *argcount = global_functions[idx].f_max_argc;
2981 *min_argcount = global_functions[idx].f_min_argc;
2982}
2983
2984/*
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002985 * Call the "f_retfunc" function to obtain the return type of function "idx".
Bram Moolenaar81330182022-02-01 12:11:58 +00002986 * "decl_type" is set to the declared type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002987 * "argtypes" is the list of argument types or NULL when there are no
2988 * arguments.
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02002989 * "argcount" may be less than the actual count when only getting the type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002990 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002991 type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00002992internal_func_ret_type(
2993 int idx,
2994 int argcount,
2995 type2_T *argtypes,
2996 type_T **decl_type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002997{
Bram Moolenaar81330182022-02-01 12:11:58 +00002998 type_T *ret;
2999
3000 *decl_type = NULL;
3001 ret = global_functions[idx].f_retfunc(argcount, argtypes, decl_type);
3002 if (*decl_type == NULL)
3003 *decl_type = ret;
3004 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003005}
3006
3007/*
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003008 * Return TRUE if "idx" is for the map() function.
3009 */
3010 int
3011internal_func_is_map(int idx)
3012{
3013 return global_functions[idx].f_func == f_map;
3014}
3015
3016/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003017 * Check the argument count to use for internal function "idx".
Bram Moolenaar389df252020-07-09 21:20:47 +02003018 * Returns -1 for failure, 0 if no method base accepted, 1 if method base is
3019 * first argument, 2 if method base is second argument, etc. 9 if method base
3020 * is last argument.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003021 */
3022 int
3023check_internal_func(int idx, int argcount)
3024{
3025 int res;
3026 char *name;
3027
3028 if (argcount < global_functions[idx].f_min_argc)
3029 res = FCERR_TOOFEW;
3030 else if (argcount > global_functions[idx].f_max_argc)
3031 res = FCERR_TOOMANY;
3032 else
Bram Moolenaar389df252020-07-09 21:20:47 +02003033 return global_functions[idx].f_argtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003034
3035 name = internal_func_name(idx);
3036 if (res == FCERR_TOOMANY)
Bram Moolenaare1242042021-12-16 20:56:57 +00003037 semsg(_(e_too_many_arguments_for_function_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003038 else
Bram Moolenaare1242042021-12-16 20:56:57 +00003039 semsg(_(e_not_enough_arguments_for_function_str), name);
Bram Moolenaar389df252020-07-09 21:20:47 +02003040 return -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003041}
3042
Bram Moolenaarac92e252019-08-03 21:58:38 +02003043 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003044call_internal_func(
3045 char_u *name,
3046 int argcount,
3047 typval_T *argvars,
3048 typval_T *rettv)
3049{
3050 int i;
3051
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003052 i = find_internal_func(name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003053 if (i < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003054 return FCERR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003055 if (argcount < global_functions[i].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003056 return FCERR_TOOFEW;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003057 if (argcount > global_functions[i].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003058 return FCERR_TOOMANY;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003059 argvars[argcount].v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003060 global_functions[i].f_func(argvars, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01003061 return FCERR_NONE;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003062}
3063
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003064 void
3065call_internal_func_by_idx(
3066 int idx,
3067 typval_T *argvars,
3068 typval_T *rettv)
3069{
3070 global_functions[idx].f_func(argvars, rettv);
3071}
3072
Bram Moolenaarac92e252019-08-03 21:58:38 +02003073/*
3074 * Invoke a method for base->method().
3075 */
3076 int
3077call_internal_method(
3078 char_u *name,
3079 int argcount,
3080 typval_T *argvars,
3081 typval_T *rettv,
3082 typval_T *basetv)
3083{
Bram Moolenaarac92e252019-08-03 21:58:38 +02003084 int fi;
3085 typval_T argv[MAX_FUNC_ARGS + 1];
3086
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003087 fi = find_internal_func(name);
Bram Moolenaar91746392019-08-16 22:22:31 +02003088 if (fi < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003089 return FCERR_UNKNOWN;
Bram Moolenaar91746392019-08-16 22:22:31 +02003090 if (global_functions[fi].f_argtype == 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003091 return FCERR_NOTMETHOD;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003092 if (argcount + 1 < global_functions[fi].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003093 return FCERR_TOOFEW;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003094 if (argcount + 1 > global_functions[fi].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003095 return FCERR_TOOMANY;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003096
Bram Moolenaarb3468902022-01-01 19:42:16 +00003097 if (global_functions[fi].f_argtype == FEARG_2)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003098 {
3099 // base value goes second
3100 argv[0] = argvars[0];
3101 argv[1] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003102 for (int i = 1; i < argcount; ++i)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003103 argv[i + 1] = argvars[i];
3104 }
Bram Moolenaar24278d22019-08-16 21:49:22 +02003105 else if (global_functions[fi].f_argtype == FEARG_3)
3106 {
3107 // base value goes third
3108 argv[0] = argvars[0];
3109 argv[1] = argvars[1];
3110 argv[2] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003111 for (int i = 2; i < argcount; ++i)
Bram Moolenaar24278d22019-08-16 21:49:22 +02003112 argv[i + 1] = argvars[i];
3113 }
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003114 else if (global_functions[fi].f_argtype == FEARG_4)
3115 {
3116 // base value goes fourth
3117 argv[0] = argvars[0];
3118 argv[1] = argvars[1];
3119 argv[2] = argvars[2];
3120 argv[3] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003121 for (int i = 3; i < argcount; ++i)
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003122 argv[i + 1] = argvars[i];
3123 }
Bram Moolenaar25e42232019-08-04 15:04:10 +02003124 else
3125 {
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003126 // FEARG_1: base value goes first
Bram Moolenaar25e42232019-08-04 15:04:10 +02003127 argv[0] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003128 for (int i = 0; i < argcount; ++i)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003129 argv[i + 1] = argvars[i];
3130 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02003131 argv[argcount + 1].v_type = VAR_UNKNOWN;
3132
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003133 global_functions[fi].f_func(argv, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01003134 return FCERR_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003135}
3136
3137/*
3138 * Return TRUE for a non-zero Number and a non-empty String.
3139 */
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003140 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003141non_zero_arg(typval_T *argvars)
3142{
3143 return ((argvars[0].v_type == VAR_NUMBER
3144 && argvars[0].vval.v_number != 0)
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003145 || (argvars[0].v_type == VAR_BOOL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003146 && argvars[0].vval.v_number == VVAL_TRUE)
3147 || (argvars[0].v_type == VAR_STRING
3148 && argvars[0].vval.v_string != NULL
3149 && *argvars[0].vval.v_string != NUL));
3150}
3151
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003152/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003153 * "and(expr, expr)" function
3154 */
3155 static void
3156f_and(typval_T *argvars, typval_T *rettv)
3157{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003158 if (in_vim9script()
3159 && (check_for_number_arg(argvars, 0) == FAIL
3160 || check_for_number_arg(argvars, 1) == FAIL))
3161 return;
3162
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003163 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
3164 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02003165}
3166
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003167/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01003168 * "balloon_show()" function
3169 */
3170#ifdef FEAT_BEVAL
3171 static void
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003172f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv)
3173{
3174 rettv->v_type = VAR_STRING;
3175 if (balloonEval != NULL)
3176 {
3177 if (balloonEval->msg == NULL)
3178 rettv->vval.v_string = NULL;
3179 else
3180 rettv->vval.v_string = vim_strsave(balloonEval->msg);
3181 }
3182}
3183
3184 static void
Bram Moolenaar59716a22017-03-01 20:32:44 +01003185f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
3186{
Bram Moolenaarcaf64342017-03-02 22:11:33 +01003187 if (balloonEval != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003188 {
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003189 if (in_vim9script()
3190 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3191 return;
3192
Bram Moolenaar246fe032017-11-19 19:56:27 +01003193 if (argvars[0].v_type == VAR_LIST
3194# ifdef FEAT_GUI
3195 && !gui.in_use
3196# endif
3197 )
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003198 {
3199 list_T *l = argvars[0].vval.v_list;
3200
3201 // empty list removes the balloon
3202 post_balloon(balloonEval, NULL,
3203 l == NULL || l->lv_len == 0 ? NULL : l);
3204 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003205 else
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003206 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003207 char_u *mesg;
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003208
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003209 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3210 return;
3211
3212 mesg = tv_get_string_chk(&argvars[0]);
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003213 if (mesg != NULL)
3214 // empty string removes the balloon
3215 post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL);
3216 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003217 }
3218}
3219
Bram Moolenaar669a8282017-11-19 20:13:05 +01003220# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003221 static void
3222f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
3223{
3224 if (rettv_list_alloc(rettv) == OK)
3225 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003226 char_u *msg;
Bram Moolenaar246fe032017-11-19 19:56:27 +01003227
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003228 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3229 return;
3230 msg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003231 if (msg != NULL)
3232 {
3233 pumitem_T *array;
3234 int size = split_message(msg, &array);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003235
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003236 // Skip the first and last item, they are always empty.
Bram Moolenaar848db572022-09-20 19:04:32 +01003237 for (int i = 1; i < size - 1; ++i)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003238 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
Bram Moolenaarb301f6b2018-02-10 15:38:35 +01003239 while (size > 0)
3240 vim_free(array[--size].pum_text);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003241 vim_free(array);
3242 }
3243 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01003244}
Bram Moolenaar669a8282017-11-19 20:13:05 +01003245# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01003246#endif
3247
3248/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003249 * Get the buffer from "arg" and give an error and return NULL if it is not
3250 * valid.
3251 */
Bram Moolenaara3347722019-05-11 21:14:24 +02003252 buf_T *
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003253get_buf_arg(typval_T *arg)
3254{
3255 buf_T *buf;
3256
3257 ++emsg_off;
3258 buf = tv_get_buf(arg, FALSE);
3259 --emsg_off;
3260 if (buf == NULL)
Bram Moolenaard82a47d2022-01-05 20:24:39 +00003261 semsg(_(e_invalid_buffer_name_str), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003262 return buf;
3263}
3264
3265/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003266 * "byte2line(byte)" function
3267 */
3268 static void
3269f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
3270{
3271#ifndef FEAT_BYTEOFF
3272 rettv->vval.v_number = -1;
3273#else
3274 long boff = 0;
3275
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003276 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3277 return;
3278
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003279 boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003280 if (boff < 0)
3281 rettv->vval.v_number = -1;
3282 else
3283 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
3284 (linenr_T)0, &boff);
3285#endif
3286}
3287
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003288/*
3289 * "call(func, arglist [, dict])" function
3290 */
3291 static void
3292f_call(typval_T *argvars, typval_T *rettv)
3293{
3294 char_u *func;
3295 partial_T *partial = NULL;
3296 dict_T *selfdict = NULL;
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003297 char_u *dot;
3298 char_u *tofree = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003299
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003300 if (in_vim9script()
Bram Moolenaar223d0a62021-12-25 19:29:21 +00003301 && (check_for_string_or_func_arg(argvars, 0) == FAIL
3302 || check_for_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003303 || check_for_opt_dict_arg(argvars, 2) == FAIL))
3304 return;
3305
Bram Moolenaard83392a2022-09-01 12:22:46 +01003306 if (check_for_list_arg(argvars, 1) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003307 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003308 if (argvars[1].vval.v_list == NULL)
3309 return;
3310
3311 if (argvars[0].v_type == VAR_FUNC)
3312 func = argvars[0].vval.v_string;
3313 else if (argvars[0].v_type == VAR_PARTIAL)
3314 {
3315 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003316 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003317 }
3318 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003319 func = tv_get_string(&argvars[0]);
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003320 if (func == NULL || *func == NUL)
3321 return; // type error, empty name or null function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003322
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003323 dot = vim_strchr(func, '.');
3324 if (dot != NULL)
3325 {
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00003326 imported_T *import = find_imported(func, dot - func, TRUE);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003327
3328 if (import != NULL && SCRIPT_ID_VALID(import->imp_sid))
3329 {
3330 scriptitem_T *si = SCRIPT_ITEM(import->imp_sid);
3331
3332 if (si->sn_autoload_prefix != NULL)
3333 {
3334 // Turn "import.Func" into "scriptname#Func".
3335 tofree = concat_str(si->sn_autoload_prefix, dot + 1);
3336 if (tofree == NULL)
3337 return;
3338 func = tofree;
3339 }
3340 }
3341 }
3342
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003343 if (argvars[2].v_type != VAR_UNKNOWN)
3344 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003345 if (check_for_dict_arg(argvars, 2) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003346 return;
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003347
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003348 selfdict = argvars[2].vval.v_dict;
3349 }
3350
3351 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003352
3353 vim_free(tofree);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003354}
3355
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003356/*
3357 * "changenr()" function
3358 */
3359 static void
3360f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
3361{
3362 rettv->vval.v_number = curbuf->b_u_seq_cur;
3363}
3364
3365/*
3366 * "char2nr(string)" function
3367 */
3368 static void
3369f_char2nr(typval_T *argvars, typval_T *rettv)
3370{
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003371 if (in_vim9script()
3372 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003373 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003374 return;
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003375
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003376 if (has_mbyte)
3377 {
3378 int utf8 = 0;
3379
3380 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar24f77502020-09-04 19:50:57 +02003381 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003382
3383 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01003384 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003385 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003386 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003387 }
3388 else
Bram Moolenaar13505972019-01-24 15:04:48 +01003389 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003390}
3391
Bram Moolenaar17793ef2020-12-28 12:56:58 +01003392/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003393 * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE,
3394 * returns the character index of the column. Otherwise, returns the byte index
3395 * of the column.
3396 */
3397 static void
3398get_col(typval_T *argvars, typval_T *rettv, int charcol)
3399{
3400 colnr_T col = 0;
3401 pos_T *fp;
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003402 switchwin_T switchwin;
3403 int winchanged = FALSE;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003404
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003405 if (check_for_string_or_list_arg(argvars, 0) == FAIL
3406 || check_for_opt_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003407 return;
3408
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003409 if (argvars[1].v_type != VAR_UNKNOWN)
3410 {
3411 tabpage_T *tp;
3412 win_T *wp;
3413
3414 // use the window specified in the second argument
3415 wp = win_id2wp_tp((int)tv_get_number(&argvars[1]), &tp);
3416 if (wp == NULL || tp == NULL)
3417 return;
3418
3419 if (switch_win_noblock(&switchwin, wp, tp, TRUE) != OK)
3420 return;
3421
3422 check_cursor();
3423 winchanged = TRUE;
3424 }
3425
3426 int fnum = curbuf->b_fnum;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003427 fp = var2fpos(&argvars[0], FALSE, &fnum, charcol);
3428 if (fp != NULL && fnum == curbuf->b_fnum)
3429 {
3430 if (fp->col == MAXCOL)
3431 {
3432 // '> can be MAXCOL, get the length of the line then
3433 if (fp->lnum <= curbuf->b_ml.ml_line_count)
3434 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
3435 else
3436 col = MAXCOL;
3437 }
3438 else
3439 {
3440 col = fp->col + 1;
3441 // col(".") when the cursor is on the NUL at the end of the line
3442 // because of "coladd" can be seen as an extra column.
3443 if (virtual_active() && fp == &curwin->w_cursor)
3444 {
3445 char_u *p = ml_get_cursor();
3446
3447 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
3448 curwin->w_virtcol - curwin->w_cursor.coladd))
3449 {
3450 int l;
3451
3452 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
3453 col += l;
3454 }
3455 }
3456 }
3457 }
3458 rettv->vval.v_number = col;
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003459
3460 if (winchanged)
3461 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003462}
3463
3464/*
3465 * "charcol()" function
3466 */
3467 static void
3468f_charcol(typval_T *argvars, typval_T *rettv)
3469{
3470 get_col(argvars, rettv, TRUE);
3471}
3472
Bram Moolenaar29b7d7a2019-07-22 23:03:57 +02003473 win_T *
Bram Moolenaaraff74912019-03-30 18:11:49 +01003474get_optional_window(typval_T *argvars, int idx)
3475{
3476 win_T *win = curwin;
3477
3478 if (argvars[idx].v_type != VAR_UNKNOWN)
3479 {
3480 win = find_win_by_nr_or_id(&argvars[idx]);
3481 if (win == NULL)
3482 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00003483 emsg(_(e_invalid_window_number));
Bram Moolenaaraff74912019-03-30 18:11:49 +01003484 return NULL;
3485 }
3486 }
3487 return win;
3488}
3489
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003490/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003491 * "col(string)" function
3492 */
3493 static void
3494f_col(typval_T *argvars, typval_T *rettv)
3495{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003496 get_col(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003497}
3498
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003499/*
3500 * "confirm(message, buttons[, default [, type]])" function
3501 */
3502 static void
3503f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3504{
3505#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3506 char_u *message;
3507 char_u *buttons = NULL;
3508 char_u buf[NUMBUFLEN];
3509 char_u buf2[NUMBUFLEN];
3510 int def = 1;
3511 int type = VIM_GENERIC;
3512 char_u *typestr;
3513 int error = FALSE;
3514
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02003515 if (in_vim9script()
3516 && (check_for_string_arg(argvars, 0) == FAIL
3517 || (check_for_opt_string_arg(argvars, 1) == FAIL
3518 || (argvars[1].v_type != VAR_UNKNOWN
3519 && (check_for_opt_number_arg(argvars, 2) == FAIL
3520 || (argvars[2].v_type != VAR_UNKNOWN
3521 && check_for_opt_string_arg(argvars, 3) == FAIL))))))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003522 return;
3523
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003524 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003525 if (message == NULL)
3526 error = TRUE;
3527 if (argvars[1].v_type != VAR_UNKNOWN)
3528 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003529 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003530 if (buttons == NULL)
3531 error = TRUE;
3532 if (argvars[2].v_type != VAR_UNKNOWN)
3533 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003534 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003535 if (argvars[3].v_type != VAR_UNKNOWN)
3536 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003537 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003538 if (typestr == NULL)
3539 error = TRUE;
3540 else
3541 {
3542 switch (TOUPPER_ASC(*typestr))
3543 {
3544 case 'E': type = VIM_ERROR; break;
3545 case 'Q': type = VIM_QUESTION; break;
3546 case 'I': type = VIM_INFO; break;
3547 case 'W': type = VIM_WARNING; break;
3548 case 'G': type = VIM_GENERIC; break;
3549 }
3550 }
3551 }
3552 }
3553 }
3554
3555 if (buttons == NULL || *buttons == NUL)
3556 buttons = (char_u *)_("&Ok");
3557
3558 if (!error)
3559 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
3560 def, NULL, FALSE);
3561#endif
3562}
3563
3564/*
3565 * "copy()" function
3566 */
3567 static void
3568f_copy(typval_T *argvars, typval_T *rettv)
3569{
Bram Moolenaar381692b2022-02-02 20:01:27 +00003570 item_copy(&argvars[0], rettv, FALSE, TRUE, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003571}
3572
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003573/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003574 * Set the cursor position.
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003575 * If 'charcol' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003576 * Otherwise use the column number as a byte offset.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003577 */
3578 static void
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003579set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003580{
Bram Moolenaar79f23442022-10-10 12:42:57 +01003581 long lnum, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003582 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003583 int set_curswant = TRUE;
3584
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003585 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003586 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02003587 || check_for_opt_number_arg(argvars, 1) == FAIL
3588 || (argvars[1].v_type != VAR_UNKNOWN
3589 && check_for_opt_number_arg(argvars, 2) == FAIL)))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003590 return;
3591
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003592 rettv->vval.v_number = -1;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003593 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003594 {
3595 pos_T pos;
3596 colnr_T curswant = -1;
3597
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003598 if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003599 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003600 emsg(_(e_invalid_argument));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003601 return;
3602 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003603 lnum = pos.lnum;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003604 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003605 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003606 if (curswant >= 0)
3607 {
3608 curwin->w_curswant = curswant - 1;
3609 set_curswant = FALSE;
3610 }
3611 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003612 else if ((argvars[0].v_type == VAR_NUMBER
3613 || argvars[0].v_type == VAR_STRING)
3614 && (argvars[1].v_type == VAR_NUMBER
3615 || argvars[1].v_type == VAR_STRING))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003616 {
Bram Moolenaar79f23442022-10-10 12:42:57 +01003617 lnum = tv_get_lnum(argvars);
3618 if (lnum < 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003619 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaar79f23442022-10-10 12:42:57 +01003620 else if (lnum == 0)
3621 lnum = curwin->w_cursor.lnum;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003622 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003623 if (charcol)
Bram Moolenaar79f23442022-10-10 12:42:57 +01003624 col = buf_charidx_to_byteidx(curbuf, lnum, col) + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003625 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003626 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003627 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003628 else
3629 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003630 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003631 return;
3632 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003633 if (lnum < 0 || col < 0 || coladd < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003634 return; // type error; errmsg already given
Bram Moolenaar79f23442022-10-10 12:42:57 +01003635 if (lnum > 0)
3636 curwin->w_cursor.lnum = lnum;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003637 if (col > 0)
3638 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003639 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003640
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003641 // Make sure the cursor is in a valid position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003642 check_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003643 // Correct cursor for multi-byte character.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003644 if (has_mbyte)
3645 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003646
3647 curwin->w_set_curswant = set_curswant;
3648 rettv->vval.v_number = 0;
3649}
3650
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003651/*
3652 * "cursor(lnum, col)" function, or
3653 * "cursor(list)"
3654 *
3655 * Moves the cursor to the specified line and column.
3656 * Returns 0 when the position could be set, -1 otherwise.
3657 */
3658 static void
3659f_cursor(typval_T *argvars, typval_T *rettv)
3660{
3661 set_cursorpos(argvars, rettv, FALSE);
3662}
3663
Bram Moolenaar4f974752019-02-17 17:44:42 +01003664#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003665/*
3666 * "debugbreak()" function
3667 */
3668 static void
3669f_debugbreak(typval_T *argvars, typval_T *rettv)
3670{
3671 int pid;
3672
3673 rettv->vval.v_number = FAIL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003674 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3675 return;
3676
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003677 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003678 if (pid == 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003679 emsg(_(e_invalid_argument));
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003680 else
3681 {
3682 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
3683
3684 if (hProcess != NULL)
3685 {
3686 DebugBreakProcess(hProcess);
3687 CloseHandle(hProcess);
3688 rettv->vval.v_number = OK;
3689 }
3690 }
3691}
3692#endif
3693
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003694/*
3695 * "deepcopy()" function
3696 */
3697 static void
3698f_deepcopy(typval_T *argvars, typval_T *rettv)
3699{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003700 varnumber_T noref = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003701
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01003702 if (check_for_opt_bool_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003703 return;
3704
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003705 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003706 noref = tv_get_bool_chk(&argvars[1], NULL);
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01003707
3708 item_copy(&argvars[0], rettv, TRUE, TRUE, noref == 0 ? get_copyID() : 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003709}
3710
3711/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003712 * "did_filetype()" function
3713 */
3714 static void
3715f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3716{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003717 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003718}
3719
3720/*
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003721 * "echoraw({expr})" function
3722 */
3723 static void
3724f_echoraw(typval_T *argvars, typval_T *rettv UNUSED)
3725{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003726 char_u *str;
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003727
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003728 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3729 return;
3730
3731 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003732 if (str != NULL && *str != NUL)
3733 {
3734 out_str(str);
3735 out_flush();
3736 }
3737}
3738
3739/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003740 * "empty({expr})" function
3741 */
3742 static void
3743f_empty(typval_T *argvars, typval_T *rettv)
3744{
3745 int n = FALSE;
3746
3747 switch (argvars[0].v_type)
3748 {
3749 case VAR_STRING:
3750 case VAR_FUNC:
3751 n = argvars[0].vval.v_string == NULL
3752 || *argvars[0].vval.v_string == NUL;
3753 break;
3754 case VAR_PARTIAL:
3755 n = FALSE;
3756 break;
3757 case VAR_NUMBER:
3758 n = argvars[0].vval.v_number == 0;
3759 break;
3760 case VAR_FLOAT:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003761 n = argvars[0].vval.v_float == 0.0;
3762 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003763 case VAR_LIST:
3764 n = argvars[0].vval.v_list == NULL
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003765 || argvars[0].vval.v_list->lv_len == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003766 break;
3767 case VAR_DICT:
3768 n = argvars[0].vval.v_dict == NULL
3769 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
3770 break;
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003771 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003772 case VAR_SPECIAL:
3773 n = argvars[0].vval.v_number != VVAL_TRUE;
3774 break;
Bram Moolenaar00b28d62022-12-08 15:32:33 +00003775 case VAR_CLASS:
3776 n = argvars[0].vval.v_class != NULL;
3777 break;
3778 case VAR_OBJECT:
3779 n = argvars[0].vval.v_object != NULL;
3780 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003781
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003782 case VAR_BLOB:
3783 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003784 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
3785 break;
3786
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003787 case VAR_JOB:
3788#ifdef FEAT_JOB_CHANNEL
3789 n = argvars[0].vval.v_job == NULL
3790 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
3791 break;
3792#endif
3793 case VAR_CHANNEL:
3794#ifdef FEAT_JOB_CHANNEL
3795 n = argvars[0].vval.v_channel == NULL
3796 || !channel_is_open(argvars[0].vval.v_channel);
3797 break;
3798#endif
3799 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02003800 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003801 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003802 case VAR_INSTR:
Bram Moolenaardd589232020-02-29 17:38:12 +01003803 internal_error_no_abort("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003804 n = TRUE;
3805 break;
3806 }
3807
3808 rettv->vval.v_number = n;
3809}
3810
3811/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003812 * "environ()" function
3813 */
3814 static void
3815f_environ(typval_T *argvars UNUSED, typval_T *rettv)
3816{
3817#if !defined(AMIGA)
3818 int i = 0;
3819 char_u *entry, *value;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01003820# if defined (MSWIN)
3821# if !defined(_UCRT)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003822 extern wchar_t **_wenviron;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01003823# endif
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003824# else
3825 extern char **environ;
3826# endif
3827
Bram Moolenaar93a10962022-06-16 11:42:09 +01003828 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003829 return;
3830
3831# ifdef MSWIN
3832 if (*_wenviron == NULL)
3833 return;
3834# else
3835 if (*environ == NULL)
3836 return;
3837# endif
3838
3839 for (i = 0; ; ++i)
3840 {
3841# ifdef MSWIN
3842 short_u *p;
3843
3844 if ((p = (short_u *)_wenviron[i]) == NULL)
3845 return;
3846 entry = utf16_to_enc(p, NULL);
3847# else
3848 if ((entry = (char_u *)environ[i]) == NULL)
3849 return;
3850 entry = vim_strsave(entry);
3851# endif
3852 if (entry == NULL) // out of memory
3853 return;
3854 if ((value = vim_strchr(entry, '=')) == NULL)
3855 {
3856 vim_free(entry);
3857 continue;
3858 }
3859 *value++ = NUL;
3860 dict_add_string(rettv->vval.v_dict, (char *)entry, value);
3861 vim_free(entry);
3862 }
3863#endif
3864}
3865
3866/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003867 * "escape({string}, {chars})" function
3868 */
3869 static void
3870f_escape(typval_T *argvars, typval_T *rettv)
3871{
3872 char_u buf[NUMBUFLEN];
3873
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003874 if (in_vim9script()
3875 && (check_for_string_arg(argvars, 0) == FAIL
3876 || check_for_string_arg(argvars, 1) == FAIL))
3877 return;
3878
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003879 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
3880 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003881 rettv->v_type = VAR_STRING;
3882}
3883
3884/*
3885 * "eval()" function
3886 */
3887 static void
3888f_eval(typval_T *argvars, typval_T *rettv)
3889{
3890 char_u *s, *p;
3891
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003892 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3893 return;
3894
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003895 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003896 if (s != NULL)
3897 s = skipwhite(s);
3898
3899 p = s;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003900 if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003901 {
3902 if (p != NULL && !aborting())
Bram Moolenaar108010a2021-06-27 22:03:33 +02003903 semsg(_(e_invalid_expression_str), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003904 need_clr_eos = FALSE;
3905 rettv->v_type = VAR_NUMBER;
3906 rettv->vval.v_number = 0;
3907 }
3908 else if (*s != NUL)
Bram Moolenaar74409f62022-01-01 15:58:22 +00003909 semsg(_(e_trailing_characters_str), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003910}
3911
3912/*
3913 * "eventhandler()" function
3914 */
3915 static void
3916f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
3917{
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003918 rettv->vval.v_number = vgetc_busy || input_busy;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003919}
3920
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003921static garray_T redir_execute_ga;
3922
3923/*
3924 * Append "value[value_len]" to the execute() output.
3925 */
3926 void
3927execute_redir_str(char_u *value, int value_len)
3928{
3929 int len;
3930
3931 if (value_len == -1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003932 len = (int)STRLEN(value); // Append the entire string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003933 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003934 len = value_len; // Append only "value_len" characters
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003935 if (ga_grow(&redir_execute_ga, len) == OK)
3936 {
3937 mch_memmove((char *)redir_execute_ga.ga_data
3938 + redir_execute_ga.ga_len, value, len);
3939 redir_execute_ga.ga_len += len;
3940 }
3941}
3942
Dominique Pelle748b3082022-01-08 12:41:16 +00003943#if defined(FEAT_LUA) || defined(PROTO)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003944/*
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003945 * Get next line from a string containing NL separated lines.
3946 * Called by do_cmdline() to get the next line.
3947 * Returns an allocated string, or NULL when at the end of the string.
3948 */
3949 static char_u *
3950get_str_line(
3951 int c UNUSED,
3952 void *cookie,
3953 int indent UNUSED,
3954 getline_opt_T options UNUSED)
3955{
3956 char_u *start = *(char_u **)cookie;
3957 char_u *line;
3958 char_u *p;
3959
3960 p = start;
3961 if (p == NULL || *p == NUL)
3962 return NULL;
3963 p = vim_strchr(p, '\n');
3964 if (p == NULL)
3965 line = vim_strsave(start);
3966 else
3967 {
3968 line = vim_strnsave(start, p - start);
3969 p++;
3970 }
3971
3972 *(char_u **)cookie = p;
3973 return line;
3974}
3975
3976/*
3977 * Execute a series of Ex commands in 'str'
3978 */
3979 void
3980execute_cmds_from_string(char_u *str)
3981{
3982 do_cmdline(NULL, get_str_line, (void *)&str,
3983 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3984}
Dominique Pelle748b3082022-01-08 12:41:16 +00003985#endif
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003986
3987/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003988 * Get next line from a list.
3989 * Called by do_cmdline() to get the next line.
3990 * Returns allocated string, or NULL for end of function.
3991 */
Bram Moolenaara7583c42022-05-07 21:14:05 +01003992 char_u *
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003993get_list_line(
3994 int c UNUSED,
3995 void *cookie,
Bram Moolenaare96a2492019-06-25 04:12:16 +02003996 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02003997 getline_opt_T options UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003998{
3999 listitem_T **p = (listitem_T **)cookie;
4000 listitem_T *item = *p;
4001 char_u buf[NUMBUFLEN];
4002 char_u *s;
4003
4004 if (item == NULL)
4005 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004006 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004007 *p = item->li_next;
4008 return s == NULL ? NULL : vim_strsave(s);
4009}
4010
4011/*
4012 * "execute()" function
4013 */
Bram Moolenaar261f3462019-09-07 15:45:32 +02004014 void
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004015execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004016{
4017 char_u *cmd = NULL;
4018 list_T *list = NULL;
4019 int save_msg_silent = msg_silent;
4020 int save_emsg_silent = emsg_silent;
4021 int save_emsg_noredir = emsg_noredir;
4022 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01004023 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004024 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01004025 int save_msg_col = msg_col;
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004026 int save_sticky_cmdmod_flags = sticky_cmdmod_flags;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004027 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004028
4029 rettv->vval.v_string = NULL;
4030 rettv->v_type = VAR_STRING;
4031
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004032 if (argvars[arg_off].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004033 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004034 list = argvars[arg_off].vval.v_list;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004035 if (list == NULL || list->lv_len == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004036 // empty list, no commands, empty output
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004037 return;
4038 ++list->lv_refcount;
4039 }
Bram Moolenaare2a8f072020-01-08 19:32:18 +01004040 else if (argvars[arg_off].v_type == VAR_JOB
4041 || argvars[arg_off].v_type == VAR_CHANNEL)
4042 {
Bram Moolenaar68db9962021-05-09 23:19:22 +02004043 semsg(_(e_using_invalid_value_as_string_str),
4044 vartype_name(argvars[arg_off].v_type));
Bram Moolenaare2a8f072020-01-08 19:32:18 +01004045 return;
4046 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004047 else
4048 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004049 cmd = tv_get_string_chk(&argvars[arg_off]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004050 if (cmd == NULL)
4051 return;
4052 }
4053
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004054 if (argvars[arg_off + 1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004055 {
4056 char_u buf[NUMBUFLEN];
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02004057 char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf,
4058 in_vim9script());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004059
4060 if (s == NULL)
4061 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004062 if (*s == NUL)
4063 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004064 if (STRNCMP(s, "silent", 6) == 0)
4065 ++msg_silent;
4066 if (STRCMP(s, "silent!") == 0)
4067 {
4068 emsg_silent = TRUE;
4069 emsg_noredir = TRUE;
4070 }
4071 }
4072 else
4073 ++msg_silent;
4074
4075 if (redir_execute)
4076 save_ga = redir_execute_ga;
Bram Moolenaar04935fb2022-01-08 16:19:22 +00004077 ga_init2(&redir_execute_ga, sizeof(char), 500);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004078 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01004079 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004080 if (!echo_output)
4081 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004082
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004083 // For "legacy call execute('cmd')" and "vim9cmd execute('cmd')" apply the
4084 // command modifiers to "cmd".
4085 sticky_cmdmod_flags = cmdmod.cmod_flags & (CMOD_LEGACY | CMOD_VIM9CMD);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004086 if (cmd != NULL)
4087 do_cmdline_cmd(cmd);
4088 else
4089 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004090 listitem_T *item;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004091
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004092 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004093 item = list->lv_first;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004094 do_cmdline(NULL, get_list_line, (void *)&item,
4095 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
4096 --list->lv_refcount;
4097 }
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004098 sticky_cmdmod_flags = save_sticky_cmdmod_flags;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004099
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004100 // Need to append a NUL to the result.
Bram Moolenaard297f352017-01-29 20:31:21 +01004101 if (ga_grow(&redir_execute_ga, 1) == OK)
4102 {
4103 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
4104 rettv->vval.v_string = redir_execute_ga.ga_data;
4105 }
4106 else
4107 {
4108 ga_clear(&redir_execute_ga);
4109 rettv->vval.v_string = NULL;
4110 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004111 msg_silent = save_msg_silent;
4112 emsg_silent = save_emsg_silent;
4113 emsg_noredir = save_emsg_noredir;
4114
4115 redir_execute = save_redir_execute;
4116 if (redir_execute)
4117 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01004118 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004119
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01004120 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004121 if (echo_output)
4122 // When not working silently: put it in column zero. A following
4123 // "echon" will overwrite the message, unavoidably.
4124 msg_col = 0;
4125 else
4126 // When working silently: Put it back where it was, since nothing
4127 // should have been written.
4128 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004129}
4130
4131/*
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004132 * "execute()" function
4133 */
4134 static void
4135f_execute(typval_T *argvars, typval_T *rettv)
4136{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004137 if (in_vim9script()
4138 && (check_for_string_or_list_arg(argvars, 0) == FAIL
4139 || check_for_opt_string_arg(argvars, 1) == FAIL))
4140 return;
4141
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004142 execute_common(argvars, rettv, 0);
4143}
4144
4145/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004146 * "exists()" function
4147 */
Bram Moolenaarbb7ee7a2021-08-02 20:06:50 +02004148 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004149f_exists(typval_T *argvars, typval_T *rettv)
4150{
4151 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004152 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004153
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004154 if (in_vim9script() && check_for_nonempty_string_arg(argvars, 0) == FAIL)
4155 return;
4156
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004157 p = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004158 if (*p == '$') // environment variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004159 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004160 // first try "normal" environment variables (fast)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004161 if (mch_getenv(p + 1) != NULL)
4162 n = TRUE;
4163 else
4164 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004165 // try expanding things like $VIM and ${HOME}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004166 p = expand_env_save(p);
4167 if (p != NULL && *p != '$')
4168 n = TRUE;
4169 vim_free(p);
4170 }
4171 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004172 else if (*p == '&' || *p == '+') // option
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004173 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004174 n = (eval_option(&p, NULL, TRUE) == OK);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004175 if (*skipwhite(p) != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004176 n = FALSE; // trailing garbage
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004177 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004178 else if (*p == '*') // internal or user defined function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004179 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02004180 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004181 }
Bram Moolenaar15c47602020-03-26 22:16:48 +01004182 else if (*p == '?') // internal function only
4183 {
4184 n = has_internal_func_name(p + 1);
4185 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004186 else if (*p == ':')
4187 {
4188 n = cmd_exists(p + 1);
4189 }
4190 else if (*p == '#')
4191 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004192 if (p[1] == '#')
4193 n = autocmd_supported(p + 2);
4194 else
4195 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004196 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004197 else // internal variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004198 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01004199 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004200 }
4201
4202 rettv->vval.v_number = n;
4203}
4204
Bram Moolenaar26735992021-08-08 14:43:22 +02004205 static void
4206f_exists_compiled(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4207{
4208 emsg(_(e_exists_compiled_can_only_be_used_in_def_function));
4209}
4210
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004211/*
4212 * "expand()" function
4213 */
4214 static void
4215f_expand(typval_T *argvars, typval_T *rettv)
4216{
4217 char_u *s;
4218 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004219 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4220 expand_T xpc;
4221 int error = FALSE;
4222 char_u *result;
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004223#ifdef BACKSLASH_IN_FILENAME
4224 char_u *p_csl_save = p_csl;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004225#endif
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004226
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004227 if (in_vim9script()
4228 && (check_for_string_arg(argvars, 0) == FAIL
4229 || check_for_opt_bool_arg(argvars, 1) == FAIL
4230 || (argvars[1].v_type != VAR_UNKNOWN
4231 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
4232 return;
4233
4234#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004235 // avoid using 'completeslash' here
4236 p_csl = empty_option;
4237#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004238
4239 rettv->v_type = VAR_STRING;
4240 if (argvars[1].v_type != VAR_UNKNOWN
4241 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004242 && tv_get_bool_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004243 && !error)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004244 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004245
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004246 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004247 if (*s == '%' || *s == '#' || *s == '<')
4248 {
Bram Moolenaar57544522022-04-12 12:54:11 +01004249 char *errormsg = NULL;
4250
4251 if (p_verbose == 0)
4252 ++emsg_off;
Bram Moolenaara96edb72022-04-28 17:52:24 +01004253 result = eval_vars(s, s, &len, NULL, &errormsg, NULL, FALSE);
Bram Moolenaar57544522022-04-12 12:54:11 +01004254 if (p_verbose == 0)
4255 --emsg_off;
4256 else if (errormsg != NULL)
4257 emsg(errormsg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004258 if (rettv->v_type == VAR_LIST)
4259 {
Bram Moolenaar93a10962022-06-16 11:42:09 +01004260 if (rettv_list_alloc(rettv) == OK && result != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004261 list_append_string(rettv->vval.v_list, result, -1);
Bram Moolenaar86173482019-10-01 17:02:16 +02004262 vim_free(result);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004263 }
4264 else
4265 rettv->vval.v_string = result;
4266 }
4267 else
4268 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004269 // When the optional second argument is non-zero, don't remove matches
4270 // for 'wildignore' and don't put matches for 'suffixes' at the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004271 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004272 && tv_get_bool_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004273 options |= WILD_KEEP_ALL;
4274 if (!error)
4275 {
4276 ExpandInit(&xpc);
4277 xpc.xp_context = EXPAND_FILES;
4278 if (p_wic)
4279 options += WILD_ICASE;
4280 if (rettv->v_type == VAR_STRING)
4281 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
4282 options, WILD_ALL);
Bram Moolenaar93a10962022-06-16 11:42:09 +01004283 else if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004284 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004285 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
Bram Moolenaar848db572022-09-20 19:04:32 +01004286 for (int i = 0; i < xpc.xp_numfiles; i++)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004287 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
4288 ExpandCleanup(&xpc);
4289 }
4290 }
4291 else
4292 rettv->vval.v_string = NULL;
4293 }
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004294#ifdef BACKSLASH_IN_FILENAME
4295 p_csl = p_csl_save;
4296#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004297}
4298
4299/*
Bram Moolenaar80dad482019-06-09 17:22:31 +02004300 * "expandcmd()" function
4301 * Expand all the special characters in a command string.
4302 */
4303 static void
4304f_expandcmd(typval_T *argvars, typval_T *rettv)
4305{
4306 exarg_T eap;
4307 char_u *cmdstr;
4308 char *errormsg = NULL;
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004309 int emsgoff = TRUE;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004310
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004311 if (in_vim9script()
4312 && (check_for_string_arg(argvars, 0) == FAIL
4313 || check_for_opt_dict_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004314 return;
4315
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004316 if (argvars[1].v_type == VAR_DICT
Bram Moolenaard61efa52022-07-23 09:52:04 +01004317 && dict_get_bool(argvars[1].vval.v_dict, "errmsg", VVAL_FALSE))
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004318 emsgoff = FALSE;
4319
Bram Moolenaar80dad482019-06-09 17:22:31 +02004320 rettv->v_type = VAR_STRING;
4321 cmdstr = vim_strsave(tv_get_string(&argvars[0]));
4322
4323 memset(&eap, 0, sizeof(eap));
4324 eap.cmd = cmdstr;
4325 eap.arg = cmdstr;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004326 eap.argt |= EX_NOSPC;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004327 eap.usefilter = FALSE;
4328 eap.nextcmd = NULL;
4329 eap.cmdidx = CMD_USER;
4330
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004331 if (emsgoff)
4332 ++emsg_off;
4333 if (expand_filename(&eap, &cmdstr, &errormsg) == FAIL)
4334 if (!emsgoff && errormsg != NULL && *errormsg != NUL)
4335 emsg(errormsg);
4336 if (emsgoff)
4337 --emsg_off;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004338
4339 rettv->vval.v_string = cmdstr;
4340}
4341
4342/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004343 * "feedkeys()" function
4344 */
4345 static void
4346f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
4347{
4348 int remap = TRUE;
4349 int insert = FALSE;
4350 char_u *keys, *flags;
4351 char_u nbuf[NUMBUFLEN];
4352 int typed = FALSE;
4353 int execute = FALSE;
Bram Moolenaara9725222022-01-16 13:30:33 +00004354 int context = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004355 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004356 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004357
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004358 // This is not allowed in the sandbox. If the commands would still be
4359 // executed in the sandbox it would be OK, but it probably happens later,
4360 // when "sandbox" is no longer set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004361 if (check_secure())
4362 return;
4363
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004364 if (in_vim9script()
4365 && (check_for_string_arg(argvars, 0) == FAIL
4366 || check_for_opt_string_arg(argvars, 1) == FAIL))
4367 return;
4368
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004369 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004370
4371 if (argvars[1].v_type != VAR_UNKNOWN)
4372 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004373 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004374 for ( ; *flags != NUL; ++flags)
4375 {
4376 switch (*flags)
4377 {
4378 case 'n': remap = FALSE; break;
4379 case 'm': remap = TRUE; break;
4380 case 't': typed = TRUE; break;
4381 case 'i': insert = TRUE; break;
4382 case 'x': execute = TRUE; break;
Bram Moolenaara9725222022-01-16 13:30:33 +00004383 case 'c': context = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004384 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004385 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004386 }
4387 }
4388 }
4389
4390 if (*keys != NUL || execute)
4391 {
Christopher Plewright20b795e2022-12-20 20:01:58 +00004392 if (lowlevel
4393#ifdef FEAT_VTP
4394 && (!is_term_win32()
4395 || (keys[0] == 3 && ctrl_c_interrupts && typed))
4396#endif
4397 )
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004398 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004399#ifdef USE_INPUT_BUF
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004400 ch_log(NULL, "feedkeys() lowlevel: %s", keys);
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01004401
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004402 int len = (int)STRLEN(keys);
4403 for (int idx = 0; idx < len; ++idx)
4404 {
4405 // if a CTRL-C was typed, set got_int, similar to what
4406 // happens in fill_input_buf()
4407 if (keys[idx] == 3 && ctrl_c_interrupts && typed)
4408 got_int = TRUE;
4409 add_to_input_buf(keys + idx, 1);
4410 }
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004411#else
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004412 emsg(_(e_lowlevel_input_not_supported));
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004413#endif
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004414 }
4415 else
4416 {
4417 // Need to escape K_SPECIAL and CSI before putting the string in
4418 // the typeahead buffer.
4419 char_u *keys_esc = vim_strsave_escape_csi(keys);
4420 if (keys_esc == NULL)
4421 return;
4422
4423 ch_log(NULL, "feedkeys(%s): %s", typed ? "typed" : "", keys);
4424
4425 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
4426 insert ? 0 : typebuf.tb_len, !typed, FALSE);
4427 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004428#ifdef FEAT_TIMERS
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004429 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004430#endif
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004431 || input_busy)
4432 typebuf_was_filled = TRUE;
4433
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004434 vim_free(keys_esc);
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004435 }
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004436
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004437 if (execute)
4438 {
4439 int save_msg_scroll = msg_scroll;
4440 sctx_T save_sctx;
4441
4442 // Avoid a 1 second delay when the keys start Insert mode.
4443 msg_scroll = FALSE;
4444
4445 ch_log(NULL, "feedkeys() executing");
4446
4447 if (context)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004448 {
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004449 save_sctx = current_sctx;
4450 current_sctx.sc_sid = 0;
4451 current_sctx.sc_version = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004452 }
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004453
4454 if (!dangerous)
4455 {
4456 ++ex_normal_busy;
4457 ++in_feedkeys;
4458 }
4459 exec_normal(TRUE, lowlevel, TRUE);
4460 if (!dangerous)
4461 {
4462 --ex_normal_busy;
4463 --in_feedkeys;
4464 }
4465
4466 msg_scroll |= save_msg_scroll;
4467
4468 if (context)
4469 current_sctx = save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004470 }
4471 }
4472}
4473
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004474/*
4475 * "fnameescape({string})" function
4476 */
4477 static void
4478f_fnameescape(typval_T *argvars, typval_T *rettv)
4479{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004480 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4481 return;
4482
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004483 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01004484 tv_get_string(&argvars[0]), VSE_NONE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004485 rettv->v_type = VAR_STRING;
4486}
4487
4488/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004489 * "foreground()" function
4490 */
4491 static void
4492f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4493{
4494#ifdef FEAT_GUI
4495 if (gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004496 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004497 gui_mch_set_foreground();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004498 return;
4499 }
4500#endif
4501#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004502 win32_set_foreground();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004503#endif
4504}
4505
Bakudankun375141e2022-09-09 18:46:47 +01004506/*
4507 * "function()" function
4508 * "funcref()" function
4509 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004510 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004511common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004512{
4513 char_u *s;
4514 char_u *name;
4515 int use_string = FALSE;
4516 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004517 char_u *trans_name = NULL;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004518 int is_global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004519
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004520 if (in_vim9script()
Bram Moolenaarae1068a2021-12-25 19:43:44 +00004521 && (check_for_string_or_func_arg(argvars, 0) == FAIL
4522 || check_for_opt_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004523 || (argvars[1].v_type != VAR_UNKNOWN
4524 && check_for_opt_dict_arg(argvars, 2) == FAIL)))
4525 return;
4526
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004527 if (argvars[0].v_type == VAR_FUNC)
4528 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004529 // function(MyFunc, [arg], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004530 s = argvars[0].vval.v_string;
4531 }
4532 else if (argvars[0].v_type == VAR_PARTIAL
4533 && argvars[0].vval.v_partial != NULL)
4534 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004535 // function(dict.MyFunc, [arg])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004536 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004537 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004538 }
4539 else
4540 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004541 // function('MyFunc', [arg], dict)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004542 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004543 use_string = TRUE;
4544 }
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004545 if (s == NULL)
4546 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004547 semsg(_(e_invalid_argument_str), "NULL");
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004548 return;
4549 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004550
Bram Moolenaar843b8842016-08-21 14:36:15 +02004551 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004552 {
4553 name = s;
Bram Moolenaareba3b7f2021-11-30 18:25:08 +00004554 trans_name = save_function_name(&name, &is_global, FALSE,
4555 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004556 if (*name != NUL)
4557 s = NULL;
4558 }
4559
Bram Moolenaar843b8842016-08-21 14:36:15 +02004560 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
4561 || (is_funcref && trans_name == NULL))
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00004562 semsg(_(e_invalid_argument_str),
4563 use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004564 // Don't check an autoload name for existence here.
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004565 else if (trans_name != NULL && (is_funcref
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004566 ? find_func(trans_name, is_global) == NULL
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004567 : !translated_function_exists(trans_name, is_global)))
Bram Moolenaara6f79292022-01-04 21:30:47 +00004568 semsg(_(e_unknown_function_str_2), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004569 else
4570 {
4571 int dict_idx = 0;
4572 int arg_idx = 0;
4573 list_T *list = NULL;
4574
4575 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004576 // Expand s: and <SID> into <SNR>nr_, so that the function can
4577 // also be called from another script. Using trans_function_name()
4578 // would also work, but some plugins depend on the name being
4579 // printable text.
Yegappan Lakshmanane7f4abd2021-12-24 20:47:38 +00004580 name = get_scriptlocal_funcname(s);
Bram Moolenaarc2f17f72022-02-21 13:13:50 +00004581 else if (trans_name != NULL && *trans_name == K_SPECIAL)
4582 name = alloc_printable_func_name(trans_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004583 else
4584 name = vim_strsave(s);
4585
4586 if (argvars[1].v_type != VAR_UNKNOWN)
4587 {
4588 if (argvars[2].v_type != VAR_UNKNOWN)
4589 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004590 // function(name, [args], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004591 arg_idx = 1;
4592 dict_idx = 2;
4593 }
4594 else if (argvars[1].v_type == VAR_DICT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004595 // function(name, dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004596 dict_idx = 1;
4597 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004598 // function(name, [args])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004599 arg_idx = 1;
4600 if (dict_idx > 0)
4601 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01004602 if (check_for_dict_arg(argvars, dict_idx) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004603 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004604 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004605 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004606 }
4607 if (argvars[dict_idx].vval.v_dict == NULL)
4608 dict_idx = 0;
4609 }
4610 if (arg_idx > 0)
4611 {
4612 if (argvars[arg_idx].v_type != VAR_LIST)
4613 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004614 emsg(_(e_second_argument_of_function_must_be_list_or_dict));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004615 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004616 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004617 }
4618 list = argvars[arg_idx].vval.v_list;
4619 if (list == NULL || list->lv_len == 0)
4620 arg_idx = 0;
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004621 else if (list->lv_len > MAX_FUNC_ARGS)
4622 {
Yegappan Lakshmanan5018a832022-04-02 21:12:21 +01004623 emsg_funcname(e_too_many_arguments_for_function_str, s);
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004624 vim_free(name);
4625 goto theend;
4626 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004627 }
4628 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004629 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004630 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004631 partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004632
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004633 // result is a VAR_PARTIAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004634 if (pt == NULL)
4635 vim_free(name);
4636 else
4637 {
4638 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
4639 {
4640 listitem_T *li;
4641 int i = 0;
4642 int arg_len = 0;
4643 int lv_len = 0;
4644
4645 if (arg_pt != NULL)
4646 arg_len = arg_pt->pt_argc;
4647 if (list != NULL)
4648 lv_len = list->lv_len;
4649 pt->pt_argc = arg_len + lv_len;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004650 pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004651 if (pt->pt_argv == NULL)
4652 {
4653 vim_free(pt);
4654 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004655 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004656 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004657 for (i = 0; i < arg_len; i++)
4658 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
4659 if (lv_len > 0)
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004660 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004661 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004662 FOR_ALL_LIST_ITEMS(list, li)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004663 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004664 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004665 }
4666
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004667 // For "function(dict.func, [], dict)" and "func" is a partial
4668 // use "dict". That is backwards compatible.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004669 if (dict_idx > 0)
4670 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004671 // The dict is bound explicitly, pt_auto is FALSE.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004672 pt->pt_dict = argvars[dict_idx].vval.v_dict;
4673 ++pt->pt_dict->dv_refcount;
4674 }
4675 else if (arg_pt != NULL)
4676 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004677 // If the dict was bound automatically the result is also
4678 // bound automatically.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004679 pt->pt_dict = arg_pt->pt_dict;
4680 pt->pt_auto = arg_pt->pt_auto;
4681 if (pt->pt_dict != NULL)
4682 ++pt->pt_dict->dv_refcount;
4683 }
4684
4685 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004686 if (arg_pt != NULL && arg_pt->pt_func != NULL)
4687 {
4688 pt->pt_func = arg_pt->pt_func;
4689 func_ptr_ref(pt->pt_func);
4690 vim_free(name);
4691 }
4692 else if (is_funcref)
4693 {
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004694 pt->pt_func = find_func(trans_name, is_global);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004695 func_ptr_ref(pt->pt_func);
4696 vim_free(name);
4697 }
4698 else
4699 {
4700 pt->pt_name = name;
4701 func_ref(name);
4702 }
Bram Moolenaar92368aa2022-02-07 17:50:39 +00004703
4704 if (arg_pt != NULL)
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00004705 {
4706 pt->pt_outer_partial = arg_pt;
4707 ++arg_pt->pt_refcount;
4708 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004709 }
4710 rettv->v_type = VAR_PARTIAL;
4711 rettv->vval.v_partial = pt;
4712 }
4713 else
4714 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004715 // result is a VAR_FUNC
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004716 rettv->v_type = VAR_FUNC;
4717 rettv->vval.v_string = name;
4718 func_ref(name);
4719 }
4720 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004721theend:
4722 vim_free(trans_name);
4723}
4724
4725/*
4726 * "funcref()" function
4727 */
4728 static void
4729f_funcref(typval_T *argvars, typval_T *rettv)
4730{
4731 common_function(argvars, rettv, TRUE);
4732}
4733
4734/*
4735 * "function()" function
4736 */
4737 static void
4738f_function(typval_T *argvars, typval_T *rettv)
4739{
4740 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004741}
4742
4743/*
4744 * "garbagecollect()" function
4745 */
4746 static void
4747f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
4748{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004749 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
4750 return;
4751
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004752 // This is postponed until we are back at the toplevel, because we may be
4753 // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004754 want_garbage_collect = TRUE;
4755
Bram Moolenaar2df47312020-09-05 17:30:44 +02004756 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004757 garbage_collect_at_exit = TRUE;
4758}
4759
4760/*
4761 * "get()" function
4762 */
4763 static void
4764f_get(typval_T *argvars, typval_T *rettv)
4765{
4766 listitem_T *li;
4767 list_T *l;
4768 dictitem_T *di;
4769 dict_T *d;
4770 typval_T *tv = NULL;
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004771 int what_is_dict = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004772
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004773 if (argvars[0].v_type == VAR_BLOB)
4774 {
4775 int error = FALSE;
4776 int idx = tv_get_number_chk(&argvars[1], &error);
4777
4778 if (!error)
4779 {
4780 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004781 if (idx < 0)
4782 idx = blob_len(argvars[0].vval.v_blob) + idx;
4783 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
4784 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004785 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004786 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004787 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004788 tv = rettv;
4789 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004790 }
4791 }
4792 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004793 {
4794 if ((l = argvars[0].vval.v_list) != NULL)
4795 {
4796 int error = FALSE;
4797
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004798 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004799 if (!error && li != NULL)
4800 tv = &li->li_tv;
4801 }
4802 }
4803 else if (argvars[0].v_type == VAR_DICT)
4804 {
4805 if ((d = argvars[0].vval.v_dict) != NULL)
4806 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004807 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004808 if (di != NULL)
4809 tv = &di->di_tv;
4810 }
4811 }
4812 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
4813 {
4814 partial_T *pt;
4815 partial_T fref_pt;
4816
4817 if (argvars[0].v_type == VAR_PARTIAL)
4818 pt = argvars[0].vval.v_partial;
4819 else
4820 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02004821 CLEAR_FIELD(fref_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004822 fref_pt.pt_name = argvars[0].vval.v_string;
4823 pt = &fref_pt;
4824 }
4825
4826 if (pt != NULL)
4827 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004828 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004829
4830 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
4831 {
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004832 char_u *name = partial_name(pt);
4833
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004834 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004835 if (name == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004836 rettv->vval.v_string = NULL;
4837 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004838 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004839 if (rettv->v_type == VAR_FUNC)
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004840 func_ref(name);
4841 if (*what == 'n' && pt->pt_name == NULL
4842 && pt->pt_func != NULL)
4843 // use <SNR> instead of the byte code
4844 name = printable_func_name(pt->pt_func);
4845 rettv->vval.v_string = vim_strsave(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004846 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004847 }
4848 else if (STRCMP(what, "dict") == 0)
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004849 {
4850 what_is_dict = TRUE;
4851 if (pt->pt_dict != NULL)
4852 rettv_dict_set(rettv, pt->pt_dict);
4853 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004854 else if (STRCMP(what, "args") == 0)
4855 {
4856 rettv->v_type = VAR_LIST;
4857 if (rettv_list_alloc(rettv) == OK)
4858 {
4859 int i;
4860
4861 for (i = 0; i < pt->pt_argc; ++i)
4862 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
4863 }
4864 }
4865 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004866 semsg(_(e_invalid_argument_str), what);
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004867
4868 // When {what} == "dict" and pt->pt_dict == NULL, evaluate the
4869 // third argument
4870 if (!what_is_dict)
4871 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004872 }
4873 }
4874 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00004875 semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004876
4877 if (tv == NULL)
4878 {
4879 if (argvars[2].v_type != VAR_UNKNOWN)
4880 copy_tv(&argvars[2], rettv);
4881 }
4882 else
4883 copy_tv(tv, rettv);
4884}
4885
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004886/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004887 * "getchangelist()" function
4888 */
4889 static void
4890f_getchangelist(typval_T *argvars, typval_T *rettv)
4891{
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004892 buf_T *buf;
4893 int i;
4894 list_T *l;
4895 dict_T *d;
LemonBoydb0ea7f2022-04-10 17:59:26 +01004896 int changelistindex;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004897
Bram Moolenaar93a10962022-06-16 11:42:09 +01004898 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004899 return;
4900
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004901 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
4902 return;
4903
Bram Moolenaar4c313b12019-08-24 22:58:31 +02004904 if (argvars[0].v_type == VAR_UNKNOWN)
4905 buf = curbuf;
4906 else
Bram Moolenaara5d38412020-09-02 21:02:35 +02004907 buf = tv_get_buf_from_arg(&argvars[0]);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004908 if (buf == NULL)
4909 return;
4910
4911 l = list_alloc();
4912 if (l == NULL)
4913 return;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004914 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01004915 {
4916 vim_free(l);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004917 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01004918 }
4919
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004920 /*
LemonBoydb0ea7f2022-04-10 17:59:26 +01004921 * The current window change list index tracks only the position for the
4922 * current buffer. For other buffers use the stored index for the current
4923 * window, or, if that's not available, the change list length.
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004924 */
LemonBoydb0ea7f2022-04-10 17:59:26 +01004925 if (buf == curwin->w_buffer)
4926 {
4927 changelistindex = curwin->w_changelistidx;
4928 }
4929 else
4930 {
4931 wininfo_T *wip;
4932
4933 FOR_ALL_BUF_WININFO(buf, wip)
4934 if (wip->wi_win == curwin)
4935 break;
4936 changelistindex = wip != NULL ? wip->wi_changelistidx
4937 : buf->b_changelistlen;
4938 }
4939 list_append_number(rettv->vval.v_list, (varnumber_T)changelistindex);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004940
4941 for (i = 0; i < buf->b_changelistlen; ++i)
4942 {
4943 if (buf->b_changelist[i].lnum == 0)
4944 continue;
4945 if ((d = dict_alloc()) == NULL)
4946 return;
4947 if (list_append_dict(l, d) == FAIL)
4948 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004949 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
4950 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004951 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004952 }
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004953}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004954
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004955 static void
4956getpos_both(
4957 typval_T *argvars,
4958 typval_T *rettv,
4959 int getcurpos,
4960 int charcol)
4961{
4962 pos_T *fp = NULL;
4963 pos_T pos;
4964 win_T *wp = curwin;
4965 list_T *l;
4966 int fnum = -1;
4967
4968 if (rettv_list_alloc(rettv) == OK)
4969 {
4970 l = rettv->vval.v_list;
4971 if (getcurpos)
4972 {
4973 if (argvars[0].v_type != VAR_UNKNOWN)
4974 {
4975 wp = find_win_by_nr_or_id(&argvars[0]);
4976 if (wp != NULL)
4977 fp = &wp->w_cursor;
4978 }
4979 else
4980 fp = &curwin->w_cursor;
4981 if (fp != NULL && charcol)
4982 {
4983 pos = *fp;
Bram Moolenaar91458462021-01-13 20:08:38 +01004984 pos.col =
4985 buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004986 fp = &pos;
4987 }
4988 }
4989 else
4990 fp = var2fpos(&argvars[0], TRUE, &fnum, charcol);
4991 if (fnum != -1)
4992 list_append_number(l, (varnumber_T)fnum);
4993 else
4994 list_append_number(l, (varnumber_T)0);
4995 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
4996 : (varnumber_T)0);
4997 list_append_number(l, (fp != NULL)
4998 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
4999 : (varnumber_T)0);
5000 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
5001 (varnumber_T)0);
5002 if (getcurpos)
5003 {
5004 int save_set_curswant = curwin->w_set_curswant;
5005 colnr_T save_curswant = curwin->w_curswant;
5006 colnr_T save_virtcol = curwin->w_virtcol;
5007
5008 if (wp == curwin)
5009 update_curswant();
5010 list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL
5011 ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1);
5012
5013 // Do not change "curswant", as it is unexpected that a get
5014 // function has a side effect.
5015 if (wp == curwin && save_set_curswant)
5016 {
5017 curwin->w_set_curswant = save_set_curswant;
5018 curwin->w_curswant = save_curswant;
5019 curwin->w_virtcol = save_virtcol;
5020 curwin->w_valid &= ~VALID_VIRTCOL;
5021 }
5022 }
5023 }
5024 else
5025 rettv->vval.v_number = FALSE;
5026}
5027
5028/*
5029 * "getcharpos()" function
5030 */
5031 static void
5032f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv)
5033{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005034 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5035 return;
5036
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005037 getpos_both(argvars, rettv, FALSE, TRUE);
5038}
5039
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005040/*
5041 * "getcharsearch()" function
5042 */
5043 static void
5044f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
5045{
Bram Moolenaar93a10962022-06-16 11:42:09 +01005046 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005047 {
5048 dict_T *dict = rettv->vval.v_dict;
5049
Bram Moolenaare0be1672018-07-08 16:50:37 +02005050 dict_add_string(dict, "char", last_csearch());
5051 dict_add_number(dict, "forward", last_csearch_forward());
5052 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005053 }
5054}
5055
5056/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005057 * "getenv()" function
5058 */
5059 static void
5060f_getenv(typval_T *argvars, typval_T *rettv)
5061{
5062 int mustfree = FALSE;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005063 char_u *p;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005064
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005065 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5066 return;
5067
5068 p = vim_getenv(tv_get_string(&argvars[0]), &mustfree);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005069 if (p == NULL)
5070 {
5071 rettv->v_type = VAR_SPECIAL;
5072 rettv->vval.v_number = VVAL_NULL;
5073 return;
5074 }
5075 if (!mustfree)
5076 p = vim_strsave(p);
5077 rettv->vval.v_string = p;
5078 rettv->v_type = VAR_STRING;
5079}
5080
5081/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005082 * "getfontname()" function
5083 */
5084 static void
5085f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
5086{
5087 rettv->v_type = VAR_STRING;
5088 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005089
5090 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5091 return;
5092
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005093#ifdef FEAT_GUI
5094 if (gui.in_use)
5095 {
5096 GuiFont font;
5097 char_u *name = NULL;
5098
5099 if (argvars[0].v_type == VAR_UNKNOWN)
5100 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005101 // Get the "Normal" font. Either the name saved by
5102 // hl_set_font_name() or from the font ID.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005103 font = gui.norm_font;
5104 name = hl_get_font_name();
5105 }
5106 else
5107 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005108 name = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005109 if (STRCMP(name, "*") == 0) // don't use font dialog
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005110 return;
5111 font = gui_mch_get_font(name, FALSE);
5112 if (font == NOFONT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005113 return; // Invalid font name, return empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005114 }
5115 rettv->vval.v_string = gui_mch_get_fontname(font, name);
5116 if (argvars[0].v_type != VAR_UNKNOWN)
5117 gui_mch_free_font(font);
5118 }
5119#endif
5120}
5121
5122/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01005123 * "getjumplist()" function
5124 */
5125 static void
5126f_getjumplist(typval_T *argvars, typval_T *rettv)
5127{
Bram Moolenaar4f505882018-02-10 21:06:32 +01005128 win_T *wp;
5129 int i;
5130 list_T *l;
5131 dict_T *d;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005132
Bram Moolenaar93a10962022-06-16 11:42:09 +01005133 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar4f505882018-02-10 21:06:32 +01005134 return;
5135
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005136 if (in_vim9script()
5137 && (check_for_opt_number_arg(argvars, 0) == FAIL
5138 || (argvars[0].v_type != VAR_UNKNOWN
5139 && check_for_opt_number_arg(argvars, 1) == FAIL)))
5140 return;
5141
Bram Moolenaar00aa0692019-04-27 20:37:57 +02005142 wp = find_tabwin(&argvars[0], &argvars[1], NULL);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005143 if (wp == NULL)
5144 return;
5145
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01005146 cleanup_jumplist(wp, TRUE);
5147
Bram Moolenaar4f505882018-02-10 21:06:32 +01005148 l = list_alloc();
5149 if (l == NULL)
5150 return;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005151 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005152 {
5153 vim_free(l);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005154 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005155 }
5156
Bram Moolenaar4f505882018-02-10 21:06:32 +01005157 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
5158
5159 for (i = 0; i < wp->w_jumplistlen; ++i)
5160 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005161 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
5162 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005163 if ((d = dict_alloc()) == NULL)
5164 return;
5165 if (list_append_dict(l, d) == FAIL)
5166 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005167 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
5168 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005169 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005170 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005171 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02005172 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005173 }
Bram Moolenaar4f505882018-02-10 21:06:32 +01005174}
5175
5176/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005177 * "getpid()" function
5178 */
5179 static void
5180f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
5181{
5182 rettv->vval.v_number = mch_get_pid();
5183}
5184
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005185/*
5186 * "getcurpos()" function
5187 */
5188 static void
5189f_getcurpos(typval_T *argvars, typval_T *rettv)
5190{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005191 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5192 return;
5193
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005194 getpos_both(argvars, rettv, TRUE, FALSE);
5195}
5196
5197 static void
5198f_getcursorcharpos(typval_T *argvars, typval_T *rettv)
5199{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005200 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5201 return;
5202
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005203 getpos_both(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005204}
5205
5206/*
5207 * "getpos(string)" function
5208 */
5209 static void
5210f_getpos(typval_T *argvars, typval_T *rettv)
5211{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005212 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5213 return;
5214
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005215 getpos_both(argvars, rettv, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005216}
5217
5218/*
zeertzjqd3f00f52021-12-24 12:02:43 +00005219 * Common between getreg(), getreginfo() and getregtype(): get the register
5220 * name from the first argument.
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005221 * Returns zero on error.
5222 */
5223 static int
5224getreg_get_regname(typval_T *argvars)
5225{
5226 char_u *strregname;
5227
5228 if (argvars[0].v_type != VAR_UNKNOWN)
5229 {
5230 strregname = tv_get_string_chk(&argvars[0]);
5231 if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1)
5232 {
5233 semsg(_(e_register_name_must_be_one_char_str), strregname);
5234 strregname = NULL;
5235 }
5236 if (strregname == NULL) // type error; errmsg already given
5237 return 0;
5238 }
5239 else
5240 // Default to v:register
5241 strregname = get_vim_var_str(VV_REG);
5242
5243 return *strregname == 0 ? '"' : *strregname;
5244}
5245
5246/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005247 * "getreg()" function
5248 */
5249 static void
5250f_getreg(typval_T *argvars, typval_T *rettv)
5251{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005252 int regname;
5253 int arg2 = FALSE;
5254 int return_list = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005255
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005256 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005257 && (check_for_opt_string_arg(argvars, 0) == FAIL
5258 || (argvars[0].v_type != VAR_UNKNOWN
5259 && (check_for_opt_bool_arg(argvars, 1) == FAIL
5260 || (argvars[1].v_type != VAR_UNKNOWN
5261 && check_for_opt_bool_arg(argvars, 2) == FAIL)))))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005262 return;
5263
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005264 regname = getreg_get_regname(argvars);
5265 if (regname == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005266 return;
5267
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005268 if (argvars[0].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_UNKNOWN)
5269 {
5270 int error = FALSE;
5271
5272 arg2 = (int)tv_get_bool_chk(&argvars[1], &error);
5273
5274 if (!error && argvars[2].v_type != VAR_UNKNOWN)
5275 return_list = (int)tv_get_bool_chk(&argvars[2], &error);
5276 if (error)
5277 return;
5278 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005279
5280 if (return_list)
5281 {
5282 rettv->v_type = VAR_LIST;
5283 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
5284 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
5285 if (rettv->vval.v_list == NULL)
5286 (void)rettv_list_alloc(rettv);
5287 else
5288 ++rettv->vval.v_list->lv_refcount;
5289 }
5290 else
5291 {
5292 rettv->v_type = VAR_STRING;
5293 rettv->vval.v_string = get_reg_contents(regname,
5294 arg2 ? GREG_EXPR_SRC : 0);
5295 }
5296}
5297
5298/*
5299 * "getregtype()" function
5300 */
5301 static void
5302f_getregtype(typval_T *argvars, typval_T *rettv)
5303{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005304 int regname;
5305 char_u buf[NUMBUFLEN + 2];
5306 long reglen = 0;
5307
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005308 // on error return an empty string
5309 rettv->v_type = VAR_STRING;
5310 rettv->vval.v_string = NULL;
5311
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005312 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5313 return;
5314
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005315 regname = getreg_get_regname(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005316 if (regname == 0)
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005317 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005318
5319 buf[0] = NUL;
5320 buf[1] = NUL;
5321 switch (get_reg_type(regname, &reglen))
5322 {
5323 case MLINE: buf[0] = 'V'; break;
5324 case MCHAR: buf[0] = 'v'; break;
5325 case MBLOCK:
5326 buf[0] = Ctrl_V;
5327 sprintf((char *)buf + 1, "%ld", reglen + 1);
5328 break;
5329 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005330 rettv->vval.v_string = vim_strsave(buf);
5331}
5332
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005333/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005334 * "gettagstack()" function
5335 */
5336 static void
5337f_gettagstack(typval_T *argvars, typval_T *rettv)
5338{
5339 win_T *wp = curwin; // default is current window
5340
Bram Moolenaar93a10962022-06-16 11:42:09 +01005341 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005342 return;
5343
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005344 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5345 return;
5346
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005347 if (argvars[0].v_type != VAR_UNKNOWN)
5348 {
5349 wp = find_win_by_nr_or_id(&argvars[0]);
5350 if (wp == NULL)
5351 return;
5352 }
5353
5354 get_tagstack(wp, rettv->vval.v_dict);
5355}
5356
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005357/*
5358 * "gettext()" function
5359 */
5360 static void
5361f_gettext(typval_T *argvars, typval_T *rettv)
5362{
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01005363 if (check_for_nonempty_string_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005364 return;
5365
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01005366 rettv->v_type = VAR_STRING;
5367 rettv->vval.v_string = vim_strsave((char_u *)_(argvars[0].vval.v_string));
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005368}
5369
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005370// for VIM_VERSION_ defines
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005371#include "version.h"
5372
5373/*
5374 * "has()" function
5375 */
Bram Moolenaara259d8d2020-01-31 20:10:50 +01005376 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005377f_has(typval_T *argvars, typval_T *rettv)
5378{
5379 int i;
5380 char_u *name;
Bram Moolenaar79296512020-03-22 16:17:14 +01005381 int x = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005382 int n = FALSE;
Bram Moolenaar79296512020-03-22 16:17:14 +01005383 typedef struct {
5384 char *name;
5385 short present;
5386 } has_item_T;
5387 static has_item_T has_list[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005388 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005389 {"amiga",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005390#ifdef AMIGA
Bram Moolenaar79296512020-03-22 16:17:14 +01005391 1
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005392#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005393 0
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005394#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005395 },
5396 {"arp",
5397#if defined(AMIGA) && defined(FEAT_ARP)
5398 1
5399#else
5400 0
5401#endif
5402 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005403 {"haiku",
5404#ifdef __HAIKU__
5405 1
5406#else
5407 0
5408#endif
5409 },
5410 {"bsd",
5411#if defined(BSD) && !defined(MACOS_X)
5412 1
5413#else
5414 0
5415#endif
5416 },
5417 {"hpux",
5418#ifdef hpux
5419 1
5420#else
5421 0
5422#endif
5423 },
5424 {"linux",
5425#ifdef __linux__
5426 1
5427#else
5428 0
5429#endif
5430 },
5431 {"mac", // Mac OS X (and, once, Mac OS Classic)
5432#ifdef MACOS_X
5433 1
5434#else
5435 0
5436#endif
5437 },
5438 {"osx", // Mac OS X
5439#ifdef MACOS_X
5440 1
5441#else
5442 0
5443#endif
5444 },
5445 {"macunix", // Mac OS X, with the darwin feature
5446#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5447 1
5448#else
5449 0
5450#endif
5451 },
5452 {"osxdarwin", // synonym for macunix
5453#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5454 1
5455#else
5456 0
5457#endif
5458 },
5459 {"qnx",
5460#ifdef __QNX__
5461 1
5462#else
5463 0
5464#endif
5465 },
5466 {"sun",
5467#ifdef SUN_SYSTEM
5468 1
5469#else
5470 0
5471#endif
5472 },
5473 {"unix",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005474#ifdef UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005475 1
5476#else
5477 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005478#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005479 },
5480 {"vms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005481#ifdef VMS
Bram Moolenaar79296512020-03-22 16:17:14 +01005482 1
5483#else
5484 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005485#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005486 },
5487 {"win32",
Bram Moolenaar4f974752019-02-17 17:44:42 +01005488#ifdef MSWIN
Bram Moolenaar79296512020-03-22 16:17:14 +01005489 1
5490#else
5491 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005492#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005493 },
5494 {"win32unix",
K.Takata972db232022-02-04 10:45:38 +00005495#ifdef WIN32UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005496 1
5497#else
5498 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005499#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005500 },
5501 {"win64",
Bram Moolenaar44b443c2019-02-18 22:14:18 +01005502#ifdef _WIN64
Bram Moolenaar79296512020-03-22 16:17:14 +01005503 1
5504#else
5505 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005506#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005507 },
Bram Moolenaar424bcae2022-01-31 14:59:41 +00005508 {"ebcdic", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005509 {"fname_case",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005510#ifndef CASE_INSENSITIVE_FILENAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005511 1
5512#else
5513 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005514#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005515 },
5516 {"acl",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005517#ifdef HAVE_ACL
Bram Moolenaar79296512020-03-22 16:17:14 +01005518 1
5519#else
5520 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005521#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005522 },
5523 {"arabic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005524#ifdef FEAT_ARABIC
Bram Moolenaar79296512020-03-22 16:17:14 +01005525 1
5526#else
5527 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005528#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005529 },
5530 {"autocmd", 1},
5531 {"autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005532#ifdef FEAT_AUTOCHDIR
Bram Moolenaar79296512020-03-22 16:17:14 +01005533 1
5534#else
5535 0
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005536#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005537 },
5538 {"autoservername",
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005539#ifdef FEAT_AUTOSERVERNAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005540 1
5541#else
5542 0
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005543#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005544 },
5545 {"balloon_eval",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005546#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005547 1
5548#else
5549 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005550#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005551 },
5552 {"balloon_multiline",
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00005553#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005554 1
5555#else
5556 0
5557#endif
5558 },
5559 {"balloon_eval_term",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005560#ifdef FEAT_BEVAL_TERM
Bram Moolenaar79296512020-03-22 16:17:14 +01005561 1
5562#else
5563 0
Bram Moolenaar51b0f372017-11-18 18:52:04 +01005564#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005565 },
Bram Moolenaar2ee347f2022-08-26 17:53:44 +01005566 {"builtin_terms", 1},
5567 {"all_builtin_terms", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005568 {"browsefilter",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005569#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01005570 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005571 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar79296512020-03-22 16:17:14 +01005572 1
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005573#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005574 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005575#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005576 },
5577 {"byte_offset",
5578#ifdef FEAT_BYTEOFF
5579 1
5580#else
5581 0
5582#endif
5583 },
5584 {"channel",
5585#ifdef FEAT_JOB_CHANNEL
5586 1
5587#else
5588 0
5589#endif
5590 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01005591 {"cindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005592 {"clientserver",
5593#ifdef FEAT_CLIENTSERVER
5594 1
5595#else
5596 0
5597#endif
5598 },
5599 {"clipboard",
5600#ifdef FEAT_CLIPBOARD
5601 1
5602#else
5603 0
5604#endif
5605 },
5606 {"cmdline_compl", 1},
5607 {"cmdline_hist", 1},
Martin Tournoij7904fa42022-10-04 16:28:45 +01005608 {"cmdwin", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005609 {"comments", 1},
5610 {"conceal",
5611#ifdef FEAT_CONCEAL
5612 1
5613#else
5614 0
5615#endif
5616 },
5617 {"cryptv",
5618#ifdef FEAT_CRYPT
5619 1
5620#else
5621 0
5622#endif
5623 },
5624 {"crypt-blowfish",
5625#ifdef FEAT_CRYPT
5626 1
5627#else
5628 0
5629#endif
5630 },
5631 {"crypt-blowfish2",
5632#ifdef FEAT_CRYPT
5633 1
5634#else
5635 0
5636#endif
5637 },
5638 {"cscope",
5639#ifdef FEAT_CSCOPE
5640 1
5641#else
5642 0
5643#endif
5644 },
5645 {"cursorbind", 1},
5646 {"cursorshape",
5647#ifdef CURSOR_SHAPE
5648 1
5649#else
5650 0
5651#endif
5652 },
5653 {"debug",
5654#ifdef DEBUG
5655 1
5656#else
5657 0
5658#endif
5659 },
5660 {"dialog_con",
5661#ifdef FEAT_CON_DIALOG
5662 1
5663#else
5664 0
5665#endif
5666 },
5667 {"dialog_gui",
5668#ifdef FEAT_GUI_DIALOG
5669 1
5670#else
5671 0
5672#endif
5673 },
5674 {"diff",
5675#ifdef FEAT_DIFF
5676 1
5677#else
5678 0
5679#endif
5680 },
5681 {"digraphs",
5682#ifdef FEAT_DIGRAPHS
5683 1
5684#else
5685 0
5686#endif
5687 },
5688 {"directx",
5689#ifdef FEAT_DIRECTX
5690 1
5691#else
5692 0
5693#endif
5694 },
5695 {"dnd",
5696#ifdef FEAT_DND
5697 1
5698#else
5699 0
5700#endif
5701 },
Bram Moolenaar1d1ce612021-06-27 19:02:52 +02005702 {"drop_file",
5703#ifdef HAVE_DROP_FILE
5704 1
5705#else
5706 0
5707#endif
5708 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005709 {"emacs_tags",
5710#ifdef FEAT_EMACS_TAGS
5711 1
5712#else
5713 0
5714#endif
5715 },
5716 {"eval", 1}, // always present, of course!
5717 {"ex_extra", 1}, // graduated feature
5718 {"extra_search",
5719#ifdef FEAT_SEARCH_EXTRA
5720 1
5721#else
5722 0
5723#endif
5724 },
Bram Moolenaarf80f40a2022-08-25 16:02:23 +01005725 {"file_in_path", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005726 {"filterpipe",
5727#if defined(FEAT_FILTERPIPE) && !defined(VIMDLL)
5728 1
5729#else
5730 0
5731#endif
5732 },
5733 {"find_in_path",
5734#ifdef FEAT_FIND_ID
5735 1
5736#else
5737 0
5738#endif
5739 },
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01005740 {"float", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005741 {"folding",
5742#ifdef FEAT_FOLDING
5743 1
5744#else
5745 0
5746#endif
5747 },
Bram Moolenaarc8ac3a02022-09-04 12:29:28 +01005748 {"footer", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01005749 {"fork",
5750#if !defined(USE_SYSTEM) && defined(UNIX)
5751 1
5752#else
5753 0
5754#endif
5755 },
5756 {"gettext",
5757#ifdef FEAT_GETTEXT
5758 1
5759#else
5760 0
5761#endif
5762 },
5763 {"gui",
5764#ifdef FEAT_GUI
5765 1
5766#else
5767 0
5768#endif
5769 },
Bram Moolenaar0b962e52022-04-03 18:02:37 +01005770 {"gui_neXtaw", 0 },
5771 {"gui_athena", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005772 {"gui_gtk",
5773#ifdef FEAT_GUI_GTK
5774 1
5775#else
5776 0
5777#endif
5778 },
5779 {"gui_gtk2",
5780#if defined(FEAT_GUI_GTK) && !defined(USE_GTK3)
5781 1
5782#else
5783 0
5784#endif
5785 },
5786 {"gui_gtk3",
5787#if defined(FEAT_GUI_GTK) && defined(USE_GTK3)
5788 1
5789#else
5790 0
5791#endif
5792 },
5793 {"gui_gnome",
5794#ifdef FEAT_GUI_GNOME
5795 1
5796#else
5797 0
5798#endif
5799 },
5800 {"gui_haiku",
5801#ifdef FEAT_GUI_HAIKU
5802 1
5803#else
5804 0
5805#endif
5806 },
Bram Moolenaar097148e2020-08-11 21:58:20 +02005807 {"gui_mac", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01005808 {"gui_motif",
5809#ifdef FEAT_GUI_MOTIF
5810 1
5811#else
5812 0
5813#endif
5814 },
5815 {"gui_photon",
5816#ifdef FEAT_GUI_PHOTON
5817 1
5818#else
5819 0
5820#endif
5821 },
5822 {"gui_win32",
5823#ifdef FEAT_GUI_MSWIN
5824 1
5825#else
5826 0
5827#endif
5828 },
5829 {"iconv",
5830#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
5831 1
5832#else
5833 0
5834#endif
5835 },
5836 {"insert_expand", 1},
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02005837 {"ipv6",
5838#ifdef FEAT_IPV6
5839 1
5840#else
5841 0
5842#endif
5843 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005844 {"job",
5845#ifdef FEAT_JOB_CHANNEL
5846 1
5847#else
5848 0
5849#endif
5850 },
Bram Moolenaar739f13a2021-12-13 13:12:53 +00005851 {"jumplist", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005852 {"keymap",
5853#ifdef FEAT_KEYMAP
5854 1
5855#else
5856 0
5857#endif
5858 },
5859 {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure
5860 {"langmap",
5861#ifdef FEAT_LANGMAP
5862 1
5863#else
5864 0
5865#endif
5866 },
5867 {"libcall",
5868#ifdef FEAT_LIBCALL
5869 1
5870#else
5871 0
5872#endif
5873 },
5874 {"linebreak",
5875#ifdef FEAT_LINEBREAK
5876 1
5877#else
5878 0
5879#endif
5880 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01005881 {"lispindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005882 {"listcmds", 1},
5883 {"localmap", 1},
5884 {"lua",
5885#if defined(FEAT_LUA) && !defined(DYNAMIC_LUA)
5886 1
5887#else
5888 0
5889#endif
5890 },
5891 {"menu",
5892#ifdef FEAT_MENU
5893 1
5894#else
5895 0
5896#endif
5897 },
5898 {"mksession",
5899#ifdef FEAT_SESSION
5900 1
5901#else
5902 0
5903#endif
5904 },
5905 {"modify_fname", 1},
5906 {"mouse", 1},
5907 {"mouseshape",
5908#ifdef FEAT_MOUSESHAPE
5909 1
5910#else
5911 0
5912#endif
5913 },
5914 {"mouse_dec",
5915#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC)
5916 1
5917#else
5918 0
5919#endif
5920 },
5921 {"mouse_gpm",
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00005922#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM) && !defined(DYNAMIC_GPM)
Bram Moolenaar79296512020-03-22 16:17:14 +01005923 1
5924#else
5925 0
5926#endif
5927 },
5928 {"mouse_jsbterm",
5929#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB)
5930 1
5931#else
5932 0
5933#endif
5934 },
5935 {"mouse_netterm",
5936#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET)
5937 1
5938#else
5939 0
5940#endif
5941 },
5942 {"mouse_pterm",
5943#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM)
5944 1
5945#else
5946 0
5947#endif
5948 },
5949 {"mouse_sgr",
5950#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5951 1
5952#else
5953 0
5954#endif
5955 },
5956 {"mouse_sysmouse",
5957#if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE)
5958 1
5959#else
5960 0
5961#endif
5962 },
5963 {"mouse_urxvt",
5964#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT)
5965 1
5966#else
5967 0
5968#endif
5969 },
5970 {"mouse_xterm",
5971#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5972 1
5973#else
5974 0
5975#endif
5976 },
5977 {"multi_byte", 1},
5978 {"multi_byte_ime",
5979#ifdef FEAT_MBYTE_IME
5980 1
5981#else
5982 0
5983#endif
5984 },
5985 {"multi_lang",
5986#ifdef FEAT_MULTI_LANG
5987 1
5988#else
5989 0
5990#endif
5991 },
5992 {"mzscheme",
5993#if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME)
5994 1
5995#else
5996 0
5997#endif
5998 },
Leah Neukirchen0a7984a2021-10-14 21:27:55 +01005999 {"nanotime",
6000#ifdef ST_MTIM_NSEC
6001 1
6002#else
6003 0
6004#endif
6005 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006006 {"num64", 1},
6007 {"ole",
6008#ifdef FEAT_OLE
6009 1
6010#else
6011 0
6012#endif
6013 },
6014 {"packages",
6015#ifdef FEAT_EVAL
6016 1
6017#else
6018 0
6019#endif
6020 },
Bram Moolenaar2bd9dbc2022-08-25 18:12:06 +01006021 {"path_extra", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006022 {"perl",
6023#if defined(FEAT_PERL) && !defined(DYNAMIC_PERL)
6024 1
6025#else
6026 0
6027#endif
6028 },
6029 {"persistent_undo",
6030#ifdef FEAT_PERSISTENT_UNDO
6031 1
6032#else
6033 0
6034#endif
6035 },
6036 {"python_compiled",
6037#if defined(FEAT_PYTHON)
6038 1
6039#else
6040 0
6041#endif
6042 },
6043 {"python_dynamic",
6044#if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON)
6045 1
6046#else
6047 0
6048#endif
6049 },
6050 {"python",
6051#if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)
6052 1
6053#else
6054 0
6055#endif
6056 },
6057 {"pythonx",
6058#if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \
6059 || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3))
6060 1
6061#else
6062 0
6063#endif
6064 },
6065 {"python3_compiled",
6066#if defined(FEAT_PYTHON3)
6067 1
6068#else
6069 0
6070#endif
6071 },
6072 {"python3_dynamic",
6073#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3)
6074 1
6075#else
6076 0
6077#endif
6078 },
6079 {"python3",
6080#if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)
6081 1
6082#else
6083 0
6084#endif
6085 },
6086 {"popupwin",
6087#ifdef FEAT_PROP_POPUP
6088 1
6089#else
6090 0
6091#endif
6092 },
6093 {"postscript",
6094#ifdef FEAT_POSTSCRIPT
6095 1
6096#else
6097 0
6098#endif
6099 },
6100 {"printer",
6101#ifdef FEAT_PRINTER
6102 1
6103#else
6104 0
6105#endif
6106 },
6107 {"profile",
6108#ifdef FEAT_PROFILE
6109 1
6110#else
6111 0
6112#endif
6113 },
6114 {"reltime",
6115#ifdef FEAT_RELTIME
6116 1
6117#else
6118 0
6119#endif
6120 },
6121 {"quickfix",
6122#ifdef FEAT_QUICKFIX
6123 1
6124#else
6125 0
6126#endif
6127 },
6128 {"rightleft",
6129#ifdef FEAT_RIGHTLEFT
6130 1
6131#else
6132 0
6133#endif
6134 },
6135 {"ruby",
6136#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
6137 1
6138#else
6139 0
6140#endif
6141 },
6142 {"scrollbind", 1},
Martin Tournoijba43e762022-10-13 22:12:15 +01006143 {"showcmd", 1},
6144 {"cmdline_info", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006145 {"signs",
6146#ifdef FEAT_SIGNS
6147 1
6148#else
6149 0
6150#endif
6151 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01006152 {"smartindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006153 {"startuptime",
6154#ifdef STARTUPTIME
6155 1
6156#else
6157 0
6158#endif
6159 },
6160 {"statusline",
6161#ifdef FEAT_STL_OPT
6162 1
6163#else
6164 0
6165#endif
6166 },
6167 {"netbeans_intg",
6168#ifdef FEAT_NETBEANS_INTG
6169 1
6170#else
6171 0
6172#endif
6173 },
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006174 {"sodium",
K.Takatad68b2fc2022-02-12 11:18:37 +00006175#if defined(FEAT_SODIUM) && !defined(DYNAMIC_SODIUM)
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006176 1
6177#else
6178 0
6179#endif
6180 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006181 {"sound",
6182#ifdef FEAT_SOUND
6183 1
6184#else
6185 0
6186#endif
6187 },
6188 {"spell",
6189#ifdef FEAT_SPELL
6190 1
6191#else
6192 0
6193#endif
6194 },
6195 {"syntax",
6196#ifdef FEAT_SYN_HL
6197 1
6198#else
6199 0
6200#endif
6201 },
6202 {"system",
6203#if defined(USE_SYSTEM) || !defined(UNIX)
6204 1
6205#else
6206 0
6207#endif
6208 },
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00006209 {"tag_binary", 1}, // graduated feature
Bram Moolenaar79296512020-03-22 16:17:14 +01006210 {"tcl",
6211#if defined(FEAT_TCL) && !defined(DYNAMIC_TCL)
6212 1
6213#else
6214 0
6215#endif
6216 },
6217 {"termguicolors",
6218#ifdef FEAT_TERMGUICOLORS
6219 1
6220#else
6221 0
6222#endif
6223 },
6224 {"terminal",
6225#if defined(FEAT_TERMINAL) && !defined(MSWIN)
6226 1
6227#else
6228 0
6229#endif
6230 },
6231 {"terminfo",
6232#ifdef TERMINFO
6233 1
6234#else
6235 0
6236#endif
6237 },
6238 {"termresponse",
6239#ifdef FEAT_TERMRESPONSE
6240 1
6241#else
6242 0
6243#endif
6244 },
Bram Moolenaar88774872022-08-16 20:24:29 +01006245 {"textobjects", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006246 {"textprop",
6247#ifdef FEAT_PROP_POPUP
6248 1
6249#else
6250 0
6251#endif
6252 },
6253 {"tgetent",
6254#ifdef HAVE_TGETENT
6255 1
6256#else
6257 0
6258#endif
6259 },
6260 {"timers",
6261#ifdef FEAT_TIMERS
6262 1
6263#else
6264 0
6265#endif
6266 },
Bram Moolenaar651fca82021-11-29 20:39:38 +00006267 {"title", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006268 {"toolbar",
6269#ifdef FEAT_TOOLBAR
6270 1
6271#else
6272 0
6273#endif
6274 },
6275 {"unnamedplus",
6276#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
6277 1
6278#else
6279 0
6280#endif
6281 },
6282 {"user-commands", 1}, // was accidentally included in 5.4
6283 {"user_commands", 1},
6284 {"vartabs",
6285#ifdef FEAT_VARTABS
6286 1
6287#else
6288 0
6289#endif
6290 },
6291 {"vertsplit", 1},
6292 {"viminfo",
6293#ifdef FEAT_VIMINFO
6294 1
6295#else
6296 0
6297#endif
6298 },
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +00006299 {"vim9script", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006300 {"vimscript-1", 1},
6301 {"vimscript-2", 1},
6302 {"vimscript-3", 1},
6303 {"vimscript-4", 1},
6304 {"virtualedit", 1},
6305 {"visual", 1},
6306 {"visualextra", 1},
6307 {"vreplace", 1},
6308 {"vtp",
6309#ifdef FEAT_VTP
6310 1
6311#else
6312 0
6313#endif
6314 },
Bram Moolenaar074fbd42022-08-26 16:41:14 +01006315 {"wildignore", 1},
Bram Moolenaar54162322022-08-26 16:58:51 +01006316 {"wildmenu", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006317 {"windows", 1},
6318 {"winaltkeys",
6319#ifdef FEAT_WAK
6320 1
6321#else
6322 0
6323#endif
6324 },
6325 {"writebackup",
6326#ifdef FEAT_WRITEBACKUP
6327 1
6328#else
6329 0
6330#endif
6331 },
6332 {"xim",
6333#ifdef FEAT_XIM
6334 1
6335#else
6336 0
6337#endif
6338 },
6339 {"xfontset",
6340#ifdef FEAT_XFONTSET
6341 1
6342#else
6343 0
6344#endif
6345 },
6346 {"xpm",
6347#if defined(FEAT_XPM_W32) || defined(HAVE_XPM)
6348 1
6349#else
6350 0
6351#endif
6352 },
6353 {"xpm_w32", // for backward compatibility
6354#ifdef FEAT_XPM_W32
6355 1
6356#else
6357 0
6358#endif
6359 },
6360 {"xsmp",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006361#ifdef USE_XSMP
Bram Moolenaar79296512020-03-22 16:17:14 +01006362 1
6363#else
6364 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006365#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006366 },
6367 {"xsmp_interact",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006368#ifdef USE_XSMP_INTERACT
Bram Moolenaar79296512020-03-22 16:17:14 +01006369 1
6370#else
6371 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006372#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006373 },
6374 {"xterm_clipboard",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006375#ifdef FEAT_XCLIPBOARD
Bram Moolenaar79296512020-03-22 16:17:14 +01006376 1
6377#else
6378 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006379#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006380 },
6381 {"xterm_save",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006382#ifdef FEAT_XTERM_SAVE
Bram Moolenaar79296512020-03-22 16:17:14 +01006383 1
6384#else
6385 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006386#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006387 },
6388 {"X11",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006389#if defined(UNIX) && defined(FEAT_X11)
Bram Moolenaar79296512020-03-22 16:17:14 +01006390 1
6391#else
6392 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006393#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006394 },
6395 {NULL, 0}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006396 };
6397
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006398 if (in_vim9script()
6399 && (check_for_string_arg(argvars, 0) == FAIL
6400 || check_for_opt_bool_arg(argvars, 1) == FAIL))
6401 return;
6402
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006403 name = tv_get_string(&argvars[0]);
Bram Moolenaar79296512020-03-22 16:17:14 +01006404 for (i = 0; has_list[i].name != NULL; ++i)
6405 if (STRICMP(name, has_list[i].name) == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006406 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006407 x = TRUE;
6408 n = has_list[i].present;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006409 break;
6410 }
6411
Bram Moolenaar79296512020-03-22 16:17:14 +01006412 // features also in has_list[] but sometimes enabled at runtime
6413 if (x == TRUE && n == FALSE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006414 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006415 if (0)
Bram Moolenaar86b9a3e2020-04-07 19:57:29 +02006416 {
6417 // intentionally empty
6418 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006419#ifdef VIMDLL
6420 else if (STRICMP(name, "filterpipe") == 0)
6421 n = gui.in_use || gui.starting;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006422#endif
6423#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6424 else if (STRICMP(name, "iconv") == 0)
6425 n = iconv_enabled(FALSE);
6426#endif
6427#ifdef DYNAMIC_LUA
6428 else if (STRICMP(name, "lua") == 0)
6429 n = lua_enabled(FALSE);
6430#endif
6431#ifdef DYNAMIC_MZSCHEME
6432 else if (STRICMP(name, "mzscheme") == 0)
6433 n = mzscheme_enabled(FALSE);
6434#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006435#ifdef DYNAMIC_PERL
6436 else if (STRICMP(name, "perl") == 0)
6437 n = perl_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006438#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006439#ifdef DYNAMIC_PYTHON
6440 else if (STRICMP(name, "python") == 0)
6441 n = python_enabled(FALSE);
6442#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006443#ifdef DYNAMIC_PYTHON3
6444 else if (STRICMP(name, "python3") == 0)
6445 n = python3_enabled(FALSE);
6446#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006447#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6448 else if (STRICMP(name, "pythonx") == 0)
6449 {
6450# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
6451 if (p_pyx == 0)
6452 n = python3_enabled(FALSE) || python_enabled(FALSE);
6453 else if (p_pyx == 3)
6454 n = python3_enabled(FALSE);
6455 else if (p_pyx == 2)
6456 n = python_enabled(FALSE);
6457# elif defined(DYNAMIC_PYTHON)
6458 n = python_enabled(FALSE);
6459# elif defined(DYNAMIC_PYTHON3)
6460 n = python3_enabled(FALSE);
6461# endif
6462 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006463#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006464#ifdef DYNAMIC_RUBY
6465 else if (STRICMP(name, "ruby") == 0)
6466 n = ruby_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006467#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006468#ifdef DYNAMIC_TCL
6469 else if (STRICMP(name, "tcl") == 0)
6470 n = tcl_enabled(FALSE);
Bram Moolenaar4b8366b2019-05-04 17:34:34 +02006471#endif
K.Takatad68b2fc2022-02-12 11:18:37 +00006472#ifdef DYNAMIC_SODIUM
6473 else if (STRICMP(name, "sodium") == 0)
6474 n = sodium_enabled(FALSE);
6475#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006476#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02006477 else if (STRICMP(name, "terminal") == 0)
6478 n = terminal_enabled();
6479#endif
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00006480#ifdef DYNAMIC_GPM
6481 else if (STRICMP(name, "mouse_gpm") == 0)
6482 n = gpm_available();
6483#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006484 }
6485
Bram Moolenaar79296512020-03-22 16:17:14 +01006486 // features not in has_list[]
6487 if (x == FALSE)
6488 {
6489 if (STRNICMP(name, "patch", 5) == 0)
6490 {
6491 x = TRUE;
6492 if (name[5] == '-'
6493 && STRLEN(name) >= 11
K.Takatad90f91f2022-07-30 15:43:59 +01006494 && (name[6] >= '1' && name[6] <= '9'))
Bram Moolenaar79296512020-03-22 16:17:14 +01006495 {
K.Takatad90f91f2022-07-30 15:43:59 +01006496 char *end;
6497 int major, minor;
Bram Moolenaar79296512020-03-22 16:17:14 +01006498
K.Takatad90f91f2022-07-30 15:43:59 +01006499 // This works for patch-8.1.2, patch-9.0.3, patch-10.0.4, etc.
6500 // Not for patch-9.10.5.
6501 major = (int)strtoul((char *)name + 6, &end, 10);
6502 if (*end == '.' && vim_isdigit(end[1])
6503 && end[2] == '.' && vim_isdigit(end[3]))
6504 {
6505 minor = atoi(end + 1);
6506
6507 // Expect "patch-9.9.01234".
6508 n = (major < VIM_VERSION_MAJOR
6509 || (major == VIM_VERSION_MAJOR
6510 && (minor < VIM_VERSION_MINOR
6511 || (minor == VIM_VERSION_MINOR
6512 && has_patch(atoi(end + 3))))));
6513 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006514 }
Bram Moolenaar5154a882022-07-18 20:48:50 +01006515 else if (isdigit(name[5]))
Bram Moolenaar79296512020-03-22 16:17:14 +01006516 n = has_patch(atoi((char *)name + 5));
6517 }
6518 else if (STRICMP(name, "vim_starting") == 0)
6519 {
6520 x = TRUE;
6521 n = (starting != 0);
6522 }
6523 else if (STRICMP(name, "ttyin") == 0)
6524 {
6525 x = TRUE;
6526 n = mch_input_isatty();
6527 }
6528 else if (STRICMP(name, "ttyout") == 0)
6529 {
6530 x = TRUE;
6531 n = stdout_isatty;
6532 }
6533 else if (STRICMP(name, "multi_byte_encoding") == 0)
6534 {
6535 x = TRUE;
6536 n = has_mbyte;
6537 }
6538 else if (STRICMP(name, "gui_running") == 0)
6539 {
6540 x = TRUE;
6541#ifdef FEAT_GUI
6542 n = (gui.in_use || gui.starting);
6543#endif
6544 }
6545 else if (STRICMP(name, "browse") == 0)
6546 {
6547 x = TRUE;
6548#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6549 n = gui.in_use; // gui_mch_browse() works when GUI is running
6550#endif
6551 }
6552 else if (STRICMP(name, "syntax_items") == 0)
6553 {
6554 x = TRUE;
6555#ifdef FEAT_SYN_HL
6556 n = syntax_present(curwin);
6557#endif
6558 }
6559 else if (STRICMP(name, "vcon") == 0)
6560 {
6561 x = TRUE;
6562#ifdef FEAT_VTP
6563 n = is_term_win32() && has_vtp_working();
6564#endif
6565 }
6566 else if (STRICMP(name, "netbeans_enabled") == 0)
6567 {
6568 x = TRUE;
6569#ifdef FEAT_NETBEANS_INTG
6570 n = netbeans_active();
6571#endif
6572 }
6573 else if (STRICMP(name, "mouse_gpm_enabled") == 0)
6574 {
6575 x = TRUE;
6576#ifdef FEAT_MOUSE_GPM
6577 n = gpm_enabled();
6578#endif
6579 }
6580 else if (STRICMP(name, "conpty") == 0)
6581 {
6582 x = TRUE;
6583#if defined(FEAT_TERMINAL) && defined(MSWIN)
6584 n = use_conpty();
6585#endif
6586 }
6587 else if (STRICMP(name, "clipboard_working") == 0)
6588 {
6589 x = TRUE;
6590#ifdef FEAT_CLIPBOARD
6591 n = clip_star.available;
6592#endif
6593 }
6594 }
6595
Bram Moolenaar04637e22020-09-05 18:45:29 +02006596 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
Bram Moolenaar79296512020-03-22 16:17:14 +01006597 // return whether feature could ever be enabled
6598 rettv->vval.v_number = x;
6599 else
6600 // return whether feature is enabled
6601 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006602}
6603
6604/*
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006605 * Return TRUE if "feature" can change later.
6606 * Also when checking for the feature has side effects, such as loading a DLL.
6607 */
6608 int
6609dynamic_feature(char_u *feature)
6610{
6611 return (feature == NULL
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006612#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6613 || (STRICMP(feature, "browse") == 0 && !gui.in_use)
6614#endif
6615#ifdef VIMDLL
6616 || STRICMP(feature, "filterpipe") == 0
6617#endif
Bram Moolenaar29b281b2020-11-10 20:58:00 +01006618#if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL)
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006619 // this can only change on Unix where the ":gui" command could be
6620 // used.
6621 || (STRICMP(feature, "gui_running") == 0 && !gui.in_use)
6622#endif
6623#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6624 || STRICMP(feature, "iconv") == 0
6625#endif
6626#ifdef DYNAMIC_LUA
6627 || STRICMP(feature, "lua") == 0
6628#endif
6629#ifdef FEAT_MOUSE_GPM
6630 || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled())
6631#endif
6632#ifdef DYNAMIC_MZSCHEME
6633 || STRICMP(feature, "mzscheme") == 0
6634#endif
6635#ifdef FEAT_NETBEANS_INTG
6636 || STRICMP(feature, "netbeans_enabled") == 0
6637#endif
6638#ifdef DYNAMIC_PERL
6639 || STRICMP(feature, "perl") == 0
6640#endif
6641#ifdef DYNAMIC_PYTHON
6642 || STRICMP(feature, "python") == 0
6643#endif
6644#ifdef DYNAMIC_PYTHON3
6645 || STRICMP(feature, "python3") == 0
6646#endif
6647#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6648 || STRICMP(feature, "pythonx") == 0
6649#endif
6650#ifdef DYNAMIC_RUBY
6651 || STRICMP(feature, "ruby") == 0
6652#endif
6653#ifdef FEAT_SYN_HL
6654 || STRICMP(feature, "syntax_items") == 0
6655#endif
6656#ifdef DYNAMIC_TCL
6657 || STRICMP(feature, "tcl") == 0
6658#endif
6659 // once "starting" is zero it will stay that way
6660 || (STRICMP(feature, "vim_starting") == 0 && starting != 0)
6661 || STRICMP(feature, "multi_byte_encoding") == 0
6662#if defined(FEAT_TERMINAL) && defined(MSWIN)
6663 || STRICMP(feature, "conpty") == 0
6664#endif
6665 );
6666}
6667
6668/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006669 * "haslocaldir()" function
6670 */
6671 static void
6672f_haslocaldir(typval_T *argvars, typval_T *rettv)
6673{
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006674 tabpage_T *tp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006675 win_T *wp = NULL;
6676
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006677 if (in_vim9script()
6678 && (check_for_opt_number_arg(argvars, 0) == FAIL
6679 || (argvars[0].v_type != VAR_UNKNOWN
6680 && check_for_opt_number_arg(argvars, 1) == FAIL)))
6681 return;
6682
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006683 wp = find_tabwin(&argvars[0], &argvars[1], &tp);
6684
6685 // Check for window-local and tab-local directories
6686 if (wp != NULL && wp->w_localdir != NULL)
6687 rettv->vval.v_number = 1;
6688 else if (tp != NULL && tp->tp_localdir != NULL)
6689 rettv->vval.v_number = 2;
6690 else
6691 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006692}
6693
6694/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006695 * "highlightID(name)" function
6696 */
6697 static void
6698f_hlID(typval_T *argvars, typval_T *rettv)
6699{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006700 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6701 return;
6702
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006703 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006704}
6705
6706/*
6707 * "highlight_exists()" function
6708 */
6709 static void
6710f_hlexists(typval_T *argvars, typval_T *rettv)
6711{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006712 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6713 return;
6714
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006715 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006716}
6717
6718/*
6719 * "hostname()" function
6720 */
6721 static void
6722f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
6723{
6724 char_u hostname[256];
6725
6726 mch_get_host_name(hostname, 256);
6727 rettv->v_type = VAR_STRING;
6728 rettv->vval.v_string = vim_strsave(hostname);
6729}
6730
6731/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006732 * "index()" function
6733 */
6734 static void
6735f_index(typval_T *argvars, typval_T *rettv)
6736{
6737 list_T *l;
6738 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006739 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006740 long idx = 0;
6741 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006742 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006743
6744 rettv->vval.v_number = -1;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006745
6746 if (in_vim9script()
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02006747 && (check_for_list_or_blob_arg(argvars, 0) == FAIL
6748 || (argvars[0].v_type == VAR_BLOB
6749 && check_for_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006750 || check_for_opt_number_arg(argvars, 2) == FAIL
6751 || (argvars[2].v_type != VAR_UNKNOWN
6752 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
6753 return;
6754
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006755 if (argvars[0].v_type == VAR_BLOB)
6756 {
6757 typval_T tv;
6758 int start = 0;
6759
6760 if (argvars[2].v_type != VAR_UNKNOWN)
6761 {
6762 start = tv_get_number_chk(&argvars[2], &error);
6763 if (error)
6764 return;
6765 }
6766 b = argvars[0].vval.v_blob;
6767 if (b == NULL)
6768 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01006769 if (start < 0)
6770 {
6771 start = blob_len(b) + start;
6772 if (start < 0)
6773 start = 0;
6774 }
6775
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006776 for (idx = start; idx < blob_len(b); ++idx)
6777 {
6778 tv.v_type = VAR_NUMBER;
6779 tv.vval.v_number = blob_get(b, idx);
6780 if (tv_equal(&tv, &argvars[1], ic, FALSE))
6781 {
6782 rettv->vval.v_number = idx;
6783 return;
6784 }
6785 }
6786 return;
6787 }
6788 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006789 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00006790 emsg(_(e_list_or_blob_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006791 return;
6792 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006793
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006794 l = argvars[0].vval.v_list;
6795 if (l != NULL)
6796 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02006797 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006798 item = l->lv_first;
6799 if (argvars[2].v_type != VAR_UNKNOWN)
6800 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006801 // Start at specified item. Use the cached index that list_find()
6802 // sets, so that a negative number also works.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006803 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006804 idx = l->lv_u.mat.lv_idx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006805 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaar6c553f92020-09-02 22:10:34 +02006806 ic = (int)tv_get_bool_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006807 if (error)
6808 item = NULL;
6809 }
6810
6811 for ( ; item != NULL; item = item->li_next, ++idx)
6812 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
6813 {
6814 rettv->vval.v_number = idx;
6815 break;
6816 }
6817 }
6818}
6819
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006820/*
6821 * Evaluate 'expr' with the v:key and v:val arguments and return the result.
6822 * The expression is expected to return a boolean value. The caller should set
6823 * the VV_KEY and VV_VAL vim variables before calling this function.
6824 */
6825 static int
6826indexof_eval_expr(typval_T *expr)
6827{
6828 typval_T argv[3];
6829 typval_T newtv;
6830 varnumber_T found;
6831 int error = FALSE;
6832
6833 argv[0] = *get_vim_var_tv(VV_KEY);
6834 argv[1] = *get_vim_var_tv(VV_VAL);
6835 newtv.v_type = VAR_UNKNOWN;
6836
Bram Moolenaar82418262022-09-28 16:16:15 +01006837 if (eval_expr_typval(expr, argv, 2, NULL, &newtv) == FAIL)
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006838 return FALSE;
6839
6840 found = tv_get_bool_chk(&newtv, &error);
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006841 clear_tv(&newtv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006842
6843 return error ? FALSE : found;
6844}
6845
6846/*
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006847 * Evaluate 'expr' for each byte in the Blob 'b' starting with the byte at
6848 * 'startidx' and return the index of the byte where 'expr' is TRUE. Returns
6849 * -1 if 'expr' doesn't evaluate to TRUE for any of the bytes.
6850 */
6851 static int
6852indexof_blob(blob_T *b, long startidx, typval_T *expr)
6853{
6854 long idx = 0;
6855
6856 if (b == NULL)
6857 return -1;
6858
6859 if (startidx < 0)
6860 {
6861 // negative index: index from the last byte
6862 startidx = blob_len(b) + startidx;
6863 if (startidx < 0)
6864 startidx = 0;
6865 }
6866
6867 set_vim_var_type(VV_KEY, VAR_NUMBER);
6868 set_vim_var_type(VV_VAL, VAR_NUMBER);
6869
6870 for (idx = startidx; idx < blob_len(b); ++idx)
6871 {
6872 set_vim_var_nr(VV_KEY, idx);
6873 set_vim_var_nr(VV_VAL, blob_get(b, idx));
6874
6875 if (indexof_eval_expr(expr))
6876 return idx;
6877 }
6878
6879 return -1;
6880}
6881
6882/*
6883 * Evaluate 'expr' for each item in the List 'l' starting with the item at
6884 * 'startidx' and return the index of the item where 'expr' is TRUE. Returns
6885 * -1 if 'expr' doesn't evaluate to TRUE for any of the items.
6886 */
6887 static int
6888indexof_list(list_T *l, long startidx, typval_T *expr)
6889{
6890 listitem_T *item;
6891 long idx = 0;
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006892 int found;
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006893
6894 if (l == NULL)
6895 return -1;
6896
6897 CHECK_LIST_MATERIALIZE(l);
6898
6899 if (startidx == 0)
6900 item = l->lv_first;
6901 else
6902 {
6903 // Start at specified item. Use the cached index that list_find()
6904 // sets, so that a negative number also works.
6905 item = list_find(l, startidx);
6906 if (item != NULL)
6907 idx = l->lv_u.mat.lv_idx;
6908 }
6909
6910 set_vim_var_type(VV_KEY, VAR_NUMBER);
6911
6912 for ( ; item != NULL; item = item->li_next, ++idx)
6913 {
6914 set_vim_var_nr(VV_KEY, idx);
6915 copy_tv(&item->li_tv, get_vim_var_tv(VV_VAL));
6916
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006917 found = indexof_eval_expr(expr);
6918 clear_tv(get_vim_var_tv(VV_VAL));
6919
6920 if (found)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006921 return idx;
6922 }
6923
6924 return -1;
6925}
6926
6927/*
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006928 * "indexof()" function
6929 */
6930 static void
6931f_indexof(typval_T *argvars, typval_T *rettv)
6932{
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006933 long startidx = 0;
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006934 typval_T save_val;
6935 typval_T save_key;
6936 int save_did_emsg;
6937
6938 rettv->vval.v_number = -1;
6939
6940 if (check_for_list_or_blob_arg(argvars, 0) == FAIL
6941 || check_for_string_or_func_arg(argvars, 1) == FAIL
6942 || check_for_opt_dict_arg(argvars, 2) == FAIL)
6943 return;
6944
6945 if ((argvars[1].v_type == VAR_STRING && argvars[1].vval.v_string == NULL)
6946 || (argvars[1].v_type == VAR_FUNC
6947 && argvars[1].vval.v_partial == NULL))
6948 return;
6949
6950 if (argvars[2].v_type == VAR_DICT)
6951 startidx = dict_get_number_def(argvars[2].vval.v_dict, "startidx", 0);
6952
6953 prepare_vimvar(VV_VAL, &save_val);
6954 prepare_vimvar(VV_KEY, &save_key);
6955
6956 // We reset "did_emsg" to be able to detect whether an error occurred
6957 // during evaluation of the expression.
6958 save_did_emsg = did_emsg;
6959 did_emsg = FALSE;
6960
6961 if (argvars[0].v_type == VAR_BLOB)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006962 rettv->vval.v_number = indexof_blob(argvars[0].vval.v_blob, startidx,
6963 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006964 else
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006965 rettv->vval.v_number = indexof_list(argvars[0].vval.v_list, startidx,
6966 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006967
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006968 restore_vimvar(VV_KEY, &save_key);
6969 restore_vimvar(VV_VAL, &save_val);
6970 did_emsg |= save_did_emsg;
6971}
6972
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006973static int inputsecret_flag = 0;
6974
6975/*
6976 * "input()" function
6977 * Also handles inputsecret() when inputsecret is set.
6978 */
6979 static void
6980f_input(typval_T *argvars, typval_T *rettv)
6981{
6982 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
6983}
6984
6985/*
6986 * "inputdialog()" function
6987 */
6988 static void
6989f_inputdialog(typval_T *argvars, typval_T *rettv)
6990{
6991#if defined(FEAT_GUI_TEXTDIALOG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006992 // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions'
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006993 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
6994 {
6995 char_u *message;
6996 char_u buf[NUMBUFLEN];
6997 char_u *defstr = (char_u *)"";
6998
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006999 if (in_vim9script()
7000 && (check_for_string_arg(argvars, 0) == FAIL
7001 || check_for_opt_string_arg(argvars, 1) == FAIL
7002 || (argvars[1].v_type != VAR_UNKNOWN
7003 && check_for_opt_string_arg(argvars, 2) == FAIL)))
7004 return;
7005
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007006 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007007 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007008 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007009 vim_strncpy(IObuff, defstr, IOSIZE - 1);
7010 else
7011 IObuff[0] = NUL;
7012 if (message != NULL && defstr != NULL
7013 && do_dialog(VIM_QUESTION, NULL, message,
7014 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
7015 rettv->vval.v_string = vim_strsave(IObuff);
7016 else
7017 {
7018 if (message != NULL && defstr != NULL
7019 && argvars[1].v_type != VAR_UNKNOWN
7020 && argvars[2].v_type != VAR_UNKNOWN)
7021 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007022 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007023 else
7024 rettv->vval.v_string = NULL;
7025 }
7026 rettv->v_type = VAR_STRING;
7027 }
7028 else
7029#endif
7030 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
7031}
7032
7033/*
7034 * "inputlist()" function
7035 */
7036 static void
7037f_inputlist(typval_T *argvars, typval_T *rettv)
7038{
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007039 list_T *l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007040 listitem_T *li;
7041 int selected;
7042 int mouse_used;
7043
7044#ifdef NO_CONSOLE_INPUT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007045 // While starting up, there is no place to enter text. When running tests
7046 // with --not-a-term we assume feedkeys() will be used.
Bram Moolenaar91d348a2017-07-29 20:16:03 +02007047 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007048 return;
7049#endif
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007050 if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
7051 return;
7052
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007053 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
7054 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00007055 semsg(_(e_argument_of_str_must_be_list), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007056 return;
7057 }
7058
7059 msg_start();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007060 msg_row = Rows - 1; // for when 'cmdheight' > 1
7061 lines_left = Rows; // avoid more prompt
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007062 msg_scroll = TRUE;
7063 msg_clr_eos();
7064
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007065 l = argvars[0].vval.v_list;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007066 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02007067 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007068 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007069 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007070 msg_putchar('\n');
7071 }
7072
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007073 // Ask for choice.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007074 selected = prompt_for_number(&mouse_used);
7075 if (mouse_used)
7076 selected -= lines_left;
7077
7078 rettv->vval.v_number = selected;
7079}
7080
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007081static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
7082
7083/*
7084 * "inputrestore()" function
7085 */
7086 static void
7087f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
7088{
7089 if (ga_userinput.ga_len > 0)
7090 {
7091 --ga_userinput.ga_len;
7092 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
Bram Moolenaarc41badb2021-06-07 22:04:52 +02007093 + ga_userinput.ga_len, TRUE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007094 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007095 }
7096 else if (p_verbose > 1)
7097 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007098 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007099 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007100 }
7101}
7102
7103/*
7104 * "inputsave()" function
7105 */
7106 static void
7107f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
7108{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007109 // Add an entry to the stack of typeahead storage.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007110 if (ga_grow(&ga_userinput, 1) == OK)
7111 {
7112 save_typeahead((tasave_T *)(ga_userinput.ga_data)
7113 + ga_userinput.ga_len);
7114 ++ga_userinput.ga_len;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007115 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007116 }
7117 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007118 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007119}
7120
7121/*
7122 * "inputsecret()" function
7123 */
7124 static void
7125f_inputsecret(typval_T *argvars, typval_T *rettv)
7126{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007127 if (in_vim9script()
7128 && (check_for_string_arg(argvars, 0) == FAIL
7129 || check_for_opt_string_arg(argvars, 1) == FAIL))
7130 return;
7131
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007132 ++cmdline_star;
7133 ++inputsecret_flag;
7134 f_input(argvars, rettv);
7135 --cmdline_star;
7136 --inputsecret_flag;
7137}
7138
7139/*
Bram Moolenaar67a2deb2019-11-25 00:05:32 +01007140 * "interrupt()" function
7141 */
7142 static void
7143f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7144{
7145 got_int = TRUE;
7146}
7147
7148/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007149 * "invert(expr)" function
7150 */
7151 static void
7152f_invert(typval_T *argvars, typval_T *rettv)
7153{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007154 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
7155 return;
7156
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007157 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007158}
7159
7160/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007161 * "islocked()" function
7162 */
7163 static void
7164f_islocked(typval_T *argvars, typval_T *rettv)
7165{
7166 lval_T lv;
7167 char_u *end;
7168 dictitem_T *di;
7169
7170 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007171
7172 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7173 return;
7174
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007175 end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
Bram Moolenaarbd77aa92021-08-12 17:06:05 +02007176 GLV_NO_AUTOLOAD | GLV_READ_ONLY | GLV_NO_DECL,
7177 FNE_CHECK_START);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007178 if (end != NULL && lv.ll_name != NULL)
7179 {
7180 if (*end != NUL)
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007181 {
7182 semsg(_(lv.ll_name == lv.ll_name_end
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00007183 ? e_invalid_argument_str : e_trailing_characters_str), end);
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007184 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007185 else
7186 {
7187 if (lv.ll_tv == NULL)
7188 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01007189 di = find_var(lv.ll_name, NULL, TRUE);
7190 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007191 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007192 // Consider a variable locked when:
7193 // 1. the variable itself is locked
7194 // 2. the value of the variable is locked.
7195 // 3. the List or Dict value is locked.
Bram Moolenaar79518e22017-02-17 16:31:35 +01007196 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
7197 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007198 }
7199 }
7200 else if (lv.ll_range)
Bram Moolenaar677658a2022-01-05 16:09:06 +00007201 emsg(_(e_range_not_allowed));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007202 else if (lv.ll_newkey != NULL)
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007203 semsg(_(e_key_not_present_in_dictionary), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007204 else if (lv.ll_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007205 // List item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007206 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
7207 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007208 // Dictionary item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007209 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
7210 }
7211 }
7212
7213 clear_lval(&lv);
7214}
7215
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007216/*
zeertzjqcdc83932022-09-12 13:38:41 +01007217 * "keytrans()" function
7218 */
7219 static void
7220f_keytrans(typval_T *argvars, typval_T *rettv)
7221{
7222 char_u *escaped;
7223
7224 rettv->v_type = VAR_STRING;
7225 if (check_for_string_arg(argvars, 0) == FAIL
7226 || argvars[0].vval.v_string == NULL)
7227 return;
7228 // Need to escape K_SPECIAL and CSI for mb_unescape().
7229 escaped = vim_strsave_escape_csi(argvars[0].vval.v_string);
7230 rettv->vval.v_string = str2special_save(escaped, TRUE, TRUE);
7231 vim_free(escaped);
7232}
7233
7234/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007235 * "last_buffer_nr()" function.
7236 */
7237 static void
7238f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
7239{
7240 int n = 0;
7241 buf_T *buf;
7242
Bram Moolenaar29323592016-07-24 22:04:11 +02007243 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007244 if (n < buf->b_fnum)
7245 n = buf->b_fnum;
7246
7247 rettv->vval.v_number = n;
7248}
7249
7250/*
7251 * "len()" function
7252 */
LemonBoy58f331a2022-04-02 21:59:06 +01007253 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007254f_len(typval_T *argvars, typval_T *rettv)
7255{
7256 switch (argvars[0].v_type)
7257 {
7258 case VAR_STRING:
7259 case VAR_NUMBER:
7260 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007261 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007262 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007263 case VAR_BLOB:
7264 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
7265 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007266 case VAR_LIST:
7267 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
7268 break;
7269 case VAR_DICT:
7270 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
7271 break;
7272 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02007273 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007274 case VAR_VOID:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01007275 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007276 case VAR_SPECIAL:
7277 case VAR_FLOAT:
7278 case VAR_FUNC:
7279 case VAR_PARTIAL:
7280 case VAR_JOB:
7281 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02007282 case VAR_INSTR:
Bram Moolenaar00b28d62022-12-08 15:32:33 +00007283 case VAR_CLASS:
7284 case VAR_OBJECT:
Bram Moolenaara6f79292022-01-04 21:30:47 +00007285 emsg(_(e_invalid_type_for_len));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007286 break;
7287 }
7288}
7289
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007290 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01007291libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007292{
7293#ifdef FEAT_LIBCALL
7294 char_u *string_in;
7295 char_u **string_result;
7296 int nr_result;
7297#endif
7298
7299 rettv->v_type = type;
7300 if (type != VAR_NUMBER)
7301 rettv->vval.v_string = NULL;
7302
7303 if (check_restricted() || check_secure())
7304 return;
7305
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02007306 if (in_vim9script()
7307 && (check_for_string_arg(argvars, 0) == FAIL
7308 || check_for_string_arg(argvars, 1) == FAIL
7309 || check_for_string_or_number_arg(argvars, 2) == FAIL))
7310 return;
7311
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007312#ifdef FEAT_LIBCALL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007313 // The first two args must be strings, otherwise it's meaningless
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007314 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
7315 {
7316 string_in = NULL;
7317 if (argvars[2].v_type == VAR_STRING)
7318 string_in = argvars[2].vval.v_string;
7319 if (type == VAR_NUMBER)
Bram Moolenaar87e15872021-09-02 19:53:07 +02007320 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007321 string_result = NULL;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007322 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007323 else
Bram Moolenaar87e15872021-09-02 19:53:07 +02007324 {
7325 rettv->vval.v_string = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007326 string_result = &rettv->vval.v_string;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007327 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007328 if (mch_libcall(argvars[0].vval.v_string,
7329 argvars[1].vval.v_string,
7330 string_in,
7331 argvars[2].vval.v_number,
7332 string_result,
7333 &nr_result) == OK
7334 && type == VAR_NUMBER)
7335 rettv->vval.v_number = nr_result;
7336 }
7337#endif
7338}
7339
7340/*
7341 * "libcall()" function
7342 */
7343 static void
7344f_libcall(typval_T *argvars, typval_T *rettv)
7345{
7346 libcall_common(argvars, rettv, VAR_STRING);
7347}
7348
7349/*
7350 * "libcallnr()" function
7351 */
7352 static void
7353f_libcallnr(typval_T *argvars, typval_T *rettv)
7354{
7355 libcall_common(argvars, rettv, VAR_NUMBER);
7356}
7357
7358/*
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007359 * "line(string, [winid])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007360 */
7361 static void
7362f_line(typval_T *argvars, typval_T *rettv)
7363{
7364 linenr_T lnum = 0;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007365 pos_T *fp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007366 int fnum;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007367 int id;
7368 tabpage_T *tp;
7369 win_T *wp;
Bram Moolenaar18f47402022-01-06 13:24:51 +00007370 switchwin_T switchwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007371
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007372 if (in_vim9script()
7373 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007374 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007375 return;
7376
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007377 if (argvars[1].v_type != VAR_UNKNOWN)
7378 {
7379 // use window specified in the second argument
7380 id = (int)tv_get_number(&argvars[1]);
7381 wp = win_id2wp_tp(id, &tp);
7382 if (wp != NULL && tp != NULL)
7383 {
Bram Moolenaar18f47402022-01-06 13:24:51 +00007384 if (switch_win_noblock(&switchwin, wp, tp, TRUE) == OK)
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007385 {
7386 check_cursor();
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007387 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007388 }
Bram Moolenaar18f47402022-01-06 13:24:51 +00007389 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007390 }
7391 }
7392 else
7393 // use current window
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007394 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007395
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007396 if (fp != NULL)
7397 lnum = fp->lnum;
7398 rettv->vval.v_number = lnum;
7399}
7400
7401/*
7402 * "line2byte(lnum)" function
7403 */
7404 static void
7405f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
7406{
7407#ifndef FEAT_BYTEOFF
7408 rettv->vval.v_number = -1;
7409#else
7410 linenr_T lnum;
7411
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007412 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7413 return;
7414
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007415 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007416 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
7417 rettv->vval.v_number = -1;
7418 else
7419 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
7420 if (rettv->vval.v_number >= 0)
7421 ++rettv->vval.v_number;
7422#endif
7423}
7424
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007425#ifdef FEAT_LUA
7426/*
7427 * "luaeval()" function
7428 */
7429 static void
7430f_luaeval(typval_T *argvars, typval_T *rettv)
7431{
7432 char_u *str;
7433 char_u buf[NUMBUFLEN];
7434
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007435 if (check_restricted() || check_secure())
7436 return;
7437
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02007438 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7439 return;
7440
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007441 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007442 do_luaeval(str, argvars + 1, rettv);
7443}
7444#endif
7445
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007446typedef enum
7447{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007448 MATCH_END, // matchend()
7449 MATCH_MATCH, // match()
7450 MATCH_STR, // matchstr()
7451 MATCH_LIST, // matchlist()
7452 MATCH_POS // matchstrpos()
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007453} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007454
7455 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007456find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007457{
7458 char_u *str = NULL;
7459 long len = 0;
7460 char_u *expr = NULL;
7461 char_u *pat;
7462 regmatch_T regmatch;
7463 char_u patbuf[NUMBUFLEN];
7464 char_u strbuf[NUMBUFLEN];
7465 char_u *save_cpo;
7466 long start = 0;
7467 long nth = 1;
7468 colnr_T startcol = 0;
7469 int match = 0;
7470 list_T *l = NULL;
7471 listitem_T *li = NULL;
7472 long idx = 0;
7473 char_u *tofree = NULL;
7474
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007475 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007476 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01007477 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007478
7479 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007480 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007481 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007482 // type MATCH_LIST: return empty list when there are no matches.
7483 // type MATCH_POS: return ["", -1, -1, -1]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007484 if (rettv_list_alloc(rettv) == FAIL)
7485 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007486 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007487 && (list_append_string(rettv->vval.v_list,
7488 (char_u *)"", 0) == FAIL
7489 || list_append_number(rettv->vval.v_list,
7490 (varnumber_T)-1) == FAIL
7491 || list_append_number(rettv->vval.v_list,
7492 (varnumber_T)-1) == FAIL
7493 || list_append_number(rettv->vval.v_list,
7494 (varnumber_T)-1) == FAIL))
7495 {
7496 list_free(rettv->vval.v_list);
7497 rettv->vval.v_list = NULL;
7498 goto theend;
7499 }
7500 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007501 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007502 {
7503 rettv->v_type = VAR_STRING;
7504 rettv->vval.v_string = NULL;
7505 }
7506
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007507 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007508 && (check_for_string_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007509 || check_for_string_arg(argvars, 1) == FAIL
7510 || check_for_opt_number_arg(argvars, 2) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007511 || (argvars[2].v_type != VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007512 && check_for_opt_number_arg(argvars, 3) == FAIL)))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007513 goto theend;
7514
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007515 if (argvars[0].v_type == VAR_LIST)
7516 {
7517 if ((l = argvars[0].vval.v_list) == NULL)
7518 goto theend;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007519 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007520 li = l->lv_first;
7521 }
7522 else
7523 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007524 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007525 len = (long)STRLEN(str);
7526 }
7527
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007528 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007529 if (pat == NULL)
7530 goto theend;
7531
7532 if (argvars[2].v_type != VAR_UNKNOWN)
7533 {
7534 int error = FALSE;
7535
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007536 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007537 if (error)
7538 goto theend;
7539 if (l != NULL)
7540 {
7541 li = list_find(l, start);
7542 if (li == NULL)
7543 goto theend;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007544 idx = l->lv_u.mat.lv_idx; // use the cached index
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007545 }
7546 else
7547 {
7548 if (start < 0)
7549 start = 0;
7550 if (start > len)
7551 goto theend;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007552 // When "count" argument is there ignore matches before "start",
7553 // otherwise skip part of the string. Differs when pattern is "^"
7554 // or "\<".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007555 if (argvars[3].v_type != VAR_UNKNOWN)
7556 startcol = start;
7557 else
7558 {
7559 str += start;
7560 len -= start;
7561 }
7562 }
7563
7564 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007565 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007566 if (error)
7567 goto theend;
7568 }
7569
7570 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
7571 if (regmatch.regprog != NULL)
7572 {
7573 regmatch.rm_ic = p_ic;
7574
7575 for (;;)
7576 {
7577 if (l != NULL)
7578 {
7579 if (li == NULL)
7580 {
7581 match = FALSE;
7582 break;
7583 }
7584 vim_free(tofree);
7585 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
7586 if (str == NULL)
7587 break;
7588 }
7589
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00007590 match = vim_regexec_nl(&regmatch, str, startcol);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007591
7592 if (match && --nth <= 0)
7593 break;
7594 if (l == NULL && !match)
7595 break;
7596
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007597 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007598 if (l != NULL)
7599 {
7600 li = li->li_next;
7601 ++idx;
7602 }
7603 else
7604 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007605 startcol = (colnr_T)(regmatch.startp[0]
7606 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007607 if (startcol > (colnr_T)len
7608 || str + startcol <= regmatch.startp[0])
7609 {
7610 match = FALSE;
7611 break;
7612 }
7613 }
7614 }
7615
7616 if (match)
7617 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007618 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007619 {
7620 listitem_T *li1 = rettv->vval.v_list->lv_first;
7621 listitem_T *li2 = li1->li_next;
7622 listitem_T *li3 = li2->li_next;
7623 listitem_T *li4 = li3->li_next;
7624
7625 vim_free(li1->li_tv.vval.v_string);
7626 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007627 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007628 li3->li_tv.vval.v_number =
7629 (varnumber_T)(regmatch.startp[0] - expr);
7630 li4->li_tv.vval.v_number =
7631 (varnumber_T)(regmatch.endp[0] - expr);
7632 if (l != NULL)
7633 li2->li_tv.vval.v_number = (varnumber_T)idx;
7634 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007635 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007636 {
7637 int i;
7638
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007639 // return list with matched string and submatches
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007640 for (i = 0; i < NSUBEXP; ++i)
7641 {
7642 if (regmatch.endp[i] == NULL)
7643 {
7644 if (list_append_string(rettv->vval.v_list,
7645 (char_u *)"", 0) == FAIL)
7646 break;
7647 }
7648 else if (list_append_string(rettv->vval.v_list,
7649 regmatch.startp[i],
7650 (int)(regmatch.endp[i] - regmatch.startp[i]))
7651 == FAIL)
7652 break;
7653 }
7654 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007655 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007656 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007657 // return matched string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007658 if (l != NULL)
7659 copy_tv(&li->li_tv, rettv);
7660 else
7661 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007662 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007663 }
7664 else if (l != NULL)
7665 rettv->vval.v_number = idx;
7666 else
7667 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007668 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007669 rettv->vval.v_number =
7670 (varnumber_T)(regmatch.startp[0] - str);
7671 else
7672 rettv->vval.v_number =
7673 (varnumber_T)(regmatch.endp[0] - str);
7674 rettv->vval.v_number += (varnumber_T)(str - expr);
7675 }
7676 }
7677 vim_regfree(regmatch.regprog);
7678 }
7679
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007680theend:
7681 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007682 // matchstrpos() without a list: drop the second item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007683 listitem_remove(rettv->vval.v_list,
7684 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007685 vim_free(tofree);
7686 p_cpo = save_cpo;
7687}
7688
7689/*
7690 * "match()" function
7691 */
7692 static void
7693f_match(typval_T *argvars, typval_T *rettv)
7694{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007695 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007696}
7697
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007698/*
7699 * "matchend()" function
7700 */
7701 static void
7702f_matchend(typval_T *argvars, typval_T *rettv)
7703{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007704 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007705}
7706
7707/*
7708 * "matchlist()" function
7709 */
7710 static void
7711f_matchlist(typval_T *argvars, typval_T *rettv)
7712{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007713 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007714}
7715
7716/*
7717 * "matchstr()" function
7718 */
7719 static void
7720f_matchstr(typval_T *argvars, typval_T *rettv)
7721{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007722 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007723}
7724
7725/*
7726 * "matchstrpos()" function
7727 */
7728 static void
7729f_matchstrpos(typval_T *argvars, typval_T *rettv)
7730{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007731 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007732}
7733
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007734 static void
7735max_min(typval_T *argvars, typval_T *rettv, int domax)
7736{
7737 varnumber_T n = 0;
7738 varnumber_T i;
7739 int error = FALSE;
7740
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007741 if (in_vim9script() && check_for_list_or_dict_arg(argvars, 0) == FAIL)
7742 return;
7743
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007744 if (argvars[0].v_type == VAR_LIST)
7745 {
7746 list_T *l;
7747 listitem_T *li;
7748
7749 l = argvars[0].vval.v_list;
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007750 if (l != NULL && l->lv_len > 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007751 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007752 if (l->lv_first == &range_list_item)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007753 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007754 if ((l->lv_u.nonmat.lv_stride > 0) ^ domax)
7755 n = l->lv_u.nonmat.lv_start;
7756 else
=?UTF-8?q?Dundar=20G=C3=B6c?=d5cec1f2022-01-29 15:19:23 +00007757 n = l->lv_u.nonmat.lv_start + ((varnumber_T)l->lv_len - 1)
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007758 * l->lv_u.nonmat.lv_stride;
7759 }
7760 else
7761 {
7762 li = l->lv_first;
7763 if (li != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007764 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007765 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007766 if (error)
7767 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007768 for (;;)
7769 {
7770 li = li->li_next;
7771 if (li == NULL)
7772 break;
7773 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007774 if (error)
7775 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007776 if (domax ? i > n : i < n)
7777 n = i;
7778 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007779 }
7780 }
7781 }
7782 }
7783 else if (argvars[0].v_type == VAR_DICT)
7784 {
7785 dict_T *d;
7786 int first = TRUE;
7787 hashitem_T *hi;
7788 int todo;
7789
7790 d = argvars[0].vval.v_dict;
7791 if (d != NULL)
7792 {
7793 todo = (int)d->dv_hashtab.ht_used;
7794 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
7795 {
7796 if (!HASHITEM_EMPTY(hi))
7797 {
7798 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007799 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007800 if (error)
7801 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007802 if (first)
7803 {
7804 n = i;
7805 first = FALSE;
7806 }
7807 else if (domax ? i > n : i < n)
7808 n = i;
7809 }
7810 }
7811 }
7812 }
7813 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007814 semsg(_(e_argument_of_str_must_be_list_or_dictionary), domax ? "max()" : "min()");
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007815
7816 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007817}
7818
7819/*
7820 * "max()" function
7821 */
7822 static void
7823f_max(typval_T *argvars, typval_T *rettv)
7824{
7825 max_min(argvars, rettv, TRUE);
7826}
7827
7828/*
7829 * "min()" function
7830 */
7831 static void
7832f_min(typval_T *argvars, typval_T *rettv)
7833{
7834 max_min(argvars, rettv, FALSE);
7835}
7836
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007837#if defined(FEAT_MZSCHEME) || defined(PROTO)
7838/*
7839 * "mzeval()" function
7840 */
7841 static void
7842f_mzeval(typval_T *argvars, typval_T *rettv)
7843{
7844 char_u *str;
7845 char_u buf[NUMBUFLEN];
7846
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007847 if (check_restricted() || check_secure())
7848 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007849
7850 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7851 return;
7852
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007853 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007854 do_mzeval(str, rettv);
7855}
7856
7857 void
7858mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
7859{
7860 typval_T argvars[3];
7861
7862 argvars[0].v_type = VAR_STRING;
7863 argvars[0].vval.v_string = name;
7864 copy_tv(args, &argvars[1]);
7865 argvars[2].v_type = VAR_UNKNOWN;
7866 f_call(argvars, rettv);
7867 clear_tv(&argvars[1]);
7868}
7869#endif
7870
7871/*
7872 * "nextnonblank()" function
7873 */
7874 static void
7875f_nextnonblank(typval_T *argvars, typval_T *rettv)
7876{
7877 linenr_T lnum;
7878
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007879 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7880 return;
7881
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007882 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007883 {
7884 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
7885 {
7886 lnum = 0;
7887 break;
7888 }
7889 if (*skipwhite(ml_get(lnum)) != NUL)
7890 break;
7891 }
7892 rettv->vval.v_number = lnum;
7893}
7894
7895/*
7896 * "nr2char()" function
7897 */
7898 static void
7899f_nr2char(typval_T *argvars, typval_T *rettv)
7900{
7901 char_u buf[NUMBUFLEN];
7902
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007903 if (in_vim9script()
7904 && (check_for_number_arg(argvars, 0) == FAIL
7905 || check_for_opt_bool_arg(argvars, 1) == FAIL))
7906 return;
7907
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007908 if (has_mbyte)
7909 {
7910 int utf8 = 0;
7911
7912 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaared6a4302020-09-05 20:29:41 +02007913 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007914 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01007915 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007916 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007917 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007918 }
7919 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007920 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007921 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007922 buf[1] = NUL;
7923 }
7924 rettv->v_type = VAR_STRING;
7925 rettv->vval.v_string = vim_strsave(buf);
7926}
7927
7928/*
7929 * "or(expr, expr)" function
7930 */
7931 static void
7932f_or(typval_T *argvars, typval_T *rettv)
7933{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007934 if (in_vim9script()
7935 && (check_for_number_arg(argvars, 0) == FAIL
7936 || check_for_number_arg(argvars, 1) == FAIL))
7937 return;
7938
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007939 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
7940 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007941}
7942
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007943#ifdef FEAT_PERL
7944/*
7945 * "perleval()" function
7946 */
7947 static void
7948f_perleval(typval_T *argvars, typval_T *rettv)
7949{
7950 char_u *str;
7951 char_u buf[NUMBUFLEN];
7952
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007953 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7954 return;
7955
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007956 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007957 do_perleval(str, rettv);
7958}
7959#endif
7960
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007961/*
7962 * "prevnonblank()" function
7963 */
7964 static void
7965f_prevnonblank(typval_T *argvars, typval_T *rettv)
7966{
7967 linenr_T lnum;
7968
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007969 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7970 return;
7971
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007972 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007973 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
7974 lnum = 0;
7975 else
7976 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
7977 --lnum;
7978 rettv->vval.v_number = lnum;
7979}
7980
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007981// This dummy va_list is here because:
7982// - passing a NULL pointer doesn't work when va_list isn't a pointer
7983// - locally in the function results in a "used before set" warning
7984// - using va_start() to initialize it gives "function with fixed args" error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007985static va_list ap;
7986
7987/*
7988 * "printf()" function
7989 */
7990 static void
7991f_printf(typval_T *argvars, typval_T *rettv)
7992{
7993 char_u buf[NUMBUFLEN];
7994 int len;
7995 char_u *s;
7996 int saved_did_emsg = did_emsg;
7997 char *fmt;
7998
7999 rettv->v_type = VAR_STRING;
8000 rettv->vval.v_string = NULL;
8001
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02008002 if (in_vim9script() && check_for_string_or_number_arg(argvars, 0) == FAIL)
8003 return;
8004
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008005 // Get the required length, allocate the buffer and do it for real.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008006 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008007 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008008 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008009 if (!did_emsg)
8010 {
8011 s = alloc(len + 1);
8012 if (s != NULL)
8013 {
8014 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008015 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
8016 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008017 }
8018 }
8019 did_emsg |= saved_did_emsg;
8020}
8021
8022/*
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008023 * "pum_getpos()" function
8024 */
8025 static void
8026f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8027{
Bram Moolenaar93a10962022-06-16 11:42:09 +01008028 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008029 return;
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008030 pum_set_event_info(rettv->vval.v_dict);
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008031}
8032
8033/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008034 * "pumvisible()" function
8035 */
8036 static void
8037f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8038{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008039 if (pum_visible())
8040 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008041}
8042
8043#ifdef FEAT_PYTHON3
8044/*
8045 * "py3eval()" function
8046 */
8047 static void
8048f_py3eval(typval_T *argvars, typval_T *rettv)
8049{
8050 char_u *str;
8051 char_u buf[NUMBUFLEN];
8052
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008053 if (check_restricted() || check_secure())
8054 return;
8055
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008056 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8057 return;
8058
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008059 if (p_pyx == 0)
8060 p_pyx = 3;
8061
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008062 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008063 do_py3eval(str, rettv);
8064}
8065#endif
8066
8067#ifdef FEAT_PYTHON
8068/*
8069 * "pyeval()" function
8070 */
8071 static void
8072f_pyeval(typval_T *argvars, typval_T *rettv)
8073{
8074 char_u *str;
8075 char_u buf[NUMBUFLEN];
8076
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008077 if (check_restricted() || check_secure())
8078 return;
8079
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008080 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8081 return;
8082
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008083 if (p_pyx == 0)
8084 p_pyx = 2;
8085
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008086 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008087 do_pyeval(str, rettv);
8088}
8089#endif
8090
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008091#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
8092/*
8093 * "pyxeval()" function
8094 */
8095 static void
8096f_pyxeval(typval_T *argvars, typval_T *rettv)
8097{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008098 if (check_restricted() || check_secure())
8099 return;
8100
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008101 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8102 return;
8103
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008104# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
8105 init_pyxversion();
8106 if (p_pyx == 2)
8107 f_pyeval(argvars, rettv);
8108 else
8109 f_py3eval(argvars, rettv);
8110# elif defined(FEAT_PYTHON)
8111 f_pyeval(argvars, rettv);
8112# elif defined(FEAT_PYTHON3)
8113 f_py3eval(argvars, rettv);
8114# endif
8115}
8116#endif
8117
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008118static UINT32_T srand_seed_for_testing = 0;
8119static int srand_seed_for_testing_is_used = FALSE;
8120
8121 static void
8122f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED)
8123{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008124 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8125 return;
8126
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008127 if (argvars[0].v_type == VAR_UNKNOWN)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008128 srand_seed_for_testing_is_used = FALSE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008129 else
8130 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008131 srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]);
8132 srand_seed_for_testing_is_used = TRUE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008133 }
8134}
8135
8136 static void
8137init_srand(UINT32_T *x)
8138{
8139#ifndef MSWIN
8140 static int dev_urandom_state = NOTDONE; // FAIL or OK once tried
8141#endif
8142
8143 if (srand_seed_for_testing_is_used)
8144 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008145 *x = srand_seed_for_testing;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008146 return;
8147 }
8148#ifndef MSWIN
8149 if (dev_urandom_state != FAIL)
8150 {
8151 int fd = open("/dev/urandom", O_RDONLY);
8152 struct {
8153 union {
8154 UINT32_T number;
8155 char bytes[sizeof(UINT32_T)];
8156 } contents;
8157 } buf;
8158
8159 // Attempt reading /dev/urandom.
8160 if (fd == -1)
8161 dev_urandom_state = FAIL;
8162 else
8163 {
8164 buf.contents.number = 0;
8165 if (read(fd, buf.contents.bytes, sizeof(UINT32_T))
8166 != sizeof(UINT32_T))
8167 dev_urandom_state = FAIL;
8168 else
8169 {
8170 dev_urandom_state = OK;
8171 *x = buf.contents.number;
8172 }
8173 close(fd);
8174 }
8175 }
8176 if (dev_urandom_state != OK)
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008177#endif
Yasuhiro Matsumotof0a9c002022-12-05 21:55:55 +00008178 {
8179 // Reading /dev/urandom doesn't work, fall back to:
8180 // - randombytes_random()
8181 // - reltime() or time()
8182 // - XOR with process ID
8183#if defined(FEAT_SODIUM)
K.Takataa8cdb4e2022-12-06 16:17:01 +00008184 if (crypt_sodium_init() >= 0)
8185 *x = crypt_sodium_randombytes_random();
Yasuhiro Matsumotof0a9c002022-12-05 21:55:55 +00008186 else
8187#endif
8188 {
8189#if defined(FEAT_RELTIME)
8190 proftime_T res;
8191 profile_start(&res);
8192# if defined(MSWIN)
8193 *x = (UINT32_T)res.LowPart;
8194# else
8195 *x = (UINT32_T)res.tv_usec;
8196# endif
8197#else
8198 *x = vim_time();
8199#endif
8200 *x ^= mch_get_pid();
8201 }
8202 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008203}
8204
kylo252ae6f1d82022-02-16 19:24:07 +00008205#define ROTL(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008206#define SPLITMIX32(x, z) ( \
kylo252ae6f1d82022-02-16 19:24:07 +00008207 (z) = ((x) += 0x9e3779b9), \
8208 (z) = ((z) ^ ((z) >> 16)) * 0x85ebca6b, \
8209 (z) = ((z) ^ ((z) >> 13)) * 0xc2b2ae35, \
8210 (z) ^ ((z) >> 16) \
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008211 )
8212#define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \
kylo252ae6f1d82022-02-16 19:24:07 +00008213 result = ROTL((y) * 5, 7) * 9; \
8214 t = (y) << 9; \
8215 (z) ^= (x); \
8216 (w) ^= (y); \
8217 (y) ^= (z), (x) ^= (w); \
8218 (z) ^= t; \
8219 (w) = ROTL(w, 11);
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008220
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008221/*
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008222 * "rand()" function
8223 */
8224 static void
8225f_rand(typval_T *argvars, typval_T *rettv)
8226{
8227 list_T *l = NULL;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008228 static UINT32_T gx, gy, gz, gw;
8229 static int initialized = FALSE;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008230 listitem_T *lx, *ly, *lz, *lw;
Bram Moolenaar0fd797e2020-11-05 20:46:32 +01008231 UINT32_T x = 0, y, z, w, t, result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008232
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008233 if (in_vim9script() && check_for_opt_list_arg(argvars, 0) == FAIL)
8234 return;
8235
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008236 if (argvars[0].v_type == VAR_UNKNOWN)
8237 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008238 // When no argument is given use the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008239 if (initialized == FALSE)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008240 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008241 // Initialize the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008242 init_srand(&x);
8243
8244 gx = SPLITMIX32(x, z);
8245 gy = SPLITMIX32(x, z);
8246 gz = SPLITMIX32(x, z);
8247 gw = SPLITMIX32(x, z);
8248 initialized = TRUE;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008249 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008250
8251 SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008252 }
8253 else if (argvars[0].v_type == VAR_LIST)
8254 {
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008255 l = argvars[0].vval.v_list;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008256 if (l == NULL || list_len(l) != 4)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008257 goto theend;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008258
8259 lx = list_find(l, 0L);
8260 ly = list_find(l, 1L);
8261 lz = list_find(l, 2L);
8262 lw = list_find(l, 3L);
8263 if (lx->li_tv.v_type != VAR_NUMBER) goto theend;
8264 if (ly->li_tv.v_type != VAR_NUMBER) goto theend;
8265 if (lz->li_tv.v_type != VAR_NUMBER) goto theend;
8266 if (lw->li_tv.v_type != VAR_NUMBER) goto theend;
8267 x = (UINT32_T)lx->li_tv.vval.v_number;
8268 y = (UINT32_T)ly->li_tv.vval.v_number;
8269 z = (UINT32_T)lz->li_tv.vval.v_number;
8270 w = (UINT32_T)lw->li_tv.vval.v_number;
8271
8272 SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w);
8273
8274 lx->li_tv.vval.v_number = (varnumber_T)x;
8275 ly->li_tv.vval.v_number = (varnumber_T)y;
8276 lz->li_tv.vval.v_number = (varnumber_T)z;
8277 lw->li_tv.vval.v_number = (varnumber_T)w;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008278 }
8279 else
8280 goto theend;
8281
8282 rettv->v_type = VAR_NUMBER;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008283 rettv->vval.v_number = (varnumber_T)result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008284 return;
8285
8286theend:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008287 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008288 rettv->v_type = VAR_NUMBER;
8289 rettv->vval.v_number = -1;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008290}
8291
8292/*
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008293 * "srand()" function
8294 */
8295 static void
8296f_srand(typval_T *argvars, typval_T *rettv)
8297{
8298 UINT32_T x = 0, z;
8299
8300 if (rettv_list_alloc(rettv) == FAIL)
8301 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008302
8303 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8304 return;
8305
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008306 if (argvars[0].v_type == VAR_UNKNOWN)
8307 {
8308 init_srand(&x);
8309 }
8310 else
8311 {
8312 int error = FALSE;
8313
8314 x = (UINT32_T)tv_get_number_chk(&argvars[0], &error);
8315 if (error)
8316 return;
8317 }
8318
8319 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8320 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8321 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8322 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8323}
8324
8325#undef ROTL
8326#undef SPLITMIX32
8327#undef SHUFFLE_XOSHIRO128STARSTAR
8328
8329/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008330 * "range()" function
8331 */
8332 static void
8333f_range(typval_T *argvars, typval_T *rettv)
8334{
8335 varnumber_T start;
8336 varnumber_T end;
8337 varnumber_T stride = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008338 int error = FALSE;
8339
Bram Moolenaar93a10962022-06-16 11:42:09 +01008340 if (rettv_list_alloc(rettv) == FAIL)
Yegappan Lakshmananca195cc2022-06-14 13:42:26 +01008341 return;
8342
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008343 if (in_vim9script()
8344 && (check_for_number_arg(argvars, 0) == FAIL
8345 || check_for_opt_number_arg(argvars, 1) == FAIL
8346 || (argvars[1].v_type != VAR_UNKNOWN
8347 && check_for_opt_number_arg(argvars, 2) == FAIL)))
8348 return;
8349
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008350 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008351 if (argvars[1].v_type == VAR_UNKNOWN)
8352 {
8353 end = start - 1;
8354 start = 0;
8355 }
8356 else
8357 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008358 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008359 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008360 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008361 }
8362
8363 if (error)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008364 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008365 if (stride == 0)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008366 emsg(_(e_stride_is_zero));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008367 else if (stride > 0 ? end + 1 < start : end - 1 > start)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008368 emsg(_(e_start_past_end));
Yegappan Lakshmananca195cc2022-06-14 13:42:26 +01008369 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008370 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008371 list_T *list = rettv->vval.v_list;
8372
8373 // Create a non-materialized list. This is much more efficient and
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008374 // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008375 // be called.
8376 list->lv_first = &range_list_item;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008377 list->lv_u.nonmat.lv_start = start;
8378 list->lv_u.nonmat.lv_end = end;
8379 list->lv_u.nonmat.lv_stride = stride;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008380 list->lv_len = (end - start) / stride + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008381 }
8382}
8383
8384/*
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008385 * Materialize "list".
8386 * Do not call directly, use CHECK_LIST_MATERIALIZE()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008387 */
8388 void
8389range_list_materialize(list_T *list)
8390{
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008391 varnumber_T start = list->lv_u.nonmat.lv_start;
8392 varnumber_T end = list->lv_u.nonmat.lv_end;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008393 int stride = list->lv_u.nonmat.lv_stride;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008394 varnumber_T i;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008395
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008396 list->lv_first = NULL;
8397 list->lv_u.mat.lv_last = NULL;
8398 list->lv_len = 0;
8399 list->lv_u.mat.lv_idx_item = NULL;
8400 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008401 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00008402 if (list_append_number(list, i) == FAIL)
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008403 break;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008404 if (list->lv_lock & VAR_ITEMS_LOCKED)
8405 list->lv_u.mat.lv_last->li_tv.v_lock = VAR_LOCKED;
8406 }
8407 list->lv_lock &= ~VAR_ITEMS_LOCKED;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008408}
8409
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008410/*
8411 * "getreginfo()" function
8412 */
8413 static void
8414f_getreginfo(typval_T *argvars, typval_T *rettv)
8415{
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008416 int regname;
8417 char_u buf[NUMBUFLEN + 2];
8418 long reglen = 0;
8419 dict_T *dict;
8420 list_T *list;
8421
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008422 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
8423 return;
8424
zeertzjqd3f00f52021-12-24 12:02:43 +00008425 regname = getreg_get_regname(argvars);
8426 if (regname == 0)
8427 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008428
zeertzjqd3f00f52021-12-24 12:02:43 +00008429 if (regname == '@')
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008430 regname = '"';
8431
8432 if (rettv_dict_alloc(rettv) == FAIL)
8433 return;
8434 dict = rettv->vval.v_dict;
8435
8436 list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
8437 if (list == NULL)
8438 return;
Bram Moolenaar91639192020-06-29 19:55:58 +02008439 (void)dict_add_list(dict, "regcontents", list);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008440
8441 buf[0] = NUL;
8442 buf[1] = NUL;
8443 switch (get_reg_type(regname, &reglen))
8444 {
8445 case MLINE: buf[0] = 'V'; break;
8446 case MCHAR: buf[0] = 'v'; break;
8447 case MBLOCK:
8448 vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
8449 reglen + 1);
8450 break;
8451 }
Bram Moolenaar91639192020-06-29 19:55:58 +02008452 (void)dict_add_string(dict, (char *)"regtype", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008453
8454 buf[0] = get_register_name(get_unname_register());
8455 buf[1] = NUL;
8456 if (regname == '"')
Bram Moolenaar91639192020-06-29 19:55:58 +02008457 (void)dict_add_string(dict, (char *)"points_to", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008458 else
8459 {
8460 dictitem_T *item = dictitem_alloc((char_u *)"isunnamed");
8461
8462 if (item != NULL)
8463 {
Bram Moolenaar82946e12022-11-24 11:31:29 +00008464 item->di_tv.v_type = VAR_BOOL;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008465 item->di_tv.vval.v_number = regname == buf[0]
Bram Moolenaar418a29f2021-02-10 22:23:41 +01008466 ? VVAL_TRUE : VVAL_FALSE;
Bram Moolenaar91639192020-06-29 19:55:58 +02008467 (void)dict_add(dict, item);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008468 }
8469 }
8470}
8471
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02008472 static void
8473return_register(int regname, typval_T *rettv)
8474{
8475 char_u buf[2] = {0, 0};
8476
8477 buf[0] = (char_u)regname;
8478 rettv->v_type = VAR_STRING;
8479 rettv->vval.v_string = vim_strsave(buf);
8480}
8481
8482/*
8483 * "reg_executing()" function
8484 */
8485 static void
8486f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
8487{
8488 return_register(reg_executing, rettv);
8489}
8490
8491/*
8492 * "reg_recording()" function
8493 */
8494 static void
8495f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
8496{
8497 return_register(reg_recording, rettv);
8498}
8499
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01008500/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008501 * "rename({from}, {to})" function
8502 */
8503 static void
8504f_rename(typval_T *argvars, typval_T *rettv)
8505{
8506 char_u buf[NUMBUFLEN];
8507
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008508 rettv->vval.v_number = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008509 if (check_restricted() || check_secure())
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008510 return;
8511
8512 if (in_vim9script()
8513 && (check_for_string_arg(argvars, 0) == FAIL
8514 || check_for_string_arg(argvars, 1) == FAIL))
8515 return;
8516
8517 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008518 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008519}
8520
8521/*
8522 * "repeat()" function
8523 */
8524 static void
8525f_repeat(typval_T *argvars, typval_T *rettv)
8526{
8527 char_u *p;
Bakudankun375141e2022-09-09 18:46:47 +01008528 varnumber_T n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008529 int slen;
8530 int len;
8531 char_u *r;
8532 int i;
8533
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008534 if (in_vim9script()
Bakudankun375141e2022-09-09 18:46:47 +01008535 && (check_for_string_or_number_or_list_or_blob_arg(argvars, 0)
8536 == FAIL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008537 || check_for_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008538 return;
8539
Bakudankun375141e2022-09-09 18:46:47 +01008540 n = tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008541 if (argvars[0].v_type == VAR_LIST)
8542 {
8543 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
8544 while (n-- > 0)
8545 if (list_extend(rettv->vval.v_list,
8546 argvars[0].vval.v_list, NULL) == FAIL)
8547 break;
8548 }
Bakudankun375141e2022-09-09 18:46:47 +01008549 else if (argvars[0].v_type == VAR_BLOB)
8550 {
8551 if (rettv_blob_alloc(rettv) == FAIL
8552 || argvars[0].vval.v_blob == NULL
8553 || n <= 0)
8554 return;
8555
8556 slen = argvars[0].vval.v_blob->bv_ga.ga_len;
8557 len = (int)slen * n;
8558 if (len <= 0)
8559 return;
8560
8561 if (ga_grow(&rettv->vval.v_blob->bv_ga, len) == FAIL)
8562 return;
8563
8564 rettv->vval.v_blob->bv_ga.ga_len = len;
8565
8566 for (i = 0; i < slen; ++i)
8567 if (blob_get(argvars[0].vval.v_blob, i) != 0)
8568 break;
8569
8570 if (i == slen)
8571 // No need to copy since all bytes are already zero
8572 return;
8573
8574 for (i = 0; i < n; ++i)
8575 blob_set_range(rettv->vval.v_blob,
8576 (long)i * slen, ((long)i + 1) * slen - 1, argvars);
8577 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008578 else
8579 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008580 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008581 rettv->v_type = VAR_STRING;
8582 rettv->vval.v_string = NULL;
8583
8584 slen = (int)STRLEN(p);
8585 len = slen * n;
8586 if (len <= 0)
8587 return;
8588
8589 r = alloc(len + 1);
8590 if (r != NULL)
8591 {
8592 for (i = 0; i < n; i++)
8593 mch_memmove(r + i * slen, p, (size_t)slen);
8594 r[len] = NUL;
8595 }
8596
8597 rettv->vval.v_string = r;
8598 }
8599}
8600
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008601#define SP_NOMOVE 0x01 // don't move cursor
8602#define SP_REPEAT 0x02 // repeat to find outer pair
8603#define SP_RETCOUNT 0x04 // return matchcount
8604#define SP_SETPCMARK 0x08 // set previous context mark
8605#define SP_START 0x10 // accept match at start position
8606#define SP_SUBPAT 0x20 // return nr of matching sub-pattern
8607#define SP_END 0x40 // leave cursor at end of match
8608#define SP_COLUMN 0x80 // start at cursor column
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008609
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008610/*
8611 * Get flags for a search function.
8612 * Possibly sets "p_ws".
8613 * Returns BACKWARD, FORWARD or zero (for an error).
8614 */
8615 static int
8616get_search_arg(typval_T *varp, int *flagsp)
8617{
8618 int dir = FORWARD;
8619 char_u *flags;
8620 char_u nbuf[NUMBUFLEN];
8621 int mask;
8622
8623 if (varp->v_type != VAR_UNKNOWN)
8624 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008625 flags = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008626 if (flags == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008627 return 0; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008628 while (*flags != NUL)
8629 {
8630 switch (*flags)
8631 {
8632 case 'b': dir = BACKWARD; break;
8633 case 'w': p_ws = TRUE; break;
8634 case 'W': p_ws = FALSE; break;
8635 default: mask = 0;
8636 if (flagsp != NULL)
8637 switch (*flags)
8638 {
8639 case 'c': mask = SP_START; break;
8640 case 'e': mask = SP_END; break;
8641 case 'm': mask = SP_RETCOUNT; break;
8642 case 'n': mask = SP_NOMOVE; break;
8643 case 'p': mask = SP_SUBPAT; break;
8644 case 'r': mask = SP_REPEAT; break;
8645 case 's': mask = SP_SETPCMARK; break;
8646 case 'z': mask = SP_COLUMN; break;
8647 }
8648 if (mask == 0)
8649 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008650 semsg(_(e_invalid_argument_str), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008651 dir = 0;
8652 }
8653 else
8654 *flagsp |= mask;
8655 }
8656 if (dir == 0)
8657 break;
8658 ++flags;
8659 }
8660 }
8661 return dir;
8662}
8663
8664/*
8665 * Shared by search() and searchpos() functions.
8666 */
8667 static int
8668search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
8669{
8670 int flags;
8671 char_u *pat;
8672 pos_T pos;
8673 pos_T save_cursor;
8674 int save_p_ws = p_ws;
8675 int dir;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008676 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008677 long lnum_stop = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008678#ifdef FEAT_RELTIME
8679 long time_limit = 0;
8680#endif
8681 int options = SEARCH_KEEP;
8682 int subpatnum;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008683 searchit_arg_T sia;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008684 int use_skip = FALSE;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008685 pos_T firstpos;
8686
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008687 if (in_vim9script()
8688 && (check_for_string_arg(argvars, 0) == FAIL
8689 || check_for_opt_string_arg(argvars, 1) == FAIL
8690 || (argvars[1].v_type != VAR_UNKNOWN
8691 && (check_for_opt_number_arg(argvars, 2) == FAIL
8692 || (argvars[2].v_type != VAR_UNKNOWN
8693 && check_for_opt_number_arg(argvars, 3) == FAIL)))))
8694 goto theend;
8695
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008696 pat = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008697 dir = get_search_arg(&argvars[1], flagsp); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008698 if (dir == 0)
8699 goto theend;
8700 flags = *flagsp;
8701 if (flags & SP_START)
8702 options |= SEARCH_START;
8703 if (flags & SP_END)
8704 options |= SEARCH_END;
8705 if (flags & SP_COLUMN)
8706 options |= SEARCH_COL;
8707
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008708 // Optional arguments: line number to stop searching, timeout and skip.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008709 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
8710 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008711 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008712 if (lnum_stop < 0)
8713 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008714 if (argvars[3].v_type != VAR_UNKNOWN)
8715 {
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008716#ifdef FEAT_RELTIME
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008717 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008718 if (time_limit < 0)
8719 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008720#endif
Bram Moolenaara9c01042020-06-07 14:50:50 +02008721 use_skip = eval_expr_valid_arg(&argvars[4]);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008722 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008723 }
8724
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008725 /*
8726 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
8727 * Check to make sure only those flags are set.
8728 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
8729 * flags cannot be set. Check for that condition also.
8730 */
8731 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
8732 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
8733 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008734 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008735 goto theend;
8736 }
8737
8738 pos = save_cursor = curwin->w_cursor;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008739 CLEAR_FIELD(firstpos);
Bram Moolenaara80faa82020-04-12 19:37:17 +02008740 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008741 sia.sa_stop_lnum = (linenr_T)lnum_stop;
8742#ifdef FEAT_RELTIME
Paul Ollis65745772022-06-05 16:55:54 +01008743 sia.sa_tm = time_limit;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008744#endif
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008745
8746 // Repeat until {skip} returns FALSE.
8747 for (;;)
8748 {
8749 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008750 options, RE_SEARCH, &sia);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008751 // finding the first match again means there is no match where {skip}
8752 // evaluates to zero.
8753 if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))
8754 subpatnum = FAIL;
8755
Bram Moolenaara9c01042020-06-07 14:50:50 +02008756 if (subpatnum == FAIL || !use_skip)
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008757 // didn't find it or no skip argument
8758 break;
8759 firstpos = pos;
8760
Bram Moolenaara9c01042020-06-07 14:50:50 +02008761 // If the skip expression matches, ignore this match.
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008762 {
8763 int do_skip;
8764 int err;
8765 pos_T save_pos = curwin->w_cursor;
8766
8767 curwin->w_cursor = pos;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008768 err = FALSE;
8769 do_skip = eval_expr_to_bool(&argvars[4], &err);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008770 curwin->w_cursor = save_pos;
8771 if (err)
8772 {
8773 // Evaluating {skip} caused an error, break here.
8774 subpatnum = FAIL;
8775 break;
8776 }
8777 if (!do_skip)
8778 break;
8779 }
zeertzjq180246c2022-06-23 12:04:46 +01008780
8781 // clear the start flag to avoid getting stuck here
8782 options &= ~SEARCH_START;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008783 }
8784
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008785 if (subpatnum != FAIL)
8786 {
8787 if (flags & SP_SUBPAT)
8788 retval = subpatnum;
8789 else
8790 retval = pos.lnum;
8791 if (flags & SP_SETPCMARK)
8792 setpcmark();
8793 curwin->w_cursor = pos;
8794 if (match_pos != NULL)
8795 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008796 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008797 match_pos->lnum = pos.lnum;
8798 match_pos->col = pos.col + 1;
8799 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008800 // "/$" will put the cursor after the end of the line, may need to
8801 // correct that here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008802 check_cursor();
8803 }
8804
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008805 // If 'n' flag is used: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008806 if (flags & SP_NOMOVE)
8807 curwin->w_cursor = save_cursor;
8808 else
8809 curwin->w_set_curswant = TRUE;
8810theend:
8811 p_ws = save_p_ws;
8812
8813 return retval;
8814}
8815
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008816#ifdef FEAT_RUBY
8817/*
8818 * "rubyeval()" function
8819 */
8820 static void
8821f_rubyeval(typval_T *argvars, typval_T *rettv)
8822{
8823 char_u *str;
8824 char_u buf[NUMBUFLEN];
8825
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008826 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8827 return;
8828
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008829 str = tv_get_string_buf(&argvars[0], buf);
8830 do_rubyeval(str, rettv);
8831}
8832#endif
8833
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008834/*
8835 * "screenattr()" function
8836 */
8837 static void
8838f_screenattr(typval_T *argvars, typval_T *rettv)
8839{
8840 int row;
8841 int col;
8842 int c;
8843
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008844 if (in_vim9script()
8845 && (check_for_number_arg(argvars, 0) == FAIL
8846 || check_for_number_arg(argvars, 1) == FAIL))
8847 return;
8848
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008849 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8850 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008851 if (row < 0 || row >= screen_Rows
8852 || col < 0 || col >= screen_Columns)
8853 c = -1;
8854 else
8855 c = ScreenAttrs[LineOffset[row] + col];
8856 rettv->vval.v_number = c;
8857}
8858
8859/*
8860 * "screenchar()" function
8861 */
8862 static void
8863f_screenchar(typval_T *argvars, typval_T *rettv)
8864{
8865 int row;
8866 int col;
8867 int off;
8868 int c;
8869
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008870 if (in_vim9script()
8871 && (check_for_number_arg(argvars, 0) == FAIL
8872 || check_for_number_arg(argvars, 1) == FAIL))
8873 return;
8874
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008875 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8876 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008877 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008878 c = -1;
8879 else
8880 {
8881 off = LineOffset[row] + col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008882 if (enc_utf8 && ScreenLinesUC[off] != 0)
8883 c = ScreenLinesUC[off];
8884 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008885 c = ScreenLines[off];
8886 }
8887 rettv->vval.v_number = c;
8888}
8889
8890/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008891 * "screenchars()" function
8892 */
8893 static void
8894f_screenchars(typval_T *argvars, typval_T *rettv)
8895{
8896 int row;
8897 int col;
8898 int off;
8899 int c;
8900 int i;
8901
8902 if (rettv_list_alloc(rettv) == FAIL)
8903 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008904
8905 if (in_vim9script()
8906 && (check_for_number_arg(argvars, 0) == FAIL
8907 || check_for_number_arg(argvars, 1) == FAIL))
8908 return;
8909
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008910 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8911 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8912 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8913 return;
8914
8915 off = LineOffset[row] + col;
8916 if (enc_utf8 && ScreenLinesUC[off] != 0)
8917 c = ScreenLinesUC[off];
8918 else
8919 c = ScreenLines[off];
8920 list_append_number(rettv->vval.v_list, (varnumber_T)c);
8921
8922 if (enc_utf8)
8923
8924 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8925 list_append_number(rettv->vval.v_list,
8926 (varnumber_T)ScreenLinesC[i][off]);
8927}
8928
8929/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008930 * "screencol()" function
8931 *
8932 * First column is 1 to be consistent with virtcol().
8933 */
8934 static void
8935f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
8936{
8937 rettv->vval.v_number = screen_screencol() + 1;
8938}
8939
8940/*
8941 * "screenrow()" function
8942 */
8943 static void
8944f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
8945{
8946 rettv->vval.v_number = screen_screenrow() + 1;
8947}
8948
8949/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008950 * "screenstring()" function
8951 */
8952 static void
8953f_screenstring(typval_T *argvars, typval_T *rettv)
8954{
8955 int row;
8956 int col;
8957 int off;
8958 int c;
8959 int i;
8960 char_u buf[MB_MAXBYTES + 1];
8961 int buflen = 0;
8962
8963 rettv->vval.v_string = NULL;
8964 rettv->v_type = VAR_STRING;
8965
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008966 if (in_vim9script()
8967 && (check_for_number_arg(argvars, 0) == FAIL
8968 || check_for_number_arg(argvars, 1) == FAIL))
8969 return;
8970
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008971 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8972 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8973 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8974 return;
8975
8976 off = LineOffset[row] + col;
8977 if (enc_utf8 && ScreenLinesUC[off] != 0)
8978 c = ScreenLinesUC[off];
8979 else
8980 c = ScreenLines[off];
8981 buflen += mb_char2bytes(c, buf);
8982
Bram Moolenaarf1387282021-03-22 17:11:15 +01008983 if (enc_utf8 && ScreenLinesUC[off] != 0)
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008984 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8985 buflen += mb_char2bytes(ScreenLinesC[i][off], buf + buflen);
8986
8987 buf[buflen] = NUL;
8988 rettv->vval.v_string = vim_strsave(buf);
8989}
8990
8991/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008992 * "search()" function
8993 */
8994 static void
8995f_search(typval_T *argvars, typval_T *rettv)
8996{
8997 int flags = 0;
8998
8999 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
9000}
9001
9002/*
9003 * "searchdecl()" function
9004 */
9005 static void
9006f_searchdecl(typval_T *argvars, typval_T *rettv)
9007{
Bram Moolenaar30788d32020-09-05 21:35:16 +02009008 int locally = TRUE;
9009 int thisblock = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009010 int error = FALSE;
9011 char_u *name;
9012
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009013 rettv->vval.v_number = 1; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009014
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009015 if (in_vim9script()
9016 && (check_for_string_arg(argvars, 0) == FAIL
9017 || check_for_opt_bool_arg(argvars, 1) == FAIL
9018 || (argvars[1].v_type != VAR_UNKNOWN
9019 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9020 return;
9021
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009022 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009023 if (argvars[1].v_type != VAR_UNKNOWN)
9024 {
Bram Moolenaar30788d32020-09-05 21:35:16 +02009025 locally = !(int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009026 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar30788d32020-09-05 21:35:16 +02009027 thisblock = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009028 }
9029 if (!error && name != NULL)
9030 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
9031 locally, thisblock, SEARCH_KEEP) == FAIL;
9032}
9033
9034/*
9035 * Used by searchpair() and searchpairpos()
9036 */
9037 static int
9038searchpair_cmn(typval_T *argvars, pos_T *match_pos)
9039{
9040 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +01009041 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009042 int save_p_ws = p_ws;
9043 int dir;
9044 int flags = 0;
9045 char_u nbuf1[NUMBUFLEN];
9046 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009047 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009048 long lnum_stop = 0;
9049 long time_limit = 0;
9050
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02009051 if (in_vim9script()
9052 && (check_for_string_arg(argvars, 0) == FAIL
9053 || check_for_string_arg(argvars, 1) == FAIL
9054 || check_for_string_arg(argvars, 2) == FAIL
9055 || check_for_opt_string_arg(argvars, 3) == FAIL
9056 || (argvars[3].v_type != VAR_UNKNOWN
9057 && argvars[4].v_type != VAR_UNKNOWN
9058 && (check_for_opt_number_arg(argvars, 5) == FAIL
9059 || (argvars[5].v_type != VAR_UNKNOWN
9060 && check_for_opt_number_arg(argvars, 6) == FAIL)))))
9061 goto theend;
9062
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009063 // Get the three pattern arguments: start, middle, end. Will result in an
9064 // error if not a valid argument.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009065 spat = tv_get_string_chk(&argvars[0]);
9066 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
9067 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009068 if (spat == NULL || mpat == NULL || epat == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009069 goto theend; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009070
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009071 // Handle the optional fourth argument: flags
9072 dir = get_search_arg(&argvars[3], &flags); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009073 if (dir == 0)
9074 goto theend;
9075
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009076 // Don't accept SP_END or SP_SUBPAT.
9077 // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009078 if ((flags & (SP_END | SP_SUBPAT)) != 0
9079 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
9080 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009081 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009082 goto theend;
9083 }
9084
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009085 // Using 'r' implies 'W', otherwise it doesn't work.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009086 if (flags & SP_REPEAT)
9087 p_ws = FALSE;
9088
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009089 // Optional fifth argument: skip expression
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009090 if (argvars[3].v_type == VAR_UNKNOWN
9091 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +01009092 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009093 else
9094 {
Bram Moolenaara9c01042020-06-07 14:50:50 +02009095 // Type is checked later.
Bram Moolenaar48570482017-10-30 21:48:41 +01009096 skip = &argvars[4];
Bram Moolenaara9c01042020-06-07 14:50:50 +02009097
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009098 if (argvars[5].v_type != VAR_UNKNOWN)
9099 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009100 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009101 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009102 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009103 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009104 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009105 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009106#ifdef FEAT_RELTIME
9107 if (argvars[6].v_type != VAR_UNKNOWN)
9108 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009109 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009110 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009111 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009112 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009113 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009114 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009115 }
9116#endif
9117 }
9118 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009119
9120 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
9121 match_pos, lnum_stop, time_limit);
9122
9123theend:
9124 p_ws = save_p_ws;
9125
9126 return retval;
9127}
9128
9129/*
9130 * "searchpair()" function
9131 */
9132 static void
9133f_searchpair(typval_T *argvars, typval_T *rettv)
9134{
9135 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
9136}
9137
9138/*
9139 * "searchpairpos()" function
9140 */
9141 static void
9142f_searchpairpos(typval_T *argvars, typval_T *rettv)
9143{
9144 pos_T match_pos;
9145 int lnum = 0;
9146 int col = 0;
9147
9148 if (rettv_list_alloc(rettv) == FAIL)
9149 return;
9150
9151 if (searchpair_cmn(argvars, &match_pos) > 0)
9152 {
9153 lnum = match_pos.lnum;
9154 col = match_pos.col;
9155 }
9156
9157 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
9158 list_append_number(rettv->vval.v_list, (varnumber_T)col);
9159}
9160
9161/*
9162 * Search for a start/middle/end thing.
9163 * Used by searchpair(), see its documentation for the details.
9164 * Returns 0 or -1 for no match,
9165 */
9166 long
9167do_searchpair(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009168 char_u *spat, // start pattern
9169 char_u *mpat, // middle pattern
9170 char_u *epat, // end pattern
9171 int dir, // BACKWARD or FORWARD
9172 typval_T *skip, // skip expression
9173 int flags, // SP_SETPCMARK and other SP_ values
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009174 pos_T *match_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009175 linenr_T lnum_stop, // stop at this line if not zero
9176 long time_limit UNUSED) // stop after this many msec
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009177{
9178 char_u *save_cpo;
9179 char_u *pat, *pat2 = NULL, *pat3 = NULL;
9180 long retval = 0;
9181 pos_T pos;
9182 pos_T firstpos;
9183 pos_T foundpos;
9184 pos_T save_cursor;
9185 pos_T save_pos;
9186 int n;
9187 int r;
9188 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +01009189 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009190 int err;
9191 int options = SEARCH_KEEP;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009192
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009193 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009194 save_cpo = p_cpo;
9195 p_cpo = empty_option;
9196
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009197 // Make two search patterns: start/end (pat2, for in nested pairs) and
9198 // start/middle/end (pat3, for the top pair).
Bram Moolenaar964b3742019-05-24 18:54:09 +02009199 pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17);
9200 pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009201 if (pat2 == NULL || pat3 == NULL)
9202 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +01009203 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009204 if (*mpat == NUL)
9205 STRCPY(pat3, pat2);
9206 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +01009207 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009208 spat, epat, mpat);
9209 if (flags & SP_START)
9210 options |= SEARCH_START;
9211
Bram Moolenaar48570482017-10-30 21:48:41 +01009212 if (skip != NULL)
Bram Moolenaara9c01042020-06-07 14:50:50 +02009213 use_skip = eval_expr_valid_arg(skip);
Bram Moolenaar48570482017-10-30 21:48:41 +01009214
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009215#ifdef FEAT_RELTIME
9216 if (time_limit > 0)
9217 init_regexp_timeout(time_limit);
9218#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009219 save_cursor = curwin->w_cursor;
9220 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009221 CLEAR_POS(&firstpos);
9222 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009223 pat = pat3;
9224 for (;;)
9225 {
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009226 searchit_arg_T sia;
9227
Bram Moolenaara80faa82020-04-12 19:37:17 +02009228 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009229 sia.sa_stop_lnum = lnum_stop;
Bram Moolenaar5d24a222018-12-23 19:10:09 +01009230 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009231 options, RE_SEARCH, &sia);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009232 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009233 // didn't find it or found the first match again: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009234 break;
9235
9236 if (firstpos.lnum == 0)
9237 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009238 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009239 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009240 // Found the same position again. Can happen with a pattern that
9241 // has "\zs" at the end and searching backwards. Advance one
9242 // character and try again.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009243 if (dir == BACKWARD)
9244 decl(&pos);
9245 else
9246 incl(&pos);
9247 }
9248 foundpos = pos;
9249
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009250 // clear the start flag to avoid getting stuck here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009251 options &= ~SEARCH_START;
9252
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009253 // If the skip pattern matches, ignore this match.
Bram Moolenaar48570482017-10-30 21:48:41 +01009254 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009255 {
9256 save_pos = curwin->w_cursor;
9257 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +01009258 err = FALSE;
9259 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009260 curwin->w_cursor = save_pos;
9261 if (err)
9262 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009263 // Evaluating {skip} caused an error, break here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009264 curwin->w_cursor = save_cursor;
9265 retval = -1;
9266 break;
9267 }
9268 if (r)
9269 continue;
9270 }
9271
9272 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
9273 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009274 // Found end when searching backwards or start when searching
9275 // forward: nested pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009276 ++nest;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009277 pat = pat2; // nested, don't search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009278 }
9279 else
9280 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009281 // Found end when searching forward or start when searching
9282 // backward: end of (nested) pair; or found middle in outer pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009283 if (--nest == 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009284 pat = pat3; // outer level, search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009285 }
9286
9287 if (nest == 0)
9288 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009289 // Found the match: return matchcount or line number.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009290 if (flags & SP_RETCOUNT)
9291 ++retval;
9292 else
9293 retval = pos.lnum;
9294 if (flags & SP_SETPCMARK)
9295 setpcmark();
9296 curwin->w_cursor = pos;
9297 if (!(flags & SP_REPEAT))
9298 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009299 nest = 1; // search for next unmatched
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009300 }
9301 }
9302
9303 if (match_pos != NULL)
9304 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009305 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009306 match_pos->lnum = curwin->w_cursor.lnum;
9307 match_pos->col = curwin->w_cursor.col + 1;
9308 }
9309
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009310 // If 'n' flag is used or search failed: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009311 if ((flags & SP_NOMOVE) || retval == 0)
9312 curwin->w_cursor = save_cursor;
9313
9314theend:
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009315#ifdef FEAT_RELTIME
Bram Moolenaar0f618382022-08-26 21:33:04 +01009316 if (time_limit > 0)
9317 disable_regexp_timeout();
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009318#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009319 vim_free(pat2);
9320 vim_free(pat3);
9321 if (p_cpo == empty_option)
9322 p_cpo = save_cpo;
9323 else
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009324 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009325 // Darn, evaluating the {skip} expression changed the value.
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009326 // If it's still empty it was changed and restored, need to restore in
9327 // the complicated way.
9328 if (*p_cpo == NUL)
Bram Moolenaar31e5c602022-04-15 13:53:33 +01009329 set_option_value_give_err((char_u *)"cpo", 0L, save_cpo, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009330 free_string_option(save_cpo);
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009331 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009332
9333 return retval;
9334}
9335
9336/*
9337 * "searchpos()" function
9338 */
9339 static void
9340f_searchpos(typval_T *argvars, typval_T *rettv)
9341{
9342 pos_T match_pos;
9343 int lnum = 0;
9344 int col = 0;
9345 int n;
9346 int flags = 0;
9347
9348 if (rettv_list_alloc(rettv) == FAIL)
9349 return;
9350
9351 n = search_cmn(argvars, &match_pos, &flags);
9352 if (n > 0)
9353 {
9354 lnum = match_pos.lnum;
9355 col = match_pos.col;
9356 }
9357
9358 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
9359 list_append_number(rettv->vval.v_list, (varnumber_T)col);
9360 if (flags & SP_SUBPAT)
9361 list_append_number(rettv->vval.v_list, (varnumber_T)n);
9362}
9363
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009364/*
9365 * Set the cursor or mark position.
Christian Brabandt98703d72021-06-24 19:55:27 +02009366 * If 'charpos' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009367 * Otherwise use the column number as a byte offset.
9368 */
9369 static void
9370set_position(typval_T *argvars, typval_T *rettv, int charpos)
9371{
9372 pos_T pos;
9373 int fnum;
9374 char_u *name;
9375 colnr_T curswant = -1;
9376
9377 rettv->vval.v_number = -1;
9378
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009379 if (in_vim9script()
9380 && (check_for_string_arg(argvars, 0) == FAIL
9381 || check_for_list_arg(argvars, 1) == FAIL))
9382 return;
9383
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009384 name = tv_get_string_chk(argvars);
9385 if (name != NULL)
9386 {
9387 if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) == OK)
9388 {
9389 if (pos.col != MAXCOL && --pos.col < 0)
9390 pos.col = 0;
9391 if ((name[0] == '.' && name[1] == NUL))
9392 {
9393 // set cursor; "fnum" is ignored
9394 curwin->w_cursor = pos;
9395 if (curswant >= 0)
9396 {
9397 curwin->w_curswant = curswant - 1;
9398 curwin->w_set_curswant = FALSE;
9399 }
9400 check_cursor();
9401 rettv->vval.v_number = 0;
9402 }
9403 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
9404 {
9405 // set mark
9406 if (setmark_pos(name[1], &pos, fnum) == OK)
9407 rettv->vval.v_number = 0;
9408 }
9409 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009410 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009411 }
9412 }
9413}
9414/*
9415 * "setcharpos()" function
9416 */
9417 static void
9418f_setcharpos(typval_T *argvars, typval_T *rettv)
9419{
9420 set_position(argvars, rettv, TRUE);
9421}
9422
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009423 static void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009424f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
9425{
9426 dict_T *d;
9427 dictitem_T *di;
9428 char_u *csearch;
9429
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01009430 if (check_for_dict_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009431 return;
9432
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009433 if ((d = argvars[0].vval.v_dict) != NULL)
9434 {
Bram Moolenaard61efa52022-07-23 09:52:04 +01009435 csearch = dict_get_string(d, "char", FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009436 if (csearch != NULL)
9437 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009438 if (enc_utf8)
9439 {
9440 int pcc[MAX_MCO];
9441 int c = utfc_ptr2char(csearch, pcc);
9442
9443 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
9444 }
9445 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009446 set_last_csearch(PTR2CHAR(csearch),
Bram Moolenaar1614a142019-10-06 22:00:13 +02009447 csearch, mb_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009448 }
9449
9450 di = dict_find(d, (char_u *)"forward", -1);
9451 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009452 set_csearch_direction((int)tv_get_number(&di->di_tv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009453 ? FORWARD : BACKWARD);
9454
9455 di = dict_find(d, (char_u *)"until", -1);
9456 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009457 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009458 }
9459}
9460
9461/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009462 * "setcursorcharpos" function
9463 */
9464 static void
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01009465f_setcursorcharpos(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009466{
9467 set_cursorpos(argvars, rettv, TRUE);
9468}
9469
9470/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009471 * "setenv()" function
9472 */
9473 static void
9474f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
9475{
9476 char_u namebuf[NUMBUFLEN];
9477 char_u valbuf[NUMBUFLEN];
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009478 char_u *name;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009479
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009480 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9481 return;
9482
9483 name = tv_get_string_buf(&argvars[0], namebuf);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009484 if (argvars[1].v_type == VAR_SPECIAL
9485 && argvars[1].vval.v_number == VVAL_NULL)
LemonBoy77142312022-04-15 20:50:46 +01009486 vim_unsetenv_ext(name);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009487 else
LemonBoy77142312022-04-15 20:50:46 +01009488 vim_setenv_ext(name, tv_get_string_buf(&argvars[1], valbuf));
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009489}
9490
9491/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009492 * "setfperm({fname}, {mode})" function
9493 */
9494 static void
9495f_setfperm(typval_T *argvars, typval_T *rettv)
9496{
9497 char_u *fname;
9498 char_u modebuf[NUMBUFLEN];
9499 char_u *mode_str;
9500 int i;
9501 int mask;
9502 int mode = 0;
9503
9504 rettv->vval.v_number = 0;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009505
9506 if (in_vim9script()
9507 && (check_for_string_arg(argvars, 0) == FAIL
9508 || check_for_string_arg(argvars, 1) == FAIL))
9509 return;
9510
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009511 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009512 if (fname == NULL)
9513 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009514 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009515 if (mode_str == NULL)
9516 return;
9517 if (STRLEN(mode_str) != 9)
9518 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009519 semsg(_(e_invalid_argument_str), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009520 return;
9521 }
9522
9523 mask = 1;
9524 for (i = 8; i >= 0; --i)
9525 {
9526 if (mode_str[i] != '-')
9527 mode |= mask;
9528 mask = mask << 1;
9529 }
9530 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
9531}
9532
9533/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009534 * "setpos()" function
9535 */
9536 static void
9537f_setpos(typval_T *argvars, typval_T *rettv)
9538{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009539 set_position(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009540}
9541
9542/*
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009543 * Translate a register type string to the yank type and block length
9544 */
9545 static int
9546get_yank_type(char_u **pp, char_u *yank_type, long *block_len)
9547{
9548 char_u *stropt = *pp;
9549 switch (*stropt)
9550 {
9551 case 'v': case 'c': // character-wise selection
9552 *yank_type = MCHAR;
9553 break;
9554 case 'V': case 'l': // line-wise selection
9555 *yank_type = MLINE;
9556 break;
9557 case 'b': case Ctrl_V: // block-wise selection
9558 *yank_type = MBLOCK;
9559 if (VIM_ISDIGIT(stropt[1]))
9560 {
9561 ++stropt;
9562 *block_len = getdigits(&stropt) - 1;
9563 --stropt;
9564 }
9565 break;
9566 default:
9567 return FAIL;
9568 }
9569 *pp = stropt;
9570 return OK;
9571}
9572
9573/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009574 * "setreg()" function
9575 */
9576 static void
9577f_setreg(typval_T *argvars, typval_T *rettv)
9578{
9579 int regname;
9580 char_u *strregname;
9581 char_u *stropt;
9582 char_u *strval;
9583 int append;
9584 char_u yank_type;
9585 long block_len;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009586 typval_T *regcontents;
9587 int pointreg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009588
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009589 if (in_vim9script()
9590 && (check_for_string_arg(argvars, 0) == FAIL
9591 || check_for_opt_string_arg(argvars, 2) == FAIL))
9592 return;
9593
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009594 pointreg = 0;
9595 regcontents = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009596 block_len = -1;
9597 yank_type = MAUTO;
9598 append = FALSE;
9599
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009600 strregname = tv_get_string_chk(argvars);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009601 rettv->vval.v_number = 1; // FAIL is default
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009602
9603 if (strregname == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009604 return; // type error; errmsg already given
Bram Moolenaar418a29f2021-02-10 22:23:41 +01009605 if (in_vim9script() && STRLEN(strregname) > 1)
9606 {
9607 semsg(_(e_register_name_must_be_one_char_str), strregname);
9608 return;
9609 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009610 regname = *strregname;
9611 if (regname == 0 || regname == '@')
9612 regname = '"';
9613
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009614 if (argvars[1].v_type == VAR_DICT)
9615 {
9616 dict_T *d = argvars[1].vval.v_dict;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009617 dictitem_T *di;
9618
9619 if (d == NULL || d->dv_hashtab.ht_used == 0)
9620 {
9621 // Empty dict, clear the register (like setreg(0, []))
9622 char_u *lstval[2] = {NULL, NULL};
9623 write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1);
9624 return;
9625 }
9626
9627 di = dict_find(d, (char_u *)"regcontents", -1);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009628 if (di != NULL)
9629 regcontents = &di->di_tv;
9630
Bram Moolenaard61efa52022-07-23 09:52:04 +01009631 stropt = dict_get_string(d, "regtype", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009632 if (stropt != NULL)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009633 {
9634 int ret = get_yank_type(&stropt, &yank_type, &block_len);
9635
9636 if (ret == FAIL || *++stropt != NUL)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009637 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009638 semsg(_(e_invalid_value_for_argument_str), "value");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009639 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009640 }
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009641 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009642
9643 if (regname == '"')
9644 {
Bram Moolenaard61efa52022-07-23 09:52:04 +01009645 stropt = dict_get_string(d, "points_to", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009646 if (stropt != NULL)
9647 {
9648 pointreg = *stropt;
9649 regname = pointreg;
9650 }
9651 }
Bram Moolenaard61efa52022-07-23 09:52:04 +01009652 else if (dict_get_bool(d, "isunnamed", -1) > 0)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009653 pointreg = regname;
9654 }
9655 else
9656 regcontents = &argvars[1];
9657
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009658 if (argvars[2].v_type != VAR_UNKNOWN)
9659 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009660 if (yank_type != MAUTO)
9661 {
Bram Moolenaare1242042021-12-16 20:56:57 +00009662 semsg(_(e_too_many_arguments_for_function_str), "setreg");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009663 return;
9664 }
9665
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009666 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009667 if (stropt == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009668 return; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009669 for (; *stropt != NUL; ++stropt)
9670 switch (*stropt)
9671 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009672 case 'a': case 'A': // append
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009673 append = TRUE;
9674 break;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009675 default:
9676 get_yank_type(&stropt, &yank_type, &block_len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009677 }
9678 }
9679
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009680 if (regcontents && regcontents->v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009681 {
9682 char_u **lstval;
9683 char_u **allocval;
9684 char_u buf[NUMBUFLEN];
9685 char_u **curval;
9686 char_u **curallocval;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009687 list_T *ll = regcontents->vval.v_list;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009688 listitem_T *li;
9689 int len;
9690
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009691 // If the list is NULL handle like an empty list.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009692 len = ll == NULL ? 0 : ll->lv_len;
9693
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009694 // First half: use for pointers to result lines; second half: use for
9695 // pointers to allocated copies.
Bram Moolenaarc799fe22019-05-28 23:08:19 +02009696 lstval = ALLOC_MULT(char_u *, (len + 1) * 2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009697 if (lstval == NULL)
9698 return;
9699 curval = lstval;
9700 allocval = lstval + len + 2;
9701 curallocval = allocval;
9702
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009703 if (ll != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009704 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009705 CHECK_LIST_MATERIALIZE(ll);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02009706 FOR_ALL_LIST_ITEMS(ll, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009707 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009708 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009709 if (strval == NULL)
9710 goto free_lstval;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009711 if (strval == buf)
9712 {
9713 // Need to make a copy, next tv_get_string_buf_chk() will
9714 // overwrite the string.
9715 strval = vim_strsave(buf);
9716 if (strval == NULL)
9717 goto free_lstval;
9718 *curallocval++ = strval;
9719 }
9720 *curval++ = strval;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009721 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009722 }
9723 *curval++ = NULL;
9724
9725 write_reg_contents_lst(regname, lstval, -1,
9726 append, yank_type, block_len);
9727free_lstval:
9728 while (curallocval > allocval)
9729 vim_free(*--curallocval);
9730 vim_free(lstval);
9731 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009732 else if (regcontents)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009733 {
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009734 strval = tv_get_string_chk(regcontents);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009735 if (strval == NULL)
9736 return;
9737 write_reg_contents_ex(regname, strval, -1,
9738 append, yank_type, block_len);
9739 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009740 if (pointreg != 0)
9741 get_yank_register(pointreg, TRUE);
9742
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009743 rettv->vval.v_number = 0;
9744}
9745
9746/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009747 * "settagstack()" function
9748 */
9749 static void
9750f_settagstack(typval_T *argvars, typval_T *rettv)
9751{
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009752 win_T *wp;
9753 dict_T *d;
9754 int action = 'r';
9755
9756 rettv->vval.v_number = -1;
9757
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009758 if (in_vim9script()
9759 && (check_for_number_arg(argvars, 0) == FAIL
9760 || check_for_dict_arg(argvars, 1) == FAIL
9761 || check_for_opt_string_arg(argvars, 2) == FAIL))
9762 return;
9763
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009764 // first argument: window number or id
9765 wp = find_win_by_nr_or_id(&argvars[0]);
9766 if (wp == NULL)
9767 return;
9768
9769 // second argument: dict with items to set in the tag stack
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01009770 if (check_for_dict_arg(argvars, 1) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009771 return;
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009772 d = argvars[1].vval.v_dict;
9773 if (d == NULL)
9774 return;
9775
9776 // third argument: action - 'a' for append and 'r' for replace.
9777 // default is to replace the stack.
9778 if (argvars[2].v_type == VAR_UNKNOWN)
9779 action = 'r';
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01009780 else if (check_for_string_arg(argvars, 2) == FAIL)
9781 return;
9782 else
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009783 {
9784 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009785 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009786 if (actstr == NULL)
9787 return;
Bram Moolenaar271fa082020-01-02 14:02:16 +01009788 if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't')
9789 && actstr[1] == NUL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009790 action = *actstr;
9791 else
9792 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00009793 semsg(_(e_invalid_action_str_2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009794 return;
9795 }
9796 }
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009797
9798 if (set_tagstack(wp, d, action) == OK)
9799 rettv->vval.v_number = 0;
9800}
9801
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009802#ifdef FEAT_CRYPT
9803/*
9804 * "sha256({string})" function
9805 */
9806 static void
9807f_sha256(typval_T *argvars, typval_T *rettv)
9808{
9809 char_u *p;
9810
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009811 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9812 return;
9813
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009814 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009815 rettv->vval.v_string = vim_strsave(
9816 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
9817 rettv->v_type = VAR_STRING;
9818}
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009819#endif // FEAT_CRYPT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009820
9821/*
9822 * "shellescape({string})" function
9823 */
9824 static void
9825f_shellescape(typval_T *argvars, typval_T *rettv)
9826{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009827 int do_special;
Bram Moolenaar20615522017-06-05 18:46:26 +02009828
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009829 if (in_vim9script()
9830 && (check_for_string_arg(argvars, 0) == FAIL
9831 || check_for_opt_bool_arg(argvars, 1) == FAIL))
9832 return;
9833
9834 do_special = non_zero_arg(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009835 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009836 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009837 rettv->v_type = VAR_STRING;
9838}
9839
9840/*
9841 * shiftwidth() function
9842 */
9843 static void
9844f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
9845{
Bram Moolenaarf9514162018-11-22 03:08:29 +01009846 rettv->vval.v_number = 0;
9847
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009848 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
9849 return;
9850
Bram Moolenaarf9514162018-11-22 03:08:29 +01009851 if (argvars[0].v_type != VAR_UNKNOWN)
9852 {
9853 long col;
9854
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009855 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +01009856 if (col < 0)
9857 return; // type error; errmsg already given
9858#ifdef FEAT_VARTABS
9859 rettv->vval.v_number = get_sw_value_col(curbuf, col);
9860 return;
9861#endif
9862 }
9863
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009864 rettv->vval.v_number = get_sw_value(curbuf);
9865}
9866
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009867/*
9868 * "soundfold({word})" function
9869 */
9870 static void
9871f_soundfold(typval_T *argvars, typval_T *rettv)
9872{
9873 char_u *s;
9874
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009875 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9876 return;
9877
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009878 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009879 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009880#ifdef FEAT_SPELL
9881 rettv->vval.v_string = eval_soundfold(s);
9882#else
9883 rettv->vval.v_string = vim_strsave(s);
9884#endif
9885}
9886
9887/*
9888 * "spellbadword()" function
9889 */
9890 static void
9891f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
9892{
9893 char_u *word = (char_u *)"";
9894 hlf_T attr = HLF_COUNT;
9895 int len = 0;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009896#ifdef FEAT_SPELL
9897 int wo_spell_save = curwin->w_p_spell;
9898
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009899 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
9900 return;
9901
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009902 if (!curwin->w_p_spell)
9903 {
9904 did_set_spelllang(curwin);
9905 curwin->w_p_spell = TRUE;
9906 }
9907
9908 if (*curwin->w_s->b_p_spl == NUL)
9909 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009910 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009911 curwin->w_p_spell = wo_spell_save;
9912 return;
9913 }
9914#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009915
9916 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009917 {
9918#ifdef FEAT_SPELL
9919 curwin->w_p_spell = wo_spell_save;
9920#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009921 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009922 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009923
9924#ifdef FEAT_SPELL
9925 if (argvars[0].v_type == VAR_UNKNOWN)
9926 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009927 // Find the start and length of the badly spelled word.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009928 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
9929 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009930 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009931 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009932 curwin->w_set_curswant = TRUE;
9933 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009934 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009935 else if (*curbuf->b_s.b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009936 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009937 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009938 int capcol = -1;
9939
9940 if (str != NULL)
9941 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009942 // Check the argument for spelling.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009943 while (*str != NUL)
9944 {
9945 len = spell_check(curwin, str, &attr, &capcol, FALSE);
9946 if (attr != HLF_COUNT)
9947 {
9948 word = str;
9949 break;
9950 }
9951 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +02009952 capcol -= len;
Bram Moolenaar0c779e82019-08-09 17:01:02 +02009953 len = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009954 }
9955 }
9956 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009957 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009958#endif
9959
9960 list_append_string(rettv->vval.v_list, word, len);
9961 list_append_string(rettv->vval.v_list, (char_u *)(
9962 attr == HLF_SPB ? "bad" :
9963 attr == HLF_SPR ? "rare" :
9964 attr == HLF_SPL ? "local" :
9965 attr == HLF_SPC ? "caps" :
9966 ""), -1);
9967}
9968
9969/*
9970 * "spellsuggest()" function
9971 */
9972 static void
9973f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
9974{
9975#ifdef FEAT_SPELL
9976 char_u *str;
9977 int typeerr = FALSE;
9978 int maxcount;
9979 garray_T ga;
9980 int i;
9981 listitem_T *li;
9982 int need_capital = FALSE;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009983 int wo_spell_save = curwin->w_p_spell;
9984
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009985 if (in_vim9script()
9986 && (check_for_string_arg(argvars, 0) == FAIL
9987 || check_for_opt_number_arg(argvars, 1) == FAIL
9988 || (argvars[1].v_type != VAR_UNKNOWN
9989 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9990 return;
9991
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009992 if (!curwin->w_p_spell)
9993 {
9994 did_set_spelllang(curwin);
9995 curwin->w_p_spell = TRUE;
9996 }
9997
9998 if (*curwin->w_s->b_p_spl == NUL)
9999 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +000010000 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010001 curwin->w_p_spell = wo_spell_save;
10002 return;
10003 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010004#endif
10005
10006 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010007 {
10008#ifdef FEAT_SPELL
10009 curwin->w_p_spell = wo_spell_save;
10010#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010011 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010012 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010013
10014#ifdef FEAT_SPELL
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010015 str = tv_get_string(&argvars[0]);
10016 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010017 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010018 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
10019 if (maxcount <= 0)
10020 return;
10021 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010022 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010023 need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr);
10024 if (typeerr)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010025 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010026 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010027 }
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010028 else
10029 maxcount = 25;
10030
10031 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
10032
10033 for (i = 0; i < ga.ga_len; ++i)
10034 {
10035 str = ((char_u **)ga.ga_data)[i];
10036
10037 li = listitem_alloc();
10038 if (li == NULL)
10039 vim_free(str);
10040 else
10041 {
10042 li->li_tv.v_type = VAR_STRING;
10043 li->li_tv.v_lock = 0;
10044 li->li_tv.vval.v_string = str;
10045 list_append(rettv->vval.v_list, li);
10046 }
10047 }
10048 ga_clear(&ga);
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010049 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010050#endif
10051}
10052
10053 static void
10054f_split(typval_T *argvars, typval_T *rettv)
10055{
10056 char_u *str;
10057 char_u *end;
10058 char_u *pat = NULL;
10059 regmatch_T regmatch;
10060 char_u patbuf[NUMBUFLEN];
10061 char_u *save_cpo;
10062 int match;
10063 colnr_T col = 0;
10064 int keepempty = FALSE;
10065 int typeerr = FALSE;
10066
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010067 if (in_vim9script()
10068 && (check_for_string_arg(argvars, 0) == FAIL
10069 || check_for_opt_string_arg(argvars, 1) == FAIL
10070 || (argvars[1].v_type != VAR_UNKNOWN
10071 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
10072 return;
10073
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010074 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010075 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +010010076 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010077
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010078 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010079 if (argvars[1].v_type != VAR_UNKNOWN)
10080 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010081 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010082 if (pat == NULL)
10083 typeerr = TRUE;
10084 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar3986b942020-09-06 16:09:04 +020010085 keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010086 }
10087 if (pat == NULL || *pat == NUL)
10088 pat = (char_u *)"[\\x01- ]\\+";
10089
10090 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010091 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010092 if (typeerr)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010093 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010094
10095 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
10096 if (regmatch.regprog != NULL)
10097 {
10098 regmatch.rm_ic = FALSE;
10099 while (*str != NUL || keepempty)
10100 {
10101 if (*str == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010102 match = FALSE; // empty item at the end
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010103 else
10104 match = vim_regexec_nl(&regmatch, str, col);
10105 if (match)
10106 end = regmatch.startp[0];
10107 else
10108 end = str + STRLEN(str);
10109 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
10110 && *str != NUL && match && end < regmatch.endp[0]))
10111 {
10112 if (list_append_string(rettv->vval.v_list, str,
10113 (int)(end - str)) == FAIL)
10114 break;
10115 }
10116 if (!match)
10117 break;
Bram Moolenaar13505972019-01-24 15:04:48 +010010118 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010119 if (regmatch.endp[0] > str)
10120 col = 0;
10121 else
Bram Moolenaar13505972019-01-24 15:04:48 +010010122 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010123 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010124 str = regmatch.endp[0];
10125 }
10126
10127 vim_regfree(regmatch.regprog);
10128 }
10129
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010130theend:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010131 p_cpo = save_cpo;
10132}
10133
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010134/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010135 * "submatch()" function
10136 */
10137 static void
10138f_submatch(typval_T *argvars, typval_T *rettv)
10139{
10140 int error = FALSE;
10141 int no;
10142 int retList = 0;
10143
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010144 if (in_vim9script()
10145 && (check_for_number_arg(argvars, 0) == FAIL
10146 || check_for_opt_bool_arg(argvars, 1) == FAIL))
10147 return;
10148
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010149 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010150 if (error)
10151 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020010152 if (no < 0 || no >= NSUBEXP)
10153 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +000010154 semsg(_(e_invalid_submatch_number_nr), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +010010155 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020010156 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010157 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaarad304702020-09-06 18:22:53 +020010158 retList = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010159 if (error)
10160 return;
10161
10162 if (retList == 0)
10163 {
10164 rettv->v_type = VAR_STRING;
10165 rettv->vval.v_string = reg_submatch(no);
10166 }
10167 else
10168 {
10169 rettv->v_type = VAR_LIST;
10170 rettv->vval.v_list = reg_submatch_list(no);
10171 }
10172}
10173
10174/*
10175 * "substitute()" function
10176 */
10177 static void
10178f_substitute(typval_T *argvars, typval_T *rettv)
10179{
10180 char_u patbuf[NUMBUFLEN];
10181 char_u subbuf[NUMBUFLEN];
10182 char_u flagsbuf[NUMBUFLEN];
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020010183 char_u *str;
10184 char_u *pat;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010185 char_u *sub = NULL;
10186 typval_T *expr = NULL;
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020010187 char_u *flg;
10188
10189 if (in_vim9script()
10190 && (check_for_string_arg(argvars, 0) == FAIL
10191 || check_for_string_arg(argvars, 1) == FAIL
10192 || check_for_string_arg(argvars, 3) == FAIL))
10193 return;
10194
10195 str = tv_get_string_chk(&argvars[0]);
10196 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
10197 flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010198
LemonBoyf3b48952022-05-05 13:53:03 +010010199 if (argvars[2].v_type == VAR_FUNC
10200 || argvars[2].v_type == VAR_PARTIAL
Bram Moolenaar00b28d62022-12-08 15:32:33 +000010201 || argvars[2].v_type == VAR_INSTR
10202 || argvars[2].v_type == VAR_CLASS
10203 || argvars[2].v_type == VAR_OBJECT)
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010204 expr = &argvars[2];
10205 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010206 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010207
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010208 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010209 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
10210 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010211 rettv->vval.v_string = NULL;
10212 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010213 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010214}
10215
10216/*
Bram Moolenaarc216a7a2022-12-05 13:50:55 +000010217 * "swapfilelist()" function
10218 */
10219 static void
10220f_swapfilelist(typval_T *argvars UNUSED, typval_T *rettv)
10221{
10222 if (rettv_list_alloc(rettv) == FAIL)
10223 return;
10224 recover_names(NULL, FALSE, rettv->vval.v_list, 0, NULL);
10225}
10226
10227/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010228 * "swapinfo(swap_filename)" function
10229 */
10230 static void
10231f_swapinfo(typval_T *argvars, typval_T *rettv)
10232{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010233 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
10234 return;
10235
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010236 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010237 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010238}
10239
10240/*
Bram Moolenaar110bd602018-09-16 18:46:59 +020010241 * "swapname(expr)" function
10242 */
10243 static void
10244f_swapname(typval_T *argvars, typval_T *rettv)
10245{
10246 buf_T *buf;
10247
10248 rettv->v_type = VAR_STRING;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010249
10250 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
10251 return;
10252
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010010253 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +020010254 if (buf == NULL || buf->b_ml.ml_mfp == NULL
10255 || buf->b_ml.ml_mfp->mf_fname == NULL)
10256 rettv->vval.v_string = NULL;
10257 else
10258 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
10259}
10260
10261/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010262 * "synID(lnum, col, trans)" function
10263 */
10264 static void
10265f_synID(typval_T *argvars UNUSED, typval_T *rettv)
10266{
10267 int id = 0;
10268#ifdef FEAT_SYN_HL
10269 linenr_T lnum;
10270 colnr_T col;
10271 int trans;
10272 int transerr = FALSE;
10273
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010274 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010275 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010276 || check_for_number_arg(argvars, 1) == FAIL
10277 || check_for_bool_arg(argvars, 2) == FAIL))
10278 return;
10279
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010280 lnum = tv_get_lnum(argvars); // -1 on type error
10281 col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaarfcb6d702020-09-05 21:41:56 +020010282 trans = (int)tv_get_bool_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010283
10284 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10285 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000010286 id = syn_get_id(curwin, lnum, col, trans, NULL, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010287#endif
10288
10289 rettv->vval.v_number = id;
10290}
10291
10292/*
10293 * "synIDattr(id, what [, mode])" function
10294 */
10295 static void
10296f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
10297{
10298 char_u *p = NULL;
10299#ifdef FEAT_SYN_HL
10300 int id;
10301 char_u *what;
10302 char_u *mode;
10303 char_u modebuf[NUMBUFLEN];
10304 int modec;
10305
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020010306 if (in_vim9script()
10307 && (check_for_number_arg(argvars, 0) == FAIL
Yegappan Lakshmananf8dbd582021-09-26 19:04:05 +010010308 || check_for_string_arg(argvars, 1) == FAIL
10309 || check_for_opt_string_arg(argvars, 2) == FAIL))
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020010310 return;
10311
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010312 id = (int)tv_get_number(&argvars[0]);
10313 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010314 if (argvars[2].v_type != VAR_UNKNOWN)
10315 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010316 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010317 modec = TOLOWER_ASC(mode[0]);
10318 if (modec != 't' && modec != 'c' && modec != 'g')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010319 modec = 0; // replace invalid with current
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010320 }
10321 else
10322 {
10323#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
10324 if (USE_24BIT)
10325 modec = 'g';
10326 else
10327#endif
10328 if (t_colors > 1)
Dominique Pelle4781d6f2021-05-18 21:46:31 +020010329 modec = 'c';
10330 else
10331 modec = 't';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010332 }
10333
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010334 switch (TOLOWER_ASC(what[0]))
10335 {
10336 case 'b':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010337 if (TOLOWER_ASC(what[1]) == 'g') // bg[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010338 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010339 else // bold
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010340 p = highlight_has_attr(id, HL_BOLD, modec);
10341 break;
10342
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010343 case 'f': // fg[#] or font
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010344 p = highlight_color(id, what, modec);
10345 break;
10346
10347 case 'i':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010348 if (TOLOWER_ASC(what[1]) == 'n') // inverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010349 p = highlight_has_attr(id, HL_INVERSE, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010350 else // italic
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010351 p = highlight_has_attr(id, HL_ITALIC, modec);
10352 break;
10353
Martin Tournoijba43e762022-10-13 22:12:15 +010010354 case 'n':
Bram Moolenaarde786322022-07-30 14:56:17 +010010355 if (TOLOWER_ASC(what[1]) == 'o') // nocombine
10356 p = highlight_has_attr(id, HL_NOCOMBINE, modec);
10357 else // name
10358 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010359 break;
10360
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010361 case 'r': // reverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010362 p = highlight_has_attr(id, HL_INVERSE, modec);
10363 break;
10364
10365 case 's':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010366 if (TOLOWER_ASC(what[1]) == 'p') // sp[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010367 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010368 // strikeout
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +020010369 else if (TOLOWER_ASC(what[1]) == 't' &&
10370 TOLOWER_ASC(what[2]) == 'r')
10371 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010372 else // standout
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010373 p = highlight_has_attr(id, HL_STANDOUT, modec);
10374 break;
10375
10376 case 'u':
Bram Moolenaar84f54632022-06-29 18:39:11 +010010377 if (STRLEN(what) >= 9)
10378 {
10379 if (TOLOWER_ASC(what[5]) == 'l')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010380 // underline
Bram Moolenaar84f54632022-06-29 18:39:11 +010010381 p = highlight_has_attr(id, HL_UNDERLINE, modec);
10382 else if (TOLOWER_ASC(what[5]) != 'd')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010383 // undercurl
Bram Moolenaar84f54632022-06-29 18:39:11 +010010384 p = highlight_has_attr(id, HL_UNDERCURL, modec);
10385 else if (TOLOWER_ASC(what[6]) != 'o')
10386 // underdashed
10387 p = highlight_has_attr(id, HL_UNDERDASHED, modec);
10388 else if (TOLOWER_ASC(what[7]) == 'u')
10389 // underdouble
10390 p = highlight_has_attr(id, HL_UNDERDOUBLE, modec);
10391 else
10392 // underdotted
10393 p = highlight_has_attr(id, HL_UNDERDOTTED, modec);
10394 }
10395 else
10396 // ul
10397 p = highlight_color(id, what, modec);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010398 break;
10399 }
10400
10401 if (p != NULL)
10402 p = vim_strsave(p);
10403#endif
10404 rettv->v_type = VAR_STRING;
10405 rettv->vval.v_string = p;
10406}
10407
10408/*
10409 * "synIDtrans(id)" function
10410 */
10411 static void
10412f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
10413{
10414 int id;
10415
10416#ifdef FEAT_SYN_HL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010417 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
10418 return;
10419
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010420 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010421
10422 if (id > 0)
10423 id = syn_get_final_id(id);
10424 else
10425#endif
10426 id = 0;
10427
10428 rettv->vval.v_number = id;
10429}
10430
10431/*
10432 * "synconcealed(lnum, col)" function
10433 */
10434 static void
10435f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
10436{
10437#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
10438 linenr_T lnum;
10439 colnr_T col;
10440 int syntax_flags = 0;
10441 int cchar;
10442 int matchid = 0;
10443 char_u str[NUMBUFLEN];
10444#endif
10445
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010446 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010447
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010448 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010449 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010450 || check_for_number_arg(argvars, 1) == FAIL))
10451 return;
10452
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010453#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010454 lnum = tv_get_lnum(argvars); // -1 on type error
10455 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010456
Bram Moolenaara80faa82020-04-12 19:37:17 +020010457 CLEAR_FIELD(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010458
Bram Moolenaar93a10962022-06-16 11:42:09 +010010459 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010460 {
10461 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10462 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
10463 && curwin->w_p_cole > 0)
10464 {
10465 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
10466 syntax_flags = get_syntax_info(&matchid);
10467
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010468 // get the conceal character
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010469 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
10470 {
10471 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +020010472 if (cchar == NUL && curwin->w_p_cole == 1)
Bram Moolenaareed9d462021-02-15 20:38:25 +010010473 cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' '
10474 : curwin->w_lcs_chars.conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010475 if (cchar != NUL)
10476 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010477 if (has_mbyte)
10478 (*mb_char2bytes)(cchar, str);
10479 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010480 str[0] = cchar;
10481 }
10482 }
10483 }
10484
10485 list_append_number(rettv->vval.v_list,
10486 (syntax_flags & HL_CONCEAL) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010487 // -1 to auto-determine strlen
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010488 list_append_string(rettv->vval.v_list, str, -1);
10489 list_append_number(rettv->vval.v_list, matchid);
10490 }
10491#endif
10492}
10493
10494/*
10495 * "synstack(lnum, col)" function
10496 */
10497 static void
10498f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
10499{
10500#ifdef FEAT_SYN_HL
10501 linenr_T lnum;
10502 colnr_T col;
10503 int i;
10504 int id;
10505#endif
10506
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010507 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010508
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010509 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010510 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010511 || check_for_number_arg(argvars, 1) == FAIL))
10512 return;
10513
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010514#ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010515 lnum = tv_get_lnum(argvars); // -1 on type error
10516 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010517
10518 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10519 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
Bram Moolenaar93a10962022-06-16 11:42:09 +010010520 && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010521 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000010522 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010523 for (i = 0; ; ++i)
10524 {
10525 id = syn_get_stack_item(i);
10526 if (id < 0)
10527 break;
10528 if (list_append_number(rettv->vval.v_list, id) == FAIL)
10529 break;
10530 }
10531 }
10532#endif
10533}
10534
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010535/*
10536 * "tabpagebuflist()" function
10537 */
10538 static void
10539f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10540{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010541 tabpage_T *tp;
10542 win_T *wp = NULL;
10543
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010544 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
10545 return;
10546
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010547 if (argvars[0].v_type == VAR_UNKNOWN)
10548 wp = firstwin;
10549 else
10550 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010551 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010552 if (tp != NULL)
10553 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
10554 }
Bram Moolenaar93a10962022-06-16 11:42:09 +010010555 if (wp != NULL && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010556 {
10557 for (; wp != NULL; wp = wp->w_next)
10558 if (list_append_number(rettv->vval.v_list,
10559 wp->w_buffer->b_fnum) == FAIL)
10560 break;
10561 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010562}
10563
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010564/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010565 * "tagfiles()" function
10566 */
10567 static void
10568f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
10569{
10570 char_u *fname;
10571 tagname_T tn;
10572 int first;
10573
10574 if (rettv_list_alloc(rettv) == FAIL)
10575 return;
10576 fname = alloc(MAXPATHL);
10577 if (fname == NULL)
10578 return;
10579
10580 for (first = TRUE; ; first = FALSE)
10581 if (get_tagfname(&tn, first, fname) == FAIL
10582 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
10583 break;
10584 tagname_free(&tn);
10585 vim_free(fname);
10586}
10587
10588/*
10589 * "taglist()" function
10590 */
10591 static void
10592f_taglist(typval_T *argvars, typval_T *rettv)
10593{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010594 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010595 char_u *tag_pattern;
10596
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010597 if (in_vim9script()
10598 && (check_for_string_arg(argvars, 0) == FAIL
10599 || check_for_opt_string_arg(argvars, 1) == FAIL))
10600 return;
10601
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010602 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010603
10604 rettv->vval.v_number = FALSE;
10605 if (*tag_pattern == NUL)
10606 return;
10607
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010608 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010609 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010610 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010611 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010612}
10613
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010614/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010615 * "type(expr)" function
10616 */
10617 static void
10618f_type(typval_T *argvars, typval_T *rettv)
10619{
10620 int n = -1;
10621
10622 switch (argvars[0].v_type)
10623 {
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010624 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
10625 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010626 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010627 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
10628 case VAR_LIST: n = VAR_TYPE_LIST; break;
10629 case VAR_DICT: n = VAR_TYPE_DICT; break;
10630 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
10631 case VAR_BOOL: n = VAR_TYPE_BOOL; break;
10632 case VAR_SPECIAL: n = VAR_TYPE_NONE; break;
Bram Moolenaarf562e722016-07-19 17:25:25 +020010633 case VAR_JOB: n = VAR_TYPE_JOB; break;
10634 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010010635 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaarf18332f2021-05-07 17:55:55 +020010636 case VAR_INSTR: n = VAR_TYPE_INSTR; break;
Bram Moolenaar00b28d62022-12-08 15:32:33 +000010637 case VAR_CLASS: n = VAR_TYPE_CLASS; break;
10638 case VAR_OBJECT: n = VAR_TYPE_OBJECT; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010639 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +020010640 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010641 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +010010642 internal_error_no_abort("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010643 n = -1;
10644 break;
10645 }
10646 rettv->vval.v_number = n;
10647}
10648
10649/*
LemonBoy0f7a3e12022-05-26 12:10:37 +010010650 * "virtcol(string, bool)" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010651 */
10652 static void
10653f_virtcol(typval_T *argvars, typval_T *rettv)
10654{
LemonBoy0f7a3e12022-05-26 12:10:37 +010010655 colnr_T vcol_start = 0;
10656 colnr_T vcol_end = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010657 pos_T *fp;
10658 int fnum = curbuf->b_fnum;
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010659 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010660
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010661 if (in_vim9script()
LemonBoy0f7a3e12022-05-26 12:10:37 +010010662 && (check_for_string_or_list_arg(argvars, 0) == FAIL
10663 || (argvars[1].v_type != VAR_UNKNOWN
10664 && check_for_bool_arg(argvars, 1) == FAIL)))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010665 return;
10666
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010667 fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010668 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
LemonBoy0f7a3e12022-05-26 12:10:37 +010010669 && fnum == curbuf->b_fnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010670 {
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010671 // Limit the column to a valid value, getvvcol() doesn't check.
10672 if (fp->col < 0)
10673 fp->col = 0;
10674 else
10675 {
10676 len = (int)STRLEN(ml_get(fp->lnum));
10677 if (fp->col > len)
10678 fp->col = len;
10679 }
LemonBoy0f7a3e12022-05-26 12:10:37 +010010680 getvvcol(curwin, fp, &vcol_start, NULL, &vcol_end);
10681 ++vcol_start;
10682 ++vcol_end;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010683 }
10684
LemonBoy0f7a3e12022-05-26 12:10:37 +010010685 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
10686 {
10687 if (rettv_list_alloc(rettv) == OK)
10688 {
10689 list_append_number(rettv->vval.v_list, vcol_start);
10690 list_append_number(rettv->vval.v_list, vcol_end);
10691 }
10692 else
10693 rettv->vval.v_number = 0;
10694 }
10695 else
10696 rettv->vval.v_number = vcol_end;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010697}
10698
10699/*
10700 * "visualmode()" function
10701 */
10702 static void
10703f_visualmode(typval_T *argvars, typval_T *rettv)
10704{
10705 char_u str[2];
10706
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010707 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
10708 return;
10709
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010710 rettv->v_type = VAR_STRING;
10711 str[0] = curbuf->b_visual_mode_eval;
10712 str[1] = NUL;
10713 rettv->vval.v_string = vim_strsave(str);
10714
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010715 // A non-zero number or non-empty string argument: reset mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010716 if (non_zero_arg(&argvars[0]))
10717 curbuf->b_visual_mode_eval = NUL;
10718}
10719
10720/*
10721 * "wildmenumode()" function
10722 */
10723 static void
10724f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10725{
Bram Moolenaar24959102022-05-07 20:01:16 +010010726 if (wild_menu_showing || ((State & MODE_CMDLINE) && cmdline_pum_active()))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010727 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010728}
10729
10730/*
Bram Moolenaar0c1e3742019-12-27 13:49:24 +010010731 * "windowsversion()" function
10732 */
10733 static void
10734f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10735{
10736 rettv->v_type = VAR_STRING;
10737 rettv->vval.v_string = vim_strsave((char_u *)windowsVersion);
10738}
10739
10740/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010741 * "wordcount()" function
10742 */
10743 static void
10744f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
10745{
10746 if (rettv_dict_alloc(rettv) == FAIL)
10747 return;
10748 cursor_pos_info(rettv->vval.v_dict);
10749}
10750
10751/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010752 * "xor(expr, expr)" function
10753 */
10754 static void
10755f_xor(typval_T *argvars, typval_T *rettv)
10756{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010757 if (in_vim9script()
10758 && (check_for_number_arg(argvars, 0) == FAIL
10759 || check_for_number_arg(argvars, 1) == FAIL))
10760 return;
10761
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010762 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
10763 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010764}
10765
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010766#endif // FEAT_EVAL