blob: cb038e4c8dadb146f68fe8f8baa934ce540c0e17 [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);
78static void f_hasmapto(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020079static void f_hlID(typval_T *argvars, typval_T *rettv);
80static void f_hlexists(typval_T *argvars, typval_T *rettv);
81static void f_hostname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020082static void f_index(typval_T *argvars, typval_T *rettv);
83static 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);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020092static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
93static void f_len(typval_T *argvars, typval_T *rettv);
94static 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 Moolenaar00f123a2018-08-21 20:28:54 +0200171static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200172static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200173static void f_synID(typval_T *argvars, typval_T *rettv);
174static void f_synIDattr(typval_T *argvars, typval_T *rettv);
175static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
176static void f_synstack(typval_T *argvars, typval_T *rettv);
177static void f_synconcealed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200178static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200179static void f_taglist(typval_T *argvars, typval_T *rettv);
180static void f_tagfiles(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200181static void f_type(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200182static void f_virtcol(typval_T *argvars, typval_T *rettv);
183static void f_visualmode(typval_T *argvars, typval_T *rettv);
184static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0c1e3742019-12-27 13:49:24 +0100185static void f_windowsversion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200186static void f_wordcount(typval_T *argvars, typval_T *rettv);
187static void f_xor(typval_T *argvars, typval_T *rettv);
188
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100189
Bram Moolenaar94738d82020-10-21 14:25:07 +0200190/*
191 * Functions that check the argument type of a builtin function.
192 * Each function returns FAIL and gives an error message if the type is wrong.
193 */
194
195// Context passed to an arg_ function.
196typedef struct {
Bram Moolenaarca174532020-10-21 16:42:22 +0200197 int arg_count; // actual argument count
Bram Moolenaar078a4612022-01-04 15:17:03 +0000198 type2_T *arg_types; // list of argument types
Bram Moolenaarca174532020-10-21 16:42:22 +0200199 int arg_idx; // current argument index (first arg is zero)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100200 cctx_T *arg_cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +0200201} argcontext_T;
202
203// A function to check one argument type. The first argument is the type to
204// check. If needed, other argument types can be obtained with the context.
205// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.
Bram Moolenaar078a4612022-01-04 15:17:03 +0000206typedef int (*argcheck_T)(type_T *, type_T *, argcontext_T *);
Bram Moolenaar94738d82020-10-21 14:25:07 +0200207
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100208/*
Bram Moolenaar351ead02021-01-16 16:07:01 +0100209 * Call need_type() to check an argument type.
210 */
211 static int
212check_arg_type(
213 type_T *expected,
214 type_T *actual,
215 argcontext_T *context)
216{
217 // TODO: would be useful to know if "actual" is a constant and pass it to
218 // need_type() to get a compile time error if possible.
219 return need_type(actual, expected,
220 context->arg_idx - context->arg_count, context->arg_idx + 1,
221 context->arg_cctx, FALSE, FALSE);
222}
223
224/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100225 * Check "type" is a float or a number.
226 */
Bram Moolenaar94738d82020-10-21 14:25:07 +0200227 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000228arg_float_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200229{
Bram Moolenaarca174532020-10-21 16:42:22 +0200230 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000231 || type->tt_type == VAR_UNKNOWN
232 || type->tt_type == VAR_FLOAT
233 || type->tt_type == VAR_NUMBER)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200234 return OK;
235 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
236 return FAIL;
237}
238
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100239/*
240 * Check "type" is a number.
241 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200242 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000243arg_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200244{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100245 return check_arg_type(&t_number, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200246}
247
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100248/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200249 * Check "type" is a dict of 'any'.
250 */
251 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000252arg_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200253{
254 return check_arg_type(&t_dict_any, type, context);
255}
256
257/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200258 * Check "type" is a list of 'any'.
259 */
260 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000261arg_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200262{
263 return check_arg_type(&t_list_any, type, context);
264}
265
266/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200267 * Check "type" is a list of numbers.
268 */
269 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000270arg_list_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200271{
272 return check_arg_type(&t_list_number, type, context);
273}
274
275/*
276 * Check "type" is a list of strings.
277 */
278 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000279arg_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200280{
281 return check_arg_type(&t_list_string, type, context);
282}
283
284/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100285 * Check "type" is a string.
286 */
287 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000288arg_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100289{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100290 return check_arg_type(&t_string, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100291}
292
293/*
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200294 * Check "type" is a blob
295 */
296 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000297arg_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200298{
299 return check_arg_type(&t_blob, type, context);
300}
301
302/*
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100303 * Check "type" is a bool or number 0 or 1.
304 */
305 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000306arg_bool(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100307{
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100308 return check_arg_type(&t_bool, type, context);
309}
310
311/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200312 * Check "type" is a list of 'any' or a blob.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100313 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200314 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000315arg_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200316{
317 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000318 || type->tt_type == VAR_UNKNOWN
319 || type->tt_type == VAR_LIST
320 || type->tt_type == VAR_BLOB)
Bram Moolenaarca174532020-10-21 16:42:22 +0200321 return OK;
322 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
323 return FAIL;
324}
325
326/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200327 * Check "type" is a string or a number
328 */
329 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000330arg_string_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200331{
332 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000333 || type->tt_type == VAR_UNKNOWN
334 || type->tt_type == VAR_STRING
335 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200336 return OK;
337 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
338 return FAIL;
339}
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200340
341/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200342 * Check "type" is a buffer (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200343 */
344 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000345arg_buffer(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200346{
347 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000348 || type->tt_type == VAR_UNKNOWN
349 || type->tt_type == VAR_STRING
350 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200351 return OK;
352 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
353 return FAIL;
354}
355
356/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200357 * Check "type" is a buffer or a dict of any
358 */
359 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000360arg_buffer_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200361{
362 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000363 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200364 || type->tt_type == VAR_STRING
365 || type->tt_type == VAR_NUMBER
366 || type->tt_type == VAR_DICT)
367 return OK;
368 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
369 return FAIL;
370}
371
372/*
373 * Check "type" is a line (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200374 */
375 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000376arg_lnum(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200377{
378 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000379 || type->tt_type == VAR_UNKNOWN
380 || type->tt_type == VAR_STRING
381 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200382 return OK;
383 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
384 return FAIL;
385}
386
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200387/*
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200388 * Check "type" is a string or a list of strings.
389 */
390 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000391arg_string_or_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200392{
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000393 if (type->tt_type == VAR_ANY
394 || type->tt_type == VAR_UNKNOWN
395 || type->tt_type == VAR_STRING)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200396 return OK;
397 if (type->tt_type != VAR_LIST)
398 {
399 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
400 return FAIL;
401 }
402 if (type->tt_member->tt_type == VAR_ANY
403 || type->tt_member->tt_type == VAR_STRING)
404 return OK;
405
406 arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);
407 return FAIL;
408}
409
410/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200411 * Check "type" is a string or a list of 'any'
412 */
413 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000414arg_string_or_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200415{
416 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000417 || type->tt_type == VAR_UNKNOWN
418 || type->tt_type == VAR_STRING
419 || type->tt_type == VAR_LIST)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200420 return OK;
421 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
422 return FAIL;
423}
424
425/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200426 * Check "type" is a string or a blob
427 */
428 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000429arg_string_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200430{
431 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000432 || type->tt_type == VAR_UNKNOWN
433 || type->tt_type == VAR_STRING
434 || type->tt_type == VAR_BLOB)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200435 return OK;
436 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
437 return FAIL;
438}
439
440/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200441 * Check "type" is a list of 'any' or a dict of 'any'.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100442 */
443 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000444arg_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100445{
446 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000447 || type->tt_type == VAR_UNKNOWN
448 || type->tt_type == VAR_LIST
449 || type->tt_type == VAR_DICT)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100450 return OK;
451 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
452 return FAIL;
453}
454
455/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200456 * Check "type" is a list of 'any' or a dict of 'any' or a blob.
457 */
458 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000459arg_list_or_dict_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200460{
461 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000462 || type->tt_type == VAR_UNKNOWN
463 || type->tt_type == VAR_LIST
464 || type->tt_type == VAR_DICT
465 || type->tt_type == VAR_BLOB)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200466 return OK;
467 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
468 return FAIL;
469}
470
471/*
Bram Moolenaar2d877592021-12-16 08:21:09 +0000472 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
473 */
474 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000475arg_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 +0000476{
477 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000478 || type->tt_type == VAR_UNKNOWN
479 || type->tt_type == VAR_LIST
480 || type->tt_type == VAR_DICT
481 || type->tt_type == VAR_BLOB
482 || type->tt_type == VAR_STRING)
Bram Moolenaar2d877592021-12-16 08:21:09 +0000483 return OK;
484 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
485 return FAIL;
486}
487
488/*
Bram Moolenaar18024052021-12-25 21:43:28 +0000489 * Check second argument of filter(): func must return a bool.
490 */
491 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000492arg_filter_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000493{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000494 if (type->tt_type == VAR_STRING
495 || type->tt_type == VAR_PARTIAL
496 || type == &t_unknown
497 || type == &t_any)
498 return OK;
499
500 if (type->tt_type == VAR_FUNC)
501 {
502 if (!(type->tt_member->tt_type == VAR_BOOL
Bram Moolenaar18024052021-12-25 21:43:28 +0000503 || type->tt_member->tt_type == VAR_NUMBER
Bram Moolenaaref8f04b2021-12-27 12:29:19 +0000504 || type->tt_member->tt_type == VAR_UNKNOWN
Bram Moolenaar18024052021-12-25 21:43:28 +0000505 || type->tt_member->tt_type == VAR_ANY))
Bram Moolenaar1080c482022-01-26 18:26:21 +0000506 {
507 arg_type_mismatch(&t_func_bool, type, context->arg_idx + 1);
508 return FAIL;
509 }
510 }
511 else
Bram Moolenaar18024052021-12-25 21:43:28 +0000512 {
Bram Moolenaar1080c482022-01-26 18:26:21 +0000513 semsg(_(e_string_or_function_required_for_argument_nr), 2);
Bram Moolenaar18024052021-12-25 21:43:28 +0000514 return FAIL;
515 }
516 return OK;
517}
518
519/*
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000520 * Check second argument of map(), the function.
Bram Moolenaar18024052021-12-25 21:43:28 +0000521 */
522 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000523arg_map_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000524{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000525 if (type->tt_type == VAR_STRING
526 || type->tt_type == VAR_PARTIAL
527 || type == &t_unknown
528 || type == &t_any)
529 return OK;
530
531 if (type->tt_type == VAR_FUNC)
Bram Moolenaar18024052021-12-25 21:43:28 +0000532 {
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000533 type_T *expected_ret = NULL;
534 type_T *(args[2]);
535 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, NULL, args};
536
537 if (context->arg_types[0].type_curr->tt_type == VAR_LIST
538 || context->arg_types[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaar18024052021-12-25 21:43:28 +0000539 {
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000540 // Use the declared type if possible, so that an error is given if
541 // a declared list changes type, but not if a constant list changes
542 // type.
543 if (context->arg_types[0].type_decl->tt_type == VAR_LIST
544 || context->arg_types[0].type_decl->tt_type == VAR_DICT)
545 expected_ret = context->arg_types[0].type_decl->tt_member;
546 else
547 expected_ret = context->arg_types[0].type_curr->tt_member;
548 }
549 else if (context->arg_types[0].type_curr->tt_type == VAR_STRING)
550 expected_ret = &t_string;
551 else if (context->arg_types[0].type_curr->tt_type == VAR_BLOB)
552 expected_ret = &t_number;
Bram Moolenaar18024052021-12-25 21:43:28 +0000553
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000554 args[0] = NULL;
555 args[1] = &t_unknown;
556 if (type->tt_argcount != -1)
557 {
558 if (!(type->tt_argcount == 2 || (type->tt_argcount == 1
559 && (type->tt_flags & TTFLAG_VARARGS))))
Bram Moolenaar35c807d2022-01-27 16:36:29 +0000560 {
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000561 emsg(_(e_invalid_number_of_arguments));
562 return FAIL;
Bram Moolenaar35c807d2022-01-27 16:36:29 +0000563 }
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000564 if (type->tt_flags & TTFLAG_VARARGS)
565 // check the argument types at runtime
566 t_func_exp.tt_argcount = -1;
567 else
Bram Moolenaar1080c482022-01-26 18:26:21 +0000568 {
Bram Moolenaarc1e6c7b2022-02-20 18:26:46 +0000569 if (context->arg_types[0].type_curr->tt_type == VAR_STRING
570 || context->arg_types[0].type_curr->tt_type == VAR_BLOB
571 || context->arg_types[0].type_curr->tt_type == VAR_LIST)
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000572 args[0] = &t_number;
Bram Moolenaarc2f17f72022-02-21 13:13:50 +0000573 else if (context->arg_types[0].type_decl->tt_type == VAR_DICT)
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000574 args[0] = &t_string;
575 if (args[0] != NULL)
576 args[1] = expected_ret;
577 }
578 }
Bram Moolenaar1080c482022-01-26 18:26:21 +0000579
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000580 if ((type->tt_member != &t_any && type->tt_member != &t_unknown)
581 || args[0] != NULL)
582 {
583 where_T where = WHERE_INIT;
584
585 t_func_exp.tt_member = expected_ret == NULL
586 || type->tt_member == &t_any
587 || type->tt_member == &t_unknown
588 ? &t_any : expected_ret;
589 if (args[0] == NULL)
590 args[0] = &t_unknown;
591 return check_arg_type(&t_func_exp, type, context);
592
593 where.wt_index = 2;
594 return check_type(&t_func_exp, type, TRUE, where);
Bram Moolenaar18024052021-12-25 21:43:28 +0000595 }
596 }
Bram Moolenaar1080c482022-01-26 18:26:21 +0000597 else
598 {
599 semsg(_(e_string_or_function_required_for_argument_nr), 2);
600 return FAIL;
601 }
Bram Moolenaar18024052021-12-25 21:43:28 +0000602 return OK;
603}
604
605/*
Bram Moolenaar73199812021-12-26 17:18:14 +0000606 * Check an expression argument, can be a string, funcref or partial.
607 * Also accept a bool, a constant resulting from compiling a string argument.
608 * Also accept a number, one and zero are accepted.
609 */
610 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000611arg_string_or_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar73199812021-12-26 17:18:14 +0000612{
613 if (type->tt_type == VAR_ANY
614 || type->tt_type == VAR_UNKNOWN
615 || type->tt_type == VAR_STRING
616 || type->tt_type == VAR_PARTIAL
617 || type->tt_type == VAR_FUNC
618 || type->tt_type == VAR_BOOL
619 || type->tt_type == VAR_NUMBER)
620 return OK;
621 arg_type_mismatch(&t_func_any, type, context->arg_idx + 1);
622 return FAIL;
623}
624
625/*
rbtnn0ccb5842021-12-18 18:33:46 +0000626 * Check "type" is a list of 'any' or a blob or a string.
627 */
628 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000629arg_string_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
rbtnn0ccb5842021-12-18 18:33:46 +0000630{
631 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000632 || type->tt_type == VAR_UNKNOWN
633 || type->tt_type == VAR_LIST
634 || type->tt_type == VAR_BLOB
635 || type->tt_type == VAR_STRING)
rbtnn0ccb5842021-12-18 18:33:46 +0000636 return OK;
637 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
638 return FAIL;
639}
640
641/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200642 * Check "type" is a job.
643 */
644 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000645arg_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200646{
647 return check_arg_type(&t_job, type, context);
648}
649
650/*
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200651 * Check "type" is a channel or a job.
652 */
653 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000654arg_chan_or_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200655{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200656 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000657 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200658 || type->tt_type == VAR_CHANNEL
659 || type->tt_type == VAR_JOB)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200660 return OK;
661 arg_type_mismatch(&t_channel, type, context->arg_idx + 1);
662 return FAIL;
663}
664
665/*
Bram Moolenaar078a4612022-01-04 15:17:03 +0000666 * Check "type" can be used as the type_decl of the previous argument.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100667 * Must not be used for the first argcheck_T entry.
668 */
669 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000670arg_same_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100671{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000672 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_decl;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100673
Bram Moolenaar351ead02021-01-16 16:07:01 +0100674 return check_arg_type(prev_type, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100675}
676
677/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100678 * Check "type" is the same basic type as the previous argument, checks list or
679 * dict vs other type, but not member type.
680 * Must not be used for the first argcheck_T entry.
681 */
682 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000683arg_same_struct_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100684{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000685 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100686
Bram Moolenaar078a4612022-01-04 15:17:03 +0000687 if (prev_type->tt_type != context->arg_types[context->arg_idx].type_curr->tt_type)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100688 return check_arg_type(prev_type, type, context);
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100689 return OK;
690}
691
692/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100693 * Check "type" is an item of the list or blob of the previous arg.
Bram Moolenaarca174532020-10-21 16:42:22 +0200694 * Must not be used for the first argcheck_T entry.
695 */
696 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000697arg_item_of_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200698{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000699 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarca174532020-10-21 16:42:22 +0200700 type_T *expected;
701
702 if (prev_type->tt_type == VAR_LIST)
703 expected = prev_type->tt_member;
704 else if (prev_type->tt_type == VAR_BLOB)
705 expected = &t_number;
706 else
707 // probably VAR_ANY, can't check
708 return OK;
709
Bram Moolenaar351ead02021-01-16 16:07:01 +0100710 return check_arg_type(expected, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200711}
712
Bram Moolenaar94738d82020-10-21 14:25:07 +0200713/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200714 * Check "type" is a string or a number or a list
715 */
716 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000717arg_str_or_nr_or_list(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200718{
Yegappan Lakshmanan841e4982021-07-11 22:04:25 +0200719 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000720 || type->tt_type == VAR_UNKNOWN
721 || type->tt_type == VAR_STRING
722 || type->tt_type == VAR_NUMBER
723 || type->tt_type == VAR_LIST)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200724 return OK;
725 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
726 return FAIL;
727}
728
729/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200730 * Check "type" is a dict of 'any' or a string
731 */
732 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000733arg_dict_any_or_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200734{
735 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000736 || type->tt_type == VAR_UNKNOWN
737 || type->tt_type == VAR_DICT
738 || type->tt_type == VAR_STRING)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200739 return OK;
740 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
741 return FAIL;
742}
743
744/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200745 * Check "type" which is the third argument of extend() (number or string or
746 * any)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100747 */
748 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000749arg_extend3(type_T *type, type_T *decl_type, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100750{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000751 type_T *first_type = context->arg_types[context->arg_idx - 2].type_curr;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100752
753 if (first_type->tt_type == VAR_LIST)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000754 return arg_number(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100755 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000756 return arg_string(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100757 return OK;
758}
759
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200760/*
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200761 * Check "type" which is the first argument of get() (blob or list or dict or
762 * funcref)
763 */
764 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000765arg_get1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200766{
767 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000768 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200769 || type->tt_type == VAR_BLOB
770 || type->tt_type == VAR_LIST
771 || type->tt_type == VAR_DICT
772 || type->tt_type == VAR_FUNC
773 || type->tt_type == VAR_PARTIAL)
774 return OK;
775
776 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
777 return FAIL;
778}
779
780/*
781 * Check "type" which is the first argument of len() (number or string or
782 * blob or list or dict)
783 */
784 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000785arg_len1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200786{
787 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000788 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200789 || type->tt_type == VAR_STRING
790 || type->tt_type == VAR_NUMBER
791 || type->tt_type == VAR_BLOB
792 || type->tt_type == VAR_LIST
793 || type->tt_type == VAR_DICT)
794 return OK;
795
796 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
797 return FAIL;
798}
799
800/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200801 * Check "type" which is the second argument of remove() (number or string or
802 * any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200803 */
804 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000805arg_remove2(type_T *type, type_T *decl_type, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200806{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000807 type_T *first_type = context->arg_types[context->arg_idx - 1].type_curr;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200808
809 if (first_type->tt_type == VAR_LIST || first_type->tt_type == VAR_BLOB)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000810 return arg_number(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200811 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000812 return arg_string_or_nr(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200813 return OK;
814}
815
816/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200817 * Check "type" which is the first argument of repeat() (string or number or
818 * list or any)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200819 */
820 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000821arg_repeat1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200822{
823 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000824 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200825 || type->tt_type == VAR_STRING
826 || type->tt_type == VAR_NUMBER
827 || type->tt_type == VAR_LIST)
828 return OK;
829
830 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
831 return FAIL;
832}
833
834/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200835 * Check "type" which is the first argument of slice() (list or blob or string
836 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200837 */
838 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000839arg_slice1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200840{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200841 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000842 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200843 || type->tt_type == VAR_LIST
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200844 || type->tt_type == VAR_BLOB
845 || type->tt_type == VAR_STRING)
846 return OK;
847
848 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
849 return FAIL;
850}
851
852/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200853 * Check "type" which is the first argument of count() (string or list or dict
854 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200855 */
856 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000857arg_count1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200858{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200859 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000860 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200861 || type->tt_type == VAR_STRING
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200862 || type->tt_type == VAR_LIST
863 || type->tt_type == VAR_DICT)
864 return OK;
865
866 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
867 return FAIL;
868}
869
870/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200871 * Check "type" which is the first argument of cursor() (number or string or
872 * list or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200873 */
874 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000875arg_cursor1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200876{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200877 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000878 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200879 || type->tt_type == VAR_NUMBER
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200880 || type->tt_type == VAR_STRING
881 || type->tt_type == VAR_LIST)
882 return OK;
883
884 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
885 return FAIL;
886}
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100887
888/*
Bram Moolenaar94738d82020-10-21 14:25:07 +0200889 * Lists of functions that check the argument types of a builtin function.
890 */
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200891static argcheck_T arg1_blob[] = {arg_blob};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200892static argcheck_T arg1_bool[] = {arg_bool};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200893static argcheck_T arg1_buffer[] = {arg_buffer};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200894static argcheck_T arg1_buffer_or_dict_any[] = {arg_buffer_or_dict_any};
895static argcheck_T arg1_chan_or_job[] = {arg_chan_or_job};
896static argcheck_T arg1_dict_any[] = {arg_dict_any};
897static argcheck_T arg1_dict_or_string[] = {arg_dict_any_or_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200898static argcheck_T arg1_float_or_nr[] = {arg_float_or_nr};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200899static argcheck_T arg1_job[] = {arg_job};
900static argcheck_T arg1_list_any[] = {arg_list_any};
901static argcheck_T arg1_list_number[] = {arg_list_number};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200902static argcheck_T arg1_list_or_blob[] = {arg_list_or_blob};
903static argcheck_T arg1_list_or_dict[] = {arg_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200904static argcheck_T arg1_list_string[] = {arg_list_string};
905static argcheck_T arg1_lnum[] = {arg_lnum};
906static argcheck_T arg1_number[] = {arg_number};
907static argcheck_T arg1_string[] = {arg_string};
908static argcheck_T arg1_string_or_list_any[] = {arg_string_or_list_any};
909static argcheck_T arg1_string_or_list_string[] = {arg_string_or_list_string};
910static argcheck_T arg1_string_or_nr[] = {arg_string_or_nr};
911static argcheck_T arg2_any_buffer[] = {NULL, arg_buffer};
912static argcheck_T arg2_buffer_any[] = {arg_buffer, NULL};
913static argcheck_T arg2_buffer_bool[] = {arg_buffer, arg_bool};
914static argcheck_T arg2_buffer_list_any[] = {arg_buffer, arg_list_any};
915static argcheck_T arg2_buffer_lnum[] = {arg_buffer, arg_lnum};
916static argcheck_T arg2_buffer_number[] = {arg_buffer, arg_number};
917static argcheck_T arg2_buffer_string[] = {arg_buffer, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200918static argcheck_T arg2_chan_or_job_dict[] = {arg_chan_or_job, arg_dict_any};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200919static argcheck_T arg2_chan_or_job_string[] = {arg_chan_or_job, arg_string};
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +0200920static argcheck_T arg2_dict_any_list_any[] = {arg_dict_any, arg_list_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200921static argcheck_T arg2_dict_any_string_or_nr[] = {arg_dict_any, arg_string_or_nr};
922static argcheck_T arg2_dict_string[] = {arg_dict_any, arg_string};
923static argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr};
924static argcheck_T arg2_job_dict[] = {arg_job, arg_dict_any};
925static argcheck_T arg2_job_string_or_number[] = {arg_job, arg_string_or_nr};
926static argcheck_T arg2_list_any_number[] = {arg_list_any, arg_number};
927static argcheck_T arg2_list_any_string[] = {arg_list_any, arg_string};
928static argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number};
929static argcheck_T arg2_list_number_bool[] = {arg_list_number, arg_bool};
930static argcheck_T arg2_listblob_item[] = {arg_list_or_blob, arg_item_of_prev};
931static argcheck_T arg2_lnum[] = {arg_lnum, arg_lnum};
932static argcheck_T arg2_lnum_number[] = {arg_lnum, arg_number};
933static argcheck_T arg2_number[] = {arg_number, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200934static argcheck_T arg2_number_any[] = {arg_number, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200935static argcheck_T arg2_number_bool[] = {arg_number, arg_bool};
936static argcheck_T arg2_number_dict_any[] = {arg_number, arg_dict_any};
937static argcheck_T arg2_number_list[] = {arg_number, arg_list_any};
938static argcheck_T arg2_number_string[] = {arg_number, arg_string};
939static argcheck_T arg2_number_string_or_list[] = {arg_number, arg_string_or_list_any};
940static argcheck_T arg2_str_or_nr_or_list_dict[] = {arg_str_or_nr_or_list, arg_dict_any};
941static argcheck_T arg2_string[] = {arg_string, arg_string};
942static argcheck_T arg2_string_any[] = {arg_string, NULL};
943static argcheck_T arg2_string_bool[] = {arg_string, arg_bool};
944static argcheck_T arg2_string_chan_or_job[] = {arg_string, arg_chan_or_job};
945static argcheck_T arg2_string_dict[] = {arg_string, arg_dict_any};
946static argcheck_T arg2_string_list_number[] = {arg_string, arg_list_number};
947static argcheck_T arg2_string_number[] = {arg_string, arg_number};
948static argcheck_T arg2_string_or_list_dict[] = {arg_string_or_list_any, arg_dict_any};
949static argcheck_T arg2_string_string_or_number[] = {arg_string, arg_string_or_nr};
950static argcheck_T arg3_any_list_dict[] = {NULL, arg_list_any, arg_dict_any};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200951static argcheck_T arg3_buffer_lnum_lnum[] = {arg_buffer, arg_lnum, arg_lnum};
952static argcheck_T arg3_buffer_number_number[] = {arg_buffer, arg_number, arg_number};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200953static argcheck_T arg3_buffer_string_any[] = {arg_buffer, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200954static argcheck_T arg3_buffer_string_dict[] = {arg_buffer, arg_string, arg_dict_any};
955static argcheck_T arg3_dict_number_number[] = {arg_dict_any, arg_number, arg_number};
956static argcheck_T arg3_list_string_dict[] = {arg_list_any, arg_string, arg_dict_any};
957static argcheck_T arg3_lnum_number_bool[] = {arg_lnum, arg_number, arg_bool};
958static argcheck_T arg3_number[] = {arg_number, arg_number, arg_number};
959static argcheck_T arg3_number_any_dict[] = {arg_number, NULL, arg_dict_any};
960static argcheck_T arg3_number_number_dict[] = {arg_number, arg_number, arg_dict_any};
961static argcheck_T arg3_number_string_any[] = {arg_number, arg_string, NULL};
962static argcheck_T arg3_number_string_buffer[] = {arg_number, arg_string, arg_buffer};
963static argcheck_T arg3_number_string_string[] = {arg_number, arg_string, arg_string};
964static argcheck_T arg3_string[] = {arg_string, arg_string, arg_string};
965static argcheck_T arg3_string_any_dict[] = {arg_string, NULL, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200966static argcheck_T arg3_string_any_string[] = {arg_string, NULL, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200967static argcheck_T arg3_string_bool_bool[] = {arg_string, arg_bool, arg_bool};
968static argcheck_T arg3_string_bool_dict[] = {arg_string, arg_bool, arg_dict_any};
969static argcheck_T arg3_string_number_bool[] = {arg_string, arg_number, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200970static argcheck_T arg3_string_string_bool[] = {arg_string, arg_string, arg_bool};
971static argcheck_T arg3_string_string_dict[] = {arg_string, arg_string, arg_dict_any};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +0200972static argcheck_T arg3_string_string_number[] = {arg_string, arg_string, arg_number};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200973static argcheck_T arg4_number_number_string_any[] = {arg_number, arg_number, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200974static argcheck_T arg4_string_string_any_string[] = {arg_string, arg_string, NULL, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200975static argcheck_T arg4_string_string_number_string[] = {arg_string, arg_string, arg_number, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200976/* Function specific argument types (not covered by the above) */
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200977static argcheck_T arg15_assert_fails[] = {arg_string_or_nr, arg_string_or_list_any, NULL, arg_number, arg_string};
978static 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 +0200979static argcheck_T arg4_browse[] = {arg_bool, arg_string, arg_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200980static argcheck_T arg23_chanexpr[] = {arg_chan_or_job, NULL, arg_dict_any};
981static argcheck_T arg23_chanraw[] = {arg_chan_or_job, arg_string_or_blob, arg_dict_any};
982static argcheck_T arg24_count[] = {arg_count1, NULL, arg_bool, arg_number};
983static argcheck_T arg13_cursor[] = {arg_cursor1, arg_number, arg_number};
984static argcheck_T arg12_deepcopy[] = {NULL, arg_bool};
985static argcheck_T arg12_execute[] = {arg_string_or_list_string, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200986static argcheck_T arg23_extend[] = {arg_list_or_dict, arg_same_as_prev, arg_extend3};
987static argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200988static argcheck_T arg23_get[] = {arg_get1, arg_string_or_nr, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200989static argcheck_T arg14_glob[] = {arg_string, arg_bool, arg_bool, arg_bool};
990static argcheck_T arg25_globpath[] = {arg_string, arg_string, arg_bool, arg_bool, arg_bool};
991static argcheck_T arg24_index[] = {arg_list_or_blob, arg_item_of_prev, arg_number, arg_bool};
992static argcheck_T arg23_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200993static argcheck_T arg1_len[] = {arg_len1};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200994static argcheck_T arg3_libcall[] = {arg_string, arg_string, arg_string_or_nr};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200995static argcheck_T arg14_maparg[] = {arg_string, arg_string, arg_bool, arg_bool};
Bram Moolenaar18024052021-12-25 21:43:28 +0000996static argcheck_T arg2_filter[] = {arg_list_or_dict_or_blob_or_string, arg_filter_func};
997static argcheck_T arg2_map[] = {arg_list_or_dict_or_blob_or_string, arg_map_func};
998static argcheck_T arg2_mapnew[] = {arg_list_or_dict_or_blob_or_string, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200999static argcheck_T arg25_matchadd[] = {arg_string, arg_string, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001000static argcheck_T arg25_matchaddpos[] = {arg_string, arg_list_any, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001001static 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 +00001002static argcheck_T arg23_reduce[] = {arg_string_list_or_blob, NULL, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001003static argcheck_T arg24_remote_expr[] = {arg_string, arg_string, arg_string, arg_number};
1004static argcheck_T arg23_remove[] = {arg_list_or_dict_or_blob, arg_remove2, arg_number};
1005static argcheck_T arg2_repeat[] = {arg_repeat1, arg_number};
Bram Moolenaar73199812021-12-26 17:18:14 +00001006static argcheck_T arg15_search[] = {arg_string, arg_string, arg_number, arg_number, arg_string_or_func};
1007static 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 +02001008static argcheck_T arg3_setbufline[] = {arg_buffer, arg_lnum, arg_str_or_nr_or_list};
1009static argcheck_T arg2_setline[] = {arg_lnum, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001010static argcheck_T arg24_setloclist[] = {arg_number, arg_list_any, arg_string, arg_dict_any};
1011static argcheck_T arg13_setqflist[] = {arg_list_any, arg_string, arg_dict_any};
1012static argcheck_T arg23_settagstack[] = {arg_number, arg_dict_any, arg_string};
1013static argcheck_T arg02_sign_getplaced[] = {arg_buffer, arg_dict_any};
1014static argcheck_T arg45_sign_place[] = {arg_number, arg_string, arg_string, arg_buffer, arg_dict_any};
1015static argcheck_T arg23_slice[] = {arg_slice1, arg_number, arg_number};
1016static argcheck_T arg13_sortuniq[] = {arg_list_any, NULL, arg_dict_any};
1017static argcheck_T arg24_strpart[] = {arg_string, arg_number, arg_number, arg_bool};
1018static argcheck_T arg12_system[] = {arg_string, arg_str_or_nr_or_list};
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001019static argcheck_T arg23_win_execute[] = {arg_number, arg_string_or_list_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001020static argcheck_T arg23_writefile[] = {arg_list_or_blob, arg_string, arg_string};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001021static argcheck_T arg24_match_func[] = {arg_string_or_list_any, arg_string, arg_number, arg_number};
Bram Moolenaarcd268012021-07-22 19:11:08 +02001022
Bram Moolenaar94738d82020-10-21 14:25:07 +02001023
1024/*
1025 * Functions that return the return type of a builtin function.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001026 * Note that "argtypes" is NULL if "argcount" is zero.
Bram Moolenaar94738d82020-10-21 14:25:07 +02001027 */
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001028 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001029ret_void(int argcount UNUSED,
1030 type2_T *argtypes UNUSED,
1031 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001032{
1033 return &t_void;
1034}
1035 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001036ret_any(int argcount UNUSED,
1037 type2_T *argtypes UNUSED,
1038 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001039{
1040 return &t_any;
1041}
1042 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001043ret_bool(int argcount UNUSED,
1044 type2_T *argtypes UNUSED,
1045 type_T **decl_type UNUSED)
Bram Moolenaar403dc312020-10-17 19:29:51 +02001046{
1047 return &t_bool;
1048}
1049 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001050ret_number_bool(int argcount UNUSED,
1051 type2_T *argtypes UNUSED,
1052 type_T **decl_type UNUSED)
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001053{
1054 return &t_number_bool;
1055}
1056 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001057ret_number(int argcount UNUSED,
1058 type2_T *argtypes UNUSED,
1059 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001060{
1061 return &t_number;
1062}
1063 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001064ret_float(int argcount UNUSED,
1065 type2_T *argtypes UNUSED,
1066 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001067{
1068 return &t_float;
1069}
1070 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001071ret_string(int argcount UNUSED,
1072 type2_T *argtypes UNUSED,
1073 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001074{
1075 return &t_string;
1076}
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001077 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001078ret_list_any(int argcount UNUSED,
1079 type2_T *argtypes UNUSED,
1080 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001081{
1082 return &t_list_any;
1083}
1084 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001085ret_list_number(int argcount UNUSED,
1086 type2_T *argtypes UNUSED,
Bram Moolenaar81330182022-02-01 12:11:58 +00001087 type_T **decl_type)
1088{
Bram Moolenaar81330182022-02-01 12:11:58 +00001089 *decl_type = &t_list_any;
1090 return &t_list_number;
1091}
1092 static type_T *
1093ret_list_string(int argcount UNUSED,
1094 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001095 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001096{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001097 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001098 return &t_list_string;
1099}
1100 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001101ret_list_dict_any(int argcount UNUSED,
1102 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001103 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001104{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001105 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001106 return &t_list_dict_any;
1107}
1108 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001109ret_list_items(int argcount UNUSED,
1110 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001111 type_T **decl_type)
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001112{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001113 *decl_type = &t_list_any;
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001114 return &t_list_list_any;
1115}
mityu61065042021-07-19 20:07:21 +02001116
1117 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001118ret_list_string_items(int argcount UNUSED,
1119 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001120 type_T **decl_type)
mityu61065042021-07-19 20:07:21 +02001121{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001122 *decl_type = &t_list_any;
mityu61065042021-07-19 20:07:21 +02001123 return &t_list_list_string;
1124}
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001125 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001126ret_dict_any(int argcount UNUSED,
1127 type2_T *argtypes UNUSED,
1128 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001129{
1130 return &t_dict_any;
1131}
1132 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001133ret_job_info(int argcount,
1134 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001135 type_T **decl_type)
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001136{
1137 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001138 {
1139 *decl_type = &t_list_any;
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001140 return &t_list_job;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001141 }
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001142 return &t_dict_any;
1143}
1144 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001145ret_dict_number(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_dict_number;
1150}
1151 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001152ret_dict_string(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_dict_string;
1157}
1158 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001159ret_blob(int argcount UNUSED,
1160 type2_T *argtypes UNUSED,
1161 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001162{
1163 return &t_blob;
1164}
1165 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001166ret_func_any(int argcount UNUSED,
1167 type2_T *argtypes UNUSED,
1168 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001169{
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001170 return &t_func_any;
1171}
1172 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001173ret_func_unknown(int argcount UNUSED,
1174 type2_T *argtypes UNUSED,
1175 type_T **decl_type UNUSED)
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001176{
1177 return &t_func_unknown;
1178}
1179 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001180ret_channel(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_channel;
1185}
1186 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001187ret_job(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_job;
1192}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001193 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001194ret_first_arg(int argcount,
1195 type2_T *argtypes,
1196 type_T **decl_type)
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001197{
1198 if (argcount > 0)
Bram Moolenaar81330182022-02-01 12:11:58 +00001199 {
1200 *decl_type = argtypes[0].type_decl;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001201 return argtypes[0].type_curr;
Bram Moolenaar81330182022-02-01 12:11:58 +00001202 }
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001203 return &t_void;
1204}
Bram Moolenaar1780f082021-07-31 22:03:59 +02001205 static type_T *
Bram Moolenaar00eb9952022-02-05 19:23:18 +00001206ret_slice(int argcount,
1207 type2_T *argtypes,
1208 type_T **decl_type)
1209{
1210 if (argcount > 0)
1211 {
1212 if (argtypes[0].type_decl != NULL)
1213 {
1214 switch (argtypes[0].type_decl->tt_type)
1215 {
1216 case VAR_STRING: *decl_type = &t_string; break;
1217 case VAR_BLOB: *decl_type = &t_blob; break;
1218 case VAR_LIST: *decl_type = &t_list_any; break;
1219 default: break;
1220 }
1221 }
1222 return argtypes[0].type_curr;
1223 }
1224 return &t_void;
1225}
1226 static type_T *
Bram Moolenaar381692b2022-02-02 20:01:27 +00001227ret_copy(int argcount,
1228 type2_T *argtypes,
1229 type_T **decl_type)
1230{
1231 if (argcount > 0)
1232 {
1233 if (argtypes[0].type_decl != NULL)
1234 {
1235 if (argtypes[0].type_decl->tt_type == VAR_LIST)
1236 *decl_type = &t_list_any;
1237 else if (argtypes[0].type_decl->tt_type == VAR_DICT)
1238 *decl_type = &t_dict_any;
1239 else
1240 *decl_type = argtypes[0].type_decl;
1241 }
1242 if (argtypes[0].type_curr != NULL)
1243 {
1244 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1245 return &t_list_any;
1246 else if (argtypes[0].type_curr->tt_type == VAR_DICT)
1247 return &t_dict_any;
1248 }
1249 return argtypes[0].type_curr;
1250 }
1251 return &t_void;
1252}
1253 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001254ret_extend(int argcount,
1255 type2_T *argtypes,
1256 type_T **decl_type)
1257{
1258 if (argcount > 0)
1259 {
1260 *decl_type = argtypes[0].type_decl;
1261 // if the second argument has a different current type then the current
1262 // type is "any"
1263 if (argcount > 1 && !equal_type(argtypes[0].type_curr,
1264 argtypes[1].type_curr, 0))
1265 {
1266 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1267 return &t_list_any;
1268 if (argtypes[0].type_curr->tt_type == VAR_DICT)
1269 return &t_dict_any;
1270 }
1271 return argtypes[0].type_curr;
1272 }
1273 return &t_void;
1274}
1275 static type_T *
1276ret_repeat(int argcount,
1277 type2_T *argtypes,
1278 type_T **decl_type UNUSED)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001279{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001280 if (argcount == 0)
1281 return &t_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001282 if (argtypes[0].type_curr == &t_number)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001283 return &t_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001284 return argtypes[0].type_curr;
Bram Moolenaar1780f082021-07-31 22:03:59 +02001285}
Bram Moolenaarea696852020-11-09 18:31:39 +01001286// for map(): returns first argument but item type may differ
1287 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001288ret_first_cont(int argcount,
1289 type2_T *argtypes,
1290 type_T **decl_type UNUSED)
Bram Moolenaarea696852020-11-09 18:31:39 +01001291{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001292 if (argcount > 0)
1293 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001294 if (argtypes[0].type_curr->tt_type == VAR_LIST)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001295 return &t_list_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001296 if (argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001297 return &t_dict_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001298 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
1299 return argtypes[0].type_curr;
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001300 }
Bram Moolenaarea696852020-11-09 18:31:39 +01001301 return &t_any;
1302}
Bram Moolenaar078a4612022-01-04 15:17:03 +00001303// for getline()
1304 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001305ret_getline(int argcount,
1306 type2_T *argtypes UNUSED,
1307 type_T **decl_type UNUSED)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001308{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001309 if (argcount == 1)
1310 return &t_string;
1311 *decl_type = &t_list_any;
1312 return &t_list_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001313}
Bram Moolenaar08018222021-12-22 18:45:37 +00001314// for finddir()
1315 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001316ret_finddir(int argcount,
1317 type2_T *argtypes UNUSED,
1318 type_T **decl_type UNUSED)
Bram Moolenaar08018222021-12-22 18:45:37 +00001319{
1320 if (argcount < 3)
1321 return &t_string;
1322 // Depending on the count would be a string or a list of strings.
1323 return &t_any;
1324}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001325
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001326/*
1327 * Used for getqflist(): returns list if there is no argument, dict if there is
1328 * one.
1329 */
1330 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001331ret_list_or_dict_0(int argcount,
1332 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001333 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001334{
1335 if (argcount > 0)
1336 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001337 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001338 return &t_list_dict_any;
1339}
1340
1341/*
1342 * Used for getloclist(): returns list if there is one argument, dict if there
1343 * are two.
1344 */
1345 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001346ret_list_or_dict_1(int argcount,
1347 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001348 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001349{
1350 if (argcount > 1)
1351 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001352 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001353 return &t_list_dict_any;
1354}
1355
Bram Moolenaar846178a2020-07-05 17:04:13 +02001356 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001357ret_argv(int argcount,
1358 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001359 type_T **decl_type)
Bram Moolenaar846178a2020-07-05 17:04:13 +02001360{
1361 // argv() returns list of strings
1362 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001363 {
1364 *decl_type = &t_list_any;
Bram Moolenaar846178a2020-07-05 17:04:13 +02001365 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001366 }
Bram Moolenaar846178a2020-07-05 17:04:13 +02001367
1368 // argv(0) returns a string, but argv(-1] returns a list
1369 return &t_any;
1370}
1371
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001372 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001373ret_remove(int argcount,
1374 type2_T *argtypes,
1375 type_T **decl_type UNUSED)
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001376{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001377 if (argcount > 0)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001378 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001379 if (argtypes[0].type_curr->tt_type == VAR_LIST
1380 || argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaar81330182022-02-01 12:11:58 +00001381 {
1382 if (argtypes[0].type_curr->tt_type
1383 == argtypes[0].type_decl->tt_type)
1384 *decl_type = argtypes[0].type_decl->tt_member;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001385 return argtypes[0].type_curr->tt_member;
Bram Moolenaar81330182022-02-01 12:11:58 +00001386 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001387 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001388 return &t_number;
1389 }
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001390 return &t_any;
1391}
1392
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001393 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001394ret_getreg(int argcount,
1395 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001396 type_T **decl_type)
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001397{
1398 // Assume that if the third argument is passed it's non-zero
1399 if (argcount == 3)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001400 {
1401 *decl_type = &t_list_any;
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001402 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001403 }
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001404 return &t_string;
1405}
1406
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001407 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001408ret_maparg(int argcount,
1409 type2_T *argtypes UNUSED,
1410 type_T **decl_type UNUSED)
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001411{
1412 // Assume that if the fourth argument is passed it's non-zero
1413 if (argcount == 4)
1414 return &t_dict_any;
1415 return &t_string;
1416}
1417
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001418/*
1419 * Array with names and number of arguments of all internal functions
1420 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
1421 */
Bram Moolenaarac92e252019-08-03 21:58:38 +02001422typedef struct
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001423{
Bram Moolenaar25e42232019-08-04 15:04:10 +02001424 char *f_name; // function name
1425 char f_min_argc; // minimal number of arguments
1426 char f_max_argc; // maximal number of arguments
1427 char f_argtype; // for method: FEARG_ values
Bram Moolenaar94738d82020-10-21 14:25:07 +02001428 argcheck_T *f_argcheck; // list of functions to check argument types
Bram Moolenaar81330182022-02-01 12:11:58 +00001429 type_T *(*f_retfunc)(int argcount, type2_T *argtypes,
1430 type_T **decl_type);
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001431 // return type function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001432 void (*f_func)(typval_T *args, typval_T *rvar);
Bram Moolenaar25e42232019-08-04 15:04:10 +02001433 // implementation of function
Bram Moolenaarac92e252019-08-03 21:58:38 +02001434} funcentry_T;
1435
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001436// values for f_argtype; zero means it cannot be used as a method
1437#define FEARG_1 1 // base is the first argument
1438#define FEARG_2 2 // base is the second argument
Bram Moolenaar24278d22019-08-16 21:49:22 +02001439#define FEARG_3 3 // base is the third argument
Bram Moolenaaraad222c2019-09-06 22:46:09 +02001440#define FEARG_4 4 // base is the fourth argument
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001441
Bram Moolenaar15c47602020-03-26 22:16:48 +01001442#ifdef FEAT_FLOAT
1443# define FLOAT_FUNC(name) name
1444#else
1445# define FLOAT_FUNC(name) NULL
1446#endif
1447#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
1448# define MATH_FUNC(name) name
1449#else
1450# define MATH_FUNC(name) NULL
1451#endif
1452#ifdef FEAT_TIMERS
1453# define TIMER_FUNC(name) name
1454#else
1455# define TIMER_FUNC(name) NULL
1456#endif
1457#ifdef FEAT_JOB_CHANNEL
1458# define JOB_FUNC(name) name
1459#else
1460# define JOB_FUNC(name) NULL
1461#endif
1462#ifdef FEAT_PROP_POPUP
1463# define PROP_FUNC(name) name
1464#else
1465# define PROP_FUNC(name) NULL
1466#endif
1467#ifdef FEAT_SIGNS
1468# define SIGN_FUNC(name) name
1469#else
1470# define SIGN_FUNC(name) NULL
1471#endif
1472#ifdef FEAT_SOUND
1473# define SOUND_FUNC(name) name
1474#else
1475# define SOUND_FUNC(name) NULL
1476#endif
1477#ifdef FEAT_TERMINAL
1478# define TERM_FUNC(name) name
1479#else
1480# define TERM_FUNC(name) NULL
1481#endif
1482
Bram Moolenaarac92e252019-08-03 21:58:38 +02001483static funcentry_T global_functions[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001484{
Bram Moolenaar94738d82020-10-21 14:25:07 +02001485 {"abs", 1, 1, FEARG_1, arg1_float_or_nr,
1486 ret_any, FLOAT_FUNC(f_abs)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001487 {"acos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001488 ret_float, FLOAT_FUNC(f_acos)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001489 {"add", 2, 2, FEARG_1, arg2_listblob_item,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001490 ret_first_arg, f_add},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001491 {"and", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001492 ret_number, f_and},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001493 {"append", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001494 ret_number_bool, f_append},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001495 {"appendbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001496 ret_number_bool, f_appendbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001497 {"argc", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001498 ret_number, f_argc},
1499 {"argidx", 0, 0, 0, NULL,
1500 ret_number, f_argidx},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001501 {"arglistid", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001502 ret_number, f_arglistid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001503 {"argv", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001504 ret_argv, f_argv},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001505 {"asin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001506 ret_float, FLOAT_FUNC(f_asin)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001507 {"assert_beeps", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001508 ret_number_bool, f_assert_beeps},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001509 {"assert_equal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001510 ret_number_bool, f_assert_equal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001511 {"assert_equalfile", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001512 ret_number_bool, f_assert_equalfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001513 {"assert_exception", 1, 2, 0, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001514 ret_number_bool, f_assert_exception},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001515 {"assert_fails", 1, 5, FEARG_1, arg15_assert_fails,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001516 ret_number_bool, f_assert_fails},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001517 {"assert_false", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001518 ret_number_bool, f_assert_false},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001519 {"assert_inrange", 3, 4, FEARG_3, arg34_assert_inrange,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001520 ret_number_bool, f_assert_inrange},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001521 {"assert_match", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001522 ret_number_bool, f_assert_match},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001523 {"assert_nobeep", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar5b8cabf2021-04-02 18:55:57 +02001524 ret_number_bool, f_assert_nobeep},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001525 {"assert_notequal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001526 ret_number_bool, f_assert_notequal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001527 {"assert_notmatch", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001528 ret_number_bool, f_assert_notmatch},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001529 {"assert_report", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001530 ret_number_bool, f_assert_report},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001531 {"assert_true", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001532 ret_number_bool, f_assert_true},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001533 {"atan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001534 ret_float, FLOAT_FUNC(f_atan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001535 {"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001536 ret_float, FLOAT_FUNC(f_atan2)},
1537 {"balloon_gettext", 0, 0, 0, NULL,
1538 ret_string,
Bram Moolenaar59716a22017-03-01 20:32:44 +01001539#ifdef FEAT_BEVAL
Bram Moolenaar15c47602020-03-26 22:16:48 +01001540 f_balloon_gettext
1541#else
1542 NULL
Bram Moolenaar59716a22017-03-01 20:32:44 +01001543#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001544 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001545 {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001546 ret_void,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001547#ifdef FEAT_BEVAL
1548 f_balloon_show
1549#else
1550 NULL
1551#endif
1552 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001553 {"balloon_split", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001554 ret_list_string,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001555#if defined(FEAT_BEVAL_TERM)
1556 f_balloon_split
1557#else
1558 NULL
1559#endif
1560 },
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001561 {"blob2list", 1, 1, FEARG_1, arg1_blob,
1562 ret_list_number, f_blob2list},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001563 {"browse", 4, 4, 0, arg4_browse,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001564 ret_string, f_browse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001565 {"browsedir", 2, 2, 0, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001566 ret_string, f_browsedir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001567 {"bufadd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001568 ret_number, f_bufadd},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001569 {"bufexists", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001570 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001571 {"buffer_exists", 1, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001572 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001573 {"buffer_name", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001574 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001575 {"buffer_number", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001576 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001577 {"buflisted", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001578 ret_number_bool, f_buflisted},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001579 {"bufload", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001580 ret_void, f_bufload},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001581 {"bufloaded", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001582 ret_number_bool, f_bufloaded},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001583 {"bufname", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001584 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001585 {"bufnr", 0, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001586 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001587 {"bufwinid", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001588 ret_number, f_bufwinid},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001589 {"bufwinnr", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001590 ret_number, f_bufwinnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001591 {"byte2line", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001592 ret_number, f_byte2line},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001593 {"byteidx", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001594 ret_number, f_byteidx},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001595 {"byteidxcomp", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001596 ret_number, f_byteidxcomp},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001597 {"call", 2, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001598 ret_any, f_call},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001599 {"ceil", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001600 ret_float, FLOAT_FUNC(f_ceil)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001601 {"ch_canread", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001602 ret_number_bool, JOB_FUNC(f_ch_canread)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001603 {"ch_close", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001604 ret_void, JOB_FUNC(f_ch_close)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001605 {"ch_close_in", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001606 ret_void, JOB_FUNC(f_ch_close_in)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001607 {"ch_evalexpr", 2, 3, FEARG_1, arg23_chanexpr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001608 ret_any, JOB_FUNC(f_ch_evalexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001609 {"ch_evalraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001610 ret_any, JOB_FUNC(f_ch_evalraw)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001611 {"ch_getbufnr", 2, 2, FEARG_1, arg2_chan_or_job_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001612 ret_number, JOB_FUNC(f_ch_getbufnr)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001613 {"ch_getjob", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001614 ret_job, JOB_FUNC(f_ch_getjob)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001615 {"ch_info", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001616 ret_dict_any, JOB_FUNC(f_ch_info)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001617 {"ch_log", 1, 2, FEARG_1, arg2_string_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001618 ret_void, JOB_FUNC(f_ch_log)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001619 {"ch_logfile", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001620 ret_void, JOB_FUNC(f_ch_logfile)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001621 {"ch_open", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001622 ret_channel, JOB_FUNC(f_ch_open)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001623 {"ch_read", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001624 ret_string, JOB_FUNC(f_ch_read)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001625 {"ch_readblob", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001626 ret_blob, JOB_FUNC(f_ch_readblob)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001627 {"ch_readraw", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001628 ret_string, JOB_FUNC(f_ch_readraw)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001629 {"ch_sendexpr", 2, 3, FEARG_1, arg23_chanexpr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001630 ret_void, JOB_FUNC(f_ch_sendexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001631 {"ch_sendraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001632 ret_void, JOB_FUNC(f_ch_sendraw)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001633 {"ch_setoptions", 2, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001634 ret_void, JOB_FUNC(f_ch_setoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001635 {"ch_status", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001636 ret_string, JOB_FUNC(f_ch_status)},
1637 {"changenr", 0, 0, 0, NULL,
1638 ret_number, f_changenr},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001639 {"char2nr", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001640 ret_number, f_char2nr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001641 {"charclass", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001642 ret_number, f_charclass},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001643 {"charcol", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001644 ret_number, f_charcol},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001645 {"charidx", 2, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001646 ret_number, f_charidx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001647 {"chdir", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001648 ret_string, f_chdir},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001649 {"cindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001650 ret_number, f_cindent},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001651 {"clearmatches", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001652 ret_void, f_clearmatches},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001653 {"col", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001654 ret_number, f_col},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001655 {"complete", 2, 2, FEARG_2, arg2_number_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001656 ret_void, f_complete},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001657 {"complete_add", 1, 1, FEARG_1, arg1_dict_or_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001658 ret_number, f_complete_add},
1659 {"complete_check", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001660 ret_number_bool, f_complete_check},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001661 {"complete_info", 0, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001662 ret_dict_any, f_complete_info},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001663 {"confirm", 1, 4, FEARG_1, arg4_string_string_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001664 ret_number, f_confirm},
1665 {"copy", 1, 1, FEARG_1, NULL,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001666 ret_copy, f_copy},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001667 {"cos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001668 ret_float, FLOAT_FUNC(f_cos)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001669 {"cosh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001670 ret_float, FLOAT_FUNC(f_cosh)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001671 {"count", 2, 4, FEARG_1, arg24_count,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001672 ret_number, f_count},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001673 {"cscope_connection",0,3, 0, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001674 ret_number, f_cscope_connection},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001675 {"cursor", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001676 ret_number, f_cursor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001677 {"debugbreak", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001678 ret_number,
Bram Moolenaar4f974752019-02-17 17:44:42 +01001679#ifdef MSWIN
Bram Moolenaar15c47602020-03-26 22:16:48 +01001680 f_debugbreak
1681#else
1682 NULL
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02001683#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001684 },
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001685 {"deepcopy", 1, 2, FEARG_1, arg12_deepcopy,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001686 ret_copy, f_deepcopy},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001687 {"delete", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001688 ret_number_bool, f_delete},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001689 {"deletebufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001690 ret_number_bool, f_deletebufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001691 {"did_filetype", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001692 ret_number_bool, f_did_filetype},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001693 {"diff_filler", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001694 ret_number, f_diff_filler},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001695 {"diff_hlID", 2, 2, FEARG_1, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001696 ret_number, f_diff_hlID},
h-east29b85712021-07-26 21:54:04 +02001697 {"digraph_get", 1, 1, FEARG_1, arg1_string,
1698 ret_string, f_digraph_get},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001699 {"digraph_getlist",0, 1, FEARG_1, arg1_bool,
h-east29b85712021-07-26 21:54:04 +02001700 ret_list_string_items, f_digraph_getlist},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001701 {"digraph_set", 2, 2, FEARG_1, arg2_string,
h-east29b85712021-07-26 21:54:04 +02001702 ret_bool, f_digraph_set},
1703 {"digraph_setlist",1, 1, FEARG_1, arg1_list_string,
1704 ret_bool, f_digraph_setlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001705 {"echoraw", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001706 ret_void, f_echoraw},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001707 {"empty", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001708 ret_number_bool, f_empty},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001709 {"environ", 0, 0, 0, NULL,
1710 ret_dict_string, f_environ},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001711 {"escape", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001712 ret_string, f_escape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001713 {"eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001714 ret_any, f_eval},
1715 {"eventhandler", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001716 ret_number_bool, f_eventhandler},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001717 {"executable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001718 ret_number, f_executable},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001719 {"execute", 1, 2, FEARG_1, arg12_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001720 ret_string, f_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001721 {"exepath", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001722 ret_string, f_exepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001723 {"exists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001724 ret_number_bool, f_exists},
Bram Moolenaar26735992021-08-08 14:43:22 +02001725 {"exists_compiled", 1, 1, FEARG_1, arg1_string,
1726 ret_number_bool, f_exists_compiled},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001727 {"exp", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001728 ret_float, FLOAT_FUNC(f_exp)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001729 {"expand", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001730 ret_any, f_expand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001731 {"expandcmd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001732 ret_string, f_expandcmd},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +01001733 {"extend", 2, 3, FEARG_1, arg23_extend,
Bram Moolenaar81330182022-02-01 12:11:58 +00001734 ret_extend, f_extend},
Bram Moolenaarb0e6b512021-01-12 20:23:40 +01001735 {"extendnew", 2, 3, FEARG_1, arg23_extendnew,
1736 ret_first_cont, f_extendnew},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001737 {"feedkeys", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001738 ret_void, f_feedkeys},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001739 {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001740 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001741 {"filereadable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001742 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001743 {"filewritable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001744 ret_number, f_filewritable},
Bram Moolenaar18024052021-12-25 21:43:28 +00001745 {"filter", 2, 2, FEARG_1, arg2_filter,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001746 ret_first_arg, f_filter},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001747 {"finddir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar08018222021-12-22 18:45:37 +00001748 ret_finddir, f_finddir},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001749 {"findfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar10c83dd2021-09-04 14:49:56 +02001750 ret_any, f_findfile},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001751 {"flatten", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001752 ret_list_any, f_flatten},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001753 {"flattennew", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3b690062021-02-01 20:14:51 +01001754 ret_list_any, f_flattennew},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001755 {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001756 ret_number, FLOAT_FUNC(f_float2nr)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001757 {"floor", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001758 ret_float, FLOAT_FUNC(f_floor)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001759 {"fmod", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001760 ret_float, FLOAT_FUNC(f_fmod)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001761 {"fnameescape", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001762 ret_string, f_fnameescape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001763 {"fnamemodify", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001764 ret_string, f_fnamemodify},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001765 {"foldclosed", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001766 ret_number, f_foldclosed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001767 {"foldclosedend", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001768 ret_number, f_foldclosedend},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001769 {"foldlevel", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001770 ret_number, f_foldlevel},
1771 {"foldtext", 0, 0, 0, NULL,
1772 ret_string, f_foldtext},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001773 {"foldtextresult", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001774 ret_string, f_foldtextresult},
1775 {"foreground", 0, 0, 0, NULL,
1776 ret_void, f_foreground},
Bram Moolenaar038e09e2021-02-06 12:38:51 +01001777 {"fullcommand", 1, 1, FEARG_1, arg1_string,
1778 ret_string, f_fullcommand},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001779 {"funcref", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001780 ret_func_unknown, f_funcref},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001781 {"function", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001782 ret_func_unknown, f_function},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001783 {"garbagecollect", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001784 ret_void, f_garbagecollect},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001785 {"get", 2, 3, FEARG_1, arg23_get,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001786 ret_any, f_get},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001787 {"getbufinfo", 0, 1, FEARG_1, arg1_buffer_or_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001788 ret_list_dict_any, f_getbufinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001789 {"getbufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001790 ret_list_string, f_getbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001791 {"getbufvar", 2, 3, FEARG_1, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001792 ret_any, f_getbufvar},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001793 {"getchangelist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001794 ret_list_any, f_getchangelist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001795 {"getchar", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001796 ret_any, f_getchar},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001797 {"getcharmod", 0, 0, 0, NULL,
1798 ret_number, f_getcharmod},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001799 {"getcharpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001800 ret_list_number, f_getcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001801 {"getcharsearch", 0, 0, 0, NULL,
1802 ret_dict_any, f_getcharsearch},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001803 {"getcharstr", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001804 ret_string, f_getcharstr},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001805 {"getcmdline", 0, 0, 0, NULL,
1806 ret_string, f_getcmdline},
1807 {"getcmdpos", 0, 0, 0, NULL,
1808 ret_number, f_getcmdpos},
1809 {"getcmdtype", 0, 0, 0, NULL,
1810 ret_string, f_getcmdtype},
1811 {"getcmdwintype", 0, 0, 0, NULL,
1812 ret_string, f_getcmdwintype},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001813 {"getcompletion", 2, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001814 ret_list_string, f_getcompletion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001815 {"getcurpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001816 ret_list_number, f_getcurpos},
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001817 {"getcursorcharpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001818 ret_list_number, f_getcursorcharpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001819 {"getcwd", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001820 ret_string, f_getcwd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001821 {"getenv", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar7ad67d12021-03-10 16:08:26 +01001822 ret_any, f_getenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001823 {"getfontname", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001824 ret_string, f_getfontname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001825 {"getfperm", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001826 ret_string, f_getfperm},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001827 {"getfsize", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001828 ret_number, f_getfsize},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001829 {"getftime", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001830 ret_number, f_getftime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001831 {"getftype", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001832 ret_string, f_getftype},
1833 {"getimstatus", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001834 ret_number_bool, f_getimstatus},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001835 {"getjumplist", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001836 ret_list_any, f_getjumplist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001837 {"getline", 1, 2, FEARG_1, arg2_lnum,
Bram Moolenaar078a4612022-01-04 15:17:03 +00001838 ret_getline, f_getline},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001839 {"getloclist", 1, 2, 0, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001840 ret_list_or_dict_1, f_getloclist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001841 {"getmarklist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001842 ret_list_dict_any, f_getmarklist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001843 {"getmatches", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001844 ret_list_dict_any, f_getmatches},
1845 {"getmousepos", 0, 0, 0, NULL,
1846 ret_dict_number, f_getmousepos},
1847 {"getpid", 0, 0, 0, NULL,
1848 ret_number, f_getpid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001849 {"getpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001850 ret_list_number, f_getpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001851 {"getqflist", 0, 1, 0, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001852 ret_list_or_dict_0, f_getqflist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001853 {"getreg", 0, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001854 ret_getreg, f_getreg},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001855 {"getreginfo", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001856 ret_dict_any, f_getreginfo},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001857 {"getregtype", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001858 ret_string, f_getregtype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001859 {"gettabinfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001860 ret_list_dict_any, f_gettabinfo},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001861 {"gettabvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001862 ret_any, f_gettabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001863 {"gettabwinvar", 3, 4, FEARG_1, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001864 ret_any, f_gettabwinvar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001865 {"gettagstack", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001866 ret_dict_any, f_gettagstack},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001867 {"gettext", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001868 ret_string, f_gettext},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001869 {"getwininfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001870 ret_list_dict_any, f_getwininfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001871 {"getwinpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001872 ret_list_number, f_getwinpos},
1873 {"getwinposx", 0, 0, 0, NULL,
1874 ret_number, f_getwinposx},
1875 {"getwinposy", 0, 0, 0, NULL,
1876 ret_number, f_getwinposy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001877 {"getwinvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001878 ret_any, f_getwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001879 {"glob", 1, 4, FEARG_1, arg14_glob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001880 ret_any, f_glob},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001881 {"glob2regpat", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001882 ret_string, f_glob2regpat},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001883 {"globpath", 2, 5, FEARG_2, arg25_globpath,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001884 ret_any, f_globpath},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001885 {"has", 1, 2, 0, arg2_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001886 ret_number_bool, f_has},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001887 {"has_key", 2, 2, FEARG_1, arg2_dict_any_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001888 ret_number_bool, f_has_key},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001889 {"haslocaldir", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001890 ret_number, f_haslocaldir},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001891 {"hasmapto", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001892 ret_number_bool, f_hasmapto},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001893 {"highlightID", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001894 ret_number, f_hlID},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001895 {"highlight_exists",1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001896 ret_number_bool, f_hlexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001897 {"histadd", 2, 2, FEARG_2, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001898 ret_number_bool, f_histadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001899 {"histdel", 1, 2, FEARG_1, arg2_string_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001900 ret_number_bool, f_histdel},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001901 {"histget", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001902 ret_string, f_histget},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001903 {"histnr", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001904 ret_number, f_histnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001905 {"hlID", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001906 ret_number, f_hlID},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001907 {"hlexists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001908 ret_number_bool, f_hlexists},
Yegappan Lakshmanand1a8d652021-11-03 21:56:45 +00001909 {"hlget", 0, 2, FEARG_1, arg2_string_bool,
1910 ret_list_dict_any, f_hlget},
1911 {"hlset", 1, 1, FEARG_1, arg1_list_any,
1912 ret_number_bool, f_hlset},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001913 {"hostname", 0, 0, 0, NULL,
1914 ret_string, f_hostname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001915 {"iconv", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001916 ret_string, f_iconv},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001917 {"indent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001918 ret_number, f_indent},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001919 {"index", 2, 4, FEARG_1, arg24_index,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001920 ret_number, f_index},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001921 {"input", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001922 ret_string, f_input},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001923 {"inputdialog", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001924 ret_string, f_inputdialog},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001925 {"inputlist", 1, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001926 ret_number, f_inputlist},
1927 {"inputrestore", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001928 ret_number_bool, f_inputrestore},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001929 {"inputsave", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001930 ret_number_bool, f_inputsave},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001931 {"inputsecret", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001932 ret_string, f_inputsecret},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001933 {"insert", 2, 3, FEARG_1, arg23_insert,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001934 ret_first_arg, f_insert},
1935 {"interrupt", 0, 0, 0, NULL,
1936 ret_void, f_interrupt},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001937 {"invert", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001938 ret_number, f_invert},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001939 {"isdirectory", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001940 ret_number_bool, f_isdirectory},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001941 {"isinf", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001942 ret_number, MATH_FUNC(f_isinf)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001943 {"islocked", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001944 ret_number_bool, f_islocked},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001945 {"isnan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001946 ret_number_bool, MATH_FUNC(f_isnan)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001947 {"items", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001948 ret_list_items, f_items},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001949 {"job_getchannel", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001950 ret_channel, JOB_FUNC(f_job_getchannel)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001951 {"job_info", 0, 1, FEARG_1, arg1_job,
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001952 ret_job_info, JOB_FUNC(f_job_info)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001953 {"job_setoptions", 2, 2, FEARG_1, arg2_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001954 ret_void, JOB_FUNC(f_job_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001955 {"job_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001956 ret_job, JOB_FUNC(f_job_start)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001957 {"job_status", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001958 ret_string, JOB_FUNC(f_job_status)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001959 {"job_stop", 1, 2, FEARG_1, arg2_job_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001960 ret_number_bool, JOB_FUNC(f_job_stop)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001961 {"join", 1, 2, FEARG_1, arg2_list_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001962 ret_string, f_join},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001963 {"js_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001964 ret_any, f_js_decode},
1965 {"js_encode", 1, 1, FEARG_1, NULL,
1966 ret_string, f_js_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001967 {"json_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001968 ret_any, f_json_decode},
1969 {"json_encode", 1, 1, FEARG_1, NULL,
1970 ret_string, f_json_encode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001971 {"keys", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001972 ret_list_string, f_keys},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001973 {"last_buffer_nr", 0, 0, 0, NULL, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001974 ret_number, f_last_buffer_nr},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001975 {"len", 1, 1, FEARG_1, arg1_len,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001976 ret_number, f_len},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001977 {"libcall", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001978 ret_string, f_libcall},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001979 {"libcallnr", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001980 ret_number, f_libcallnr},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001981 {"line", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001982 ret_number, f_line},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001983 {"line2byte", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001984 ret_number, f_line2byte},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001985 {"lispindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001986 ret_number, f_lispindent},
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001987 {"list2blob", 1, 1, FEARG_1, arg1_list_number,
1988 ret_blob, f_list2blob},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001989 {"list2str", 1, 2, FEARG_1, arg2_list_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001990 ret_string, f_list2str},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001991 {"listener_add", 1, 2, FEARG_2, arg2_any_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001992 ret_number, f_listener_add},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001993 {"listener_flush", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001994 ret_void, f_listener_flush},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001995 {"listener_remove", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001996 ret_number_bool, f_listener_remove},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001997 {"localtime", 0, 0, 0, NULL,
1998 ret_number, f_localtime},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001999 {"log", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002000 ret_float, FLOAT_FUNC(f_log)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002001 {"log10", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002002 ret_float, FLOAT_FUNC(f_log10)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002003 {"luaeval", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002004 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002005#ifdef FEAT_LUA
Bram Moolenaar15c47602020-03-26 22:16:48 +01002006 f_luaeval
2007#else
2008 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002009#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002010 },
Bram Moolenaar18024052021-12-25 21:43:28 +00002011 {"map", 2, 2, FEARG_1, arg2_map,
Bram Moolenaarea696852020-11-09 18:31:39 +01002012 ret_first_cont, f_map},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002013 {"maparg", 1, 4, FEARG_1, arg14_maparg,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002014 ret_maparg, f_maparg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002015 {"mapcheck", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002016 ret_string, f_mapcheck},
Bram Moolenaar18024052021-12-25 21:43:28 +00002017 {"mapnew", 2, 2, FEARG_1, arg2_mapnew,
Bram Moolenaarea696852020-11-09 18:31:39 +01002018 ret_first_cont, f_mapnew},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002019 {"mapset", 3, 3, FEARG_1, arg3_string_bool_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002020 ret_void, f_mapset},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002021 {"match", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002022 ret_any, f_match},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002023 {"matchadd", 2, 5, FEARG_1, arg25_matchadd,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002024 ret_number, f_matchadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002025 {"matchaddpos", 2, 5, FEARG_1, arg25_matchaddpos,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002026 ret_number, f_matchaddpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002027 {"matcharg", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002028 ret_list_string, f_matcharg},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002029 {"matchdelete", 1, 2, FEARG_1, arg2_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002030 ret_number_bool, f_matchdelete},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002031 {"matchend", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002032 ret_number, f_matchend},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002033 {"matchfuzzy", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002034 ret_list_string, f_matchfuzzy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002035 {"matchfuzzypos", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002036 ret_list_any, f_matchfuzzypos},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002037 {"matchlist", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002038 ret_list_string, f_matchlist},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002039 {"matchstr", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002040 ret_string, f_matchstr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002041 {"matchstrpos", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002042 ret_list_any, f_matchstrpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002043 {"max", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002044 ret_number, f_max},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002045 {"menu_info", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002046 ret_dict_any,
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002047#ifdef FEAT_MENU
Bram Moolenaar15c47602020-03-26 22:16:48 +01002048 f_menu_info
2049#else
2050 NULL
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002051#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002052 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002053 {"min", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002054 ret_number, f_min},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002055 {"mkdir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002056 ret_number_bool, f_mkdir},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002057 {"mode", 0, 1, FEARG_1, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002058 ret_string, f_mode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002059 {"mzeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002060 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002061#ifdef FEAT_MZSCHEME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002062 f_mzeval
2063#else
2064 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002065#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002066 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002067 {"nextnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002068 ret_number, f_nextnonblank},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002069 {"nr2char", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002070 ret_string, f_nr2char},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002071 {"or", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002072 ret_number, f_or},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002073 {"pathshorten", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002074 ret_string, f_pathshorten},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002075 {"perleval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002076 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002077#ifdef FEAT_PERL
Bram Moolenaar15c47602020-03-26 22:16:48 +01002078 f_perleval
2079#else
2080 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002081#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002082 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002083 {"popup_atcursor", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002084 ret_number, PROP_FUNC(f_popup_atcursor)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002085 {"popup_beval", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002086 ret_number, PROP_FUNC(f_popup_beval)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002087 {"popup_clear", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002088 ret_void, PROP_FUNC(f_popup_clear)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002089 {"popup_close", 1, 2, FEARG_1, arg2_number_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002090 ret_void, PROP_FUNC(f_popup_close)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002091 {"popup_create", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002092 ret_number, PROP_FUNC(f_popup_create)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002093 {"popup_dialog", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002094 ret_number, PROP_FUNC(f_popup_dialog)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002095 {"popup_filter_menu", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002096 ret_bool, PROP_FUNC(f_popup_filter_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002097 {"popup_filter_yesno", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002098 ret_bool, PROP_FUNC(f_popup_filter_yesno)},
2099 {"popup_findinfo", 0, 0, 0, NULL,
2100 ret_number, PROP_FUNC(f_popup_findinfo)},
2101 {"popup_findpreview", 0, 0, 0, NULL,
2102 ret_number, PROP_FUNC(f_popup_findpreview)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002103 {"popup_getoptions", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002104 ret_dict_any, PROP_FUNC(f_popup_getoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002105 {"popup_getpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002106 ret_dict_any, PROP_FUNC(f_popup_getpos)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002107 {"popup_hide", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002108 ret_void, PROP_FUNC(f_popup_hide)},
2109 {"popup_list", 0, 0, 0, NULL,
2110 ret_list_number, PROP_FUNC(f_popup_list)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002111 {"popup_locate", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002112 ret_number, PROP_FUNC(f_popup_locate)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002113 {"popup_menu", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002114 ret_number, PROP_FUNC(f_popup_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002115 {"popup_move", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002116 ret_void, PROP_FUNC(f_popup_move)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002117 {"popup_notification", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002118 ret_number, PROP_FUNC(f_popup_notification)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002119 {"popup_setoptions", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002120 ret_void, PROP_FUNC(f_popup_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002121 {"popup_settext", 2, 2, FEARG_1, arg2_number_string_or_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002122 ret_void, PROP_FUNC(f_popup_settext)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002123 {"popup_show", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002124 ret_void, PROP_FUNC(f_popup_show)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002125 {"pow", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002126 ret_float, FLOAT_FUNC(f_pow)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002127 {"prevnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002128 ret_number, f_prevnonblank},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002129 {"printf", 1, 19, FEARG_2, arg119_printf,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002130 ret_string, f_printf},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002131 {"prompt_getprompt", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002132 ret_string, JOB_FUNC(f_prompt_getprompt)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002133 {"prompt_setcallback", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002134 ret_void, JOB_FUNC(f_prompt_setcallback)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002135 {"prompt_setinterrupt", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002136 ret_void, JOB_FUNC(f_prompt_setinterrupt)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002137 {"prompt_setprompt", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002138 ret_void, JOB_FUNC(f_prompt_setprompt)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002139 {"prop_add", 3, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002140 ret_void, PROP_FUNC(f_prop_add)},
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02002141 {"prop_add_list", 2, 2, FEARG_1, arg2_dict_any_list_any,
2142 ret_void, PROP_FUNC(f_prop_add_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002143 {"prop_clear", 1, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002144 ret_void, PROP_FUNC(f_prop_clear)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002145 {"prop_find", 1, 2, FEARG_1, arg2_dict_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002146 ret_dict_any, PROP_FUNC(f_prop_find)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002147 {"prop_list", 1, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002148 ret_list_dict_any, PROP_FUNC(f_prop_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002149 {"prop_remove", 1, 3, FEARG_1, arg3_dict_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002150 ret_number, PROP_FUNC(f_prop_remove)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002151 {"prop_type_add", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002152 ret_void, PROP_FUNC(f_prop_type_add)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002153 {"prop_type_change", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002154 ret_void, PROP_FUNC(f_prop_type_change)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002155 {"prop_type_delete", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002156 ret_void, PROP_FUNC(f_prop_type_delete)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002157 {"prop_type_get", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002158 ret_dict_any, PROP_FUNC(f_prop_type_get)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002159 {"prop_type_list", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002160 ret_list_string, PROP_FUNC(f_prop_type_list)},
2161 {"pum_getpos", 0, 0, 0, NULL,
2162 ret_dict_number, f_pum_getpos},
2163 {"pumvisible", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002164 ret_number_bool, f_pumvisible},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002165 {"py3eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002166 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002167#ifdef FEAT_PYTHON3
Bram Moolenaar15c47602020-03-26 22:16:48 +01002168 f_py3eval
2169#else
2170 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002171#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002172 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002173 {"pyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002174 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002175#ifdef FEAT_PYTHON
Bram Moolenaar15c47602020-03-26 22:16:48 +01002176 f_pyeval
2177#else
2178 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002179#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002180 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002181 {"pyxeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002182 ret_any,
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002183#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar15c47602020-03-26 22:16:48 +01002184 f_pyxeval
2185#else
2186 NULL
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002187#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002188 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002189 {"rand", 0, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002190 ret_number, f_rand},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002191 {"range", 1, 3, FEARG_1, arg3_number,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00002192 ret_list_number, f_range},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002193 {"readblob", 1, 1, FEARG_1, arg1_string,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002194 ret_blob, f_readblob},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002195 {"readdir", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002196 ret_list_string, f_readdir},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002197 {"readdirex", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002198 ret_list_dict_any, f_readdirex},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002199 {"readfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002200 ret_list_string, f_readfile},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002201 {"reduce", 2, 3, FEARG_1, arg23_reduce,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002202 ret_any, f_reduce},
2203 {"reg_executing", 0, 0, 0, NULL,
2204 ret_string, f_reg_executing},
2205 {"reg_recording", 0, 0, 0, NULL,
2206 ret_string, f_reg_recording},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002207 {"reltime", 0, 2, FEARG_1, arg2_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002208 ret_list_any, f_reltime},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002209 {"reltimefloat", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002210 ret_float, FLOAT_FUNC(f_reltimefloat)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002211 {"reltimestr", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002212 ret_string, f_reltimestr},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002213 {"remote_expr", 2, 4, FEARG_1, arg24_remote_expr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002214 ret_string, f_remote_expr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002215 {"remote_foreground", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002216 ret_string, f_remote_foreground},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002217 {"remote_peek", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002218 ret_number, f_remote_peek},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002219 {"remote_read", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002220 ret_string, f_remote_read},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002221 {"remote_send", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002222 ret_string, f_remote_send},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002223 {"remote_startserver", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002224 ret_void, f_remote_startserver},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002225 {"remove", 2, 3, FEARG_1, arg23_remove,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002226 ret_remove, f_remove},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002227 {"rename", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002228 ret_number_bool, f_rename},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002229 {"repeat", 2, 2, FEARG_1, arg2_repeat,
Bram Moolenaar1780f082021-07-31 22:03:59 +02002230 ret_repeat, f_repeat},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002231 {"resolve", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002232 ret_string, f_resolve},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002233 {"reverse", 1, 1, FEARG_1, arg1_list_or_blob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002234 ret_first_arg, f_reverse},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002235 {"round", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002236 ret_float, FLOAT_FUNC(f_round)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002237 {"rubyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002238 ret_any,
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002239#ifdef FEAT_RUBY
Bram Moolenaar15c47602020-03-26 22:16:48 +01002240 f_rubyeval
2241#else
2242 NULL
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002243#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002244 },
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002245 {"screenattr", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002246 ret_number, f_screenattr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002247 {"screenchar", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002248 ret_number, f_screenchar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002249 {"screenchars", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002250 ret_list_number, f_screenchars},
2251 {"screencol", 0, 0, 0, NULL,
2252 ret_number, f_screencol},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002253 {"screenpos", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002254 ret_dict_number, f_screenpos},
2255 {"screenrow", 0, 0, 0, NULL,
2256 ret_number, f_screenrow},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002257 {"screenstring", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002258 ret_string, f_screenstring},
Bram Moolenaarcd268012021-07-22 19:11:08 +02002259 {"search", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002260 ret_number, f_search},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002261 {"searchcount", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002262 ret_dict_any, f_searchcount},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002263 {"searchdecl", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002264 ret_number_bool, f_searchdecl},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002265 {"searchpair", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002266 ret_number, f_searchpair},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002267 {"searchpairpos", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002268 ret_list_number, f_searchpairpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002269 {"searchpos", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002270 ret_list_number, f_searchpos},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002271 {"server2client", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002272 ret_number_bool, f_server2client},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002273 {"serverlist", 0, 0, 0, NULL,
2274 ret_string, f_serverlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002275 {"setbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002276 ret_number_bool, f_setbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002277 {"setbufvar", 3, 3, FEARG_3, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002278 ret_void, f_setbufvar},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002279 {"setcellwidths", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002280 ret_void, f_setcellwidths},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002281 {"setcharpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002282 ret_number_bool, f_setcharpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002283 {"setcharsearch", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002284 ret_void, f_setcharsearch},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002285 {"setcmdpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002286 ret_number_bool, f_setcmdpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002287 {"setcursorcharpos", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002288 ret_number_bool, f_setcursorcharpos},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002289 {"setenv", 2, 2, FEARG_2, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002290 ret_void, f_setenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002291 {"setfperm", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002292 ret_number_bool, f_setfperm},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002293 {"setline", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002294 ret_number_bool, f_setline},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002295 {"setloclist", 2, 4, FEARG_2, arg24_setloclist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002296 ret_number_bool, f_setloclist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002297 {"setmatches", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002298 ret_number_bool, f_setmatches},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002299 {"setpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002300 ret_number_bool, f_setpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002301 {"setqflist", 1, 3, FEARG_1, arg13_setqflist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002302 ret_number_bool, f_setqflist},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002303 {"setreg", 2, 3, FEARG_2, arg3_string_any_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002304 ret_number_bool, f_setreg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002305 {"settabvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002306 ret_void, f_settabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002307 {"settabwinvar", 4, 4, FEARG_4, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002308 ret_void, f_settabwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002309 {"settagstack", 2, 3, FEARG_2, arg23_settagstack,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002310 ret_number_bool, f_settagstack},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002311 {"setwinvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002312 ret_void, f_setwinvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002313 {"sha256", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002314 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002315#ifdef FEAT_CRYPT
Bram Moolenaar15c47602020-03-26 22:16:48 +01002316 f_sha256
2317#else
2318 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002319#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002320 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002321 {"shellescape", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002322 ret_string, f_shellescape},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002323 {"shiftwidth", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002324 ret_number, f_shiftwidth},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002325 {"sign_define", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002326 ret_any, SIGN_FUNC(f_sign_define)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002327 {"sign_getdefined", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002328 ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002329 {"sign_getplaced", 0, 2, FEARG_1, arg02_sign_getplaced,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002330 ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002331 {"sign_jump", 3, 3, FEARG_1, arg3_number_string_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002332 ret_number, SIGN_FUNC(f_sign_jump)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002333 {"sign_place", 4, 5, FEARG_1, arg45_sign_place,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002334 ret_number, SIGN_FUNC(f_sign_place)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002335 {"sign_placelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002336 ret_list_number, SIGN_FUNC(f_sign_placelist)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002337 {"sign_undefine", 0, 1, FEARG_1, arg1_string_or_list_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002338 ret_number_bool, SIGN_FUNC(f_sign_undefine)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002339 {"sign_unplace", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002340 ret_number_bool, SIGN_FUNC(f_sign_unplace)},
Sean Dewara63780b2021-11-03 13:15:47 +00002341 {"sign_unplacelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002342 ret_list_number, SIGN_FUNC(f_sign_unplacelist)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002343 {"simplify", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002344 ret_string, f_simplify},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002345 {"sin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002346 ret_float, FLOAT_FUNC(f_sin)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002347 {"sinh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002348 ret_float, FLOAT_FUNC(f_sinh)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002349 {"slice", 2, 3, FEARG_1, arg23_slice,
Bram Moolenaar00eb9952022-02-05 19:23:18 +00002350 ret_slice, f_slice},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002351 {"sort", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002352 ret_first_arg, f_sort},
2353 {"sound_clear", 0, 0, 0, NULL,
2354 ret_void, SOUND_FUNC(f_sound_clear)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002355 {"sound_playevent", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002356 ret_number, SOUND_FUNC(f_sound_playevent)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002357 {"sound_playfile", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002358 ret_number, SOUND_FUNC(f_sound_playfile)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002359 {"sound_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002360 ret_void, SOUND_FUNC(f_sound_stop)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002361 {"soundfold", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002362 ret_string, f_soundfold},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002363 {"spellbadword", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002364 ret_list_string, f_spellbadword},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002365 {"spellsuggest", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002366 ret_list_string, f_spellsuggest},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002367 {"split", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002368 ret_list_string, f_split},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002369 {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002370 ret_float, FLOAT_FUNC(f_sqrt)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002371 {"srand", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002372 ret_list_number, f_srand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002373 {"state", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002374 ret_string, f_state},
Bram Moolenaar80a070c2021-08-08 15:51:10 +02002375 {"str2float", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002376 ret_float, FLOAT_FUNC(f_str2float)},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002377 {"str2list", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002378 ret_list_number, f_str2list},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002379 {"str2nr", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002380 ret_number, f_str2nr},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002381 {"strcharlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01002382 ret_number, f_strcharlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002383 {"strcharpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002384 ret_string, f_strcharpart},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002385 {"strchars", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002386 ret_number, f_strchars},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002387 {"strdisplaywidth", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002388 ret_number, f_strdisplaywidth},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002389 {"strftime", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002390 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002391#ifdef HAVE_STRFTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002392 f_strftime
2393#else
2394 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002395#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002396 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002397 {"strgetchar", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002398 ret_number, f_strgetchar},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002399 {"stridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002400 ret_number, f_stridx},
2401 {"string", 1, 1, FEARG_1, NULL,
2402 ret_string, f_string},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002403 {"strlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002404 ret_number, f_strlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002405 {"strpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002406 ret_string, f_strpart},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002407 {"strptime", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002408 ret_number,
Bram Moolenaar10455d42019-11-21 15:36:18 +01002409#ifdef HAVE_STRPTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002410 f_strptime
2411#else
2412 NULL
Bram Moolenaar10455d42019-11-21 15:36:18 +01002413#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002414 },
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002415 {"strridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002416 ret_number, f_strridx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002417 {"strtrans", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002418 ret_string, f_strtrans},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002419 {"strwidth", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002420 ret_number, f_strwidth},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002421 {"submatch", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002422 ret_string, f_submatch},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002423 {"substitute", 4, 4, FEARG_1, arg4_string_string_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002424 ret_string, f_substitute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002425 {"swapinfo", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002426 ret_dict_any, f_swapinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002427 {"swapname", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002428 ret_string, f_swapname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002429 {"synID", 3, 3, 0, arg3_lnum_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002430 ret_number, f_synID},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002431 {"synIDattr", 2, 3, FEARG_1, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002432 ret_string, f_synIDattr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002433 {"synIDtrans", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002434 ret_number, f_synIDtrans},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002435 {"synconcealed", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002436 ret_list_any, f_synconcealed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002437 {"synstack", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002438 ret_list_number, f_synstack},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002439 {"system", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002440 ret_string, f_system},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002441 {"systemlist", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002442 ret_list_string, f_systemlist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002443 {"tabpagebuflist", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002444 ret_list_number, f_tabpagebuflist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002445 {"tabpagenr", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002446 ret_number, f_tabpagenr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002447 {"tabpagewinnr", 1, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002448 ret_number, f_tabpagewinnr},
2449 {"tagfiles", 0, 0, 0, NULL,
2450 ret_list_string, f_tagfiles},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002451 {"taglist", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002452 ret_list_dict_any, f_taglist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002453 {"tan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002454 ret_float, FLOAT_FUNC(f_tan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002455 {"tanh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002456 ret_float, FLOAT_FUNC(f_tanh)},
2457 {"tempname", 0, 0, 0, NULL,
2458 ret_string, f_tempname},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002459 {"term_dumpdiff", 2, 3, FEARG_1, arg3_string_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002460 ret_number, TERM_FUNC(f_term_dumpdiff)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002461 {"term_dumpload", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002462 ret_number, TERM_FUNC(f_term_dumpload)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002463 {"term_dumpwrite", 2, 3, FEARG_2, arg3_buffer_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002464 ret_void, TERM_FUNC(f_term_dumpwrite)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002465 {"term_getaltscreen", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002466 ret_number, TERM_FUNC(f_term_getaltscreen)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002467 {"term_getansicolors", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002468 ret_list_string,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002469#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002470 f_term_getansicolors
2471#else
2472 NULL
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02002473#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002474 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002475 {"term_getattr", 2, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002476 ret_number, TERM_FUNC(f_term_getattr)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002477 {"term_getcursor", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002478 ret_list_any, TERM_FUNC(f_term_getcursor)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002479 {"term_getjob", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002480 ret_job, TERM_FUNC(f_term_getjob)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002481 {"term_getline", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002482 ret_string, TERM_FUNC(f_term_getline)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002483 {"term_getscrolled", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002484 ret_number, TERM_FUNC(f_term_getscrolled)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002485 {"term_getsize", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002486 ret_list_number, TERM_FUNC(f_term_getsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002487 {"term_getstatus", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002488 ret_string, TERM_FUNC(f_term_getstatus)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002489 {"term_gettitle", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002490 ret_string, TERM_FUNC(f_term_gettitle)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002491 {"term_gettty", 1, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002492 ret_string, TERM_FUNC(f_term_gettty)},
2493 {"term_list", 0, 0, 0, NULL,
2494 ret_list_number, TERM_FUNC(f_term_list)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002495 {"term_scrape", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002496 ret_list_dict_any, TERM_FUNC(f_term_scrape)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002497 {"term_sendkeys", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002498 ret_void, TERM_FUNC(f_term_sendkeys)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002499 {"term_setansicolors", 2, 2, FEARG_1, arg2_buffer_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002500 ret_void,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002501#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002502 f_term_setansicolors
2503#else
2504 NULL
2505#endif
2506 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002507 {"term_setapi", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002508 ret_void, TERM_FUNC(f_term_setapi)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002509 {"term_setkill", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002510 ret_void, TERM_FUNC(f_term_setkill)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002511 {"term_setrestore", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002512 ret_void, TERM_FUNC(f_term_setrestore)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002513 {"term_setsize", 3, 3, FEARG_1, arg3_buffer_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002514 ret_void, TERM_FUNC(f_term_setsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002515 {"term_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002516 ret_number, TERM_FUNC(f_term_start)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002517 {"term_wait", 1, 2, FEARG_1, arg2_buffer_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002518 ret_void, TERM_FUNC(f_term_wait)},
2519 {"terminalprops", 0, 0, 0, NULL,
2520 ret_dict_string, f_terminalprops},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002521 {"test_alloc_fail", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002522 ret_void, f_test_alloc_fail},
2523 {"test_autochdir", 0, 0, 0, NULL,
2524 ret_void, f_test_autochdir},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002525 {"test_feedinput", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002526 ret_void, f_test_feedinput},
2527 {"test_garbagecollect_now", 0, 0, 0, NULL,
2528 ret_void, f_test_garbagecollect_now},
2529 {"test_garbagecollect_soon", 0, 0, 0, NULL,
2530 ret_void, f_test_garbagecollect_soon},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002531 {"test_getvalue", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002532 ret_number, f_test_getvalue},
Yegappan Lakshmanan06011e12022-01-30 12:37:29 +00002533 {"test_gui_event", 2, 2, FEARG_1, arg2_string_dict,
2534 ret_bool, f_test_gui_event},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002535 {"test_ignore_error", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002536 ret_void, f_test_ignore_error},
2537 {"test_null_blob", 0, 0, 0, NULL,
2538 ret_blob, f_test_null_blob},
2539 {"test_null_channel", 0, 0, 0, NULL,
2540 ret_channel, JOB_FUNC(f_test_null_channel)},
2541 {"test_null_dict", 0, 0, 0, NULL,
2542 ret_dict_any, f_test_null_dict},
2543 {"test_null_function", 0, 0, 0, NULL,
2544 ret_func_any, f_test_null_function},
2545 {"test_null_job", 0, 0, 0, NULL,
2546 ret_job, JOB_FUNC(f_test_null_job)},
2547 {"test_null_list", 0, 0, 0, NULL,
2548 ret_list_any, f_test_null_list},
2549 {"test_null_partial", 0, 0, 0, NULL,
2550 ret_func_any, f_test_null_partial},
2551 {"test_null_string", 0, 0, 0, NULL,
2552 ret_string, f_test_null_string},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002553 {"test_option_not_set", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002554 ret_void, f_test_option_not_set},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002555 {"test_override", 2, 2, FEARG_2, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002556 ret_void, f_test_override},
2557 {"test_refcount", 1, 1, FEARG_1, NULL,
2558 ret_number, f_test_refcount},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002559 {"test_setmouse", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002560 ret_void, f_test_setmouse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002561 {"test_settime", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002562 ret_void, f_test_settime},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002563 {"test_srand_seed", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002564 ret_void, f_test_srand_seed},
2565 {"test_unknown", 0, 0, 0, NULL,
2566 ret_any, f_test_unknown},
2567 {"test_void", 0, 0, 0, NULL,
2568 ret_void, f_test_void},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002569 {"timer_info", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002570 ret_list_dict_any, TIMER_FUNC(f_timer_info)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002571 {"timer_pause", 2, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002572 ret_void, TIMER_FUNC(f_timer_pause)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002573 {"timer_start", 2, 3, FEARG_1, arg3_number_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002574 ret_number, TIMER_FUNC(f_timer_start)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002575 {"timer_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002576 ret_void, TIMER_FUNC(f_timer_stop)},
2577 {"timer_stopall", 0, 0, 0, NULL,
2578 ret_void, TIMER_FUNC(f_timer_stopall)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002579 {"tolower", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002580 ret_string, f_tolower},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002581 {"toupper", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002582 ret_string, f_toupper},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002583 {"tr", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002584 ret_string, f_tr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002585 {"trim", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002586 ret_string, f_trim},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002587 {"trunc", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002588 ret_float, FLOAT_FUNC(f_trunc)},
2589 {"type", 1, 1, FEARG_1, NULL,
2590 ret_number, f_type},
Bram Moolenaara47e05f2021-01-12 21:49:00 +01002591 {"typename", 1, 1, FEARG_1, NULL,
2592 ret_string, f_typename},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002593 {"undofile", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002594 ret_string, f_undofile},
2595 {"undotree", 0, 0, 0, NULL,
2596 ret_dict_any, f_undotree},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002597 {"uniq", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar08018222021-12-22 18:45:37 +00002598 ret_first_arg, f_uniq},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002599 {"values", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002600 ret_list_any, f_values},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002601 {"virtcol", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002602 ret_number, f_virtcol},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002603 {"visualmode", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002604 ret_string, f_visualmode},
2605 {"wildmenumode", 0, 0, 0, NULL,
2606 ret_number, f_wildmenumode},
Bram Moolenaar52312242021-07-11 18:23:19 +02002607 {"win_execute", 2, 3, FEARG_2, arg23_win_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002608 ret_string, f_win_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002609 {"win_findbuf", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002610 ret_list_number, f_win_findbuf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002611 {"win_getid", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002612 ret_number, f_win_getid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002613 {"win_gettype", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002614 ret_string, f_win_gettype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002615 {"win_gotoid", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002616 ret_number_bool, f_win_gotoid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002617 {"win_id2tabwin", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002618 ret_list_number, f_win_id2tabwin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002619 {"win_id2win", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002620 ret_number, f_win_id2win},
Daniel Steinbergee630312022-01-10 13:36:34 +00002621 {"win_move_separator", 2, 2, FEARG_1, arg2_number,
2622 ret_number_bool, f_win_move_separator},
2623 {"win_move_statusline", 2, 2, FEARG_1, arg2_number,
2624 ret_number_bool, f_win_move_statusline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002625 {"win_screenpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002626 ret_list_number, f_win_screenpos},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002627 {"win_splitmove", 2, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002628 ret_number_bool, f_win_splitmove},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002629 {"winbufnr", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002630 ret_number, f_winbufnr},
2631 {"wincol", 0, 0, 0, NULL,
2632 ret_number, f_wincol},
2633 {"windowsversion", 0, 0, 0, NULL,
2634 ret_string, f_windowsversion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002635 {"winheight", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002636 ret_number, f_winheight},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002637 {"winlayout", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002638 ret_list_any, f_winlayout},
2639 {"winline", 0, 0, 0, NULL,
2640 ret_number, f_winline},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002641 {"winnr", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002642 ret_number, f_winnr},
2643 {"winrestcmd", 0, 0, 0, NULL,
2644 ret_string, f_winrestcmd},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002645 {"winrestview", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002646 ret_void, f_winrestview},
2647 {"winsaveview", 0, 0, 0, NULL,
Bram Moolenaar43b69b32021-01-07 20:23:33 +01002648 ret_dict_number, f_winsaveview},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002649 {"winwidth", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002650 ret_number, f_winwidth},
2651 {"wordcount", 0, 0, 0, NULL,
2652 ret_dict_number, f_wordcount},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002653 {"writefile", 2, 3, FEARG_1, arg23_writefile,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002654 ret_number_bool, f_writefile},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002655 {"xor", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002656 ret_number, f_xor},
Bram Moolenaarac92e252019-08-03 21:58:38 +02002657};
2658
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002659/*
2660 * Function given to ExpandGeneric() to obtain the list of internal
2661 * or user defined function names.
2662 */
2663 char_u *
2664get_function_name(expand_T *xp, int idx)
2665{
2666 static int intidx = -1;
2667 char_u *name;
2668
2669 if (idx == 0)
2670 intidx = -1;
2671 if (intidx < 0)
2672 {
2673 name = get_user_func_name(xp, idx);
naohiro ono5aec7552021-08-19 21:20:41 +02002674 if (name != NULL)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002675 {
naohiro ono5aec7552021-08-19 21:20:41 +02002676 if (*name != NUL && *name != '<'
2677 && STRNCMP("g:", xp->xp_pattern, 2) == 0)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002678 return cat_prefix_varname('g', name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002679 return name;
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002680 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002681 }
K.Takataeeec2542021-06-02 13:28:16 +02002682 if (++intidx < (int)ARRAY_LENGTH(global_functions))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002683 {
Bram Moolenaarac92e252019-08-03 21:58:38 +02002684 STRCPY(IObuff, global_functions[intidx].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002685 STRCAT(IObuff, "(");
Bram Moolenaarac92e252019-08-03 21:58:38 +02002686 if (global_functions[intidx].f_max_argc == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002687 STRCAT(IObuff, ")");
2688 return IObuff;
2689 }
2690
2691 return NULL;
2692}
2693
2694/*
2695 * Function given to ExpandGeneric() to obtain the list of internal or
2696 * user defined variable or function names.
2697 */
2698 char_u *
2699get_expr_name(expand_T *xp, int idx)
2700{
2701 static int intidx = -1;
2702 char_u *name;
2703
2704 if (idx == 0)
2705 intidx = -1;
2706 if (intidx < 0)
2707 {
2708 name = get_function_name(xp, idx);
2709 if (name != NULL)
2710 return name;
2711 }
2712 return get_user_var_name(xp, ++intidx);
2713}
2714
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002715/*
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002716 * Find internal function "name" in table "global_functions".
Bram Moolenaar15c47602020-03-26 22:16:48 +01002717 * Return index, or -1 if not found or "implemented" is TRUE and the function
2718 * is not implemented.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002719 */
Bram Moolenaar15c47602020-03-26 22:16:48 +01002720 static int
2721find_internal_func_opt(char_u *name, int implemented)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002722{
2723 int first = 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002724 int last;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002725 int cmp;
2726 int x;
2727
K.Takataeeec2542021-06-02 13:28:16 +02002728 last = (int)ARRAY_LENGTH(global_functions) - 1;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002729
2730 // Find the function name in the table. Binary search.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002731 while (first <= last)
2732 {
2733 x = first + ((unsigned)(last - first) >> 1);
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002734 cmp = STRCMP(name, global_functions[x].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002735 if (cmp < 0)
2736 last = x - 1;
2737 else if (cmp > 0)
2738 first = x + 1;
Bram Moolenaar15c47602020-03-26 22:16:48 +01002739 else if (implemented && global_functions[x].f_func == NULL)
2740 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002741 else
2742 return x;
2743 }
2744 return -1;
2745}
2746
Bram Moolenaar15c47602020-03-26 22:16:48 +01002747/*
2748 * Find internal function "name" in table "global_functions".
2749 * Return index, or -1 if not found or the function is not implemented.
2750 */
2751 int
2752find_internal_func(char_u *name)
2753{
2754 return find_internal_func_opt(name, TRUE);
2755}
2756
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002757 int
Bram Moolenaarac92e252019-08-03 21:58:38 +02002758has_internal_func(char_u *name)
2759{
Bram Moolenaar15c47602020-03-26 22:16:48 +01002760 return find_internal_func_opt(name, TRUE) >= 0;
2761}
2762
2763 static int
2764has_internal_func_name(char_u *name)
2765{
2766 return find_internal_func_opt(name, FALSE) >= 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002767}
2768
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002769 char *
2770internal_func_name(int idx)
2771{
2772 return global_functions[idx].f_name;
2773}
2774
Bram Moolenaar94738d82020-10-21 14:25:07 +02002775/*
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002776 * Check the argument types for builtin function "idx".
Bram Moolenaar94738d82020-10-21 14:25:07 +02002777 * Uses the list of types on the type stack: "types".
2778 * Return FAIL and gives an error message when a type is wrong.
2779 */
2780 int
Bram Moolenaar351ead02021-01-16 16:07:01 +01002781internal_func_check_arg_types(
Bram Moolenaar078a4612022-01-04 15:17:03 +00002782 type2_T *types,
Bram Moolenaar351ead02021-01-16 16:07:01 +01002783 int idx,
2784 int argcount,
2785 cctx_T *cctx)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002786{
2787 argcheck_T *argchecks = global_functions[idx].f_argcheck;
2788 int i;
2789
2790 if (argchecks != NULL)
2791 {
2792 argcontext_T context;
2793
2794 context.arg_count = argcount;
Bram Moolenaarca174532020-10-21 16:42:22 +02002795 context.arg_types = types;
Bram Moolenaar351ead02021-01-16 16:07:01 +01002796 context.arg_cctx = cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +02002797 for (i = 0; i < argcount; ++i)
2798 if (argchecks[i] != NULL)
2799 {
2800 context.arg_idx = i;
Bram Moolenaar078a4612022-01-04 15:17:03 +00002801 if (argchecks[i](types[i].type_curr, types[i].type_decl,
2802 &context) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002803 return FAIL;
2804 }
2805 }
2806 return OK;
2807}
2808
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002809/*
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02002810 * Get the argument count for function "idx".
2811 * "argcount" is the total argument count, "min_argcount" the non-optional
2812 * argument count.
2813 */
2814 void
2815internal_func_get_argcount(int idx, int *argcount, int *min_argcount)
2816{
2817 *argcount = global_functions[idx].f_max_argc;
2818 *min_argcount = global_functions[idx].f_min_argc;
2819}
2820
2821/*
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002822 * Call the "f_retfunc" function to obtain the return type of function "idx".
Bram Moolenaar81330182022-02-01 12:11:58 +00002823 * "decl_type" is set to the declared type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002824 * "argtypes" is the list of argument types or NULL when there are no
2825 * arguments.
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02002826 * "argcount" may be less than the actual count when only getting the type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002827 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002828 type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00002829internal_func_ret_type(
2830 int idx,
2831 int argcount,
2832 type2_T *argtypes,
2833 type_T **decl_type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002834{
Bram Moolenaar81330182022-02-01 12:11:58 +00002835 type_T *ret;
2836
2837 *decl_type = NULL;
2838 ret = global_functions[idx].f_retfunc(argcount, argtypes, decl_type);
2839 if (*decl_type == NULL)
2840 *decl_type = ret;
2841 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002842}
2843
2844/*
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002845 * Return TRUE if "idx" is for the map() function.
2846 */
2847 int
2848internal_func_is_map(int idx)
2849{
2850 return global_functions[idx].f_func == f_map;
2851}
2852
2853/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002854 * Check the argument count to use for internal function "idx".
Bram Moolenaar389df252020-07-09 21:20:47 +02002855 * Returns -1 for failure, 0 if no method base accepted, 1 if method base is
2856 * first argument, 2 if method base is second argument, etc. 9 if method base
2857 * is last argument.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002858 */
2859 int
2860check_internal_func(int idx, int argcount)
2861{
2862 int res;
2863 char *name;
2864
2865 if (argcount < global_functions[idx].f_min_argc)
2866 res = FCERR_TOOFEW;
2867 else if (argcount > global_functions[idx].f_max_argc)
2868 res = FCERR_TOOMANY;
2869 else
Bram Moolenaar389df252020-07-09 21:20:47 +02002870 return global_functions[idx].f_argtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002871
2872 name = internal_func_name(idx);
2873 if (res == FCERR_TOOMANY)
Bram Moolenaare1242042021-12-16 20:56:57 +00002874 semsg(_(e_too_many_arguments_for_function_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002875 else
Bram Moolenaare1242042021-12-16 20:56:57 +00002876 semsg(_(e_not_enough_arguments_for_function_str), name);
Bram Moolenaar389df252020-07-09 21:20:47 +02002877 return -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002878}
2879
Bram Moolenaarac92e252019-08-03 21:58:38 +02002880 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002881call_internal_func(
2882 char_u *name,
2883 int argcount,
2884 typval_T *argvars,
2885 typval_T *rettv)
2886{
2887 int i;
2888
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002889 i = find_internal_func(name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002890 if (i < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002891 return FCERR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002892 if (argcount < global_functions[i].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002893 return FCERR_TOOFEW;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002894 if (argcount > global_functions[i].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002895 return FCERR_TOOMANY;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002896 argvars[argcount].v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002897 global_functions[i].f_func(argvars, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01002898 return FCERR_NONE;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002899}
2900
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002901 void
2902call_internal_func_by_idx(
2903 int idx,
2904 typval_T *argvars,
2905 typval_T *rettv)
2906{
2907 global_functions[idx].f_func(argvars, rettv);
2908}
2909
Bram Moolenaarac92e252019-08-03 21:58:38 +02002910/*
2911 * Invoke a method for base->method().
2912 */
2913 int
2914call_internal_method(
2915 char_u *name,
2916 int argcount,
2917 typval_T *argvars,
2918 typval_T *rettv,
2919 typval_T *basetv)
2920{
2921 int i;
2922 int fi;
2923 typval_T argv[MAX_FUNC_ARGS + 1];
2924
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002925 fi = find_internal_func(name);
Bram Moolenaar91746392019-08-16 22:22:31 +02002926 if (fi < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002927 return FCERR_UNKNOWN;
Bram Moolenaar91746392019-08-16 22:22:31 +02002928 if (global_functions[fi].f_argtype == 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002929 return FCERR_NOTMETHOD;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002930 if (argcount + 1 < global_functions[fi].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002931 return FCERR_TOOFEW;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002932 if (argcount + 1 > global_functions[fi].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002933 return FCERR_TOOMANY;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002934
Bram Moolenaarb3468902022-01-01 19:42:16 +00002935 if (global_functions[fi].f_argtype == FEARG_2)
Bram Moolenaar25e42232019-08-04 15:04:10 +02002936 {
2937 // base value goes second
2938 argv[0] = argvars[0];
2939 argv[1] = *basetv;
2940 for (i = 1; i < argcount; ++i)
2941 argv[i + 1] = argvars[i];
2942 }
Bram Moolenaar24278d22019-08-16 21:49:22 +02002943 else if (global_functions[fi].f_argtype == FEARG_3)
2944 {
2945 // base value goes third
2946 argv[0] = argvars[0];
2947 argv[1] = argvars[1];
2948 argv[2] = *basetv;
2949 for (i = 2; i < argcount; ++i)
2950 argv[i + 1] = argvars[i];
2951 }
Bram Moolenaaraad222c2019-09-06 22:46:09 +02002952 else if (global_functions[fi].f_argtype == FEARG_4)
2953 {
2954 // base value goes fourth
2955 argv[0] = argvars[0];
2956 argv[1] = argvars[1];
2957 argv[2] = argvars[2];
2958 argv[3] = *basetv;
2959 for (i = 3; i < argcount; ++i)
2960 argv[i + 1] = argvars[i];
2961 }
Bram Moolenaar25e42232019-08-04 15:04:10 +02002962 else
2963 {
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002964 // FEARG_1: base value goes first
Bram Moolenaar25e42232019-08-04 15:04:10 +02002965 argv[0] = *basetv;
2966 for (i = 0; i < argcount; ++i)
2967 argv[i + 1] = argvars[i];
2968 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02002969 argv[argcount + 1].v_type = VAR_UNKNOWN;
2970
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002971 global_functions[fi].f_func(argv, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01002972 return FCERR_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002973}
2974
2975/*
2976 * Return TRUE for a non-zero Number and a non-empty String.
2977 */
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02002978 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002979non_zero_arg(typval_T *argvars)
2980{
2981 return ((argvars[0].v_type == VAR_NUMBER
2982 && argvars[0].vval.v_number != 0)
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01002983 || (argvars[0].v_type == VAR_BOOL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002984 && argvars[0].vval.v_number == VVAL_TRUE)
2985 || (argvars[0].v_type == VAR_STRING
2986 && argvars[0].vval.v_string != NULL
2987 && *argvars[0].vval.v_string != NUL));
2988}
2989
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002990/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002991 * "and(expr, expr)" function
2992 */
2993 static void
2994f_and(typval_T *argvars, typval_T *rettv)
2995{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002996 if (in_vim9script()
2997 && (check_for_number_arg(argvars, 0) == FAIL
2998 || check_for_number_arg(argvars, 1) == FAIL))
2999 return;
3000
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003001 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
3002 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02003003}
3004
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003005/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01003006 * "balloon_show()" function
3007 */
3008#ifdef FEAT_BEVAL
3009 static void
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003010f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv)
3011{
3012 rettv->v_type = VAR_STRING;
3013 if (balloonEval != NULL)
3014 {
3015 if (balloonEval->msg == NULL)
3016 rettv->vval.v_string = NULL;
3017 else
3018 rettv->vval.v_string = vim_strsave(balloonEval->msg);
3019 }
3020}
3021
3022 static void
Bram Moolenaar59716a22017-03-01 20:32:44 +01003023f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
3024{
Bram Moolenaarcaf64342017-03-02 22:11:33 +01003025 if (balloonEval != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003026 {
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003027 if (in_vim9script()
3028 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3029 return;
3030
Bram Moolenaar246fe032017-11-19 19:56:27 +01003031 if (argvars[0].v_type == VAR_LIST
3032# ifdef FEAT_GUI
3033 && !gui.in_use
3034# endif
3035 )
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003036 {
3037 list_T *l = argvars[0].vval.v_list;
3038
3039 // empty list removes the balloon
3040 post_balloon(balloonEval, NULL,
3041 l == NULL || l->lv_len == 0 ? NULL : l);
3042 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003043 else
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003044 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003045 char_u *mesg;
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003046
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003047 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3048 return;
3049
3050 mesg = tv_get_string_chk(&argvars[0]);
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003051 if (mesg != NULL)
3052 // empty string removes the balloon
3053 post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL);
3054 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003055 }
3056}
3057
Bram Moolenaar669a8282017-11-19 20:13:05 +01003058# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003059 static void
3060f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
3061{
3062 if (rettv_list_alloc(rettv) == OK)
3063 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003064 char_u *msg;
Bram Moolenaar246fe032017-11-19 19:56:27 +01003065
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003066 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3067 return;
3068 msg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003069 if (msg != NULL)
3070 {
3071 pumitem_T *array;
3072 int size = split_message(msg, &array);
3073 int i;
3074
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003075 // Skip the first and last item, they are always empty.
Bram Moolenaar246fe032017-11-19 19:56:27 +01003076 for (i = 1; i < size - 1; ++i)
3077 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
Bram Moolenaarb301f6b2018-02-10 15:38:35 +01003078 while (size > 0)
3079 vim_free(array[--size].pum_text);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003080 vim_free(array);
3081 }
3082 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01003083}
Bram Moolenaar669a8282017-11-19 20:13:05 +01003084# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01003085#endif
3086
3087/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003088 * Get the buffer from "arg" and give an error and return NULL if it is not
3089 * valid.
3090 */
Bram Moolenaara3347722019-05-11 21:14:24 +02003091 buf_T *
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003092get_buf_arg(typval_T *arg)
3093{
3094 buf_T *buf;
3095
3096 ++emsg_off;
3097 buf = tv_get_buf(arg, FALSE);
3098 --emsg_off;
3099 if (buf == NULL)
Bram Moolenaard82a47d2022-01-05 20:24:39 +00003100 semsg(_(e_invalid_buffer_name_str), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003101 return buf;
3102}
3103
3104/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003105 * "byte2line(byte)" function
3106 */
3107 static void
3108f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
3109{
3110#ifndef FEAT_BYTEOFF
3111 rettv->vval.v_number = -1;
3112#else
3113 long boff = 0;
3114
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003115 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3116 return;
3117
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003118 boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003119 if (boff < 0)
3120 rettv->vval.v_number = -1;
3121 else
3122 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
3123 (linenr_T)0, &boff);
3124#endif
3125}
3126
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003127/*
3128 * "call(func, arglist [, dict])" function
3129 */
3130 static void
3131f_call(typval_T *argvars, typval_T *rettv)
3132{
3133 char_u *func;
3134 partial_T *partial = NULL;
3135 dict_T *selfdict = NULL;
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003136 char_u *dot;
3137 char_u *tofree = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003138
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003139 if (in_vim9script()
Bram Moolenaar223d0a62021-12-25 19:29:21 +00003140 && (check_for_string_or_func_arg(argvars, 0) == FAIL
3141 || check_for_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003142 || check_for_opt_dict_arg(argvars, 2) == FAIL))
3143 return;
3144
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003145 if (argvars[1].v_type != VAR_LIST)
3146 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00003147 emsg(_(e_list_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003148 return;
3149 }
3150 if (argvars[1].vval.v_list == NULL)
3151 return;
3152
3153 if (argvars[0].v_type == VAR_FUNC)
3154 func = argvars[0].vval.v_string;
3155 else if (argvars[0].v_type == VAR_PARTIAL)
3156 {
3157 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003158 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003159 }
3160 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003161 func = tv_get_string(&argvars[0]);
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003162 if (func == NULL || *func == NUL)
3163 return; // type error, empty name or null function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003164
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003165 dot = vim_strchr(func, '.');
3166 if (dot != NULL)
3167 {
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00003168 imported_T *import = find_imported(func, dot - func, TRUE);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003169
3170 if (import != NULL && SCRIPT_ID_VALID(import->imp_sid))
3171 {
3172 scriptitem_T *si = SCRIPT_ITEM(import->imp_sid);
3173
3174 if (si->sn_autoload_prefix != NULL)
3175 {
3176 // Turn "import.Func" into "scriptname#Func".
3177 tofree = concat_str(si->sn_autoload_prefix, dot + 1);
3178 if (tofree == NULL)
3179 return;
3180 func = tofree;
3181 }
3182 }
3183 }
3184
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003185 if (argvars[2].v_type != VAR_UNKNOWN)
3186 {
3187 if (argvars[2].v_type != VAR_DICT)
3188 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00003189 emsg(_(e_dictionary_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003190 return;
3191 }
3192 selfdict = argvars[2].vval.v_dict;
3193 }
3194
3195 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003196
3197 vim_free(tofree);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003198}
3199
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003200/*
3201 * "changenr()" function
3202 */
3203 static void
3204f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
3205{
3206 rettv->vval.v_number = curbuf->b_u_seq_cur;
3207}
3208
3209/*
3210 * "char2nr(string)" function
3211 */
3212 static void
3213f_char2nr(typval_T *argvars, typval_T *rettv)
3214{
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003215 if (in_vim9script()
3216 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003217 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003218 return;
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003219
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003220 if (has_mbyte)
3221 {
3222 int utf8 = 0;
3223
3224 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar24f77502020-09-04 19:50:57 +02003225 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003226
3227 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01003228 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003229 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003230 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003231 }
3232 else
Bram Moolenaar13505972019-01-24 15:04:48 +01003233 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003234}
3235
Bram Moolenaar17793ef2020-12-28 12:56:58 +01003236/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003237 * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE,
3238 * returns the character index of the column. Otherwise, returns the byte index
3239 * of the column.
3240 */
3241 static void
3242get_col(typval_T *argvars, typval_T *rettv, int charcol)
3243{
3244 colnr_T col = 0;
3245 pos_T *fp;
3246 int fnum = curbuf->b_fnum;
3247
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003248 if (in_vim9script()
3249 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3250 return;
3251
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003252 fp = var2fpos(&argvars[0], FALSE, &fnum, charcol);
3253 if (fp != NULL && fnum == curbuf->b_fnum)
3254 {
3255 if (fp->col == MAXCOL)
3256 {
3257 // '> can be MAXCOL, get the length of the line then
3258 if (fp->lnum <= curbuf->b_ml.ml_line_count)
3259 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
3260 else
3261 col = MAXCOL;
3262 }
3263 else
3264 {
3265 col = fp->col + 1;
3266 // col(".") when the cursor is on the NUL at the end of the line
3267 // because of "coladd" can be seen as an extra column.
3268 if (virtual_active() && fp == &curwin->w_cursor)
3269 {
3270 char_u *p = ml_get_cursor();
3271
3272 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
3273 curwin->w_virtcol - curwin->w_cursor.coladd))
3274 {
3275 int l;
3276
3277 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
3278 col += l;
3279 }
3280 }
3281 }
3282 }
3283 rettv->vval.v_number = col;
3284}
3285
3286/*
3287 * "charcol()" function
3288 */
3289 static void
3290f_charcol(typval_T *argvars, typval_T *rettv)
3291{
3292 get_col(argvars, rettv, TRUE);
3293}
3294
Bram Moolenaar29b7d7a2019-07-22 23:03:57 +02003295 win_T *
Bram Moolenaaraff74912019-03-30 18:11:49 +01003296get_optional_window(typval_T *argvars, int idx)
3297{
3298 win_T *win = curwin;
3299
3300 if (argvars[idx].v_type != VAR_UNKNOWN)
3301 {
3302 win = find_win_by_nr_or_id(&argvars[idx]);
3303 if (win == NULL)
3304 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00003305 emsg(_(e_invalid_window_number));
Bram Moolenaaraff74912019-03-30 18:11:49 +01003306 return NULL;
3307 }
3308 }
3309 return win;
3310}
3311
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003312/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003313 * "col(string)" function
3314 */
3315 static void
3316f_col(typval_T *argvars, typval_T *rettv)
3317{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003318 get_col(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003319}
3320
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003321/*
3322 * "confirm(message, buttons[, default [, type]])" function
3323 */
3324 static void
3325f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3326{
3327#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3328 char_u *message;
3329 char_u *buttons = NULL;
3330 char_u buf[NUMBUFLEN];
3331 char_u buf2[NUMBUFLEN];
3332 int def = 1;
3333 int type = VIM_GENERIC;
3334 char_u *typestr;
3335 int error = FALSE;
3336
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02003337 if (in_vim9script()
3338 && (check_for_string_arg(argvars, 0) == FAIL
3339 || (check_for_opt_string_arg(argvars, 1) == FAIL
3340 || (argvars[1].v_type != VAR_UNKNOWN
3341 && (check_for_opt_number_arg(argvars, 2) == FAIL
3342 || (argvars[2].v_type != VAR_UNKNOWN
3343 && check_for_opt_string_arg(argvars, 3) == FAIL))))))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003344 return;
3345
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003346 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003347 if (message == NULL)
3348 error = TRUE;
3349 if (argvars[1].v_type != VAR_UNKNOWN)
3350 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003351 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003352 if (buttons == NULL)
3353 error = TRUE;
3354 if (argvars[2].v_type != VAR_UNKNOWN)
3355 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003356 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003357 if (argvars[3].v_type != VAR_UNKNOWN)
3358 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003359 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003360 if (typestr == NULL)
3361 error = TRUE;
3362 else
3363 {
3364 switch (TOUPPER_ASC(*typestr))
3365 {
3366 case 'E': type = VIM_ERROR; break;
3367 case 'Q': type = VIM_QUESTION; break;
3368 case 'I': type = VIM_INFO; break;
3369 case 'W': type = VIM_WARNING; break;
3370 case 'G': type = VIM_GENERIC; break;
3371 }
3372 }
3373 }
3374 }
3375 }
3376
3377 if (buttons == NULL || *buttons == NUL)
3378 buttons = (char_u *)_("&Ok");
3379
3380 if (!error)
3381 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
3382 def, NULL, FALSE);
3383#endif
3384}
3385
3386/*
3387 * "copy()" function
3388 */
3389 static void
3390f_copy(typval_T *argvars, typval_T *rettv)
3391{
Bram Moolenaar381692b2022-02-02 20:01:27 +00003392 item_copy(&argvars[0], rettv, FALSE, TRUE, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003393}
3394
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003395/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003396 * Set the cursor position.
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003397 * If 'charcol' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003398 * Otherwise use the column number as a byte offset.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003399 */
3400 static void
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003401set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003402{
3403 long line, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003404 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003405 int set_curswant = TRUE;
3406
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003407 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003408 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02003409 || check_for_opt_number_arg(argvars, 1) == FAIL
3410 || (argvars[1].v_type != VAR_UNKNOWN
3411 && check_for_opt_number_arg(argvars, 2) == FAIL)))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003412 return;
3413
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003414 rettv->vval.v_number = -1;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003415 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003416 {
3417 pos_T pos;
3418 colnr_T curswant = -1;
3419
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003420 if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003421 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003422 emsg(_(e_invalid_argument));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003423 return;
3424 }
3425 line = pos.lnum;
3426 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003427 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003428 if (curswant >= 0)
3429 {
3430 curwin->w_curswant = curswant - 1;
3431 set_curswant = FALSE;
3432 }
3433 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003434 else if ((argvars[0].v_type == VAR_NUMBER ||
3435 argvars[0].v_type == VAR_STRING)
Bram Moolenaar9ebcf232021-01-16 16:52:49 +01003436 && (argvars[1].v_type == VAR_NUMBER ||
3437 argvars[1].v_type == VAR_STRING))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003438 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003439 line = tv_get_lnum(argvars);
Bram Moolenaar9a963372020-12-21 21:58:46 +01003440 if (line < 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003441 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003442 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003443 if (charcol)
Bram Moolenaar91458462021-01-13 20:08:38 +01003444 col = buf_charidx_to_byteidx(curbuf, line, col) + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003445 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003446 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003447 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003448 else
3449 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003450 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003451 return;
3452 }
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01003453 if (line < 0 || col < 0 || coladd < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003454 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003455 if (line > 0)
3456 curwin->w_cursor.lnum = line;
3457 if (col > 0)
3458 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003459 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003460
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003461 // Make sure the cursor is in a valid position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003462 check_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003463 // Correct cursor for multi-byte character.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003464 if (has_mbyte)
3465 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003466
3467 curwin->w_set_curswant = set_curswant;
3468 rettv->vval.v_number = 0;
3469}
3470
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003471/*
3472 * "cursor(lnum, col)" function, or
3473 * "cursor(list)"
3474 *
3475 * Moves the cursor to the specified line and column.
3476 * Returns 0 when the position could be set, -1 otherwise.
3477 */
3478 static void
3479f_cursor(typval_T *argvars, typval_T *rettv)
3480{
3481 set_cursorpos(argvars, rettv, FALSE);
3482}
3483
Bram Moolenaar4f974752019-02-17 17:44:42 +01003484#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003485/*
3486 * "debugbreak()" function
3487 */
3488 static void
3489f_debugbreak(typval_T *argvars, typval_T *rettv)
3490{
3491 int pid;
3492
3493 rettv->vval.v_number = FAIL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003494 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3495 return;
3496
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003497 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003498 if (pid == 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003499 emsg(_(e_invalid_argument));
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003500 else
3501 {
3502 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
3503
3504 if (hProcess != NULL)
3505 {
3506 DebugBreakProcess(hProcess);
3507 CloseHandle(hProcess);
3508 rettv->vval.v_number = OK;
3509 }
3510 }
3511}
3512#endif
3513
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003514/*
3515 * "deepcopy()" function
3516 */
3517 static void
3518f_deepcopy(typval_T *argvars, typval_T *rettv)
3519{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003520 varnumber_T noref = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003521 int copyID;
3522
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003523 if (in_vim9script()
3524 && (check_for_opt_bool_arg(argvars, 1) == FAIL))
3525 return;
3526
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003527 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003528 noref = tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003529 if (noref < 0 || noref > 1)
Bram Moolenaarbade44e2020-09-26 22:39:24 +02003530 semsg(_(e_using_number_as_bool_nr), noref);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003531 else
3532 {
3533 copyID = get_copyID();
Bram Moolenaar381692b2022-02-02 20:01:27 +00003534 item_copy(&argvars[0], rettv, TRUE, TRUE, noref == 0 ? copyID : 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003535 }
3536}
3537
3538/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003539 * "did_filetype()" function
3540 */
3541 static void
3542f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3543{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003544 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003545}
3546
3547/*
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003548 * "echoraw({expr})" function
3549 */
3550 static void
3551f_echoraw(typval_T *argvars, typval_T *rettv UNUSED)
3552{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003553 char_u *str;
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003554
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003555 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3556 return;
3557
3558 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003559 if (str != NULL && *str != NUL)
3560 {
3561 out_str(str);
3562 out_flush();
3563 }
3564}
3565
3566/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003567 * "empty({expr})" function
3568 */
3569 static void
3570f_empty(typval_T *argvars, typval_T *rettv)
3571{
3572 int n = FALSE;
3573
3574 switch (argvars[0].v_type)
3575 {
3576 case VAR_STRING:
3577 case VAR_FUNC:
3578 n = argvars[0].vval.v_string == NULL
3579 || *argvars[0].vval.v_string == NUL;
3580 break;
3581 case VAR_PARTIAL:
3582 n = FALSE;
3583 break;
3584 case VAR_NUMBER:
3585 n = argvars[0].vval.v_number == 0;
3586 break;
3587 case VAR_FLOAT:
3588#ifdef FEAT_FLOAT
3589 n = argvars[0].vval.v_float == 0.0;
3590 break;
3591#endif
3592 case VAR_LIST:
3593 n = argvars[0].vval.v_list == NULL
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003594 || argvars[0].vval.v_list->lv_len == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003595 break;
3596 case VAR_DICT:
3597 n = argvars[0].vval.v_dict == NULL
3598 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
3599 break;
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003600 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003601 case VAR_SPECIAL:
3602 n = argvars[0].vval.v_number != VVAL_TRUE;
3603 break;
3604
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003605 case VAR_BLOB:
3606 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003607 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
3608 break;
3609
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003610 case VAR_JOB:
3611#ifdef FEAT_JOB_CHANNEL
3612 n = argvars[0].vval.v_job == NULL
3613 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
3614 break;
3615#endif
3616 case VAR_CHANNEL:
3617#ifdef FEAT_JOB_CHANNEL
3618 n = argvars[0].vval.v_channel == NULL
3619 || !channel_is_open(argvars[0].vval.v_channel);
3620 break;
3621#endif
3622 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02003623 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003624 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003625 case VAR_INSTR:
Bram Moolenaardd589232020-02-29 17:38:12 +01003626 internal_error_no_abort("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003627 n = TRUE;
3628 break;
3629 }
3630
3631 rettv->vval.v_number = n;
3632}
3633
3634/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003635 * "environ()" function
3636 */
3637 static void
3638f_environ(typval_T *argvars UNUSED, typval_T *rettv)
3639{
3640#if !defined(AMIGA)
3641 int i = 0;
3642 char_u *entry, *value;
3643# ifdef MSWIN
3644 extern wchar_t **_wenviron;
3645# else
3646 extern char **environ;
3647# endif
3648
3649 if (rettv_dict_alloc(rettv) != OK)
3650 return;
3651
3652# ifdef MSWIN
3653 if (*_wenviron == NULL)
3654 return;
3655# else
3656 if (*environ == NULL)
3657 return;
3658# endif
3659
3660 for (i = 0; ; ++i)
3661 {
3662# ifdef MSWIN
3663 short_u *p;
3664
3665 if ((p = (short_u *)_wenviron[i]) == NULL)
3666 return;
3667 entry = utf16_to_enc(p, NULL);
3668# else
3669 if ((entry = (char_u *)environ[i]) == NULL)
3670 return;
3671 entry = vim_strsave(entry);
3672# endif
3673 if (entry == NULL) // out of memory
3674 return;
3675 if ((value = vim_strchr(entry, '=')) == NULL)
3676 {
3677 vim_free(entry);
3678 continue;
3679 }
3680 *value++ = NUL;
3681 dict_add_string(rettv->vval.v_dict, (char *)entry, value);
3682 vim_free(entry);
3683 }
3684#endif
3685}
3686
3687/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003688 * "escape({string}, {chars})" function
3689 */
3690 static void
3691f_escape(typval_T *argvars, typval_T *rettv)
3692{
3693 char_u buf[NUMBUFLEN];
3694
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003695 if (in_vim9script()
3696 && (check_for_string_arg(argvars, 0) == FAIL
3697 || check_for_string_arg(argvars, 1) == FAIL))
3698 return;
3699
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003700 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
3701 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003702 rettv->v_type = VAR_STRING;
3703}
3704
3705/*
3706 * "eval()" function
3707 */
3708 static void
3709f_eval(typval_T *argvars, typval_T *rettv)
3710{
3711 char_u *s, *p;
3712
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003713 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3714 return;
3715
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003716 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003717 if (s != NULL)
3718 s = skipwhite(s);
3719
3720 p = s;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003721 if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003722 {
3723 if (p != NULL && !aborting())
Bram Moolenaar108010a2021-06-27 22:03:33 +02003724 semsg(_(e_invalid_expression_str), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003725 need_clr_eos = FALSE;
3726 rettv->v_type = VAR_NUMBER;
3727 rettv->vval.v_number = 0;
3728 }
3729 else if (*s != NUL)
Bram Moolenaar74409f62022-01-01 15:58:22 +00003730 semsg(_(e_trailing_characters_str), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003731}
3732
3733/*
3734 * "eventhandler()" function
3735 */
3736 static void
3737f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
3738{
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003739 rettv->vval.v_number = vgetc_busy || input_busy;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003740}
3741
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003742static garray_T redir_execute_ga;
3743
3744/*
3745 * Append "value[value_len]" to the execute() output.
3746 */
3747 void
3748execute_redir_str(char_u *value, int value_len)
3749{
3750 int len;
3751
3752 if (value_len == -1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003753 len = (int)STRLEN(value); // Append the entire string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003754 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003755 len = value_len; // Append only "value_len" characters
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003756 if (ga_grow(&redir_execute_ga, len) == OK)
3757 {
3758 mch_memmove((char *)redir_execute_ga.ga_data
3759 + redir_execute_ga.ga_len, value, len);
3760 redir_execute_ga.ga_len += len;
3761 }
3762}
3763
Dominique Pelle748b3082022-01-08 12:41:16 +00003764#if defined(FEAT_LUA) || defined(PROTO)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003765/*
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003766 * Get next line from a string containing NL separated lines.
3767 * Called by do_cmdline() to get the next line.
3768 * Returns an allocated string, or NULL when at the end of the string.
3769 */
3770 static char_u *
3771get_str_line(
3772 int c UNUSED,
3773 void *cookie,
3774 int indent UNUSED,
3775 getline_opt_T options UNUSED)
3776{
3777 char_u *start = *(char_u **)cookie;
3778 char_u *line;
3779 char_u *p;
3780
3781 p = start;
3782 if (p == NULL || *p == NUL)
3783 return NULL;
3784 p = vim_strchr(p, '\n');
3785 if (p == NULL)
3786 line = vim_strsave(start);
3787 else
3788 {
3789 line = vim_strnsave(start, p - start);
3790 p++;
3791 }
3792
3793 *(char_u **)cookie = p;
3794 return line;
3795}
3796
3797/*
3798 * Execute a series of Ex commands in 'str'
3799 */
3800 void
3801execute_cmds_from_string(char_u *str)
3802{
3803 do_cmdline(NULL, get_str_line, (void *)&str,
3804 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3805}
Dominique Pelle748b3082022-01-08 12:41:16 +00003806#endif
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003807
3808/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003809 * Get next line from a list.
3810 * Called by do_cmdline() to get the next line.
3811 * Returns allocated string, or NULL for end of function.
3812 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003813 static char_u *
3814get_list_line(
3815 int c UNUSED,
3816 void *cookie,
Bram Moolenaare96a2492019-06-25 04:12:16 +02003817 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02003818 getline_opt_T options UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003819{
3820 listitem_T **p = (listitem_T **)cookie;
3821 listitem_T *item = *p;
3822 char_u buf[NUMBUFLEN];
3823 char_u *s;
3824
3825 if (item == NULL)
3826 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003827 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003828 *p = item->li_next;
3829 return s == NULL ? NULL : vim_strsave(s);
3830}
3831
3832/*
3833 * "execute()" function
3834 */
Bram Moolenaar261f3462019-09-07 15:45:32 +02003835 void
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003836execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003837{
3838 char_u *cmd = NULL;
3839 list_T *list = NULL;
3840 int save_msg_silent = msg_silent;
3841 int save_emsg_silent = emsg_silent;
3842 int save_emsg_noredir = emsg_noredir;
3843 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01003844 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003845 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003846 int save_msg_col = msg_col;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003847 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003848
3849 rettv->vval.v_string = NULL;
3850 rettv->v_type = VAR_STRING;
3851
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003852 if (argvars[arg_off].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003853 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003854 list = argvars[arg_off].vval.v_list;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003855 if (list == NULL || list->lv_len == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003856 // empty list, no commands, empty output
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003857 return;
3858 ++list->lv_refcount;
3859 }
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003860 else if (argvars[arg_off].v_type == VAR_JOB
3861 || argvars[arg_off].v_type == VAR_CHANNEL)
3862 {
Bram Moolenaar68db9962021-05-09 23:19:22 +02003863 semsg(_(e_using_invalid_value_as_string_str),
3864 vartype_name(argvars[arg_off].v_type));
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003865 return;
3866 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003867 else
3868 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003869 cmd = tv_get_string_chk(&argvars[arg_off]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003870 if (cmd == NULL)
3871 return;
3872 }
3873
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003874 if (argvars[arg_off + 1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003875 {
3876 char_u buf[NUMBUFLEN];
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02003877 char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf,
3878 in_vim9script());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003879
3880 if (s == NULL)
3881 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003882 if (*s == NUL)
3883 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003884 if (STRNCMP(s, "silent", 6) == 0)
3885 ++msg_silent;
3886 if (STRCMP(s, "silent!") == 0)
3887 {
3888 emsg_silent = TRUE;
3889 emsg_noredir = TRUE;
3890 }
3891 }
3892 else
3893 ++msg_silent;
3894
3895 if (redir_execute)
3896 save_ga = redir_execute_ga;
Bram Moolenaar04935fb2022-01-08 16:19:22 +00003897 ga_init2(&redir_execute_ga, sizeof(char), 500);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003898 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01003899 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003900 if (!echo_output)
3901 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003902
3903 if (cmd != NULL)
3904 do_cmdline_cmd(cmd);
3905 else
3906 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003907 listitem_T *item;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003908
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02003909 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003910 item = list->lv_first;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003911 do_cmdline(NULL, get_list_line, (void *)&item,
3912 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3913 --list->lv_refcount;
3914 }
3915
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003916 // Need to append a NUL to the result.
Bram Moolenaard297f352017-01-29 20:31:21 +01003917 if (ga_grow(&redir_execute_ga, 1) == OK)
3918 {
3919 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
3920 rettv->vval.v_string = redir_execute_ga.ga_data;
3921 }
3922 else
3923 {
3924 ga_clear(&redir_execute_ga);
3925 rettv->vval.v_string = NULL;
3926 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003927 msg_silent = save_msg_silent;
3928 emsg_silent = save_emsg_silent;
3929 emsg_noredir = save_emsg_noredir;
3930
3931 redir_execute = save_redir_execute;
3932 if (redir_execute)
3933 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01003934 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003935
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003936 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003937 if (echo_output)
3938 // When not working silently: put it in column zero. A following
3939 // "echon" will overwrite the message, unavoidably.
3940 msg_col = 0;
3941 else
3942 // When working silently: Put it back where it was, since nothing
3943 // should have been written.
3944 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003945}
3946
3947/*
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003948 * "execute()" function
3949 */
3950 static void
3951f_execute(typval_T *argvars, typval_T *rettv)
3952{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003953 if (in_vim9script()
3954 && (check_for_string_or_list_arg(argvars, 0) == FAIL
3955 || check_for_opt_string_arg(argvars, 1) == FAIL))
3956 return;
3957
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003958 execute_common(argvars, rettv, 0);
3959}
3960
3961/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003962 * "exists()" function
3963 */
Bram Moolenaarbb7ee7a2021-08-02 20:06:50 +02003964 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003965f_exists(typval_T *argvars, typval_T *rettv)
3966{
3967 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003968 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003969
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003970 if (in_vim9script() && check_for_nonempty_string_arg(argvars, 0) == FAIL)
3971 return;
3972
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003973 p = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003974 if (*p == '$') // environment variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003975 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003976 // first try "normal" environment variables (fast)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003977 if (mch_getenv(p + 1) != NULL)
3978 n = TRUE;
3979 else
3980 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003981 // try expanding things like $VIM and ${HOME}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003982 p = expand_env_save(p);
3983 if (p != NULL && *p != '$')
3984 n = TRUE;
3985 vim_free(p);
3986 }
3987 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003988 else if (*p == '&' || *p == '+') // option
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003989 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003990 n = (eval_option(&p, NULL, TRUE) == OK);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003991 if (*skipwhite(p) != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003992 n = FALSE; // trailing garbage
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003993 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003994 else if (*p == '*') // internal or user defined function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003995 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02003996 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003997 }
Bram Moolenaar15c47602020-03-26 22:16:48 +01003998 else if (*p == '?') // internal function only
3999 {
4000 n = has_internal_func_name(p + 1);
4001 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004002 else if (*p == ':')
4003 {
4004 n = cmd_exists(p + 1);
4005 }
4006 else if (*p == '#')
4007 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004008 if (p[1] == '#')
4009 n = autocmd_supported(p + 2);
4010 else
4011 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004012 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004013 else // internal variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004014 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01004015 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004016 }
4017
4018 rettv->vval.v_number = n;
4019}
4020
Bram Moolenaar26735992021-08-08 14:43:22 +02004021 static void
4022f_exists_compiled(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4023{
4024 emsg(_(e_exists_compiled_can_only_be_used_in_def_function));
4025}
4026
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004027/*
4028 * "expand()" function
4029 */
4030 static void
4031f_expand(typval_T *argvars, typval_T *rettv)
4032{
4033 char_u *s;
4034 int len;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004035 char *errormsg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004036 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4037 expand_T xpc;
4038 int error = FALSE;
4039 char_u *result;
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004040#ifdef BACKSLASH_IN_FILENAME
4041 char_u *p_csl_save = p_csl;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004042#endif
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004043
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004044 if (in_vim9script()
4045 && (check_for_string_arg(argvars, 0) == FAIL
4046 || check_for_opt_bool_arg(argvars, 1) == FAIL
4047 || (argvars[1].v_type != VAR_UNKNOWN
4048 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
4049 return;
4050
4051#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004052 // avoid using 'completeslash' here
4053 p_csl = empty_option;
4054#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004055
4056 rettv->v_type = VAR_STRING;
4057 if (argvars[1].v_type != VAR_UNKNOWN
4058 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004059 && tv_get_bool_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004060 && !error)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004061 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004062
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004063 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004064 if (*s == '%' || *s == '#' || *s == '<')
4065 {
4066 ++emsg_off;
4067 result = eval_vars(s, s, &len, NULL, &errormsg, NULL);
4068 --emsg_off;
4069 if (rettv->v_type == VAR_LIST)
4070 {
4071 if (rettv_list_alloc(rettv) != FAIL && result != NULL)
4072 list_append_string(rettv->vval.v_list, result, -1);
Bram Moolenaar86173482019-10-01 17:02:16 +02004073 vim_free(result);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004074 }
4075 else
4076 rettv->vval.v_string = result;
4077 }
4078 else
4079 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004080 // When the optional second argument is non-zero, don't remove matches
4081 // for 'wildignore' and don't put matches for 'suffixes' at the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004082 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004083 && tv_get_bool_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004084 options |= WILD_KEEP_ALL;
4085 if (!error)
4086 {
4087 ExpandInit(&xpc);
4088 xpc.xp_context = EXPAND_FILES;
4089 if (p_wic)
4090 options += WILD_ICASE;
4091 if (rettv->v_type == VAR_STRING)
4092 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
4093 options, WILD_ALL);
4094 else if (rettv_list_alloc(rettv) != FAIL)
4095 {
4096 int i;
4097
4098 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
4099 for (i = 0; i < xpc.xp_numfiles; i++)
4100 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
4101 ExpandCleanup(&xpc);
4102 }
4103 }
4104 else
4105 rettv->vval.v_string = NULL;
4106 }
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004107#ifdef BACKSLASH_IN_FILENAME
4108 p_csl = p_csl_save;
4109#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004110}
4111
4112/*
Bram Moolenaar80dad482019-06-09 17:22:31 +02004113 * "expandcmd()" function
4114 * Expand all the special characters in a command string.
4115 */
4116 static void
4117f_expandcmd(typval_T *argvars, typval_T *rettv)
4118{
4119 exarg_T eap;
4120 char_u *cmdstr;
4121 char *errormsg = NULL;
4122
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004123 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4124 return;
4125
Bram Moolenaar80dad482019-06-09 17:22:31 +02004126 rettv->v_type = VAR_STRING;
4127 cmdstr = vim_strsave(tv_get_string(&argvars[0]));
4128
4129 memset(&eap, 0, sizeof(eap));
4130 eap.cmd = cmdstr;
4131 eap.arg = cmdstr;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004132 eap.argt |= EX_NOSPC;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004133 eap.usefilter = FALSE;
4134 eap.nextcmd = NULL;
4135 eap.cmdidx = CMD_USER;
4136
4137 expand_filename(&eap, &cmdstr, &errormsg);
4138 if (errormsg != NULL && *errormsg != NUL)
4139 emsg(errormsg);
4140
4141 rettv->vval.v_string = cmdstr;
4142}
4143
4144/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004145 * "feedkeys()" function
4146 */
4147 static void
4148f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
4149{
4150 int remap = TRUE;
4151 int insert = FALSE;
4152 char_u *keys, *flags;
4153 char_u nbuf[NUMBUFLEN];
4154 int typed = FALSE;
4155 int execute = FALSE;
Bram Moolenaara9725222022-01-16 13:30:33 +00004156 int context = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004157 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004158 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004159 char_u *keys_esc;
4160
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004161 // This is not allowed in the sandbox. If the commands would still be
4162 // executed in the sandbox it would be OK, but it probably happens later,
4163 // when "sandbox" is no longer set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004164 if (check_secure())
4165 return;
4166
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004167 if (in_vim9script()
4168 && (check_for_string_arg(argvars, 0) == FAIL
4169 || check_for_opt_string_arg(argvars, 1) == FAIL))
4170 return;
4171
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004172 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004173
4174 if (argvars[1].v_type != VAR_UNKNOWN)
4175 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004176 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004177 for ( ; *flags != NUL; ++flags)
4178 {
4179 switch (*flags)
4180 {
4181 case 'n': remap = FALSE; break;
4182 case 'm': remap = TRUE; break;
4183 case 't': typed = TRUE; break;
4184 case 'i': insert = TRUE; break;
4185 case 'x': execute = TRUE; break;
Bram Moolenaara9725222022-01-16 13:30:33 +00004186 case 'c': context = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004187 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004188 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004189 }
4190 }
4191 }
4192
4193 if (*keys != NUL || execute)
4194 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004195 // Need to escape K_SPECIAL and CSI before putting the string in the
4196 // typeahead buffer.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004197 keys_esc = vim_strsave_escape_csi(keys);
4198 if (keys_esc != NULL)
4199 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004200 if (lowlevel)
4201 {
4202#ifdef USE_INPUT_BUF
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01004203 int idx;
4204 int len = (int)STRLEN(keys);
4205
4206 for (idx = 0; idx < len; ++idx)
4207 {
4208 // if a CTRL-C was typed, set got_int, similar to what
4209 // happens in fill_input_buf()
4210 if (keys[idx] == 3 && ctrl_c_interrupts && typed)
4211 got_int = TRUE;
4212 add_to_input_buf(keys + idx, 1);
4213 }
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004214#else
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004215 emsg(_(e_lowlevel_input_not_supported));
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004216#endif
4217 }
4218 else
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004219 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004220 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004221 insert ? 0 : typebuf.tb_len, !typed, FALSE);
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004222 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004223#ifdef FEAT_TIMERS
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004224 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004225#endif
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004226 || input_busy)
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004227 typebuf_was_filled = TRUE;
4228 }
4229 vim_free(keys_esc);
4230
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004231 if (execute)
4232 {
Bram Moolenaara9725222022-01-16 13:30:33 +00004233 int save_msg_scroll = msg_scroll;
4234 sctx_T save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004235
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004236 // Avoid a 1 second delay when the keys start Insert mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004237 msg_scroll = FALSE;
4238
Bram Moolenaara9725222022-01-16 13:30:33 +00004239 if (context)
4240 {
4241 save_sctx = current_sctx;
4242 current_sctx.sc_sid = 0;
4243 current_sctx.sc_version = 0;
4244 }
4245
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004246 if (!dangerous)
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004247 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004248 ++ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004249 ++in_feedkeys;
4250 }
Bram Moolenaar905dd902019-04-07 14:21:47 +02004251 exec_normal(TRUE, lowlevel, TRUE);
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004252 if (!dangerous)
Bram Moolenaar189832b2020-09-23 12:29:11 +02004253 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004254 --ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004255 --in_feedkeys;
Bram Moolenaar189832b2020-09-23 12:29:11 +02004256 }
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004257
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004258 msg_scroll |= save_msg_scroll;
Bram Moolenaara9725222022-01-16 13:30:33 +00004259
4260 if (context)
4261 current_sctx = save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004262 }
4263 }
4264 }
4265}
4266
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004267/*
4268 * "fnameescape({string})" function
4269 */
4270 static void
4271f_fnameescape(typval_T *argvars, typval_T *rettv)
4272{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004273 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4274 return;
4275
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004276 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01004277 tv_get_string(&argvars[0]), VSE_NONE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004278 rettv->v_type = VAR_STRING;
4279}
4280
4281/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004282 * "foreground()" function
4283 */
4284 static void
4285f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4286{
4287#ifdef FEAT_GUI
4288 if (gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004289 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004290 gui_mch_set_foreground();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004291 return;
4292 }
4293#endif
4294#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004295 win32_set_foreground();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004296#endif
4297}
4298
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004299 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004300common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004301{
4302 char_u *s;
4303 char_u *name;
4304 int use_string = FALSE;
4305 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004306 char_u *trans_name = NULL;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004307 int is_global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004308
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004309 if (in_vim9script()
Bram Moolenaarae1068a2021-12-25 19:43:44 +00004310 && (check_for_string_or_func_arg(argvars, 0) == FAIL
4311 || check_for_opt_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004312 || (argvars[1].v_type != VAR_UNKNOWN
4313 && check_for_opt_dict_arg(argvars, 2) == FAIL)))
4314 return;
4315
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004316 if (argvars[0].v_type == VAR_FUNC)
4317 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004318 // function(MyFunc, [arg], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004319 s = argvars[0].vval.v_string;
4320 }
4321 else if (argvars[0].v_type == VAR_PARTIAL
4322 && argvars[0].vval.v_partial != NULL)
4323 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004324 // function(dict.MyFunc, [arg])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004325 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004326 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004327 }
4328 else
4329 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004330 // function('MyFunc', [arg], dict)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004331 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004332 use_string = TRUE;
4333 }
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004334 if (s == NULL)
4335 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004336 semsg(_(e_invalid_argument_str), "NULL");
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004337 return;
4338 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004339
Bram Moolenaar843b8842016-08-21 14:36:15 +02004340 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004341 {
4342 name = s;
Bram Moolenaareba3b7f2021-11-30 18:25:08 +00004343 trans_name = save_function_name(&name, &is_global, FALSE,
4344 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004345 if (*name != NUL)
4346 s = NULL;
4347 }
4348
Bram Moolenaar843b8842016-08-21 14:36:15 +02004349 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
4350 || (is_funcref && trans_name == NULL))
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004351 semsg(_(e_invalid_argument_str), use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004352 // Don't check an autoload name for existence here.
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004353 else if (trans_name != NULL && (is_funcref
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004354 ? find_func(trans_name, is_global) == NULL
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004355 : !translated_function_exists(trans_name, is_global)))
Bram Moolenaara6f79292022-01-04 21:30:47 +00004356 semsg(_(e_unknown_function_str_2), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004357 else
4358 {
4359 int dict_idx = 0;
4360 int arg_idx = 0;
4361 list_T *list = NULL;
4362
4363 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004364 // Expand s: and <SID> into <SNR>nr_, so that the function can
4365 // also be called from another script. Using trans_function_name()
4366 // would also work, but some plugins depend on the name being
4367 // printable text.
Yegappan Lakshmanane7f4abd2021-12-24 20:47:38 +00004368 name = get_scriptlocal_funcname(s);
Bram Moolenaarc2f17f72022-02-21 13:13:50 +00004369 else if (trans_name != NULL && *trans_name == K_SPECIAL)
4370 name = alloc_printable_func_name(trans_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004371 else
4372 name = vim_strsave(s);
4373
4374 if (argvars[1].v_type != VAR_UNKNOWN)
4375 {
4376 if (argvars[2].v_type != VAR_UNKNOWN)
4377 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004378 // function(name, [args], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004379 arg_idx = 1;
4380 dict_idx = 2;
4381 }
4382 else if (argvars[1].v_type == VAR_DICT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004383 // function(name, dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004384 dict_idx = 1;
4385 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004386 // function(name, [args])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004387 arg_idx = 1;
4388 if (dict_idx > 0)
4389 {
4390 if (argvars[dict_idx].v_type != VAR_DICT)
4391 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004392 emsg(_(e_expected_dict));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004393 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004394 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004395 }
4396 if (argvars[dict_idx].vval.v_dict == NULL)
4397 dict_idx = 0;
4398 }
4399 if (arg_idx > 0)
4400 {
4401 if (argvars[arg_idx].v_type != VAR_LIST)
4402 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004403 emsg(_(e_second_argument_of_function_must_be_list_or_dict));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004404 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004405 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004406 }
4407 list = argvars[arg_idx].vval.v_list;
4408 if (list == NULL || list->lv_len == 0)
4409 arg_idx = 0;
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004410 else if (list->lv_len > MAX_FUNC_ARGS)
4411 {
Bram Moolenaare1242042021-12-16 20:56:57 +00004412 emsg_funcname((char *)e_too_many_arguments_for_function_str,
4413 s);
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004414 vim_free(name);
4415 goto theend;
4416 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004417 }
4418 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004419 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004420 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004421 partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004422
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004423 // result is a VAR_PARTIAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004424 if (pt == NULL)
4425 vim_free(name);
4426 else
4427 {
4428 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
4429 {
4430 listitem_T *li;
4431 int i = 0;
4432 int arg_len = 0;
4433 int lv_len = 0;
4434
4435 if (arg_pt != NULL)
4436 arg_len = arg_pt->pt_argc;
4437 if (list != NULL)
4438 lv_len = list->lv_len;
4439 pt->pt_argc = arg_len + lv_len;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004440 pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004441 if (pt->pt_argv == NULL)
4442 {
4443 vim_free(pt);
4444 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004445 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004446 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004447 for (i = 0; i < arg_len; i++)
4448 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
4449 if (lv_len > 0)
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004450 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004451 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004452 FOR_ALL_LIST_ITEMS(list, li)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004453 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004454 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004455 }
4456
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004457 // For "function(dict.func, [], dict)" and "func" is a partial
4458 // use "dict". That is backwards compatible.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004459 if (dict_idx > 0)
4460 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004461 // The dict is bound explicitly, pt_auto is FALSE.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004462 pt->pt_dict = argvars[dict_idx].vval.v_dict;
4463 ++pt->pt_dict->dv_refcount;
4464 }
4465 else if (arg_pt != NULL)
4466 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004467 // If the dict was bound automatically the result is also
4468 // bound automatically.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004469 pt->pt_dict = arg_pt->pt_dict;
4470 pt->pt_auto = arg_pt->pt_auto;
4471 if (pt->pt_dict != NULL)
4472 ++pt->pt_dict->dv_refcount;
4473 }
4474
4475 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004476 if (arg_pt != NULL && arg_pt->pt_func != NULL)
4477 {
4478 pt->pt_func = arg_pt->pt_func;
4479 func_ptr_ref(pt->pt_func);
4480 vim_free(name);
4481 }
4482 else if (is_funcref)
4483 {
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004484 pt->pt_func = find_func(trans_name, is_global);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004485 func_ptr_ref(pt->pt_func);
4486 vim_free(name);
4487 }
4488 else
4489 {
4490 pt->pt_name = name;
4491 func_ref(name);
4492 }
Bram Moolenaar92368aa2022-02-07 17:50:39 +00004493
4494 if (arg_pt != NULL)
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00004495 {
4496 pt->pt_outer_partial = arg_pt;
4497 ++arg_pt->pt_refcount;
4498 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004499 }
4500 rettv->v_type = VAR_PARTIAL;
4501 rettv->vval.v_partial = pt;
4502 }
4503 else
4504 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004505 // result is a VAR_FUNC
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004506 rettv->v_type = VAR_FUNC;
4507 rettv->vval.v_string = name;
4508 func_ref(name);
4509 }
4510 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004511theend:
4512 vim_free(trans_name);
4513}
4514
4515/*
4516 * "funcref()" function
4517 */
4518 static void
4519f_funcref(typval_T *argvars, typval_T *rettv)
4520{
4521 common_function(argvars, rettv, TRUE);
4522}
4523
4524/*
4525 * "function()" function
4526 */
4527 static void
4528f_function(typval_T *argvars, typval_T *rettv)
4529{
4530 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004531}
4532
4533/*
4534 * "garbagecollect()" function
4535 */
4536 static void
4537f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
4538{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004539 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
4540 return;
4541
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004542 // This is postponed until we are back at the toplevel, because we may be
4543 // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004544 want_garbage_collect = TRUE;
4545
Bram Moolenaar2df47312020-09-05 17:30:44 +02004546 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004547 garbage_collect_at_exit = TRUE;
4548}
4549
4550/*
4551 * "get()" function
4552 */
4553 static void
4554f_get(typval_T *argvars, typval_T *rettv)
4555{
4556 listitem_T *li;
4557 list_T *l;
4558 dictitem_T *di;
4559 dict_T *d;
4560 typval_T *tv = NULL;
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004561 int what_is_dict = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004562
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004563 if (argvars[0].v_type == VAR_BLOB)
4564 {
4565 int error = FALSE;
4566 int idx = tv_get_number_chk(&argvars[1], &error);
4567
4568 if (!error)
4569 {
4570 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004571 if (idx < 0)
4572 idx = blob_len(argvars[0].vval.v_blob) + idx;
4573 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
4574 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004575 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004576 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004577 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004578 tv = rettv;
4579 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004580 }
4581 }
4582 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004583 {
4584 if ((l = argvars[0].vval.v_list) != NULL)
4585 {
4586 int error = FALSE;
4587
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004588 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004589 if (!error && li != NULL)
4590 tv = &li->li_tv;
4591 }
4592 }
4593 else if (argvars[0].v_type == VAR_DICT)
4594 {
4595 if ((d = argvars[0].vval.v_dict) != NULL)
4596 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004597 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004598 if (di != NULL)
4599 tv = &di->di_tv;
4600 }
4601 }
4602 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
4603 {
4604 partial_T *pt;
4605 partial_T fref_pt;
4606
4607 if (argvars[0].v_type == VAR_PARTIAL)
4608 pt = argvars[0].vval.v_partial;
4609 else
4610 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02004611 CLEAR_FIELD(fref_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004612 fref_pt.pt_name = argvars[0].vval.v_string;
4613 pt = &fref_pt;
4614 }
4615
4616 if (pt != NULL)
4617 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004618 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004619 char_u *n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004620
4621 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
4622 {
4623 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004624 n = partial_name(pt);
4625 if (n == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004626 rettv->vval.v_string = NULL;
4627 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004628 {
4629 rettv->vval.v_string = vim_strsave(n);
4630 if (rettv->v_type == VAR_FUNC)
4631 func_ref(rettv->vval.v_string);
4632 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004633 }
4634 else if (STRCMP(what, "dict") == 0)
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004635 {
4636 what_is_dict = TRUE;
4637 if (pt->pt_dict != NULL)
4638 rettv_dict_set(rettv, pt->pt_dict);
4639 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004640 else if (STRCMP(what, "args") == 0)
4641 {
4642 rettv->v_type = VAR_LIST;
4643 if (rettv_list_alloc(rettv) == OK)
4644 {
4645 int i;
4646
4647 for (i = 0; i < pt->pt_argc; ++i)
4648 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
4649 }
4650 }
4651 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004652 semsg(_(e_invalid_argument_str), what);
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004653
4654 // When {what} == "dict" and pt->pt_dict == NULL, evaluate the
4655 // third argument
4656 if (!what_is_dict)
4657 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004658 }
4659 }
4660 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00004661 semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004662
4663 if (tv == NULL)
4664 {
4665 if (argvars[2].v_type != VAR_UNKNOWN)
4666 copy_tv(&argvars[2], rettv);
4667 }
4668 else
4669 copy_tv(tv, rettv);
4670}
4671
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004672/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004673 * "getchangelist()" function
4674 */
4675 static void
4676f_getchangelist(typval_T *argvars, typval_T *rettv)
4677{
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004678 buf_T *buf;
4679 int i;
4680 list_T *l;
4681 dict_T *d;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004682
4683 if (rettv_list_alloc(rettv) != OK)
4684 return;
4685
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004686 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
4687 return;
4688
Bram Moolenaar4c313b12019-08-24 22:58:31 +02004689 if (argvars[0].v_type == VAR_UNKNOWN)
4690 buf = curbuf;
4691 else
Bram Moolenaara5d38412020-09-02 21:02:35 +02004692 buf = tv_get_buf_from_arg(&argvars[0]);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004693 if (buf == NULL)
4694 return;
4695
4696 l = list_alloc();
4697 if (l == NULL)
4698 return;
4699
4700 if (list_append_list(rettv->vval.v_list, l) == FAIL)
4701 return;
4702 /*
4703 * The current window change list index tracks only the position in the
4704 * current buffer change list. For other buffers, use the change list
4705 * length as the current index.
4706 */
4707 list_append_number(rettv->vval.v_list,
4708 (varnumber_T)((buf == curwin->w_buffer)
4709 ? curwin->w_changelistidx : buf->b_changelistlen));
4710
4711 for (i = 0; i < buf->b_changelistlen; ++i)
4712 {
4713 if (buf->b_changelist[i].lnum == 0)
4714 continue;
4715 if ((d = dict_alloc()) == NULL)
4716 return;
4717 if (list_append_dict(l, d) == FAIL)
4718 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004719 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
4720 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004721 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004722 }
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004723}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004724
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004725 static void
4726getpos_both(
4727 typval_T *argvars,
4728 typval_T *rettv,
4729 int getcurpos,
4730 int charcol)
4731{
4732 pos_T *fp = NULL;
4733 pos_T pos;
4734 win_T *wp = curwin;
4735 list_T *l;
4736 int fnum = -1;
4737
4738 if (rettv_list_alloc(rettv) == OK)
4739 {
4740 l = rettv->vval.v_list;
4741 if (getcurpos)
4742 {
4743 if (argvars[0].v_type != VAR_UNKNOWN)
4744 {
4745 wp = find_win_by_nr_or_id(&argvars[0]);
4746 if (wp != NULL)
4747 fp = &wp->w_cursor;
4748 }
4749 else
4750 fp = &curwin->w_cursor;
4751 if (fp != NULL && charcol)
4752 {
4753 pos = *fp;
Bram Moolenaar91458462021-01-13 20:08:38 +01004754 pos.col =
4755 buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004756 fp = &pos;
4757 }
4758 }
4759 else
4760 fp = var2fpos(&argvars[0], TRUE, &fnum, charcol);
4761 if (fnum != -1)
4762 list_append_number(l, (varnumber_T)fnum);
4763 else
4764 list_append_number(l, (varnumber_T)0);
4765 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
4766 : (varnumber_T)0);
4767 list_append_number(l, (fp != NULL)
4768 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
4769 : (varnumber_T)0);
4770 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
4771 (varnumber_T)0);
4772 if (getcurpos)
4773 {
4774 int save_set_curswant = curwin->w_set_curswant;
4775 colnr_T save_curswant = curwin->w_curswant;
4776 colnr_T save_virtcol = curwin->w_virtcol;
4777
4778 if (wp == curwin)
4779 update_curswant();
4780 list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL
4781 ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1);
4782
4783 // Do not change "curswant", as it is unexpected that a get
4784 // function has a side effect.
4785 if (wp == curwin && save_set_curswant)
4786 {
4787 curwin->w_set_curswant = save_set_curswant;
4788 curwin->w_curswant = save_curswant;
4789 curwin->w_virtcol = save_virtcol;
4790 curwin->w_valid &= ~VALID_VIRTCOL;
4791 }
4792 }
4793 }
4794 else
4795 rettv->vval.v_number = FALSE;
4796}
4797
4798/*
4799 * "getcharpos()" function
4800 */
4801 static void
4802f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv)
4803{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004804 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4805 return;
4806
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004807 getpos_both(argvars, rettv, FALSE, TRUE);
4808}
4809
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004810/*
4811 * "getcharsearch()" function
4812 */
4813 static void
4814f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
4815{
4816 if (rettv_dict_alloc(rettv) != FAIL)
4817 {
4818 dict_T *dict = rettv->vval.v_dict;
4819
Bram Moolenaare0be1672018-07-08 16:50:37 +02004820 dict_add_string(dict, "char", last_csearch());
4821 dict_add_number(dict, "forward", last_csearch_forward());
4822 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004823 }
4824}
4825
4826/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004827 * "getenv()" function
4828 */
4829 static void
4830f_getenv(typval_T *argvars, typval_T *rettv)
4831{
4832 int mustfree = FALSE;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004833 char_u *p;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004834
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004835 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4836 return;
4837
4838 p = vim_getenv(tv_get_string(&argvars[0]), &mustfree);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004839 if (p == NULL)
4840 {
4841 rettv->v_type = VAR_SPECIAL;
4842 rettv->vval.v_number = VVAL_NULL;
4843 return;
4844 }
4845 if (!mustfree)
4846 p = vim_strsave(p);
4847 rettv->vval.v_string = p;
4848 rettv->v_type = VAR_STRING;
4849}
4850
4851/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004852 * "getfontname()" function
4853 */
4854 static void
4855f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
4856{
4857 rettv->v_type = VAR_STRING;
4858 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004859
4860 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
4861 return;
4862
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004863#ifdef FEAT_GUI
4864 if (gui.in_use)
4865 {
4866 GuiFont font;
4867 char_u *name = NULL;
4868
4869 if (argvars[0].v_type == VAR_UNKNOWN)
4870 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004871 // Get the "Normal" font. Either the name saved by
4872 // hl_set_font_name() or from the font ID.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004873 font = gui.norm_font;
4874 name = hl_get_font_name();
4875 }
4876 else
4877 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004878 name = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004879 if (STRCMP(name, "*") == 0) // don't use font dialog
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004880 return;
4881 font = gui_mch_get_font(name, FALSE);
4882 if (font == NOFONT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004883 return; // Invalid font name, return empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004884 }
4885 rettv->vval.v_string = gui_mch_get_fontname(font, name);
4886 if (argvars[0].v_type != VAR_UNKNOWN)
4887 gui_mch_free_font(font);
4888 }
4889#endif
4890}
4891
4892/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01004893 * "getjumplist()" function
4894 */
4895 static void
4896f_getjumplist(typval_T *argvars, typval_T *rettv)
4897{
Bram Moolenaar4f505882018-02-10 21:06:32 +01004898 win_T *wp;
4899 int i;
4900 list_T *l;
4901 dict_T *d;
Bram Moolenaar4f505882018-02-10 21:06:32 +01004902
4903 if (rettv_list_alloc(rettv) != OK)
4904 return;
4905
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004906 if (in_vim9script()
4907 && (check_for_opt_number_arg(argvars, 0) == FAIL
4908 || (argvars[0].v_type != VAR_UNKNOWN
4909 && check_for_opt_number_arg(argvars, 1) == FAIL)))
4910 return;
4911
Bram Moolenaar00aa0692019-04-27 20:37:57 +02004912 wp = find_tabwin(&argvars[0], &argvars[1], NULL);
Bram Moolenaar4f505882018-02-10 21:06:32 +01004913 if (wp == NULL)
4914 return;
4915
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01004916 cleanup_jumplist(wp, TRUE);
4917
Bram Moolenaar4f505882018-02-10 21:06:32 +01004918 l = list_alloc();
4919 if (l == NULL)
4920 return;
4921
4922 if (list_append_list(rettv->vval.v_list, l) == FAIL)
4923 return;
4924 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
4925
4926 for (i = 0; i < wp->w_jumplistlen; ++i)
4927 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01004928 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
4929 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01004930 if ((d = dict_alloc()) == NULL)
4931 return;
4932 if (list_append_dict(l, d) == FAIL)
4933 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004934 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
4935 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004936 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004937 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01004938 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02004939 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01004940 }
Bram Moolenaar4f505882018-02-10 21:06:32 +01004941}
4942
4943/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004944 * "getpid()" function
4945 */
4946 static void
4947f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
4948{
4949 rettv->vval.v_number = mch_get_pid();
4950}
4951
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004952/*
4953 * "getcurpos()" function
4954 */
4955 static void
4956f_getcurpos(typval_T *argvars, typval_T *rettv)
4957{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004958 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
4959 return;
4960
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004961 getpos_both(argvars, rettv, TRUE, FALSE);
4962}
4963
4964 static void
4965f_getcursorcharpos(typval_T *argvars, typval_T *rettv)
4966{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004967 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
4968 return;
4969
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004970 getpos_both(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004971}
4972
4973/*
4974 * "getpos(string)" function
4975 */
4976 static void
4977f_getpos(typval_T *argvars, typval_T *rettv)
4978{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004979 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4980 return;
4981
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004982 getpos_both(argvars, rettv, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004983}
4984
4985/*
zeertzjqd3f00f52021-12-24 12:02:43 +00004986 * Common between getreg(), getreginfo() and getregtype(): get the register
4987 * name from the first argument.
Bram Moolenaar51e64b22021-12-24 10:48:30 +00004988 * Returns zero on error.
4989 */
4990 static int
4991getreg_get_regname(typval_T *argvars)
4992{
4993 char_u *strregname;
4994
4995 if (argvars[0].v_type != VAR_UNKNOWN)
4996 {
4997 strregname = tv_get_string_chk(&argvars[0]);
4998 if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1)
4999 {
5000 semsg(_(e_register_name_must_be_one_char_str), strregname);
5001 strregname = NULL;
5002 }
5003 if (strregname == NULL) // type error; errmsg already given
5004 return 0;
5005 }
5006 else
5007 // Default to v:register
5008 strregname = get_vim_var_str(VV_REG);
5009
5010 return *strregname == 0 ? '"' : *strregname;
5011}
5012
5013/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005014 * "getreg()" function
5015 */
5016 static void
5017f_getreg(typval_T *argvars, typval_T *rettv)
5018{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005019 int regname;
5020 int arg2 = FALSE;
5021 int return_list = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005022
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005023 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005024 && (check_for_opt_string_arg(argvars, 0) == FAIL
5025 || (argvars[0].v_type != VAR_UNKNOWN
5026 && (check_for_opt_bool_arg(argvars, 1) == FAIL
5027 || (argvars[1].v_type != VAR_UNKNOWN
5028 && check_for_opt_bool_arg(argvars, 2) == FAIL)))))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005029 return;
5030
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005031 regname = getreg_get_regname(argvars);
5032 if (regname == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005033 return;
5034
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005035 if (argvars[0].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_UNKNOWN)
5036 {
5037 int error = FALSE;
5038
5039 arg2 = (int)tv_get_bool_chk(&argvars[1], &error);
5040
5041 if (!error && argvars[2].v_type != VAR_UNKNOWN)
5042 return_list = (int)tv_get_bool_chk(&argvars[2], &error);
5043 if (error)
5044 return;
5045 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005046
5047 if (return_list)
5048 {
5049 rettv->v_type = VAR_LIST;
5050 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
5051 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
5052 if (rettv->vval.v_list == NULL)
5053 (void)rettv_list_alloc(rettv);
5054 else
5055 ++rettv->vval.v_list->lv_refcount;
5056 }
5057 else
5058 {
5059 rettv->v_type = VAR_STRING;
5060 rettv->vval.v_string = get_reg_contents(regname,
5061 arg2 ? GREG_EXPR_SRC : 0);
5062 }
5063}
5064
5065/*
5066 * "getregtype()" function
5067 */
5068 static void
5069f_getregtype(typval_T *argvars, typval_T *rettv)
5070{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005071 int regname;
5072 char_u buf[NUMBUFLEN + 2];
5073 long reglen = 0;
5074
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005075 // on error return an empty string
5076 rettv->v_type = VAR_STRING;
5077 rettv->vval.v_string = NULL;
5078
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005079 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5080 return;
5081
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005082 regname = getreg_get_regname(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005083 if (regname == 0)
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005084 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005085
5086 buf[0] = NUL;
5087 buf[1] = NUL;
5088 switch (get_reg_type(regname, &reglen))
5089 {
5090 case MLINE: buf[0] = 'V'; break;
5091 case MCHAR: buf[0] = 'v'; break;
5092 case MBLOCK:
5093 buf[0] = Ctrl_V;
5094 sprintf((char *)buf + 1, "%ld", reglen + 1);
5095 break;
5096 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005097 rettv->vval.v_string = vim_strsave(buf);
5098}
5099
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005100/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005101 * "gettagstack()" function
5102 */
5103 static void
5104f_gettagstack(typval_T *argvars, typval_T *rettv)
5105{
5106 win_T *wp = curwin; // default is current window
5107
5108 if (rettv_dict_alloc(rettv) != OK)
5109 return;
5110
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005111 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5112 return;
5113
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005114 if (argvars[0].v_type != VAR_UNKNOWN)
5115 {
5116 wp = find_win_by_nr_or_id(&argvars[0]);
5117 if (wp == NULL)
5118 return;
5119 }
5120
5121 get_tagstack(wp, rettv->vval.v_dict);
5122}
5123
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005124/*
5125 * "gettext()" function
5126 */
5127 static void
5128f_gettext(typval_T *argvars, typval_T *rettv)
5129{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005130 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5131 return;
5132
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005133 if (argvars[0].v_type != VAR_STRING
5134 || argvars[0].vval.v_string == NULL
5135 || *argvars[0].vval.v_string == NUL)
5136 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005137 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005138 }
5139 else
5140 {
5141 rettv->v_type = VAR_STRING;
5142 rettv->vval.v_string = vim_strsave(
5143 (char_u *)_(argvars[0].vval.v_string));
5144 }
5145}
5146
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005147// for VIM_VERSION_ defines
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005148#include "version.h"
5149
5150/*
5151 * "has()" function
5152 */
Bram Moolenaara259d8d2020-01-31 20:10:50 +01005153 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005154f_has(typval_T *argvars, typval_T *rettv)
5155{
5156 int i;
5157 char_u *name;
Bram Moolenaar79296512020-03-22 16:17:14 +01005158 int x = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005159 int n = FALSE;
Bram Moolenaar79296512020-03-22 16:17:14 +01005160 typedef struct {
5161 char *name;
5162 short present;
5163 } has_item_T;
5164 static has_item_T has_list[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005165 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005166 {"amiga",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005167#ifdef AMIGA
Bram Moolenaar79296512020-03-22 16:17:14 +01005168 1
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005169#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005170 0
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005171#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005172 },
5173 {"arp",
5174#if defined(AMIGA) && defined(FEAT_ARP)
5175 1
5176#else
5177 0
5178#endif
5179 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005180 {"haiku",
5181#ifdef __HAIKU__
5182 1
5183#else
5184 0
5185#endif
5186 },
5187 {"bsd",
5188#if defined(BSD) && !defined(MACOS_X)
5189 1
5190#else
5191 0
5192#endif
5193 },
5194 {"hpux",
5195#ifdef hpux
5196 1
5197#else
5198 0
5199#endif
5200 },
5201 {"linux",
5202#ifdef __linux__
5203 1
5204#else
5205 0
5206#endif
5207 },
5208 {"mac", // Mac OS X (and, once, Mac OS Classic)
5209#ifdef MACOS_X
5210 1
5211#else
5212 0
5213#endif
5214 },
5215 {"osx", // Mac OS X
5216#ifdef MACOS_X
5217 1
5218#else
5219 0
5220#endif
5221 },
5222 {"macunix", // Mac OS X, with the darwin feature
5223#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5224 1
5225#else
5226 0
5227#endif
5228 },
5229 {"osxdarwin", // synonym for macunix
5230#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5231 1
5232#else
5233 0
5234#endif
5235 },
5236 {"qnx",
5237#ifdef __QNX__
5238 1
5239#else
5240 0
5241#endif
5242 },
5243 {"sun",
5244#ifdef SUN_SYSTEM
5245 1
5246#else
5247 0
5248#endif
5249 },
5250 {"unix",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005251#ifdef UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005252 1
5253#else
5254 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005255#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005256 },
5257 {"vms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005258#ifdef VMS
Bram Moolenaar79296512020-03-22 16:17:14 +01005259 1
5260#else
5261 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005262#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005263 },
5264 {"win32",
Bram Moolenaar4f974752019-02-17 17:44:42 +01005265#ifdef MSWIN
Bram Moolenaar79296512020-03-22 16:17:14 +01005266 1
5267#else
5268 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005269#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005270 },
5271 {"win32unix",
K.Takata972db232022-02-04 10:45:38 +00005272#ifdef WIN32UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005273 1
5274#else
5275 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005276#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005277 },
5278 {"win64",
Bram Moolenaar44b443c2019-02-18 22:14:18 +01005279#ifdef _WIN64
Bram Moolenaar79296512020-03-22 16:17:14 +01005280 1
5281#else
5282 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005283#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005284 },
Bram Moolenaar424bcae2022-01-31 14:59:41 +00005285 {"ebcdic", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005286 {"fname_case",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005287#ifndef CASE_INSENSITIVE_FILENAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005288 1
5289#else
5290 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005291#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005292 },
5293 {"acl",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005294#ifdef HAVE_ACL
Bram Moolenaar79296512020-03-22 16:17:14 +01005295 1
5296#else
5297 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005298#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005299 },
5300 {"arabic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005301#ifdef FEAT_ARABIC
Bram Moolenaar79296512020-03-22 16:17:14 +01005302 1
5303#else
5304 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005305#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005306 },
5307 {"autocmd", 1},
5308 {"autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005309#ifdef FEAT_AUTOCHDIR
Bram Moolenaar79296512020-03-22 16:17:14 +01005310 1
5311#else
5312 0
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005313#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005314 },
5315 {"autoservername",
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005316#ifdef FEAT_AUTOSERVERNAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005317 1
5318#else
5319 0
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005320#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005321 },
5322 {"balloon_eval",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005323#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005324 1
5325#else
5326 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005327#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005328 },
5329 {"balloon_multiline",
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00005330#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005331 1
5332#else
5333 0
5334#endif
5335 },
5336 {"balloon_eval_term",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005337#ifdef FEAT_BEVAL_TERM
Bram Moolenaar79296512020-03-22 16:17:14 +01005338 1
5339#else
5340 0
Bram Moolenaar51b0f372017-11-18 18:52:04 +01005341#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005342 },
5343 {"builtin_terms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005344#if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
Bram Moolenaar79296512020-03-22 16:17:14 +01005345 1
5346#else
5347 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005348#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005349 },
5350 {"all_builtin_terms",
5351#if defined(ALL_BUILTIN_TCAPS)
5352 1
5353#else
5354 0
5355#endif
5356 },
5357 {"browsefilter",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005358#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01005359 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005360 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar79296512020-03-22 16:17:14 +01005361 1
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005362#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005363 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005364#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005365 },
5366 {"byte_offset",
5367#ifdef FEAT_BYTEOFF
5368 1
5369#else
5370 0
5371#endif
5372 },
5373 {"channel",
5374#ifdef FEAT_JOB_CHANNEL
5375 1
5376#else
5377 0
5378#endif
5379 },
5380 {"cindent",
5381#ifdef FEAT_CINDENT
5382 1
5383#else
5384 0
5385#endif
5386 },
5387 {"clientserver",
5388#ifdef FEAT_CLIENTSERVER
5389 1
5390#else
5391 0
5392#endif
5393 },
5394 {"clipboard",
5395#ifdef FEAT_CLIPBOARD
5396 1
5397#else
5398 0
5399#endif
5400 },
5401 {"cmdline_compl", 1},
5402 {"cmdline_hist", 1},
Bram Moolenaar21829c52021-01-26 22:42:21 +01005403 {"cmdwin",
5404#ifdef FEAT_CMDWIN
5405 1
5406#else
5407 0
5408#endif
5409 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005410 {"comments", 1},
5411 {"conceal",
5412#ifdef FEAT_CONCEAL
5413 1
5414#else
5415 0
5416#endif
5417 },
5418 {"cryptv",
5419#ifdef FEAT_CRYPT
5420 1
5421#else
5422 0
5423#endif
5424 },
5425 {"crypt-blowfish",
5426#ifdef FEAT_CRYPT
5427 1
5428#else
5429 0
5430#endif
5431 },
5432 {"crypt-blowfish2",
5433#ifdef FEAT_CRYPT
5434 1
5435#else
5436 0
5437#endif
5438 },
5439 {"cscope",
5440#ifdef FEAT_CSCOPE
5441 1
5442#else
5443 0
5444#endif
5445 },
5446 {"cursorbind", 1},
5447 {"cursorshape",
5448#ifdef CURSOR_SHAPE
5449 1
5450#else
5451 0
5452#endif
5453 },
5454 {"debug",
5455#ifdef DEBUG
5456 1
5457#else
5458 0
5459#endif
5460 },
5461 {"dialog_con",
5462#ifdef FEAT_CON_DIALOG
5463 1
5464#else
5465 0
5466#endif
5467 },
5468 {"dialog_gui",
5469#ifdef FEAT_GUI_DIALOG
5470 1
5471#else
5472 0
5473#endif
5474 },
5475 {"diff",
5476#ifdef FEAT_DIFF
5477 1
5478#else
5479 0
5480#endif
5481 },
5482 {"digraphs",
5483#ifdef FEAT_DIGRAPHS
5484 1
5485#else
5486 0
5487#endif
5488 },
5489 {"directx",
5490#ifdef FEAT_DIRECTX
5491 1
5492#else
5493 0
5494#endif
5495 },
5496 {"dnd",
5497#ifdef FEAT_DND
5498 1
5499#else
5500 0
5501#endif
5502 },
Bram Moolenaar1d1ce612021-06-27 19:02:52 +02005503 {"drop_file",
5504#ifdef HAVE_DROP_FILE
5505 1
5506#else
5507 0
5508#endif
5509 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005510 {"emacs_tags",
5511#ifdef FEAT_EMACS_TAGS
5512 1
5513#else
5514 0
5515#endif
5516 },
5517 {"eval", 1}, // always present, of course!
5518 {"ex_extra", 1}, // graduated feature
5519 {"extra_search",
5520#ifdef FEAT_SEARCH_EXTRA
5521 1
5522#else
5523 0
5524#endif
5525 },
5526 {"file_in_path",
5527#ifdef FEAT_SEARCHPATH
5528 1
5529#else
5530 0
5531#endif
5532 },
5533 {"filterpipe",
5534#if defined(FEAT_FILTERPIPE) && !defined(VIMDLL)
5535 1
5536#else
5537 0
5538#endif
5539 },
5540 {"find_in_path",
5541#ifdef FEAT_FIND_ID
5542 1
5543#else
5544 0
5545#endif
5546 },
5547 {"float",
5548#ifdef FEAT_FLOAT
5549 1
5550#else
5551 0
5552#endif
5553 },
5554 {"folding",
5555#ifdef FEAT_FOLDING
5556 1
5557#else
5558 0
5559#endif
5560 },
5561 {"footer",
5562#ifdef FEAT_FOOTER
5563 1
5564#else
5565 0
5566#endif
5567 },
5568 {"fork",
5569#if !defined(USE_SYSTEM) && defined(UNIX)
5570 1
5571#else
5572 0
5573#endif
5574 },
5575 {"gettext",
5576#ifdef FEAT_GETTEXT
5577 1
5578#else
5579 0
5580#endif
5581 },
5582 {"gui",
5583#ifdef FEAT_GUI
5584 1
5585#else
5586 0
5587#endif
5588 },
5589 {"gui_neXtaw",
5590#if defined(FEAT_GUI_ATHENA) && defined(FEAT_GUI_NEXTAW)
5591 1
5592#else
5593 0
5594#endif
5595 },
5596 {"gui_athena",
5597#if defined(FEAT_GUI_ATHENA) && !defined(FEAT_GUI_NEXTAW)
5598 1
5599#else
5600 0
5601#endif
5602 },
5603 {"gui_gtk",
5604#ifdef FEAT_GUI_GTK
5605 1
5606#else
5607 0
5608#endif
5609 },
5610 {"gui_gtk2",
5611#if defined(FEAT_GUI_GTK) && !defined(USE_GTK3)
5612 1
5613#else
5614 0
5615#endif
5616 },
5617 {"gui_gtk3",
5618#if defined(FEAT_GUI_GTK) && defined(USE_GTK3)
5619 1
5620#else
5621 0
5622#endif
5623 },
5624 {"gui_gnome",
5625#ifdef FEAT_GUI_GNOME
5626 1
5627#else
5628 0
5629#endif
5630 },
5631 {"gui_haiku",
5632#ifdef FEAT_GUI_HAIKU
5633 1
5634#else
5635 0
5636#endif
5637 },
Bram Moolenaar097148e2020-08-11 21:58:20 +02005638 {"gui_mac", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01005639 {"gui_motif",
5640#ifdef FEAT_GUI_MOTIF
5641 1
5642#else
5643 0
5644#endif
5645 },
5646 {"gui_photon",
5647#ifdef FEAT_GUI_PHOTON
5648 1
5649#else
5650 0
5651#endif
5652 },
5653 {"gui_win32",
5654#ifdef FEAT_GUI_MSWIN
5655 1
5656#else
5657 0
5658#endif
5659 },
5660 {"iconv",
5661#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
5662 1
5663#else
5664 0
5665#endif
5666 },
5667 {"insert_expand", 1},
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02005668 {"ipv6",
5669#ifdef FEAT_IPV6
5670 1
5671#else
5672 0
5673#endif
5674 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005675 {"job",
5676#ifdef FEAT_JOB_CHANNEL
5677 1
5678#else
5679 0
5680#endif
5681 },
Bram Moolenaar739f13a2021-12-13 13:12:53 +00005682 {"jumplist", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005683 {"keymap",
5684#ifdef FEAT_KEYMAP
5685 1
5686#else
5687 0
5688#endif
5689 },
5690 {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure
5691 {"langmap",
5692#ifdef FEAT_LANGMAP
5693 1
5694#else
5695 0
5696#endif
5697 },
5698 {"libcall",
5699#ifdef FEAT_LIBCALL
5700 1
5701#else
5702 0
5703#endif
5704 },
5705 {"linebreak",
5706#ifdef FEAT_LINEBREAK
5707 1
5708#else
5709 0
5710#endif
5711 },
5712 {"lispindent",
5713#ifdef FEAT_LISP
5714 1
5715#else
5716 0
5717#endif
5718 },
5719 {"listcmds", 1},
5720 {"localmap", 1},
5721 {"lua",
5722#if defined(FEAT_LUA) && !defined(DYNAMIC_LUA)
5723 1
5724#else
5725 0
5726#endif
5727 },
5728 {"menu",
5729#ifdef FEAT_MENU
5730 1
5731#else
5732 0
5733#endif
5734 },
5735 {"mksession",
5736#ifdef FEAT_SESSION
5737 1
5738#else
5739 0
5740#endif
5741 },
5742 {"modify_fname", 1},
5743 {"mouse", 1},
5744 {"mouseshape",
5745#ifdef FEAT_MOUSESHAPE
5746 1
5747#else
5748 0
5749#endif
5750 },
5751 {"mouse_dec",
5752#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC)
5753 1
5754#else
5755 0
5756#endif
5757 },
5758 {"mouse_gpm",
5759#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM)
5760 1
5761#else
5762 0
5763#endif
5764 },
5765 {"mouse_jsbterm",
5766#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB)
5767 1
5768#else
5769 0
5770#endif
5771 },
5772 {"mouse_netterm",
5773#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET)
5774 1
5775#else
5776 0
5777#endif
5778 },
5779 {"mouse_pterm",
5780#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM)
5781 1
5782#else
5783 0
5784#endif
5785 },
5786 {"mouse_sgr",
5787#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5788 1
5789#else
5790 0
5791#endif
5792 },
5793 {"mouse_sysmouse",
5794#if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE)
5795 1
5796#else
5797 0
5798#endif
5799 },
5800 {"mouse_urxvt",
5801#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT)
5802 1
5803#else
5804 0
5805#endif
5806 },
5807 {"mouse_xterm",
5808#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5809 1
5810#else
5811 0
5812#endif
5813 },
5814 {"multi_byte", 1},
5815 {"multi_byte_ime",
5816#ifdef FEAT_MBYTE_IME
5817 1
5818#else
5819 0
5820#endif
5821 },
5822 {"multi_lang",
5823#ifdef FEAT_MULTI_LANG
5824 1
5825#else
5826 0
5827#endif
5828 },
5829 {"mzscheme",
5830#if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME)
5831 1
5832#else
5833 0
5834#endif
5835 },
Leah Neukirchen0a7984a2021-10-14 21:27:55 +01005836 {"nanotime",
5837#ifdef ST_MTIM_NSEC
5838 1
5839#else
5840 0
5841#endif
5842 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005843 {"num64", 1},
5844 {"ole",
5845#ifdef FEAT_OLE
5846 1
5847#else
5848 0
5849#endif
5850 },
5851 {"packages",
5852#ifdef FEAT_EVAL
5853 1
5854#else
5855 0
5856#endif
5857 },
5858 {"path_extra",
5859#ifdef FEAT_PATH_EXTRA
5860 1
5861#else
5862 0
5863#endif
5864 },
5865 {"perl",
5866#if defined(FEAT_PERL) && !defined(DYNAMIC_PERL)
5867 1
5868#else
5869 0
5870#endif
5871 },
5872 {"persistent_undo",
5873#ifdef FEAT_PERSISTENT_UNDO
5874 1
5875#else
5876 0
5877#endif
5878 },
5879 {"python_compiled",
5880#if defined(FEAT_PYTHON)
5881 1
5882#else
5883 0
5884#endif
5885 },
5886 {"python_dynamic",
5887#if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON)
5888 1
5889#else
5890 0
5891#endif
5892 },
5893 {"python",
5894#if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)
5895 1
5896#else
5897 0
5898#endif
5899 },
5900 {"pythonx",
5901#if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \
5902 || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3))
5903 1
5904#else
5905 0
5906#endif
5907 },
5908 {"python3_compiled",
5909#if defined(FEAT_PYTHON3)
5910 1
5911#else
5912 0
5913#endif
5914 },
5915 {"python3_dynamic",
5916#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3)
5917 1
5918#else
5919 0
5920#endif
5921 },
5922 {"python3",
5923#if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)
5924 1
5925#else
5926 0
5927#endif
5928 },
5929 {"popupwin",
5930#ifdef FEAT_PROP_POPUP
5931 1
5932#else
5933 0
5934#endif
5935 },
5936 {"postscript",
5937#ifdef FEAT_POSTSCRIPT
5938 1
5939#else
5940 0
5941#endif
5942 },
5943 {"printer",
5944#ifdef FEAT_PRINTER
5945 1
5946#else
5947 0
5948#endif
5949 },
5950 {"profile",
5951#ifdef FEAT_PROFILE
5952 1
5953#else
5954 0
5955#endif
5956 },
5957 {"reltime",
5958#ifdef FEAT_RELTIME
5959 1
5960#else
5961 0
5962#endif
5963 },
5964 {"quickfix",
5965#ifdef FEAT_QUICKFIX
5966 1
5967#else
5968 0
5969#endif
5970 },
5971 {"rightleft",
5972#ifdef FEAT_RIGHTLEFT
5973 1
5974#else
5975 0
5976#endif
5977 },
5978 {"ruby",
5979#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
5980 1
5981#else
5982 0
5983#endif
5984 },
5985 {"scrollbind", 1},
5986 {"showcmd",
5987#ifdef FEAT_CMDL_INFO
5988 1
5989#else
5990 0
5991#endif
5992 },
5993 {"cmdline_info",
5994#ifdef FEAT_CMDL_INFO
5995 1
5996#else
5997 0
5998#endif
5999 },
6000 {"signs",
6001#ifdef FEAT_SIGNS
6002 1
6003#else
6004 0
6005#endif
6006 },
6007 {"smartindent",
6008#ifdef FEAT_SMARTINDENT
6009 1
6010#else
6011 0
6012#endif
6013 },
6014 {"startuptime",
6015#ifdef STARTUPTIME
6016 1
6017#else
6018 0
6019#endif
6020 },
6021 {"statusline",
6022#ifdef FEAT_STL_OPT
6023 1
6024#else
6025 0
6026#endif
6027 },
6028 {"netbeans_intg",
6029#ifdef FEAT_NETBEANS_INTG
6030 1
6031#else
6032 0
6033#endif
6034 },
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006035 {"sodium",
K.Takatad68b2fc2022-02-12 11:18:37 +00006036#if defined(FEAT_SODIUM) && !defined(DYNAMIC_SODIUM)
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006037 1
6038#else
6039 0
6040#endif
6041 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006042 {"sound",
6043#ifdef FEAT_SOUND
6044 1
6045#else
6046 0
6047#endif
6048 },
6049 {"spell",
6050#ifdef FEAT_SPELL
6051 1
6052#else
6053 0
6054#endif
6055 },
6056 {"syntax",
6057#ifdef FEAT_SYN_HL
6058 1
6059#else
6060 0
6061#endif
6062 },
6063 {"system",
6064#if defined(USE_SYSTEM) || !defined(UNIX)
6065 1
6066#else
6067 0
6068#endif
6069 },
6070 {"tag_binary",
6071#ifdef FEAT_TAG_BINS
6072 1
6073#else
6074 0
6075#endif
6076 },
6077 {"tcl",
6078#if defined(FEAT_TCL) && !defined(DYNAMIC_TCL)
6079 1
6080#else
6081 0
6082#endif
6083 },
6084 {"termguicolors",
6085#ifdef FEAT_TERMGUICOLORS
6086 1
6087#else
6088 0
6089#endif
6090 },
6091 {"terminal",
6092#if defined(FEAT_TERMINAL) && !defined(MSWIN)
6093 1
6094#else
6095 0
6096#endif
6097 },
6098 {"terminfo",
6099#ifdef TERMINFO
6100 1
6101#else
6102 0
6103#endif
6104 },
6105 {"termresponse",
6106#ifdef FEAT_TERMRESPONSE
6107 1
6108#else
6109 0
6110#endif
6111 },
6112 {"textobjects",
6113#ifdef FEAT_TEXTOBJ
6114 1
6115#else
6116 0
6117#endif
6118 },
6119 {"textprop",
6120#ifdef FEAT_PROP_POPUP
6121 1
6122#else
6123 0
6124#endif
6125 },
6126 {"tgetent",
6127#ifdef HAVE_TGETENT
6128 1
6129#else
6130 0
6131#endif
6132 },
6133 {"timers",
6134#ifdef FEAT_TIMERS
6135 1
6136#else
6137 0
6138#endif
6139 },
Bram Moolenaar651fca82021-11-29 20:39:38 +00006140 {"title", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006141 {"toolbar",
6142#ifdef FEAT_TOOLBAR
6143 1
6144#else
6145 0
6146#endif
6147 },
6148 {"unnamedplus",
6149#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
6150 1
6151#else
6152 0
6153#endif
6154 },
6155 {"user-commands", 1}, // was accidentally included in 5.4
6156 {"user_commands", 1},
6157 {"vartabs",
6158#ifdef FEAT_VARTABS
6159 1
6160#else
6161 0
6162#endif
6163 },
6164 {"vertsplit", 1},
6165 {"viminfo",
6166#ifdef FEAT_VIMINFO
6167 1
6168#else
6169 0
6170#endif
6171 },
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +00006172 {"vim9script", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006173 {"vimscript-1", 1},
6174 {"vimscript-2", 1},
6175 {"vimscript-3", 1},
6176 {"vimscript-4", 1},
6177 {"virtualedit", 1},
6178 {"visual", 1},
6179 {"visualextra", 1},
6180 {"vreplace", 1},
6181 {"vtp",
6182#ifdef FEAT_VTP
6183 1
6184#else
6185 0
6186#endif
6187 },
6188 {"wildignore",
6189#ifdef FEAT_WILDIGN
6190 1
6191#else
6192 0
6193#endif
6194 },
6195 {"wildmenu",
6196#ifdef FEAT_WILDMENU
6197 1
6198#else
6199 0
6200#endif
6201 },
6202 {"windows", 1},
6203 {"winaltkeys",
6204#ifdef FEAT_WAK
6205 1
6206#else
6207 0
6208#endif
6209 },
6210 {"writebackup",
6211#ifdef FEAT_WRITEBACKUP
6212 1
6213#else
6214 0
6215#endif
6216 },
6217 {"xim",
6218#ifdef FEAT_XIM
6219 1
6220#else
6221 0
6222#endif
6223 },
6224 {"xfontset",
6225#ifdef FEAT_XFONTSET
6226 1
6227#else
6228 0
6229#endif
6230 },
6231 {"xpm",
6232#if defined(FEAT_XPM_W32) || defined(HAVE_XPM)
6233 1
6234#else
6235 0
6236#endif
6237 },
6238 {"xpm_w32", // for backward compatibility
6239#ifdef FEAT_XPM_W32
6240 1
6241#else
6242 0
6243#endif
6244 },
6245 {"xsmp",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006246#ifdef USE_XSMP
Bram Moolenaar79296512020-03-22 16:17:14 +01006247 1
6248#else
6249 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006250#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006251 },
6252 {"xsmp_interact",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006253#ifdef USE_XSMP_INTERACT
Bram Moolenaar79296512020-03-22 16:17:14 +01006254 1
6255#else
6256 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006257#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006258 },
6259 {"xterm_clipboard",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006260#ifdef FEAT_XCLIPBOARD
Bram Moolenaar79296512020-03-22 16:17:14 +01006261 1
6262#else
6263 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006264#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006265 },
6266 {"xterm_save",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006267#ifdef FEAT_XTERM_SAVE
Bram Moolenaar79296512020-03-22 16:17:14 +01006268 1
6269#else
6270 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006271#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006272 },
6273 {"X11",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006274#if defined(UNIX) && defined(FEAT_X11)
Bram Moolenaar79296512020-03-22 16:17:14 +01006275 1
6276#else
6277 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006278#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006279 },
6280 {NULL, 0}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006281 };
6282
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006283 if (in_vim9script()
6284 && (check_for_string_arg(argvars, 0) == FAIL
6285 || check_for_opt_bool_arg(argvars, 1) == FAIL))
6286 return;
6287
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006288 name = tv_get_string(&argvars[0]);
Bram Moolenaar79296512020-03-22 16:17:14 +01006289 for (i = 0; has_list[i].name != NULL; ++i)
6290 if (STRICMP(name, has_list[i].name) == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006291 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006292 x = TRUE;
6293 n = has_list[i].present;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006294 break;
6295 }
6296
Bram Moolenaar79296512020-03-22 16:17:14 +01006297 // features also in has_list[] but sometimes enabled at runtime
6298 if (x == TRUE && n == FALSE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006299 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006300 if (0)
Bram Moolenaar86b9a3e2020-04-07 19:57:29 +02006301 {
6302 // intentionally empty
6303 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006304#ifdef VIMDLL
6305 else if (STRICMP(name, "filterpipe") == 0)
6306 n = gui.in_use || gui.starting;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006307#endif
6308#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6309 else if (STRICMP(name, "iconv") == 0)
6310 n = iconv_enabled(FALSE);
6311#endif
6312#ifdef DYNAMIC_LUA
6313 else if (STRICMP(name, "lua") == 0)
6314 n = lua_enabled(FALSE);
6315#endif
6316#ifdef DYNAMIC_MZSCHEME
6317 else if (STRICMP(name, "mzscheme") == 0)
6318 n = mzscheme_enabled(FALSE);
6319#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006320#ifdef DYNAMIC_PERL
6321 else if (STRICMP(name, "perl") == 0)
6322 n = perl_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006323#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006324#ifdef DYNAMIC_PYTHON
6325 else if (STRICMP(name, "python") == 0)
6326 n = python_enabled(FALSE);
6327#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006328#ifdef DYNAMIC_PYTHON3
6329 else if (STRICMP(name, "python3") == 0)
6330 n = python3_enabled(FALSE);
6331#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006332#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6333 else if (STRICMP(name, "pythonx") == 0)
6334 {
6335# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
6336 if (p_pyx == 0)
6337 n = python3_enabled(FALSE) || python_enabled(FALSE);
6338 else if (p_pyx == 3)
6339 n = python3_enabled(FALSE);
6340 else if (p_pyx == 2)
6341 n = python_enabled(FALSE);
6342# elif defined(DYNAMIC_PYTHON)
6343 n = python_enabled(FALSE);
6344# elif defined(DYNAMIC_PYTHON3)
6345 n = python3_enabled(FALSE);
6346# endif
6347 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006348#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006349#ifdef DYNAMIC_RUBY
6350 else if (STRICMP(name, "ruby") == 0)
6351 n = ruby_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006352#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006353#ifdef DYNAMIC_TCL
6354 else if (STRICMP(name, "tcl") == 0)
6355 n = tcl_enabled(FALSE);
Bram Moolenaar4b8366b2019-05-04 17:34:34 +02006356#endif
K.Takatad68b2fc2022-02-12 11:18:37 +00006357#ifdef DYNAMIC_SODIUM
6358 else if (STRICMP(name, "sodium") == 0)
6359 n = sodium_enabled(FALSE);
6360#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006361#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02006362 else if (STRICMP(name, "terminal") == 0)
6363 n = terminal_enabled();
6364#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006365 }
6366
Bram Moolenaar79296512020-03-22 16:17:14 +01006367 // features not in has_list[]
6368 if (x == FALSE)
6369 {
6370 if (STRNICMP(name, "patch", 5) == 0)
6371 {
6372 x = TRUE;
6373 if (name[5] == '-'
6374 && STRLEN(name) >= 11
6375 && vim_isdigit(name[6])
6376 && vim_isdigit(name[8])
6377 && vim_isdigit(name[10]))
6378 {
6379 int major = atoi((char *)name + 6);
6380 int minor = atoi((char *)name + 8);
6381
6382 // Expect "patch-9.9.01234".
6383 n = (major < VIM_VERSION_MAJOR
6384 || (major == VIM_VERSION_MAJOR
6385 && (minor < VIM_VERSION_MINOR
6386 || (minor == VIM_VERSION_MINOR
6387 && has_patch(atoi((char *)name + 10))))));
6388 }
6389 else
6390 n = has_patch(atoi((char *)name + 5));
6391 }
6392 else if (STRICMP(name, "vim_starting") == 0)
6393 {
6394 x = TRUE;
6395 n = (starting != 0);
6396 }
6397 else if (STRICMP(name, "ttyin") == 0)
6398 {
6399 x = TRUE;
6400 n = mch_input_isatty();
6401 }
6402 else if (STRICMP(name, "ttyout") == 0)
6403 {
6404 x = TRUE;
6405 n = stdout_isatty;
6406 }
6407 else if (STRICMP(name, "multi_byte_encoding") == 0)
6408 {
6409 x = TRUE;
6410 n = has_mbyte;
6411 }
6412 else if (STRICMP(name, "gui_running") == 0)
6413 {
6414 x = TRUE;
6415#ifdef FEAT_GUI
6416 n = (gui.in_use || gui.starting);
6417#endif
6418 }
6419 else if (STRICMP(name, "browse") == 0)
6420 {
6421 x = TRUE;
6422#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6423 n = gui.in_use; // gui_mch_browse() works when GUI is running
6424#endif
6425 }
6426 else if (STRICMP(name, "syntax_items") == 0)
6427 {
6428 x = TRUE;
6429#ifdef FEAT_SYN_HL
6430 n = syntax_present(curwin);
6431#endif
6432 }
6433 else if (STRICMP(name, "vcon") == 0)
6434 {
6435 x = TRUE;
6436#ifdef FEAT_VTP
6437 n = is_term_win32() && has_vtp_working();
6438#endif
6439 }
6440 else if (STRICMP(name, "netbeans_enabled") == 0)
6441 {
6442 x = TRUE;
6443#ifdef FEAT_NETBEANS_INTG
6444 n = netbeans_active();
6445#endif
6446 }
6447 else if (STRICMP(name, "mouse_gpm_enabled") == 0)
6448 {
6449 x = TRUE;
6450#ifdef FEAT_MOUSE_GPM
6451 n = gpm_enabled();
6452#endif
6453 }
6454 else if (STRICMP(name, "conpty") == 0)
6455 {
6456 x = TRUE;
6457#if defined(FEAT_TERMINAL) && defined(MSWIN)
6458 n = use_conpty();
6459#endif
6460 }
6461 else if (STRICMP(name, "clipboard_working") == 0)
6462 {
6463 x = TRUE;
6464#ifdef FEAT_CLIPBOARD
6465 n = clip_star.available;
6466#endif
6467 }
6468 }
6469
Bram Moolenaar04637e22020-09-05 18:45:29 +02006470 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
Bram Moolenaar79296512020-03-22 16:17:14 +01006471 // return whether feature could ever be enabled
6472 rettv->vval.v_number = x;
6473 else
6474 // return whether feature is enabled
6475 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006476}
6477
6478/*
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006479 * Return TRUE if "feature" can change later.
6480 * Also when checking for the feature has side effects, such as loading a DLL.
6481 */
6482 int
6483dynamic_feature(char_u *feature)
6484{
6485 return (feature == NULL
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006486#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6487 || (STRICMP(feature, "browse") == 0 && !gui.in_use)
6488#endif
6489#ifdef VIMDLL
6490 || STRICMP(feature, "filterpipe") == 0
6491#endif
Bram Moolenaar29b281b2020-11-10 20:58:00 +01006492#if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL)
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006493 // this can only change on Unix where the ":gui" command could be
6494 // used.
6495 || (STRICMP(feature, "gui_running") == 0 && !gui.in_use)
6496#endif
6497#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6498 || STRICMP(feature, "iconv") == 0
6499#endif
6500#ifdef DYNAMIC_LUA
6501 || STRICMP(feature, "lua") == 0
6502#endif
6503#ifdef FEAT_MOUSE_GPM
6504 || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled())
6505#endif
6506#ifdef DYNAMIC_MZSCHEME
6507 || STRICMP(feature, "mzscheme") == 0
6508#endif
6509#ifdef FEAT_NETBEANS_INTG
6510 || STRICMP(feature, "netbeans_enabled") == 0
6511#endif
6512#ifdef DYNAMIC_PERL
6513 || STRICMP(feature, "perl") == 0
6514#endif
6515#ifdef DYNAMIC_PYTHON
6516 || STRICMP(feature, "python") == 0
6517#endif
6518#ifdef DYNAMIC_PYTHON3
6519 || STRICMP(feature, "python3") == 0
6520#endif
6521#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6522 || STRICMP(feature, "pythonx") == 0
6523#endif
6524#ifdef DYNAMIC_RUBY
6525 || STRICMP(feature, "ruby") == 0
6526#endif
6527#ifdef FEAT_SYN_HL
6528 || STRICMP(feature, "syntax_items") == 0
6529#endif
6530#ifdef DYNAMIC_TCL
6531 || STRICMP(feature, "tcl") == 0
6532#endif
6533 // once "starting" is zero it will stay that way
6534 || (STRICMP(feature, "vim_starting") == 0 && starting != 0)
6535 || STRICMP(feature, "multi_byte_encoding") == 0
6536#if defined(FEAT_TERMINAL) && defined(MSWIN)
6537 || STRICMP(feature, "conpty") == 0
6538#endif
6539 );
6540}
6541
6542/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006543 * "haslocaldir()" function
6544 */
6545 static void
6546f_haslocaldir(typval_T *argvars, typval_T *rettv)
6547{
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006548 tabpage_T *tp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006549 win_T *wp = NULL;
6550
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006551 if (in_vim9script()
6552 && (check_for_opt_number_arg(argvars, 0) == FAIL
6553 || (argvars[0].v_type != VAR_UNKNOWN
6554 && check_for_opt_number_arg(argvars, 1) == FAIL)))
6555 return;
6556
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006557 wp = find_tabwin(&argvars[0], &argvars[1], &tp);
6558
6559 // Check for window-local and tab-local directories
6560 if (wp != NULL && wp->w_localdir != NULL)
6561 rettv->vval.v_number = 1;
6562 else if (tp != NULL && tp->tp_localdir != NULL)
6563 rettv->vval.v_number = 2;
6564 else
6565 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006566}
6567
6568/*
6569 * "hasmapto()" function
6570 */
6571 static void
6572f_hasmapto(typval_T *argvars, typval_T *rettv)
6573{
6574 char_u *name;
6575 char_u *mode;
6576 char_u buf[NUMBUFLEN];
6577 int abbr = FALSE;
6578
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006579 if (in_vim9script()
6580 && (check_for_string_arg(argvars, 0) == FAIL
6581 || check_for_opt_string_arg(argvars, 1) == FAIL
6582 || (argvars[1].v_type != VAR_UNKNOWN
6583 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
6584 return;
6585
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006586 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006587 if (argvars[1].v_type == VAR_UNKNOWN)
6588 mode = (char_u *)"nvo";
6589 else
6590 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006591 mode = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006592 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar04d594b2020-09-02 22:25:35 +02006593 abbr = (int)tv_get_bool(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006594 }
6595
6596 if (map_to_exists(name, mode, abbr))
6597 rettv->vval.v_number = TRUE;
6598 else
6599 rettv->vval.v_number = FALSE;
6600}
6601
6602/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006603 * "highlightID(name)" function
6604 */
6605 static void
6606f_hlID(typval_T *argvars, typval_T *rettv)
6607{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006608 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6609 return;
6610
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006611 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006612}
6613
6614/*
6615 * "highlight_exists()" function
6616 */
6617 static void
6618f_hlexists(typval_T *argvars, typval_T *rettv)
6619{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006620 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6621 return;
6622
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006623 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006624}
6625
6626/*
6627 * "hostname()" function
6628 */
6629 static void
6630f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
6631{
6632 char_u hostname[256];
6633
6634 mch_get_host_name(hostname, 256);
6635 rettv->v_type = VAR_STRING;
6636 rettv->vval.v_string = vim_strsave(hostname);
6637}
6638
6639/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006640 * "index()" function
6641 */
6642 static void
6643f_index(typval_T *argvars, typval_T *rettv)
6644{
6645 list_T *l;
6646 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006647 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006648 long idx = 0;
6649 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006650 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006651
6652 rettv->vval.v_number = -1;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006653
6654 if (in_vim9script()
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02006655 && (check_for_list_or_blob_arg(argvars, 0) == FAIL
6656 || (argvars[0].v_type == VAR_BLOB
6657 && check_for_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006658 || check_for_opt_number_arg(argvars, 2) == FAIL
6659 || (argvars[2].v_type != VAR_UNKNOWN
6660 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
6661 return;
6662
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006663 if (argvars[0].v_type == VAR_BLOB)
6664 {
6665 typval_T tv;
6666 int start = 0;
6667
6668 if (argvars[2].v_type != VAR_UNKNOWN)
6669 {
6670 start = tv_get_number_chk(&argvars[2], &error);
6671 if (error)
6672 return;
6673 }
6674 b = argvars[0].vval.v_blob;
6675 if (b == NULL)
6676 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01006677 if (start < 0)
6678 {
6679 start = blob_len(b) + start;
6680 if (start < 0)
6681 start = 0;
6682 }
6683
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006684 for (idx = start; idx < blob_len(b); ++idx)
6685 {
6686 tv.v_type = VAR_NUMBER;
6687 tv.vval.v_number = blob_get(b, idx);
6688 if (tv_equal(&tv, &argvars[1], ic, FALSE))
6689 {
6690 rettv->vval.v_number = idx;
6691 return;
6692 }
6693 }
6694 return;
6695 }
6696 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006697 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00006698 emsg(_(e_list_or_blob_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006699 return;
6700 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006701
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006702 l = argvars[0].vval.v_list;
6703 if (l != NULL)
6704 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02006705 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006706 item = l->lv_first;
6707 if (argvars[2].v_type != VAR_UNKNOWN)
6708 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006709 // Start at specified item. Use the cached index that list_find()
6710 // sets, so that a negative number also works.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006711 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006712 idx = l->lv_u.mat.lv_idx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006713 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaar6c553f92020-09-02 22:10:34 +02006714 ic = (int)tv_get_bool_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006715 if (error)
6716 item = NULL;
6717 }
6718
6719 for ( ; item != NULL; item = item->li_next, ++idx)
6720 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
6721 {
6722 rettv->vval.v_number = idx;
6723 break;
6724 }
6725 }
6726}
6727
6728static int inputsecret_flag = 0;
6729
6730/*
6731 * "input()" function
6732 * Also handles inputsecret() when inputsecret is set.
6733 */
6734 static void
6735f_input(typval_T *argvars, typval_T *rettv)
6736{
6737 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
6738}
6739
6740/*
6741 * "inputdialog()" function
6742 */
6743 static void
6744f_inputdialog(typval_T *argvars, typval_T *rettv)
6745{
6746#if defined(FEAT_GUI_TEXTDIALOG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006747 // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions'
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006748 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
6749 {
6750 char_u *message;
6751 char_u buf[NUMBUFLEN];
6752 char_u *defstr = (char_u *)"";
6753
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006754 if (in_vim9script()
6755 && (check_for_string_arg(argvars, 0) == FAIL
6756 || check_for_opt_string_arg(argvars, 1) == FAIL
6757 || (argvars[1].v_type != VAR_UNKNOWN
6758 && check_for_opt_string_arg(argvars, 2) == FAIL)))
6759 return;
6760
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006761 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006762 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006763 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006764 vim_strncpy(IObuff, defstr, IOSIZE - 1);
6765 else
6766 IObuff[0] = NUL;
6767 if (message != NULL && defstr != NULL
6768 && do_dialog(VIM_QUESTION, NULL, message,
6769 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
6770 rettv->vval.v_string = vim_strsave(IObuff);
6771 else
6772 {
6773 if (message != NULL && defstr != NULL
6774 && argvars[1].v_type != VAR_UNKNOWN
6775 && argvars[2].v_type != VAR_UNKNOWN)
6776 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006777 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006778 else
6779 rettv->vval.v_string = NULL;
6780 }
6781 rettv->v_type = VAR_STRING;
6782 }
6783 else
6784#endif
6785 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
6786}
6787
6788/*
6789 * "inputlist()" function
6790 */
6791 static void
6792f_inputlist(typval_T *argvars, typval_T *rettv)
6793{
Bram Moolenaar50985eb2020-01-27 22:09:39 +01006794 list_T *l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006795 listitem_T *li;
6796 int selected;
6797 int mouse_used;
6798
6799#ifdef NO_CONSOLE_INPUT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006800 // While starting up, there is no place to enter text. When running tests
6801 // with --not-a-term we assume feedkeys() will be used.
Bram Moolenaar91d348a2017-07-29 20:16:03 +02006802 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006803 return;
6804#endif
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006805 if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
6806 return;
6807
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006808 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
6809 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00006810 semsg(_(e_argument_of_str_must_be_list), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006811 return;
6812 }
6813
6814 msg_start();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006815 msg_row = Rows - 1; // for when 'cmdheight' > 1
6816 lines_left = Rows; // avoid more prompt
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006817 msg_scroll = TRUE;
6818 msg_clr_eos();
6819
Bram Moolenaar50985eb2020-01-27 22:09:39 +01006820 l = argvars[0].vval.v_list;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02006821 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02006822 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006823 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01006824 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006825 msg_putchar('\n');
6826 }
6827
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006828 // Ask for choice.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006829 selected = prompt_for_number(&mouse_used);
6830 if (mouse_used)
6831 selected -= lines_left;
6832
6833 rettv->vval.v_number = selected;
6834}
6835
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006836static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
6837
6838/*
6839 * "inputrestore()" function
6840 */
6841 static void
6842f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
6843{
6844 if (ga_userinput.ga_len > 0)
6845 {
6846 --ga_userinput.ga_len;
6847 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
Bram Moolenaarc41badb2021-06-07 22:04:52 +02006848 + ga_userinput.ga_len, TRUE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006849 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006850 }
6851 else if (p_verbose > 1)
6852 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01006853 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006854 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006855 }
6856}
6857
6858/*
6859 * "inputsave()" function
6860 */
6861 static void
6862f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
6863{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006864 // Add an entry to the stack of typeahead storage.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006865 if (ga_grow(&ga_userinput, 1) == OK)
6866 {
6867 save_typeahead((tasave_T *)(ga_userinput.ga_data)
6868 + ga_userinput.ga_len);
6869 ++ga_userinput.ga_len;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006870 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006871 }
6872 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006873 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006874}
6875
6876/*
6877 * "inputsecret()" function
6878 */
6879 static void
6880f_inputsecret(typval_T *argvars, typval_T *rettv)
6881{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006882 if (in_vim9script()
6883 && (check_for_string_arg(argvars, 0) == FAIL
6884 || check_for_opt_string_arg(argvars, 1) == FAIL))
6885 return;
6886
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006887 ++cmdline_star;
6888 ++inputsecret_flag;
6889 f_input(argvars, rettv);
6890 --cmdline_star;
6891 --inputsecret_flag;
6892}
6893
6894/*
Bram Moolenaar67a2deb2019-11-25 00:05:32 +01006895 * "interrupt()" function
6896 */
6897 static void
6898f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
6899{
6900 got_int = TRUE;
6901}
6902
6903/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006904 * "invert(expr)" function
6905 */
6906 static void
6907f_invert(typval_T *argvars, typval_T *rettv)
6908{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006909 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
6910 return;
6911
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006912 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006913}
6914
6915/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006916 * "islocked()" function
6917 */
6918 static void
6919f_islocked(typval_T *argvars, typval_T *rettv)
6920{
6921 lval_T lv;
6922 char_u *end;
6923 dictitem_T *di;
6924
6925 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02006926
6927 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6928 return;
6929
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006930 end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
Bram Moolenaarbd77aa92021-08-12 17:06:05 +02006931 GLV_NO_AUTOLOAD | GLV_READ_ONLY | GLV_NO_DECL,
6932 FNE_CHECK_START);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006933 if (end != NULL && lv.ll_name != NULL)
6934 {
6935 if (*end != NUL)
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02006936 {
6937 semsg(_(lv.ll_name == lv.ll_name_end
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00006938 ? e_invalid_argument_str : e_trailing_characters_str), end);
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02006939 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006940 else
6941 {
6942 if (lv.ll_tv == NULL)
6943 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01006944 di = find_var(lv.ll_name, NULL, TRUE);
6945 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006946 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006947 // Consider a variable locked when:
6948 // 1. the variable itself is locked
6949 // 2. the value of the variable is locked.
6950 // 3. the List or Dict value is locked.
Bram Moolenaar79518e22017-02-17 16:31:35 +01006951 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
6952 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006953 }
6954 }
6955 else if (lv.ll_range)
Bram Moolenaar677658a2022-01-05 16:09:06 +00006956 emsg(_(e_range_not_allowed));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006957 else if (lv.ll_newkey != NULL)
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00006958 semsg(_(e_key_not_present_in_dictionary), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006959 else if (lv.ll_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006960 // List item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006961 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
6962 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006963 // Dictionary item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006964 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
6965 }
6966 }
6967
6968 clear_lval(&lv);
6969}
6970
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006971/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006972 * "last_buffer_nr()" function.
6973 */
6974 static void
6975f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
6976{
6977 int n = 0;
6978 buf_T *buf;
6979
Bram Moolenaar29323592016-07-24 22:04:11 +02006980 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006981 if (n < buf->b_fnum)
6982 n = buf->b_fnum;
6983
6984 rettv->vval.v_number = n;
6985}
6986
6987/*
6988 * "len()" function
6989 */
6990 static void
6991f_len(typval_T *argvars, typval_T *rettv)
6992{
6993 switch (argvars[0].v_type)
6994 {
6995 case VAR_STRING:
6996 case VAR_NUMBER:
6997 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006998 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006999 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007000 case VAR_BLOB:
7001 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
7002 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007003 case VAR_LIST:
7004 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
7005 break;
7006 case VAR_DICT:
7007 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
7008 break;
7009 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02007010 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007011 case VAR_VOID:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01007012 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007013 case VAR_SPECIAL:
7014 case VAR_FLOAT:
7015 case VAR_FUNC:
7016 case VAR_PARTIAL:
7017 case VAR_JOB:
7018 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02007019 case VAR_INSTR:
Bram Moolenaara6f79292022-01-04 21:30:47 +00007020 emsg(_(e_invalid_type_for_len));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007021 break;
7022 }
7023}
7024
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007025 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01007026libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007027{
7028#ifdef FEAT_LIBCALL
7029 char_u *string_in;
7030 char_u **string_result;
7031 int nr_result;
7032#endif
7033
7034 rettv->v_type = type;
7035 if (type != VAR_NUMBER)
7036 rettv->vval.v_string = NULL;
7037
7038 if (check_restricted() || check_secure())
7039 return;
7040
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02007041 if (in_vim9script()
7042 && (check_for_string_arg(argvars, 0) == FAIL
7043 || check_for_string_arg(argvars, 1) == FAIL
7044 || check_for_string_or_number_arg(argvars, 2) == FAIL))
7045 return;
7046
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007047#ifdef FEAT_LIBCALL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007048 // The first two args must be strings, otherwise it's meaningless
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007049 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
7050 {
7051 string_in = NULL;
7052 if (argvars[2].v_type == VAR_STRING)
7053 string_in = argvars[2].vval.v_string;
7054 if (type == VAR_NUMBER)
Bram Moolenaar87e15872021-09-02 19:53:07 +02007055 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007056 string_result = NULL;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007057 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007058 else
Bram Moolenaar87e15872021-09-02 19:53:07 +02007059 {
7060 rettv->vval.v_string = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007061 string_result = &rettv->vval.v_string;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007062 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007063 if (mch_libcall(argvars[0].vval.v_string,
7064 argvars[1].vval.v_string,
7065 string_in,
7066 argvars[2].vval.v_number,
7067 string_result,
7068 &nr_result) == OK
7069 && type == VAR_NUMBER)
7070 rettv->vval.v_number = nr_result;
7071 }
7072#endif
7073}
7074
7075/*
7076 * "libcall()" function
7077 */
7078 static void
7079f_libcall(typval_T *argvars, typval_T *rettv)
7080{
7081 libcall_common(argvars, rettv, VAR_STRING);
7082}
7083
7084/*
7085 * "libcallnr()" function
7086 */
7087 static void
7088f_libcallnr(typval_T *argvars, typval_T *rettv)
7089{
7090 libcall_common(argvars, rettv, VAR_NUMBER);
7091}
7092
7093/*
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007094 * "line(string, [winid])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007095 */
7096 static void
7097f_line(typval_T *argvars, typval_T *rettv)
7098{
7099 linenr_T lnum = 0;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007100 pos_T *fp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007101 int fnum;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007102 int id;
7103 tabpage_T *tp;
7104 win_T *wp;
Bram Moolenaar18f47402022-01-06 13:24:51 +00007105 switchwin_T switchwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007106
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007107 if (in_vim9script()
7108 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007109 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007110 return;
7111
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007112 if (argvars[1].v_type != VAR_UNKNOWN)
7113 {
7114 // use window specified in the second argument
7115 id = (int)tv_get_number(&argvars[1]);
7116 wp = win_id2wp_tp(id, &tp);
7117 if (wp != NULL && tp != NULL)
7118 {
Bram Moolenaar18f47402022-01-06 13:24:51 +00007119 if (switch_win_noblock(&switchwin, wp, tp, TRUE) == OK)
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007120 {
7121 check_cursor();
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007122 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007123 }
Bram Moolenaar18f47402022-01-06 13:24:51 +00007124 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007125 }
7126 }
7127 else
7128 // use current window
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007129 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007130
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007131 if (fp != NULL)
7132 lnum = fp->lnum;
7133 rettv->vval.v_number = lnum;
7134}
7135
7136/*
7137 * "line2byte(lnum)" function
7138 */
7139 static void
7140f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
7141{
7142#ifndef FEAT_BYTEOFF
7143 rettv->vval.v_number = -1;
7144#else
7145 linenr_T lnum;
7146
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007147 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7148 return;
7149
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007150 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007151 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
7152 rettv->vval.v_number = -1;
7153 else
7154 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
7155 if (rettv->vval.v_number >= 0)
7156 ++rettv->vval.v_number;
7157#endif
7158}
7159
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007160#ifdef FEAT_LUA
7161/*
7162 * "luaeval()" function
7163 */
7164 static void
7165f_luaeval(typval_T *argvars, typval_T *rettv)
7166{
7167 char_u *str;
7168 char_u buf[NUMBUFLEN];
7169
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007170 if (check_restricted() || check_secure())
7171 return;
7172
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02007173 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7174 return;
7175
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007176 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007177 do_luaeval(str, argvars + 1, rettv);
7178}
7179#endif
7180
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007181typedef enum
7182{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007183 MATCH_END, // matchend()
7184 MATCH_MATCH, // match()
7185 MATCH_STR, // matchstr()
7186 MATCH_LIST, // matchlist()
7187 MATCH_POS // matchstrpos()
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007188} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007189
7190 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007191find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007192{
7193 char_u *str = NULL;
7194 long len = 0;
7195 char_u *expr = NULL;
7196 char_u *pat;
7197 regmatch_T regmatch;
7198 char_u patbuf[NUMBUFLEN];
7199 char_u strbuf[NUMBUFLEN];
7200 char_u *save_cpo;
7201 long start = 0;
7202 long nth = 1;
7203 colnr_T startcol = 0;
7204 int match = 0;
7205 list_T *l = NULL;
7206 listitem_T *li = NULL;
7207 long idx = 0;
7208 char_u *tofree = NULL;
7209
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007210 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007211 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01007212 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007213
7214 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007215 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007216 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007217 // type MATCH_LIST: return empty list when there are no matches.
7218 // type MATCH_POS: return ["", -1, -1, -1]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007219 if (rettv_list_alloc(rettv) == FAIL)
7220 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007221 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007222 && (list_append_string(rettv->vval.v_list,
7223 (char_u *)"", 0) == FAIL
7224 || list_append_number(rettv->vval.v_list,
7225 (varnumber_T)-1) == FAIL
7226 || list_append_number(rettv->vval.v_list,
7227 (varnumber_T)-1) == FAIL
7228 || list_append_number(rettv->vval.v_list,
7229 (varnumber_T)-1) == FAIL))
7230 {
7231 list_free(rettv->vval.v_list);
7232 rettv->vval.v_list = NULL;
7233 goto theend;
7234 }
7235 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007236 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007237 {
7238 rettv->v_type = VAR_STRING;
7239 rettv->vval.v_string = NULL;
7240 }
7241
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007242 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007243 && (check_for_string_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007244 || check_for_string_arg(argvars, 1) == FAIL
7245 || check_for_opt_number_arg(argvars, 2) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007246 || (argvars[2].v_type != VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007247 && check_for_opt_number_arg(argvars, 3) == FAIL)))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007248 goto theend;
7249
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007250 if (argvars[0].v_type == VAR_LIST)
7251 {
7252 if ((l = argvars[0].vval.v_list) == NULL)
7253 goto theend;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007254 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007255 li = l->lv_first;
7256 }
7257 else
7258 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007259 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007260 len = (long)STRLEN(str);
7261 }
7262
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007263 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007264 if (pat == NULL)
7265 goto theend;
7266
7267 if (argvars[2].v_type != VAR_UNKNOWN)
7268 {
7269 int error = FALSE;
7270
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007271 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007272 if (error)
7273 goto theend;
7274 if (l != NULL)
7275 {
7276 li = list_find(l, start);
7277 if (li == NULL)
7278 goto theend;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007279 idx = l->lv_u.mat.lv_idx; // use the cached index
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007280 }
7281 else
7282 {
7283 if (start < 0)
7284 start = 0;
7285 if (start > len)
7286 goto theend;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007287 // When "count" argument is there ignore matches before "start",
7288 // otherwise skip part of the string. Differs when pattern is "^"
7289 // or "\<".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007290 if (argvars[3].v_type != VAR_UNKNOWN)
7291 startcol = start;
7292 else
7293 {
7294 str += start;
7295 len -= start;
7296 }
7297 }
7298
7299 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007300 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007301 if (error)
7302 goto theend;
7303 }
7304
7305 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
7306 if (regmatch.regprog != NULL)
7307 {
7308 regmatch.rm_ic = p_ic;
7309
7310 for (;;)
7311 {
7312 if (l != NULL)
7313 {
7314 if (li == NULL)
7315 {
7316 match = FALSE;
7317 break;
7318 }
7319 vim_free(tofree);
7320 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
7321 if (str == NULL)
7322 break;
7323 }
7324
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00007325 match = vim_regexec_nl(&regmatch, str, startcol);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007326
7327 if (match && --nth <= 0)
7328 break;
7329 if (l == NULL && !match)
7330 break;
7331
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007332 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007333 if (l != NULL)
7334 {
7335 li = li->li_next;
7336 ++idx;
7337 }
7338 else
7339 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007340 startcol = (colnr_T)(regmatch.startp[0]
7341 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007342 if (startcol > (colnr_T)len
7343 || str + startcol <= regmatch.startp[0])
7344 {
7345 match = FALSE;
7346 break;
7347 }
7348 }
7349 }
7350
7351 if (match)
7352 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007353 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007354 {
7355 listitem_T *li1 = rettv->vval.v_list->lv_first;
7356 listitem_T *li2 = li1->li_next;
7357 listitem_T *li3 = li2->li_next;
7358 listitem_T *li4 = li3->li_next;
7359
7360 vim_free(li1->li_tv.vval.v_string);
7361 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007362 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007363 li3->li_tv.vval.v_number =
7364 (varnumber_T)(regmatch.startp[0] - expr);
7365 li4->li_tv.vval.v_number =
7366 (varnumber_T)(regmatch.endp[0] - expr);
7367 if (l != NULL)
7368 li2->li_tv.vval.v_number = (varnumber_T)idx;
7369 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007370 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007371 {
7372 int i;
7373
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007374 // return list with matched string and submatches
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007375 for (i = 0; i < NSUBEXP; ++i)
7376 {
7377 if (regmatch.endp[i] == NULL)
7378 {
7379 if (list_append_string(rettv->vval.v_list,
7380 (char_u *)"", 0) == FAIL)
7381 break;
7382 }
7383 else if (list_append_string(rettv->vval.v_list,
7384 regmatch.startp[i],
7385 (int)(regmatch.endp[i] - regmatch.startp[i]))
7386 == FAIL)
7387 break;
7388 }
7389 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007390 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007391 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007392 // return matched string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007393 if (l != NULL)
7394 copy_tv(&li->li_tv, rettv);
7395 else
7396 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007397 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007398 }
7399 else if (l != NULL)
7400 rettv->vval.v_number = idx;
7401 else
7402 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007403 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007404 rettv->vval.v_number =
7405 (varnumber_T)(regmatch.startp[0] - str);
7406 else
7407 rettv->vval.v_number =
7408 (varnumber_T)(regmatch.endp[0] - str);
7409 rettv->vval.v_number += (varnumber_T)(str - expr);
7410 }
7411 }
7412 vim_regfree(regmatch.regprog);
7413 }
7414
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007415theend:
7416 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007417 // matchstrpos() without a list: drop the second item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007418 listitem_remove(rettv->vval.v_list,
7419 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007420 vim_free(tofree);
7421 p_cpo = save_cpo;
7422}
7423
7424/*
7425 * "match()" function
7426 */
7427 static void
7428f_match(typval_T *argvars, typval_T *rettv)
7429{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007430 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007431}
7432
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007433/*
7434 * "matchend()" function
7435 */
7436 static void
7437f_matchend(typval_T *argvars, typval_T *rettv)
7438{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007439 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007440}
7441
7442/*
7443 * "matchlist()" function
7444 */
7445 static void
7446f_matchlist(typval_T *argvars, typval_T *rettv)
7447{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007448 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007449}
7450
7451/*
7452 * "matchstr()" function
7453 */
7454 static void
7455f_matchstr(typval_T *argvars, typval_T *rettv)
7456{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007457 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007458}
7459
7460/*
7461 * "matchstrpos()" function
7462 */
7463 static void
7464f_matchstrpos(typval_T *argvars, typval_T *rettv)
7465{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007466 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007467}
7468
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007469 static void
7470max_min(typval_T *argvars, typval_T *rettv, int domax)
7471{
7472 varnumber_T n = 0;
7473 varnumber_T i;
7474 int error = FALSE;
7475
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007476 if (in_vim9script() && check_for_list_or_dict_arg(argvars, 0) == FAIL)
7477 return;
7478
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007479 if (argvars[0].v_type == VAR_LIST)
7480 {
7481 list_T *l;
7482 listitem_T *li;
7483
7484 l = argvars[0].vval.v_list;
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007485 if (l != NULL && l->lv_len > 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007486 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007487 if (l->lv_first == &range_list_item)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007488 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007489 if ((l->lv_u.nonmat.lv_stride > 0) ^ domax)
7490 n = l->lv_u.nonmat.lv_start;
7491 else
=?UTF-8?q?Dundar=20G=C3=B6c?=d5cec1f2022-01-29 15:19:23 +00007492 n = l->lv_u.nonmat.lv_start + ((varnumber_T)l->lv_len - 1)
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007493 * l->lv_u.nonmat.lv_stride;
7494 }
7495 else
7496 {
7497 li = l->lv_first;
7498 if (li != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007499 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007500 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007501 if (error)
7502 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007503 for (;;)
7504 {
7505 li = li->li_next;
7506 if (li == NULL)
7507 break;
7508 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007509 if (error)
7510 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007511 if (domax ? i > n : i < n)
7512 n = i;
7513 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007514 }
7515 }
7516 }
7517 }
7518 else if (argvars[0].v_type == VAR_DICT)
7519 {
7520 dict_T *d;
7521 int first = TRUE;
7522 hashitem_T *hi;
7523 int todo;
7524
7525 d = argvars[0].vval.v_dict;
7526 if (d != NULL)
7527 {
7528 todo = (int)d->dv_hashtab.ht_used;
7529 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
7530 {
7531 if (!HASHITEM_EMPTY(hi))
7532 {
7533 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007534 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007535 if (error)
7536 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007537 if (first)
7538 {
7539 n = i;
7540 first = FALSE;
7541 }
7542 else if (domax ? i > n : i < n)
7543 n = i;
7544 }
7545 }
7546 }
7547 }
7548 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007549 semsg(_(e_argument_of_str_must_be_list_or_dictionary), domax ? "max()" : "min()");
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007550
7551 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007552}
7553
7554/*
7555 * "max()" function
7556 */
7557 static void
7558f_max(typval_T *argvars, typval_T *rettv)
7559{
7560 max_min(argvars, rettv, TRUE);
7561}
7562
7563/*
7564 * "min()" function
7565 */
7566 static void
7567f_min(typval_T *argvars, typval_T *rettv)
7568{
7569 max_min(argvars, rettv, FALSE);
7570}
7571
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007572#if defined(FEAT_MZSCHEME) || defined(PROTO)
7573/*
7574 * "mzeval()" function
7575 */
7576 static void
7577f_mzeval(typval_T *argvars, typval_T *rettv)
7578{
7579 char_u *str;
7580 char_u buf[NUMBUFLEN];
7581
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007582 if (check_restricted() || check_secure())
7583 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007584
7585 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7586 return;
7587
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007588 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007589 do_mzeval(str, rettv);
7590}
7591
7592 void
7593mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
7594{
7595 typval_T argvars[3];
7596
7597 argvars[0].v_type = VAR_STRING;
7598 argvars[0].vval.v_string = name;
7599 copy_tv(args, &argvars[1]);
7600 argvars[2].v_type = VAR_UNKNOWN;
7601 f_call(argvars, rettv);
7602 clear_tv(&argvars[1]);
7603}
7604#endif
7605
7606/*
7607 * "nextnonblank()" function
7608 */
7609 static void
7610f_nextnonblank(typval_T *argvars, typval_T *rettv)
7611{
7612 linenr_T lnum;
7613
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007614 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7615 return;
7616
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007617 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007618 {
7619 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
7620 {
7621 lnum = 0;
7622 break;
7623 }
7624 if (*skipwhite(ml_get(lnum)) != NUL)
7625 break;
7626 }
7627 rettv->vval.v_number = lnum;
7628}
7629
7630/*
7631 * "nr2char()" function
7632 */
7633 static void
7634f_nr2char(typval_T *argvars, typval_T *rettv)
7635{
7636 char_u buf[NUMBUFLEN];
7637
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007638 if (in_vim9script()
7639 && (check_for_number_arg(argvars, 0) == FAIL
7640 || check_for_opt_bool_arg(argvars, 1) == FAIL))
7641 return;
7642
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007643 if (has_mbyte)
7644 {
7645 int utf8 = 0;
7646
7647 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaared6a4302020-09-05 20:29:41 +02007648 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007649 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01007650 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007651 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007652 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007653 }
7654 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007655 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007656 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007657 buf[1] = NUL;
7658 }
7659 rettv->v_type = VAR_STRING;
7660 rettv->vval.v_string = vim_strsave(buf);
7661}
7662
7663/*
7664 * "or(expr, expr)" function
7665 */
7666 static void
7667f_or(typval_T *argvars, typval_T *rettv)
7668{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007669 if (in_vim9script()
7670 && (check_for_number_arg(argvars, 0) == FAIL
7671 || check_for_number_arg(argvars, 1) == FAIL))
7672 return;
7673
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007674 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
7675 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007676}
7677
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007678#ifdef FEAT_PERL
7679/*
7680 * "perleval()" function
7681 */
7682 static void
7683f_perleval(typval_T *argvars, typval_T *rettv)
7684{
7685 char_u *str;
7686 char_u buf[NUMBUFLEN];
7687
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007688 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7689 return;
7690
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007691 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007692 do_perleval(str, rettv);
7693}
7694#endif
7695
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007696/*
7697 * "prevnonblank()" function
7698 */
7699 static void
7700f_prevnonblank(typval_T *argvars, typval_T *rettv)
7701{
7702 linenr_T lnum;
7703
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007704 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7705 return;
7706
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007707 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007708 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
7709 lnum = 0;
7710 else
7711 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
7712 --lnum;
7713 rettv->vval.v_number = lnum;
7714}
7715
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007716// This dummy va_list is here because:
7717// - passing a NULL pointer doesn't work when va_list isn't a pointer
7718// - locally in the function results in a "used before set" warning
7719// - using va_start() to initialize it gives "function with fixed args" error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007720static va_list ap;
7721
7722/*
7723 * "printf()" function
7724 */
7725 static void
7726f_printf(typval_T *argvars, typval_T *rettv)
7727{
7728 char_u buf[NUMBUFLEN];
7729 int len;
7730 char_u *s;
7731 int saved_did_emsg = did_emsg;
7732 char *fmt;
7733
7734 rettv->v_type = VAR_STRING;
7735 rettv->vval.v_string = NULL;
7736
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02007737 if (in_vim9script() && check_for_string_or_number_arg(argvars, 0) == FAIL)
7738 return;
7739
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007740 // Get the required length, allocate the buffer and do it for real.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007741 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007742 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02007743 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007744 if (!did_emsg)
7745 {
7746 s = alloc(len + 1);
7747 if (s != NULL)
7748 {
7749 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02007750 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
7751 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007752 }
7753 }
7754 did_emsg |= saved_did_emsg;
7755}
7756
7757/*
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007758 * "pum_getpos()" function
7759 */
7760 static void
7761f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7762{
7763 if (rettv_dict_alloc(rettv) != OK)
7764 return;
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007765 pum_set_event_info(rettv->vval.v_dict);
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007766}
7767
7768/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007769 * "pumvisible()" function
7770 */
7771 static void
7772f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7773{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007774 if (pum_visible())
7775 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007776}
7777
7778#ifdef FEAT_PYTHON3
7779/*
7780 * "py3eval()" function
7781 */
7782 static void
7783f_py3eval(typval_T *argvars, typval_T *rettv)
7784{
7785 char_u *str;
7786 char_u buf[NUMBUFLEN];
7787
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007788 if (check_restricted() || check_secure())
7789 return;
7790
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007791 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7792 return;
7793
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01007794 if (p_pyx == 0)
7795 p_pyx = 3;
7796
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007797 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007798 do_py3eval(str, rettv);
7799}
7800#endif
7801
7802#ifdef FEAT_PYTHON
7803/*
7804 * "pyeval()" function
7805 */
7806 static void
7807f_pyeval(typval_T *argvars, typval_T *rettv)
7808{
7809 char_u *str;
7810 char_u buf[NUMBUFLEN];
7811
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007812 if (check_restricted() || check_secure())
7813 return;
7814
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007815 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7816 return;
7817
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01007818 if (p_pyx == 0)
7819 p_pyx = 2;
7820
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007821 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007822 do_pyeval(str, rettv);
7823}
7824#endif
7825
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01007826#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
7827/*
7828 * "pyxeval()" function
7829 */
7830 static void
7831f_pyxeval(typval_T *argvars, typval_T *rettv)
7832{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007833 if (check_restricted() || check_secure())
7834 return;
7835
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007836 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7837 return;
7838
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01007839# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
7840 init_pyxversion();
7841 if (p_pyx == 2)
7842 f_pyeval(argvars, rettv);
7843 else
7844 f_py3eval(argvars, rettv);
7845# elif defined(FEAT_PYTHON)
7846 f_pyeval(argvars, rettv);
7847# elif defined(FEAT_PYTHON3)
7848 f_py3eval(argvars, rettv);
7849# endif
7850}
7851#endif
7852
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007853static UINT32_T srand_seed_for_testing = 0;
7854static int srand_seed_for_testing_is_used = FALSE;
7855
7856 static void
7857f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED)
7858{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007859 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
7860 return;
7861
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007862 if (argvars[0].v_type == VAR_UNKNOWN)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02007863 srand_seed_for_testing_is_used = FALSE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007864 else
7865 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02007866 srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]);
7867 srand_seed_for_testing_is_used = TRUE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007868 }
7869}
7870
7871 static void
7872init_srand(UINT32_T *x)
7873{
7874#ifndef MSWIN
7875 static int dev_urandom_state = NOTDONE; // FAIL or OK once tried
7876#endif
7877
7878 if (srand_seed_for_testing_is_used)
7879 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02007880 *x = srand_seed_for_testing;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007881 return;
7882 }
7883#ifndef MSWIN
7884 if (dev_urandom_state != FAIL)
7885 {
7886 int fd = open("/dev/urandom", O_RDONLY);
7887 struct {
7888 union {
7889 UINT32_T number;
7890 char bytes[sizeof(UINT32_T)];
7891 } contents;
7892 } buf;
7893
7894 // Attempt reading /dev/urandom.
7895 if (fd == -1)
7896 dev_urandom_state = FAIL;
7897 else
7898 {
7899 buf.contents.number = 0;
7900 if (read(fd, buf.contents.bytes, sizeof(UINT32_T))
7901 != sizeof(UINT32_T))
7902 dev_urandom_state = FAIL;
7903 else
7904 {
7905 dev_urandom_state = OK;
7906 *x = buf.contents.number;
7907 }
7908 close(fd);
7909 }
7910 }
7911 if (dev_urandom_state != OK)
7912 // Reading /dev/urandom doesn't work, fall back to time().
7913#endif
7914 *x = vim_time();
7915}
7916
kylo252ae6f1d82022-02-16 19:24:07 +00007917#define ROTL(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007918#define SPLITMIX32(x, z) ( \
kylo252ae6f1d82022-02-16 19:24:07 +00007919 (z) = ((x) += 0x9e3779b9), \
7920 (z) = ((z) ^ ((z) >> 16)) * 0x85ebca6b, \
7921 (z) = ((z) ^ ((z) >> 13)) * 0xc2b2ae35, \
7922 (z) ^ ((z) >> 16) \
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007923 )
7924#define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \
kylo252ae6f1d82022-02-16 19:24:07 +00007925 result = ROTL((y) * 5, 7) * 9; \
7926 t = (y) << 9; \
7927 (z) ^= (x); \
7928 (w) ^= (y); \
7929 (y) ^= (z), (x) ^= (w); \
7930 (z) ^= t; \
7931 (w) = ROTL(w, 11);
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007932
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007933/*
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007934 * "rand()" function
7935 */
7936 static void
7937f_rand(typval_T *argvars, typval_T *rettv)
7938{
7939 list_T *l = NULL;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007940 static UINT32_T gx, gy, gz, gw;
7941 static int initialized = FALSE;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007942 listitem_T *lx, *ly, *lz, *lw;
Bram Moolenaar0fd797e2020-11-05 20:46:32 +01007943 UINT32_T x = 0, y, z, w, t, result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007944
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007945 if (in_vim9script() && check_for_opt_list_arg(argvars, 0) == FAIL)
7946 return;
7947
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007948 if (argvars[0].v_type == VAR_UNKNOWN)
7949 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007950 // When no argument is given use the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007951 if (initialized == FALSE)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007952 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007953 // Initialize the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007954 init_srand(&x);
7955
7956 gx = SPLITMIX32(x, z);
7957 gy = SPLITMIX32(x, z);
7958 gz = SPLITMIX32(x, z);
7959 gw = SPLITMIX32(x, z);
7960 initialized = TRUE;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007961 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007962
7963 SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007964 }
7965 else if (argvars[0].v_type == VAR_LIST)
7966 {
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007967 l = argvars[0].vval.v_list;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007968 if (l == NULL || list_len(l) != 4)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007969 goto theend;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007970
7971 lx = list_find(l, 0L);
7972 ly = list_find(l, 1L);
7973 lz = list_find(l, 2L);
7974 lw = list_find(l, 3L);
7975 if (lx->li_tv.v_type != VAR_NUMBER) goto theend;
7976 if (ly->li_tv.v_type != VAR_NUMBER) goto theend;
7977 if (lz->li_tv.v_type != VAR_NUMBER) goto theend;
7978 if (lw->li_tv.v_type != VAR_NUMBER) goto theend;
7979 x = (UINT32_T)lx->li_tv.vval.v_number;
7980 y = (UINT32_T)ly->li_tv.vval.v_number;
7981 z = (UINT32_T)lz->li_tv.vval.v_number;
7982 w = (UINT32_T)lw->li_tv.vval.v_number;
7983
7984 SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w);
7985
7986 lx->li_tv.vval.v_number = (varnumber_T)x;
7987 ly->li_tv.vval.v_number = (varnumber_T)y;
7988 lz->li_tv.vval.v_number = (varnumber_T)z;
7989 lw->li_tv.vval.v_number = (varnumber_T)w;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007990 }
7991 else
7992 goto theend;
7993
7994 rettv->v_type = VAR_NUMBER;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007995 rettv->vval.v_number = (varnumber_T)result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007996 return;
7997
7998theend:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00007999 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008000 rettv->v_type = VAR_NUMBER;
8001 rettv->vval.v_number = -1;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008002}
8003
8004/*
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008005 * "srand()" function
8006 */
8007 static void
8008f_srand(typval_T *argvars, typval_T *rettv)
8009{
8010 UINT32_T x = 0, z;
8011
8012 if (rettv_list_alloc(rettv) == FAIL)
8013 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008014
8015 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8016 return;
8017
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008018 if (argvars[0].v_type == VAR_UNKNOWN)
8019 {
8020 init_srand(&x);
8021 }
8022 else
8023 {
8024 int error = FALSE;
8025
8026 x = (UINT32_T)tv_get_number_chk(&argvars[0], &error);
8027 if (error)
8028 return;
8029 }
8030
8031 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8032 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8033 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8034 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8035}
8036
8037#undef ROTL
8038#undef SPLITMIX32
8039#undef SHUFFLE_XOSHIRO128STARSTAR
8040
8041/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008042 * "range()" function
8043 */
8044 static void
8045f_range(typval_T *argvars, typval_T *rettv)
8046{
8047 varnumber_T start;
8048 varnumber_T end;
8049 varnumber_T stride = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008050 int error = FALSE;
8051
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008052 if (in_vim9script()
8053 && (check_for_number_arg(argvars, 0) == FAIL
8054 || check_for_opt_number_arg(argvars, 1) == FAIL
8055 || (argvars[1].v_type != VAR_UNKNOWN
8056 && check_for_opt_number_arg(argvars, 2) == FAIL)))
8057 return;
8058
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008059 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008060 if (argvars[1].v_type == VAR_UNKNOWN)
8061 {
8062 end = start - 1;
8063 start = 0;
8064 }
8065 else
8066 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008067 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008068 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008069 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008070 }
8071
8072 if (error)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008073 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008074 if (stride == 0)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008075 emsg(_(e_stride_is_zero));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008076 else if (stride > 0 ? end + 1 < start : end - 1 > start)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008077 emsg(_(e_start_past_end));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008078 else if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008079 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008080 list_T *list = rettv->vval.v_list;
8081
8082 // Create a non-materialized list. This is much more efficient and
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008083 // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008084 // be called.
8085 list->lv_first = &range_list_item;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008086 list->lv_u.nonmat.lv_start = start;
8087 list->lv_u.nonmat.lv_end = end;
8088 list->lv_u.nonmat.lv_stride = stride;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008089 list->lv_len = (end - start) / stride + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008090 }
8091}
8092
8093/*
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008094 * Materialize "list".
8095 * Do not call directly, use CHECK_LIST_MATERIALIZE()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008096 */
8097 void
8098range_list_materialize(list_T *list)
8099{
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008100 varnumber_T start = list->lv_u.nonmat.lv_start;
8101 varnumber_T end = list->lv_u.nonmat.lv_end;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008102 int stride = list->lv_u.nonmat.lv_stride;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008103 varnumber_T i;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008104
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008105 list->lv_first = NULL;
8106 list->lv_u.mat.lv_last = NULL;
8107 list->lv_len = 0;
8108 list->lv_u.mat.lv_idx_item = NULL;
8109 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008110 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00008111 if (list_append_number(list, i) == FAIL)
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008112 break;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008113 if (list->lv_lock & VAR_ITEMS_LOCKED)
8114 list->lv_u.mat.lv_last->li_tv.v_lock = VAR_LOCKED;
8115 }
8116 list->lv_lock &= ~VAR_ITEMS_LOCKED;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008117}
8118
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008119/*
8120 * "getreginfo()" function
8121 */
8122 static void
8123f_getreginfo(typval_T *argvars, typval_T *rettv)
8124{
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008125 int regname;
8126 char_u buf[NUMBUFLEN + 2];
8127 long reglen = 0;
8128 dict_T *dict;
8129 list_T *list;
8130
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008131 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
8132 return;
8133
zeertzjqd3f00f52021-12-24 12:02:43 +00008134 regname = getreg_get_regname(argvars);
8135 if (regname == 0)
8136 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008137
zeertzjqd3f00f52021-12-24 12:02:43 +00008138 if (regname == '@')
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008139 regname = '"';
8140
8141 if (rettv_dict_alloc(rettv) == FAIL)
8142 return;
8143 dict = rettv->vval.v_dict;
8144
8145 list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
8146 if (list == NULL)
8147 return;
Bram Moolenaar91639192020-06-29 19:55:58 +02008148 (void)dict_add_list(dict, "regcontents", list);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008149
8150 buf[0] = NUL;
8151 buf[1] = NUL;
8152 switch (get_reg_type(regname, &reglen))
8153 {
8154 case MLINE: buf[0] = 'V'; break;
8155 case MCHAR: buf[0] = 'v'; break;
8156 case MBLOCK:
8157 vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
8158 reglen + 1);
8159 break;
8160 }
Bram Moolenaar91639192020-06-29 19:55:58 +02008161 (void)dict_add_string(dict, (char *)"regtype", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008162
8163 buf[0] = get_register_name(get_unname_register());
8164 buf[1] = NUL;
8165 if (regname == '"')
Bram Moolenaar91639192020-06-29 19:55:58 +02008166 (void)dict_add_string(dict, (char *)"points_to", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008167 else
8168 {
8169 dictitem_T *item = dictitem_alloc((char_u *)"isunnamed");
8170
8171 if (item != NULL)
8172 {
8173 item->di_tv.v_type = VAR_SPECIAL;
8174 item->di_tv.vval.v_number = regname == buf[0]
Bram Moolenaar418a29f2021-02-10 22:23:41 +01008175 ? VVAL_TRUE : VVAL_FALSE;
Bram Moolenaar91639192020-06-29 19:55:58 +02008176 (void)dict_add(dict, item);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008177 }
8178 }
8179}
8180
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02008181 static void
8182return_register(int regname, typval_T *rettv)
8183{
8184 char_u buf[2] = {0, 0};
8185
8186 buf[0] = (char_u)regname;
8187 rettv->v_type = VAR_STRING;
8188 rettv->vval.v_string = vim_strsave(buf);
8189}
8190
8191/*
8192 * "reg_executing()" function
8193 */
8194 static void
8195f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
8196{
8197 return_register(reg_executing, rettv);
8198}
8199
8200/*
8201 * "reg_recording()" function
8202 */
8203 static void
8204f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
8205{
8206 return_register(reg_recording, rettv);
8207}
8208
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01008209/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008210 * "rename({from}, {to})" function
8211 */
8212 static void
8213f_rename(typval_T *argvars, typval_T *rettv)
8214{
8215 char_u buf[NUMBUFLEN];
8216
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008217 rettv->vval.v_number = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008218 if (check_restricted() || check_secure())
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008219 return;
8220
8221 if (in_vim9script()
8222 && (check_for_string_arg(argvars, 0) == FAIL
8223 || check_for_string_arg(argvars, 1) == FAIL))
8224 return;
8225
8226 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008227 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008228}
8229
8230/*
8231 * "repeat()" function
8232 */
8233 static void
8234f_repeat(typval_T *argvars, typval_T *rettv)
8235{
8236 char_u *p;
8237 int n;
8238 int slen;
8239 int len;
8240 char_u *r;
8241 int i;
8242
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008243 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008244 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
8245 || check_for_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008246 return;
8247
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008248 n = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008249 if (argvars[0].v_type == VAR_LIST)
8250 {
8251 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
8252 while (n-- > 0)
8253 if (list_extend(rettv->vval.v_list,
8254 argvars[0].vval.v_list, NULL) == FAIL)
8255 break;
8256 }
8257 else
8258 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008259 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008260 rettv->v_type = VAR_STRING;
8261 rettv->vval.v_string = NULL;
8262
8263 slen = (int)STRLEN(p);
8264 len = slen * n;
8265 if (len <= 0)
8266 return;
8267
8268 r = alloc(len + 1);
8269 if (r != NULL)
8270 {
8271 for (i = 0; i < n; i++)
8272 mch_memmove(r + i * slen, p, (size_t)slen);
8273 r[len] = NUL;
8274 }
8275
8276 rettv->vval.v_string = r;
8277 }
8278}
8279
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008280#define SP_NOMOVE 0x01 // don't move cursor
8281#define SP_REPEAT 0x02 // repeat to find outer pair
8282#define SP_RETCOUNT 0x04 // return matchcount
8283#define SP_SETPCMARK 0x08 // set previous context mark
8284#define SP_START 0x10 // accept match at start position
8285#define SP_SUBPAT 0x20 // return nr of matching sub-pattern
8286#define SP_END 0x40 // leave cursor at end of match
8287#define SP_COLUMN 0x80 // start at cursor column
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008288
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008289/*
8290 * Get flags for a search function.
8291 * Possibly sets "p_ws".
8292 * Returns BACKWARD, FORWARD or zero (for an error).
8293 */
8294 static int
8295get_search_arg(typval_T *varp, int *flagsp)
8296{
8297 int dir = FORWARD;
8298 char_u *flags;
8299 char_u nbuf[NUMBUFLEN];
8300 int mask;
8301
8302 if (varp->v_type != VAR_UNKNOWN)
8303 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008304 flags = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008305 if (flags == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008306 return 0; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008307 while (*flags != NUL)
8308 {
8309 switch (*flags)
8310 {
8311 case 'b': dir = BACKWARD; break;
8312 case 'w': p_ws = TRUE; break;
8313 case 'W': p_ws = FALSE; break;
8314 default: mask = 0;
8315 if (flagsp != NULL)
8316 switch (*flags)
8317 {
8318 case 'c': mask = SP_START; break;
8319 case 'e': mask = SP_END; break;
8320 case 'm': mask = SP_RETCOUNT; break;
8321 case 'n': mask = SP_NOMOVE; break;
8322 case 'p': mask = SP_SUBPAT; break;
8323 case 'r': mask = SP_REPEAT; break;
8324 case 's': mask = SP_SETPCMARK; break;
8325 case 'z': mask = SP_COLUMN; break;
8326 }
8327 if (mask == 0)
8328 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008329 semsg(_(e_invalid_argument_str), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008330 dir = 0;
8331 }
8332 else
8333 *flagsp |= mask;
8334 }
8335 if (dir == 0)
8336 break;
8337 ++flags;
8338 }
8339 }
8340 return dir;
8341}
8342
8343/*
8344 * Shared by search() and searchpos() functions.
8345 */
8346 static int
8347search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
8348{
8349 int flags;
8350 char_u *pat;
8351 pos_T pos;
8352 pos_T save_cursor;
8353 int save_p_ws = p_ws;
8354 int dir;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008355 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008356 long lnum_stop = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008357#ifdef FEAT_RELTIME
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008358 proftime_T tm;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008359 long time_limit = 0;
8360#endif
8361 int options = SEARCH_KEEP;
8362 int subpatnum;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008363 searchit_arg_T sia;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008364 int use_skip = FALSE;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008365 pos_T firstpos;
8366
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008367 if (in_vim9script()
8368 && (check_for_string_arg(argvars, 0) == FAIL
8369 || check_for_opt_string_arg(argvars, 1) == FAIL
8370 || (argvars[1].v_type != VAR_UNKNOWN
8371 && (check_for_opt_number_arg(argvars, 2) == FAIL
8372 || (argvars[2].v_type != VAR_UNKNOWN
8373 && check_for_opt_number_arg(argvars, 3) == FAIL)))))
8374 goto theend;
8375
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008376 pat = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008377 dir = get_search_arg(&argvars[1], flagsp); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008378 if (dir == 0)
8379 goto theend;
8380 flags = *flagsp;
8381 if (flags & SP_START)
8382 options |= SEARCH_START;
8383 if (flags & SP_END)
8384 options |= SEARCH_END;
8385 if (flags & SP_COLUMN)
8386 options |= SEARCH_COL;
8387
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008388 // Optional arguments: line number to stop searching, timeout and skip.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008389 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
8390 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008391 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008392 if (lnum_stop < 0)
8393 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008394 if (argvars[3].v_type != VAR_UNKNOWN)
8395 {
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008396#ifdef FEAT_RELTIME
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008397 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008398 if (time_limit < 0)
8399 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008400#endif
Bram Moolenaara9c01042020-06-07 14:50:50 +02008401 use_skip = eval_expr_valid_arg(&argvars[4]);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008402 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008403 }
8404
8405#ifdef FEAT_RELTIME
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008406 // Set the time limit, if there is one.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008407 profile_setlimit(time_limit, &tm);
8408#endif
8409
8410 /*
8411 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
8412 * Check to make sure only those flags are set.
8413 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
8414 * flags cannot be set. Check for that condition also.
8415 */
8416 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
8417 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
8418 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008419 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008420 goto theend;
8421 }
8422
8423 pos = save_cursor = curwin->w_cursor;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008424 CLEAR_FIELD(firstpos);
Bram Moolenaara80faa82020-04-12 19:37:17 +02008425 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008426 sia.sa_stop_lnum = (linenr_T)lnum_stop;
8427#ifdef FEAT_RELTIME
8428 sia.sa_tm = &tm;
8429#endif
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008430
8431 // Repeat until {skip} returns FALSE.
8432 for (;;)
8433 {
8434 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008435 options, RE_SEARCH, &sia);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008436 // finding the first match again means there is no match where {skip}
8437 // evaluates to zero.
8438 if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))
8439 subpatnum = FAIL;
8440
Bram Moolenaara9c01042020-06-07 14:50:50 +02008441 if (subpatnum == FAIL || !use_skip)
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008442 // didn't find it or no skip argument
8443 break;
8444 firstpos = pos;
8445
Bram Moolenaara9c01042020-06-07 14:50:50 +02008446 // If the skip expression matches, ignore this match.
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008447 {
8448 int do_skip;
8449 int err;
8450 pos_T save_pos = curwin->w_cursor;
8451
8452 curwin->w_cursor = pos;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008453 err = FALSE;
8454 do_skip = eval_expr_to_bool(&argvars[4], &err);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008455 curwin->w_cursor = save_pos;
8456 if (err)
8457 {
8458 // Evaluating {skip} caused an error, break here.
8459 subpatnum = FAIL;
8460 break;
8461 }
8462 if (!do_skip)
8463 break;
8464 }
8465 }
8466
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008467 if (subpatnum != FAIL)
8468 {
8469 if (flags & SP_SUBPAT)
8470 retval = subpatnum;
8471 else
8472 retval = pos.lnum;
8473 if (flags & SP_SETPCMARK)
8474 setpcmark();
8475 curwin->w_cursor = pos;
8476 if (match_pos != NULL)
8477 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008478 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008479 match_pos->lnum = pos.lnum;
8480 match_pos->col = pos.col + 1;
8481 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008482 // "/$" will put the cursor after the end of the line, may need to
8483 // correct that here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008484 check_cursor();
8485 }
8486
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008487 // If 'n' flag is used: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008488 if (flags & SP_NOMOVE)
8489 curwin->w_cursor = save_cursor;
8490 else
8491 curwin->w_set_curswant = TRUE;
8492theend:
8493 p_ws = save_p_ws;
8494
8495 return retval;
8496}
8497
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008498#ifdef FEAT_RUBY
8499/*
8500 * "rubyeval()" function
8501 */
8502 static void
8503f_rubyeval(typval_T *argvars, typval_T *rettv)
8504{
8505 char_u *str;
8506 char_u buf[NUMBUFLEN];
8507
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008508 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8509 return;
8510
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008511 str = tv_get_string_buf(&argvars[0], buf);
8512 do_rubyeval(str, rettv);
8513}
8514#endif
8515
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008516/*
8517 * "screenattr()" function
8518 */
8519 static void
8520f_screenattr(typval_T *argvars, typval_T *rettv)
8521{
8522 int row;
8523 int col;
8524 int c;
8525
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008526 if (in_vim9script()
8527 && (check_for_number_arg(argvars, 0) == FAIL
8528 || check_for_number_arg(argvars, 1) == FAIL))
8529 return;
8530
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008531 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8532 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008533 if (row < 0 || row >= screen_Rows
8534 || col < 0 || col >= screen_Columns)
8535 c = -1;
8536 else
8537 c = ScreenAttrs[LineOffset[row] + col];
8538 rettv->vval.v_number = c;
8539}
8540
8541/*
8542 * "screenchar()" function
8543 */
8544 static void
8545f_screenchar(typval_T *argvars, typval_T *rettv)
8546{
8547 int row;
8548 int col;
8549 int off;
8550 int c;
8551
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008552 if (in_vim9script()
8553 && (check_for_number_arg(argvars, 0) == FAIL
8554 || check_for_number_arg(argvars, 1) == FAIL))
8555 return;
8556
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008557 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8558 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008559 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008560 c = -1;
8561 else
8562 {
8563 off = LineOffset[row] + col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008564 if (enc_utf8 && ScreenLinesUC[off] != 0)
8565 c = ScreenLinesUC[off];
8566 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008567 c = ScreenLines[off];
8568 }
8569 rettv->vval.v_number = c;
8570}
8571
8572/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008573 * "screenchars()" function
8574 */
8575 static void
8576f_screenchars(typval_T *argvars, typval_T *rettv)
8577{
8578 int row;
8579 int col;
8580 int off;
8581 int c;
8582 int i;
8583
8584 if (rettv_list_alloc(rettv) == FAIL)
8585 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008586
8587 if (in_vim9script()
8588 && (check_for_number_arg(argvars, 0) == FAIL
8589 || check_for_number_arg(argvars, 1) == FAIL))
8590 return;
8591
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008592 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8593 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8594 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8595 return;
8596
8597 off = LineOffset[row] + col;
8598 if (enc_utf8 && ScreenLinesUC[off] != 0)
8599 c = ScreenLinesUC[off];
8600 else
8601 c = ScreenLines[off];
8602 list_append_number(rettv->vval.v_list, (varnumber_T)c);
8603
8604 if (enc_utf8)
8605
8606 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8607 list_append_number(rettv->vval.v_list,
8608 (varnumber_T)ScreenLinesC[i][off]);
8609}
8610
8611/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008612 * "screencol()" function
8613 *
8614 * First column is 1 to be consistent with virtcol().
8615 */
8616 static void
8617f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
8618{
8619 rettv->vval.v_number = screen_screencol() + 1;
8620}
8621
8622/*
8623 * "screenrow()" function
8624 */
8625 static void
8626f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
8627{
8628 rettv->vval.v_number = screen_screenrow() + 1;
8629}
8630
8631/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008632 * "screenstring()" function
8633 */
8634 static void
8635f_screenstring(typval_T *argvars, typval_T *rettv)
8636{
8637 int row;
8638 int col;
8639 int off;
8640 int c;
8641 int i;
8642 char_u buf[MB_MAXBYTES + 1];
8643 int buflen = 0;
8644
8645 rettv->vval.v_string = NULL;
8646 rettv->v_type = VAR_STRING;
8647
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008648 if (in_vim9script()
8649 && (check_for_number_arg(argvars, 0) == FAIL
8650 || check_for_number_arg(argvars, 1) == FAIL))
8651 return;
8652
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008653 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8654 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8655 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8656 return;
8657
8658 off = LineOffset[row] + col;
8659 if (enc_utf8 && ScreenLinesUC[off] != 0)
8660 c = ScreenLinesUC[off];
8661 else
8662 c = ScreenLines[off];
8663 buflen += mb_char2bytes(c, buf);
8664
Bram Moolenaarf1387282021-03-22 17:11:15 +01008665 if (enc_utf8 && ScreenLinesUC[off] != 0)
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008666 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8667 buflen += mb_char2bytes(ScreenLinesC[i][off], buf + buflen);
8668
8669 buf[buflen] = NUL;
8670 rettv->vval.v_string = vim_strsave(buf);
8671}
8672
8673/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008674 * "search()" function
8675 */
8676 static void
8677f_search(typval_T *argvars, typval_T *rettv)
8678{
8679 int flags = 0;
8680
8681 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
8682}
8683
8684/*
8685 * "searchdecl()" function
8686 */
8687 static void
8688f_searchdecl(typval_T *argvars, typval_T *rettv)
8689{
Bram Moolenaar30788d32020-09-05 21:35:16 +02008690 int locally = TRUE;
8691 int thisblock = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008692 int error = FALSE;
8693 char_u *name;
8694
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008695 rettv->vval.v_number = 1; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008696
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02008697 if (in_vim9script()
8698 && (check_for_string_arg(argvars, 0) == FAIL
8699 || check_for_opt_bool_arg(argvars, 1) == FAIL
8700 || (argvars[1].v_type != VAR_UNKNOWN
8701 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
8702 return;
8703
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008704 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008705 if (argvars[1].v_type != VAR_UNKNOWN)
8706 {
Bram Moolenaar30788d32020-09-05 21:35:16 +02008707 locally = !(int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008708 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar30788d32020-09-05 21:35:16 +02008709 thisblock = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008710 }
8711 if (!error && name != NULL)
8712 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
8713 locally, thisblock, SEARCH_KEEP) == FAIL;
8714}
8715
8716/*
8717 * Used by searchpair() and searchpairpos()
8718 */
8719 static int
8720searchpair_cmn(typval_T *argvars, pos_T *match_pos)
8721{
8722 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +01008723 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008724 int save_p_ws = p_ws;
8725 int dir;
8726 int flags = 0;
8727 char_u nbuf1[NUMBUFLEN];
8728 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008729 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008730 long lnum_stop = 0;
8731 long time_limit = 0;
8732
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02008733 if (in_vim9script()
8734 && (check_for_string_arg(argvars, 0) == FAIL
8735 || check_for_string_arg(argvars, 1) == FAIL
8736 || check_for_string_arg(argvars, 2) == FAIL
8737 || check_for_opt_string_arg(argvars, 3) == FAIL
8738 || (argvars[3].v_type != VAR_UNKNOWN
8739 && argvars[4].v_type != VAR_UNKNOWN
8740 && (check_for_opt_number_arg(argvars, 5) == FAIL
8741 || (argvars[5].v_type != VAR_UNKNOWN
8742 && check_for_opt_number_arg(argvars, 6) == FAIL)))))
8743 goto theend;
8744
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008745 // Get the three pattern arguments: start, middle, end. Will result in an
8746 // error if not a valid argument.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008747 spat = tv_get_string_chk(&argvars[0]);
8748 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
8749 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008750 if (spat == NULL || mpat == NULL || epat == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008751 goto theend; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008752
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008753 // Handle the optional fourth argument: flags
8754 dir = get_search_arg(&argvars[3], &flags); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008755 if (dir == 0)
8756 goto theend;
8757
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008758 // Don't accept SP_END or SP_SUBPAT.
8759 // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008760 if ((flags & (SP_END | SP_SUBPAT)) != 0
8761 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
8762 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008763 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008764 goto theend;
8765 }
8766
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008767 // Using 'r' implies 'W', otherwise it doesn't work.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008768 if (flags & SP_REPEAT)
8769 p_ws = FALSE;
8770
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008771 // Optional fifth argument: skip expression
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008772 if (argvars[3].v_type == VAR_UNKNOWN
8773 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +01008774 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008775 else
8776 {
Bram Moolenaara9c01042020-06-07 14:50:50 +02008777 // Type is checked later.
Bram Moolenaar48570482017-10-30 21:48:41 +01008778 skip = &argvars[4];
Bram Moolenaara9c01042020-06-07 14:50:50 +02008779
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008780 if (argvars[5].v_type != VAR_UNKNOWN)
8781 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008782 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008783 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008784 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008785 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008786 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008787 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008788#ifdef FEAT_RELTIME
8789 if (argvars[6].v_type != VAR_UNKNOWN)
8790 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008791 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008792 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008793 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008794 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008795 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008796 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008797 }
8798#endif
8799 }
8800 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008801
8802 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
8803 match_pos, lnum_stop, time_limit);
8804
8805theend:
8806 p_ws = save_p_ws;
8807
8808 return retval;
8809}
8810
8811/*
8812 * "searchpair()" function
8813 */
8814 static void
8815f_searchpair(typval_T *argvars, typval_T *rettv)
8816{
8817 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
8818}
8819
8820/*
8821 * "searchpairpos()" function
8822 */
8823 static void
8824f_searchpairpos(typval_T *argvars, typval_T *rettv)
8825{
8826 pos_T match_pos;
8827 int lnum = 0;
8828 int col = 0;
8829
8830 if (rettv_list_alloc(rettv) == FAIL)
8831 return;
8832
8833 if (searchpair_cmn(argvars, &match_pos) > 0)
8834 {
8835 lnum = match_pos.lnum;
8836 col = match_pos.col;
8837 }
8838
8839 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
8840 list_append_number(rettv->vval.v_list, (varnumber_T)col);
8841}
8842
8843/*
8844 * Search for a start/middle/end thing.
8845 * Used by searchpair(), see its documentation for the details.
8846 * Returns 0 or -1 for no match,
8847 */
8848 long
8849do_searchpair(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008850 char_u *spat, // start pattern
8851 char_u *mpat, // middle pattern
8852 char_u *epat, // end pattern
8853 int dir, // BACKWARD or FORWARD
8854 typval_T *skip, // skip expression
8855 int flags, // SP_SETPCMARK and other SP_ values
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008856 pos_T *match_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008857 linenr_T lnum_stop, // stop at this line if not zero
8858 long time_limit UNUSED) // stop after this many msec
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008859{
8860 char_u *save_cpo;
8861 char_u *pat, *pat2 = NULL, *pat3 = NULL;
8862 long retval = 0;
8863 pos_T pos;
8864 pos_T firstpos;
8865 pos_T foundpos;
8866 pos_T save_cursor;
8867 pos_T save_pos;
8868 int n;
8869 int r;
8870 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +01008871 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008872 int err;
8873 int options = SEARCH_KEEP;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008874#ifdef FEAT_RELTIME
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008875 proftime_T tm;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008876#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008877
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008878 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008879 save_cpo = p_cpo;
8880 p_cpo = empty_option;
8881
8882#ifdef FEAT_RELTIME
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008883 // Set the time limit, if there is one.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008884 profile_setlimit(time_limit, &tm);
8885#endif
8886
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008887 // Make two search patterns: start/end (pat2, for in nested pairs) and
8888 // start/middle/end (pat3, for the top pair).
Bram Moolenaar964b3742019-05-24 18:54:09 +02008889 pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17);
8890 pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008891 if (pat2 == NULL || pat3 == NULL)
8892 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +01008893 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008894 if (*mpat == NUL)
8895 STRCPY(pat3, pat2);
8896 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +01008897 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008898 spat, epat, mpat);
8899 if (flags & SP_START)
8900 options |= SEARCH_START;
8901
Bram Moolenaar48570482017-10-30 21:48:41 +01008902 if (skip != NULL)
Bram Moolenaara9c01042020-06-07 14:50:50 +02008903 use_skip = eval_expr_valid_arg(skip);
Bram Moolenaar48570482017-10-30 21:48:41 +01008904
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008905 save_cursor = curwin->w_cursor;
8906 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01008907 CLEAR_POS(&firstpos);
8908 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008909 pat = pat3;
8910 for (;;)
8911 {
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008912 searchit_arg_T sia;
8913
Bram Moolenaara80faa82020-04-12 19:37:17 +02008914 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008915 sia.sa_stop_lnum = lnum_stop;
8916#ifdef FEAT_RELTIME
8917 sia.sa_tm = &tm;
8918#endif
Bram Moolenaar5d24a222018-12-23 19:10:09 +01008919 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008920 options, RE_SEARCH, &sia);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01008921 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008922 // didn't find it or found the first match again: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008923 break;
8924
8925 if (firstpos.lnum == 0)
8926 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01008927 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008928 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008929 // Found the same position again. Can happen with a pattern that
8930 // has "\zs" at the end and searching backwards. Advance one
8931 // character and try again.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008932 if (dir == BACKWARD)
8933 decl(&pos);
8934 else
8935 incl(&pos);
8936 }
8937 foundpos = pos;
8938
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008939 // clear the start flag to avoid getting stuck here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008940 options &= ~SEARCH_START;
8941
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008942 // If the skip pattern matches, ignore this match.
Bram Moolenaar48570482017-10-30 21:48:41 +01008943 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008944 {
8945 save_pos = curwin->w_cursor;
8946 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +01008947 err = FALSE;
8948 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008949 curwin->w_cursor = save_pos;
8950 if (err)
8951 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008952 // Evaluating {skip} caused an error, break here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008953 curwin->w_cursor = save_cursor;
8954 retval = -1;
8955 break;
8956 }
8957 if (r)
8958 continue;
8959 }
8960
8961 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
8962 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008963 // Found end when searching backwards or start when searching
8964 // forward: nested pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008965 ++nest;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008966 pat = pat2; // nested, don't search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008967 }
8968 else
8969 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008970 // Found end when searching forward or start when searching
8971 // backward: end of (nested) pair; or found middle in outer pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008972 if (--nest == 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008973 pat = pat3; // outer level, search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008974 }
8975
8976 if (nest == 0)
8977 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008978 // Found the match: return matchcount or line number.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008979 if (flags & SP_RETCOUNT)
8980 ++retval;
8981 else
8982 retval = pos.lnum;
8983 if (flags & SP_SETPCMARK)
8984 setpcmark();
8985 curwin->w_cursor = pos;
8986 if (!(flags & SP_REPEAT))
8987 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008988 nest = 1; // search for next unmatched
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008989 }
8990 }
8991
8992 if (match_pos != NULL)
8993 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008994 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008995 match_pos->lnum = curwin->w_cursor.lnum;
8996 match_pos->col = curwin->w_cursor.col + 1;
8997 }
8998
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008999 // If 'n' flag is used or search failed: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009000 if ((flags & SP_NOMOVE) || retval == 0)
9001 curwin->w_cursor = save_cursor;
9002
9003theend:
9004 vim_free(pat2);
9005 vim_free(pat3);
9006 if (p_cpo == empty_option)
9007 p_cpo = save_cpo;
9008 else
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009009 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009010 // Darn, evaluating the {skip} expression changed the value.
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009011 // If it's still empty it was changed and restored, need to restore in
9012 // the complicated way.
9013 if (*p_cpo == NUL)
9014 set_option_value((char_u *)"cpo", 0L, save_cpo, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009015 free_string_option(save_cpo);
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009016 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009017
9018 return retval;
9019}
9020
9021/*
9022 * "searchpos()" function
9023 */
9024 static void
9025f_searchpos(typval_T *argvars, typval_T *rettv)
9026{
9027 pos_T match_pos;
9028 int lnum = 0;
9029 int col = 0;
9030 int n;
9031 int flags = 0;
9032
9033 if (rettv_list_alloc(rettv) == FAIL)
9034 return;
9035
9036 n = search_cmn(argvars, &match_pos, &flags);
9037 if (n > 0)
9038 {
9039 lnum = match_pos.lnum;
9040 col = match_pos.col;
9041 }
9042
9043 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
9044 list_append_number(rettv->vval.v_list, (varnumber_T)col);
9045 if (flags & SP_SUBPAT)
9046 list_append_number(rettv->vval.v_list, (varnumber_T)n);
9047}
9048
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009049/*
9050 * Set the cursor or mark position.
Christian Brabandt98703d72021-06-24 19:55:27 +02009051 * If 'charpos' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009052 * Otherwise use the column number as a byte offset.
9053 */
9054 static void
9055set_position(typval_T *argvars, typval_T *rettv, int charpos)
9056{
9057 pos_T pos;
9058 int fnum;
9059 char_u *name;
9060 colnr_T curswant = -1;
9061
9062 rettv->vval.v_number = -1;
9063
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009064 if (in_vim9script()
9065 && (check_for_string_arg(argvars, 0) == FAIL
9066 || check_for_list_arg(argvars, 1) == FAIL))
9067 return;
9068
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009069 name = tv_get_string_chk(argvars);
9070 if (name != NULL)
9071 {
9072 if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) == OK)
9073 {
9074 if (pos.col != MAXCOL && --pos.col < 0)
9075 pos.col = 0;
9076 if ((name[0] == '.' && name[1] == NUL))
9077 {
9078 // set cursor; "fnum" is ignored
9079 curwin->w_cursor = pos;
9080 if (curswant >= 0)
9081 {
9082 curwin->w_curswant = curswant - 1;
9083 curwin->w_set_curswant = FALSE;
9084 }
9085 check_cursor();
9086 rettv->vval.v_number = 0;
9087 }
9088 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
9089 {
9090 // set mark
9091 if (setmark_pos(name[1], &pos, fnum) == OK)
9092 rettv->vval.v_number = 0;
9093 }
9094 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009095 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009096 }
9097 }
9098}
9099/*
9100 * "setcharpos()" function
9101 */
9102 static void
9103f_setcharpos(typval_T *argvars, typval_T *rettv)
9104{
9105 set_position(argvars, rettv, TRUE);
9106}
9107
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009108 static void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009109f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
9110{
9111 dict_T *d;
9112 dictitem_T *di;
9113 char_u *csearch;
9114
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009115 if (in_vim9script() && check_for_dict_arg(argvars, 0) == FAIL)
9116 return;
9117
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009118 if (argvars[0].v_type != VAR_DICT)
9119 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009120 emsg(_(e_dictionary_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009121 return;
9122 }
9123
9124 if ((d = argvars[0].vval.v_dict) != NULL)
9125 {
Bram Moolenaar8f667172018-12-14 15:38:31 +01009126 csearch = dict_get_string(d, (char_u *)"char", FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009127 if (csearch != NULL)
9128 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009129 if (enc_utf8)
9130 {
9131 int pcc[MAX_MCO];
9132 int c = utfc_ptr2char(csearch, pcc);
9133
9134 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
9135 }
9136 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009137 set_last_csearch(PTR2CHAR(csearch),
Bram Moolenaar1614a142019-10-06 22:00:13 +02009138 csearch, mb_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009139 }
9140
9141 di = dict_find(d, (char_u *)"forward", -1);
9142 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009143 set_csearch_direction((int)tv_get_number(&di->di_tv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009144 ? FORWARD : BACKWARD);
9145
9146 di = dict_find(d, (char_u *)"until", -1);
9147 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009148 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009149 }
9150}
9151
9152/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009153 * "setcursorcharpos" function
9154 */
9155 static void
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01009156f_setcursorcharpos(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009157{
9158 set_cursorpos(argvars, rettv, TRUE);
9159}
9160
9161/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009162 * "setenv()" function
9163 */
9164 static void
9165f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
9166{
9167 char_u namebuf[NUMBUFLEN];
9168 char_u valbuf[NUMBUFLEN];
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009169 char_u *name;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009170
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009171 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9172 return;
9173
9174 name = tv_get_string_buf(&argvars[0], namebuf);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009175 if (argvars[1].v_type == VAR_SPECIAL
9176 && argvars[1].vval.v_number == VVAL_NULL)
9177 vim_unsetenv(name);
9178 else
9179 vim_setenv(name, tv_get_string_buf(&argvars[1], valbuf));
9180}
9181
9182/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009183 * "setfperm({fname}, {mode})" function
9184 */
9185 static void
9186f_setfperm(typval_T *argvars, typval_T *rettv)
9187{
9188 char_u *fname;
9189 char_u modebuf[NUMBUFLEN];
9190 char_u *mode_str;
9191 int i;
9192 int mask;
9193 int mode = 0;
9194
9195 rettv->vval.v_number = 0;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009196
9197 if (in_vim9script()
9198 && (check_for_string_arg(argvars, 0) == FAIL
9199 || check_for_string_arg(argvars, 1) == FAIL))
9200 return;
9201
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009202 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009203 if (fname == NULL)
9204 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009205 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009206 if (mode_str == NULL)
9207 return;
9208 if (STRLEN(mode_str) != 9)
9209 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009210 semsg(_(e_invalid_argument_str), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009211 return;
9212 }
9213
9214 mask = 1;
9215 for (i = 8; i >= 0; --i)
9216 {
9217 if (mode_str[i] != '-')
9218 mode |= mask;
9219 mask = mask << 1;
9220 }
9221 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
9222}
9223
9224/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009225 * "setpos()" function
9226 */
9227 static void
9228f_setpos(typval_T *argvars, typval_T *rettv)
9229{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009230 set_position(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009231}
9232
9233/*
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009234 * Translate a register type string to the yank type and block length
9235 */
9236 static int
9237get_yank_type(char_u **pp, char_u *yank_type, long *block_len)
9238{
9239 char_u *stropt = *pp;
9240 switch (*stropt)
9241 {
9242 case 'v': case 'c': // character-wise selection
9243 *yank_type = MCHAR;
9244 break;
9245 case 'V': case 'l': // line-wise selection
9246 *yank_type = MLINE;
9247 break;
9248 case 'b': case Ctrl_V: // block-wise selection
9249 *yank_type = MBLOCK;
9250 if (VIM_ISDIGIT(stropt[1]))
9251 {
9252 ++stropt;
9253 *block_len = getdigits(&stropt) - 1;
9254 --stropt;
9255 }
9256 break;
9257 default:
9258 return FAIL;
9259 }
9260 *pp = stropt;
9261 return OK;
9262}
9263
9264/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009265 * "setreg()" function
9266 */
9267 static void
9268f_setreg(typval_T *argvars, typval_T *rettv)
9269{
9270 int regname;
9271 char_u *strregname;
9272 char_u *stropt;
9273 char_u *strval;
9274 int append;
9275 char_u yank_type;
9276 long block_len;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009277 typval_T *regcontents;
9278 int pointreg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009279
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009280 if (in_vim9script()
9281 && (check_for_string_arg(argvars, 0) == FAIL
9282 || check_for_opt_string_arg(argvars, 2) == FAIL))
9283 return;
9284
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009285 pointreg = 0;
9286 regcontents = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009287 block_len = -1;
9288 yank_type = MAUTO;
9289 append = FALSE;
9290
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009291 strregname = tv_get_string_chk(argvars);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009292 rettv->vval.v_number = 1; // FAIL is default
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009293
9294 if (strregname == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009295 return; // type error; errmsg already given
Bram Moolenaar418a29f2021-02-10 22:23:41 +01009296 if (in_vim9script() && STRLEN(strregname) > 1)
9297 {
9298 semsg(_(e_register_name_must_be_one_char_str), strregname);
9299 return;
9300 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009301 regname = *strregname;
9302 if (regname == 0 || regname == '@')
9303 regname = '"';
9304
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009305 if (argvars[1].v_type == VAR_DICT)
9306 {
9307 dict_T *d = argvars[1].vval.v_dict;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009308 dictitem_T *di;
9309
9310 if (d == NULL || d->dv_hashtab.ht_used == 0)
9311 {
9312 // Empty dict, clear the register (like setreg(0, []))
9313 char_u *lstval[2] = {NULL, NULL};
9314 write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1);
9315 return;
9316 }
9317
9318 di = dict_find(d, (char_u *)"regcontents", -1);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009319 if (di != NULL)
9320 regcontents = &di->di_tv;
9321
9322 stropt = dict_get_string(d, (char_u *)"regtype", FALSE);
9323 if (stropt != NULL)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009324 {
9325 int ret = get_yank_type(&stropt, &yank_type, &block_len);
9326
9327 if (ret == FAIL || *++stropt != NUL)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009328 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009329 semsg(_(e_invalid_value_for_argument_str), "value");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009330 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009331 }
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009332 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009333
9334 if (regname == '"')
9335 {
9336 stropt = dict_get_string(d, (char_u *)"points_to", FALSE);
9337 if (stropt != NULL)
9338 {
9339 pointreg = *stropt;
9340 regname = pointreg;
9341 }
9342 }
Bram Moolenaar6a950582020-08-28 16:39:33 +02009343 else if (dict_get_bool(d, (char_u *)"isunnamed", -1) > 0)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009344 pointreg = regname;
9345 }
9346 else
9347 regcontents = &argvars[1];
9348
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009349 if (argvars[2].v_type != VAR_UNKNOWN)
9350 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009351 if (yank_type != MAUTO)
9352 {
Bram Moolenaare1242042021-12-16 20:56:57 +00009353 semsg(_(e_too_many_arguments_for_function_str), "setreg");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009354 return;
9355 }
9356
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009357 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009358 if (stropt == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009359 return; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009360 for (; *stropt != NUL; ++stropt)
9361 switch (*stropt)
9362 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009363 case 'a': case 'A': // append
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009364 append = TRUE;
9365 break;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009366 default:
9367 get_yank_type(&stropt, &yank_type, &block_len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009368 }
9369 }
9370
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009371 if (regcontents && regcontents->v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009372 {
9373 char_u **lstval;
9374 char_u **allocval;
9375 char_u buf[NUMBUFLEN];
9376 char_u **curval;
9377 char_u **curallocval;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009378 list_T *ll = regcontents->vval.v_list;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009379 listitem_T *li;
9380 int len;
9381
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009382 // If the list is NULL handle like an empty list.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009383 len = ll == NULL ? 0 : ll->lv_len;
9384
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009385 // First half: use for pointers to result lines; second half: use for
9386 // pointers to allocated copies.
Bram Moolenaarc799fe22019-05-28 23:08:19 +02009387 lstval = ALLOC_MULT(char_u *, (len + 1) * 2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009388 if (lstval == NULL)
9389 return;
9390 curval = lstval;
9391 allocval = lstval + len + 2;
9392 curallocval = allocval;
9393
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009394 if (ll != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009395 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009396 CHECK_LIST_MATERIALIZE(ll);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02009397 FOR_ALL_LIST_ITEMS(ll, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009398 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009399 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009400 if (strval == NULL)
9401 goto free_lstval;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009402 if (strval == buf)
9403 {
9404 // Need to make a copy, next tv_get_string_buf_chk() will
9405 // overwrite the string.
9406 strval = vim_strsave(buf);
9407 if (strval == NULL)
9408 goto free_lstval;
9409 *curallocval++ = strval;
9410 }
9411 *curval++ = strval;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009412 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009413 }
9414 *curval++ = NULL;
9415
9416 write_reg_contents_lst(regname, lstval, -1,
9417 append, yank_type, block_len);
9418free_lstval:
9419 while (curallocval > allocval)
9420 vim_free(*--curallocval);
9421 vim_free(lstval);
9422 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009423 else if (regcontents)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009424 {
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009425 strval = tv_get_string_chk(regcontents);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009426 if (strval == NULL)
9427 return;
9428 write_reg_contents_ex(regname, strval, -1,
9429 append, yank_type, block_len);
9430 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009431 if (pointreg != 0)
9432 get_yank_register(pointreg, TRUE);
9433
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009434 rettv->vval.v_number = 0;
9435}
9436
9437/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009438 * "settagstack()" function
9439 */
9440 static void
9441f_settagstack(typval_T *argvars, typval_T *rettv)
9442{
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009443 win_T *wp;
9444 dict_T *d;
9445 int action = 'r';
9446
9447 rettv->vval.v_number = -1;
9448
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009449 if (in_vim9script()
9450 && (check_for_number_arg(argvars, 0) == FAIL
9451 || check_for_dict_arg(argvars, 1) == FAIL
9452 || check_for_opt_string_arg(argvars, 2) == FAIL))
9453 return;
9454
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009455 // first argument: window number or id
9456 wp = find_win_by_nr_or_id(&argvars[0]);
9457 if (wp == NULL)
9458 return;
9459
9460 // second argument: dict with items to set in the tag stack
9461 if (argvars[1].v_type != VAR_DICT)
9462 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009463 emsg(_(e_dictionary_required));
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009464 return;
9465 }
9466 d = argvars[1].vval.v_dict;
9467 if (d == NULL)
9468 return;
9469
9470 // third argument: action - 'a' for append and 'r' for replace.
9471 // default is to replace the stack.
9472 if (argvars[2].v_type == VAR_UNKNOWN)
9473 action = 'r';
9474 else if (argvars[2].v_type == VAR_STRING)
9475 {
9476 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009477 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009478 if (actstr == NULL)
9479 return;
Bram Moolenaar271fa082020-01-02 14:02:16 +01009480 if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't')
9481 && actstr[1] == NUL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009482 action = *actstr;
9483 else
9484 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00009485 semsg(_(e_invalid_action_str_2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009486 return;
9487 }
9488 }
9489 else
9490 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009491 emsg(_(e_string_required));
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009492 return;
9493 }
9494
9495 if (set_tagstack(wp, d, action) == OK)
9496 rettv->vval.v_number = 0;
9497}
9498
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009499#ifdef FEAT_CRYPT
9500/*
9501 * "sha256({string})" function
9502 */
9503 static void
9504f_sha256(typval_T *argvars, typval_T *rettv)
9505{
9506 char_u *p;
9507
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009508 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9509 return;
9510
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009511 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009512 rettv->vval.v_string = vim_strsave(
9513 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
9514 rettv->v_type = VAR_STRING;
9515}
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009516#endif // FEAT_CRYPT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009517
9518/*
9519 * "shellescape({string})" function
9520 */
9521 static void
9522f_shellescape(typval_T *argvars, typval_T *rettv)
9523{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009524 int do_special;
Bram Moolenaar20615522017-06-05 18:46:26 +02009525
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009526 if (in_vim9script()
9527 && (check_for_string_arg(argvars, 0) == FAIL
9528 || check_for_opt_bool_arg(argvars, 1) == FAIL))
9529 return;
9530
9531 do_special = non_zero_arg(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009532 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009533 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009534 rettv->v_type = VAR_STRING;
9535}
9536
9537/*
9538 * shiftwidth() function
9539 */
9540 static void
9541f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
9542{
Bram Moolenaarf9514162018-11-22 03:08:29 +01009543 rettv->vval.v_number = 0;
9544
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009545 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
9546 return;
9547
Bram Moolenaarf9514162018-11-22 03:08:29 +01009548 if (argvars[0].v_type != VAR_UNKNOWN)
9549 {
9550 long col;
9551
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009552 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +01009553 if (col < 0)
9554 return; // type error; errmsg already given
9555#ifdef FEAT_VARTABS
9556 rettv->vval.v_number = get_sw_value_col(curbuf, col);
9557 return;
9558#endif
9559 }
9560
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009561 rettv->vval.v_number = get_sw_value(curbuf);
9562}
9563
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009564/*
9565 * "soundfold({word})" function
9566 */
9567 static void
9568f_soundfold(typval_T *argvars, typval_T *rettv)
9569{
9570 char_u *s;
9571
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009572 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9573 return;
9574
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009575 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009576 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009577#ifdef FEAT_SPELL
9578 rettv->vval.v_string = eval_soundfold(s);
9579#else
9580 rettv->vval.v_string = vim_strsave(s);
9581#endif
9582}
9583
9584/*
9585 * "spellbadword()" function
9586 */
9587 static void
9588f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
9589{
9590 char_u *word = (char_u *)"";
9591 hlf_T attr = HLF_COUNT;
9592 int len = 0;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009593#ifdef FEAT_SPELL
9594 int wo_spell_save = curwin->w_p_spell;
9595
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009596 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
9597 return;
9598
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009599 if (!curwin->w_p_spell)
9600 {
9601 did_set_spelllang(curwin);
9602 curwin->w_p_spell = TRUE;
9603 }
9604
9605 if (*curwin->w_s->b_p_spl == NUL)
9606 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009607 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009608 curwin->w_p_spell = wo_spell_save;
9609 return;
9610 }
9611#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009612
9613 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009614 {
9615#ifdef FEAT_SPELL
9616 curwin->w_p_spell = wo_spell_save;
9617#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009618 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009619 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009620
9621#ifdef FEAT_SPELL
9622 if (argvars[0].v_type == VAR_UNKNOWN)
9623 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009624 // Find the start and length of the badly spelled word.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009625 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
9626 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009627 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009628 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009629 curwin->w_set_curswant = TRUE;
9630 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009631 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009632 else if (*curbuf->b_s.b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009633 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009634 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009635 int capcol = -1;
9636
9637 if (str != NULL)
9638 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009639 // Check the argument for spelling.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009640 while (*str != NUL)
9641 {
9642 len = spell_check(curwin, str, &attr, &capcol, FALSE);
9643 if (attr != HLF_COUNT)
9644 {
9645 word = str;
9646 break;
9647 }
9648 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +02009649 capcol -= len;
Bram Moolenaar0c779e82019-08-09 17:01:02 +02009650 len = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009651 }
9652 }
9653 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009654 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009655#endif
9656
9657 list_append_string(rettv->vval.v_list, word, len);
9658 list_append_string(rettv->vval.v_list, (char_u *)(
9659 attr == HLF_SPB ? "bad" :
9660 attr == HLF_SPR ? "rare" :
9661 attr == HLF_SPL ? "local" :
9662 attr == HLF_SPC ? "caps" :
9663 ""), -1);
9664}
9665
9666/*
9667 * "spellsuggest()" function
9668 */
9669 static void
9670f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
9671{
9672#ifdef FEAT_SPELL
9673 char_u *str;
9674 int typeerr = FALSE;
9675 int maxcount;
9676 garray_T ga;
9677 int i;
9678 listitem_T *li;
9679 int need_capital = FALSE;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009680 int wo_spell_save = curwin->w_p_spell;
9681
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009682 if (in_vim9script()
9683 && (check_for_string_arg(argvars, 0) == FAIL
9684 || check_for_opt_number_arg(argvars, 1) == FAIL
9685 || (argvars[1].v_type != VAR_UNKNOWN
9686 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9687 return;
9688
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009689 if (!curwin->w_p_spell)
9690 {
9691 did_set_spelllang(curwin);
9692 curwin->w_p_spell = TRUE;
9693 }
9694
9695 if (*curwin->w_s->b_p_spl == NUL)
9696 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009697 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009698 curwin->w_p_spell = wo_spell_save;
9699 return;
9700 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009701#endif
9702
9703 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009704 {
9705#ifdef FEAT_SPELL
9706 curwin->w_p_spell = wo_spell_save;
9707#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009708 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009709 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009710
9711#ifdef FEAT_SPELL
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009712 if (*curwin->w_s->b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009713 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009714 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009715 if (argvars[1].v_type != VAR_UNKNOWN)
9716 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009717 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009718 if (maxcount <= 0)
9719 return;
9720 if (argvars[2].v_type != VAR_UNKNOWN)
9721 {
Bram Moolenaar7c27f332020-09-05 22:45:55 +02009722 need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009723 if (typeerr)
9724 return;
9725 }
9726 }
9727 else
9728 maxcount = 25;
9729
9730 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
9731
9732 for (i = 0; i < ga.ga_len; ++i)
9733 {
9734 str = ((char_u **)ga.ga_data)[i];
9735
9736 li = listitem_alloc();
9737 if (li == NULL)
9738 vim_free(str);
9739 else
9740 {
9741 li->li_tv.v_type = VAR_STRING;
9742 li->li_tv.v_lock = 0;
9743 li->li_tv.vval.v_string = str;
9744 list_append(rettv->vval.v_list, li);
9745 }
9746 }
9747 ga_clear(&ga);
9748 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009749 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009750#endif
9751}
9752
9753 static void
9754f_split(typval_T *argvars, typval_T *rettv)
9755{
9756 char_u *str;
9757 char_u *end;
9758 char_u *pat = NULL;
9759 regmatch_T regmatch;
9760 char_u patbuf[NUMBUFLEN];
9761 char_u *save_cpo;
9762 int match;
9763 colnr_T col = 0;
9764 int keepempty = FALSE;
9765 int typeerr = FALSE;
9766
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009767 if (in_vim9script()
9768 && (check_for_string_arg(argvars, 0) == FAIL
9769 || check_for_opt_string_arg(argvars, 1) == FAIL
9770 || (argvars[1].v_type != VAR_UNKNOWN
9771 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9772 return;
9773
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009774 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009775 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009776 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009777
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009778 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009779 if (argvars[1].v_type != VAR_UNKNOWN)
9780 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009781 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009782 if (pat == NULL)
9783 typeerr = TRUE;
9784 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar3986b942020-09-06 16:09:04 +02009785 keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009786 }
9787 if (pat == NULL || *pat == NUL)
9788 pat = (char_u *)"[\\x01- ]\\+";
9789
9790 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02009791 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009792 if (typeerr)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02009793 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009794
9795 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
9796 if (regmatch.regprog != NULL)
9797 {
9798 regmatch.rm_ic = FALSE;
9799 while (*str != NUL || keepempty)
9800 {
9801 if (*str == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009802 match = FALSE; // empty item at the end
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009803 else
9804 match = vim_regexec_nl(&regmatch, str, col);
9805 if (match)
9806 end = regmatch.startp[0];
9807 else
9808 end = str + STRLEN(str);
9809 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
9810 && *str != NUL && match && end < regmatch.endp[0]))
9811 {
9812 if (list_append_string(rettv->vval.v_list, str,
9813 (int)(end - str)) == FAIL)
9814 break;
9815 }
9816 if (!match)
9817 break;
Bram Moolenaar13505972019-01-24 15:04:48 +01009818 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009819 if (regmatch.endp[0] > str)
9820 col = 0;
9821 else
Bram Moolenaar13505972019-01-24 15:04:48 +01009822 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009823 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009824 str = regmatch.endp[0];
9825 }
9826
9827 vim_regfree(regmatch.regprog);
9828 }
9829
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02009830theend:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009831 p_cpo = save_cpo;
9832}
9833
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009834/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009835 * "submatch()" function
9836 */
9837 static void
9838f_submatch(typval_T *argvars, typval_T *rettv)
9839{
9840 int error = FALSE;
9841 int no;
9842 int retList = 0;
9843
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009844 if (in_vim9script()
9845 && (check_for_number_arg(argvars, 0) == FAIL
9846 || check_for_opt_bool_arg(argvars, 1) == FAIL))
9847 return;
9848
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009849 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009850 if (error)
9851 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +02009852 if (no < 0 || no >= NSUBEXP)
9853 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00009854 semsg(_(e_invalid_submatch_number_nr), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +01009855 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +02009856 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009857 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaarad304702020-09-06 18:22:53 +02009858 retList = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009859 if (error)
9860 return;
9861
9862 if (retList == 0)
9863 {
9864 rettv->v_type = VAR_STRING;
9865 rettv->vval.v_string = reg_submatch(no);
9866 }
9867 else
9868 {
9869 rettv->v_type = VAR_LIST;
9870 rettv->vval.v_list = reg_submatch_list(no);
9871 }
9872}
9873
9874/*
9875 * "substitute()" function
9876 */
9877 static void
9878f_substitute(typval_T *argvars, typval_T *rettv)
9879{
9880 char_u patbuf[NUMBUFLEN];
9881 char_u subbuf[NUMBUFLEN];
9882 char_u flagsbuf[NUMBUFLEN];
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02009883 char_u *str;
9884 char_u *pat;
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009885 char_u *sub = NULL;
9886 typval_T *expr = NULL;
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02009887 char_u *flg;
9888
9889 if (in_vim9script()
9890 && (check_for_string_arg(argvars, 0) == FAIL
9891 || check_for_string_arg(argvars, 1) == FAIL
9892 || check_for_string_arg(argvars, 3) == FAIL))
9893 return;
9894
9895 str = tv_get_string_chk(&argvars[0]);
9896 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
9897 flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009898
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009899 if (argvars[2].v_type == VAR_FUNC || argvars[2].v_type == VAR_PARTIAL)
9900 expr = &argvars[2];
9901 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009902 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009903
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009904 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009905 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
9906 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009907 rettv->vval.v_string = NULL;
9908 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009909 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009910}
9911
9912/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +02009913 * "swapinfo(swap_filename)" function
9914 */
9915 static void
9916f_swapinfo(typval_T *argvars, typval_T *rettv)
9917{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009918 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9919 return;
9920
Bram Moolenaar00f123a2018-08-21 20:28:54 +02009921 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009922 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +02009923}
9924
9925/*
Bram Moolenaar110bd602018-09-16 18:46:59 +02009926 * "swapname(expr)" function
9927 */
9928 static void
9929f_swapname(typval_T *argvars, typval_T *rettv)
9930{
9931 buf_T *buf;
9932
9933 rettv->v_type = VAR_STRING;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009934
9935 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
9936 return;
9937
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01009938 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +02009939 if (buf == NULL || buf->b_ml.ml_mfp == NULL
9940 || buf->b_ml.ml_mfp->mf_fname == NULL)
9941 rettv->vval.v_string = NULL;
9942 else
9943 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
9944}
9945
9946/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009947 * "synID(lnum, col, trans)" function
9948 */
9949 static void
9950f_synID(typval_T *argvars UNUSED, typval_T *rettv)
9951{
9952 int id = 0;
9953#ifdef FEAT_SYN_HL
9954 linenr_T lnum;
9955 colnr_T col;
9956 int trans;
9957 int transerr = FALSE;
9958
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009959 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02009960 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009961 || check_for_number_arg(argvars, 1) == FAIL
9962 || check_for_bool_arg(argvars, 2) == FAIL))
9963 return;
9964
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009965 lnum = tv_get_lnum(argvars); // -1 on type error
9966 col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaarfcb6d702020-09-05 21:41:56 +02009967 trans = (int)tv_get_bool_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009968
9969 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
9970 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00009971 id = syn_get_id(curwin, lnum, col, trans, NULL, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009972#endif
9973
9974 rettv->vval.v_number = id;
9975}
9976
9977/*
9978 * "synIDattr(id, what [, mode])" function
9979 */
9980 static void
9981f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
9982{
9983 char_u *p = NULL;
9984#ifdef FEAT_SYN_HL
9985 int id;
9986 char_u *what;
9987 char_u *mode;
9988 char_u modebuf[NUMBUFLEN];
9989 int modec;
9990
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02009991 if (in_vim9script()
9992 && (check_for_number_arg(argvars, 0) == FAIL
Yegappan Lakshmananf8dbd582021-09-26 19:04:05 +01009993 || check_for_string_arg(argvars, 1) == FAIL
9994 || check_for_opt_string_arg(argvars, 2) == FAIL))
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02009995 return;
9996
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009997 id = (int)tv_get_number(&argvars[0]);
9998 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009999 if (argvars[2].v_type != VAR_UNKNOWN)
10000 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010001 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010002 modec = TOLOWER_ASC(mode[0]);
10003 if (modec != 't' && modec != 'c' && modec != 'g')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010004 modec = 0; // replace invalid with current
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010005 }
10006 else
10007 {
10008#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
10009 if (USE_24BIT)
10010 modec = 'g';
10011 else
10012#endif
10013 if (t_colors > 1)
Dominique Pelle4781d6f2021-05-18 21:46:31 +020010014 modec = 'c';
10015 else
10016 modec = 't';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010017 }
10018
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010019 switch (TOLOWER_ASC(what[0]))
10020 {
10021 case 'b':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010022 if (TOLOWER_ASC(what[1]) == 'g') // bg[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010023 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010024 else // bold
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010025 p = highlight_has_attr(id, HL_BOLD, modec);
10026 break;
10027
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010028 case 'f': // fg[#] or font
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010029 p = highlight_color(id, what, modec);
10030 break;
10031
10032 case 'i':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010033 if (TOLOWER_ASC(what[1]) == 'n') // inverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010034 p = highlight_has_attr(id, HL_INVERSE, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010035 else // italic
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010036 p = highlight_has_attr(id, HL_ITALIC, modec);
10037 break;
10038
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010039 case 'n': // name
Bram Moolenaarc96272e2017-03-26 13:50:09 +020010040 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010041 break;
10042
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010043 case 'r': // reverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010044 p = highlight_has_attr(id, HL_INVERSE, modec);
10045 break;
10046
10047 case 's':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010048 if (TOLOWER_ASC(what[1]) == 'p') // sp[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010049 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010050 // strikeout
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +020010051 else if (TOLOWER_ASC(what[1]) == 't' &&
10052 TOLOWER_ASC(what[2]) == 'r')
10053 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010054 else // standout
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010055 p = highlight_has_attr(id, HL_STANDOUT, modec);
10056 break;
10057
10058 case 'u':
Bram Moolenaar391c3622020-09-29 20:59:17 +020010059 if (TOLOWER_ASC(what[1]) == 'l') // ul
10060 p = highlight_color(id, what, modec);
10061 else if (STRLEN(what) <= 5 || TOLOWER_ASC(what[5]) != 'c')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010062 // underline
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010063 p = highlight_has_attr(id, HL_UNDERLINE, modec);
10064 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010065 // undercurl
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010066 p = highlight_has_attr(id, HL_UNDERCURL, modec);
10067 break;
10068 }
10069
10070 if (p != NULL)
10071 p = vim_strsave(p);
10072#endif
10073 rettv->v_type = VAR_STRING;
10074 rettv->vval.v_string = p;
10075}
10076
10077/*
10078 * "synIDtrans(id)" function
10079 */
10080 static void
10081f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
10082{
10083 int id;
10084
10085#ifdef FEAT_SYN_HL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010086 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
10087 return;
10088
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010089 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010090
10091 if (id > 0)
10092 id = syn_get_final_id(id);
10093 else
10094#endif
10095 id = 0;
10096
10097 rettv->vval.v_number = id;
10098}
10099
10100/*
10101 * "synconcealed(lnum, col)" function
10102 */
10103 static void
10104f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
10105{
10106#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
10107 linenr_T lnum;
10108 colnr_T col;
10109 int syntax_flags = 0;
10110 int cchar;
10111 int matchid = 0;
10112 char_u str[NUMBUFLEN];
10113#endif
10114
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010115 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010116
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010117 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010118 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010119 || check_for_number_arg(argvars, 1) == FAIL))
10120 return;
10121
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010122#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010123 lnum = tv_get_lnum(argvars); // -1 on type error
10124 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010125
Bram Moolenaara80faa82020-04-12 19:37:17 +020010126 CLEAR_FIELD(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010127
10128 if (rettv_list_alloc(rettv) != FAIL)
10129 {
10130 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10131 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
10132 && curwin->w_p_cole > 0)
10133 {
10134 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
10135 syntax_flags = get_syntax_info(&matchid);
10136
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010137 // get the conceal character
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010138 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
10139 {
10140 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +020010141 if (cchar == NUL && curwin->w_p_cole == 1)
Bram Moolenaareed9d462021-02-15 20:38:25 +010010142 cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' '
10143 : curwin->w_lcs_chars.conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010144 if (cchar != NUL)
10145 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010146 if (has_mbyte)
10147 (*mb_char2bytes)(cchar, str);
10148 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010149 str[0] = cchar;
10150 }
10151 }
10152 }
10153
10154 list_append_number(rettv->vval.v_list,
10155 (syntax_flags & HL_CONCEAL) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010156 // -1 to auto-determine strlen
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010157 list_append_string(rettv->vval.v_list, str, -1);
10158 list_append_number(rettv->vval.v_list, matchid);
10159 }
10160#endif
10161}
10162
10163/*
10164 * "synstack(lnum, col)" function
10165 */
10166 static void
10167f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
10168{
10169#ifdef FEAT_SYN_HL
10170 linenr_T lnum;
10171 colnr_T col;
10172 int i;
10173 int id;
10174#endif
10175
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010176 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010177
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010178 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010179 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010180 || check_for_number_arg(argvars, 1) == FAIL))
10181 return;
10182
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010183#ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010184 lnum = tv_get_lnum(argvars); // -1 on type error
10185 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010186
10187 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10188 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
10189 && rettv_list_alloc(rettv) != FAIL)
10190 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000010191 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010192 for (i = 0; ; ++i)
10193 {
10194 id = syn_get_stack_item(i);
10195 if (id < 0)
10196 break;
10197 if (list_append_number(rettv->vval.v_list, id) == FAIL)
10198 break;
10199 }
10200 }
10201#endif
10202}
10203
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010204/*
10205 * "tabpagebuflist()" function
10206 */
10207 static void
10208f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10209{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010210 tabpage_T *tp;
10211 win_T *wp = NULL;
10212
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010213 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
10214 return;
10215
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010216 if (argvars[0].v_type == VAR_UNKNOWN)
10217 wp = firstwin;
10218 else
10219 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010220 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010221 if (tp != NULL)
10222 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
10223 }
10224 if (wp != NULL && rettv_list_alloc(rettv) != FAIL)
10225 {
10226 for (; wp != NULL; wp = wp->w_next)
10227 if (list_append_number(rettv->vval.v_list,
10228 wp->w_buffer->b_fnum) == FAIL)
10229 break;
10230 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010231}
10232
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010233/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010234 * "tagfiles()" function
10235 */
10236 static void
10237f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
10238{
10239 char_u *fname;
10240 tagname_T tn;
10241 int first;
10242
10243 if (rettv_list_alloc(rettv) == FAIL)
10244 return;
10245 fname = alloc(MAXPATHL);
10246 if (fname == NULL)
10247 return;
10248
10249 for (first = TRUE; ; first = FALSE)
10250 if (get_tagfname(&tn, first, fname) == FAIL
10251 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
10252 break;
10253 tagname_free(&tn);
10254 vim_free(fname);
10255}
10256
10257/*
10258 * "taglist()" function
10259 */
10260 static void
10261f_taglist(typval_T *argvars, typval_T *rettv)
10262{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010263 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010264 char_u *tag_pattern;
10265
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010266 if (in_vim9script()
10267 && (check_for_string_arg(argvars, 0) == FAIL
10268 || check_for_opt_string_arg(argvars, 1) == FAIL))
10269 return;
10270
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010271 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010272
10273 rettv->vval.v_number = FALSE;
10274 if (*tag_pattern == NUL)
10275 return;
10276
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010277 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010278 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010279 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010280 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010281}
10282
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010283/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010284 * "type(expr)" function
10285 */
10286 static void
10287f_type(typval_T *argvars, typval_T *rettv)
10288{
10289 int n = -1;
10290
10291 switch (argvars[0].v_type)
10292 {
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010293 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
10294 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010295 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010296 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
10297 case VAR_LIST: n = VAR_TYPE_LIST; break;
10298 case VAR_DICT: n = VAR_TYPE_DICT; break;
10299 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
10300 case VAR_BOOL: n = VAR_TYPE_BOOL; break;
10301 case VAR_SPECIAL: n = VAR_TYPE_NONE; break;
Bram Moolenaarf562e722016-07-19 17:25:25 +020010302 case VAR_JOB: n = VAR_TYPE_JOB; break;
10303 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010010304 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaarf18332f2021-05-07 17:55:55 +020010305 case VAR_INSTR: n = VAR_TYPE_INSTR; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010306 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +020010307 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010308 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +010010309 internal_error_no_abort("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010310 n = -1;
10311 break;
10312 }
10313 rettv->vval.v_number = n;
10314}
10315
10316/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010317 * "virtcol(string)" function
10318 */
10319 static void
10320f_virtcol(typval_T *argvars, typval_T *rettv)
10321{
10322 colnr_T vcol = 0;
10323 pos_T *fp;
10324 int fnum = curbuf->b_fnum;
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010325 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010326
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010327 if (in_vim9script()
10328 && check_for_string_or_list_arg(argvars, 0) == FAIL)
10329 return;
10330
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010331 fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010332 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
10333 && fnum == curbuf->b_fnum)
10334 {
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010335 // Limit the column to a valid value, getvvcol() doesn't check.
10336 if (fp->col < 0)
10337 fp->col = 0;
10338 else
10339 {
10340 len = (int)STRLEN(ml_get(fp->lnum));
10341 if (fp->col > len)
10342 fp->col = len;
10343 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010344 getvvcol(curwin, fp, NULL, NULL, &vcol);
10345 ++vcol;
10346 }
10347
10348 rettv->vval.v_number = vcol;
10349}
10350
10351/*
10352 * "visualmode()" function
10353 */
10354 static void
10355f_visualmode(typval_T *argvars, typval_T *rettv)
10356{
10357 char_u str[2];
10358
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010359 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
10360 return;
10361
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010362 rettv->v_type = VAR_STRING;
10363 str[0] = curbuf->b_visual_mode_eval;
10364 str[1] = NUL;
10365 rettv->vval.v_string = vim_strsave(str);
10366
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010367 // A non-zero number or non-empty string argument: reset mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010368 if (non_zero_arg(&argvars[0]))
10369 curbuf->b_visual_mode_eval = NUL;
10370}
10371
10372/*
10373 * "wildmenumode()" function
10374 */
10375 static void
10376f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10377{
10378#ifdef FEAT_WILDMENU
Yegappan Lakshmanan3908ef52022-02-08 12:08:07 +000010379 if (wild_menu_showing || ((State & CMDLINE) && cmdline_pum_active()))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010380 rettv->vval.v_number = 1;
10381#endif
10382}
10383
10384/*
Bram Moolenaar0c1e3742019-12-27 13:49:24 +010010385 * "windowsversion()" function
10386 */
10387 static void
10388f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10389{
10390 rettv->v_type = VAR_STRING;
10391 rettv->vval.v_string = vim_strsave((char_u *)windowsVersion);
10392}
10393
10394/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010395 * "wordcount()" function
10396 */
10397 static void
10398f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
10399{
10400 if (rettv_dict_alloc(rettv) == FAIL)
10401 return;
10402 cursor_pos_info(rettv->vval.v_dict);
10403}
10404
10405/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010406 * "xor(expr, expr)" function
10407 */
10408 static void
10409f_xor(typval_T *argvars, typval_T *rettv)
10410{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010411 if (in_vim9script()
10412 && (check_for_number_arg(argvars, 0) == FAIL
10413 || check_for_number_arg(argvars, 1) == FAIL))
10414 return;
10415
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010416 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
10417 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010418}
10419
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010420#endif // FEAT_EVAL