blob: 9cbd413405b06e8e9c7be40cf4d0d181fa19c02b [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * evalfunc.c: Builtin functions
12 */
13#define USING_FLOAT_STUFF
14
15#include "vim.h"
16
17#if defined(FEAT_EVAL) || defined(PROTO)
18
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020019#ifdef VMS
20# include <float.h>
21#endif
22
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020023static void f_and(typval_T *argvars, typval_T *rettv);
Bram Moolenaar59716a22017-03-01 20:32:44 +010024#ifdef FEAT_BEVAL
Bram Moolenaarbe0a2592019-05-09 13:50:16 +020025static void f_balloon_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar59716a22017-03-01 20:32:44 +010026static void f_balloon_show(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010027# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +010028static void f_balloon_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010029# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +010030#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020031static void f_byte2line(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020032static void f_call(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020033static void f_changenr(typval_T *argvars, typval_T *rettv);
34static void f_char2nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010035static void f_charcol(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020036static void f_col(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020037static void f_confirm(typval_T *argvars, typval_T *rettv);
38static void f_copy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020039static void f_cursor(typval_T *argsvars, typval_T *rettv);
Bram Moolenaar4f974752019-02-17 17:44:42 +010040#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +020041static void f_debugbreak(typval_T *argvars, typval_T *rettv);
42#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020043static void f_deepcopy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020044static void f_did_filetype(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4132eb52020-02-14 16:53:00 +010045static void f_echoraw(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020046static void f_empty(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020047static void f_environ(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020048static void f_escape(typval_T *argvars, typval_T *rettv);
49static void f_eval(typval_T *argvars, typval_T *rettv);
50static void f_eventhandler(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020051static void f_execute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar26735992021-08-08 14:43:22 +020052static void f_exists_compiled(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020053static void f_expand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar80dad482019-06-09 17:22:31 +020054static void f_expandcmd(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020055static void f_feedkeys(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020056static void f_fnameescape(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020057static void f_foreground(typval_T *argvars, typval_T *rettv);
Bram Moolenaar437bafe2016-08-01 15:40:54 +020058static void f_funcref(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020059static void f_function(typval_T *argvars, typval_T *rettv);
60static void f_garbagecollect(typval_T *argvars, typval_T *rettv);
61static void f_get(typval_T *argvars, typval_T *rettv);
Bram Moolenaar07ad8162018-02-13 13:59:59 +010062static void f_getchangelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010063static void f_getcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020064static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020065static void f_getenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020066static void f_getfontname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4f505882018-02-10 21:06:32 +010067static void f_getjumplist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020068static void f_getpid(typval_T *argvars, typval_T *rettv);
69static void f_getcurpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010070static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020071static void f_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020072static void f_getreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020073static void f_getreginfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020074static void f_getregtype(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010075static void f_gettagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +020076static void f_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020077static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020078static void f_hlID(typval_T *argvars, typval_T *rettv);
79static void f_hlexists(typval_T *argvars, typval_T *rettv);
80static void f_hostname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020081static void f_index(typval_T *argvars, typval_T *rettv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +010082static void f_indexof(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020083static void f_input(typval_T *argvars, typval_T *rettv);
84static void f_inputdialog(typval_T *argvars, typval_T *rettv);
85static void f_inputlist(typval_T *argvars, typval_T *rettv);
86static void f_inputrestore(typval_T *argvars, typval_T *rettv);
87static void f_inputsave(typval_T *argvars, typval_T *rettv);
88static void f_inputsecret(typval_T *argvars, typval_T *rettv);
Bram Moolenaar67a2deb2019-11-25 00:05:32 +010089static void f_interrupt(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020090static void f_invert(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020091static void f_islocked(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020092static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020093static void f_libcall(typval_T *argvars, typval_T *rettv);
94static void f_libcallnr(typval_T *argvars, typval_T *rettv);
95static void f_line(typval_T *argvars, typval_T *rettv);
96static void f_line2byte(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020097#ifdef FEAT_LUA
98static void f_luaeval(typval_T *argvars, typval_T *rettv);
99#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200100static void f_match(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200101static void f_matchend(typval_T *argvars, typval_T *rettv);
102static void f_matchlist(typval_T *argvars, typval_T *rettv);
103static void f_matchstr(typval_T *argvars, typval_T *rettv);
104static void f_matchstrpos(typval_T *argvars, typval_T *rettv);
105static void f_max(typval_T *argvars, typval_T *rettv);
106static void f_min(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200107#ifdef FEAT_MZSCHEME
108static void f_mzeval(typval_T *argvars, typval_T *rettv);
109#endif
110static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
111static void f_nr2char(typval_T *argvars, typval_T *rettv);
112static void f_or(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200113#ifdef FEAT_PERL
114static void f_perleval(typval_T *argvars, typval_T *rettv);
115#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200116static void f_prevnonblank(typval_T *argvars, typval_T *rettv);
117static void f_printf(typval_T *argvars, typval_T *rettv);
Bram Moolenaare9bd5722019-08-17 19:36:06 +0200118static void f_pum_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200119static void f_pumvisible(typval_T *argvars, typval_T *rettv);
120#ifdef FEAT_PYTHON3
121static void f_py3eval(typval_T *argvars, typval_T *rettv);
122#endif
123#ifdef FEAT_PYTHON
124static void f_pyeval(typval_T *argvars, typval_T *rettv);
125#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100126#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
127static void f_pyxeval(typval_T *argvars, typval_T *rettv);
128#endif
Bram Moolenaar4f645c52020-02-08 16:40:39 +0100129static void f_test_srand_seed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100130static void f_rand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200131static void f_range(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200132static void f_reg_executing(typval_T *argvars, typval_T *rettv);
133static void f_reg_recording(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200134static void f_rename(typval_T *argvars, typval_T *rettv);
135static void f_repeat(typval_T *argvars, typval_T *rettv);
Bram Moolenaare99be0e2019-03-26 22:51:09 +0100136#ifdef FEAT_RUBY
137static void f_rubyeval(typval_T *argvars, typval_T *rettv);
138#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200139static void f_screenattr(typval_T *argvars, typval_T *rettv);
140static void f_screenchar(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100141static void f_screenchars(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200142static void f_screencol(typval_T *argvars, typval_T *rettv);
143static void f_screenrow(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100144static void f_screenstring(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200145static void f_search(typval_T *argvars, typval_T *rettv);
146static void f_searchdecl(typval_T *argvars, typval_T *rettv);
147static void f_searchpair(typval_T *argvars, typval_T *rettv);
148static void f_searchpairpos(typval_T *argvars, typval_T *rettv);
149static void f_searchpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100150static void f_setcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200151static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100152static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +0200153static void f_setenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200154static void f_setfperm(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200155static void f_setpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200156static void f_setreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100157static void f_settagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200158#ifdef FEAT_CRYPT
159static void f_sha256(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb005cd82019-09-04 15:54:55 +0200160#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200161static void f_shellescape(typval_T *argvars, typval_T *rettv);
162static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200163static void f_soundfold(typval_T *argvars, typval_T *rettv);
164static void f_spellbadword(typval_T *argvars, typval_T *rettv);
165static void f_spellsuggest(typval_T *argvars, typval_T *rettv);
166static void f_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100167static void f_srand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200168static void f_submatch(typval_T *argvars, typval_T *rettv);
169static void f_substitute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200170static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200171static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200172static void f_synID(typval_T *argvars, typval_T *rettv);
173static void f_synIDattr(typval_T *argvars, typval_T *rettv);
174static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
175static void f_synstack(typval_T *argvars, typval_T *rettv);
176static void f_synconcealed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200177static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200178static void f_taglist(typval_T *argvars, typval_T *rettv);
179static void f_tagfiles(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200180static void f_type(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200181static void f_virtcol(typval_T *argvars, typval_T *rettv);
182static void f_visualmode(typval_T *argvars, typval_T *rettv);
183static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0c1e3742019-12-27 13:49:24 +0100184static void f_windowsversion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200185static void f_wordcount(typval_T *argvars, typval_T *rettv);
186static void f_xor(typval_T *argvars, typval_T *rettv);
187
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100188
Bram Moolenaar94738d82020-10-21 14:25:07 +0200189/*
190 * Functions that check the argument type of a builtin function.
191 * Each function returns FAIL and gives an error message if the type is wrong.
192 */
193
194// Context passed to an arg_ function.
195typedef struct {
Bram Moolenaarca174532020-10-21 16:42:22 +0200196 int arg_count; // actual argument count
Bram Moolenaar078a4612022-01-04 15:17:03 +0000197 type2_T *arg_types; // list of argument types
Bram Moolenaarca174532020-10-21 16:42:22 +0200198 int arg_idx; // current argument index (first arg is zero)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100199 cctx_T *arg_cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +0200200} argcontext_T;
201
202// A function to check one argument type. The first argument is the type to
203// check. If needed, other argument types can be obtained with the context.
204// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.
Bram Moolenaar078a4612022-01-04 15:17:03 +0000205typedef int (*argcheck_T)(type_T *, type_T *, argcontext_T *);
Bram Moolenaar94738d82020-10-21 14:25:07 +0200206
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100207/*
Bram Moolenaar351ead02021-01-16 16:07:01 +0100208 * Call need_type() to check an argument type.
209 */
210 static int
211check_arg_type(
212 type_T *expected,
213 type_T *actual,
214 argcontext_T *context)
215{
216 // TODO: would be useful to know if "actual" is a constant and pass it to
217 // need_type() to get a compile time error if possible.
218 return need_type(actual, expected,
219 context->arg_idx - context->arg_count, context->arg_idx + 1,
220 context->arg_cctx, FALSE, FALSE);
221}
222
223/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100224 * Check "type" is a float or a number.
225 */
Bram Moolenaar94738d82020-10-21 14:25:07 +0200226 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000227arg_float_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200228{
Bram Moolenaarca174532020-10-21 16:42:22 +0200229 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000230 || type->tt_type == VAR_UNKNOWN
231 || type->tt_type == VAR_FLOAT
232 || type->tt_type == VAR_NUMBER)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200233 return OK;
234 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
235 return FAIL;
236}
237
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100238/*
239 * Check "type" is a number.
240 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200241 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000242arg_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200243{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100244 return check_arg_type(&t_number, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200245}
246
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100247/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200248 * Check "type" is a dict of 'any'.
249 */
250 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000251arg_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200252{
253 return check_arg_type(&t_dict_any, type, context);
254}
255
256/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200257 * Check "type" is a list of 'any'.
258 */
259 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000260arg_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200261{
262 return check_arg_type(&t_list_any, type, context);
263}
264
265/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200266 * Check "type" is a list of numbers.
267 */
268 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000269arg_list_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200270{
271 return check_arg_type(&t_list_number, type, context);
272}
273
274/*
275 * Check "type" is a list of strings.
276 */
277 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000278arg_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200279{
280 return check_arg_type(&t_list_string, type, context);
281}
282
283/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100284 * Check "type" is a string.
285 */
286 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000287arg_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100288{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100289 return check_arg_type(&t_string, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100290}
291
292/*
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200293 * Check "type" is a blob
294 */
295 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000296arg_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200297{
298 return check_arg_type(&t_blob, type, context);
299}
300
301/*
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100302 * Check "type" is a bool or number 0 or 1.
303 */
304 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000305arg_bool(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100306{
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100307 return check_arg_type(&t_bool, type, context);
308}
309
310/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200311 * Check "type" is a list of 'any' or a blob.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100312 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200313 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000314arg_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200315{
316 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000317 || type->tt_type == VAR_UNKNOWN
318 || type->tt_type == VAR_LIST
319 || type->tt_type == VAR_BLOB)
Bram Moolenaarca174532020-10-21 16:42:22 +0200320 return OK;
321 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
322 return FAIL;
323}
324
325/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200326 * Check "type" is a string or a number
327 */
328 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000329arg_string_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200330{
331 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000332 || type->tt_type == VAR_UNKNOWN
333 || type->tt_type == VAR_STRING
334 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200335 return OK;
336 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
337 return FAIL;
338}
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200339
340/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200341 * Check "type" is a buffer (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200342 */
343 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000344arg_buffer(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200345{
346 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000347 || type->tt_type == VAR_UNKNOWN
348 || type->tt_type == VAR_STRING
349 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200350 return OK;
351 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
352 return FAIL;
353}
354
355/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200356 * Check "type" is a buffer or a dict of any
357 */
358 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000359arg_buffer_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200360{
361 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000362 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200363 || type->tt_type == VAR_STRING
364 || type->tt_type == VAR_NUMBER
365 || type->tt_type == VAR_DICT)
366 return OK;
367 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
368 return FAIL;
369}
370
371/*
372 * Check "type" is a line (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200373 */
374 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000375arg_lnum(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200376{
377 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000378 || type->tt_type == VAR_UNKNOWN
379 || type->tt_type == VAR_STRING
380 || type->tt_type == VAR_NUMBER)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200381 return OK;
382 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
383 return FAIL;
384}
385
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200386/*
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200387 * Check "type" is a string or a list of strings.
388 */
389 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000390arg_string_or_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200391{
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000392 if (type->tt_type == VAR_ANY
393 || type->tt_type == VAR_UNKNOWN
394 || type->tt_type == VAR_STRING)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200395 return OK;
396 if (type->tt_type != VAR_LIST)
397 {
398 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
399 return FAIL;
400 }
401 if (type->tt_member->tt_type == VAR_ANY
402 || type->tt_member->tt_type == VAR_STRING)
403 return OK;
404
405 arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);
406 return FAIL;
407}
408
409/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200410 * Check "type" is a string or a list of 'any'
411 */
412 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000413arg_string_or_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200414{
415 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000416 || type->tt_type == VAR_UNKNOWN
417 || type->tt_type == VAR_STRING
418 || type->tt_type == VAR_LIST)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200419 return OK;
420 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
421 return FAIL;
422}
423
424/*
Ernie Rael51d04d12022-05-04 15:40:22 +0100425 * Check "type" is a string or a dict of 'any'
426 */
427 static int
428arg_string_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
429{
430 if (type->tt_type == VAR_ANY
431 || type->tt_type == VAR_UNKNOWN
432 || type->tt_type == VAR_STRING
433 || type->tt_type == VAR_DICT)
434 return OK;
435 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
436 return FAIL;
437}
438
439/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200440 * Check "type" is a string or a blob
441 */
442 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000443arg_string_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200444{
445 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000446 || type->tt_type == VAR_UNKNOWN
447 || type->tt_type == VAR_STRING
448 || type->tt_type == VAR_BLOB)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200449 return OK;
450 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
451 return FAIL;
452}
453
454/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200455 * Check "type" is a list of 'any' or a dict of 'any'.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100456 */
457 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000458arg_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100459{
460 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000461 || type->tt_type == VAR_UNKNOWN
462 || type->tt_type == VAR_LIST
463 || type->tt_type == VAR_DICT)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100464 return OK;
465 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
466 return FAIL;
467}
468
469/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200470 * Check "type" is a list of 'any' or a dict of 'any' or a blob.
471 */
472 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000473arg_list_or_dict_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200474{
475 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000476 || type->tt_type == VAR_UNKNOWN
477 || type->tt_type == VAR_LIST
478 || type->tt_type == VAR_DICT
479 || type->tt_type == VAR_BLOB)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200480 return OK;
481 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
482 return FAIL;
483}
484
485/*
Bram Moolenaar2d877592021-12-16 08:21:09 +0000486 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
487 */
488 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000489arg_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 +0000490{
491 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000492 || type->tt_type == VAR_UNKNOWN
493 || type->tt_type == VAR_LIST
494 || type->tt_type == VAR_DICT
495 || type->tt_type == VAR_BLOB
496 || type->tt_type == VAR_STRING)
Bram Moolenaar2d877592021-12-16 08:21:09 +0000497 return OK;
498 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
499 return FAIL;
500}
501
502/*
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000503 * Check second argument of map() or filter().
504 */
505 static int
506check_map_filter_arg2(type_T *type, argcontext_T *context, int is_map)
507{
508 type_T *expected_member = NULL;
509 type_T *(args[2]);
510 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, NULL, args};
511
512 if (context->arg_types[0].type_curr->tt_type == VAR_LIST
513 || context->arg_types[0].type_curr->tt_type == VAR_DICT)
514 {
515 // Use the declared type if possible, so that an error is given if
516 // a declared list changes type, but not if a constant list changes
517 // type.
518 if (context->arg_types[0].type_decl->tt_type == VAR_LIST
519 || context->arg_types[0].type_decl->tt_type == VAR_DICT)
520 expected_member = context->arg_types[0].type_decl->tt_member;
521 else
522 expected_member = context->arg_types[0].type_curr->tt_member;
523 }
524 else if (context->arg_types[0].type_curr->tt_type == VAR_STRING)
525 expected_member = &t_string;
526 else if (context->arg_types[0].type_curr->tt_type == VAR_BLOB)
527 expected_member = &t_number;
528
529 args[0] = NULL;
530 args[1] = &t_unknown;
531 if (type->tt_argcount != -1)
532 {
533 if (!(type->tt_argcount == 2 || (type->tt_argcount == 1
534 && (type->tt_flags & TTFLAG_VARARGS))))
535 {
536 emsg(_(e_invalid_number_of_arguments));
537 return FAIL;
538 }
539 if (type->tt_flags & TTFLAG_VARARGS)
540 // check the argument types at runtime
541 t_func_exp.tt_argcount = -1;
542 else
543 {
544 if (context->arg_types[0].type_curr->tt_type == VAR_STRING
545 || context->arg_types[0].type_curr->tt_type == VAR_BLOB
546 || context->arg_types[0].type_curr->tt_type == VAR_LIST)
547 args[0] = &t_number;
548 else if (context->arg_types[0].type_decl->tt_type == VAR_DICT)
549 args[0] = &t_string;
550 if (args[0] != NULL)
551 args[1] = expected_member;
552 }
553 }
554
555 if ((type->tt_member != &t_any && type->tt_member != &t_unknown)
556 || args[0] != NULL)
557 {
558 where_T where = WHERE_INIT;
559
560 if (is_map)
561 t_func_exp.tt_member = expected_member == NULL
562 || type->tt_member == &t_any
563 || type->tt_member == &t_unknown
564 ? &t_any : expected_member;
565 else
566 t_func_exp.tt_member = &t_bool;
567 if (args[0] == NULL)
568 args[0] = &t_unknown;
Bram Moolenaar6e1a3872022-02-23 19:11:49 +0000569 if (type->tt_argcount == -1)
570 t_func_exp.tt_argcount = -1;
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000571
572 where.wt_index = 2;
573 return check_type(&t_func_exp, type, TRUE, where);
574 }
575 return OK;
576}
577
578/*
Bram Moolenaar18024052021-12-25 21:43:28 +0000579 * Check second argument of filter(): func must return a bool.
580 */
581 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000582arg_filter_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000583{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000584 if (type->tt_type == VAR_STRING
585 || type->tt_type == VAR_PARTIAL
586 || type == &t_unknown
587 || type == &t_any)
588 return OK;
589
590 if (type->tt_type == VAR_FUNC)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000591 return check_map_filter_arg2(type, context, FALSE);
592 semsg(_(e_string_or_function_required_for_argument_nr), 2);
593 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000594}
595
596/*
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000597 * Check second argument of map(), the function.
Bram Moolenaar18024052021-12-25 21:43:28 +0000598 */
599 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000600arg_map_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000601{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000602 if (type->tt_type == VAR_STRING
603 || type->tt_type == VAR_PARTIAL
604 || type == &t_unknown
605 || type == &t_any)
606 return OK;
607
608 if (type->tt_type == VAR_FUNC)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000609 return check_map_filter_arg2(type, context, TRUE);
610 semsg(_(e_string_or_function_required_for_argument_nr), 2);
611 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000612}
613
614/*
Bram Moolenaare843efc2022-02-22 21:54:44 +0000615 * Check second argument of sort() and uniq(), the "how" argument.
616 */
617 static int
618arg_sort_how(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
619{
620 if (type->tt_type == VAR_STRING
621 || type->tt_type == VAR_PARTIAL
622 || type == &t_unknown
623 || type == &t_any)
624 return OK;
625
626 if (type->tt_type == VAR_FUNC)
627 {
628 type_T *(args[2]);
629 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, &t_number, args};
630
631 if (context->arg_types[0].type_curr->tt_type == VAR_LIST)
632 args[0] = context->arg_types[0].type_curr->tt_member;
633 else
634 args[0] = &t_unknown;
635 if ((type->tt_member != &t_any && type->tt_member != &t_unknown)
636 || args[0] != &t_unknown)
637 {
638 where_T where = WHERE_INIT;
639
640 args[1] = args[0];
Bram Moolenaarfa026162022-02-23 21:03:32 +0000641 if (type->tt_argcount == -1)
642 t_func_exp.tt_argcount = -1;
Bram Moolenaare843efc2022-02-22 21:54:44 +0000643 where.wt_index = 2;
644 return check_type(&t_func_exp, type, TRUE, where);
645 }
646
647 return OK;
648 }
649 semsg(_(e_string_or_function_required_for_argument_nr), 2);
650 return FAIL;
651}
652
653/*
Bram Moolenaar73199812021-12-26 17:18:14 +0000654 * Check an expression argument, can be a string, funcref or partial.
655 * Also accept a bool, a constant resulting from compiling a string argument.
656 * Also accept a number, one and zero are accepted.
657 */
658 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000659arg_string_or_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar73199812021-12-26 17:18:14 +0000660{
661 if (type->tt_type == VAR_ANY
662 || type->tt_type == VAR_UNKNOWN
663 || type->tt_type == VAR_STRING
664 || type->tt_type == VAR_PARTIAL
665 || type->tt_type == VAR_FUNC
666 || type->tt_type == VAR_BOOL
667 || type->tt_type == VAR_NUMBER)
668 return OK;
669 arg_type_mismatch(&t_func_any, type, context->arg_idx + 1);
670 return FAIL;
671}
672
673/*
rbtnn0ccb5842021-12-18 18:33:46 +0000674 * Check "type" is a list of 'any' or a blob or a string.
675 */
676 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000677arg_string_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
rbtnn0ccb5842021-12-18 18:33:46 +0000678{
679 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000680 || type->tt_type == VAR_UNKNOWN
681 || type->tt_type == VAR_LIST
682 || type->tt_type == VAR_BLOB
683 || type->tt_type == VAR_STRING)
rbtnn0ccb5842021-12-18 18:33:46 +0000684 return OK;
685 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
686 return FAIL;
687}
688
689/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200690 * Check "type" is a job.
691 */
692 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000693arg_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200694{
695 return check_arg_type(&t_job, type, context);
696}
697
698/*
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200699 * Check "type" is a channel or a job.
700 */
701 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000702arg_chan_or_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200703{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200704 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000705 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200706 || type->tt_type == VAR_CHANNEL
707 || type->tt_type == VAR_JOB)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200708 return OK;
709 arg_type_mismatch(&t_channel, type, context->arg_idx + 1);
710 return FAIL;
711}
712
713/*
Bram Moolenaar078a4612022-01-04 15:17:03 +0000714 * Check "type" can be used as the type_decl of the previous argument.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100715 * Must not be used for the first argcheck_T entry.
716 */
717 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000718arg_same_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100719{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000720 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_decl;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100721
Bram Moolenaar351ead02021-01-16 16:07:01 +0100722 return check_arg_type(prev_type, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100723}
724
725/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100726 * Check "type" is the same basic type as the previous argument, checks list or
727 * dict vs other type, but not member type.
728 * Must not be used for the first argcheck_T entry.
729 */
730 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000731arg_same_struct_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100732{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000733 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100734
Bram Moolenaar078a4612022-01-04 15:17:03 +0000735 if (prev_type->tt_type != context->arg_types[context->arg_idx].type_curr->tt_type)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100736 return check_arg_type(prev_type, type, context);
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100737 return OK;
738}
739
740/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100741 * Check "type" is an item of the list or blob of the previous arg.
Bram Moolenaarca174532020-10-21 16:42:22 +0200742 * Must not be used for the first argcheck_T entry.
743 */
744 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000745arg_item_of_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200746{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000747 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarca174532020-10-21 16:42:22 +0200748 type_T *expected;
749
750 if (prev_type->tt_type == VAR_LIST)
751 expected = prev_type->tt_member;
752 else if (prev_type->tt_type == VAR_BLOB)
753 expected = &t_number;
754 else
755 // probably VAR_ANY, can't check
756 return OK;
757
Bram Moolenaar351ead02021-01-16 16:07:01 +0100758 return check_arg_type(expected, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200759}
760
Bram Moolenaar94738d82020-10-21 14:25:07 +0200761/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200762 * Check "type" is a string or a number or a list
763 */
764 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000765arg_str_or_nr_or_list(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200766{
Yegappan Lakshmanan841e4982021-07-11 22:04:25 +0200767 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000768 || type->tt_type == VAR_UNKNOWN
769 || type->tt_type == VAR_STRING
770 || type->tt_type == VAR_NUMBER
771 || type->tt_type == VAR_LIST)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200772 return OK;
773 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
774 return FAIL;
775}
776
777/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200778 * Check "type" is a dict of 'any' or a string
779 */
780 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000781arg_dict_any_or_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200782{
783 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000784 || type->tt_type == VAR_UNKNOWN
785 || type->tt_type == VAR_DICT
786 || type->tt_type == VAR_STRING)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200787 return OK;
788 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
789 return FAIL;
790}
791
792/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200793 * Check "type" which is the third argument of extend() (number or string or
794 * any)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100795 */
796 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000797arg_extend3(type_T *type, type_T *decl_type, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100798{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000799 type_T *first_type = context->arg_types[context->arg_idx - 2].type_curr;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100800
801 if (first_type->tt_type == VAR_LIST)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000802 return arg_number(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100803 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000804 return arg_string(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100805 return OK;
806}
807
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200808/*
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200809 * Check "type" which is the first argument of get() (blob or list or dict or
810 * funcref)
811 */
812 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000813arg_get1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200814{
815 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000816 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200817 || type->tt_type == VAR_BLOB
818 || type->tt_type == VAR_LIST
819 || type->tt_type == VAR_DICT
820 || type->tt_type == VAR_FUNC
821 || type->tt_type == VAR_PARTIAL)
822 return OK;
823
824 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
825 return FAIL;
826}
827
828/*
829 * Check "type" which is the first argument of len() (number or string or
830 * blob or list or dict)
831 */
832 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000833arg_len1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200834{
835 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000836 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200837 || type->tt_type == VAR_STRING
838 || type->tt_type == VAR_NUMBER
839 || type->tt_type == VAR_BLOB
840 || type->tt_type == VAR_LIST
841 || type->tt_type == VAR_DICT)
842 return OK;
843
844 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
845 return FAIL;
846}
847
848/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200849 * Check "type" which is the second argument of remove() (number or string or
850 * any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200851 */
852 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000853arg_remove2(type_T *type, type_T *decl_type, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200854{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000855 type_T *first_type = context->arg_types[context->arg_idx - 1].type_curr;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200856
857 if (first_type->tt_type == VAR_LIST || first_type->tt_type == VAR_BLOB)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000858 return arg_number(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200859 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000860 return arg_string_or_nr(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200861 return OK;
862}
863
864/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200865 * Check "type" which is the first argument of repeat() (string or number or
866 * list or any)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200867 */
868 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000869arg_repeat1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200870{
871 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000872 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200873 || type->tt_type == VAR_STRING
874 || type->tt_type == VAR_NUMBER
875 || type->tt_type == VAR_LIST)
876 return OK;
877
878 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
879 return FAIL;
880}
881
882/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200883 * Check "type" which is the first argument of slice() (list or blob or string
884 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200885 */
886 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000887arg_slice1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200888{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200889 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000890 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200891 || type->tt_type == VAR_LIST
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200892 || type->tt_type == VAR_BLOB
893 || type->tt_type == VAR_STRING)
894 return OK;
895
896 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
897 return FAIL;
898}
899
900/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200901 * Check "type" which is the first argument of count() (string or list or dict
902 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200903 */
904 static int
Bram Moolenaar3e518a82022-08-30 17:45:33 +0100905arg_string_or_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200906{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200907 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000908 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200909 || type->tt_type == VAR_STRING
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200910 || type->tt_type == VAR_LIST
911 || type->tt_type == VAR_DICT)
912 return OK;
913
Bram Moolenaar3e518a82022-08-30 17:45:33 +0100914 semsg(_(e_string_list_or_dict_required_for_argument_nr),
915 context->arg_idx + 1);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200916 return FAIL;
917}
918
919/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200920 * Check "type" which is the first argument of cursor() (number or string or
921 * list or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200922 */
923 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000924arg_cursor1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200925{
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200926 if (type->tt_type == VAR_ANY
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000927 || type->tt_type == VAR_UNKNOWN
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +0200928 || type->tt_type == VAR_NUMBER
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200929 || type->tt_type == VAR_STRING
930 || type->tt_type == VAR_LIST)
931 return OK;
932
933 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
934 return FAIL;
935}
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100936
937/*
Bram Moolenaar94738d82020-10-21 14:25:07 +0200938 * Lists of functions that check the argument types of a builtin function.
939 */
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200940static argcheck_T arg1_blob[] = {arg_blob};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200941static argcheck_T arg1_bool[] = {arg_bool};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200942static argcheck_T arg1_buffer[] = {arg_buffer};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200943static argcheck_T arg1_buffer_or_dict_any[] = {arg_buffer_or_dict_any};
944static argcheck_T arg1_chan_or_job[] = {arg_chan_or_job};
945static argcheck_T arg1_dict_any[] = {arg_dict_any};
946static argcheck_T arg1_dict_or_string[] = {arg_dict_any_or_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200947static argcheck_T arg1_float_or_nr[] = {arg_float_or_nr};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200948static argcheck_T arg1_job[] = {arg_job};
949static argcheck_T arg1_list_any[] = {arg_list_any};
950static argcheck_T arg1_list_number[] = {arg_list_number};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200951static argcheck_T arg1_list_or_blob[] = {arg_list_or_blob};
952static argcheck_T arg1_list_or_dict[] = {arg_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200953static argcheck_T arg1_list_string[] = {arg_list_string};
Bram Moolenaar3e518a82022-08-30 17:45:33 +0100954static argcheck_T arg1_string_or_list_or_dict[] = {arg_string_or_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200955static argcheck_T arg1_lnum[] = {arg_lnum};
956static argcheck_T arg1_number[] = {arg_number};
957static argcheck_T arg1_string[] = {arg_string};
958static argcheck_T arg1_string_or_list_any[] = {arg_string_or_list_any};
959static argcheck_T arg1_string_or_list_string[] = {arg_string_or_list_string};
960static argcheck_T arg1_string_or_nr[] = {arg_string_or_nr};
961static argcheck_T arg2_any_buffer[] = {NULL, arg_buffer};
962static argcheck_T arg2_buffer_any[] = {arg_buffer, NULL};
963static argcheck_T arg2_buffer_bool[] = {arg_buffer, arg_bool};
964static argcheck_T arg2_buffer_list_any[] = {arg_buffer, arg_list_any};
965static argcheck_T arg2_buffer_lnum[] = {arg_buffer, arg_lnum};
966static argcheck_T arg2_buffer_number[] = {arg_buffer, arg_number};
967static argcheck_T arg2_buffer_string[] = {arg_buffer, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200968static argcheck_T arg2_chan_or_job_dict[] = {arg_chan_or_job, arg_dict_any};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200969static argcheck_T arg2_chan_or_job_string[] = {arg_chan_or_job, arg_string};
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +0200970static argcheck_T arg2_dict_any_list_any[] = {arg_dict_any, arg_list_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200971static argcheck_T arg2_dict_any_string_or_nr[] = {arg_dict_any, arg_string_or_nr};
972static argcheck_T arg2_dict_string[] = {arg_dict_any, arg_string};
973static argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr};
974static argcheck_T arg2_job_dict[] = {arg_job, arg_dict_any};
975static argcheck_T arg2_job_string_or_number[] = {arg_job, arg_string_or_nr};
976static argcheck_T arg2_list_any_number[] = {arg_list_any, arg_number};
977static argcheck_T arg2_list_any_string[] = {arg_list_any, arg_string};
978static argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number};
979static argcheck_T arg2_list_number_bool[] = {arg_list_number, arg_bool};
980static argcheck_T arg2_listblob_item[] = {arg_list_or_blob, arg_item_of_prev};
981static argcheck_T arg2_lnum[] = {arg_lnum, arg_lnum};
982static argcheck_T arg2_lnum_number[] = {arg_lnum, arg_number};
983static argcheck_T arg2_number[] = {arg_number, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200984static argcheck_T arg2_number_any[] = {arg_number, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200985static argcheck_T arg2_number_bool[] = {arg_number, arg_bool};
986static argcheck_T arg2_number_dict_any[] = {arg_number, arg_dict_any};
987static argcheck_T arg2_number_list[] = {arg_number, arg_list_any};
988static argcheck_T arg2_number_string[] = {arg_number, arg_string};
989static argcheck_T arg2_number_string_or_list[] = {arg_number, arg_string_or_list_any};
990static argcheck_T arg2_str_or_nr_or_list_dict[] = {arg_str_or_nr_or_list, arg_dict_any};
991static argcheck_T arg2_string[] = {arg_string, arg_string};
992static argcheck_T arg2_string_any[] = {arg_string, NULL};
993static argcheck_T arg2_string_bool[] = {arg_string, arg_bool};
994static argcheck_T arg2_string_chan_or_job[] = {arg_string, arg_chan_or_job};
995static argcheck_T arg2_string_dict[] = {arg_string, arg_dict_any};
996static argcheck_T arg2_string_list_number[] = {arg_string, arg_list_number};
997static argcheck_T arg2_string_number[] = {arg_string, arg_number};
998static argcheck_T arg2_string_or_list_dict[] = {arg_string_or_list_any, arg_dict_any};
LemonBoy0f7a3e12022-05-26 12:10:37 +0100999static argcheck_T arg2_string_or_list_bool[] = {arg_string_or_list_any, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001000static argcheck_T arg2_string_string_or_number[] = {arg_string, arg_string_or_nr};
1001static argcheck_T arg3_any_list_dict[] = {NULL, arg_list_any, arg_dict_any};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001002static argcheck_T arg3_buffer_lnum_lnum[] = {arg_buffer, arg_lnum, arg_lnum};
1003static argcheck_T arg3_buffer_number_number[] = {arg_buffer, arg_number, arg_number};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001004static argcheck_T arg3_buffer_string_any[] = {arg_buffer, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001005static argcheck_T arg3_buffer_string_dict[] = {arg_buffer, arg_string, arg_dict_any};
1006static argcheck_T arg3_dict_number_number[] = {arg_dict_any, arg_number, arg_number};
1007static argcheck_T arg3_list_string_dict[] = {arg_list_any, arg_string, arg_dict_any};
1008static argcheck_T arg3_lnum_number_bool[] = {arg_lnum, arg_number, arg_bool};
1009static argcheck_T arg3_number[] = {arg_number, arg_number, arg_number};
1010static argcheck_T arg3_number_any_dict[] = {arg_number, NULL, arg_dict_any};
1011static argcheck_T arg3_number_number_dict[] = {arg_number, arg_number, arg_dict_any};
1012static argcheck_T arg3_number_string_any[] = {arg_number, arg_string, NULL};
1013static argcheck_T arg3_number_string_buffer[] = {arg_number, arg_string, arg_buffer};
1014static argcheck_T arg3_number_string_string[] = {arg_number, arg_string, arg_string};
1015static argcheck_T arg3_string[] = {arg_string, arg_string, arg_string};
1016static argcheck_T arg3_string_any_dict[] = {arg_string, NULL, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001017static argcheck_T arg3_string_any_string[] = {arg_string, NULL, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001018static argcheck_T arg3_string_bool_bool[] = {arg_string, arg_bool, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001019static argcheck_T arg3_string_number_bool[] = {arg_string, arg_number, arg_bool};
Ernie Rael51d04d12022-05-04 15:40:22 +01001020static argcheck_T arg3_string_or_dict_bool_dict[] = {arg_string_or_dict_any, arg_bool, arg_dict_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001021static argcheck_T arg3_string_string_bool[] = {arg_string, arg_string, arg_bool};
1022static argcheck_T arg3_string_string_dict[] = {arg_string, arg_string, arg_dict_any};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001023static argcheck_T arg3_string_string_number[] = {arg_string, arg_string, arg_number};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001024static argcheck_T arg4_number_number_string_any[] = {arg_number, arg_number, arg_string, NULL};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001025static argcheck_T arg4_string_string_any_string[] = {arg_string, arg_string, NULL, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001026static argcheck_T arg4_string_string_number_string[] = {arg_string, arg_string, arg_number, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001027/* Function specific argument types (not covered by the above) */
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001028static argcheck_T arg15_assert_fails[] = {arg_string_or_nr, arg_string_or_list_any, NULL, arg_number, arg_string};
1029static 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 +02001030static argcheck_T arg4_browse[] = {arg_bool, arg_string, arg_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001031static argcheck_T arg23_chanexpr[] = {arg_chan_or_job, NULL, arg_dict_any};
1032static argcheck_T arg23_chanraw[] = {arg_chan_or_job, arg_string_or_blob, arg_dict_any};
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001033static argcheck_T arg24_count[] = {arg_string_or_list_or_dict, NULL, arg_bool, arg_number};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001034static argcheck_T arg13_cursor[] = {arg_cursor1, arg_number, arg_number};
1035static argcheck_T arg12_deepcopy[] = {NULL, arg_bool};
1036static argcheck_T arg12_execute[] = {arg_string_or_list_string, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001037static argcheck_T arg23_extend[] = {arg_list_or_dict, arg_same_as_prev, arg_extend3};
1038static argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001039static argcheck_T arg23_get[] = {arg_get1, arg_string_or_nr, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001040static argcheck_T arg14_glob[] = {arg_string, arg_bool, arg_bool, arg_bool};
1041static argcheck_T arg25_globpath[] = {arg_string, arg_string, arg_bool, arg_bool, arg_bool};
1042static argcheck_T arg24_index[] = {arg_list_or_blob, arg_item_of_prev, arg_number, arg_bool};
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01001043static argcheck_T arg23_index[] = {arg_list_or_blob, arg_filter_func, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001044static argcheck_T arg23_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001045static argcheck_T arg1_len[] = {arg_len1};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001046static argcheck_T arg3_libcall[] = {arg_string, arg_string, arg_string_or_nr};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001047static argcheck_T arg14_maparg[] = {arg_string, arg_string, arg_bool, arg_bool};
Bram Moolenaar18024052021-12-25 21:43:28 +00001048static argcheck_T arg2_filter[] = {arg_list_or_dict_or_blob_or_string, arg_filter_func};
1049static argcheck_T arg2_map[] = {arg_list_or_dict_or_blob_or_string, arg_map_func};
1050static argcheck_T arg2_mapnew[] = {arg_list_or_dict_or_blob_or_string, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001051static argcheck_T arg25_matchadd[] = {arg_string, arg_string, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001052static argcheck_T arg25_matchaddpos[] = {arg_string, arg_list_any, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001053static 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 +00001054static argcheck_T arg23_reduce[] = {arg_string_list_or_blob, NULL, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001055static argcheck_T arg24_remote_expr[] = {arg_string, arg_string, arg_string, arg_number};
1056static argcheck_T arg23_remove[] = {arg_list_or_dict_or_blob, arg_remove2, arg_number};
1057static argcheck_T arg2_repeat[] = {arg_repeat1, arg_number};
Bram Moolenaar73199812021-12-26 17:18:14 +00001058static argcheck_T arg15_search[] = {arg_string, arg_string, arg_number, arg_number, arg_string_or_func};
1059static 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 +02001060static argcheck_T arg3_setbufline[] = {arg_buffer, arg_lnum, arg_str_or_nr_or_list};
1061static argcheck_T arg2_setline[] = {arg_lnum, NULL};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001062static argcheck_T arg24_setloclist[] = {arg_number, arg_list_any, arg_string, arg_dict_any};
1063static argcheck_T arg13_setqflist[] = {arg_list_any, arg_string, arg_dict_any};
1064static argcheck_T arg23_settagstack[] = {arg_number, arg_dict_any, arg_string};
1065static argcheck_T arg02_sign_getplaced[] = {arg_buffer, arg_dict_any};
1066static argcheck_T arg45_sign_place[] = {arg_number, arg_string, arg_string, arg_buffer, arg_dict_any};
1067static argcheck_T arg23_slice[] = {arg_slice1, arg_number, arg_number};
Bram Moolenaare843efc2022-02-22 21:54:44 +00001068static argcheck_T arg13_sortuniq[] = {arg_list_any, arg_sort_how, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001069static argcheck_T arg24_strpart[] = {arg_string, arg_number, arg_number, arg_bool};
1070static argcheck_T arg12_system[] = {arg_string, arg_str_or_nr_or_list};
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001071static argcheck_T arg23_win_execute[] = {arg_number, arg_string_or_list_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001072static argcheck_T arg23_writefile[] = {arg_list_or_blob, arg_string, arg_string};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001073static argcheck_T arg24_match_func[] = {arg_string_or_list_any, arg_string, arg_number, arg_number};
Bram Moolenaarcd268012021-07-22 19:11:08 +02001074
Bram Moolenaar94738d82020-10-21 14:25:07 +02001075
1076/*
1077 * Functions that return the return type of a builtin function.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001078 * Note that "argtypes" is NULL if "argcount" is zero.
Bram Moolenaar94738d82020-10-21 14:25:07 +02001079 */
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001080 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001081ret_void(int argcount UNUSED,
1082 type2_T *argtypes UNUSED,
1083 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001084{
1085 return &t_void;
1086}
1087 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001088ret_any(int argcount UNUSED,
1089 type2_T *argtypes UNUSED,
1090 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001091{
1092 return &t_any;
1093}
1094 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001095ret_bool(int argcount UNUSED,
1096 type2_T *argtypes UNUSED,
1097 type_T **decl_type UNUSED)
Bram Moolenaar403dc312020-10-17 19:29:51 +02001098{
1099 return &t_bool;
1100}
1101 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001102ret_number_bool(int argcount UNUSED,
1103 type2_T *argtypes UNUSED,
1104 type_T **decl_type UNUSED)
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001105{
1106 return &t_number_bool;
1107}
1108 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001109ret_number(int argcount UNUSED,
1110 type2_T *argtypes UNUSED,
1111 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001112{
1113 return &t_number;
1114}
1115 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001116ret_float(int argcount UNUSED,
1117 type2_T *argtypes UNUSED,
1118 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001119{
1120 return &t_float;
1121}
1122 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001123ret_string(int argcount UNUSED,
1124 type2_T *argtypes UNUSED,
1125 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001126{
1127 return &t_string;
1128}
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001129 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001130ret_list_any(int argcount UNUSED,
1131 type2_T *argtypes UNUSED,
1132 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001133{
1134 return &t_list_any;
1135}
1136 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001137ret_list_number(int argcount UNUSED,
1138 type2_T *argtypes UNUSED,
Bram Moolenaar81330182022-02-01 12:11:58 +00001139 type_T **decl_type)
1140{
Bram Moolenaar81330182022-02-01 12:11:58 +00001141 *decl_type = &t_list_any;
1142 return &t_list_number;
1143}
1144 static type_T *
1145ret_list_string(int argcount UNUSED,
1146 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001147 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001148{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001149 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001150 return &t_list_string;
1151}
1152 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001153ret_list_dict_any(int argcount UNUSED,
1154 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001155 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001156{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001157 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001158 return &t_list_dict_any;
1159}
1160 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001161ret_list_items(int argcount UNUSED,
1162 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001163 type_T **decl_type)
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001164{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001165 *decl_type = &t_list_any;
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001166 return &t_list_list_any;
1167}
mityu61065042021-07-19 20:07:21 +02001168
1169 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001170ret_list_string_items(int argcount UNUSED,
1171 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001172 type_T **decl_type)
mityu61065042021-07-19 20:07:21 +02001173{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001174 *decl_type = &t_list_any;
mityu61065042021-07-19 20:07:21 +02001175 return &t_list_list_string;
1176}
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001177 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001178ret_dict_any(int argcount UNUSED,
1179 type2_T *argtypes UNUSED,
1180 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001181{
1182 return &t_dict_any;
1183}
1184 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001185ret_job_info(int argcount,
1186 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001187 type_T **decl_type)
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001188{
1189 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001190 {
1191 *decl_type = &t_list_any;
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001192 return &t_list_job;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001193 }
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001194 return &t_dict_any;
1195}
1196 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001197ret_dict_number(int argcount UNUSED,
1198 type2_T *argtypes UNUSED,
1199 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001200{
1201 return &t_dict_number;
1202}
1203 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001204ret_dict_string(int argcount UNUSED,
1205 type2_T *argtypes UNUSED,
1206 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001207{
1208 return &t_dict_string;
1209}
1210 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001211ret_blob(int argcount UNUSED,
1212 type2_T *argtypes UNUSED,
1213 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001214{
1215 return &t_blob;
1216}
1217 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001218ret_func_any(int argcount UNUSED,
1219 type2_T *argtypes UNUSED,
1220 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001221{
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001222 return &t_func_any;
1223}
1224 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001225ret_func_unknown(int argcount UNUSED,
1226 type2_T *argtypes UNUSED,
1227 type_T **decl_type UNUSED)
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001228{
1229 return &t_func_unknown;
1230}
1231 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001232ret_channel(int argcount UNUSED,
1233 type2_T *argtypes UNUSED,
1234 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001235{
1236 return &t_channel;
1237}
1238 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001239ret_job(int argcount UNUSED,
1240 type2_T *argtypes UNUSED,
1241 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001242{
1243 return &t_job;
1244}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001245 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001246ret_first_arg(int argcount,
1247 type2_T *argtypes,
1248 type_T **decl_type)
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001249{
1250 if (argcount > 0)
Bram Moolenaar81330182022-02-01 12:11:58 +00001251 {
1252 *decl_type = argtypes[0].type_decl;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001253 return argtypes[0].type_curr;
Bram Moolenaar81330182022-02-01 12:11:58 +00001254 }
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001255 return &t_void;
1256}
Bram Moolenaar1780f082021-07-31 22:03:59 +02001257 static type_T *
Bram Moolenaar00eb9952022-02-05 19:23:18 +00001258ret_slice(int argcount,
1259 type2_T *argtypes,
1260 type_T **decl_type)
1261{
1262 if (argcount > 0)
1263 {
1264 if (argtypes[0].type_decl != NULL)
1265 {
1266 switch (argtypes[0].type_decl->tt_type)
1267 {
1268 case VAR_STRING: *decl_type = &t_string; break;
1269 case VAR_BLOB: *decl_type = &t_blob; break;
1270 case VAR_LIST: *decl_type = &t_list_any; break;
1271 default: break;
1272 }
1273 }
1274 return argtypes[0].type_curr;
1275 }
1276 return &t_void;
1277}
1278 static type_T *
Bram Moolenaar381692b2022-02-02 20:01:27 +00001279ret_copy(int argcount,
1280 type2_T *argtypes,
1281 type_T **decl_type)
1282{
1283 if (argcount > 0)
1284 {
1285 if (argtypes[0].type_decl != NULL)
1286 {
1287 if (argtypes[0].type_decl->tt_type == VAR_LIST)
1288 *decl_type = &t_list_any;
1289 else if (argtypes[0].type_decl->tt_type == VAR_DICT)
1290 *decl_type = &t_dict_any;
1291 else
1292 *decl_type = argtypes[0].type_decl;
1293 }
1294 if (argtypes[0].type_curr != NULL)
1295 {
1296 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1297 return &t_list_any;
1298 else if (argtypes[0].type_curr->tt_type == VAR_DICT)
1299 return &t_dict_any;
1300 }
1301 return argtypes[0].type_curr;
1302 }
1303 return &t_void;
1304}
1305 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001306ret_extend(int argcount,
1307 type2_T *argtypes,
1308 type_T **decl_type)
1309{
1310 if (argcount > 0)
1311 {
1312 *decl_type = argtypes[0].type_decl;
1313 // if the second argument has a different current type then the current
1314 // type is "any"
1315 if (argcount > 1 && !equal_type(argtypes[0].type_curr,
1316 argtypes[1].type_curr, 0))
1317 {
1318 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1319 return &t_list_any;
1320 if (argtypes[0].type_curr->tt_type == VAR_DICT)
1321 return &t_dict_any;
1322 }
1323 return argtypes[0].type_curr;
1324 }
1325 return &t_void;
1326}
1327 static type_T *
1328ret_repeat(int argcount,
1329 type2_T *argtypes,
1330 type_T **decl_type UNUSED)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001331{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001332 if (argcount == 0)
1333 return &t_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001334 if (argtypes[0].type_curr == &t_number)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001335 return &t_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001336 return argtypes[0].type_curr;
Bram Moolenaar1780f082021-07-31 22:03:59 +02001337}
Bram Moolenaarea696852020-11-09 18:31:39 +01001338// for map(): returns first argument but item type may differ
1339 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001340ret_first_cont(int argcount,
1341 type2_T *argtypes,
1342 type_T **decl_type UNUSED)
Bram Moolenaarea696852020-11-09 18:31:39 +01001343{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001344 if (argcount > 0)
1345 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001346 if (argtypes[0].type_curr->tt_type == VAR_LIST)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001347 return &t_list_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001348 if (argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001349 return &t_dict_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001350 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
1351 return argtypes[0].type_curr;
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001352 }
Bram Moolenaarea696852020-11-09 18:31:39 +01001353 return &t_any;
1354}
Bram Moolenaar078a4612022-01-04 15:17:03 +00001355// for getline()
1356 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001357ret_getline(int argcount,
1358 type2_T *argtypes UNUSED,
1359 type_T **decl_type UNUSED)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001360{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001361 if (argcount == 1)
1362 return &t_string;
1363 *decl_type = &t_list_any;
1364 return &t_list_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001365}
Bram Moolenaar08018222021-12-22 18:45:37 +00001366// for finddir()
1367 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001368ret_finddir(int argcount,
1369 type2_T *argtypes UNUSED,
1370 type_T **decl_type UNUSED)
Bram Moolenaar08018222021-12-22 18:45:37 +00001371{
1372 if (argcount < 3)
1373 return &t_string;
1374 // Depending on the count would be a string or a list of strings.
1375 return &t_any;
1376}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001377
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001378/*
1379 * Used for getqflist(): returns list if there is no argument, dict if there is
1380 * one.
1381 */
1382 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001383ret_list_or_dict_0(int argcount,
1384 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001385 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001386{
1387 if (argcount > 0)
1388 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001389 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001390 return &t_list_dict_any;
1391}
1392
1393/*
1394 * Used for getloclist(): returns list if there is one argument, dict if there
1395 * are two.
1396 */
1397 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001398ret_list_or_dict_1(int argcount,
1399 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001400 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001401{
1402 if (argcount > 1)
1403 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001404 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001405 return &t_list_dict_any;
1406}
1407
Bram Moolenaar846178a2020-07-05 17:04:13 +02001408 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001409ret_argv(int argcount,
1410 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001411 type_T **decl_type)
Bram Moolenaar846178a2020-07-05 17:04:13 +02001412{
1413 // argv() returns list of strings
1414 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001415 {
1416 *decl_type = &t_list_any;
Bram Moolenaar846178a2020-07-05 17:04:13 +02001417 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001418 }
Bram Moolenaar846178a2020-07-05 17:04:13 +02001419
1420 // argv(0) returns a string, but argv(-1] returns a list
1421 return &t_any;
1422}
1423
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001424 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001425ret_remove(int argcount,
1426 type2_T *argtypes,
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001427 type_T **decl_type)
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001428{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001429 if (argcount > 0)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001430 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001431 if (argtypes[0].type_curr->tt_type == VAR_LIST
1432 || argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaar81330182022-02-01 12:11:58 +00001433 {
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001434 if (argcount == 3)
1435 {
1436 *decl_type = argtypes[0].type_decl;
1437 return argtypes[0].type_curr;
1438 }
Bram Moolenaar81330182022-02-01 12:11:58 +00001439 if (argtypes[0].type_curr->tt_type
1440 == argtypes[0].type_decl->tt_type)
1441 *decl_type = argtypes[0].type_decl->tt_member;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001442 return argtypes[0].type_curr->tt_member;
Bram Moolenaar81330182022-02-01 12:11:58 +00001443 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001444 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001445 return &t_number;
1446 }
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001447 return &t_any;
1448}
1449
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001450 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001451ret_getreg(int argcount,
1452 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001453 type_T **decl_type)
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001454{
1455 // Assume that if the third argument is passed it's non-zero
1456 if (argcount == 3)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001457 {
1458 *decl_type = &t_list_any;
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001459 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001460 }
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001461 return &t_string;
1462}
1463
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001464 static type_T *
LemonBoy0f7a3e12022-05-26 12:10:37 +01001465ret_virtcol(int argcount,
1466 type2_T *argtypes UNUSED,
1467 type_T **decl_type)
1468{
1469 // Assume that if the second argument is passed it's non-zero
1470 if (argcount == 2)
1471 {
1472 *decl_type = &t_list_any;
1473 return &t_list_number;
1474 }
1475 return &t_number;
1476}
1477
1478 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001479ret_maparg(int argcount,
1480 type2_T *argtypes UNUSED,
1481 type_T **decl_type UNUSED)
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001482{
1483 // Assume that if the fourth argument is passed it's non-zero
1484 if (argcount == 4)
1485 return &t_dict_any;
1486 return &t_string;
1487}
1488
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001489/*
1490 * Array with names and number of arguments of all internal functions
1491 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
1492 */
Bram Moolenaarac92e252019-08-03 21:58:38 +02001493typedef struct
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001494{
Bram Moolenaar25e42232019-08-04 15:04:10 +02001495 char *f_name; // function name
1496 char f_min_argc; // minimal number of arguments
1497 char f_max_argc; // maximal number of arguments
1498 char f_argtype; // for method: FEARG_ values
Bram Moolenaar94738d82020-10-21 14:25:07 +02001499 argcheck_T *f_argcheck; // list of functions to check argument types
Bram Moolenaar81330182022-02-01 12:11:58 +00001500 type_T *(*f_retfunc)(int argcount, type2_T *argtypes,
1501 type_T **decl_type);
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001502 // return type function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001503 void (*f_func)(typval_T *args, typval_T *rvar);
Bram Moolenaar25e42232019-08-04 15:04:10 +02001504 // implementation of function
Bram Moolenaarac92e252019-08-03 21:58:38 +02001505} funcentry_T;
1506
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001507// values for f_argtype; zero means it cannot be used as a method
1508#define FEARG_1 1 // base is the first argument
1509#define FEARG_2 2 // base is the second argument
Bram Moolenaar24278d22019-08-16 21:49:22 +02001510#define FEARG_3 3 // base is the third argument
Bram Moolenaaraad222c2019-09-06 22:46:09 +02001511#define FEARG_4 4 // base is the fourth argument
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001512
Bram Moolenaar15c47602020-03-26 22:16:48 +01001513#ifdef FEAT_FLOAT
1514# define FLOAT_FUNC(name) name
1515#else
1516# define FLOAT_FUNC(name) NULL
1517#endif
1518#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
1519# define MATH_FUNC(name) name
1520#else
1521# define MATH_FUNC(name) NULL
1522#endif
1523#ifdef FEAT_TIMERS
1524# define TIMER_FUNC(name) name
1525#else
1526# define TIMER_FUNC(name) NULL
1527#endif
1528#ifdef FEAT_JOB_CHANNEL
1529# define JOB_FUNC(name) name
1530#else
1531# define JOB_FUNC(name) NULL
1532#endif
1533#ifdef FEAT_PROP_POPUP
1534# define PROP_FUNC(name) name
1535#else
1536# define PROP_FUNC(name) NULL
1537#endif
1538#ifdef FEAT_SIGNS
1539# define SIGN_FUNC(name) name
1540#else
1541# define SIGN_FUNC(name) NULL
1542#endif
1543#ifdef FEAT_SOUND
1544# define SOUND_FUNC(name) name
1545#else
1546# define SOUND_FUNC(name) NULL
1547#endif
1548#ifdef FEAT_TERMINAL
1549# define TERM_FUNC(name) name
1550#else
1551# define TERM_FUNC(name) NULL
1552#endif
1553
Bram Moolenaarac92e252019-08-03 21:58:38 +02001554static funcentry_T global_functions[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001555{
Bram Moolenaar94738d82020-10-21 14:25:07 +02001556 {"abs", 1, 1, FEARG_1, arg1_float_or_nr,
1557 ret_any, FLOAT_FUNC(f_abs)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001558 {"acos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001559 ret_float, FLOAT_FUNC(f_acos)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001560 {"add", 2, 2, FEARG_1, arg2_listblob_item,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001561 ret_first_arg, f_add},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001562 {"and", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001563 ret_number, f_and},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001564 {"append", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001565 ret_number_bool, f_append},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001566 {"appendbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001567 ret_number_bool, f_appendbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001568 {"argc", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001569 ret_number, f_argc},
1570 {"argidx", 0, 0, 0, NULL,
1571 ret_number, f_argidx},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001572 {"arglistid", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001573 ret_number, f_arglistid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001574 {"argv", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001575 ret_argv, f_argv},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001576 {"asin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001577 ret_float, FLOAT_FUNC(f_asin)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001578 {"assert_beeps", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001579 ret_number_bool, f_assert_beeps},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001580 {"assert_equal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001581 ret_number_bool, f_assert_equal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001582 {"assert_equalfile", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001583 ret_number_bool, f_assert_equalfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001584 {"assert_exception", 1, 2, 0, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001585 ret_number_bool, f_assert_exception},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001586 {"assert_fails", 1, 5, FEARG_1, arg15_assert_fails,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001587 ret_number_bool, f_assert_fails},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001588 {"assert_false", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001589 ret_number_bool, f_assert_false},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001590 {"assert_inrange", 3, 4, FEARG_3, arg34_assert_inrange,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001591 ret_number_bool, f_assert_inrange},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001592 {"assert_match", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001593 ret_number_bool, f_assert_match},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001594 {"assert_nobeep", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar5b8cabf2021-04-02 18:55:57 +02001595 ret_number_bool, f_assert_nobeep},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001596 {"assert_notequal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001597 ret_number_bool, f_assert_notequal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001598 {"assert_notmatch", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001599 ret_number_bool, f_assert_notmatch},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001600 {"assert_report", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001601 ret_number_bool, f_assert_report},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001602 {"assert_true", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001603 ret_number_bool, f_assert_true},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001604 {"atan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001605 ret_float, FLOAT_FUNC(f_atan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001606 {"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001607 ret_float, FLOAT_FUNC(f_atan2)},
Yegappan Lakshmanan1755a912022-05-19 10:31:47 +01001608 {"autocmd_add", 1, 1, FEARG_1, arg1_list_any,
1609 ret_number_bool, f_autocmd_add},
1610 {"autocmd_delete", 1, 1, FEARG_1, arg1_list_any,
1611 ret_number_bool, f_autocmd_delete},
1612 {"autocmd_get", 0, 1, FEARG_1, arg1_dict_any,
1613 ret_list_dict_any, f_autocmd_get},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001614 {"balloon_gettext", 0, 0, 0, NULL,
1615 ret_string,
Bram Moolenaar59716a22017-03-01 20:32:44 +01001616#ifdef FEAT_BEVAL
Bram Moolenaar15c47602020-03-26 22:16:48 +01001617 f_balloon_gettext
1618#else
1619 NULL
Bram Moolenaar59716a22017-03-01 20:32:44 +01001620#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001621 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001622 {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001623 ret_void,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001624#ifdef FEAT_BEVAL
1625 f_balloon_show
1626#else
1627 NULL
1628#endif
1629 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001630 {"balloon_split", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001631 ret_list_string,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001632#if defined(FEAT_BEVAL_TERM)
1633 f_balloon_split
1634#else
1635 NULL
1636#endif
1637 },
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001638 {"blob2list", 1, 1, FEARG_1, arg1_blob,
1639 ret_list_number, f_blob2list},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001640 {"browse", 4, 4, 0, arg4_browse,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001641 ret_string, f_browse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001642 {"browsedir", 2, 2, 0, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001643 ret_string, f_browsedir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001644 {"bufadd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001645 ret_number, f_bufadd},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001646 {"bufexists", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001647 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001648 {"buffer_exists", 1, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001649 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001650 {"buffer_name", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001651 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001652 {"buffer_number", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001653 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001654 {"buflisted", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001655 ret_number_bool, f_buflisted},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001656 {"bufload", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001657 ret_void, f_bufload},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001658 {"bufloaded", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001659 ret_number_bool, f_bufloaded},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001660 {"bufname", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001661 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001662 {"bufnr", 0, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001663 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001664 {"bufwinid", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001665 ret_number, f_bufwinid},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001666 {"bufwinnr", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001667 ret_number, f_bufwinnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001668 {"byte2line", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001669 ret_number, f_byte2line},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001670 {"byteidx", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001671 ret_number, f_byteidx},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001672 {"byteidxcomp", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001673 ret_number, f_byteidxcomp},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001674 {"call", 2, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001675 ret_any, f_call},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001676 {"ceil", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001677 ret_float, FLOAT_FUNC(f_ceil)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001678 {"ch_canread", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001679 ret_number_bool, JOB_FUNC(f_ch_canread)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001680 {"ch_close", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001681 ret_void, JOB_FUNC(f_ch_close)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001682 {"ch_close_in", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001683 ret_void, JOB_FUNC(f_ch_close_in)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001684 {"ch_evalexpr", 2, 3, FEARG_1, arg23_chanexpr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001685 ret_any, JOB_FUNC(f_ch_evalexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001686 {"ch_evalraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001687 ret_any, JOB_FUNC(f_ch_evalraw)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001688 {"ch_getbufnr", 2, 2, FEARG_1, arg2_chan_or_job_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001689 ret_number, JOB_FUNC(f_ch_getbufnr)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001690 {"ch_getjob", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001691 ret_job, JOB_FUNC(f_ch_getjob)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001692 {"ch_info", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001693 ret_dict_any, JOB_FUNC(f_ch_info)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001694 {"ch_log", 1, 2, FEARG_1, arg2_string_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001695 ret_void, JOB_FUNC(f_ch_log)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001696 {"ch_logfile", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001697 ret_void, JOB_FUNC(f_ch_logfile)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001698 {"ch_open", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001699 ret_channel, JOB_FUNC(f_ch_open)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001700 {"ch_read", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001701 ret_string, JOB_FUNC(f_ch_read)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001702 {"ch_readblob", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001703 ret_blob, JOB_FUNC(f_ch_readblob)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001704 {"ch_readraw", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001705 ret_string, JOB_FUNC(f_ch_readraw)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001706 {"ch_sendexpr", 2, 3, FEARG_1, arg23_chanexpr,
Yegappan Lakshmanan3b470ae2022-04-16 10:41:27 +01001707 ret_any, JOB_FUNC(f_ch_sendexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001708 {"ch_sendraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001709 ret_void, JOB_FUNC(f_ch_sendraw)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001710 {"ch_setoptions", 2, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001711 ret_void, JOB_FUNC(f_ch_setoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001712 {"ch_status", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001713 ret_string, JOB_FUNC(f_ch_status)},
1714 {"changenr", 0, 0, 0, NULL,
1715 ret_number, f_changenr},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001716 {"char2nr", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001717 ret_number, f_char2nr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001718 {"charclass", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001719 ret_number, f_charclass},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001720 {"charcol", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001721 ret_number, f_charcol},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001722 {"charidx", 2, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001723 ret_number, f_charidx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001724 {"chdir", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001725 ret_string, f_chdir},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001726 {"cindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001727 ret_number, f_cindent},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001728 {"clearmatches", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001729 ret_void, f_clearmatches},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001730 {"col", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001731 ret_number, f_col},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001732 {"complete", 2, 2, FEARG_2, arg2_number_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001733 ret_void, f_complete},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001734 {"complete_add", 1, 1, FEARG_1, arg1_dict_or_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001735 ret_number, f_complete_add},
1736 {"complete_check", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001737 ret_number_bool, f_complete_check},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001738 {"complete_info", 0, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001739 ret_dict_any, f_complete_info},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001740 {"confirm", 1, 4, FEARG_1, arg4_string_string_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001741 ret_number, f_confirm},
1742 {"copy", 1, 1, FEARG_1, NULL,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001743 ret_copy, f_copy},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001744 {"cos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001745 ret_float, FLOAT_FUNC(f_cos)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001746 {"cosh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001747 ret_float, FLOAT_FUNC(f_cosh)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001748 {"count", 2, 4, FEARG_1, arg24_count,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001749 ret_number, f_count},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001750 {"cscope_connection",0,3, 0, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001751 ret_number, f_cscope_connection},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001752 {"cursor", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001753 ret_number, f_cursor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001754 {"debugbreak", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001755 ret_number,
Bram Moolenaar4f974752019-02-17 17:44:42 +01001756#ifdef MSWIN
Bram Moolenaar15c47602020-03-26 22:16:48 +01001757 f_debugbreak
1758#else
1759 NULL
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02001760#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001761 },
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001762 {"deepcopy", 1, 2, FEARG_1, arg12_deepcopy,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001763 ret_copy, f_deepcopy},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001764 {"delete", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001765 ret_number_bool, f_delete},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001766 {"deletebufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001767 ret_number_bool, f_deletebufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001768 {"did_filetype", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001769 ret_number_bool, f_did_filetype},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001770 {"diff_filler", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001771 ret_number, f_diff_filler},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001772 {"diff_hlID", 2, 2, FEARG_1, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001773 ret_number, f_diff_hlID},
h-east29b85712021-07-26 21:54:04 +02001774 {"digraph_get", 1, 1, FEARG_1, arg1_string,
1775 ret_string, f_digraph_get},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001776 {"digraph_getlist",0, 1, FEARG_1, arg1_bool,
h-east29b85712021-07-26 21:54:04 +02001777 ret_list_string_items, f_digraph_getlist},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001778 {"digraph_set", 2, 2, FEARG_1, arg2_string,
h-east29b85712021-07-26 21:54:04 +02001779 ret_bool, f_digraph_set},
1780 {"digraph_setlist",1, 1, FEARG_1, arg1_list_string,
1781 ret_bool, f_digraph_setlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001782 {"echoraw", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001783 ret_void, f_echoraw},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001784 {"empty", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001785 ret_number_bool, f_empty},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001786 {"environ", 0, 0, 0, NULL,
1787 ret_dict_string, f_environ},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001788 {"escape", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001789 ret_string, f_escape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001790 {"eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001791 ret_any, f_eval},
1792 {"eventhandler", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001793 ret_number_bool, f_eventhandler},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001794 {"executable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001795 ret_number, f_executable},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001796 {"execute", 1, 2, FEARG_1, arg12_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001797 ret_string, f_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001798 {"exepath", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001799 ret_string, f_exepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001800 {"exists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001801 ret_number_bool, f_exists},
Bram Moolenaar26735992021-08-08 14:43:22 +02001802 {"exists_compiled", 1, 1, FEARG_1, arg1_string,
1803 ret_number_bool, f_exists_compiled},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001804 {"exp", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001805 ret_float, FLOAT_FUNC(f_exp)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001806 {"expand", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001807 ret_any, f_expand},
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01001808 {"expandcmd", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001809 ret_string, f_expandcmd},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +01001810 {"extend", 2, 3, FEARG_1, arg23_extend,
Bram Moolenaar81330182022-02-01 12:11:58 +00001811 ret_extend, f_extend},
Bram Moolenaarb0e6b512021-01-12 20:23:40 +01001812 {"extendnew", 2, 3, FEARG_1, arg23_extendnew,
1813 ret_first_cont, f_extendnew},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001814 {"feedkeys", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001815 ret_void, f_feedkeys},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001816 {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001817 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001818 {"filereadable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001819 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001820 {"filewritable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001821 ret_number, f_filewritable},
Bram Moolenaar18024052021-12-25 21:43:28 +00001822 {"filter", 2, 2, FEARG_1, arg2_filter,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001823 ret_first_arg, f_filter},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001824 {"finddir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar08018222021-12-22 18:45:37 +00001825 ret_finddir, f_finddir},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001826 {"findfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar10c83dd2021-09-04 14:49:56 +02001827 ret_any, f_findfile},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001828 {"flatten", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001829 ret_list_any, f_flatten},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001830 {"flattennew", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3b690062021-02-01 20:14:51 +01001831 ret_list_any, f_flattennew},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001832 {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001833 ret_number, FLOAT_FUNC(f_float2nr)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001834 {"floor", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001835 ret_float, FLOAT_FUNC(f_floor)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001836 {"fmod", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001837 ret_float, FLOAT_FUNC(f_fmod)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001838 {"fnameescape", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001839 ret_string, f_fnameescape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001840 {"fnamemodify", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001841 ret_string, f_fnamemodify},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001842 {"foldclosed", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001843 ret_number, f_foldclosed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001844 {"foldclosedend", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001845 ret_number, f_foldclosedend},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001846 {"foldlevel", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001847 ret_number, f_foldlevel},
1848 {"foldtext", 0, 0, 0, NULL,
1849 ret_string, f_foldtext},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001850 {"foldtextresult", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001851 ret_string, f_foldtextresult},
1852 {"foreground", 0, 0, 0, NULL,
1853 ret_void, f_foreground},
Bram Moolenaar038e09e2021-02-06 12:38:51 +01001854 {"fullcommand", 1, 1, FEARG_1, arg1_string,
1855 ret_string, f_fullcommand},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001856 {"funcref", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001857 ret_func_unknown, f_funcref},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001858 {"function", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001859 ret_func_unknown, f_function},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001860 {"garbagecollect", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001861 ret_void, f_garbagecollect},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001862 {"get", 2, 3, FEARG_1, arg23_get,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001863 ret_any, f_get},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001864 {"getbufinfo", 0, 1, FEARG_1, arg1_buffer_or_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001865 ret_list_dict_any, f_getbufinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001866 {"getbufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001867 ret_list_string, f_getbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001868 {"getbufvar", 2, 3, FEARG_1, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001869 ret_any, f_getbufvar},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001870 {"getchangelist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001871 ret_list_any, f_getchangelist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001872 {"getchar", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001873 ret_any, f_getchar},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001874 {"getcharmod", 0, 0, 0, NULL,
1875 ret_number, f_getcharmod},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001876 {"getcharpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001877 ret_list_number, f_getcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001878 {"getcharsearch", 0, 0, 0, NULL,
1879 ret_dict_any, f_getcharsearch},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001880 {"getcharstr", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001881 ret_string, f_getcharstr},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01001882 {"getcmdcompltype", 0, 0, 0, NULL,
1883 ret_string, f_getcmdcompltype},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001884 {"getcmdline", 0, 0, 0, NULL,
1885 ret_string, f_getcmdline},
1886 {"getcmdpos", 0, 0, 0, NULL,
1887 ret_number, f_getcmdpos},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01001888 {"getcmdscreenpos", 0, 0, 0, NULL,
1889 ret_number, f_getcmdscreenpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001890 {"getcmdtype", 0, 0, 0, NULL,
1891 ret_string, f_getcmdtype},
1892 {"getcmdwintype", 0, 0, 0, NULL,
1893 ret_string, f_getcmdwintype},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001894 {"getcompletion", 2, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001895 ret_list_string, f_getcompletion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001896 {"getcurpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001897 ret_list_number, f_getcurpos},
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001898 {"getcursorcharpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001899 ret_list_number, f_getcursorcharpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001900 {"getcwd", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001901 ret_string, f_getcwd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001902 {"getenv", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar7ad67d12021-03-10 16:08:26 +01001903 ret_any, f_getenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001904 {"getfontname", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001905 ret_string, f_getfontname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001906 {"getfperm", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001907 ret_string, f_getfperm},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001908 {"getfsize", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001909 ret_number, f_getfsize},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001910 {"getftime", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001911 ret_number, f_getftime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001912 {"getftype", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001913 ret_string, f_getftype},
1914 {"getimstatus", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001915 ret_number_bool, f_getimstatus},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001916 {"getjumplist", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001917 ret_list_any, f_getjumplist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001918 {"getline", 1, 2, FEARG_1, arg2_lnum,
Bram Moolenaar078a4612022-01-04 15:17:03 +00001919 ret_getline, f_getline},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001920 {"getloclist", 1, 2, 0, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001921 ret_list_or_dict_1, f_getloclist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001922 {"getmarklist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001923 ret_list_dict_any, f_getmarklist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001924 {"getmatches", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001925 ret_list_dict_any, f_getmatches},
1926 {"getmousepos", 0, 0, 0, NULL,
1927 ret_dict_number, f_getmousepos},
1928 {"getpid", 0, 0, 0, NULL,
1929 ret_number, f_getpid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001930 {"getpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001931 ret_list_number, f_getpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001932 {"getqflist", 0, 1, 0, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001933 ret_list_or_dict_0, f_getqflist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001934 {"getreg", 0, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001935 ret_getreg, f_getreg},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001936 {"getreginfo", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001937 ret_dict_any, f_getreginfo},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001938 {"getregtype", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001939 ret_string, f_getregtype},
Yegappan Lakshmanan520f6ef2022-08-25 17:40:40 +01001940 {"getscriptinfo", 0, 1, 0, arg1_dict_any,
Yegappan Lakshmananf768c3d2022-08-22 13:15:13 +01001941 ret_list_dict_any, f_getscriptinfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001942 {"gettabinfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001943 ret_list_dict_any, f_gettabinfo},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001944 {"gettabvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001945 ret_any, f_gettabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001946 {"gettabwinvar", 3, 4, FEARG_1, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001947 ret_any, f_gettabwinvar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001948 {"gettagstack", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001949 ret_dict_any, f_gettagstack},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001950 {"gettext", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001951 ret_string, f_gettext},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001952 {"getwininfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001953 ret_list_dict_any, f_getwininfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001954 {"getwinpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001955 ret_list_number, f_getwinpos},
1956 {"getwinposx", 0, 0, 0, NULL,
1957 ret_number, f_getwinposx},
1958 {"getwinposy", 0, 0, 0, NULL,
1959 ret_number, f_getwinposy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001960 {"getwinvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001961 ret_any, f_getwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001962 {"glob", 1, 4, FEARG_1, arg14_glob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001963 ret_any, f_glob},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001964 {"glob2regpat", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001965 ret_string, f_glob2regpat},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001966 {"globpath", 2, 5, FEARG_2, arg25_globpath,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001967 ret_any, f_globpath},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001968 {"has", 1, 2, 0, arg2_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001969 ret_number_bool, f_has},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001970 {"has_key", 2, 2, FEARG_1, arg2_dict_any_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001971 ret_number_bool, f_has_key},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001972 {"haslocaldir", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001973 ret_number, f_haslocaldir},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001974 {"hasmapto", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001975 ret_number_bool, f_hasmapto},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001976 {"highlightID", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001977 ret_number, f_hlID},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001978 {"highlight_exists",1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001979 ret_number_bool, f_hlexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001980 {"histadd", 2, 2, FEARG_2, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001981 ret_number_bool, f_histadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001982 {"histdel", 1, 2, FEARG_1, arg2_string_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001983 ret_number_bool, f_histdel},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001984 {"histget", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001985 ret_string, f_histget},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001986 {"histnr", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001987 ret_number, f_histnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001988 {"hlID", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001989 ret_number, f_hlID},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001990 {"hlexists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001991 ret_number_bool, f_hlexists},
Yegappan Lakshmanand1a8d652021-11-03 21:56:45 +00001992 {"hlget", 0, 2, FEARG_1, arg2_string_bool,
1993 ret_list_dict_any, f_hlget},
1994 {"hlset", 1, 1, FEARG_1, arg1_list_any,
1995 ret_number_bool, f_hlset},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001996 {"hostname", 0, 0, 0, NULL,
1997 ret_string, f_hostname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001998 {"iconv", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001999 ret_string, f_iconv},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002000 {"indent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002001 ret_number, f_indent},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002002 {"index", 2, 4, FEARG_1, arg24_index,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002003 ret_number, f_index},
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01002004 {"indexof", 2, 3, FEARG_1, arg23_index,
2005 ret_number, f_indexof},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002006 {"input", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002007 ret_string, f_input},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002008 {"inputdialog", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002009 ret_string, f_inputdialog},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002010 {"inputlist", 1, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002011 ret_number, f_inputlist},
2012 {"inputrestore", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002013 ret_number_bool, f_inputrestore},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002014 {"inputsave", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002015 ret_number_bool, f_inputsave},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002016 {"inputsecret", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002017 ret_string, f_inputsecret},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002018 {"insert", 2, 3, FEARG_1, arg23_insert,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002019 ret_first_arg, f_insert},
2020 {"interrupt", 0, 0, 0, NULL,
2021 ret_void, f_interrupt},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002022 {"invert", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002023 ret_number, f_invert},
LemonBoydca1d402022-04-28 15:26:33 +01002024 {"isabsolutepath", 1, 1, FEARG_1, arg1_string,
2025 ret_number_bool, f_isabsolutepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002026 {"isdirectory", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002027 ret_number_bool, f_isdirectory},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002028 {"isinf", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002029 ret_number, MATH_FUNC(f_isinf)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002030 {"islocked", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002031 ret_number_bool, f_islocked},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002032 {"isnan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002033 ret_number_bool, MATH_FUNC(f_isnan)},
Bram Moolenaar3e518a82022-08-30 17:45:33 +01002034 {"items", 1, 1, FEARG_1, arg1_string_or_list_or_dict,
Bram Moolenaarefc5db52021-07-07 21:21:30 +02002035 ret_list_items, f_items},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002036 {"job_getchannel", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002037 ret_channel, JOB_FUNC(f_job_getchannel)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002038 {"job_info", 0, 1, FEARG_1, arg1_job,
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01002039 ret_job_info, JOB_FUNC(f_job_info)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002040 {"job_setoptions", 2, 2, FEARG_1, arg2_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002041 ret_void, JOB_FUNC(f_job_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002042 {"job_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002043 ret_job, JOB_FUNC(f_job_start)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002044 {"job_status", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002045 ret_string, JOB_FUNC(f_job_status)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002046 {"job_stop", 1, 2, FEARG_1, arg2_job_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002047 ret_number_bool, JOB_FUNC(f_job_stop)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002048 {"join", 1, 2, FEARG_1, arg2_list_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002049 ret_string, f_join},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002050 {"js_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002051 ret_any, f_js_decode},
2052 {"js_encode", 1, 1, FEARG_1, NULL,
2053 ret_string, f_js_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002054 {"json_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002055 ret_any, f_json_decode},
2056 {"json_encode", 1, 1, FEARG_1, NULL,
2057 ret_string, f_json_encode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002058 {"keys", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002059 ret_list_string, f_keys},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002060 {"last_buffer_nr", 0, 0, 0, NULL, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02002061 ret_number, f_last_buffer_nr},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002062 {"len", 1, 1, FEARG_1, arg1_len,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002063 ret_number, f_len},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002064 {"libcall", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002065 ret_string, f_libcall},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002066 {"libcallnr", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002067 ret_number, f_libcallnr},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002068 {"line", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002069 ret_number, f_line},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002070 {"line2byte", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002071 ret_number, f_line2byte},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002072 {"lispindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002073 ret_number, f_lispindent},
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02002074 {"list2blob", 1, 1, FEARG_1, arg1_list_number,
2075 ret_blob, f_list2blob},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002076 {"list2str", 1, 2, FEARG_1, arg2_list_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002077 ret_string, f_list2str},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002078 {"listener_add", 1, 2, FEARG_2, arg2_any_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002079 ret_number, f_listener_add},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002080 {"listener_flush", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002081 ret_void, f_listener_flush},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002082 {"listener_remove", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002083 ret_number_bool, f_listener_remove},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002084 {"localtime", 0, 0, 0, NULL,
2085 ret_number, f_localtime},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002086 {"log", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002087 ret_float, FLOAT_FUNC(f_log)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002088 {"log10", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002089 ret_float, FLOAT_FUNC(f_log10)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002090 {"luaeval", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002091 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002092#ifdef FEAT_LUA
Bram Moolenaar15c47602020-03-26 22:16:48 +01002093 f_luaeval
2094#else
2095 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002096#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002097 },
Bram Moolenaar18024052021-12-25 21:43:28 +00002098 {"map", 2, 2, FEARG_1, arg2_map,
Bram Moolenaarea696852020-11-09 18:31:39 +01002099 ret_first_cont, f_map},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002100 {"maparg", 1, 4, FEARG_1, arg14_maparg,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002101 ret_maparg, f_maparg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002102 {"mapcheck", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002103 ret_string, f_mapcheck},
Ernie Rael09661202022-04-25 14:40:44 +01002104 {"maplist", 0, 1, 0, arg1_bool,
2105 ret_list_dict_any, f_maplist},
Bram Moolenaar18024052021-12-25 21:43:28 +00002106 {"mapnew", 2, 2, FEARG_1, arg2_mapnew,
Bram Moolenaarea696852020-11-09 18:31:39 +01002107 ret_first_cont, f_mapnew},
Ernie Rael51d04d12022-05-04 15:40:22 +01002108 {"mapset", 1, 3, FEARG_1, arg3_string_or_dict_bool_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002109 ret_void, f_mapset},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002110 {"match", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002111 ret_any, f_match},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002112 {"matchadd", 2, 5, FEARG_1, arg25_matchadd,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002113 ret_number, f_matchadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002114 {"matchaddpos", 2, 5, FEARG_1, arg25_matchaddpos,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002115 ret_number, f_matchaddpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002116 {"matcharg", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002117 ret_list_string, f_matcharg},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002118 {"matchdelete", 1, 2, FEARG_1, arg2_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002119 ret_number_bool, f_matchdelete},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002120 {"matchend", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002121 ret_number, f_matchend},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002122 {"matchfuzzy", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002123 ret_list_string, f_matchfuzzy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002124 {"matchfuzzypos", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002125 ret_list_any, f_matchfuzzypos},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002126 {"matchlist", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002127 ret_list_string, f_matchlist},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002128 {"matchstr", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002129 ret_string, f_matchstr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002130 {"matchstrpos", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002131 ret_list_any, f_matchstrpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002132 {"max", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002133 ret_number, f_max},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002134 {"menu_info", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002135 ret_dict_any,
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002136#ifdef FEAT_MENU
Bram Moolenaar15c47602020-03-26 22:16:48 +01002137 f_menu_info
2138#else
2139 NULL
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002140#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002141 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002142 {"min", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002143 ret_number, f_min},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002144 {"mkdir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002145 ret_number_bool, f_mkdir},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002146 {"mode", 0, 1, FEARG_1, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002147 ret_string, f_mode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002148 {"mzeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002149 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002150#ifdef FEAT_MZSCHEME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002151 f_mzeval
2152#else
2153 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002154#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002155 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002156 {"nextnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002157 ret_number, f_nextnonblank},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002158 {"nr2char", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002159 ret_string, f_nr2char},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002160 {"or", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002161 ret_number, f_or},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002162 {"pathshorten", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002163 ret_string, f_pathshorten},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002164 {"perleval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002165 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002166#ifdef FEAT_PERL
Bram Moolenaar15c47602020-03-26 22:16:48 +01002167 f_perleval
2168#else
2169 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002170#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002171 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002172 {"popup_atcursor", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002173 ret_number, PROP_FUNC(f_popup_atcursor)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002174 {"popup_beval", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002175 ret_number, PROP_FUNC(f_popup_beval)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002176 {"popup_clear", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002177 ret_void, PROP_FUNC(f_popup_clear)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002178 {"popup_close", 1, 2, FEARG_1, arg2_number_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002179 ret_void, PROP_FUNC(f_popup_close)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002180 {"popup_create", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002181 ret_number, PROP_FUNC(f_popup_create)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002182 {"popup_dialog", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002183 ret_number, PROP_FUNC(f_popup_dialog)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002184 {"popup_filter_menu", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002185 ret_bool, PROP_FUNC(f_popup_filter_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002186 {"popup_filter_yesno", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002187 ret_bool, PROP_FUNC(f_popup_filter_yesno)},
2188 {"popup_findinfo", 0, 0, 0, NULL,
2189 ret_number, PROP_FUNC(f_popup_findinfo)},
2190 {"popup_findpreview", 0, 0, 0, NULL,
2191 ret_number, PROP_FUNC(f_popup_findpreview)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002192 {"popup_getoptions", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002193 ret_dict_any, PROP_FUNC(f_popup_getoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002194 {"popup_getpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002195 ret_dict_any, PROP_FUNC(f_popup_getpos)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002196 {"popup_hide", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002197 ret_void, PROP_FUNC(f_popup_hide)},
2198 {"popup_list", 0, 0, 0, NULL,
2199 ret_list_number, PROP_FUNC(f_popup_list)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002200 {"popup_locate", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002201 ret_number, PROP_FUNC(f_popup_locate)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002202 {"popup_menu", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002203 ret_number, PROP_FUNC(f_popup_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002204 {"popup_move", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002205 ret_void, PROP_FUNC(f_popup_move)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002206 {"popup_notification", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002207 ret_number, PROP_FUNC(f_popup_notification)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002208 {"popup_setoptions", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002209 ret_void, PROP_FUNC(f_popup_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002210 {"popup_settext", 2, 2, FEARG_1, arg2_number_string_or_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002211 ret_void, PROP_FUNC(f_popup_settext)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002212 {"popup_show", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002213 ret_void, PROP_FUNC(f_popup_show)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002214 {"pow", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002215 ret_float, FLOAT_FUNC(f_pow)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002216 {"prevnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002217 ret_number, f_prevnonblank},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002218 {"printf", 1, 19, FEARG_2, arg119_printf,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002219 ret_string, f_printf},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002220 {"prompt_getprompt", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002221 ret_string, JOB_FUNC(f_prompt_getprompt)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002222 {"prompt_setcallback", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002223 ret_void, JOB_FUNC(f_prompt_setcallback)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002224 {"prompt_setinterrupt", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002225 ret_void, JOB_FUNC(f_prompt_setinterrupt)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002226 {"prompt_setprompt", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002227 ret_void, JOB_FUNC(f_prompt_setprompt)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002228 {"prop_add", 3, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01002229 ret_number, PROP_FUNC(f_prop_add)},
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02002230 {"prop_add_list", 2, 2, FEARG_1, arg2_dict_any_list_any,
2231 ret_void, PROP_FUNC(f_prop_add_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002232 {"prop_clear", 1, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002233 ret_void, PROP_FUNC(f_prop_clear)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002234 {"prop_find", 1, 2, FEARG_1, arg2_dict_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002235 ret_dict_any, PROP_FUNC(f_prop_find)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002236 {"prop_list", 1, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002237 ret_list_dict_any, PROP_FUNC(f_prop_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002238 {"prop_remove", 1, 3, FEARG_1, arg3_dict_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002239 ret_number, PROP_FUNC(f_prop_remove)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002240 {"prop_type_add", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002241 ret_void, PROP_FUNC(f_prop_type_add)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002242 {"prop_type_change", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002243 ret_void, PROP_FUNC(f_prop_type_change)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002244 {"prop_type_delete", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002245 ret_void, PROP_FUNC(f_prop_type_delete)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002246 {"prop_type_get", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002247 ret_dict_any, PROP_FUNC(f_prop_type_get)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002248 {"prop_type_list", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002249 ret_list_string, PROP_FUNC(f_prop_type_list)},
2250 {"pum_getpos", 0, 0, 0, NULL,
2251 ret_dict_number, f_pum_getpos},
2252 {"pumvisible", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002253 ret_number_bool, f_pumvisible},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002254 {"py3eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002255 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002256#ifdef FEAT_PYTHON3
Bram Moolenaar15c47602020-03-26 22:16:48 +01002257 f_py3eval
2258#else
2259 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002260#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002261 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002262 {"pyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002263 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002264#ifdef FEAT_PYTHON
Bram Moolenaar15c47602020-03-26 22:16:48 +01002265 f_pyeval
2266#else
2267 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002268#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002269 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002270 {"pyxeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002271 ret_any,
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002272#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar15c47602020-03-26 22:16:48 +01002273 f_pyxeval
2274#else
2275 NULL
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002276#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002277 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002278 {"rand", 0, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002279 ret_number, f_rand},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002280 {"range", 1, 3, FEARG_1, arg3_number,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00002281 ret_list_number, f_range},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002282 {"readblob", 1, 1, FEARG_1, arg1_string,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002283 ret_blob, f_readblob},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002284 {"readdir", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002285 ret_list_string, f_readdir},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002286 {"readdirex", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002287 ret_list_dict_any, f_readdirex},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002288 {"readfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002289 ret_list_string, f_readfile},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002290 {"reduce", 2, 3, FEARG_1, arg23_reduce,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002291 ret_any, f_reduce},
2292 {"reg_executing", 0, 0, 0, NULL,
2293 ret_string, f_reg_executing},
2294 {"reg_recording", 0, 0, 0, NULL,
2295 ret_string, f_reg_recording},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002296 {"reltime", 0, 2, FEARG_1, arg2_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002297 ret_list_any, f_reltime},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002298 {"reltimefloat", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002299 ret_float, FLOAT_FUNC(f_reltimefloat)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002300 {"reltimestr", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002301 ret_string, f_reltimestr},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002302 {"remote_expr", 2, 4, FEARG_1, arg24_remote_expr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002303 ret_string, f_remote_expr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002304 {"remote_foreground", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002305 ret_string, f_remote_foreground},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002306 {"remote_peek", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002307 ret_number, f_remote_peek},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002308 {"remote_read", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002309 ret_string, f_remote_read},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002310 {"remote_send", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002311 ret_string, f_remote_send},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002312 {"remote_startserver", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002313 ret_void, f_remote_startserver},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002314 {"remove", 2, 3, FEARG_1, arg23_remove,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002315 ret_remove, f_remove},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002316 {"rename", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002317 ret_number_bool, f_rename},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002318 {"repeat", 2, 2, FEARG_1, arg2_repeat,
Bram Moolenaar1780f082021-07-31 22:03:59 +02002319 ret_repeat, f_repeat},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002320 {"resolve", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002321 ret_string, f_resolve},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002322 {"reverse", 1, 1, FEARG_1, arg1_list_or_blob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002323 ret_first_arg, f_reverse},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002324 {"round", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002325 ret_float, FLOAT_FUNC(f_round)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002326 {"rubyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002327 ret_any,
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002328#ifdef FEAT_RUBY
Bram Moolenaar15c47602020-03-26 22:16:48 +01002329 f_rubyeval
2330#else
2331 NULL
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002332#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002333 },
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002334 {"screenattr", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002335 ret_number, f_screenattr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002336 {"screenchar", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002337 ret_number, f_screenchar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002338 {"screenchars", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002339 ret_list_number, f_screenchars},
2340 {"screencol", 0, 0, 0, NULL,
2341 ret_number, f_screencol},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002342 {"screenpos", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002343 ret_dict_number, f_screenpos},
2344 {"screenrow", 0, 0, 0, NULL,
2345 ret_number, f_screenrow},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002346 {"screenstring", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002347 ret_string, f_screenstring},
Bram Moolenaarcd268012021-07-22 19:11:08 +02002348 {"search", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002349 ret_number, f_search},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002350 {"searchcount", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002351 ret_dict_any, f_searchcount},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002352 {"searchdecl", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002353 ret_number_bool, f_searchdecl},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002354 {"searchpair", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002355 ret_number, f_searchpair},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002356 {"searchpairpos", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002357 ret_list_number, f_searchpairpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002358 {"searchpos", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002359 ret_list_number, f_searchpos},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002360 {"server2client", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002361 ret_number_bool, f_server2client},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002362 {"serverlist", 0, 0, 0, NULL,
2363 ret_string, f_serverlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002364 {"setbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002365 ret_number_bool, f_setbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002366 {"setbufvar", 3, 3, FEARG_3, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002367 ret_void, f_setbufvar},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002368 {"setcellwidths", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002369 ret_void, f_setcellwidths},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002370 {"setcharpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002371 ret_number_bool, f_setcharpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002372 {"setcharsearch", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002373 ret_void, f_setcharsearch},
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01002374 {"setcmdline", 1, 2, FEARG_1, arg2_string_number,
2375 ret_number_bool, f_setcmdline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002376 {"setcmdpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002377 ret_number_bool, f_setcmdpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002378 {"setcursorcharpos", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002379 ret_number_bool, f_setcursorcharpos},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002380 {"setenv", 2, 2, FEARG_2, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002381 ret_void, f_setenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002382 {"setfperm", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002383 ret_number_bool, f_setfperm},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002384 {"setline", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002385 ret_number_bool, f_setline},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002386 {"setloclist", 2, 4, FEARG_2, arg24_setloclist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002387 ret_number_bool, f_setloclist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002388 {"setmatches", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002389 ret_number_bool, f_setmatches},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002390 {"setpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002391 ret_number_bool, f_setpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002392 {"setqflist", 1, 3, FEARG_1, arg13_setqflist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002393 ret_number_bool, f_setqflist},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002394 {"setreg", 2, 3, FEARG_2, arg3_string_any_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002395 ret_number_bool, f_setreg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002396 {"settabvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002397 ret_void, f_settabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002398 {"settabwinvar", 4, 4, FEARG_4, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002399 ret_void, f_settabwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002400 {"settagstack", 2, 3, FEARG_2, arg23_settagstack,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002401 ret_number_bool, f_settagstack},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002402 {"setwinvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002403 ret_void, f_setwinvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002404 {"sha256", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002405 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002406#ifdef FEAT_CRYPT
Bram Moolenaar15c47602020-03-26 22:16:48 +01002407 f_sha256
2408#else
2409 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002410#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002411 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002412 {"shellescape", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002413 ret_string, f_shellescape},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002414 {"shiftwidth", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002415 ret_number, f_shiftwidth},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002416 {"sign_define", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002417 ret_any, SIGN_FUNC(f_sign_define)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002418 {"sign_getdefined", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002419 ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002420 {"sign_getplaced", 0, 2, FEARG_1, arg02_sign_getplaced,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002421 ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002422 {"sign_jump", 3, 3, FEARG_1, arg3_number_string_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002423 ret_number, SIGN_FUNC(f_sign_jump)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002424 {"sign_place", 4, 5, FEARG_1, arg45_sign_place,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002425 ret_number, SIGN_FUNC(f_sign_place)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002426 {"sign_placelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002427 ret_list_number, SIGN_FUNC(f_sign_placelist)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002428 {"sign_undefine", 0, 1, FEARG_1, arg1_string_or_list_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002429 ret_number_bool, SIGN_FUNC(f_sign_undefine)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002430 {"sign_unplace", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002431 ret_number_bool, SIGN_FUNC(f_sign_unplace)},
Sean Dewara63780b2021-11-03 13:15:47 +00002432 {"sign_unplacelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002433 ret_list_number, SIGN_FUNC(f_sign_unplacelist)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002434 {"simplify", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002435 ret_string, f_simplify},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002436 {"sin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002437 ret_float, FLOAT_FUNC(f_sin)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002438 {"sinh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002439 ret_float, FLOAT_FUNC(f_sinh)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002440 {"slice", 2, 3, FEARG_1, arg23_slice,
Bram Moolenaar00eb9952022-02-05 19:23:18 +00002441 ret_slice, f_slice},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002442 {"sort", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002443 ret_first_arg, f_sort},
2444 {"sound_clear", 0, 0, 0, NULL,
2445 ret_void, SOUND_FUNC(f_sound_clear)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002446 {"sound_playevent", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002447 ret_number, SOUND_FUNC(f_sound_playevent)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002448 {"sound_playfile", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002449 ret_number, SOUND_FUNC(f_sound_playfile)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002450 {"sound_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002451 ret_void, SOUND_FUNC(f_sound_stop)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002452 {"soundfold", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002453 ret_string, f_soundfold},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002454 {"spellbadword", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002455 ret_list_string, f_spellbadword},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002456 {"spellsuggest", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002457 ret_list_string, f_spellsuggest},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002458 {"split", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002459 ret_list_string, f_split},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002460 {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002461 ret_float, FLOAT_FUNC(f_sqrt)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002462 {"srand", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002463 ret_list_number, f_srand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002464 {"state", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002465 ret_string, f_state},
Bram Moolenaar80a070c2021-08-08 15:51:10 +02002466 {"str2float", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002467 ret_float, FLOAT_FUNC(f_str2float)},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002468 {"str2list", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002469 ret_list_number, f_str2list},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002470 {"str2nr", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002471 ret_number, f_str2nr},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002472 {"strcharlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01002473 ret_number, f_strcharlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002474 {"strcharpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002475 ret_string, f_strcharpart},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002476 {"strchars", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002477 ret_number, f_strchars},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002478 {"strdisplaywidth", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002479 ret_number, f_strdisplaywidth},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002480 {"strftime", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002481 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002482#ifdef HAVE_STRFTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002483 f_strftime
2484#else
2485 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002486#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002487 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002488 {"strgetchar", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002489 ret_number, f_strgetchar},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002490 {"stridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002491 ret_number, f_stridx},
2492 {"string", 1, 1, FEARG_1, NULL,
2493 ret_string, f_string},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002494 {"strlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002495 ret_number, f_strlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002496 {"strpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002497 ret_string, f_strpart},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002498 {"strptime", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002499 ret_number,
Bram Moolenaar10455d42019-11-21 15:36:18 +01002500#ifdef HAVE_STRPTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002501 f_strptime
2502#else
2503 NULL
Bram Moolenaar10455d42019-11-21 15:36:18 +01002504#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002505 },
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002506 {"strridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002507 ret_number, f_strridx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002508 {"strtrans", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002509 ret_string, f_strtrans},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002510 {"strwidth", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002511 ret_number, f_strwidth},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002512 {"submatch", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002513 ret_string, f_submatch},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002514 {"substitute", 4, 4, FEARG_1, arg4_string_string_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002515 ret_string, f_substitute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002516 {"swapinfo", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002517 ret_dict_any, f_swapinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002518 {"swapname", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002519 ret_string, f_swapname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002520 {"synID", 3, 3, 0, arg3_lnum_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002521 ret_number, f_synID},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002522 {"synIDattr", 2, 3, FEARG_1, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002523 ret_string, f_synIDattr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002524 {"synIDtrans", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002525 ret_number, f_synIDtrans},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002526 {"synconcealed", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002527 ret_list_any, f_synconcealed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002528 {"synstack", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002529 ret_list_number, f_synstack},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002530 {"system", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002531 ret_string, f_system},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002532 {"systemlist", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002533 ret_list_string, f_systemlist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002534 {"tabpagebuflist", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002535 ret_list_number, f_tabpagebuflist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002536 {"tabpagenr", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002537 ret_number, f_tabpagenr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002538 {"tabpagewinnr", 1, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002539 ret_number, f_tabpagewinnr},
2540 {"tagfiles", 0, 0, 0, NULL,
2541 ret_list_string, f_tagfiles},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002542 {"taglist", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002543 ret_list_dict_any, f_taglist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002544 {"tan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002545 ret_float, FLOAT_FUNC(f_tan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002546 {"tanh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002547 ret_float, FLOAT_FUNC(f_tanh)},
2548 {"tempname", 0, 0, 0, NULL,
2549 ret_string, f_tempname},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002550 {"term_dumpdiff", 2, 3, FEARG_1, arg3_string_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002551 ret_number, TERM_FUNC(f_term_dumpdiff)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002552 {"term_dumpload", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002553 ret_number, TERM_FUNC(f_term_dumpload)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002554 {"term_dumpwrite", 2, 3, FEARG_2, arg3_buffer_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002555 ret_void, TERM_FUNC(f_term_dumpwrite)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002556 {"term_getaltscreen", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002557 ret_number, TERM_FUNC(f_term_getaltscreen)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002558 {"term_getansicolors", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002559 ret_list_string,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002560#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002561 f_term_getansicolors
2562#else
2563 NULL
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02002564#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002565 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002566 {"term_getattr", 2, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002567 ret_number, TERM_FUNC(f_term_getattr)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002568 {"term_getcursor", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002569 ret_list_any, TERM_FUNC(f_term_getcursor)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002570 {"term_getjob", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002571 ret_job, TERM_FUNC(f_term_getjob)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002572 {"term_getline", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002573 ret_string, TERM_FUNC(f_term_getline)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002574 {"term_getscrolled", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002575 ret_number, TERM_FUNC(f_term_getscrolled)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002576 {"term_getsize", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002577 ret_list_number, TERM_FUNC(f_term_getsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002578 {"term_getstatus", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002579 ret_string, TERM_FUNC(f_term_getstatus)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002580 {"term_gettitle", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002581 ret_string, TERM_FUNC(f_term_gettitle)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002582 {"term_gettty", 1, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002583 ret_string, TERM_FUNC(f_term_gettty)},
2584 {"term_list", 0, 0, 0, NULL,
2585 ret_list_number, TERM_FUNC(f_term_list)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002586 {"term_scrape", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002587 ret_list_dict_any, TERM_FUNC(f_term_scrape)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002588 {"term_sendkeys", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002589 ret_void, TERM_FUNC(f_term_sendkeys)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002590 {"term_setansicolors", 2, 2, FEARG_1, arg2_buffer_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002591 ret_void,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002592#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002593 f_term_setansicolors
2594#else
2595 NULL
2596#endif
2597 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002598 {"term_setapi", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002599 ret_void, TERM_FUNC(f_term_setapi)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002600 {"term_setkill", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002601 ret_void, TERM_FUNC(f_term_setkill)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002602 {"term_setrestore", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002603 ret_void, TERM_FUNC(f_term_setrestore)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002604 {"term_setsize", 3, 3, FEARG_1, arg3_buffer_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002605 ret_void, TERM_FUNC(f_term_setsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002606 {"term_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002607 ret_number, TERM_FUNC(f_term_start)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002608 {"term_wait", 1, 2, FEARG_1, arg2_buffer_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002609 ret_void, TERM_FUNC(f_term_wait)},
2610 {"terminalprops", 0, 0, 0, NULL,
2611 ret_dict_string, f_terminalprops},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002612 {"test_alloc_fail", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002613 ret_void, f_test_alloc_fail},
2614 {"test_autochdir", 0, 0, 0, NULL,
2615 ret_void, f_test_autochdir},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002616 {"test_feedinput", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002617 ret_void, f_test_feedinput},
2618 {"test_garbagecollect_now", 0, 0, 0, NULL,
2619 ret_void, f_test_garbagecollect_now},
2620 {"test_garbagecollect_soon", 0, 0, 0, NULL,
2621 ret_void, f_test_garbagecollect_soon},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002622 {"test_getvalue", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002623 ret_number, f_test_getvalue},
Yegappan Lakshmanan06011e12022-01-30 12:37:29 +00002624 {"test_gui_event", 2, 2, FEARG_1, arg2_string_dict,
2625 ret_bool, f_test_gui_event},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002626 {"test_ignore_error", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002627 ret_void, f_test_ignore_error},
2628 {"test_null_blob", 0, 0, 0, NULL,
2629 ret_blob, f_test_null_blob},
2630 {"test_null_channel", 0, 0, 0, NULL,
2631 ret_channel, JOB_FUNC(f_test_null_channel)},
2632 {"test_null_dict", 0, 0, 0, NULL,
2633 ret_dict_any, f_test_null_dict},
2634 {"test_null_function", 0, 0, 0, NULL,
2635 ret_func_any, f_test_null_function},
2636 {"test_null_job", 0, 0, 0, NULL,
2637 ret_job, JOB_FUNC(f_test_null_job)},
2638 {"test_null_list", 0, 0, 0, NULL,
2639 ret_list_any, f_test_null_list},
2640 {"test_null_partial", 0, 0, 0, NULL,
2641 ret_func_any, f_test_null_partial},
2642 {"test_null_string", 0, 0, 0, NULL,
2643 ret_string, f_test_null_string},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002644 {"test_option_not_set", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002645 ret_void, f_test_option_not_set},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002646 {"test_override", 2, 2, FEARG_2, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002647 ret_void, f_test_override},
2648 {"test_refcount", 1, 1, FEARG_1, NULL,
2649 ret_number, f_test_refcount},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002650 {"test_setmouse", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002651 ret_void, f_test_setmouse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002652 {"test_settime", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002653 ret_void, f_test_settime},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002654 {"test_srand_seed", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002655 ret_void, f_test_srand_seed},
2656 {"test_unknown", 0, 0, 0, NULL,
2657 ret_any, f_test_unknown},
2658 {"test_void", 0, 0, 0, NULL,
2659 ret_void, f_test_void},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002660 {"timer_info", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002661 ret_list_dict_any, TIMER_FUNC(f_timer_info)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002662 {"timer_pause", 2, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002663 ret_void, TIMER_FUNC(f_timer_pause)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002664 {"timer_start", 2, 3, FEARG_1, arg3_number_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002665 ret_number, TIMER_FUNC(f_timer_start)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002666 {"timer_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002667 ret_void, TIMER_FUNC(f_timer_stop)},
2668 {"timer_stopall", 0, 0, 0, NULL,
2669 ret_void, TIMER_FUNC(f_timer_stopall)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002670 {"tolower", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002671 ret_string, f_tolower},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002672 {"toupper", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002673 ret_string, f_toupper},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002674 {"tr", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002675 ret_string, f_tr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002676 {"trim", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002677 ret_string, f_trim},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002678 {"trunc", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002679 ret_float, FLOAT_FUNC(f_trunc)},
2680 {"type", 1, 1, FEARG_1, NULL,
2681 ret_number, f_type},
Bram Moolenaara47e05f2021-01-12 21:49:00 +01002682 {"typename", 1, 1, FEARG_1, NULL,
2683 ret_string, f_typename},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002684 {"undofile", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002685 ret_string, f_undofile},
2686 {"undotree", 0, 0, 0, NULL,
2687 ret_dict_any, f_undotree},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002688 {"uniq", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar08018222021-12-22 18:45:37 +00002689 ret_first_arg, f_uniq},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002690 {"values", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002691 ret_list_any, f_values},
LemonBoy0f7a3e12022-05-26 12:10:37 +01002692 {"virtcol", 1, 2, FEARG_1, arg2_string_or_list_bool,
2693 ret_virtcol, f_virtcol},
Bram Moolenaar5a6ec102022-05-27 21:58:00 +01002694 {"virtcol2col", 3, 3, FEARG_1, arg3_number,
2695 ret_number, f_virtcol2col},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002696 {"visualmode", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002697 ret_string, f_visualmode},
2698 {"wildmenumode", 0, 0, 0, NULL,
2699 ret_number, f_wildmenumode},
Bram Moolenaar52312242021-07-11 18:23:19 +02002700 {"win_execute", 2, 3, FEARG_2, arg23_win_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002701 ret_string, f_win_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002702 {"win_findbuf", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002703 ret_list_number, f_win_findbuf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002704 {"win_getid", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002705 ret_number, f_win_getid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002706 {"win_gettype", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002707 ret_string, f_win_gettype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002708 {"win_gotoid", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002709 ret_number_bool, f_win_gotoid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002710 {"win_id2tabwin", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002711 ret_list_number, f_win_id2tabwin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002712 {"win_id2win", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002713 ret_number, f_win_id2win},
Daniel Steinbergee630312022-01-10 13:36:34 +00002714 {"win_move_separator", 2, 2, FEARG_1, arg2_number,
2715 ret_number_bool, f_win_move_separator},
2716 {"win_move_statusline", 2, 2, FEARG_1, arg2_number,
2717 ret_number_bool, f_win_move_statusline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002718 {"win_screenpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002719 ret_list_number, f_win_screenpos},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002720 {"win_splitmove", 2, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002721 ret_number_bool, f_win_splitmove},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002722 {"winbufnr", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002723 ret_number, f_winbufnr},
2724 {"wincol", 0, 0, 0, NULL,
2725 ret_number, f_wincol},
2726 {"windowsversion", 0, 0, 0, NULL,
2727 ret_string, f_windowsversion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002728 {"winheight", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002729 ret_number, f_winheight},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002730 {"winlayout", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002731 ret_list_any, f_winlayout},
2732 {"winline", 0, 0, 0, NULL,
2733 ret_number, f_winline},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002734 {"winnr", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002735 ret_number, f_winnr},
2736 {"winrestcmd", 0, 0, 0, NULL,
2737 ret_string, f_winrestcmd},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002738 {"winrestview", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002739 ret_void, f_winrestview},
2740 {"winsaveview", 0, 0, 0, NULL,
Bram Moolenaar43b69b32021-01-07 20:23:33 +01002741 ret_dict_number, f_winsaveview},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002742 {"winwidth", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002743 ret_number, f_winwidth},
2744 {"wordcount", 0, 0, 0, NULL,
2745 ret_dict_number, f_wordcount},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002746 {"writefile", 2, 3, FEARG_1, arg23_writefile,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002747 ret_number_bool, f_writefile},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002748 {"xor", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002749 ret_number, f_xor},
Bram Moolenaarac92e252019-08-03 21:58:38 +02002750};
2751
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002752/*
2753 * Function given to ExpandGeneric() to obtain the list of internal
2754 * or user defined function names.
2755 */
2756 char_u *
2757get_function_name(expand_T *xp, int idx)
2758{
2759 static int intidx = -1;
2760 char_u *name;
2761
2762 if (idx == 0)
2763 intidx = -1;
2764 if (intidx < 0)
2765 {
2766 name = get_user_func_name(xp, idx);
naohiro ono5aec7552021-08-19 21:20:41 +02002767 if (name != NULL)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002768 {
naohiro ono5aec7552021-08-19 21:20:41 +02002769 if (*name != NUL && *name != '<'
2770 && STRNCMP("g:", xp->xp_pattern, 2) == 0)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002771 return cat_prefix_varname('g', name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002772 return name;
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002773 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002774 }
K.Takataeeec2542021-06-02 13:28:16 +02002775 if (++intidx < (int)ARRAY_LENGTH(global_functions))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002776 {
Bram Moolenaarac92e252019-08-03 21:58:38 +02002777 STRCPY(IObuff, global_functions[intidx].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002778 STRCAT(IObuff, "(");
Bram Moolenaarac92e252019-08-03 21:58:38 +02002779 if (global_functions[intidx].f_max_argc == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002780 STRCAT(IObuff, ")");
2781 return IObuff;
2782 }
2783
2784 return NULL;
2785}
2786
2787/*
2788 * Function given to ExpandGeneric() to obtain the list of internal or
2789 * user defined variable or function names.
2790 */
2791 char_u *
2792get_expr_name(expand_T *xp, int idx)
2793{
2794 static int intidx = -1;
2795 char_u *name;
2796
2797 if (idx == 0)
2798 intidx = -1;
2799 if (intidx < 0)
2800 {
2801 name = get_function_name(xp, idx);
2802 if (name != NULL)
2803 return name;
2804 }
2805 return get_user_var_name(xp, ++intidx);
2806}
2807
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002808/*
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002809 * Find internal function "name" in table "global_functions".
Bram Moolenaar15c47602020-03-26 22:16:48 +01002810 * Return index, or -1 if not found or "implemented" is TRUE and the function
2811 * is not implemented.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002812 */
Bram Moolenaar15c47602020-03-26 22:16:48 +01002813 static int
2814find_internal_func_opt(char_u *name, int implemented)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002815{
2816 int first = 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002817 int last;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002818 int cmp;
2819 int x;
2820
K.Takataeeec2542021-06-02 13:28:16 +02002821 last = (int)ARRAY_LENGTH(global_functions) - 1;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002822
2823 // Find the function name in the table. Binary search.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002824 while (first <= last)
2825 {
2826 x = first + ((unsigned)(last - first) >> 1);
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002827 cmp = STRCMP(name, global_functions[x].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002828 if (cmp < 0)
2829 last = x - 1;
2830 else if (cmp > 0)
2831 first = x + 1;
Bram Moolenaar15c47602020-03-26 22:16:48 +01002832 else if (implemented && global_functions[x].f_func == NULL)
2833 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002834 else
2835 return x;
2836 }
2837 return -1;
2838}
2839
Bram Moolenaar15c47602020-03-26 22:16:48 +01002840/*
2841 * Find internal function "name" in table "global_functions".
2842 * Return index, or -1 if not found or the function is not implemented.
2843 */
2844 int
2845find_internal_func(char_u *name)
2846{
2847 return find_internal_func_opt(name, TRUE);
2848}
2849
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002850 int
Bram Moolenaarac92e252019-08-03 21:58:38 +02002851has_internal_func(char_u *name)
2852{
Bram Moolenaar15c47602020-03-26 22:16:48 +01002853 return find_internal_func_opt(name, TRUE) >= 0;
2854}
2855
2856 static int
2857has_internal_func_name(char_u *name)
2858{
2859 return find_internal_func_opt(name, FALSE) >= 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002860}
2861
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002862 char *
2863internal_func_name(int idx)
2864{
2865 return global_functions[idx].f_name;
2866}
2867
Bram Moolenaar94738d82020-10-21 14:25:07 +02002868/*
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002869 * Check the argument types for builtin function "idx".
Bram Moolenaar94738d82020-10-21 14:25:07 +02002870 * Uses the list of types on the type stack: "types".
2871 * Return FAIL and gives an error message when a type is wrong.
2872 */
2873 int
Bram Moolenaar351ead02021-01-16 16:07:01 +01002874internal_func_check_arg_types(
Bram Moolenaar078a4612022-01-04 15:17:03 +00002875 type2_T *types,
Bram Moolenaar351ead02021-01-16 16:07:01 +01002876 int idx,
2877 int argcount,
2878 cctx_T *cctx)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002879{
2880 argcheck_T *argchecks = global_functions[idx].f_argcheck;
2881 int i;
2882
2883 if (argchecks != NULL)
2884 {
2885 argcontext_T context;
2886
2887 context.arg_count = argcount;
Bram Moolenaarca174532020-10-21 16:42:22 +02002888 context.arg_types = types;
Bram Moolenaar351ead02021-01-16 16:07:01 +01002889 context.arg_cctx = cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +02002890 for (i = 0; i < argcount; ++i)
2891 if (argchecks[i] != NULL)
2892 {
2893 context.arg_idx = i;
Bram Moolenaar078a4612022-01-04 15:17:03 +00002894 if (argchecks[i](types[i].type_curr, types[i].type_decl,
2895 &context) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002896 return FAIL;
2897 }
2898 }
2899 return OK;
2900}
2901
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002902/*
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02002903 * Get the argument count for function "idx".
2904 * "argcount" is the total argument count, "min_argcount" the non-optional
2905 * argument count.
2906 */
2907 void
2908internal_func_get_argcount(int idx, int *argcount, int *min_argcount)
2909{
2910 *argcount = global_functions[idx].f_max_argc;
2911 *min_argcount = global_functions[idx].f_min_argc;
2912}
2913
2914/*
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002915 * Call the "f_retfunc" function to obtain the return type of function "idx".
Bram Moolenaar81330182022-02-01 12:11:58 +00002916 * "decl_type" is set to the declared type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002917 * "argtypes" is the list of argument types or NULL when there are no
2918 * arguments.
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02002919 * "argcount" may be less than the actual count when only getting the type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002920 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002921 type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00002922internal_func_ret_type(
2923 int idx,
2924 int argcount,
2925 type2_T *argtypes,
2926 type_T **decl_type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002927{
Bram Moolenaar81330182022-02-01 12:11:58 +00002928 type_T *ret;
2929
2930 *decl_type = NULL;
2931 ret = global_functions[idx].f_retfunc(argcount, argtypes, decl_type);
2932 if (*decl_type == NULL)
2933 *decl_type = ret;
2934 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002935}
2936
2937/*
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002938 * Return TRUE if "idx" is for the map() function.
2939 */
2940 int
2941internal_func_is_map(int idx)
2942{
2943 return global_functions[idx].f_func == f_map;
2944}
2945
2946/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002947 * Check the argument count to use for internal function "idx".
Bram Moolenaar389df252020-07-09 21:20:47 +02002948 * Returns -1 for failure, 0 if no method base accepted, 1 if method base is
2949 * first argument, 2 if method base is second argument, etc. 9 if method base
2950 * is last argument.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002951 */
2952 int
2953check_internal_func(int idx, int argcount)
2954{
2955 int res;
2956 char *name;
2957
2958 if (argcount < global_functions[idx].f_min_argc)
2959 res = FCERR_TOOFEW;
2960 else if (argcount > global_functions[idx].f_max_argc)
2961 res = FCERR_TOOMANY;
2962 else
Bram Moolenaar389df252020-07-09 21:20:47 +02002963 return global_functions[idx].f_argtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002964
2965 name = internal_func_name(idx);
2966 if (res == FCERR_TOOMANY)
Bram Moolenaare1242042021-12-16 20:56:57 +00002967 semsg(_(e_too_many_arguments_for_function_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002968 else
Bram Moolenaare1242042021-12-16 20:56:57 +00002969 semsg(_(e_not_enough_arguments_for_function_str), name);
Bram Moolenaar389df252020-07-09 21:20:47 +02002970 return -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002971}
2972
Bram Moolenaarac92e252019-08-03 21:58:38 +02002973 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002974call_internal_func(
2975 char_u *name,
2976 int argcount,
2977 typval_T *argvars,
2978 typval_T *rettv)
2979{
2980 int i;
2981
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002982 i = find_internal_func(name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002983 if (i < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002984 return FCERR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002985 if (argcount < global_functions[i].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002986 return FCERR_TOOFEW;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002987 if (argcount > global_functions[i].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002988 return FCERR_TOOMANY;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002989 argvars[argcount].v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002990 global_functions[i].f_func(argvars, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01002991 return FCERR_NONE;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002992}
2993
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002994 void
2995call_internal_func_by_idx(
2996 int idx,
2997 typval_T *argvars,
2998 typval_T *rettv)
2999{
3000 global_functions[idx].f_func(argvars, rettv);
3001}
3002
Bram Moolenaarac92e252019-08-03 21:58:38 +02003003/*
3004 * Invoke a method for base->method().
3005 */
3006 int
3007call_internal_method(
3008 char_u *name,
3009 int argcount,
3010 typval_T *argvars,
3011 typval_T *rettv,
3012 typval_T *basetv)
3013{
3014 int i;
3015 int fi;
3016 typval_T argv[MAX_FUNC_ARGS + 1];
3017
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003018 fi = find_internal_func(name);
Bram Moolenaar91746392019-08-16 22:22:31 +02003019 if (fi < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003020 return FCERR_UNKNOWN;
Bram Moolenaar91746392019-08-16 22:22:31 +02003021 if (global_functions[fi].f_argtype == 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003022 return FCERR_NOTMETHOD;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003023 if (argcount + 1 < global_functions[fi].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003024 return FCERR_TOOFEW;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003025 if (argcount + 1 > global_functions[fi].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003026 return FCERR_TOOMANY;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003027
Bram Moolenaarb3468902022-01-01 19:42:16 +00003028 if (global_functions[fi].f_argtype == FEARG_2)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003029 {
3030 // base value goes second
3031 argv[0] = argvars[0];
3032 argv[1] = *basetv;
3033 for (i = 1; i < argcount; ++i)
3034 argv[i + 1] = argvars[i];
3035 }
Bram Moolenaar24278d22019-08-16 21:49:22 +02003036 else if (global_functions[fi].f_argtype == FEARG_3)
3037 {
3038 // base value goes third
3039 argv[0] = argvars[0];
3040 argv[1] = argvars[1];
3041 argv[2] = *basetv;
3042 for (i = 2; i < argcount; ++i)
3043 argv[i + 1] = argvars[i];
3044 }
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003045 else if (global_functions[fi].f_argtype == FEARG_4)
3046 {
3047 // base value goes fourth
3048 argv[0] = argvars[0];
3049 argv[1] = argvars[1];
3050 argv[2] = argvars[2];
3051 argv[3] = *basetv;
3052 for (i = 3; i < argcount; ++i)
3053 argv[i + 1] = argvars[i];
3054 }
Bram Moolenaar25e42232019-08-04 15:04:10 +02003055 else
3056 {
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003057 // FEARG_1: base value goes first
Bram Moolenaar25e42232019-08-04 15:04:10 +02003058 argv[0] = *basetv;
3059 for (i = 0; i < argcount; ++i)
3060 argv[i + 1] = argvars[i];
3061 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02003062 argv[argcount + 1].v_type = VAR_UNKNOWN;
3063
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003064 global_functions[fi].f_func(argv, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01003065 return FCERR_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003066}
3067
3068/*
3069 * Return TRUE for a non-zero Number and a non-empty String.
3070 */
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003071 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003072non_zero_arg(typval_T *argvars)
3073{
3074 return ((argvars[0].v_type == VAR_NUMBER
3075 && argvars[0].vval.v_number != 0)
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003076 || (argvars[0].v_type == VAR_BOOL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003077 && argvars[0].vval.v_number == VVAL_TRUE)
3078 || (argvars[0].v_type == VAR_STRING
3079 && argvars[0].vval.v_string != NULL
3080 && *argvars[0].vval.v_string != NUL));
3081}
3082
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003083/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003084 * "and(expr, expr)" function
3085 */
3086 static void
3087f_and(typval_T *argvars, typval_T *rettv)
3088{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003089 if (in_vim9script()
3090 && (check_for_number_arg(argvars, 0) == FAIL
3091 || check_for_number_arg(argvars, 1) == FAIL))
3092 return;
3093
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003094 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
3095 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02003096}
3097
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003098/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01003099 * "balloon_show()" function
3100 */
3101#ifdef FEAT_BEVAL
3102 static void
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003103f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv)
3104{
3105 rettv->v_type = VAR_STRING;
3106 if (balloonEval != NULL)
3107 {
3108 if (balloonEval->msg == NULL)
3109 rettv->vval.v_string = NULL;
3110 else
3111 rettv->vval.v_string = vim_strsave(balloonEval->msg);
3112 }
3113}
3114
3115 static void
Bram Moolenaar59716a22017-03-01 20:32:44 +01003116f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
3117{
Bram Moolenaarcaf64342017-03-02 22:11:33 +01003118 if (balloonEval != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003119 {
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003120 if (in_vim9script()
3121 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3122 return;
3123
Bram Moolenaar246fe032017-11-19 19:56:27 +01003124 if (argvars[0].v_type == VAR_LIST
3125# ifdef FEAT_GUI
3126 && !gui.in_use
3127# endif
3128 )
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003129 {
3130 list_T *l = argvars[0].vval.v_list;
3131
3132 // empty list removes the balloon
3133 post_balloon(balloonEval, NULL,
3134 l == NULL || l->lv_len == 0 ? NULL : l);
3135 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003136 else
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003137 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003138 char_u *mesg;
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003139
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003140 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3141 return;
3142
3143 mesg = tv_get_string_chk(&argvars[0]);
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003144 if (mesg != NULL)
3145 // empty string removes the balloon
3146 post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL);
3147 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01003148 }
3149}
3150
Bram Moolenaar669a8282017-11-19 20:13:05 +01003151# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003152 static void
3153f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
3154{
3155 if (rettv_list_alloc(rettv) == OK)
3156 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003157 char_u *msg;
Bram Moolenaar246fe032017-11-19 19:56:27 +01003158
Bram Moolenaar32105ae2021-03-27 18:59:25 +01003159 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3160 return;
3161 msg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003162 if (msg != NULL)
3163 {
3164 pumitem_T *array;
3165 int size = split_message(msg, &array);
3166 int i;
3167
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003168 // Skip the first and last item, they are always empty.
Bram Moolenaar246fe032017-11-19 19:56:27 +01003169 for (i = 1; i < size - 1; ++i)
3170 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
Bram Moolenaarb301f6b2018-02-10 15:38:35 +01003171 while (size > 0)
3172 vim_free(array[--size].pum_text);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003173 vim_free(array);
3174 }
3175 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01003176}
Bram Moolenaar669a8282017-11-19 20:13:05 +01003177# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01003178#endif
3179
3180/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003181 * Get the buffer from "arg" and give an error and return NULL if it is not
3182 * valid.
3183 */
Bram Moolenaara3347722019-05-11 21:14:24 +02003184 buf_T *
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003185get_buf_arg(typval_T *arg)
3186{
3187 buf_T *buf;
3188
3189 ++emsg_off;
3190 buf = tv_get_buf(arg, FALSE);
3191 --emsg_off;
3192 if (buf == NULL)
Bram Moolenaard82a47d2022-01-05 20:24:39 +00003193 semsg(_(e_invalid_buffer_name_str), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003194 return buf;
3195}
3196
3197/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003198 * "byte2line(byte)" function
3199 */
3200 static void
3201f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
3202{
3203#ifndef FEAT_BYTEOFF
3204 rettv->vval.v_number = -1;
3205#else
3206 long boff = 0;
3207
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003208 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3209 return;
3210
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003211 boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003212 if (boff < 0)
3213 rettv->vval.v_number = -1;
3214 else
3215 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
3216 (linenr_T)0, &boff);
3217#endif
3218}
3219
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003220/*
3221 * "call(func, arglist [, dict])" function
3222 */
3223 static void
3224f_call(typval_T *argvars, typval_T *rettv)
3225{
3226 char_u *func;
3227 partial_T *partial = NULL;
3228 dict_T *selfdict = NULL;
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003229 char_u *dot;
3230 char_u *tofree = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003231
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003232 if (in_vim9script()
Bram Moolenaar223d0a62021-12-25 19:29:21 +00003233 && (check_for_string_or_func_arg(argvars, 0) == FAIL
3234 || check_for_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003235 || check_for_opt_dict_arg(argvars, 2) == FAIL))
3236 return;
3237
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003238 if (argvars[1].v_type != VAR_LIST)
3239 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00003240 emsg(_(e_list_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003241 return;
3242 }
3243 if (argvars[1].vval.v_list == NULL)
3244 return;
3245
3246 if (argvars[0].v_type == VAR_FUNC)
3247 func = argvars[0].vval.v_string;
3248 else if (argvars[0].v_type == VAR_PARTIAL)
3249 {
3250 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003251 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003252 }
3253 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003254 func = tv_get_string(&argvars[0]);
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003255 if (func == NULL || *func == NUL)
3256 return; // type error, empty name or null function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003257
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003258 dot = vim_strchr(func, '.');
3259 if (dot != NULL)
3260 {
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00003261 imported_T *import = find_imported(func, dot - func, TRUE);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003262
3263 if (import != NULL && SCRIPT_ID_VALID(import->imp_sid))
3264 {
3265 scriptitem_T *si = SCRIPT_ITEM(import->imp_sid);
3266
3267 if (si->sn_autoload_prefix != NULL)
3268 {
3269 // Turn "import.Func" into "scriptname#Func".
3270 tofree = concat_str(si->sn_autoload_prefix, dot + 1);
3271 if (tofree == NULL)
3272 return;
3273 func = tofree;
3274 }
3275 }
3276 }
3277
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003278 if (argvars[2].v_type != VAR_UNKNOWN)
3279 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003280 if (check_for_dict_arg(argvars, 2) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003281 return;
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003282
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003283 selfdict = argvars[2].vval.v_dict;
3284 }
3285
3286 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003287
3288 vim_free(tofree);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003289}
3290
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003291/*
3292 * "changenr()" function
3293 */
3294 static void
3295f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
3296{
3297 rettv->vval.v_number = curbuf->b_u_seq_cur;
3298}
3299
3300/*
3301 * "char2nr(string)" function
3302 */
3303 static void
3304f_char2nr(typval_T *argvars, typval_T *rettv)
3305{
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003306 if (in_vim9script()
3307 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003308 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003309 return;
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003310
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003311 if (has_mbyte)
3312 {
3313 int utf8 = 0;
3314
3315 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar24f77502020-09-04 19:50:57 +02003316 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003317
3318 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01003319 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003320 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003321 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003322 }
3323 else
Bram Moolenaar13505972019-01-24 15:04:48 +01003324 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003325}
3326
Bram Moolenaar17793ef2020-12-28 12:56:58 +01003327/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003328 * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE,
3329 * returns the character index of the column. Otherwise, returns the byte index
3330 * of the column.
3331 */
3332 static void
3333get_col(typval_T *argvars, typval_T *rettv, int charcol)
3334{
3335 colnr_T col = 0;
3336 pos_T *fp;
3337 int fnum = curbuf->b_fnum;
3338
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003339 if (in_vim9script()
3340 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3341 return;
3342
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003343 fp = var2fpos(&argvars[0], FALSE, &fnum, charcol);
3344 if (fp != NULL && fnum == curbuf->b_fnum)
3345 {
3346 if (fp->col == MAXCOL)
3347 {
3348 // '> can be MAXCOL, get the length of the line then
3349 if (fp->lnum <= curbuf->b_ml.ml_line_count)
3350 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
3351 else
3352 col = MAXCOL;
3353 }
3354 else
3355 {
3356 col = fp->col + 1;
3357 // col(".") when the cursor is on the NUL at the end of the line
3358 // because of "coladd" can be seen as an extra column.
3359 if (virtual_active() && fp == &curwin->w_cursor)
3360 {
3361 char_u *p = ml_get_cursor();
3362
3363 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
3364 curwin->w_virtcol - curwin->w_cursor.coladd))
3365 {
3366 int l;
3367
3368 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
3369 col += l;
3370 }
3371 }
3372 }
3373 }
3374 rettv->vval.v_number = col;
3375}
3376
3377/*
3378 * "charcol()" function
3379 */
3380 static void
3381f_charcol(typval_T *argvars, typval_T *rettv)
3382{
3383 get_col(argvars, rettv, TRUE);
3384}
3385
Bram Moolenaar29b7d7a2019-07-22 23:03:57 +02003386 win_T *
Bram Moolenaaraff74912019-03-30 18:11:49 +01003387get_optional_window(typval_T *argvars, int idx)
3388{
3389 win_T *win = curwin;
3390
3391 if (argvars[idx].v_type != VAR_UNKNOWN)
3392 {
3393 win = find_win_by_nr_or_id(&argvars[idx]);
3394 if (win == NULL)
3395 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00003396 emsg(_(e_invalid_window_number));
Bram Moolenaaraff74912019-03-30 18:11:49 +01003397 return NULL;
3398 }
3399 }
3400 return win;
3401}
3402
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003403/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003404 * "col(string)" function
3405 */
3406 static void
3407f_col(typval_T *argvars, typval_T *rettv)
3408{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003409 get_col(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003410}
3411
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003412/*
3413 * "confirm(message, buttons[, default [, type]])" function
3414 */
3415 static void
3416f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3417{
3418#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3419 char_u *message;
3420 char_u *buttons = NULL;
3421 char_u buf[NUMBUFLEN];
3422 char_u buf2[NUMBUFLEN];
3423 int def = 1;
3424 int type = VIM_GENERIC;
3425 char_u *typestr;
3426 int error = FALSE;
3427
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02003428 if (in_vim9script()
3429 && (check_for_string_arg(argvars, 0) == FAIL
3430 || (check_for_opt_string_arg(argvars, 1) == FAIL
3431 || (argvars[1].v_type != VAR_UNKNOWN
3432 && (check_for_opt_number_arg(argvars, 2) == FAIL
3433 || (argvars[2].v_type != VAR_UNKNOWN
3434 && check_for_opt_string_arg(argvars, 3) == FAIL))))))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003435 return;
3436
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003437 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003438 if (message == NULL)
3439 error = TRUE;
3440 if (argvars[1].v_type != VAR_UNKNOWN)
3441 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003442 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003443 if (buttons == NULL)
3444 error = TRUE;
3445 if (argvars[2].v_type != VAR_UNKNOWN)
3446 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003447 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003448 if (argvars[3].v_type != VAR_UNKNOWN)
3449 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003450 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003451 if (typestr == NULL)
3452 error = TRUE;
3453 else
3454 {
3455 switch (TOUPPER_ASC(*typestr))
3456 {
3457 case 'E': type = VIM_ERROR; break;
3458 case 'Q': type = VIM_QUESTION; break;
3459 case 'I': type = VIM_INFO; break;
3460 case 'W': type = VIM_WARNING; break;
3461 case 'G': type = VIM_GENERIC; break;
3462 }
3463 }
3464 }
3465 }
3466 }
3467
3468 if (buttons == NULL || *buttons == NUL)
3469 buttons = (char_u *)_("&Ok");
3470
3471 if (!error)
3472 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
3473 def, NULL, FALSE);
3474#endif
3475}
3476
3477/*
3478 * "copy()" function
3479 */
3480 static void
3481f_copy(typval_T *argvars, typval_T *rettv)
3482{
Bram Moolenaar381692b2022-02-02 20:01:27 +00003483 item_copy(&argvars[0], rettv, FALSE, TRUE, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003484}
3485
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003486/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003487 * Set the cursor position.
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003488 * If 'charcol' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003489 * Otherwise use the column number as a byte offset.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003490 */
3491 static void
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003492set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003493{
3494 long line, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003495 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003496 int set_curswant = TRUE;
3497
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003498 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003499 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02003500 || check_for_opt_number_arg(argvars, 1) == FAIL
3501 || (argvars[1].v_type != VAR_UNKNOWN
3502 && check_for_opt_number_arg(argvars, 2) == FAIL)))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003503 return;
3504
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003505 rettv->vval.v_number = -1;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003506 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003507 {
3508 pos_T pos;
3509 colnr_T curswant = -1;
3510
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003511 if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003512 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003513 emsg(_(e_invalid_argument));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003514 return;
3515 }
3516 line = pos.lnum;
3517 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003518 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003519 if (curswant >= 0)
3520 {
3521 curwin->w_curswant = curswant - 1;
3522 set_curswant = FALSE;
3523 }
3524 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003525 else if ((argvars[0].v_type == VAR_NUMBER ||
3526 argvars[0].v_type == VAR_STRING)
Bram Moolenaar9ebcf232021-01-16 16:52:49 +01003527 && (argvars[1].v_type == VAR_NUMBER ||
3528 argvars[1].v_type == VAR_STRING))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003529 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003530 line = tv_get_lnum(argvars);
Bram Moolenaar9a963372020-12-21 21:58:46 +01003531 if (line < 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003532 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003533 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003534 if (charcol)
Bram Moolenaar91458462021-01-13 20:08:38 +01003535 col = buf_charidx_to_byteidx(curbuf, line, col) + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003536 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003537 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003538 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003539 else
3540 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003541 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003542 return;
3543 }
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01003544 if (line < 0 || col < 0 || coladd < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003545 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003546 if (line > 0)
3547 curwin->w_cursor.lnum = line;
3548 if (col > 0)
3549 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003550 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003551
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003552 // Make sure the cursor is in a valid position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003553 check_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003554 // Correct cursor for multi-byte character.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003555 if (has_mbyte)
3556 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003557
3558 curwin->w_set_curswant = set_curswant;
3559 rettv->vval.v_number = 0;
3560}
3561
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003562/*
3563 * "cursor(lnum, col)" function, or
3564 * "cursor(list)"
3565 *
3566 * Moves the cursor to the specified line and column.
3567 * Returns 0 when the position could be set, -1 otherwise.
3568 */
3569 static void
3570f_cursor(typval_T *argvars, typval_T *rettv)
3571{
3572 set_cursorpos(argvars, rettv, FALSE);
3573}
3574
Bram Moolenaar4f974752019-02-17 17:44:42 +01003575#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003576/*
3577 * "debugbreak()" function
3578 */
3579 static void
3580f_debugbreak(typval_T *argvars, typval_T *rettv)
3581{
3582 int pid;
3583
3584 rettv->vval.v_number = FAIL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003585 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3586 return;
3587
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003588 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003589 if (pid == 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003590 emsg(_(e_invalid_argument));
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003591 else
3592 {
3593 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
3594
3595 if (hProcess != NULL)
3596 {
3597 DebugBreakProcess(hProcess);
3598 CloseHandle(hProcess);
3599 rettv->vval.v_number = OK;
3600 }
3601 }
3602}
3603#endif
3604
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003605/*
3606 * "deepcopy()" function
3607 */
3608 static void
3609f_deepcopy(typval_T *argvars, typval_T *rettv)
3610{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003611 varnumber_T noref = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003612
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003613 if (in_vim9script()
3614 && (check_for_opt_bool_arg(argvars, 1) == FAIL))
3615 return;
3616
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003617 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003618 noref = tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003619 if (noref < 0 || noref > 1)
Bram Moolenaarbade44e2020-09-26 22:39:24 +02003620 semsg(_(e_using_number_as_bool_nr), noref);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003621 else
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01003622 item_copy(&argvars[0], rettv, TRUE, TRUE,
3623 noref == 0 ? get_copyID() : 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003624}
3625
3626/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003627 * "did_filetype()" function
3628 */
3629 static void
3630f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3631{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003632 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003633}
3634
3635/*
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003636 * "echoraw({expr})" function
3637 */
3638 static void
3639f_echoraw(typval_T *argvars, typval_T *rettv UNUSED)
3640{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003641 char_u *str;
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003642
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003643 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3644 return;
3645
3646 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003647 if (str != NULL && *str != NUL)
3648 {
3649 out_str(str);
3650 out_flush();
3651 }
3652}
3653
3654/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003655 * "empty({expr})" function
3656 */
3657 static void
3658f_empty(typval_T *argvars, typval_T *rettv)
3659{
3660 int n = FALSE;
3661
3662 switch (argvars[0].v_type)
3663 {
3664 case VAR_STRING:
3665 case VAR_FUNC:
3666 n = argvars[0].vval.v_string == NULL
3667 || *argvars[0].vval.v_string == NUL;
3668 break;
3669 case VAR_PARTIAL:
3670 n = FALSE;
3671 break;
3672 case VAR_NUMBER:
3673 n = argvars[0].vval.v_number == 0;
3674 break;
3675 case VAR_FLOAT:
3676#ifdef FEAT_FLOAT
3677 n = argvars[0].vval.v_float == 0.0;
3678 break;
3679#endif
3680 case VAR_LIST:
3681 n = argvars[0].vval.v_list == NULL
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003682 || argvars[0].vval.v_list->lv_len == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003683 break;
3684 case VAR_DICT:
3685 n = argvars[0].vval.v_dict == NULL
3686 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
3687 break;
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003688 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003689 case VAR_SPECIAL:
3690 n = argvars[0].vval.v_number != VVAL_TRUE;
3691 break;
3692
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003693 case VAR_BLOB:
3694 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003695 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
3696 break;
3697
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003698 case VAR_JOB:
3699#ifdef FEAT_JOB_CHANNEL
3700 n = argvars[0].vval.v_job == NULL
3701 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
3702 break;
3703#endif
3704 case VAR_CHANNEL:
3705#ifdef FEAT_JOB_CHANNEL
3706 n = argvars[0].vval.v_channel == NULL
3707 || !channel_is_open(argvars[0].vval.v_channel);
3708 break;
3709#endif
3710 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02003711 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003712 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003713 case VAR_INSTR:
Bram Moolenaardd589232020-02-29 17:38:12 +01003714 internal_error_no_abort("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003715 n = TRUE;
3716 break;
3717 }
3718
3719 rettv->vval.v_number = n;
3720}
3721
3722/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003723 * "environ()" function
3724 */
3725 static void
3726f_environ(typval_T *argvars UNUSED, typval_T *rettv)
3727{
3728#if !defined(AMIGA)
3729 int i = 0;
3730 char_u *entry, *value;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01003731# if defined (MSWIN)
3732# if !defined(_UCRT)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003733 extern wchar_t **_wenviron;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01003734# endif
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003735# else
3736 extern char **environ;
3737# endif
3738
Bram Moolenaar93a10962022-06-16 11:42:09 +01003739 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003740 return;
3741
3742# ifdef MSWIN
3743 if (*_wenviron == NULL)
3744 return;
3745# else
3746 if (*environ == NULL)
3747 return;
3748# endif
3749
3750 for (i = 0; ; ++i)
3751 {
3752# ifdef MSWIN
3753 short_u *p;
3754
3755 if ((p = (short_u *)_wenviron[i]) == NULL)
3756 return;
3757 entry = utf16_to_enc(p, NULL);
3758# else
3759 if ((entry = (char_u *)environ[i]) == NULL)
3760 return;
3761 entry = vim_strsave(entry);
3762# endif
3763 if (entry == NULL) // out of memory
3764 return;
3765 if ((value = vim_strchr(entry, '=')) == NULL)
3766 {
3767 vim_free(entry);
3768 continue;
3769 }
3770 *value++ = NUL;
3771 dict_add_string(rettv->vval.v_dict, (char *)entry, value);
3772 vim_free(entry);
3773 }
3774#endif
3775}
3776
3777/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003778 * "escape({string}, {chars})" function
3779 */
3780 static void
3781f_escape(typval_T *argvars, typval_T *rettv)
3782{
3783 char_u buf[NUMBUFLEN];
3784
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003785 if (in_vim9script()
3786 && (check_for_string_arg(argvars, 0) == FAIL
3787 || check_for_string_arg(argvars, 1) == FAIL))
3788 return;
3789
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003790 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
3791 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003792 rettv->v_type = VAR_STRING;
3793}
3794
3795/*
3796 * "eval()" function
3797 */
3798 static void
3799f_eval(typval_T *argvars, typval_T *rettv)
3800{
3801 char_u *s, *p;
3802
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003803 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3804 return;
3805
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003806 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003807 if (s != NULL)
3808 s = skipwhite(s);
3809
3810 p = s;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003811 if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003812 {
3813 if (p != NULL && !aborting())
Bram Moolenaar108010a2021-06-27 22:03:33 +02003814 semsg(_(e_invalid_expression_str), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003815 need_clr_eos = FALSE;
3816 rettv->v_type = VAR_NUMBER;
3817 rettv->vval.v_number = 0;
3818 }
3819 else if (*s != NUL)
Bram Moolenaar74409f62022-01-01 15:58:22 +00003820 semsg(_(e_trailing_characters_str), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003821}
3822
3823/*
3824 * "eventhandler()" function
3825 */
3826 static void
3827f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
3828{
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003829 rettv->vval.v_number = vgetc_busy || input_busy;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003830}
3831
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003832static garray_T redir_execute_ga;
3833
3834/*
3835 * Append "value[value_len]" to the execute() output.
3836 */
3837 void
3838execute_redir_str(char_u *value, int value_len)
3839{
3840 int len;
3841
3842 if (value_len == -1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003843 len = (int)STRLEN(value); // Append the entire string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003844 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003845 len = value_len; // Append only "value_len" characters
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003846 if (ga_grow(&redir_execute_ga, len) == OK)
3847 {
3848 mch_memmove((char *)redir_execute_ga.ga_data
3849 + redir_execute_ga.ga_len, value, len);
3850 redir_execute_ga.ga_len += len;
3851 }
3852}
3853
Dominique Pelle748b3082022-01-08 12:41:16 +00003854#if defined(FEAT_LUA) || defined(PROTO)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003855/*
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003856 * Get next line from a string containing NL separated lines.
3857 * Called by do_cmdline() to get the next line.
3858 * Returns an allocated string, or NULL when at the end of the string.
3859 */
3860 static char_u *
3861get_str_line(
3862 int c UNUSED,
3863 void *cookie,
3864 int indent UNUSED,
3865 getline_opt_T options UNUSED)
3866{
3867 char_u *start = *(char_u **)cookie;
3868 char_u *line;
3869 char_u *p;
3870
3871 p = start;
3872 if (p == NULL || *p == NUL)
3873 return NULL;
3874 p = vim_strchr(p, '\n');
3875 if (p == NULL)
3876 line = vim_strsave(start);
3877 else
3878 {
3879 line = vim_strnsave(start, p - start);
3880 p++;
3881 }
3882
3883 *(char_u **)cookie = p;
3884 return line;
3885}
3886
3887/*
3888 * Execute a series of Ex commands in 'str'
3889 */
3890 void
3891execute_cmds_from_string(char_u *str)
3892{
3893 do_cmdline(NULL, get_str_line, (void *)&str,
3894 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3895}
Dominique Pelle748b3082022-01-08 12:41:16 +00003896#endif
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02003897
3898/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003899 * Get next line from a list.
3900 * Called by do_cmdline() to get the next line.
3901 * Returns allocated string, or NULL for end of function.
3902 */
Bram Moolenaara7583c42022-05-07 21:14:05 +01003903 char_u *
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003904get_list_line(
3905 int c UNUSED,
3906 void *cookie,
Bram Moolenaare96a2492019-06-25 04:12:16 +02003907 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02003908 getline_opt_T options UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003909{
3910 listitem_T **p = (listitem_T **)cookie;
3911 listitem_T *item = *p;
3912 char_u buf[NUMBUFLEN];
3913 char_u *s;
3914
3915 if (item == NULL)
3916 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003917 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003918 *p = item->li_next;
3919 return s == NULL ? NULL : vim_strsave(s);
3920}
3921
3922/*
3923 * "execute()" function
3924 */
Bram Moolenaar261f3462019-09-07 15:45:32 +02003925 void
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003926execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003927{
3928 char_u *cmd = NULL;
3929 list_T *list = NULL;
3930 int save_msg_silent = msg_silent;
3931 int save_emsg_silent = emsg_silent;
3932 int save_emsg_noredir = emsg_noredir;
3933 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01003934 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003935 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003936 int save_msg_col = msg_col;
Kota Kato3d3f6ac2022-08-04 18:50:14 +01003937 int save_sticky_cmdmod_flags = sticky_cmdmod_flags;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003938 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003939
3940 rettv->vval.v_string = NULL;
3941 rettv->v_type = VAR_STRING;
3942
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003943 if (argvars[arg_off].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003944 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003945 list = argvars[arg_off].vval.v_list;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003946 if (list == NULL || list->lv_len == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003947 // empty list, no commands, empty output
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003948 return;
3949 ++list->lv_refcount;
3950 }
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003951 else if (argvars[arg_off].v_type == VAR_JOB
3952 || argvars[arg_off].v_type == VAR_CHANNEL)
3953 {
Bram Moolenaar68db9962021-05-09 23:19:22 +02003954 semsg(_(e_using_invalid_value_as_string_str),
3955 vartype_name(argvars[arg_off].v_type));
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003956 return;
3957 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003958 else
3959 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003960 cmd = tv_get_string_chk(&argvars[arg_off]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003961 if (cmd == NULL)
3962 return;
3963 }
3964
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003965 if (argvars[arg_off + 1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003966 {
3967 char_u buf[NUMBUFLEN];
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02003968 char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf,
3969 in_vim9script());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003970
3971 if (s == NULL)
3972 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003973 if (*s == NUL)
3974 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003975 if (STRNCMP(s, "silent", 6) == 0)
3976 ++msg_silent;
3977 if (STRCMP(s, "silent!") == 0)
3978 {
3979 emsg_silent = TRUE;
3980 emsg_noredir = TRUE;
3981 }
3982 }
3983 else
3984 ++msg_silent;
3985
3986 if (redir_execute)
3987 save_ga = redir_execute_ga;
Bram Moolenaar04935fb2022-01-08 16:19:22 +00003988 ga_init2(&redir_execute_ga, sizeof(char), 500);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003989 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01003990 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003991 if (!echo_output)
3992 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003993
Kota Kato3d3f6ac2022-08-04 18:50:14 +01003994 // For "legacy call execute('cmd')" and "vim9cmd execute('cmd')" apply the
3995 // command modifiers to "cmd".
3996 sticky_cmdmod_flags = cmdmod.cmod_flags & (CMOD_LEGACY | CMOD_VIM9CMD);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003997 if (cmd != NULL)
3998 do_cmdline_cmd(cmd);
3999 else
4000 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004001 listitem_T *item;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004002
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004003 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004004 item = list->lv_first;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004005 do_cmdline(NULL, get_list_line, (void *)&item,
4006 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
4007 --list->lv_refcount;
4008 }
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004009 sticky_cmdmod_flags = save_sticky_cmdmod_flags;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004010
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004011 // Need to append a NUL to the result.
Bram Moolenaard297f352017-01-29 20:31:21 +01004012 if (ga_grow(&redir_execute_ga, 1) == OK)
4013 {
4014 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
4015 rettv->vval.v_string = redir_execute_ga.ga_data;
4016 }
4017 else
4018 {
4019 ga_clear(&redir_execute_ga);
4020 rettv->vval.v_string = NULL;
4021 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004022 msg_silent = save_msg_silent;
4023 emsg_silent = save_emsg_silent;
4024 emsg_noredir = save_emsg_noredir;
4025
4026 redir_execute = save_redir_execute;
4027 if (redir_execute)
4028 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01004029 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004030
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01004031 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004032 if (echo_output)
4033 // When not working silently: put it in column zero. A following
4034 // "echon" will overwrite the message, unavoidably.
4035 msg_col = 0;
4036 else
4037 // When working silently: Put it back where it was, since nothing
4038 // should have been written.
4039 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004040}
4041
4042/*
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004043 * "execute()" function
4044 */
4045 static void
4046f_execute(typval_T *argvars, typval_T *rettv)
4047{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004048 if (in_vim9script()
4049 && (check_for_string_or_list_arg(argvars, 0) == FAIL
4050 || check_for_opt_string_arg(argvars, 1) == FAIL))
4051 return;
4052
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004053 execute_common(argvars, rettv, 0);
4054}
4055
4056/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004057 * "exists()" function
4058 */
Bram Moolenaarbb7ee7a2021-08-02 20:06:50 +02004059 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004060f_exists(typval_T *argvars, typval_T *rettv)
4061{
4062 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004063 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004064
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004065 if (in_vim9script() && check_for_nonempty_string_arg(argvars, 0) == FAIL)
4066 return;
4067
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004068 p = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004069 if (*p == '$') // environment variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004070 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004071 // first try "normal" environment variables (fast)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004072 if (mch_getenv(p + 1) != NULL)
4073 n = TRUE;
4074 else
4075 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004076 // try expanding things like $VIM and ${HOME}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004077 p = expand_env_save(p);
4078 if (p != NULL && *p != '$')
4079 n = TRUE;
4080 vim_free(p);
4081 }
4082 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004083 else if (*p == '&' || *p == '+') // option
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004084 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004085 n = (eval_option(&p, NULL, TRUE) == OK);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004086 if (*skipwhite(p) != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004087 n = FALSE; // trailing garbage
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004088 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004089 else if (*p == '*') // internal or user defined function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004090 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02004091 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004092 }
Bram Moolenaar15c47602020-03-26 22:16:48 +01004093 else if (*p == '?') // internal function only
4094 {
4095 n = has_internal_func_name(p + 1);
4096 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004097 else if (*p == ':')
4098 {
4099 n = cmd_exists(p + 1);
4100 }
4101 else if (*p == '#')
4102 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004103 if (p[1] == '#')
4104 n = autocmd_supported(p + 2);
4105 else
4106 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004107 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004108 else // internal variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004109 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01004110 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004111 }
4112
4113 rettv->vval.v_number = n;
4114}
4115
Bram Moolenaar26735992021-08-08 14:43:22 +02004116 static void
4117f_exists_compiled(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4118{
4119 emsg(_(e_exists_compiled_can_only_be_used_in_def_function));
4120}
4121
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004122/*
4123 * "expand()" function
4124 */
4125 static void
4126f_expand(typval_T *argvars, typval_T *rettv)
4127{
4128 char_u *s;
4129 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004130 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4131 expand_T xpc;
4132 int error = FALSE;
4133 char_u *result;
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004134#ifdef BACKSLASH_IN_FILENAME
4135 char_u *p_csl_save = p_csl;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004136#endif
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004137
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004138 if (in_vim9script()
4139 && (check_for_string_arg(argvars, 0) == FAIL
4140 || check_for_opt_bool_arg(argvars, 1) == FAIL
4141 || (argvars[1].v_type != VAR_UNKNOWN
4142 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
4143 return;
4144
4145#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004146 // avoid using 'completeslash' here
4147 p_csl = empty_option;
4148#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004149
4150 rettv->v_type = VAR_STRING;
4151 if (argvars[1].v_type != VAR_UNKNOWN
4152 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004153 && tv_get_bool_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004154 && !error)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004155 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004156
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004157 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004158 if (*s == '%' || *s == '#' || *s == '<')
4159 {
Bram Moolenaar57544522022-04-12 12:54:11 +01004160 char *errormsg = NULL;
4161
4162 if (p_verbose == 0)
4163 ++emsg_off;
Bram Moolenaara96edb72022-04-28 17:52:24 +01004164 result = eval_vars(s, s, &len, NULL, &errormsg, NULL, FALSE);
Bram Moolenaar57544522022-04-12 12:54:11 +01004165 if (p_verbose == 0)
4166 --emsg_off;
4167 else if (errormsg != NULL)
4168 emsg(errormsg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004169 if (rettv->v_type == VAR_LIST)
4170 {
Bram Moolenaar93a10962022-06-16 11:42:09 +01004171 if (rettv_list_alloc(rettv) == OK && result != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004172 list_append_string(rettv->vval.v_list, result, -1);
Bram Moolenaar86173482019-10-01 17:02:16 +02004173 vim_free(result);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004174 }
4175 else
4176 rettv->vval.v_string = result;
4177 }
4178 else
4179 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004180 // When the optional second argument is non-zero, don't remove matches
4181 // for 'wildignore' and don't put matches for 'suffixes' at the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004182 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004183 && tv_get_bool_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004184 options |= WILD_KEEP_ALL;
4185 if (!error)
4186 {
4187 ExpandInit(&xpc);
4188 xpc.xp_context = EXPAND_FILES;
4189 if (p_wic)
4190 options += WILD_ICASE;
4191 if (rettv->v_type == VAR_STRING)
4192 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
4193 options, WILD_ALL);
Bram Moolenaar93a10962022-06-16 11:42:09 +01004194 else if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004195 {
4196 int i;
4197
4198 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
4199 for (i = 0; i < xpc.xp_numfiles; i++)
4200 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
4201 ExpandCleanup(&xpc);
4202 }
4203 }
4204 else
4205 rettv->vval.v_string = NULL;
4206 }
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004207#ifdef BACKSLASH_IN_FILENAME
4208 p_csl = p_csl_save;
4209#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004210}
4211
4212/*
Bram Moolenaar80dad482019-06-09 17:22:31 +02004213 * "expandcmd()" function
4214 * Expand all the special characters in a command string.
4215 */
4216 static void
4217f_expandcmd(typval_T *argvars, typval_T *rettv)
4218{
4219 exarg_T eap;
4220 char_u *cmdstr;
4221 char *errormsg = NULL;
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004222 int emsgoff = TRUE;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004223
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004224 if (in_vim9script()
4225 && (check_for_string_arg(argvars, 0) == FAIL
4226 || check_for_opt_dict_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004227 return;
4228
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004229 if (argvars[1].v_type == VAR_DICT
Bram Moolenaard61efa52022-07-23 09:52:04 +01004230 && dict_get_bool(argvars[1].vval.v_dict, "errmsg", VVAL_FALSE))
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004231 emsgoff = FALSE;
4232
Bram Moolenaar80dad482019-06-09 17:22:31 +02004233 rettv->v_type = VAR_STRING;
4234 cmdstr = vim_strsave(tv_get_string(&argvars[0]));
4235
4236 memset(&eap, 0, sizeof(eap));
4237 eap.cmd = cmdstr;
4238 eap.arg = cmdstr;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004239 eap.argt |= EX_NOSPC;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004240 eap.usefilter = FALSE;
4241 eap.nextcmd = NULL;
4242 eap.cmdidx = CMD_USER;
4243
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004244 if (emsgoff)
4245 ++emsg_off;
4246 if (expand_filename(&eap, &cmdstr, &errormsg) == FAIL)
4247 if (!emsgoff && errormsg != NULL && *errormsg != NUL)
4248 emsg(errormsg);
4249 if (emsgoff)
4250 --emsg_off;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004251
4252 rettv->vval.v_string = cmdstr;
4253}
4254
4255/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004256 * "feedkeys()" function
4257 */
4258 static void
4259f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
4260{
4261 int remap = TRUE;
4262 int insert = FALSE;
4263 char_u *keys, *flags;
4264 char_u nbuf[NUMBUFLEN];
4265 int typed = FALSE;
4266 int execute = FALSE;
Bram Moolenaara9725222022-01-16 13:30:33 +00004267 int context = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004268 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004269 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004270 char_u *keys_esc;
4271
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004272 // This is not allowed in the sandbox. If the commands would still be
4273 // executed in the sandbox it would be OK, but it probably happens later,
4274 // when "sandbox" is no longer set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004275 if (check_secure())
4276 return;
4277
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004278 if (in_vim9script()
4279 && (check_for_string_arg(argvars, 0) == FAIL
4280 || check_for_opt_string_arg(argvars, 1) == FAIL))
4281 return;
4282
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004283 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004284
4285 if (argvars[1].v_type != VAR_UNKNOWN)
4286 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004287 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004288 for ( ; *flags != NUL; ++flags)
4289 {
4290 switch (*flags)
4291 {
4292 case 'n': remap = FALSE; break;
4293 case 'm': remap = TRUE; break;
4294 case 't': typed = TRUE; break;
4295 case 'i': insert = TRUE; break;
4296 case 'x': execute = TRUE; break;
Bram Moolenaara9725222022-01-16 13:30:33 +00004297 case 'c': context = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004298 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004299 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004300 }
4301 }
4302 }
4303
4304 if (*keys != NUL || execute)
4305 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004306 // Need to escape K_SPECIAL and CSI before putting the string in the
4307 // typeahead buffer.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004308 keys_esc = vim_strsave_escape_csi(keys);
4309 if (keys_esc != NULL)
4310 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004311 if (lowlevel)
4312 {
4313#ifdef USE_INPUT_BUF
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01004314 int idx;
4315 int len = (int)STRLEN(keys);
4316
4317 for (idx = 0; idx < len; ++idx)
4318 {
4319 // if a CTRL-C was typed, set got_int, similar to what
4320 // happens in fill_input_buf()
4321 if (keys[idx] == 3 && ctrl_c_interrupts && typed)
4322 got_int = TRUE;
4323 add_to_input_buf(keys + idx, 1);
4324 }
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004325#else
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004326 emsg(_(e_lowlevel_input_not_supported));
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004327#endif
4328 }
4329 else
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004330 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004331 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004332 insert ? 0 : typebuf.tb_len, !typed, FALSE);
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004333 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004334#ifdef FEAT_TIMERS
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004335 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004336#endif
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004337 || input_busy)
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004338 typebuf_was_filled = TRUE;
4339 }
4340 vim_free(keys_esc);
4341
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004342 if (execute)
4343 {
Bram Moolenaara9725222022-01-16 13:30:33 +00004344 int save_msg_scroll = msg_scroll;
4345 sctx_T save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004346
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004347 // Avoid a 1 second delay when the keys start Insert mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004348 msg_scroll = FALSE;
4349
Bram Moolenaara9725222022-01-16 13:30:33 +00004350 if (context)
4351 {
4352 save_sctx = current_sctx;
4353 current_sctx.sc_sid = 0;
4354 current_sctx.sc_version = 0;
4355 }
4356
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004357 if (!dangerous)
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004358 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004359 ++ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004360 ++in_feedkeys;
4361 }
Bram Moolenaar905dd902019-04-07 14:21:47 +02004362 exec_normal(TRUE, lowlevel, TRUE);
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004363 if (!dangerous)
Bram Moolenaar189832b2020-09-23 12:29:11 +02004364 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004365 --ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02004366 --in_feedkeys;
Bram Moolenaar189832b2020-09-23 12:29:11 +02004367 }
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02004368
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004369 msg_scroll |= save_msg_scroll;
Bram Moolenaara9725222022-01-16 13:30:33 +00004370
4371 if (context)
4372 current_sctx = save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004373 }
4374 }
4375 }
4376}
4377
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004378/*
4379 * "fnameescape({string})" function
4380 */
4381 static void
4382f_fnameescape(typval_T *argvars, typval_T *rettv)
4383{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004384 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4385 return;
4386
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004387 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01004388 tv_get_string(&argvars[0]), VSE_NONE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004389 rettv->v_type = VAR_STRING;
4390}
4391
4392/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004393 * "foreground()" function
4394 */
4395 static void
4396f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4397{
4398#ifdef FEAT_GUI
4399 if (gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004400 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004401 gui_mch_set_foreground();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004402 return;
4403 }
4404#endif
4405#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004406 win32_set_foreground();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004407#endif
4408}
4409
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004410 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004411common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004412{
4413 char_u *s;
4414 char_u *name;
4415 int use_string = FALSE;
4416 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004417 char_u *trans_name = NULL;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004418 int is_global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004419
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004420 if (in_vim9script()
Bram Moolenaarae1068a2021-12-25 19:43:44 +00004421 && (check_for_string_or_func_arg(argvars, 0) == FAIL
4422 || check_for_opt_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004423 || (argvars[1].v_type != VAR_UNKNOWN
4424 && check_for_opt_dict_arg(argvars, 2) == FAIL)))
4425 return;
4426
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004427 if (argvars[0].v_type == VAR_FUNC)
4428 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004429 // function(MyFunc, [arg], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004430 s = argvars[0].vval.v_string;
4431 }
4432 else if (argvars[0].v_type == VAR_PARTIAL
4433 && argvars[0].vval.v_partial != NULL)
4434 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004435 // function(dict.MyFunc, [arg])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004436 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004437 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004438 }
4439 else
4440 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004441 // function('MyFunc', [arg], dict)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004442 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004443 use_string = TRUE;
4444 }
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004445 if (s == NULL)
4446 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004447 semsg(_(e_invalid_argument_str), "NULL");
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004448 return;
4449 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004450
Bram Moolenaar843b8842016-08-21 14:36:15 +02004451 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004452 {
4453 name = s;
Bram Moolenaareba3b7f2021-11-30 18:25:08 +00004454 trans_name = save_function_name(&name, &is_global, FALSE,
4455 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004456 if (*name != NUL)
4457 s = NULL;
4458 }
4459
Bram Moolenaar843b8842016-08-21 14:36:15 +02004460 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
4461 || (is_funcref && trans_name == NULL))
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00004462 semsg(_(e_invalid_argument_str),
4463 use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004464 // Don't check an autoload name for existence here.
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004465 else if (trans_name != NULL && (is_funcref
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004466 ? find_func(trans_name, is_global) == NULL
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004467 : !translated_function_exists(trans_name, is_global)))
Bram Moolenaara6f79292022-01-04 21:30:47 +00004468 semsg(_(e_unknown_function_str_2), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004469 else
4470 {
4471 int dict_idx = 0;
4472 int arg_idx = 0;
4473 list_T *list = NULL;
4474
4475 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004476 // Expand s: and <SID> into <SNR>nr_, so that the function can
4477 // also be called from another script. Using trans_function_name()
4478 // would also work, but some plugins depend on the name being
4479 // printable text.
Yegappan Lakshmanane7f4abd2021-12-24 20:47:38 +00004480 name = get_scriptlocal_funcname(s);
Bram Moolenaarc2f17f72022-02-21 13:13:50 +00004481 else if (trans_name != NULL && *trans_name == K_SPECIAL)
4482 name = alloc_printable_func_name(trans_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004483 else
4484 name = vim_strsave(s);
4485
4486 if (argvars[1].v_type != VAR_UNKNOWN)
4487 {
4488 if (argvars[2].v_type != VAR_UNKNOWN)
4489 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004490 // function(name, [args], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004491 arg_idx = 1;
4492 dict_idx = 2;
4493 }
4494 else if (argvars[1].v_type == VAR_DICT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004495 // function(name, dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004496 dict_idx = 1;
4497 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004498 // function(name, [args])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004499 arg_idx = 1;
4500 if (dict_idx > 0)
4501 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01004502 if (check_for_dict_arg(argvars, dict_idx) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004503 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004504 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004505 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004506 }
4507 if (argvars[dict_idx].vval.v_dict == NULL)
4508 dict_idx = 0;
4509 }
4510 if (arg_idx > 0)
4511 {
4512 if (argvars[arg_idx].v_type != VAR_LIST)
4513 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004514 emsg(_(e_second_argument_of_function_must_be_list_or_dict));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004515 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004516 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004517 }
4518 list = argvars[arg_idx].vval.v_list;
4519 if (list == NULL || list->lv_len == 0)
4520 arg_idx = 0;
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004521 else if (list->lv_len > MAX_FUNC_ARGS)
4522 {
Yegappan Lakshmanan5018a832022-04-02 21:12:21 +01004523 emsg_funcname(e_too_many_arguments_for_function_str, s);
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004524 vim_free(name);
4525 goto theend;
4526 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004527 }
4528 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004529 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004530 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004531 partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004532
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004533 // result is a VAR_PARTIAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004534 if (pt == NULL)
4535 vim_free(name);
4536 else
4537 {
4538 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
4539 {
4540 listitem_T *li;
4541 int i = 0;
4542 int arg_len = 0;
4543 int lv_len = 0;
4544
4545 if (arg_pt != NULL)
4546 arg_len = arg_pt->pt_argc;
4547 if (list != NULL)
4548 lv_len = list->lv_len;
4549 pt->pt_argc = arg_len + lv_len;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004550 pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004551 if (pt->pt_argv == NULL)
4552 {
4553 vim_free(pt);
4554 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004555 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004556 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004557 for (i = 0; i < arg_len; i++)
4558 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
4559 if (lv_len > 0)
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004560 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004561 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004562 FOR_ALL_LIST_ITEMS(list, li)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004563 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004564 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004565 }
4566
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004567 // For "function(dict.func, [], dict)" and "func" is a partial
4568 // use "dict". That is backwards compatible.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004569 if (dict_idx > 0)
4570 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004571 // The dict is bound explicitly, pt_auto is FALSE.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004572 pt->pt_dict = argvars[dict_idx].vval.v_dict;
4573 ++pt->pt_dict->dv_refcount;
4574 }
4575 else if (arg_pt != NULL)
4576 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004577 // If the dict was bound automatically the result is also
4578 // bound automatically.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004579 pt->pt_dict = arg_pt->pt_dict;
4580 pt->pt_auto = arg_pt->pt_auto;
4581 if (pt->pt_dict != NULL)
4582 ++pt->pt_dict->dv_refcount;
4583 }
4584
4585 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004586 if (arg_pt != NULL && arg_pt->pt_func != NULL)
4587 {
4588 pt->pt_func = arg_pt->pt_func;
4589 func_ptr_ref(pt->pt_func);
4590 vim_free(name);
4591 }
4592 else if (is_funcref)
4593 {
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004594 pt->pt_func = find_func(trans_name, is_global);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004595 func_ptr_ref(pt->pt_func);
4596 vim_free(name);
4597 }
4598 else
4599 {
4600 pt->pt_name = name;
4601 func_ref(name);
4602 }
Bram Moolenaar92368aa2022-02-07 17:50:39 +00004603
4604 if (arg_pt != NULL)
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00004605 {
4606 pt->pt_outer_partial = arg_pt;
4607 ++arg_pt->pt_refcount;
4608 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004609 }
4610 rettv->v_type = VAR_PARTIAL;
4611 rettv->vval.v_partial = pt;
4612 }
4613 else
4614 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004615 // result is a VAR_FUNC
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004616 rettv->v_type = VAR_FUNC;
4617 rettv->vval.v_string = name;
4618 func_ref(name);
4619 }
4620 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004621theend:
4622 vim_free(trans_name);
4623}
4624
4625/*
4626 * "funcref()" function
4627 */
4628 static void
4629f_funcref(typval_T *argvars, typval_T *rettv)
4630{
4631 common_function(argvars, rettv, TRUE);
4632}
4633
4634/*
4635 * "function()" function
4636 */
4637 static void
4638f_function(typval_T *argvars, typval_T *rettv)
4639{
4640 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004641}
4642
4643/*
4644 * "garbagecollect()" function
4645 */
4646 static void
4647f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
4648{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004649 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
4650 return;
4651
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004652 // This is postponed until we are back at the toplevel, because we may be
4653 // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004654 want_garbage_collect = TRUE;
4655
Bram Moolenaar2df47312020-09-05 17:30:44 +02004656 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004657 garbage_collect_at_exit = TRUE;
4658}
4659
4660/*
4661 * "get()" function
4662 */
4663 static void
4664f_get(typval_T *argvars, typval_T *rettv)
4665{
4666 listitem_T *li;
4667 list_T *l;
4668 dictitem_T *di;
4669 dict_T *d;
4670 typval_T *tv = NULL;
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004671 int what_is_dict = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004672
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004673 if (argvars[0].v_type == VAR_BLOB)
4674 {
4675 int error = FALSE;
4676 int idx = tv_get_number_chk(&argvars[1], &error);
4677
4678 if (!error)
4679 {
4680 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004681 if (idx < 0)
4682 idx = blob_len(argvars[0].vval.v_blob) + idx;
4683 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
4684 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004685 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004686 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004687 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004688 tv = rettv;
4689 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004690 }
4691 }
4692 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004693 {
4694 if ((l = argvars[0].vval.v_list) != NULL)
4695 {
4696 int error = FALSE;
4697
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004698 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004699 if (!error && li != NULL)
4700 tv = &li->li_tv;
4701 }
4702 }
4703 else if (argvars[0].v_type == VAR_DICT)
4704 {
4705 if ((d = argvars[0].vval.v_dict) != NULL)
4706 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004707 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004708 if (di != NULL)
4709 tv = &di->di_tv;
4710 }
4711 }
4712 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
4713 {
4714 partial_T *pt;
4715 partial_T fref_pt;
4716
4717 if (argvars[0].v_type == VAR_PARTIAL)
4718 pt = argvars[0].vval.v_partial;
4719 else
4720 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02004721 CLEAR_FIELD(fref_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004722 fref_pt.pt_name = argvars[0].vval.v_string;
4723 pt = &fref_pt;
4724 }
4725
4726 if (pt != NULL)
4727 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004728 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004729
4730 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
4731 {
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004732 char_u *name = partial_name(pt);
4733
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004734 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004735 if (name == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004736 rettv->vval.v_string = NULL;
4737 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004738 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004739 if (rettv->v_type == VAR_FUNC)
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01004740 func_ref(name);
4741 if (*what == 'n' && pt->pt_name == NULL
4742 && pt->pt_func != NULL)
4743 // use <SNR> instead of the byte code
4744 name = printable_func_name(pt->pt_func);
4745 rettv->vval.v_string = vim_strsave(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004746 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004747 }
4748 else if (STRCMP(what, "dict") == 0)
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004749 {
4750 what_is_dict = TRUE;
4751 if (pt->pt_dict != NULL)
4752 rettv_dict_set(rettv, pt->pt_dict);
4753 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004754 else if (STRCMP(what, "args") == 0)
4755 {
4756 rettv->v_type = VAR_LIST;
4757 if (rettv_list_alloc(rettv) == OK)
4758 {
4759 int i;
4760
4761 for (i = 0; i < pt->pt_argc; ++i)
4762 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
4763 }
4764 }
4765 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004766 semsg(_(e_invalid_argument_str), what);
Bram Moolenaarf91aac52019-07-28 13:21:01 +02004767
4768 // When {what} == "dict" and pt->pt_dict == NULL, evaluate the
4769 // third argument
4770 if (!what_is_dict)
4771 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004772 }
4773 }
4774 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00004775 semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004776
4777 if (tv == NULL)
4778 {
4779 if (argvars[2].v_type != VAR_UNKNOWN)
4780 copy_tv(&argvars[2], rettv);
4781 }
4782 else
4783 copy_tv(tv, rettv);
4784}
4785
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004786/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004787 * "getchangelist()" function
4788 */
4789 static void
4790f_getchangelist(typval_T *argvars, typval_T *rettv)
4791{
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004792 buf_T *buf;
4793 int i;
4794 list_T *l;
4795 dict_T *d;
LemonBoydb0ea7f2022-04-10 17:59:26 +01004796 int changelistindex;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004797
Bram Moolenaar93a10962022-06-16 11:42:09 +01004798 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004799 return;
4800
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004801 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
4802 return;
4803
Bram Moolenaar4c313b12019-08-24 22:58:31 +02004804 if (argvars[0].v_type == VAR_UNKNOWN)
4805 buf = curbuf;
4806 else
Bram Moolenaara5d38412020-09-02 21:02:35 +02004807 buf = tv_get_buf_from_arg(&argvars[0]);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004808 if (buf == NULL)
4809 return;
4810
4811 l = list_alloc();
4812 if (l == NULL)
4813 return;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004814 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01004815 {
4816 vim_free(l);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004817 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01004818 }
4819
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004820 /*
LemonBoydb0ea7f2022-04-10 17:59:26 +01004821 * The current window change list index tracks only the position for the
4822 * current buffer. For other buffers use the stored index for the current
4823 * window, or, if that's not available, the change list length.
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004824 */
LemonBoydb0ea7f2022-04-10 17:59:26 +01004825 if (buf == curwin->w_buffer)
4826 {
4827 changelistindex = curwin->w_changelistidx;
4828 }
4829 else
4830 {
4831 wininfo_T *wip;
4832
4833 FOR_ALL_BUF_WININFO(buf, wip)
4834 if (wip->wi_win == curwin)
4835 break;
4836 changelistindex = wip != NULL ? wip->wi_changelistidx
4837 : buf->b_changelistlen;
4838 }
4839 list_append_number(rettv->vval.v_list, (varnumber_T)changelistindex);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004840
4841 for (i = 0; i < buf->b_changelistlen; ++i)
4842 {
4843 if (buf->b_changelist[i].lnum == 0)
4844 continue;
4845 if ((d = dict_alloc()) == NULL)
4846 return;
4847 if (list_append_dict(l, d) == FAIL)
4848 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004849 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
4850 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004851 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004852 }
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004853}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004854
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004855 static void
4856getpos_both(
4857 typval_T *argvars,
4858 typval_T *rettv,
4859 int getcurpos,
4860 int charcol)
4861{
4862 pos_T *fp = NULL;
4863 pos_T pos;
4864 win_T *wp = curwin;
4865 list_T *l;
4866 int fnum = -1;
4867
4868 if (rettv_list_alloc(rettv) == OK)
4869 {
4870 l = rettv->vval.v_list;
4871 if (getcurpos)
4872 {
4873 if (argvars[0].v_type != VAR_UNKNOWN)
4874 {
4875 wp = find_win_by_nr_or_id(&argvars[0]);
4876 if (wp != NULL)
4877 fp = &wp->w_cursor;
4878 }
4879 else
4880 fp = &curwin->w_cursor;
4881 if (fp != NULL && charcol)
4882 {
4883 pos = *fp;
Bram Moolenaar91458462021-01-13 20:08:38 +01004884 pos.col =
4885 buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004886 fp = &pos;
4887 }
4888 }
4889 else
4890 fp = var2fpos(&argvars[0], TRUE, &fnum, charcol);
4891 if (fnum != -1)
4892 list_append_number(l, (varnumber_T)fnum);
4893 else
4894 list_append_number(l, (varnumber_T)0);
4895 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
4896 : (varnumber_T)0);
4897 list_append_number(l, (fp != NULL)
4898 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
4899 : (varnumber_T)0);
4900 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
4901 (varnumber_T)0);
4902 if (getcurpos)
4903 {
4904 int save_set_curswant = curwin->w_set_curswant;
4905 colnr_T save_curswant = curwin->w_curswant;
4906 colnr_T save_virtcol = curwin->w_virtcol;
4907
4908 if (wp == curwin)
4909 update_curswant();
4910 list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL
4911 ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1);
4912
4913 // Do not change "curswant", as it is unexpected that a get
4914 // function has a side effect.
4915 if (wp == curwin && save_set_curswant)
4916 {
4917 curwin->w_set_curswant = save_set_curswant;
4918 curwin->w_curswant = save_curswant;
4919 curwin->w_virtcol = save_virtcol;
4920 curwin->w_valid &= ~VALID_VIRTCOL;
4921 }
4922 }
4923 }
4924 else
4925 rettv->vval.v_number = FALSE;
4926}
4927
4928/*
4929 * "getcharpos()" function
4930 */
4931 static void
4932f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv)
4933{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004934 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4935 return;
4936
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004937 getpos_both(argvars, rettv, FALSE, TRUE);
4938}
4939
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004940/*
4941 * "getcharsearch()" function
4942 */
4943 static void
4944f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
4945{
Bram Moolenaar93a10962022-06-16 11:42:09 +01004946 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004947 {
4948 dict_T *dict = rettv->vval.v_dict;
4949
Bram Moolenaare0be1672018-07-08 16:50:37 +02004950 dict_add_string(dict, "char", last_csearch());
4951 dict_add_number(dict, "forward", last_csearch_forward());
4952 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004953 }
4954}
4955
4956/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004957 * "getenv()" function
4958 */
4959 static void
4960f_getenv(typval_T *argvars, typval_T *rettv)
4961{
4962 int mustfree = FALSE;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004963 char_u *p;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004964
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004965 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4966 return;
4967
4968 p = vim_getenv(tv_get_string(&argvars[0]), &mustfree);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004969 if (p == NULL)
4970 {
4971 rettv->v_type = VAR_SPECIAL;
4972 rettv->vval.v_number = VVAL_NULL;
4973 return;
4974 }
4975 if (!mustfree)
4976 p = vim_strsave(p);
4977 rettv->vval.v_string = p;
4978 rettv->v_type = VAR_STRING;
4979}
4980
4981/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004982 * "getfontname()" function
4983 */
4984 static void
4985f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
4986{
4987 rettv->v_type = VAR_STRING;
4988 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004989
4990 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
4991 return;
4992
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004993#ifdef FEAT_GUI
4994 if (gui.in_use)
4995 {
4996 GuiFont font;
4997 char_u *name = NULL;
4998
4999 if (argvars[0].v_type == VAR_UNKNOWN)
5000 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005001 // Get the "Normal" font. Either the name saved by
5002 // hl_set_font_name() or from the font ID.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005003 font = gui.norm_font;
5004 name = hl_get_font_name();
5005 }
5006 else
5007 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005008 name = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005009 if (STRCMP(name, "*") == 0) // don't use font dialog
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005010 return;
5011 font = gui_mch_get_font(name, FALSE);
5012 if (font == NOFONT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005013 return; // Invalid font name, return empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005014 }
5015 rettv->vval.v_string = gui_mch_get_fontname(font, name);
5016 if (argvars[0].v_type != VAR_UNKNOWN)
5017 gui_mch_free_font(font);
5018 }
5019#endif
5020}
5021
5022/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01005023 * "getjumplist()" function
5024 */
5025 static void
5026f_getjumplist(typval_T *argvars, typval_T *rettv)
5027{
Bram Moolenaar4f505882018-02-10 21:06:32 +01005028 win_T *wp;
5029 int i;
5030 list_T *l;
5031 dict_T *d;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005032
Bram Moolenaar93a10962022-06-16 11:42:09 +01005033 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar4f505882018-02-10 21:06:32 +01005034 return;
5035
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005036 if (in_vim9script()
5037 && (check_for_opt_number_arg(argvars, 0) == FAIL
5038 || (argvars[0].v_type != VAR_UNKNOWN
5039 && check_for_opt_number_arg(argvars, 1) == FAIL)))
5040 return;
5041
Bram Moolenaar00aa0692019-04-27 20:37:57 +02005042 wp = find_tabwin(&argvars[0], &argvars[1], NULL);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005043 if (wp == NULL)
5044 return;
5045
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01005046 cleanup_jumplist(wp, TRUE);
5047
Bram Moolenaar4f505882018-02-10 21:06:32 +01005048 l = list_alloc();
5049 if (l == NULL)
5050 return;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005051 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005052 {
5053 vim_free(l);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005054 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005055 }
5056
Bram Moolenaar4f505882018-02-10 21:06:32 +01005057 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
5058
5059 for (i = 0; i < wp->w_jumplistlen; ++i)
5060 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005061 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
5062 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005063 if ((d = dict_alloc()) == NULL)
5064 return;
5065 if (list_append_dict(l, d) == FAIL)
5066 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005067 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
5068 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005069 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005070 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005071 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02005072 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005073 }
Bram Moolenaar4f505882018-02-10 21:06:32 +01005074}
5075
5076/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005077 * "getpid()" function
5078 */
5079 static void
5080f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
5081{
5082 rettv->vval.v_number = mch_get_pid();
5083}
5084
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005085/*
5086 * "getcurpos()" function
5087 */
5088 static void
5089f_getcurpos(typval_T *argvars, typval_T *rettv)
5090{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005091 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5092 return;
5093
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005094 getpos_both(argvars, rettv, TRUE, FALSE);
5095}
5096
5097 static void
5098f_getcursorcharpos(typval_T *argvars, typval_T *rettv)
5099{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005100 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5101 return;
5102
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005103 getpos_both(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005104}
5105
5106/*
5107 * "getpos(string)" function
5108 */
5109 static void
5110f_getpos(typval_T *argvars, typval_T *rettv)
5111{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005112 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5113 return;
5114
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005115 getpos_both(argvars, rettv, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005116}
5117
5118/*
zeertzjqd3f00f52021-12-24 12:02:43 +00005119 * Common between getreg(), getreginfo() and getregtype(): get the register
5120 * name from the first argument.
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005121 * Returns zero on error.
5122 */
5123 static int
5124getreg_get_regname(typval_T *argvars)
5125{
5126 char_u *strregname;
5127
5128 if (argvars[0].v_type != VAR_UNKNOWN)
5129 {
5130 strregname = tv_get_string_chk(&argvars[0]);
5131 if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1)
5132 {
5133 semsg(_(e_register_name_must_be_one_char_str), strregname);
5134 strregname = NULL;
5135 }
5136 if (strregname == NULL) // type error; errmsg already given
5137 return 0;
5138 }
5139 else
5140 // Default to v:register
5141 strregname = get_vim_var_str(VV_REG);
5142
5143 return *strregname == 0 ? '"' : *strregname;
5144}
5145
5146/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005147 * "getreg()" function
5148 */
5149 static void
5150f_getreg(typval_T *argvars, typval_T *rettv)
5151{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005152 int regname;
5153 int arg2 = FALSE;
5154 int return_list = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005155
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005156 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005157 && (check_for_opt_string_arg(argvars, 0) == FAIL
5158 || (argvars[0].v_type != VAR_UNKNOWN
5159 && (check_for_opt_bool_arg(argvars, 1) == FAIL
5160 || (argvars[1].v_type != VAR_UNKNOWN
5161 && check_for_opt_bool_arg(argvars, 2) == FAIL)))))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005162 return;
5163
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005164 regname = getreg_get_regname(argvars);
5165 if (regname == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005166 return;
5167
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005168 if (argvars[0].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_UNKNOWN)
5169 {
5170 int error = FALSE;
5171
5172 arg2 = (int)tv_get_bool_chk(&argvars[1], &error);
5173
5174 if (!error && argvars[2].v_type != VAR_UNKNOWN)
5175 return_list = (int)tv_get_bool_chk(&argvars[2], &error);
5176 if (error)
5177 return;
5178 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005179
5180 if (return_list)
5181 {
5182 rettv->v_type = VAR_LIST;
5183 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
5184 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
5185 if (rettv->vval.v_list == NULL)
5186 (void)rettv_list_alloc(rettv);
5187 else
5188 ++rettv->vval.v_list->lv_refcount;
5189 }
5190 else
5191 {
5192 rettv->v_type = VAR_STRING;
5193 rettv->vval.v_string = get_reg_contents(regname,
5194 arg2 ? GREG_EXPR_SRC : 0);
5195 }
5196}
5197
5198/*
5199 * "getregtype()" function
5200 */
5201 static void
5202f_getregtype(typval_T *argvars, typval_T *rettv)
5203{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005204 int regname;
5205 char_u buf[NUMBUFLEN + 2];
5206 long reglen = 0;
5207
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005208 // on error return an empty string
5209 rettv->v_type = VAR_STRING;
5210 rettv->vval.v_string = NULL;
5211
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005212 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5213 return;
5214
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005215 regname = getreg_get_regname(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005216 if (regname == 0)
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005217 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005218
5219 buf[0] = NUL;
5220 buf[1] = NUL;
5221 switch (get_reg_type(regname, &reglen))
5222 {
5223 case MLINE: buf[0] = 'V'; break;
5224 case MCHAR: buf[0] = 'v'; break;
5225 case MBLOCK:
5226 buf[0] = Ctrl_V;
5227 sprintf((char *)buf + 1, "%ld", reglen + 1);
5228 break;
5229 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005230 rettv->vval.v_string = vim_strsave(buf);
5231}
5232
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005233/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005234 * "gettagstack()" function
5235 */
5236 static void
5237f_gettagstack(typval_T *argvars, typval_T *rettv)
5238{
5239 win_T *wp = curwin; // default is current window
5240
Bram Moolenaar93a10962022-06-16 11:42:09 +01005241 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005242 return;
5243
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005244 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5245 return;
5246
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005247 if (argvars[0].v_type != VAR_UNKNOWN)
5248 {
5249 wp = find_win_by_nr_or_id(&argvars[0]);
5250 if (wp == NULL)
5251 return;
5252 }
5253
5254 get_tagstack(wp, rettv->vval.v_dict);
5255}
5256
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005257/*
5258 * "gettext()" function
5259 */
5260 static void
5261f_gettext(typval_T *argvars, typval_T *rettv)
5262{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005263 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5264 return;
5265
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005266 if (argvars[0].v_type != VAR_STRING
5267 || argvars[0].vval.v_string == NULL
5268 || *argvars[0].vval.v_string == NUL)
5269 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005270 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005271 }
5272 else
5273 {
5274 rettv->v_type = VAR_STRING;
5275 rettv->vval.v_string = vim_strsave(
5276 (char_u *)_(argvars[0].vval.v_string));
5277 }
5278}
5279
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005280// for VIM_VERSION_ defines
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005281#include "version.h"
5282
5283/*
5284 * "has()" function
5285 */
Bram Moolenaara259d8d2020-01-31 20:10:50 +01005286 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005287f_has(typval_T *argvars, typval_T *rettv)
5288{
5289 int i;
5290 char_u *name;
Bram Moolenaar79296512020-03-22 16:17:14 +01005291 int x = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005292 int n = FALSE;
Bram Moolenaar79296512020-03-22 16:17:14 +01005293 typedef struct {
5294 char *name;
5295 short present;
5296 } has_item_T;
5297 static has_item_T has_list[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005298 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005299 {"amiga",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005300#ifdef AMIGA
Bram Moolenaar79296512020-03-22 16:17:14 +01005301 1
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005302#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005303 0
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005304#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005305 },
5306 {"arp",
5307#if defined(AMIGA) && defined(FEAT_ARP)
5308 1
5309#else
5310 0
5311#endif
5312 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005313 {"haiku",
5314#ifdef __HAIKU__
5315 1
5316#else
5317 0
5318#endif
5319 },
5320 {"bsd",
5321#if defined(BSD) && !defined(MACOS_X)
5322 1
5323#else
5324 0
5325#endif
5326 },
5327 {"hpux",
5328#ifdef hpux
5329 1
5330#else
5331 0
5332#endif
5333 },
5334 {"linux",
5335#ifdef __linux__
5336 1
5337#else
5338 0
5339#endif
5340 },
5341 {"mac", // Mac OS X (and, once, Mac OS Classic)
5342#ifdef MACOS_X
5343 1
5344#else
5345 0
5346#endif
5347 },
5348 {"osx", // Mac OS X
5349#ifdef MACOS_X
5350 1
5351#else
5352 0
5353#endif
5354 },
5355 {"macunix", // Mac OS X, with the darwin feature
5356#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5357 1
5358#else
5359 0
5360#endif
5361 },
5362 {"osxdarwin", // synonym for macunix
5363#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5364 1
5365#else
5366 0
5367#endif
5368 },
5369 {"qnx",
5370#ifdef __QNX__
5371 1
5372#else
5373 0
5374#endif
5375 },
5376 {"sun",
5377#ifdef SUN_SYSTEM
5378 1
5379#else
5380 0
5381#endif
5382 },
5383 {"unix",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005384#ifdef UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005385 1
5386#else
5387 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005388#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005389 },
5390 {"vms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005391#ifdef VMS
Bram Moolenaar79296512020-03-22 16:17:14 +01005392 1
5393#else
5394 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005395#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005396 },
5397 {"win32",
Bram Moolenaar4f974752019-02-17 17:44:42 +01005398#ifdef MSWIN
Bram Moolenaar79296512020-03-22 16:17:14 +01005399 1
5400#else
5401 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005402#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005403 },
5404 {"win32unix",
K.Takata972db232022-02-04 10:45:38 +00005405#ifdef WIN32UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005406 1
5407#else
5408 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005409#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005410 },
5411 {"win64",
Bram Moolenaar44b443c2019-02-18 22:14:18 +01005412#ifdef _WIN64
Bram Moolenaar79296512020-03-22 16:17:14 +01005413 1
5414#else
5415 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005416#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005417 },
Bram Moolenaar424bcae2022-01-31 14:59:41 +00005418 {"ebcdic", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005419 {"fname_case",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005420#ifndef CASE_INSENSITIVE_FILENAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005421 1
5422#else
5423 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005424#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005425 },
5426 {"acl",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005427#ifdef HAVE_ACL
Bram Moolenaar79296512020-03-22 16:17:14 +01005428 1
5429#else
5430 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005431#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005432 },
5433 {"arabic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005434#ifdef FEAT_ARABIC
Bram Moolenaar79296512020-03-22 16:17:14 +01005435 1
5436#else
5437 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005438#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005439 },
5440 {"autocmd", 1},
5441 {"autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005442#ifdef FEAT_AUTOCHDIR
Bram Moolenaar79296512020-03-22 16:17:14 +01005443 1
5444#else
5445 0
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02005446#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005447 },
5448 {"autoservername",
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005449#ifdef FEAT_AUTOSERVERNAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005450 1
5451#else
5452 0
Bram Moolenaare42a6d22017-11-12 19:21:51 +01005453#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005454 },
5455 {"balloon_eval",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005456#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005457 1
5458#else
5459 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005460#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005461 },
5462 {"balloon_multiline",
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00005463#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01005464 1
5465#else
5466 0
5467#endif
5468 },
5469 {"balloon_eval_term",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01005470#ifdef FEAT_BEVAL_TERM
Bram Moolenaar79296512020-03-22 16:17:14 +01005471 1
5472#else
5473 0
Bram Moolenaar51b0f372017-11-18 18:52:04 +01005474#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005475 },
Bram Moolenaar2ee347f2022-08-26 17:53:44 +01005476 {"builtin_terms", 1},
5477 {"all_builtin_terms", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005478 {"browsefilter",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005479#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01005480 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005481 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar79296512020-03-22 16:17:14 +01005482 1
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005483#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005484 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005485#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005486 },
5487 {"byte_offset",
5488#ifdef FEAT_BYTEOFF
5489 1
5490#else
5491 0
5492#endif
5493 },
5494 {"channel",
5495#ifdef FEAT_JOB_CHANNEL
5496 1
5497#else
5498 0
5499#endif
5500 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01005501 {"cindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005502 {"clientserver",
5503#ifdef FEAT_CLIENTSERVER
5504 1
5505#else
5506 0
5507#endif
5508 },
5509 {"clipboard",
5510#ifdef FEAT_CLIPBOARD
5511 1
5512#else
5513 0
5514#endif
5515 },
5516 {"cmdline_compl", 1},
5517 {"cmdline_hist", 1},
Bram Moolenaar21829c52021-01-26 22:42:21 +01005518 {"cmdwin",
5519#ifdef FEAT_CMDWIN
5520 1
5521#else
5522 0
5523#endif
5524 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005525 {"comments", 1},
5526 {"conceal",
5527#ifdef FEAT_CONCEAL
5528 1
5529#else
5530 0
5531#endif
5532 },
5533 {"cryptv",
5534#ifdef FEAT_CRYPT
5535 1
5536#else
5537 0
5538#endif
5539 },
5540 {"crypt-blowfish",
5541#ifdef FEAT_CRYPT
5542 1
5543#else
5544 0
5545#endif
5546 },
5547 {"crypt-blowfish2",
5548#ifdef FEAT_CRYPT
5549 1
5550#else
5551 0
5552#endif
5553 },
5554 {"cscope",
5555#ifdef FEAT_CSCOPE
5556 1
5557#else
5558 0
5559#endif
5560 },
5561 {"cursorbind", 1},
5562 {"cursorshape",
5563#ifdef CURSOR_SHAPE
5564 1
5565#else
5566 0
5567#endif
5568 },
5569 {"debug",
5570#ifdef DEBUG
5571 1
5572#else
5573 0
5574#endif
5575 },
5576 {"dialog_con",
5577#ifdef FEAT_CON_DIALOG
5578 1
5579#else
5580 0
5581#endif
5582 },
5583 {"dialog_gui",
5584#ifdef FEAT_GUI_DIALOG
5585 1
5586#else
5587 0
5588#endif
5589 },
5590 {"diff",
5591#ifdef FEAT_DIFF
5592 1
5593#else
5594 0
5595#endif
5596 },
5597 {"digraphs",
5598#ifdef FEAT_DIGRAPHS
5599 1
5600#else
5601 0
5602#endif
5603 },
5604 {"directx",
5605#ifdef FEAT_DIRECTX
5606 1
5607#else
5608 0
5609#endif
5610 },
5611 {"dnd",
5612#ifdef FEAT_DND
5613 1
5614#else
5615 0
5616#endif
5617 },
Bram Moolenaar1d1ce612021-06-27 19:02:52 +02005618 {"drop_file",
5619#ifdef HAVE_DROP_FILE
5620 1
5621#else
5622 0
5623#endif
5624 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005625 {"emacs_tags",
5626#ifdef FEAT_EMACS_TAGS
5627 1
5628#else
5629 0
5630#endif
5631 },
5632 {"eval", 1}, // always present, of course!
5633 {"ex_extra", 1}, // graduated feature
5634 {"extra_search",
5635#ifdef FEAT_SEARCH_EXTRA
5636 1
5637#else
5638 0
5639#endif
5640 },
Bram Moolenaarf80f40a2022-08-25 16:02:23 +01005641 {"file_in_path", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005642 {"filterpipe",
5643#if defined(FEAT_FILTERPIPE) && !defined(VIMDLL)
5644 1
5645#else
5646 0
5647#endif
5648 },
5649 {"find_in_path",
5650#ifdef FEAT_FIND_ID
5651 1
5652#else
5653 0
5654#endif
5655 },
5656 {"float",
5657#ifdef FEAT_FLOAT
5658 1
5659#else
5660 0
5661#endif
5662 },
5663 {"folding",
5664#ifdef FEAT_FOLDING
5665 1
5666#else
5667 0
5668#endif
5669 },
5670 {"footer",
5671#ifdef FEAT_FOOTER
5672 1
5673#else
5674 0
5675#endif
5676 },
5677 {"fork",
5678#if !defined(USE_SYSTEM) && defined(UNIX)
5679 1
5680#else
5681 0
5682#endif
5683 },
5684 {"gettext",
5685#ifdef FEAT_GETTEXT
5686 1
5687#else
5688 0
5689#endif
5690 },
5691 {"gui",
5692#ifdef FEAT_GUI
5693 1
5694#else
5695 0
5696#endif
5697 },
Bram Moolenaar0b962e52022-04-03 18:02:37 +01005698 {"gui_neXtaw", 0 },
5699 {"gui_athena", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005700 {"gui_gtk",
5701#ifdef FEAT_GUI_GTK
5702 1
5703#else
5704 0
5705#endif
5706 },
5707 {"gui_gtk2",
5708#if defined(FEAT_GUI_GTK) && !defined(USE_GTK3)
5709 1
5710#else
5711 0
5712#endif
5713 },
5714 {"gui_gtk3",
5715#if defined(FEAT_GUI_GTK) && defined(USE_GTK3)
5716 1
5717#else
5718 0
5719#endif
5720 },
5721 {"gui_gnome",
5722#ifdef FEAT_GUI_GNOME
5723 1
5724#else
5725 0
5726#endif
5727 },
5728 {"gui_haiku",
5729#ifdef FEAT_GUI_HAIKU
5730 1
5731#else
5732 0
5733#endif
5734 },
Bram Moolenaar097148e2020-08-11 21:58:20 +02005735 {"gui_mac", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01005736 {"gui_motif",
5737#ifdef FEAT_GUI_MOTIF
5738 1
5739#else
5740 0
5741#endif
5742 },
5743 {"gui_photon",
5744#ifdef FEAT_GUI_PHOTON
5745 1
5746#else
5747 0
5748#endif
5749 },
5750 {"gui_win32",
5751#ifdef FEAT_GUI_MSWIN
5752 1
5753#else
5754 0
5755#endif
5756 },
5757 {"iconv",
5758#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
5759 1
5760#else
5761 0
5762#endif
5763 },
5764 {"insert_expand", 1},
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02005765 {"ipv6",
5766#ifdef FEAT_IPV6
5767 1
5768#else
5769 0
5770#endif
5771 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005772 {"job",
5773#ifdef FEAT_JOB_CHANNEL
5774 1
5775#else
5776 0
5777#endif
5778 },
Bram Moolenaar739f13a2021-12-13 13:12:53 +00005779 {"jumplist", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005780 {"keymap",
5781#ifdef FEAT_KEYMAP
5782 1
5783#else
5784 0
5785#endif
5786 },
5787 {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure
5788 {"langmap",
5789#ifdef FEAT_LANGMAP
5790 1
5791#else
5792 0
5793#endif
5794 },
5795 {"libcall",
5796#ifdef FEAT_LIBCALL
5797 1
5798#else
5799 0
5800#endif
5801 },
5802 {"linebreak",
5803#ifdef FEAT_LINEBREAK
5804 1
5805#else
5806 0
5807#endif
5808 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01005809 {"lispindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005810 {"listcmds", 1},
5811 {"localmap", 1},
5812 {"lua",
5813#if defined(FEAT_LUA) && !defined(DYNAMIC_LUA)
5814 1
5815#else
5816 0
5817#endif
5818 },
5819 {"menu",
5820#ifdef FEAT_MENU
5821 1
5822#else
5823 0
5824#endif
5825 },
5826 {"mksession",
5827#ifdef FEAT_SESSION
5828 1
5829#else
5830 0
5831#endif
5832 },
5833 {"modify_fname", 1},
5834 {"mouse", 1},
5835 {"mouseshape",
5836#ifdef FEAT_MOUSESHAPE
5837 1
5838#else
5839 0
5840#endif
5841 },
5842 {"mouse_dec",
5843#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC)
5844 1
5845#else
5846 0
5847#endif
5848 },
5849 {"mouse_gpm",
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00005850#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM) && !defined(DYNAMIC_GPM)
Bram Moolenaar79296512020-03-22 16:17:14 +01005851 1
5852#else
5853 0
5854#endif
5855 },
5856 {"mouse_jsbterm",
5857#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB)
5858 1
5859#else
5860 0
5861#endif
5862 },
5863 {"mouse_netterm",
5864#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET)
5865 1
5866#else
5867 0
5868#endif
5869 },
5870 {"mouse_pterm",
5871#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM)
5872 1
5873#else
5874 0
5875#endif
5876 },
5877 {"mouse_sgr",
5878#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5879 1
5880#else
5881 0
5882#endif
5883 },
5884 {"mouse_sysmouse",
5885#if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE)
5886 1
5887#else
5888 0
5889#endif
5890 },
5891 {"mouse_urxvt",
5892#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT)
5893 1
5894#else
5895 0
5896#endif
5897 },
5898 {"mouse_xterm",
5899#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
5900 1
5901#else
5902 0
5903#endif
5904 },
5905 {"multi_byte", 1},
5906 {"multi_byte_ime",
5907#ifdef FEAT_MBYTE_IME
5908 1
5909#else
5910 0
5911#endif
5912 },
5913 {"multi_lang",
5914#ifdef FEAT_MULTI_LANG
5915 1
5916#else
5917 0
5918#endif
5919 },
5920 {"mzscheme",
5921#if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME)
5922 1
5923#else
5924 0
5925#endif
5926 },
Leah Neukirchen0a7984a2021-10-14 21:27:55 +01005927 {"nanotime",
5928#ifdef ST_MTIM_NSEC
5929 1
5930#else
5931 0
5932#endif
5933 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005934 {"num64", 1},
5935 {"ole",
5936#ifdef FEAT_OLE
5937 1
5938#else
5939 0
5940#endif
5941 },
5942 {"packages",
5943#ifdef FEAT_EVAL
5944 1
5945#else
5946 0
5947#endif
5948 },
Bram Moolenaar2bd9dbc2022-08-25 18:12:06 +01005949 {"path_extra", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01005950 {"perl",
5951#if defined(FEAT_PERL) && !defined(DYNAMIC_PERL)
5952 1
5953#else
5954 0
5955#endif
5956 },
5957 {"persistent_undo",
5958#ifdef FEAT_PERSISTENT_UNDO
5959 1
5960#else
5961 0
5962#endif
5963 },
5964 {"python_compiled",
5965#if defined(FEAT_PYTHON)
5966 1
5967#else
5968 0
5969#endif
5970 },
5971 {"python_dynamic",
5972#if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON)
5973 1
5974#else
5975 0
5976#endif
5977 },
5978 {"python",
5979#if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)
5980 1
5981#else
5982 0
5983#endif
5984 },
5985 {"pythonx",
5986#if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \
5987 || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3))
5988 1
5989#else
5990 0
5991#endif
5992 },
5993 {"python3_compiled",
5994#if defined(FEAT_PYTHON3)
5995 1
5996#else
5997 0
5998#endif
5999 },
6000 {"python3_dynamic",
6001#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3)
6002 1
6003#else
6004 0
6005#endif
6006 },
6007 {"python3",
6008#if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)
6009 1
6010#else
6011 0
6012#endif
6013 },
6014 {"popupwin",
6015#ifdef FEAT_PROP_POPUP
6016 1
6017#else
6018 0
6019#endif
6020 },
6021 {"postscript",
6022#ifdef FEAT_POSTSCRIPT
6023 1
6024#else
6025 0
6026#endif
6027 },
6028 {"printer",
6029#ifdef FEAT_PRINTER
6030 1
6031#else
6032 0
6033#endif
6034 },
6035 {"profile",
6036#ifdef FEAT_PROFILE
6037 1
6038#else
6039 0
6040#endif
6041 },
6042 {"reltime",
6043#ifdef FEAT_RELTIME
6044 1
6045#else
6046 0
6047#endif
6048 },
6049 {"quickfix",
6050#ifdef FEAT_QUICKFIX
6051 1
6052#else
6053 0
6054#endif
6055 },
6056 {"rightleft",
6057#ifdef FEAT_RIGHTLEFT
6058 1
6059#else
6060 0
6061#endif
6062 },
6063 {"ruby",
6064#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
6065 1
6066#else
6067 0
6068#endif
6069 },
6070 {"scrollbind", 1},
6071 {"showcmd",
6072#ifdef FEAT_CMDL_INFO
6073 1
6074#else
6075 0
6076#endif
6077 },
6078 {"cmdline_info",
6079#ifdef FEAT_CMDL_INFO
6080 1
6081#else
6082 0
6083#endif
6084 },
6085 {"signs",
6086#ifdef FEAT_SIGNS
6087 1
6088#else
6089 0
6090#endif
6091 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01006092 {"smartindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006093 {"startuptime",
6094#ifdef STARTUPTIME
6095 1
6096#else
6097 0
6098#endif
6099 },
6100 {"statusline",
6101#ifdef FEAT_STL_OPT
6102 1
6103#else
6104 0
6105#endif
6106 },
6107 {"netbeans_intg",
6108#ifdef FEAT_NETBEANS_INTG
6109 1
6110#else
6111 0
6112#endif
6113 },
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006114 {"sodium",
K.Takatad68b2fc2022-02-12 11:18:37 +00006115#if defined(FEAT_SODIUM) && !defined(DYNAMIC_SODIUM)
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006116 1
6117#else
6118 0
6119#endif
6120 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006121 {"sound",
6122#ifdef FEAT_SOUND
6123 1
6124#else
6125 0
6126#endif
6127 },
6128 {"spell",
6129#ifdef FEAT_SPELL
6130 1
6131#else
6132 0
6133#endif
6134 },
6135 {"syntax",
6136#ifdef FEAT_SYN_HL
6137 1
6138#else
6139 0
6140#endif
6141 },
6142 {"system",
6143#if defined(USE_SYSTEM) || !defined(UNIX)
6144 1
6145#else
6146 0
6147#endif
6148 },
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00006149 {"tag_binary", 1}, // graduated feature
Bram Moolenaar79296512020-03-22 16:17:14 +01006150 {"tcl",
6151#if defined(FEAT_TCL) && !defined(DYNAMIC_TCL)
6152 1
6153#else
6154 0
6155#endif
6156 },
6157 {"termguicolors",
6158#ifdef FEAT_TERMGUICOLORS
6159 1
6160#else
6161 0
6162#endif
6163 },
6164 {"terminal",
6165#if defined(FEAT_TERMINAL) && !defined(MSWIN)
6166 1
6167#else
6168 0
6169#endif
6170 },
6171 {"terminfo",
6172#ifdef TERMINFO
6173 1
6174#else
6175 0
6176#endif
6177 },
6178 {"termresponse",
6179#ifdef FEAT_TERMRESPONSE
6180 1
6181#else
6182 0
6183#endif
6184 },
Bram Moolenaar88774872022-08-16 20:24:29 +01006185 {"textobjects", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006186 {"textprop",
6187#ifdef FEAT_PROP_POPUP
6188 1
6189#else
6190 0
6191#endif
6192 },
6193 {"tgetent",
6194#ifdef HAVE_TGETENT
6195 1
6196#else
6197 0
6198#endif
6199 },
6200 {"timers",
6201#ifdef FEAT_TIMERS
6202 1
6203#else
6204 0
6205#endif
6206 },
Bram Moolenaar651fca82021-11-29 20:39:38 +00006207 {"title", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006208 {"toolbar",
6209#ifdef FEAT_TOOLBAR
6210 1
6211#else
6212 0
6213#endif
6214 },
6215 {"unnamedplus",
6216#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
6217 1
6218#else
6219 0
6220#endif
6221 },
6222 {"user-commands", 1}, // was accidentally included in 5.4
6223 {"user_commands", 1},
6224 {"vartabs",
6225#ifdef FEAT_VARTABS
6226 1
6227#else
6228 0
6229#endif
6230 },
6231 {"vertsplit", 1},
6232 {"viminfo",
6233#ifdef FEAT_VIMINFO
6234 1
6235#else
6236 0
6237#endif
6238 },
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +00006239 {"vim9script", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006240 {"vimscript-1", 1},
6241 {"vimscript-2", 1},
6242 {"vimscript-3", 1},
6243 {"vimscript-4", 1},
6244 {"virtualedit", 1},
6245 {"visual", 1},
6246 {"visualextra", 1},
6247 {"vreplace", 1},
6248 {"vtp",
6249#ifdef FEAT_VTP
6250 1
6251#else
6252 0
6253#endif
6254 },
Bram Moolenaar074fbd42022-08-26 16:41:14 +01006255 {"wildignore", 1},
Bram Moolenaar54162322022-08-26 16:58:51 +01006256 {"wildmenu", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006257 {"windows", 1},
6258 {"winaltkeys",
6259#ifdef FEAT_WAK
6260 1
6261#else
6262 0
6263#endif
6264 },
6265 {"writebackup",
6266#ifdef FEAT_WRITEBACKUP
6267 1
6268#else
6269 0
6270#endif
6271 },
6272 {"xim",
6273#ifdef FEAT_XIM
6274 1
6275#else
6276 0
6277#endif
6278 },
6279 {"xfontset",
6280#ifdef FEAT_XFONTSET
6281 1
6282#else
6283 0
6284#endif
6285 },
6286 {"xpm",
6287#if defined(FEAT_XPM_W32) || defined(HAVE_XPM)
6288 1
6289#else
6290 0
6291#endif
6292 },
6293 {"xpm_w32", // for backward compatibility
6294#ifdef FEAT_XPM_W32
6295 1
6296#else
6297 0
6298#endif
6299 },
6300 {"xsmp",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006301#ifdef USE_XSMP
Bram Moolenaar79296512020-03-22 16:17:14 +01006302 1
6303#else
6304 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006305#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006306 },
6307 {"xsmp_interact",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006308#ifdef USE_XSMP_INTERACT
Bram Moolenaar79296512020-03-22 16:17:14 +01006309 1
6310#else
6311 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006312#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006313 },
6314 {"xterm_clipboard",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006315#ifdef FEAT_XCLIPBOARD
Bram Moolenaar79296512020-03-22 16:17:14 +01006316 1
6317#else
6318 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006319#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006320 },
6321 {"xterm_save",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006322#ifdef FEAT_XTERM_SAVE
Bram Moolenaar79296512020-03-22 16:17:14 +01006323 1
6324#else
6325 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006326#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006327 },
6328 {"X11",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006329#if defined(UNIX) && defined(FEAT_X11)
Bram Moolenaar79296512020-03-22 16:17:14 +01006330 1
6331#else
6332 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006333#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006334 },
6335 {NULL, 0}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006336 };
6337
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006338 if (in_vim9script()
6339 && (check_for_string_arg(argvars, 0) == FAIL
6340 || check_for_opt_bool_arg(argvars, 1) == FAIL))
6341 return;
6342
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006343 name = tv_get_string(&argvars[0]);
Bram Moolenaar79296512020-03-22 16:17:14 +01006344 for (i = 0; has_list[i].name != NULL; ++i)
6345 if (STRICMP(name, has_list[i].name) == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006346 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006347 x = TRUE;
6348 n = has_list[i].present;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006349 break;
6350 }
6351
Bram Moolenaar79296512020-03-22 16:17:14 +01006352 // features also in has_list[] but sometimes enabled at runtime
6353 if (x == TRUE && n == FALSE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006354 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006355 if (0)
Bram Moolenaar86b9a3e2020-04-07 19:57:29 +02006356 {
6357 // intentionally empty
6358 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006359#ifdef VIMDLL
6360 else if (STRICMP(name, "filterpipe") == 0)
6361 n = gui.in_use || gui.starting;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006362#endif
6363#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6364 else if (STRICMP(name, "iconv") == 0)
6365 n = iconv_enabled(FALSE);
6366#endif
6367#ifdef DYNAMIC_LUA
6368 else if (STRICMP(name, "lua") == 0)
6369 n = lua_enabled(FALSE);
6370#endif
6371#ifdef DYNAMIC_MZSCHEME
6372 else if (STRICMP(name, "mzscheme") == 0)
6373 n = mzscheme_enabled(FALSE);
6374#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006375#ifdef DYNAMIC_PERL
6376 else if (STRICMP(name, "perl") == 0)
6377 n = perl_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006378#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006379#ifdef DYNAMIC_PYTHON
6380 else if (STRICMP(name, "python") == 0)
6381 n = python_enabled(FALSE);
6382#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006383#ifdef DYNAMIC_PYTHON3
6384 else if (STRICMP(name, "python3") == 0)
6385 n = python3_enabled(FALSE);
6386#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006387#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6388 else if (STRICMP(name, "pythonx") == 0)
6389 {
6390# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
6391 if (p_pyx == 0)
6392 n = python3_enabled(FALSE) || python_enabled(FALSE);
6393 else if (p_pyx == 3)
6394 n = python3_enabled(FALSE);
6395 else if (p_pyx == 2)
6396 n = python_enabled(FALSE);
6397# elif defined(DYNAMIC_PYTHON)
6398 n = python_enabled(FALSE);
6399# elif defined(DYNAMIC_PYTHON3)
6400 n = python3_enabled(FALSE);
6401# endif
6402 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006403#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006404#ifdef DYNAMIC_RUBY
6405 else if (STRICMP(name, "ruby") == 0)
6406 n = ruby_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006407#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006408#ifdef DYNAMIC_TCL
6409 else if (STRICMP(name, "tcl") == 0)
6410 n = tcl_enabled(FALSE);
Bram Moolenaar4b8366b2019-05-04 17:34:34 +02006411#endif
K.Takatad68b2fc2022-02-12 11:18:37 +00006412#ifdef DYNAMIC_SODIUM
6413 else if (STRICMP(name, "sodium") == 0)
6414 n = sodium_enabled(FALSE);
6415#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006416#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02006417 else if (STRICMP(name, "terminal") == 0)
6418 n = terminal_enabled();
6419#endif
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00006420#ifdef DYNAMIC_GPM
6421 else if (STRICMP(name, "mouse_gpm") == 0)
6422 n = gpm_available();
6423#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006424 }
6425
Bram Moolenaar79296512020-03-22 16:17:14 +01006426 // features not in has_list[]
6427 if (x == FALSE)
6428 {
6429 if (STRNICMP(name, "patch", 5) == 0)
6430 {
6431 x = TRUE;
6432 if (name[5] == '-'
6433 && STRLEN(name) >= 11
K.Takatad90f91f2022-07-30 15:43:59 +01006434 && (name[6] >= '1' && name[6] <= '9'))
Bram Moolenaar79296512020-03-22 16:17:14 +01006435 {
K.Takatad90f91f2022-07-30 15:43:59 +01006436 char *end;
6437 int major, minor;
Bram Moolenaar79296512020-03-22 16:17:14 +01006438
K.Takatad90f91f2022-07-30 15:43:59 +01006439 // This works for patch-8.1.2, patch-9.0.3, patch-10.0.4, etc.
6440 // Not for patch-9.10.5.
6441 major = (int)strtoul((char *)name + 6, &end, 10);
6442 if (*end == '.' && vim_isdigit(end[1])
6443 && end[2] == '.' && vim_isdigit(end[3]))
6444 {
6445 minor = atoi(end + 1);
6446
6447 // Expect "patch-9.9.01234".
6448 n = (major < VIM_VERSION_MAJOR
6449 || (major == VIM_VERSION_MAJOR
6450 && (minor < VIM_VERSION_MINOR
6451 || (minor == VIM_VERSION_MINOR
6452 && has_patch(atoi(end + 3))))));
6453 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006454 }
Bram Moolenaar5154a882022-07-18 20:48:50 +01006455 else if (isdigit(name[5]))
Bram Moolenaar79296512020-03-22 16:17:14 +01006456 n = has_patch(atoi((char *)name + 5));
6457 }
6458 else if (STRICMP(name, "vim_starting") == 0)
6459 {
6460 x = TRUE;
6461 n = (starting != 0);
6462 }
6463 else if (STRICMP(name, "ttyin") == 0)
6464 {
6465 x = TRUE;
6466 n = mch_input_isatty();
6467 }
6468 else if (STRICMP(name, "ttyout") == 0)
6469 {
6470 x = TRUE;
6471 n = stdout_isatty;
6472 }
6473 else if (STRICMP(name, "multi_byte_encoding") == 0)
6474 {
6475 x = TRUE;
6476 n = has_mbyte;
6477 }
6478 else if (STRICMP(name, "gui_running") == 0)
6479 {
6480 x = TRUE;
6481#ifdef FEAT_GUI
6482 n = (gui.in_use || gui.starting);
6483#endif
6484 }
6485 else if (STRICMP(name, "browse") == 0)
6486 {
6487 x = TRUE;
6488#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6489 n = gui.in_use; // gui_mch_browse() works when GUI is running
6490#endif
6491 }
6492 else if (STRICMP(name, "syntax_items") == 0)
6493 {
6494 x = TRUE;
6495#ifdef FEAT_SYN_HL
6496 n = syntax_present(curwin);
6497#endif
6498 }
6499 else if (STRICMP(name, "vcon") == 0)
6500 {
6501 x = TRUE;
6502#ifdef FEAT_VTP
6503 n = is_term_win32() && has_vtp_working();
6504#endif
6505 }
6506 else if (STRICMP(name, "netbeans_enabled") == 0)
6507 {
6508 x = TRUE;
6509#ifdef FEAT_NETBEANS_INTG
6510 n = netbeans_active();
6511#endif
6512 }
6513 else if (STRICMP(name, "mouse_gpm_enabled") == 0)
6514 {
6515 x = TRUE;
6516#ifdef FEAT_MOUSE_GPM
6517 n = gpm_enabled();
6518#endif
6519 }
6520 else if (STRICMP(name, "conpty") == 0)
6521 {
6522 x = TRUE;
6523#if defined(FEAT_TERMINAL) && defined(MSWIN)
6524 n = use_conpty();
6525#endif
6526 }
6527 else if (STRICMP(name, "clipboard_working") == 0)
6528 {
6529 x = TRUE;
6530#ifdef FEAT_CLIPBOARD
6531 n = clip_star.available;
6532#endif
6533 }
6534 }
6535
Bram Moolenaar04637e22020-09-05 18:45:29 +02006536 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
Bram Moolenaar79296512020-03-22 16:17:14 +01006537 // return whether feature could ever be enabled
6538 rettv->vval.v_number = x;
6539 else
6540 // return whether feature is enabled
6541 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006542}
6543
6544/*
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006545 * Return TRUE if "feature" can change later.
6546 * Also when checking for the feature has side effects, such as loading a DLL.
6547 */
6548 int
6549dynamic_feature(char_u *feature)
6550{
6551 return (feature == NULL
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006552#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
6553 || (STRICMP(feature, "browse") == 0 && !gui.in_use)
6554#endif
6555#ifdef VIMDLL
6556 || STRICMP(feature, "filterpipe") == 0
6557#endif
Bram Moolenaar29b281b2020-11-10 20:58:00 +01006558#if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL)
Bram Moolenaar8cebd432020-11-08 12:49:47 +01006559 // this can only change on Unix where the ":gui" command could be
6560 // used.
6561 || (STRICMP(feature, "gui_running") == 0 && !gui.in_use)
6562#endif
6563#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6564 || STRICMP(feature, "iconv") == 0
6565#endif
6566#ifdef DYNAMIC_LUA
6567 || STRICMP(feature, "lua") == 0
6568#endif
6569#ifdef FEAT_MOUSE_GPM
6570 || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled())
6571#endif
6572#ifdef DYNAMIC_MZSCHEME
6573 || STRICMP(feature, "mzscheme") == 0
6574#endif
6575#ifdef FEAT_NETBEANS_INTG
6576 || STRICMP(feature, "netbeans_enabled") == 0
6577#endif
6578#ifdef DYNAMIC_PERL
6579 || STRICMP(feature, "perl") == 0
6580#endif
6581#ifdef DYNAMIC_PYTHON
6582 || STRICMP(feature, "python") == 0
6583#endif
6584#ifdef DYNAMIC_PYTHON3
6585 || STRICMP(feature, "python3") == 0
6586#endif
6587#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6588 || STRICMP(feature, "pythonx") == 0
6589#endif
6590#ifdef DYNAMIC_RUBY
6591 || STRICMP(feature, "ruby") == 0
6592#endif
6593#ifdef FEAT_SYN_HL
6594 || STRICMP(feature, "syntax_items") == 0
6595#endif
6596#ifdef DYNAMIC_TCL
6597 || STRICMP(feature, "tcl") == 0
6598#endif
6599 // once "starting" is zero it will stay that way
6600 || (STRICMP(feature, "vim_starting") == 0 && starting != 0)
6601 || STRICMP(feature, "multi_byte_encoding") == 0
6602#if defined(FEAT_TERMINAL) && defined(MSWIN)
6603 || STRICMP(feature, "conpty") == 0
6604#endif
6605 );
6606}
6607
6608/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006609 * "haslocaldir()" function
6610 */
6611 static void
6612f_haslocaldir(typval_T *argvars, typval_T *rettv)
6613{
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006614 tabpage_T *tp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006615 win_T *wp = NULL;
6616
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006617 if (in_vim9script()
6618 && (check_for_opt_number_arg(argvars, 0) == FAIL
6619 || (argvars[0].v_type != VAR_UNKNOWN
6620 && check_for_opt_number_arg(argvars, 1) == FAIL)))
6621 return;
6622
Bram Moolenaar00aa0692019-04-27 20:37:57 +02006623 wp = find_tabwin(&argvars[0], &argvars[1], &tp);
6624
6625 // Check for window-local and tab-local directories
6626 if (wp != NULL && wp->w_localdir != NULL)
6627 rettv->vval.v_number = 1;
6628 else if (tp != NULL && tp->tp_localdir != NULL)
6629 rettv->vval.v_number = 2;
6630 else
6631 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006632}
6633
6634/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006635 * "highlightID(name)" function
6636 */
6637 static void
6638f_hlID(typval_T *argvars, typval_T *rettv)
6639{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006640 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6641 return;
6642
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006643 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006644}
6645
6646/*
6647 * "highlight_exists()" function
6648 */
6649 static void
6650f_hlexists(typval_T *argvars, typval_T *rettv)
6651{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006652 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
6653 return;
6654
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006655 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006656}
6657
6658/*
6659 * "hostname()" function
6660 */
6661 static void
6662f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
6663{
6664 char_u hostname[256];
6665
6666 mch_get_host_name(hostname, 256);
6667 rettv->v_type = VAR_STRING;
6668 rettv->vval.v_string = vim_strsave(hostname);
6669}
6670
6671/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006672 * "index()" function
6673 */
6674 static void
6675f_index(typval_T *argvars, typval_T *rettv)
6676{
6677 list_T *l;
6678 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006679 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006680 long idx = 0;
6681 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006682 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006683
6684 rettv->vval.v_number = -1;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006685
6686 if (in_vim9script()
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02006687 && (check_for_list_or_blob_arg(argvars, 0) == FAIL
6688 || (argvars[0].v_type == VAR_BLOB
6689 && check_for_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006690 || check_for_opt_number_arg(argvars, 2) == FAIL
6691 || (argvars[2].v_type != VAR_UNKNOWN
6692 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
6693 return;
6694
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006695 if (argvars[0].v_type == VAR_BLOB)
6696 {
6697 typval_T tv;
6698 int start = 0;
6699
6700 if (argvars[2].v_type != VAR_UNKNOWN)
6701 {
6702 start = tv_get_number_chk(&argvars[2], &error);
6703 if (error)
6704 return;
6705 }
6706 b = argvars[0].vval.v_blob;
6707 if (b == NULL)
6708 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01006709 if (start < 0)
6710 {
6711 start = blob_len(b) + start;
6712 if (start < 0)
6713 start = 0;
6714 }
6715
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006716 for (idx = start; idx < blob_len(b); ++idx)
6717 {
6718 tv.v_type = VAR_NUMBER;
6719 tv.vval.v_number = blob_get(b, idx);
6720 if (tv_equal(&tv, &argvars[1], ic, FALSE))
6721 {
6722 rettv->vval.v_number = idx;
6723 return;
6724 }
6725 }
6726 return;
6727 }
6728 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006729 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00006730 emsg(_(e_list_or_blob_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006731 return;
6732 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006733
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006734 l = argvars[0].vval.v_list;
6735 if (l != NULL)
6736 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02006737 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006738 item = l->lv_first;
6739 if (argvars[2].v_type != VAR_UNKNOWN)
6740 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006741 // Start at specified item. Use the cached index that list_find()
6742 // sets, so that a negative number also works.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006743 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006744 idx = l->lv_u.mat.lv_idx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006745 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaar6c553f92020-09-02 22:10:34 +02006746 ic = (int)tv_get_bool_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006747 if (error)
6748 item = NULL;
6749 }
6750
6751 for ( ; item != NULL; item = item->li_next, ++idx)
6752 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
6753 {
6754 rettv->vval.v_number = idx;
6755 break;
6756 }
6757 }
6758}
6759
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006760/*
6761 * Evaluate 'expr' with the v:key and v:val arguments and return the result.
6762 * The expression is expected to return a boolean value. The caller should set
6763 * the VV_KEY and VV_VAL vim variables before calling this function.
6764 */
6765 static int
6766indexof_eval_expr(typval_T *expr)
6767{
6768 typval_T argv[3];
6769 typval_T newtv;
6770 varnumber_T found;
6771 int error = FALSE;
6772
6773 argv[0] = *get_vim_var_tv(VV_KEY);
6774 argv[1] = *get_vim_var_tv(VV_VAL);
6775 newtv.v_type = VAR_UNKNOWN;
6776
6777 if (eval_expr_typval(expr, argv, 2, &newtv) == FAIL)
6778 return FALSE;
6779
6780 found = tv_get_bool_chk(&newtv, &error);
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006781 clear_tv(&newtv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006782
6783 return error ? FALSE : found;
6784}
6785
6786/*
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006787 * Evaluate 'expr' for each byte in the Blob 'b' starting with the byte at
6788 * 'startidx' and return the index of the byte where 'expr' is TRUE. Returns
6789 * -1 if 'expr' doesn't evaluate to TRUE for any of the bytes.
6790 */
6791 static int
6792indexof_blob(blob_T *b, long startidx, typval_T *expr)
6793{
6794 long idx = 0;
6795
6796 if (b == NULL)
6797 return -1;
6798
6799 if (startidx < 0)
6800 {
6801 // negative index: index from the last byte
6802 startidx = blob_len(b) + startidx;
6803 if (startidx < 0)
6804 startidx = 0;
6805 }
6806
6807 set_vim_var_type(VV_KEY, VAR_NUMBER);
6808 set_vim_var_type(VV_VAL, VAR_NUMBER);
6809
6810 for (idx = startidx; idx < blob_len(b); ++idx)
6811 {
6812 set_vim_var_nr(VV_KEY, idx);
6813 set_vim_var_nr(VV_VAL, blob_get(b, idx));
6814
6815 if (indexof_eval_expr(expr))
6816 return idx;
6817 }
6818
6819 return -1;
6820}
6821
6822/*
6823 * Evaluate 'expr' for each item in the List 'l' starting with the item at
6824 * 'startidx' and return the index of the item where 'expr' is TRUE. Returns
6825 * -1 if 'expr' doesn't evaluate to TRUE for any of the items.
6826 */
6827 static int
6828indexof_list(list_T *l, long startidx, typval_T *expr)
6829{
6830 listitem_T *item;
6831 long idx = 0;
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006832 int found;
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006833
6834 if (l == NULL)
6835 return -1;
6836
6837 CHECK_LIST_MATERIALIZE(l);
6838
6839 if (startidx == 0)
6840 item = l->lv_first;
6841 else
6842 {
6843 // Start at specified item. Use the cached index that list_find()
6844 // sets, so that a negative number also works.
6845 item = list_find(l, startidx);
6846 if (item != NULL)
6847 idx = l->lv_u.mat.lv_idx;
6848 }
6849
6850 set_vim_var_type(VV_KEY, VAR_NUMBER);
6851
6852 for ( ; item != NULL; item = item->li_next, ++idx)
6853 {
6854 set_vim_var_nr(VV_KEY, idx);
6855 copy_tv(&item->li_tv, get_vim_var_tv(VV_VAL));
6856
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01006857 found = indexof_eval_expr(expr);
6858 clear_tv(get_vim_var_tv(VV_VAL));
6859
6860 if (found)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006861 return idx;
6862 }
6863
6864 return -1;
6865}
6866
6867/*
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006868 * "indexof()" function
6869 */
6870 static void
6871f_indexof(typval_T *argvars, typval_T *rettv)
6872{
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006873 long startidx = 0;
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006874 typval_T save_val;
6875 typval_T save_key;
6876 int save_did_emsg;
6877
6878 rettv->vval.v_number = -1;
6879
6880 if (check_for_list_or_blob_arg(argvars, 0) == FAIL
6881 || check_for_string_or_func_arg(argvars, 1) == FAIL
6882 || check_for_opt_dict_arg(argvars, 2) == FAIL)
6883 return;
6884
6885 if ((argvars[1].v_type == VAR_STRING && argvars[1].vval.v_string == NULL)
6886 || (argvars[1].v_type == VAR_FUNC
6887 && argvars[1].vval.v_partial == NULL))
6888 return;
6889
6890 if (argvars[2].v_type == VAR_DICT)
6891 startidx = dict_get_number_def(argvars[2].vval.v_dict, "startidx", 0);
6892
6893 prepare_vimvar(VV_VAL, &save_val);
6894 prepare_vimvar(VV_KEY, &save_key);
6895
6896 // We reset "did_emsg" to be able to detect whether an error occurred
6897 // during evaluation of the expression.
6898 save_did_emsg = did_emsg;
6899 did_emsg = FALSE;
6900
6901 if (argvars[0].v_type == VAR_BLOB)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006902 rettv->vval.v_number = indexof_blob(argvars[0].vval.v_blob, startidx,
6903 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006904 else
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01006905 rettv->vval.v_number = indexof_list(argvars[0].vval.v_list, startidx,
6906 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006907
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01006908 restore_vimvar(VV_KEY, &save_key);
6909 restore_vimvar(VV_VAL, &save_val);
6910 did_emsg |= save_did_emsg;
6911}
6912
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006913static int inputsecret_flag = 0;
6914
6915/*
6916 * "input()" function
6917 * Also handles inputsecret() when inputsecret is set.
6918 */
6919 static void
6920f_input(typval_T *argvars, typval_T *rettv)
6921{
6922 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
6923}
6924
6925/*
6926 * "inputdialog()" function
6927 */
6928 static void
6929f_inputdialog(typval_T *argvars, typval_T *rettv)
6930{
6931#if defined(FEAT_GUI_TEXTDIALOG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006932 // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions'
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006933 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
6934 {
6935 char_u *message;
6936 char_u buf[NUMBUFLEN];
6937 char_u *defstr = (char_u *)"";
6938
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006939 if (in_vim9script()
6940 && (check_for_string_arg(argvars, 0) == FAIL
6941 || check_for_opt_string_arg(argvars, 1) == FAIL
6942 || (argvars[1].v_type != VAR_UNKNOWN
6943 && check_for_opt_string_arg(argvars, 2) == FAIL)))
6944 return;
6945
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006946 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006947 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006948 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006949 vim_strncpy(IObuff, defstr, IOSIZE - 1);
6950 else
6951 IObuff[0] = NUL;
6952 if (message != NULL && defstr != NULL
6953 && do_dialog(VIM_QUESTION, NULL, message,
6954 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
6955 rettv->vval.v_string = vim_strsave(IObuff);
6956 else
6957 {
6958 if (message != NULL && defstr != NULL
6959 && argvars[1].v_type != VAR_UNKNOWN
6960 && argvars[2].v_type != VAR_UNKNOWN)
6961 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006962 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006963 else
6964 rettv->vval.v_string = NULL;
6965 }
6966 rettv->v_type = VAR_STRING;
6967 }
6968 else
6969#endif
6970 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
6971}
6972
6973/*
6974 * "inputlist()" function
6975 */
6976 static void
6977f_inputlist(typval_T *argvars, typval_T *rettv)
6978{
Bram Moolenaar50985eb2020-01-27 22:09:39 +01006979 list_T *l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006980 listitem_T *li;
6981 int selected;
6982 int mouse_used;
6983
6984#ifdef NO_CONSOLE_INPUT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006985 // While starting up, there is no place to enter text. When running tests
6986 // with --not-a-term we assume feedkeys() will be used.
Bram Moolenaar91d348a2017-07-29 20:16:03 +02006987 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006988 return;
6989#endif
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02006990 if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
6991 return;
6992
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006993 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
6994 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00006995 semsg(_(e_argument_of_str_must_be_list), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006996 return;
6997 }
6998
6999 msg_start();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007000 msg_row = Rows - 1; // for when 'cmdheight' > 1
7001 lines_left = Rows; // avoid more prompt
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007002 msg_scroll = TRUE;
7003 msg_clr_eos();
7004
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007005 l = argvars[0].vval.v_list;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007006 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02007007 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007008 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007009 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007010 msg_putchar('\n');
7011 }
7012
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007013 // Ask for choice.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007014 selected = prompt_for_number(&mouse_used);
7015 if (mouse_used)
7016 selected -= lines_left;
7017
7018 rettv->vval.v_number = selected;
7019}
7020
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007021static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
7022
7023/*
7024 * "inputrestore()" function
7025 */
7026 static void
7027f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
7028{
7029 if (ga_userinput.ga_len > 0)
7030 {
7031 --ga_userinput.ga_len;
7032 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
Bram Moolenaarc41badb2021-06-07 22:04:52 +02007033 + ga_userinput.ga_len, TRUE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007034 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007035 }
7036 else if (p_verbose > 1)
7037 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007038 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007039 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007040 }
7041}
7042
7043/*
7044 * "inputsave()" function
7045 */
7046 static void
7047f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
7048{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007049 // Add an entry to the stack of typeahead storage.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007050 if (ga_grow(&ga_userinput, 1) == OK)
7051 {
7052 save_typeahead((tasave_T *)(ga_userinput.ga_data)
7053 + ga_userinput.ga_len);
7054 ++ga_userinput.ga_len;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007055 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007056 }
7057 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007058 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007059}
7060
7061/*
7062 * "inputsecret()" function
7063 */
7064 static void
7065f_inputsecret(typval_T *argvars, typval_T *rettv)
7066{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007067 if (in_vim9script()
7068 && (check_for_string_arg(argvars, 0) == FAIL
7069 || check_for_opt_string_arg(argvars, 1) == FAIL))
7070 return;
7071
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007072 ++cmdline_star;
7073 ++inputsecret_flag;
7074 f_input(argvars, rettv);
7075 --cmdline_star;
7076 --inputsecret_flag;
7077}
7078
7079/*
Bram Moolenaar67a2deb2019-11-25 00:05:32 +01007080 * "interrupt()" function
7081 */
7082 static void
7083f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7084{
7085 got_int = TRUE;
7086}
7087
7088/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007089 * "invert(expr)" function
7090 */
7091 static void
7092f_invert(typval_T *argvars, typval_T *rettv)
7093{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007094 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
7095 return;
7096
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007097 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007098}
7099
7100/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007101 * "islocked()" function
7102 */
7103 static void
7104f_islocked(typval_T *argvars, typval_T *rettv)
7105{
7106 lval_T lv;
7107 char_u *end;
7108 dictitem_T *di;
7109
7110 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007111
7112 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7113 return;
7114
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007115 end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
Bram Moolenaarbd77aa92021-08-12 17:06:05 +02007116 GLV_NO_AUTOLOAD | GLV_READ_ONLY | GLV_NO_DECL,
7117 FNE_CHECK_START);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007118 if (end != NULL && lv.ll_name != NULL)
7119 {
7120 if (*end != NUL)
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007121 {
7122 semsg(_(lv.ll_name == lv.ll_name_end
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00007123 ? e_invalid_argument_str : e_trailing_characters_str), end);
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007124 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007125 else
7126 {
7127 if (lv.ll_tv == NULL)
7128 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01007129 di = find_var(lv.ll_name, NULL, TRUE);
7130 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007131 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007132 // Consider a variable locked when:
7133 // 1. the variable itself is locked
7134 // 2. the value of the variable is locked.
7135 // 3. the List or Dict value is locked.
Bram Moolenaar79518e22017-02-17 16:31:35 +01007136 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
7137 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007138 }
7139 }
7140 else if (lv.ll_range)
Bram Moolenaar677658a2022-01-05 16:09:06 +00007141 emsg(_(e_range_not_allowed));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007142 else if (lv.ll_newkey != NULL)
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007143 semsg(_(e_key_not_present_in_dictionary), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007144 else if (lv.ll_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007145 // List item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007146 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
7147 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007148 // Dictionary item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007149 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
7150 }
7151 }
7152
7153 clear_lval(&lv);
7154}
7155
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007156/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007157 * "last_buffer_nr()" function.
7158 */
7159 static void
7160f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
7161{
7162 int n = 0;
7163 buf_T *buf;
7164
Bram Moolenaar29323592016-07-24 22:04:11 +02007165 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007166 if (n < buf->b_fnum)
7167 n = buf->b_fnum;
7168
7169 rettv->vval.v_number = n;
7170}
7171
7172/*
7173 * "len()" function
7174 */
LemonBoy58f331a2022-04-02 21:59:06 +01007175 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007176f_len(typval_T *argvars, typval_T *rettv)
7177{
7178 switch (argvars[0].v_type)
7179 {
7180 case VAR_STRING:
7181 case VAR_NUMBER:
7182 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007183 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007184 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007185 case VAR_BLOB:
7186 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
7187 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007188 case VAR_LIST:
7189 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
7190 break;
7191 case VAR_DICT:
7192 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
7193 break;
7194 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02007195 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007196 case VAR_VOID:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01007197 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007198 case VAR_SPECIAL:
7199 case VAR_FLOAT:
7200 case VAR_FUNC:
7201 case VAR_PARTIAL:
7202 case VAR_JOB:
7203 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02007204 case VAR_INSTR:
Bram Moolenaara6f79292022-01-04 21:30:47 +00007205 emsg(_(e_invalid_type_for_len));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007206 break;
7207 }
7208}
7209
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007210 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01007211libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007212{
7213#ifdef FEAT_LIBCALL
7214 char_u *string_in;
7215 char_u **string_result;
7216 int nr_result;
7217#endif
7218
7219 rettv->v_type = type;
7220 if (type != VAR_NUMBER)
7221 rettv->vval.v_string = NULL;
7222
7223 if (check_restricted() || check_secure())
7224 return;
7225
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02007226 if (in_vim9script()
7227 && (check_for_string_arg(argvars, 0) == FAIL
7228 || check_for_string_arg(argvars, 1) == FAIL
7229 || check_for_string_or_number_arg(argvars, 2) == FAIL))
7230 return;
7231
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007232#ifdef FEAT_LIBCALL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007233 // The first two args must be strings, otherwise it's meaningless
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007234 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
7235 {
7236 string_in = NULL;
7237 if (argvars[2].v_type == VAR_STRING)
7238 string_in = argvars[2].vval.v_string;
7239 if (type == VAR_NUMBER)
Bram Moolenaar87e15872021-09-02 19:53:07 +02007240 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007241 string_result = NULL;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007242 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007243 else
Bram Moolenaar87e15872021-09-02 19:53:07 +02007244 {
7245 rettv->vval.v_string = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007246 string_result = &rettv->vval.v_string;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007247 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007248 if (mch_libcall(argvars[0].vval.v_string,
7249 argvars[1].vval.v_string,
7250 string_in,
7251 argvars[2].vval.v_number,
7252 string_result,
7253 &nr_result) == OK
7254 && type == VAR_NUMBER)
7255 rettv->vval.v_number = nr_result;
7256 }
7257#endif
7258}
7259
7260/*
7261 * "libcall()" function
7262 */
7263 static void
7264f_libcall(typval_T *argvars, typval_T *rettv)
7265{
7266 libcall_common(argvars, rettv, VAR_STRING);
7267}
7268
7269/*
7270 * "libcallnr()" function
7271 */
7272 static void
7273f_libcallnr(typval_T *argvars, typval_T *rettv)
7274{
7275 libcall_common(argvars, rettv, VAR_NUMBER);
7276}
7277
7278/*
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007279 * "line(string, [winid])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007280 */
7281 static void
7282f_line(typval_T *argvars, typval_T *rettv)
7283{
7284 linenr_T lnum = 0;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007285 pos_T *fp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007286 int fnum;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007287 int id;
7288 tabpage_T *tp;
7289 win_T *wp;
Bram Moolenaar18f47402022-01-06 13:24:51 +00007290 switchwin_T switchwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007291
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007292 if (in_vim9script()
7293 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007294 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007295 return;
7296
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007297 if (argvars[1].v_type != VAR_UNKNOWN)
7298 {
7299 // use window specified in the second argument
7300 id = (int)tv_get_number(&argvars[1]);
7301 wp = win_id2wp_tp(id, &tp);
7302 if (wp != NULL && tp != NULL)
7303 {
Bram Moolenaar18f47402022-01-06 13:24:51 +00007304 if (switch_win_noblock(&switchwin, wp, tp, TRUE) == OK)
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007305 {
7306 check_cursor();
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007307 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007308 }
Bram Moolenaar18f47402022-01-06 13:24:51 +00007309 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007310 }
7311 }
7312 else
7313 // use current window
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007314 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007315
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007316 if (fp != NULL)
7317 lnum = fp->lnum;
7318 rettv->vval.v_number = lnum;
7319}
7320
7321/*
7322 * "line2byte(lnum)" function
7323 */
7324 static void
7325f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
7326{
7327#ifndef FEAT_BYTEOFF
7328 rettv->vval.v_number = -1;
7329#else
7330 linenr_T lnum;
7331
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007332 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7333 return;
7334
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007335 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007336 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
7337 rettv->vval.v_number = -1;
7338 else
7339 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
7340 if (rettv->vval.v_number >= 0)
7341 ++rettv->vval.v_number;
7342#endif
7343}
7344
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007345#ifdef FEAT_LUA
7346/*
7347 * "luaeval()" function
7348 */
7349 static void
7350f_luaeval(typval_T *argvars, typval_T *rettv)
7351{
7352 char_u *str;
7353 char_u buf[NUMBUFLEN];
7354
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007355 if (check_restricted() || check_secure())
7356 return;
7357
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02007358 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7359 return;
7360
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007361 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007362 do_luaeval(str, argvars + 1, rettv);
7363}
7364#endif
7365
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007366typedef enum
7367{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007368 MATCH_END, // matchend()
7369 MATCH_MATCH, // match()
7370 MATCH_STR, // matchstr()
7371 MATCH_LIST, // matchlist()
7372 MATCH_POS // matchstrpos()
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007373} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007374
7375 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007376find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007377{
7378 char_u *str = NULL;
7379 long len = 0;
7380 char_u *expr = NULL;
7381 char_u *pat;
7382 regmatch_T regmatch;
7383 char_u patbuf[NUMBUFLEN];
7384 char_u strbuf[NUMBUFLEN];
7385 char_u *save_cpo;
7386 long start = 0;
7387 long nth = 1;
7388 colnr_T startcol = 0;
7389 int match = 0;
7390 list_T *l = NULL;
7391 listitem_T *li = NULL;
7392 long idx = 0;
7393 char_u *tofree = NULL;
7394
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007395 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007396 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01007397 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007398
7399 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007400 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007401 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007402 // type MATCH_LIST: return empty list when there are no matches.
7403 // type MATCH_POS: return ["", -1, -1, -1]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007404 if (rettv_list_alloc(rettv) == FAIL)
7405 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007406 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007407 && (list_append_string(rettv->vval.v_list,
7408 (char_u *)"", 0) == FAIL
7409 || list_append_number(rettv->vval.v_list,
7410 (varnumber_T)-1) == FAIL
7411 || list_append_number(rettv->vval.v_list,
7412 (varnumber_T)-1) == FAIL
7413 || list_append_number(rettv->vval.v_list,
7414 (varnumber_T)-1) == FAIL))
7415 {
7416 list_free(rettv->vval.v_list);
7417 rettv->vval.v_list = NULL;
7418 goto theend;
7419 }
7420 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007421 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007422 {
7423 rettv->v_type = VAR_STRING;
7424 rettv->vval.v_string = NULL;
7425 }
7426
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007427 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007428 && (check_for_string_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007429 || check_for_string_arg(argvars, 1) == FAIL
7430 || check_for_opt_number_arg(argvars, 2) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007431 || (argvars[2].v_type != VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007432 && check_for_opt_number_arg(argvars, 3) == FAIL)))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02007433 goto theend;
7434
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007435 if (argvars[0].v_type == VAR_LIST)
7436 {
7437 if ((l = argvars[0].vval.v_list) == NULL)
7438 goto theend;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007439 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007440 li = l->lv_first;
7441 }
7442 else
7443 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007444 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007445 len = (long)STRLEN(str);
7446 }
7447
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007448 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007449 if (pat == NULL)
7450 goto theend;
7451
7452 if (argvars[2].v_type != VAR_UNKNOWN)
7453 {
7454 int error = FALSE;
7455
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007456 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007457 if (error)
7458 goto theend;
7459 if (l != NULL)
7460 {
7461 li = list_find(l, start);
7462 if (li == NULL)
7463 goto theend;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007464 idx = l->lv_u.mat.lv_idx; // use the cached index
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007465 }
7466 else
7467 {
7468 if (start < 0)
7469 start = 0;
7470 if (start > len)
7471 goto theend;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007472 // When "count" argument is there ignore matches before "start",
7473 // otherwise skip part of the string. Differs when pattern is "^"
7474 // or "\<".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007475 if (argvars[3].v_type != VAR_UNKNOWN)
7476 startcol = start;
7477 else
7478 {
7479 str += start;
7480 len -= start;
7481 }
7482 }
7483
7484 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007485 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007486 if (error)
7487 goto theend;
7488 }
7489
7490 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
7491 if (regmatch.regprog != NULL)
7492 {
7493 regmatch.rm_ic = p_ic;
7494
7495 for (;;)
7496 {
7497 if (l != NULL)
7498 {
7499 if (li == NULL)
7500 {
7501 match = FALSE;
7502 break;
7503 }
7504 vim_free(tofree);
7505 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
7506 if (str == NULL)
7507 break;
7508 }
7509
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00007510 match = vim_regexec_nl(&regmatch, str, startcol);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007511
7512 if (match && --nth <= 0)
7513 break;
7514 if (l == NULL && !match)
7515 break;
7516
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007517 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007518 if (l != NULL)
7519 {
7520 li = li->li_next;
7521 ++idx;
7522 }
7523 else
7524 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007525 startcol = (colnr_T)(regmatch.startp[0]
7526 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007527 if (startcol > (colnr_T)len
7528 || str + startcol <= regmatch.startp[0])
7529 {
7530 match = FALSE;
7531 break;
7532 }
7533 }
7534 }
7535
7536 if (match)
7537 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007538 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007539 {
7540 listitem_T *li1 = rettv->vval.v_list->lv_first;
7541 listitem_T *li2 = li1->li_next;
7542 listitem_T *li3 = li2->li_next;
7543 listitem_T *li4 = li3->li_next;
7544
7545 vim_free(li1->li_tv.vval.v_string);
7546 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007547 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007548 li3->li_tv.vval.v_number =
7549 (varnumber_T)(regmatch.startp[0] - expr);
7550 li4->li_tv.vval.v_number =
7551 (varnumber_T)(regmatch.endp[0] - expr);
7552 if (l != NULL)
7553 li2->li_tv.vval.v_number = (varnumber_T)idx;
7554 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007555 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007556 {
7557 int i;
7558
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007559 // return list with matched string and submatches
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007560 for (i = 0; i < NSUBEXP; ++i)
7561 {
7562 if (regmatch.endp[i] == NULL)
7563 {
7564 if (list_append_string(rettv->vval.v_list,
7565 (char_u *)"", 0) == FAIL)
7566 break;
7567 }
7568 else if (list_append_string(rettv->vval.v_list,
7569 regmatch.startp[i],
7570 (int)(regmatch.endp[i] - regmatch.startp[i]))
7571 == FAIL)
7572 break;
7573 }
7574 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007575 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007576 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007577 // return matched string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007578 if (l != NULL)
7579 copy_tv(&li->li_tv, rettv);
7580 else
7581 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02007582 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007583 }
7584 else if (l != NULL)
7585 rettv->vval.v_number = idx;
7586 else
7587 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007588 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007589 rettv->vval.v_number =
7590 (varnumber_T)(regmatch.startp[0] - str);
7591 else
7592 rettv->vval.v_number =
7593 (varnumber_T)(regmatch.endp[0] - str);
7594 rettv->vval.v_number += (varnumber_T)(str - expr);
7595 }
7596 }
7597 vim_regfree(regmatch.regprog);
7598 }
7599
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007600theend:
7601 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007602 // matchstrpos() without a list: drop the second item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007603 listitem_remove(rettv->vval.v_list,
7604 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007605 vim_free(tofree);
7606 p_cpo = save_cpo;
7607}
7608
7609/*
7610 * "match()" function
7611 */
7612 static void
7613f_match(typval_T *argvars, typval_T *rettv)
7614{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007615 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007616}
7617
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007618/*
7619 * "matchend()" function
7620 */
7621 static void
7622f_matchend(typval_T *argvars, typval_T *rettv)
7623{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007624 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007625}
7626
7627/*
7628 * "matchlist()" function
7629 */
7630 static void
7631f_matchlist(typval_T *argvars, typval_T *rettv)
7632{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007633 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007634}
7635
7636/*
7637 * "matchstr()" function
7638 */
7639 static void
7640f_matchstr(typval_T *argvars, typval_T *rettv)
7641{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007642 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007643}
7644
7645/*
7646 * "matchstrpos()" function
7647 */
7648 static void
7649f_matchstrpos(typval_T *argvars, typval_T *rettv)
7650{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007651 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007652}
7653
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007654 static void
7655max_min(typval_T *argvars, typval_T *rettv, int domax)
7656{
7657 varnumber_T n = 0;
7658 varnumber_T i;
7659 int error = FALSE;
7660
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007661 if (in_vim9script() && check_for_list_or_dict_arg(argvars, 0) == FAIL)
7662 return;
7663
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007664 if (argvars[0].v_type == VAR_LIST)
7665 {
7666 list_T *l;
7667 listitem_T *li;
7668
7669 l = argvars[0].vval.v_list;
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007670 if (l != NULL && l->lv_len > 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007671 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007672 if (l->lv_first == &range_list_item)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007673 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007674 if ((l->lv_u.nonmat.lv_stride > 0) ^ domax)
7675 n = l->lv_u.nonmat.lv_start;
7676 else
=?UTF-8?q?Dundar=20G=C3=B6c?=d5cec1f2022-01-29 15:19:23 +00007677 n = l->lv_u.nonmat.lv_start + ((varnumber_T)l->lv_len - 1)
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007678 * l->lv_u.nonmat.lv_stride;
7679 }
7680 else
7681 {
7682 li = l->lv_first;
7683 if (li != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007684 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007685 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007686 if (error)
7687 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007688 for (;;)
7689 {
7690 li = li->li_next;
7691 if (li == NULL)
7692 break;
7693 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007694 if (error)
7695 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01007696 if (domax ? i > n : i < n)
7697 n = i;
7698 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007699 }
7700 }
7701 }
7702 }
7703 else if (argvars[0].v_type == VAR_DICT)
7704 {
7705 dict_T *d;
7706 int first = TRUE;
7707 hashitem_T *hi;
7708 int todo;
7709
7710 d = argvars[0].vval.v_dict;
7711 if (d != NULL)
7712 {
7713 todo = (int)d->dv_hashtab.ht_used;
7714 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
7715 {
7716 if (!HASHITEM_EMPTY(hi))
7717 {
7718 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007719 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007720 if (error)
7721 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007722 if (first)
7723 {
7724 n = i;
7725 first = FALSE;
7726 }
7727 else if (domax ? i > n : i < n)
7728 n = i;
7729 }
7730 }
7731 }
7732 }
7733 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007734 semsg(_(e_argument_of_str_must_be_list_or_dictionary), domax ? "max()" : "min()");
Bram Moolenaarab65fc72021-02-04 22:07:16 +01007735
7736 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007737}
7738
7739/*
7740 * "max()" function
7741 */
7742 static void
7743f_max(typval_T *argvars, typval_T *rettv)
7744{
7745 max_min(argvars, rettv, TRUE);
7746}
7747
7748/*
7749 * "min()" function
7750 */
7751 static void
7752f_min(typval_T *argvars, typval_T *rettv)
7753{
7754 max_min(argvars, rettv, FALSE);
7755}
7756
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007757#if defined(FEAT_MZSCHEME) || defined(PROTO)
7758/*
7759 * "mzeval()" function
7760 */
7761 static void
7762f_mzeval(typval_T *argvars, typval_T *rettv)
7763{
7764 char_u *str;
7765 char_u buf[NUMBUFLEN];
7766
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007767 if (check_restricted() || check_secure())
7768 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007769
7770 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7771 return;
7772
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007773 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007774 do_mzeval(str, rettv);
7775}
7776
7777 void
7778mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
7779{
7780 typval_T argvars[3];
7781
7782 argvars[0].v_type = VAR_STRING;
7783 argvars[0].vval.v_string = name;
7784 copy_tv(args, &argvars[1]);
7785 argvars[2].v_type = VAR_UNKNOWN;
7786 f_call(argvars, rettv);
7787 clear_tv(&argvars[1]);
7788}
7789#endif
7790
7791/*
7792 * "nextnonblank()" function
7793 */
7794 static void
7795f_nextnonblank(typval_T *argvars, typval_T *rettv)
7796{
7797 linenr_T lnum;
7798
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007799 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7800 return;
7801
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007802 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007803 {
7804 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
7805 {
7806 lnum = 0;
7807 break;
7808 }
7809 if (*skipwhite(ml_get(lnum)) != NUL)
7810 break;
7811 }
7812 rettv->vval.v_number = lnum;
7813}
7814
7815/*
7816 * "nr2char()" function
7817 */
7818 static void
7819f_nr2char(typval_T *argvars, typval_T *rettv)
7820{
7821 char_u buf[NUMBUFLEN];
7822
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007823 if (in_vim9script()
7824 && (check_for_number_arg(argvars, 0) == FAIL
7825 || check_for_opt_bool_arg(argvars, 1) == FAIL))
7826 return;
7827
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007828 if (has_mbyte)
7829 {
7830 int utf8 = 0;
7831
7832 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaared6a4302020-09-05 20:29:41 +02007833 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007834 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01007835 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007836 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007837 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007838 }
7839 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007840 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007841 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007842 buf[1] = NUL;
7843 }
7844 rettv->v_type = VAR_STRING;
7845 rettv->vval.v_string = vim_strsave(buf);
7846}
7847
7848/*
7849 * "or(expr, expr)" function
7850 */
7851 static void
7852f_or(typval_T *argvars, typval_T *rettv)
7853{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007854 if (in_vim9script()
7855 && (check_for_number_arg(argvars, 0) == FAIL
7856 || check_for_number_arg(argvars, 1) == FAIL))
7857 return;
7858
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007859 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
7860 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007861}
7862
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007863#ifdef FEAT_PERL
7864/*
7865 * "perleval()" function
7866 */
7867 static void
7868f_perleval(typval_T *argvars, typval_T *rettv)
7869{
7870 char_u *str;
7871 char_u buf[NUMBUFLEN];
7872
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007873 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7874 return;
7875
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007876 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007877 do_perleval(str, rettv);
7878}
7879#endif
7880
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007881/*
7882 * "prevnonblank()" function
7883 */
7884 static void
7885f_prevnonblank(typval_T *argvars, typval_T *rettv)
7886{
7887 linenr_T lnum;
7888
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007889 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
7890 return;
7891
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007892 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007893 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
7894 lnum = 0;
7895 else
7896 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
7897 --lnum;
7898 rettv->vval.v_number = lnum;
7899}
7900
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007901// This dummy va_list is here because:
7902// - passing a NULL pointer doesn't work when va_list isn't a pointer
7903// - locally in the function results in a "used before set" warning
7904// - using va_start() to initialize it gives "function with fixed args" error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007905static va_list ap;
7906
7907/*
7908 * "printf()" function
7909 */
7910 static void
7911f_printf(typval_T *argvars, typval_T *rettv)
7912{
7913 char_u buf[NUMBUFLEN];
7914 int len;
7915 char_u *s;
7916 int saved_did_emsg = did_emsg;
7917 char *fmt;
7918
7919 rettv->v_type = VAR_STRING;
7920 rettv->vval.v_string = NULL;
7921
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02007922 if (in_vim9script() && check_for_string_or_number_arg(argvars, 0) == FAIL)
7923 return;
7924
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007925 // Get the required length, allocate the buffer and do it for real.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007926 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007927 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02007928 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007929 if (!did_emsg)
7930 {
7931 s = alloc(len + 1);
7932 if (s != NULL)
7933 {
7934 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02007935 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
7936 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007937 }
7938 }
7939 did_emsg |= saved_did_emsg;
7940}
7941
7942/*
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007943 * "pum_getpos()" function
7944 */
7945 static void
7946f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7947{
Bram Moolenaar93a10962022-06-16 11:42:09 +01007948 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007949 return;
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007950 pum_set_event_info(rettv->vval.v_dict);
Bram Moolenaare9bd5722019-08-17 19:36:06 +02007951}
7952
7953/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007954 * "pumvisible()" function
7955 */
7956 static void
7957f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7958{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007959 if (pum_visible())
7960 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007961}
7962
7963#ifdef FEAT_PYTHON3
7964/*
7965 * "py3eval()" function
7966 */
7967 static void
7968f_py3eval(typval_T *argvars, typval_T *rettv)
7969{
7970 char_u *str;
7971 char_u buf[NUMBUFLEN];
7972
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007973 if (check_restricted() || check_secure())
7974 return;
7975
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007976 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7977 return;
7978
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01007979 if (p_pyx == 0)
7980 p_pyx = 3;
7981
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007982 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007983 do_py3eval(str, rettv);
7984}
7985#endif
7986
7987#ifdef FEAT_PYTHON
7988/*
7989 * "pyeval()" function
7990 */
7991 static void
7992f_pyeval(typval_T *argvars, typval_T *rettv)
7993{
7994 char_u *str;
7995 char_u buf[NUMBUFLEN];
7996
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007997 if (check_restricted() || check_secure())
7998 return;
7999
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008000 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8001 return;
8002
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008003 if (p_pyx == 0)
8004 p_pyx = 2;
8005
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008006 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008007 do_pyeval(str, rettv);
8008}
8009#endif
8010
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008011#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
8012/*
8013 * "pyxeval()" function
8014 */
8015 static void
8016f_pyxeval(typval_T *argvars, typval_T *rettv)
8017{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008018 if (check_restricted() || check_secure())
8019 return;
8020
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008021 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8022 return;
8023
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008024# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
8025 init_pyxversion();
8026 if (p_pyx == 2)
8027 f_pyeval(argvars, rettv);
8028 else
8029 f_py3eval(argvars, rettv);
8030# elif defined(FEAT_PYTHON)
8031 f_pyeval(argvars, rettv);
8032# elif defined(FEAT_PYTHON3)
8033 f_py3eval(argvars, rettv);
8034# endif
8035}
8036#endif
8037
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008038static UINT32_T srand_seed_for_testing = 0;
8039static int srand_seed_for_testing_is_used = FALSE;
8040
8041 static void
8042f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED)
8043{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008044 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8045 return;
8046
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008047 if (argvars[0].v_type == VAR_UNKNOWN)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008048 srand_seed_for_testing_is_used = FALSE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008049 else
8050 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008051 srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]);
8052 srand_seed_for_testing_is_used = TRUE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008053 }
8054}
8055
8056 static void
8057init_srand(UINT32_T *x)
8058{
8059#ifndef MSWIN
8060 static int dev_urandom_state = NOTDONE; // FAIL or OK once tried
8061#endif
8062
8063 if (srand_seed_for_testing_is_used)
8064 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008065 *x = srand_seed_for_testing;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008066 return;
8067 }
8068#ifndef MSWIN
8069 if (dev_urandom_state != FAIL)
8070 {
8071 int fd = open("/dev/urandom", O_RDONLY);
8072 struct {
8073 union {
8074 UINT32_T number;
8075 char bytes[sizeof(UINT32_T)];
8076 } contents;
8077 } buf;
8078
8079 // Attempt reading /dev/urandom.
8080 if (fd == -1)
8081 dev_urandom_state = FAIL;
8082 else
8083 {
8084 buf.contents.number = 0;
8085 if (read(fd, buf.contents.bytes, sizeof(UINT32_T))
8086 != sizeof(UINT32_T))
8087 dev_urandom_state = FAIL;
8088 else
8089 {
8090 dev_urandom_state = OK;
8091 *x = buf.contents.number;
8092 }
8093 close(fd);
8094 }
8095 }
8096 if (dev_urandom_state != OK)
8097 // Reading /dev/urandom doesn't work, fall back to time().
8098#endif
8099 *x = vim_time();
8100}
8101
kylo252ae6f1d82022-02-16 19:24:07 +00008102#define ROTL(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008103#define SPLITMIX32(x, z) ( \
kylo252ae6f1d82022-02-16 19:24:07 +00008104 (z) = ((x) += 0x9e3779b9), \
8105 (z) = ((z) ^ ((z) >> 16)) * 0x85ebca6b, \
8106 (z) = ((z) ^ ((z) >> 13)) * 0xc2b2ae35, \
8107 (z) ^ ((z) >> 16) \
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008108 )
8109#define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \
kylo252ae6f1d82022-02-16 19:24:07 +00008110 result = ROTL((y) * 5, 7) * 9; \
8111 t = (y) << 9; \
8112 (z) ^= (x); \
8113 (w) ^= (y); \
8114 (y) ^= (z), (x) ^= (w); \
8115 (z) ^= t; \
8116 (w) = ROTL(w, 11);
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008117
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008118/*
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008119 * "rand()" function
8120 */
8121 static void
8122f_rand(typval_T *argvars, typval_T *rettv)
8123{
8124 list_T *l = NULL;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008125 static UINT32_T gx, gy, gz, gw;
8126 static int initialized = FALSE;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008127 listitem_T *lx, *ly, *lz, *lw;
Bram Moolenaar0fd797e2020-11-05 20:46:32 +01008128 UINT32_T x = 0, y, z, w, t, result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008129
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008130 if (in_vim9script() && check_for_opt_list_arg(argvars, 0) == FAIL)
8131 return;
8132
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008133 if (argvars[0].v_type == VAR_UNKNOWN)
8134 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008135 // When no argument is given use the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008136 if (initialized == FALSE)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008137 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008138 // Initialize the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008139 init_srand(&x);
8140
8141 gx = SPLITMIX32(x, z);
8142 gy = SPLITMIX32(x, z);
8143 gz = SPLITMIX32(x, z);
8144 gw = SPLITMIX32(x, z);
8145 initialized = TRUE;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008146 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008147
8148 SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008149 }
8150 else if (argvars[0].v_type == VAR_LIST)
8151 {
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008152 l = argvars[0].vval.v_list;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008153 if (l == NULL || list_len(l) != 4)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008154 goto theend;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008155
8156 lx = list_find(l, 0L);
8157 ly = list_find(l, 1L);
8158 lz = list_find(l, 2L);
8159 lw = list_find(l, 3L);
8160 if (lx->li_tv.v_type != VAR_NUMBER) goto theend;
8161 if (ly->li_tv.v_type != VAR_NUMBER) goto theend;
8162 if (lz->li_tv.v_type != VAR_NUMBER) goto theend;
8163 if (lw->li_tv.v_type != VAR_NUMBER) goto theend;
8164 x = (UINT32_T)lx->li_tv.vval.v_number;
8165 y = (UINT32_T)ly->li_tv.vval.v_number;
8166 z = (UINT32_T)lz->li_tv.vval.v_number;
8167 w = (UINT32_T)lw->li_tv.vval.v_number;
8168
8169 SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w);
8170
8171 lx->li_tv.vval.v_number = (varnumber_T)x;
8172 ly->li_tv.vval.v_number = (varnumber_T)y;
8173 lz->li_tv.vval.v_number = (varnumber_T)z;
8174 lw->li_tv.vval.v_number = (varnumber_T)w;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008175 }
8176 else
8177 goto theend;
8178
8179 rettv->v_type = VAR_NUMBER;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008180 rettv->vval.v_number = (varnumber_T)result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008181 return;
8182
8183theend:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008184 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01008185 rettv->v_type = VAR_NUMBER;
8186 rettv->vval.v_number = -1;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01008187}
8188
8189/*
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008190 * "srand()" function
8191 */
8192 static void
8193f_srand(typval_T *argvars, typval_T *rettv)
8194{
8195 UINT32_T x = 0, z;
8196
8197 if (rettv_list_alloc(rettv) == FAIL)
8198 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008199
8200 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8201 return;
8202
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008203 if (argvars[0].v_type == VAR_UNKNOWN)
8204 {
8205 init_srand(&x);
8206 }
8207 else
8208 {
8209 int error = FALSE;
8210
8211 x = (UINT32_T)tv_get_number_chk(&argvars[0], &error);
8212 if (error)
8213 return;
8214 }
8215
8216 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8217 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8218 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8219 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
8220}
8221
8222#undef ROTL
8223#undef SPLITMIX32
8224#undef SHUFFLE_XOSHIRO128STARSTAR
8225
8226/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008227 * "range()" function
8228 */
8229 static void
8230f_range(typval_T *argvars, typval_T *rettv)
8231{
8232 varnumber_T start;
8233 varnumber_T end;
8234 varnumber_T stride = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008235 int error = FALSE;
8236
Bram Moolenaar93a10962022-06-16 11:42:09 +01008237 if (rettv_list_alloc(rettv) == FAIL)
Yegappan Lakshmananca195cc2022-06-14 13:42:26 +01008238 return;
8239
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008240 if (in_vim9script()
8241 && (check_for_number_arg(argvars, 0) == FAIL
8242 || check_for_opt_number_arg(argvars, 1) == FAIL
8243 || (argvars[1].v_type != VAR_UNKNOWN
8244 && check_for_opt_number_arg(argvars, 2) == FAIL)))
8245 return;
8246
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008247 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008248 if (argvars[1].v_type == VAR_UNKNOWN)
8249 {
8250 end = start - 1;
8251 start = 0;
8252 }
8253 else
8254 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008255 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008256 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008257 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008258 }
8259
8260 if (error)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008261 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008262 if (stride == 0)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008263 emsg(_(e_stride_is_zero));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008264 else if (stride > 0 ? end + 1 < start : end - 1 > start)
Bram Moolenaara6f79292022-01-04 21:30:47 +00008265 emsg(_(e_start_past_end));
Yegappan Lakshmananca195cc2022-06-14 13:42:26 +01008266 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008267 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008268 list_T *list = rettv->vval.v_list;
8269
8270 // Create a non-materialized list. This is much more efficient and
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008271 // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008272 // be called.
8273 list->lv_first = &range_list_item;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008274 list->lv_u.nonmat.lv_start = start;
8275 list->lv_u.nonmat.lv_end = end;
8276 list->lv_u.nonmat.lv_stride = stride;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008277 list->lv_len = (end - start) / stride + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008278 }
8279}
8280
8281/*
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008282 * Materialize "list".
8283 * Do not call directly, use CHECK_LIST_MATERIALIZE()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008284 */
8285 void
8286range_list_materialize(list_T *list)
8287{
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008288 varnumber_T start = list->lv_u.nonmat.lv_start;
8289 varnumber_T end = list->lv_u.nonmat.lv_end;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008290 int stride = list->lv_u.nonmat.lv_stride;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008291 varnumber_T i;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008292
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008293 list->lv_first = NULL;
8294 list->lv_u.mat.lv_last = NULL;
8295 list->lv_len = 0;
8296 list->lv_u.mat.lv_idx_item = NULL;
8297 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008298 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00008299 if (list_append_number(list, i) == FAIL)
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008300 break;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00008301 if (list->lv_lock & VAR_ITEMS_LOCKED)
8302 list->lv_u.mat.lv_last->li_tv.v_lock = VAR_LOCKED;
8303 }
8304 list->lv_lock &= ~VAR_ITEMS_LOCKED;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008305}
8306
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008307/*
8308 * "getreginfo()" function
8309 */
8310 static void
8311f_getreginfo(typval_T *argvars, typval_T *rettv)
8312{
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008313 int regname;
8314 char_u buf[NUMBUFLEN + 2];
8315 long reglen = 0;
8316 dict_T *dict;
8317 list_T *list;
8318
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008319 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
8320 return;
8321
zeertzjqd3f00f52021-12-24 12:02:43 +00008322 regname = getreg_get_regname(argvars);
8323 if (regname == 0)
8324 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008325
zeertzjqd3f00f52021-12-24 12:02:43 +00008326 if (regname == '@')
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008327 regname = '"';
8328
8329 if (rettv_dict_alloc(rettv) == FAIL)
8330 return;
8331 dict = rettv->vval.v_dict;
8332
8333 list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
8334 if (list == NULL)
8335 return;
Bram Moolenaar91639192020-06-29 19:55:58 +02008336 (void)dict_add_list(dict, "regcontents", list);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008337
8338 buf[0] = NUL;
8339 buf[1] = NUL;
8340 switch (get_reg_type(regname, &reglen))
8341 {
8342 case MLINE: buf[0] = 'V'; break;
8343 case MCHAR: buf[0] = 'v'; break;
8344 case MBLOCK:
8345 vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
8346 reglen + 1);
8347 break;
8348 }
Bram Moolenaar91639192020-06-29 19:55:58 +02008349 (void)dict_add_string(dict, (char *)"regtype", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008350
8351 buf[0] = get_register_name(get_unname_register());
8352 buf[1] = NUL;
8353 if (regname == '"')
Bram Moolenaar91639192020-06-29 19:55:58 +02008354 (void)dict_add_string(dict, (char *)"points_to", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008355 else
8356 {
8357 dictitem_T *item = dictitem_alloc((char_u *)"isunnamed");
8358
8359 if (item != NULL)
8360 {
8361 item->di_tv.v_type = VAR_SPECIAL;
8362 item->di_tv.vval.v_number = regname == buf[0]
Bram Moolenaar418a29f2021-02-10 22:23:41 +01008363 ? VVAL_TRUE : VVAL_FALSE;
Bram Moolenaar91639192020-06-29 19:55:58 +02008364 (void)dict_add(dict, item);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008365 }
8366 }
8367}
8368
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02008369 static void
8370return_register(int regname, typval_T *rettv)
8371{
8372 char_u buf[2] = {0, 0};
8373
8374 buf[0] = (char_u)regname;
8375 rettv->v_type = VAR_STRING;
8376 rettv->vval.v_string = vim_strsave(buf);
8377}
8378
8379/*
8380 * "reg_executing()" function
8381 */
8382 static void
8383f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
8384{
8385 return_register(reg_executing, rettv);
8386}
8387
8388/*
8389 * "reg_recording()" function
8390 */
8391 static void
8392f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
8393{
8394 return_register(reg_recording, rettv);
8395}
8396
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01008397/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008398 * "rename({from}, {to})" function
8399 */
8400 static void
8401f_rename(typval_T *argvars, typval_T *rettv)
8402{
8403 char_u buf[NUMBUFLEN];
8404
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008405 rettv->vval.v_number = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008406 if (check_restricted() || check_secure())
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008407 return;
8408
8409 if (in_vim9script()
8410 && (check_for_string_arg(argvars, 0) == FAIL
8411 || check_for_string_arg(argvars, 1) == FAIL))
8412 return;
8413
8414 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008415 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008416}
8417
8418/*
8419 * "repeat()" function
8420 */
8421 static void
8422f_repeat(typval_T *argvars, typval_T *rettv)
8423{
8424 char_u *p;
8425 int n;
8426 int slen;
8427 int len;
8428 char_u *r;
8429 int i;
8430
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008431 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008432 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
8433 || check_for_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008434 return;
8435
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008436 n = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008437 if (argvars[0].v_type == VAR_LIST)
8438 {
8439 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
8440 while (n-- > 0)
8441 if (list_extend(rettv->vval.v_list,
8442 argvars[0].vval.v_list, NULL) == FAIL)
8443 break;
8444 }
8445 else
8446 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008447 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008448 rettv->v_type = VAR_STRING;
8449 rettv->vval.v_string = NULL;
8450
8451 slen = (int)STRLEN(p);
8452 len = slen * n;
8453 if (len <= 0)
8454 return;
8455
8456 r = alloc(len + 1);
8457 if (r != NULL)
8458 {
8459 for (i = 0; i < n; i++)
8460 mch_memmove(r + i * slen, p, (size_t)slen);
8461 r[len] = NUL;
8462 }
8463
8464 rettv->vval.v_string = r;
8465 }
8466}
8467
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008468#define SP_NOMOVE 0x01 // don't move cursor
8469#define SP_REPEAT 0x02 // repeat to find outer pair
8470#define SP_RETCOUNT 0x04 // return matchcount
8471#define SP_SETPCMARK 0x08 // set previous context mark
8472#define SP_START 0x10 // accept match at start position
8473#define SP_SUBPAT 0x20 // return nr of matching sub-pattern
8474#define SP_END 0x40 // leave cursor at end of match
8475#define SP_COLUMN 0x80 // start at cursor column
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008476
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008477/*
8478 * Get flags for a search function.
8479 * Possibly sets "p_ws".
8480 * Returns BACKWARD, FORWARD or zero (for an error).
8481 */
8482 static int
8483get_search_arg(typval_T *varp, int *flagsp)
8484{
8485 int dir = FORWARD;
8486 char_u *flags;
8487 char_u nbuf[NUMBUFLEN];
8488 int mask;
8489
8490 if (varp->v_type != VAR_UNKNOWN)
8491 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008492 flags = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008493 if (flags == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008494 return 0; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008495 while (*flags != NUL)
8496 {
8497 switch (*flags)
8498 {
8499 case 'b': dir = BACKWARD; break;
8500 case 'w': p_ws = TRUE; break;
8501 case 'W': p_ws = FALSE; break;
8502 default: mask = 0;
8503 if (flagsp != NULL)
8504 switch (*flags)
8505 {
8506 case 'c': mask = SP_START; break;
8507 case 'e': mask = SP_END; break;
8508 case 'm': mask = SP_RETCOUNT; break;
8509 case 'n': mask = SP_NOMOVE; break;
8510 case 'p': mask = SP_SUBPAT; break;
8511 case 'r': mask = SP_REPEAT; break;
8512 case 's': mask = SP_SETPCMARK; break;
8513 case 'z': mask = SP_COLUMN; break;
8514 }
8515 if (mask == 0)
8516 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008517 semsg(_(e_invalid_argument_str), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008518 dir = 0;
8519 }
8520 else
8521 *flagsp |= mask;
8522 }
8523 if (dir == 0)
8524 break;
8525 ++flags;
8526 }
8527 }
8528 return dir;
8529}
8530
8531/*
8532 * Shared by search() and searchpos() functions.
8533 */
8534 static int
8535search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
8536{
8537 int flags;
8538 char_u *pat;
8539 pos_T pos;
8540 pos_T save_cursor;
8541 int save_p_ws = p_ws;
8542 int dir;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008543 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008544 long lnum_stop = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008545#ifdef FEAT_RELTIME
8546 long time_limit = 0;
8547#endif
8548 int options = SEARCH_KEEP;
8549 int subpatnum;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008550 searchit_arg_T sia;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008551 int use_skip = FALSE;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008552 pos_T firstpos;
8553
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02008554 if (in_vim9script()
8555 && (check_for_string_arg(argvars, 0) == FAIL
8556 || check_for_opt_string_arg(argvars, 1) == FAIL
8557 || (argvars[1].v_type != VAR_UNKNOWN
8558 && (check_for_opt_number_arg(argvars, 2) == FAIL
8559 || (argvars[2].v_type != VAR_UNKNOWN
8560 && check_for_opt_number_arg(argvars, 3) == FAIL)))))
8561 goto theend;
8562
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008563 pat = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008564 dir = get_search_arg(&argvars[1], flagsp); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008565 if (dir == 0)
8566 goto theend;
8567 flags = *flagsp;
8568 if (flags & SP_START)
8569 options |= SEARCH_START;
8570 if (flags & SP_END)
8571 options |= SEARCH_END;
8572 if (flags & SP_COLUMN)
8573 options |= SEARCH_COL;
8574
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008575 // Optional arguments: line number to stop searching, timeout and skip.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008576 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
8577 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008578 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008579 if (lnum_stop < 0)
8580 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008581 if (argvars[3].v_type != VAR_UNKNOWN)
8582 {
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008583#ifdef FEAT_RELTIME
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008584 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008585 if (time_limit < 0)
8586 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008587#endif
Bram Moolenaara9c01042020-06-07 14:50:50 +02008588 use_skip = eval_expr_valid_arg(&argvars[4]);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008589 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008590 }
8591
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008592 /*
8593 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
8594 * Check to make sure only those flags are set.
8595 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
8596 * flags cannot be set. Check for that condition also.
8597 */
8598 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
8599 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
8600 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008601 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008602 goto theend;
8603 }
8604
8605 pos = save_cursor = curwin->w_cursor;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008606 CLEAR_FIELD(firstpos);
Bram Moolenaara80faa82020-04-12 19:37:17 +02008607 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008608 sia.sa_stop_lnum = (linenr_T)lnum_stop;
8609#ifdef FEAT_RELTIME
Paul Ollis65745772022-06-05 16:55:54 +01008610 sia.sa_tm = time_limit;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008611#endif
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008612
8613 // Repeat until {skip} returns FALSE.
8614 for (;;)
8615 {
8616 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02008617 options, RE_SEARCH, &sia);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008618 // finding the first match again means there is no match where {skip}
8619 // evaluates to zero.
8620 if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))
8621 subpatnum = FAIL;
8622
Bram Moolenaara9c01042020-06-07 14:50:50 +02008623 if (subpatnum == FAIL || !use_skip)
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008624 // didn't find it or no skip argument
8625 break;
8626 firstpos = pos;
8627
Bram Moolenaara9c01042020-06-07 14:50:50 +02008628 // If the skip expression matches, ignore this match.
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008629 {
8630 int do_skip;
8631 int err;
8632 pos_T save_pos = curwin->w_cursor;
8633
8634 curwin->w_cursor = pos;
Bram Moolenaara9c01042020-06-07 14:50:50 +02008635 err = FALSE;
8636 do_skip = eval_expr_to_bool(&argvars[4], &err);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008637 curwin->w_cursor = save_pos;
8638 if (err)
8639 {
8640 // Evaluating {skip} caused an error, break here.
8641 subpatnum = FAIL;
8642 break;
8643 }
8644 if (!do_skip)
8645 break;
8646 }
zeertzjq180246c2022-06-23 12:04:46 +01008647
8648 // clear the start flag to avoid getting stuck here
8649 options &= ~SEARCH_START;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02008650 }
8651
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008652 if (subpatnum != FAIL)
8653 {
8654 if (flags & SP_SUBPAT)
8655 retval = subpatnum;
8656 else
8657 retval = pos.lnum;
8658 if (flags & SP_SETPCMARK)
8659 setpcmark();
8660 curwin->w_cursor = pos;
8661 if (match_pos != NULL)
8662 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008663 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008664 match_pos->lnum = pos.lnum;
8665 match_pos->col = pos.col + 1;
8666 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008667 // "/$" will put the cursor after the end of the line, may need to
8668 // correct that here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008669 check_cursor();
8670 }
8671
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008672 // If 'n' flag is used: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008673 if (flags & SP_NOMOVE)
8674 curwin->w_cursor = save_cursor;
8675 else
8676 curwin->w_set_curswant = TRUE;
8677theend:
8678 p_ws = save_p_ws;
8679
8680 return retval;
8681}
8682
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008683#ifdef FEAT_RUBY
8684/*
8685 * "rubyeval()" function
8686 */
8687 static void
8688f_rubyeval(typval_T *argvars, typval_T *rettv)
8689{
8690 char_u *str;
8691 char_u buf[NUMBUFLEN];
8692
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008693 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8694 return;
8695
Bram Moolenaare99be0e2019-03-26 22:51:09 +01008696 str = tv_get_string_buf(&argvars[0], buf);
8697 do_rubyeval(str, rettv);
8698}
8699#endif
8700
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008701/*
8702 * "screenattr()" function
8703 */
8704 static void
8705f_screenattr(typval_T *argvars, typval_T *rettv)
8706{
8707 int row;
8708 int col;
8709 int c;
8710
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008711 if (in_vim9script()
8712 && (check_for_number_arg(argvars, 0) == FAIL
8713 || check_for_number_arg(argvars, 1) == FAIL))
8714 return;
8715
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008716 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8717 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008718 if (row < 0 || row >= screen_Rows
8719 || col < 0 || col >= screen_Columns)
8720 c = -1;
8721 else
8722 c = ScreenAttrs[LineOffset[row] + col];
8723 rettv->vval.v_number = c;
8724}
8725
8726/*
8727 * "screenchar()" function
8728 */
8729 static void
8730f_screenchar(typval_T *argvars, typval_T *rettv)
8731{
8732 int row;
8733 int col;
8734 int off;
8735 int c;
8736
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008737 if (in_vim9script()
8738 && (check_for_number_arg(argvars, 0) == FAIL
8739 || check_for_number_arg(argvars, 1) == FAIL))
8740 return;
8741
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008742 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8743 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008744 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008745 c = -1;
8746 else
8747 {
8748 off = LineOffset[row] + col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008749 if (enc_utf8 && ScreenLinesUC[off] != 0)
8750 c = ScreenLinesUC[off];
8751 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008752 c = ScreenLines[off];
8753 }
8754 rettv->vval.v_number = c;
8755}
8756
8757/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008758 * "screenchars()" function
8759 */
8760 static void
8761f_screenchars(typval_T *argvars, typval_T *rettv)
8762{
8763 int row;
8764 int col;
8765 int off;
8766 int c;
8767 int i;
8768
8769 if (rettv_list_alloc(rettv) == FAIL)
8770 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008771
8772 if (in_vim9script()
8773 && (check_for_number_arg(argvars, 0) == FAIL
8774 || check_for_number_arg(argvars, 1) == FAIL))
8775 return;
8776
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008777 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8778 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8779 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8780 return;
8781
8782 off = LineOffset[row] + col;
8783 if (enc_utf8 && ScreenLinesUC[off] != 0)
8784 c = ScreenLinesUC[off];
8785 else
8786 c = ScreenLines[off];
8787 list_append_number(rettv->vval.v_list, (varnumber_T)c);
8788
8789 if (enc_utf8)
8790
8791 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8792 list_append_number(rettv->vval.v_list,
8793 (varnumber_T)ScreenLinesC[i][off]);
8794}
8795
8796/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008797 * "screencol()" function
8798 *
8799 * First column is 1 to be consistent with virtcol().
8800 */
8801 static void
8802f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
8803{
8804 rettv->vval.v_number = screen_screencol() + 1;
8805}
8806
8807/*
8808 * "screenrow()" function
8809 */
8810 static void
8811f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
8812{
8813 rettv->vval.v_number = screen_screenrow() + 1;
8814}
8815
8816/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008817 * "screenstring()" function
8818 */
8819 static void
8820f_screenstring(typval_T *argvars, typval_T *rettv)
8821{
8822 int row;
8823 int col;
8824 int off;
8825 int c;
8826 int i;
8827 char_u buf[MB_MAXBYTES + 1];
8828 int buflen = 0;
8829
8830 rettv->vval.v_string = NULL;
8831 rettv->v_type = VAR_STRING;
8832
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008833 if (in_vim9script()
8834 && (check_for_number_arg(argvars, 0) == FAIL
8835 || check_for_number_arg(argvars, 1) == FAIL))
8836 return;
8837
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008838 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
8839 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
8840 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
8841 return;
8842
8843 off = LineOffset[row] + col;
8844 if (enc_utf8 && ScreenLinesUC[off] != 0)
8845 c = ScreenLinesUC[off];
8846 else
8847 c = ScreenLines[off];
8848 buflen += mb_char2bytes(c, buf);
8849
Bram Moolenaarf1387282021-03-22 17:11:15 +01008850 if (enc_utf8 && ScreenLinesUC[off] != 0)
Bram Moolenaar2912abb2019-03-29 14:16:42 +01008851 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
8852 buflen += mb_char2bytes(ScreenLinesC[i][off], buf + buflen);
8853
8854 buf[buflen] = NUL;
8855 rettv->vval.v_string = vim_strsave(buf);
8856}
8857
8858/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008859 * "search()" function
8860 */
8861 static void
8862f_search(typval_T *argvars, typval_T *rettv)
8863{
8864 int flags = 0;
8865
8866 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
8867}
8868
8869/*
8870 * "searchdecl()" function
8871 */
8872 static void
8873f_searchdecl(typval_T *argvars, typval_T *rettv)
8874{
Bram Moolenaar30788d32020-09-05 21:35:16 +02008875 int locally = TRUE;
8876 int thisblock = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008877 int error = FALSE;
8878 char_u *name;
8879
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008880 rettv->vval.v_number = 1; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008881
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02008882 if (in_vim9script()
8883 && (check_for_string_arg(argvars, 0) == FAIL
8884 || check_for_opt_bool_arg(argvars, 1) == FAIL
8885 || (argvars[1].v_type != VAR_UNKNOWN
8886 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
8887 return;
8888
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008889 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008890 if (argvars[1].v_type != VAR_UNKNOWN)
8891 {
Bram Moolenaar30788d32020-09-05 21:35:16 +02008892 locally = !(int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008893 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar30788d32020-09-05 21:35:16 +02008894 thisblock = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008895 }
8896 if (!error && name != NULL)
8897 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
8898 locally, thisblock, SEARCH_KEEP) == FAIL;
8899}
8900
8901/*
8902 * Used by searchpair() and searchpairpos()
8903 */
8904 static int
8905searchpair_cmn(typval_T *argvars, pos_T *match_pos)
8906{
8907 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +01008908 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008909 int save_p_ws = p_ws;
8910 int dir;
8911 int flags = 0;
8912 char_u nbuf1[NUMBUFLEN];
8913 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008914 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008915 long lnum_stop = 0;
8916 long time_limit = 0;
8917
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02008918 if (in_vim9script()
8919 && (check_for_string_arg(argvars, 0) == FAIL
8920 || check_for_string_arg(argvars, 1) == FAIL
8921 || check_for_string_arg(argvars, 2) == FAIL
8922 || check_for_opt_string_arg(argvars, 3) == FAIL
8923 || (argvars[3].v_type != VAR_UNKNOWN
8924 && argvars[4].v_type != VAR_UNKNOWN
8925 && (check_for_opt_number_arg(argvars, 5) == FAIL
8926 || (argvars[5].v_type != VAR_UNKNOWN
8927 && check_for_opt_number_arg(argvars, 6) == FAIL)))))
8928 goto theend;
8929
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008930 // Get the three pattern arguments: start, middle, end. Will result in an
8931 // error if not a valid argument.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008932 spat = tv_get_string_chk(&argvars[0]);
8933 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
8934 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008935 if (spat == NULL || mpat == NULL || epat == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008936 goto theend; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008937
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008938 // Handle the optional fourth argument: flags
8939 dir = get_search_arg(&argvars[3], &flags); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008940 if (dir == 0)
8941 goto theend;
8942
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008943 // Don't accept SP_END or SP_SUBPAT.
8944 // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008945 if ((flags & (SP_END | SP_SUBPAT)) != 0
8946 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
8947 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008948 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008949 goto theend;
8950 }
8951
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008952 // Using 'r' implies 'W', otherwise it doesn't work.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008953 if (flags & SP_REPEAT)
8954 p_ws = FALSE;
8955
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008956 // Optional fifth argument: skip expression
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008957 if (argvars[3].v_type == VAR_UNKNOWN
8958 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +01008959 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008960 else
8961 {
Bram Moolenaara9c01042020-06-07 14:50:50 +02008962 // Type is checked later.
Bram Moolenaar48570482017-10-30 21:48:41 +01008963 skip = &argvars[4];
Bram Moolenaara9c01042020-06-07 14:50:50 +02008964
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008965 if (argvars[5].v_type != VAR_UNKNOWN)
8966 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008967 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008968 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008969 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008970 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008971 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008972 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008973#ifdef FEAT_RELTIME
8974 if (argvars[6].v_type != VAR_UNKNOWN)
8975 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008976 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008977 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008978 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00008979 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008980 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02008981 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008982 }
8983#endif
8984 }
8985 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008986
8987 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
8988 match_pos, lnum_stop, time_limit);
8989
8990theend:
8991 p_ws = save_p_ws;
8992
8993 return retval;
8994}
8995
8996/*
8997 * "searchpair()" function
8998 */
8999 static void
9000f_searchpair(typval_T *argvars, typval_T *rettv)
9001{
9002 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
9003}
9004
9005/*
9006 * "searchpairpos()" function
9007 */
9008 static void
9009f_searchpairpos(typval_T *argvars, typval_T *rettv)
9010{
9011 pos_T match_pos;
9012 int lnum = 0;
9013 int col = 0;
9014
9015 if (rettv_list_alloc(rettv) == FAIL)
9016 return;
9017
9018 if (searchpair_cmn(argvars, &match_pos) > 0)
9019 {
9020 lnum = match_pos.lnum;
9021 col = match_pos.col;
9022 }
9023
9024 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
9025 list_append_number(rettv->vval.v_list, (varnumber_T)col);
9026}
9027
9028/*
9029 * Search for a start/middle/end thing.
9030 * Used by searchpair(), see its documentation for the details.
9031 * Returns 0 or -1 for no match,
9032 */
9033 long
9034do_searchpair(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009035 char_u *spat, // start pattern
9036 char_u *mpat, // middle pattern
9037 char_u *epat, // end pattern
9038 int dir, // BACKWARD or FORWARD
9039 typval_T *skip, // skip expression
9040 int flags, // SP_SETPCMARK and other SP_ values
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009041 pos_T *match_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009042 linenr_T lnum_stop, // stop at this line if not zero
9043 long time_limit UNUSED) // stop after this many msec
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009044{
9045 char_u *save_cpo;
9046 char_u *pat, *pat2 = NULL, *pat3 = NULL;
9047 long retval = 0;
9048 pos_T pos;
9049 pos_T firstpos;
9050 pos_T foundpos;
9051 pos_T save_cursor;
9052 pos_T save_pos;
9053 int n;
9054 int r;
9055 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +01009056 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009057 int err;
9058 int options = SEARCH_KEEP;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009059
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009060 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009061 save_cpo = p_cpo;
9062 p_cpo = empty_option;
9063
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009064 // Make two search patterns: start/end (pat2, for in nested pairs) and
9065 // start/middle/end (pat3, for the top pair).
Bram Moolenaar964b3742019-05-24 18:54:09 +02009066 pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17);
9067 pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009068 if (pat2 == NULL || pat3 == NULL)
9069 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +01009070 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009071 if (*mpat == NUL)
9072 STRCPY(pat3, pat2);
9073 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +01009074 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009075 spat, epat, mpat);
9076 if (flags & SP_START)
9077 options |= SEARCH_START;
9078
Bram Moolenaar48570482017-10-30 21:48:41 +01009079 if (skip != NULL)
Bram Moolenaara9c01042020-06-07 14:50:50 +02009080 use_skip = eval_expr_valid_arg(skip);
Bram Moolenaar48570482017-10-30 21:48:41 +01009081
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009082#ifdef FEAT_RELTIME
9083 if (time_limit > 0)
9084 init_regexp_timeout(time_limit);
9085#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009086 save_cursor = curwin->w_cursor;
9087 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009088 CLEAR_POS(&firstpos);
9089 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009090 pat = pat3;
9091 for (;;)
9092 {
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009093 searchit_arg_T sia;
9094
Bram Moolenaara80faa82020-04-12 19:37:17 +02009095 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009096 sia.sa_stop_lnum = lnum_stop;
Bram Moolenaar5d24a222018-12-23 19:10:09 +01009097 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009098 options, RE_SEARCH, &sia);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009099 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009100 // didn't find it or found the first match again: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009101 break;
9102
9103 if (firstpos.lnum == 0)
9104 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01009105 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009106 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009107 // Found the same position again. Can happen with a pattern that
9108 // has "\zs" at the end and searching backwards. Advance one
9109 // character and try again.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009110 if (dir == BACKWARD)
9111 decl(&pos);
9112 else
9113 incl(&pos);
9114 }
9115 foundpos = pos;
9116
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009117 // clear the start flag to avoid getting stuck here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009118 options &= ~SEARCH_START;
9119
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009120 // If the skip pattern matches, ignore this match.
Bram Moolenaar48570482017-10-30 21:48:41 +01009121 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009122 {
9123 save_pos = curwin->w_cursor;
9124 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +01009125 err = FALSE;
9126 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009127 curwin->w_cursor = save_pos;
9128 if (err)
9129 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009130 // Evaluating {skip} caused an error, break here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009131 curwin->w_cursor = save_cursor;
9132 retval = -1;
9133 break;
9134 }
9135 if (r)
9136 continue;
9137 }
9138
9139 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
9140 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009141 // Found end when searching backwards or start when searching
9142 // forward: nested pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009143 ++nest;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009144 pat = pat2; // nested, don't search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009145 }
9146 else
9147 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009148 // Found end when searching forward or start when searching
9149 // backward: end of (nested) pair; or found middle in outer pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009150 if (--nest == 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009151 pat = pat3; // outer level, search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009152 }
9153
9154 if (nest == 0)
9155 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009156 // Found the match: return matchcount or line number.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009157 if (flags & SP_RETCOUNT)
9158 ++retval;
9159 else
9160 retval = pos.lnum;
9161 if (flags & SP_SETPCMARK)
9162 setpcmark();
9163 curwin->w_cursor = pos;
9164 if (!(flags & SP_REPEAT))
9165 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009166 nest = 1; // search for next unmatched
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009167 }
9168 }
9169
9170 if (match_pos != NULL)
9171 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009172 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009173 match_pos->lnum = curwin->w_cursor.lnum;
9174 match_pos->col = curwin->w_cursor.col + 1;
9175 }
9176
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009177 // If 'n' flag is used or search failed: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009178 if ((flags & SP_NOMOVE) || retval == 0)
9179 curwin->w_cursor = save_cursor;
9180
9181theend:
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009182#ifdef FEAT_RELTIME
Bram Moolenaar0f618382022-08-26 21:33:04 +01009183 if (time_limit > 0)
9184 disable_regexp_timeout();
Bram Moolenaar5ea38d12022-06-16 21:20:48 +01009185#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009186 vim_free(pat2);
9187 vim_free(pat3);
9188 if (p_cpo == empty_option)
9189 p_cpo = save_cpo;
9190 else
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009191 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009192 // Darn, evaluating the {skip} expression changed the value.
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009193 // If it's still empty it was changed and restored, need to restore in
9194 // the complicated way.
9195 if (*p_cpo == NUL)
Bram Moolenaar31e5c602022-04-15 13:53:33 +01009196 set_option_value_give_err((char_u *)"cpo", 0L, save_cpo, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009197 free_string_option(save_cpo);
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009198 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009199
9200 return retval;
9201}
9202
9203/*
9204 * "searchpos()" function
9205 */
9206 static void
9207f_searchpos(typval_T *argvars, typval_T *rettv)
9208{
9209 pos_T match_pos;
9210 int lnum = 0;
9211 int col = 0;
9212 int n;
9213 int flags = 0;
9214
9215 if (rettv_list_alloc(rettv) == FAIL)
9216 return;
9217
9218 n = search_cmn(argvars, &match_pos, &flags);
9219 if (n > 0)
9220 {
9221 lnum = match_pos.lnum;
9222 col = match_pos.col;
9223 }
9224
9225 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
9226 list_append_number(rettv->vval.v_list, (varnumber_T)col);
9227 if (flags & SP_SUBPAT)
9228 list_append_number(rettv->vval.v_list, (varnumber_T)n);
9229}
9230
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009231/*
9232 * Set the cursor or mark position.
Christian Brabandt98703d72021-06-24 19:55:27 +02009233 * If 'charpos' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009234 * Otherwise use the column number as a byte offset.
9235 */
9236 static void
9237set_position(typval_T *argvars, typval_T *rettv, int charpos)
9238{
9239 pos_T pos;
9240 int fnum;
9241 char_u *name;
9242 colnr_T curswant = -1;
9243
9244 rettv->vval.v_number = -1;
9245
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009246 if (in_vim9script()
9247 && (check_for_string_arg(argvars, 0) == FAIL
9248 || check_for_list_arg(argvars, 1) == FAIL))
9249 return;
9250
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009251 name = tv_get_string_chk(argvars);
9252 if (name != NULL)
9253 {
9254 if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) == OK)
9255 {
9256 if (pos.col != MAXCOL && --pos.col < 0)
9257 pos.col = 0;
9258 if ((name[0] == '.' && name[1] == NUL))
9259 {
9260 // set cursor; "fnum" is ignored
9261 curwin->w_cursor = pos;
9262 if (curswant >= 0)
9263 {
9264 curwin->w_curswant = curswant - 1;
9265 curwin->w_set_curswant = FALSE;
9266 }
9267 check_cursor();
9268 rettv->vval.v_number = 0;
9269 }
9270 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
9271 {
9272 // set mark
9273 if (setmark_pos(name[1], &pos, fnum) == OK)
9274 rettv->vval.v_number = 0;
9275 }
9276 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009277 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009278 }
9279 }
9280}
9281/*
9282 * "setcharpos()" function
9283 */
9284 static void
9285f_setcharpos(typval_T *argvars, typval_T *rettv)
9286{
9287 set_position(argvars, rettv, TRUE);
9288}
9289
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009290 static void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009291f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
9292{
9293 dict_T *d;
9294 dictitem_T *di;
9295 char_u *csearch;
9296
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01009297 if (check_for_dict_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009298 return;
9299
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009300 if ((d = argvars[0].vval.v_dict) != NULL)
9301 {
Bram Moolenaard61efa52022-07-23 09:52:04 +01009302 csearch = dict_get_string(d, "char", FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009303 if (csearch != NULL)
9304 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009305 if (enc_utf8)
9306 {
9307 int pcc[MAX_MCO];
9308 int c = utfc_ptr2char(csearch, pcc);
9309
9310 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
9311 }
9312 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009313 set_last_csearch(PTR2CHAR(csearch),
Bram Moolenaar1614a142019-10-06 22:00:13 +02009314 csearch, mb_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009315 }
9316
9317 di = dict_find(d, (char_u *)"forward", -1);
9318 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009319 set_csearch_direction((int)tv_get_number(&di->di_tv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009320 ? FORWARD : BACKWARD);
9321
9322 di = dict_find(d, (char_u *)"until", -1);
9323 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009324 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009325 }
9326}
9327
9328/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009329 * "setcursorcharpos" function
9330 */
9331 static void
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01009332f_setcursorcharpos(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009333{
9334 set_cursorpos(argvars, rettv, TRUE);
9335}
9336
9337/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009338 * "setenv()" function
9339 */
9340 static void
9341f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
9342{
9343 char_u namebuf[NUMBUFLEN];
9344 char_u valbuf[NUMBUFLEN];
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009345 char_u *name;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009346
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009347 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9348 return;
9349
9350 name = tv_get_string_buf(&argvars[0], namebuf);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009351 if (argvars[1].v_type == VAR_SPECIAL
9352 && argvars[1].vval.v_number == VVAL_NULL)
LemonBoy77142312022-04-15 20:50:46 +01009353 vim_unsetenv_ext(name);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009354 else
LemonBoy77142312022-04-15 20:50:46 +01009355 vim_setenv_ext(name, tv_get_string_buf(&argvars[1], valbuf));
Bram Moolenaar691ddee2019-05-09 14:52:41 +02009356}
9357
9358/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009359 * "setfperm({fname}, {mode})" function
9360 */
9361 static void
9362f_setfperm(typval_T *argvars, typval_T *rettv)
9363{
9364 char_u *fname;
9365 char_u modebuf[NUMBUFLEN];
9366 char_u *mode_str;
9367 int i;
9368 int mask;
9369 int mode = 0;
9370
9371 rettv->vval.v_number = 0;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009372
9373 if (in_vim9script()
9374 && (check_for_string_arg(argvars, 0) == FAIL
9375 || check_for_string_arg(argvars, 1) == FAIL))
9376 return;
9377
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009378 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009379 if (fname == NULL)
9380 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009381 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009382 if (mode_str == NULL)
9383 return;
9384 if (STRLEN(mode_str) != 9)
9385 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009386 semsg(_(e_invalid_argument_str), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009387 return;
9388 }
9389
9390 mask = 1;
9391 for (i = 8; i >= 0; --i)
9392 {
9393 if (mode_str[i] != '-')
9394 mode |= mask;
9395 mask = mask << 1;
9396 }
9397 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
9398}
9399
9400/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009401 * "setpos()" function
9402 */
9403 static void
9404f_setpos(typval_T *argvars, typval_T *rettv)
9405{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009406 set_position(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009407}
9408
9409/*
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009410 * Translate a register type string to the yank type and block length
9411 */
9412 static int
9413get_yank_type(char_u **pp, char_u *yank_type, long *block_len)
9414{
9415 char_u *stropt = *pp;
9416 switch (*stropt)
9417 {
9418 case 'v': case 'c': // character-wise selection
9419 *yank_type = MCHAR;
9420 break;
9421 case 'V': case 'l': // line-wise selection
9422 *yank_type = MLINE;
9423 break;
9424 case 'b': case Ctrl_V: // block-wise selection
9425 *yank_type = MBLOCK;
9426 if (VIM_ISDIGIT(stropt[1]))
9427 {
9428 ++stropt;
9429 *block_len = getdigits(&stropt) - 1;
9430 --stropt;
9431 }
9432 break;
9433 default:
9434 return FAIL;
9435 }
9436 *pp = stropt;
9437 return OK;
9438}
9439
9440/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009441 * "setreg()" function
9442 */
9443 static void
9444f_setreg(typval_T *argvars, typval_T *rettv)
9445{
9446 int regname;
9447 char_u *strregname;
9448 char_u *stropt;
9449 char_u *strval;
9450 int append;
9451 char_u yank_type;
9452 long block_len;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009453 typval_T *regcontents;
9454 int pointreg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009455
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02009456 if (in_vim9script()
9457 && (check_for_string_arg(argvars, 0) == FAIL
9458 || check_for_opt_string_arg(argvars, 2) == FAIL))
9459 return;
9460
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009461 pointreg = 0;
9462 regcontents = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009463 block_len = -1;
9464 yank_type = MAUTO;
9465 append = FALSE;
9466
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009467 strregname = tv_get_string_chk(argvars);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009468 rettv->vval.v_number = 1; // FAIL is default
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009469
9470 if (strregname == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009471 return; // type error; errmsg already given
Bram Moolenaar418a29f2021-02-10 22:23:41 +01009472 if (in_vim9script() && STRLEN(strregname) > 1)
9473 {
9474 semsg(_(e_register_name_must_be_one_char_str), strregname);
9475 return;
9476 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009477 regname = *strregname;
9478 if (regname == 0 || regname == '@')
9479 regname = '"';
9480
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009481 if (argvars[1].v_type == VAR_DICT)
9482 {
9483 dict_T *d = argvars[1].vval.v_dict;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009484 dictitem_T *di;
9485
9486 if (d == NULL || d->dv_hashtab.ht_used == 0)
9487 {
9488 // Empty dict, clear the register (like setreg(0, []))
9489 char_u *lstval[2] = {NULL, NULL};
9490 write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1);
9491 return;
9492 }
9493
9494 di = dict_find(d, (char_u *)"regcontents", -1);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009495 if (di != NULL)
9496 regcontents = &di->di_tv;
9497
Bram Moolenaard61efa52022-07-23 09:52:04 +01009498 stropt = dict_get_string(d, "regtype", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009499 if (stropt != NULL)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009500 {
9501 int ret = get_yank_type(&stropt, &yank_type, &block_len);
9502
9503 if (ret == FAIL || *++stropt != NUL)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009504 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009505 semsg(_(e_invalid_value_for_argument_str), "value");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009506 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009507 }
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009508 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009509
9510 if (regname == '"')
9511 {
Bram Moolenaard61efa52022-07-23 09:52:04 +01009512 stropt = dict_get_string(d, "points_to", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009513 if (stropt != NULL)
9514 {
9515 pointreg = *stropt;
9516 regname = pointreg;
9517 }
9518 }
Bram Moolenaard61efa52022-07-23 09:52:04 +01009519 else if (dict_get_bool(d, "isunnamed", -1) > 0)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009520 pointreg = regname;
9521 }
9522 else
9523 regcontents = &argvars[1];
9524
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009525 if (argvars[2].v_type != VAR_UNKNOWN)
9526 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009527 if (yank_type != MAUTO)
9528 {
Bram Moolenaare1242042021-12-16 20:56:57 +00009529 semsg(_(e_too_many_arguments_for_function_str), "setreg");
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009530 return;
9531 }
9532
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009533 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009534 if (stropt == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009535 return; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009536 for (; *stropt != NUL; ++stropt)
9537 switch (*stropt)
9538 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009539 case 'a': case 'A': // append
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009540 append = TRUE;
9541 break;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009542 default:
9543 get_yank_type(&stropt, &yank_type, &block_len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009544 }
9545 }
9546
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009547 if (regcontents && regcontents->v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009548 {
9549 char_u **lstval;
9550 char_u **allocval;
9551 char_u buf[NUMBUFLEN];
9552 char_u **curval;
9553 char_u **curallocval;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009554 list_T *ll = regcontents->vval.v_list;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009555 listitem_T *li;
9556 int len;
9557
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009558 // If the list is NULL handle like an empty list.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009559 len = ll == NULL ? 0 : ll->lv_len;
9560
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009561 // First half: use for pointers to result lines; second half: use for
9562 // pointers to allocated copies.
Bram Moolenaarc799fe22019-05-28 23:08:19 +02009563 lstval = ALLOC_MULT(char_u *, (len + 1) * 2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009564 if (lstval == NULL)
9565 return;
9566 curval = lstval;
9567 allocval = lstval + len + 2;
9568 curallocval = allocval;
9569
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009570 if (ll != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009571 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009572 CHECK_LIST_MATERIALIZE(ll);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02009573 FOR_ALL_LIST_ITEMS(ll, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009574 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009575 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009576 if (strval == NULL)
9577 goto free_lstval;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01009578 if (strval == buf)
9579 {
9580 // Need to make a copy, next tv_get_string_buf_chk() will
9581 // overwrite the string.
9582 strval = vim_strsave(buf);
9583 if (strval == NULL)
9584 goto free_lstval;
9585 *curallocval++ = strval;
9586 }
9587 *curval++ = strval;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009588 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009589 }
9590 *curval++ = NULL;
9591
9592 write_reg_contents_lst(regname, lstval, -1,
9593 append, yank_type, block_len);
9594free_lstval:
9595 while (curallocval > allocval)
9596 vim_free(*--curallocval);
9597 vim_free(lstval);
9598 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009599 else if (regcontents)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009600 {
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009601 strval = tv_get_string_chk(regcontents);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009602 if (strval == NULL)
9603 return;
9604 write_reg_contents_ex(regname, strval, -1,
9605 append, yank_type, block_len);
9606 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009607 if (pointreg != 0)
9608 get_yank_register(pointreg, TRUE);
9609
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009610 rettv->vval.v_number = 0;
9611}
9612
9613/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009614 * "settagstack()" function
9615 */
9616 static void
9617f_settagstack(typval_T *argvars, typval_T *rettv)
9618{
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009619 win_T *wp;
9620 dict_T *d;
9621 int action = 'r';
9622
9623 rettv->vval.v_number = -1;
9624
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009625 if (in_vim9script()
9626 && (check_for_number_arg(argvars, 0) == FAIL
9627 || check_for_dict_arg(argvars, 1) == FAIL
9628 || check_for_opt_string_arg(argvars, 2) == FAIL))
9629 return;
9630
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009631 // first argument: window number or id
9632 wp = find_win_by_nr_or_id(&argvars[0]);
9633 if (wp == NULL)
9634 return;
9635
9636 // second argument: dict with items to set in the tag stack
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01009637 if (check_for_dict_arg(argvars, 1) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009638 return;
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009639 d = argvars[1].vval.v_dict;
9640 if (d == NULL)
9641 return;
9642
9643 // third argument: action - 'a' for append and 'r' for replace.
9644 // default is to replace the stack.
9645 if (argvars[2].v_type == VAR_UNKNOWN)
9646 action = 'r';
9647 else if (argvars[2].v_type == VAR_STRING)
9648 {
9649 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009650 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009651 if (actstr == NULL)
9652 return;
Bram Moolenaar271fa082020-01-02 14:02:16 +01009653 if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't')
9654 && actstr[1] == NUL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009655 action = *actstr;
9656 else
9657 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00009658 semsg(_(e_invalid_action_str_2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009659 return;
9660 }
9661 }
9662 else
9663 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009664 emsg(_(e_string_required));
Bram Moolenaarf49cc602018-11-11 15:21:05 +01009665 return;
9666 }
9667
9668 if (set_tagstack(wp, d, action) == OK)
9669 rettv->vval.v_number = 0;
9670}
9671
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009672#ifdef FEAT_CRYPT
9673/*
9674 * "sha256({string})" function
9675 */
9676 static void
9677f_sha256(typval_T *argvars, typval_T *rettv)
9678{
9679 char_u *p;
9680
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009681 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9682 return;
9683
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009684 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009685 rettv->vval.v_string = vim_strsave(
9686 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
9687 rettv->v_type = VAR_STRING;
9688}
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009689#endif // FEAT_CRYPT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009690
9691/*
9692 * "shellescape({string})" function
9693 */
9694 static void
9695f_shellescape(typval_T *argvars, typval_T *rettv)
9696{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009697 int do_special;
Bram Moolenaar20615522017-06-05 18:46:26 +02009698
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009699 if (in_vim9script()
9700 && (check_for_string_arg(argvars, 0) == FAIL
9701 || check_for_opt_bool_arg(argvars, 1) == FAIL))
9702 return;
9703
9704 do_special = non_zero_arg(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009705 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009706 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009707 rettv->v_type = VAR_STRING;
9708}
9709
9710/*
9711 * shiftwidth() function
9712 */
9713 static void
9714f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
9715{
Bram Moolenaarf9514162018-11-22 03:08:29 +01009716 rettv->vval.v_number = 0;
9717
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009718 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
9719 return;
9720
Bram Moolenaarf9514162018-11-22 03:08:29 +01009721 if (argvars[0].v_type != VAR_UNKNOWN)
9722 {
9723 long col;
9724
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009725 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +01009726 if (col < 0)
9727 return; // type error; errmsg already given
9728#ifdef FEAT_VARTABS
9729 rettv->vval.v_number = get_sw_value_col(curbuf, col);
9730 return;
9731#endif
9732 }
9733
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009734 rettv->vval.v_number = get_sw_value(curbuf);
9735}
9736
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009737/*
9738 * "soundfold({word})" function
9739 */
9740 static void
9741f_soundfold(typval_T *argvars, typval_T *rettv)
9742{
9743 char_u *s;
9744
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009745 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9746 return;
9747
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009748 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009749 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009750#ifdef FEAT_SPELL
9751 rettv->vval.v_string = eval_soundfold(s);
9752#else
9753 rettv->vval.v_string = vim_strsave(s);
9754#endif
9755}
9756
9757/*
9758 * "spellbadword()" function
9759 */
9760 static void
9761f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
9762{
9763 char_u *word = (char_u *)"";
9764 hlf_T attr = HLF_COUNT;
9765 int len = 0;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009766#ifdef FEAT_SPELL
9767 int wo_spell_save = curwin->w_p_spell;
9768
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009769 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
9770 return;
9771
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009772 if (!curwin->w_p_spell)
9773 {
9774 did_set_spelllang(curwin);
9775 curwin->w_p_spell = TRUE;
9776 }
9777
9778 if (*curwin->w_s->b_p_spl == NUL)
9779 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009780 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009781 curwin->w_p_spell = wo_spell_save;
9782 return;
9783 }
9784#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009785
9786 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009787 {
9788#ifdef FEAT_SPELL
9789 curwin->w_p_spell = wo_spell_save;
9790#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009791 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009792 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009793
9794#ifdef FEAT_SPELL
9795 if (argvars[0].v_type == VAR_UNKNOWN)
9796 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009797 // Find the start and length of the badly spelled word.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009798 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
9799 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009800 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009801 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +01009802 curwin->w_set_curswant = TRUE;
9803 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009804 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009805 else if (*curbuf->b_s.b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009806 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009807 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009808 int capcol = -1;
9809
9810 if (str != NULL)
9811 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009812 // Check the argument for spelling.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009813 while (*str != NUL)
9814 {
9815 len = spell_check(curwin, str, &attr, &capcol, FALSE);
9816 if (attr != HLF_COUNT)
9817 {
9818 word = str;
9819 break;
9820 }
9821 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +02009822 capcol -= len;
Bram Moolenaar0c779e82019-08-09 17:01:02 +02009823 len = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009824 }
9825 }
9826 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009827 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009828#endif
9829
9830 list_append_string(rettv->vval.v_list, word, len);
9831 list_append_string(rettv->vval.v_list, (char_u *)(
9832 attr == HLF_SPB ? "bad" :
9833 attr == HLF_SPR ? "rare" :
9834 attr == HLF_SPL ? "local" :
9835 attr == HLF_SPC ? "caps" :
9836 ""), -1);
9837}
9838
9839/*
9840 * "spellsuggest()" function
9841 */
9842 static void
9843f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
9844{
9845#ifdef FEAT_SPELL
9846 char_u *str;
9847 int typeerr = FALSE;
9848 int maxcount;
9849 garray_T ga;
9850 int i;
9851 listitem_T *li;
9852 int need_capital = FALSE;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009853 int wo_spell_save = curwin->w_p_spell;
9854
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009855 if (in_vim9script()
9856 && (check_for_string_arg(argvars, 0) == FAIL
9857 || check_for_opt_number_arg(argvars, 1) == FAIL
9858 || (argvars[1].v_type != VAR_UNKNOWN
9859 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9860 return;
9861
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009862 if (!curwin->w_p_spell)
9863 {
9864 did_set_spelllang(curwin);
9865 curwin->w_p_spell = TRUE;
9866 }
9867
9868 if (*curwin->w_s->b_p_spl == NUL)
9869 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00009870 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009871 curwin->w_p_spell = wo_spell_save;
9872 return;
9873 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009874#endif
9875
9876 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009877 {
9878#ifdef FEAT_SPELL
9879 curwin->w_p_spell = wo_spell_save;
9880#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009881 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009882 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009883
9884#ifdef FEAT_SPELL
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +01009885 str = tv_get_string(&argvars[0]);
9886 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009887 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +01009888 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
9889 if (maxcount <= 0)
9890 return;
9891 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009892 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +01009893 need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr);
9894 if (typeerr)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009895 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009896 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009897 }
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +01009898 else
9899 maxcount = 25;
9900
9901 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
9902
9903 for (i = 0; i < ga.ga_len; ++i)
9904 {
9905 str = ((char_u **)ga.ga_data)[i];
9906
9907 li = listitem_alloc();
9908 if (li == NULL)
9909 vim_free(str);
9910 else
9911 {
9912 li->li_tv.v_type = VAR_STRING;
9913 li->li_tv.v_lock = 0;
9914 li->li_tv.vval.v_string = str;
9915 list_append(rettv->vval.v_list, li);
9916 }
9917 }
9918 ga_clear(&ga);
Bram Moolenaar152e79e2020-06-10 15:32:08 +02009919 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009920#endif
9921}
9922
9923 static void
9924f_split(typval_T *argvars, typval_T *rettv)
9925{
9926 char_u *str;
9927 char_u *end;
9928 char_u *pat = NULL;
9929 regmatch_T regmatch;
9930 char_u patbuf[NUMBUFLEN];
9931 char_u *save_cpo;
9932 int match;
9933 colnr_T col = 0;
9934 int keepempty = FALSE;
9935 int typeerr = FALSE;
9936
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009937 if (in_vim9script()
9938 && (check_for_string_arg(argvars, 0) == FAIL
9939 || check_for_opt_string_arg(argvars, 1) == FAIL
9940 || (argvars[1].v_type != VAR_UNKNOWN
9941 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9942 return;
9943
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009944 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009945 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01009946 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009947
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009948 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009949 if (argvars[1].v_type != VAR_UNKNOWN)
9950 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009951 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009952 if (pat == NULL)
9953 typeerr = TRUE;
9954 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar3986b942020-09-06 16:09:04 +02009955 keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009956 }
9957 if (pat == NULL || *pat == NUL)
9958 pat = (char_u *)"[\\x01- ]\\+";
9959
9960 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02009961 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009962 if (typeerr)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02009963 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009964
9965 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
9966 if (regmatch.regprog != NULL)
9967 {
9968 regmatch.rm_ic = FALSE;
9969 while (*str != NUL || keepempty)
9970 {
9971 if (*str == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009972 match = FALSE; // empty item at the end
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009973 else
9974 match = vim_regexec_nl(&regmatch, str, col);
9975 if (match)
9976 end = regmatch.startp[0];
9977 else
9978 end = str + STRLEN(str);
9979 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
9980 && *str != NUL && match && end < regmatch.endp[0]))
9981 {
9982 if (list_append_string(rettv->vval.v_list, str,
9983 (int)(end - str)) == FAIL)
9984 break;
9985 }
9986 if (!match)
9987 break;
Bram Moolenaar13505972019-01-24 15:04:48 +01009988 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009989 if (regmatch.endp[0] > str)
9990 col = 0;
9991 else
Bram Moolenaar13505972019-01-24 15:04:48 +01009992 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009993 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009994 str = regmatch.endp[0];
9995 }
9996
9997 vim_regfree(regmatch.regprog);
9998 }
9999
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010000theend:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010001 p_cpo = save_cpo;
10002}
10003
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010004/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010005 * "submatch()" function
10006 */
10007 static void
10008f_submatch(typval_T *argvars, typval_T *rettv)
10009{
10010 int error = FALSE;
10011 int no;
10012 int retList = 0;
10013
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010014 if (in_vim9script()
10015 && (check_for_number_arg(argvars, 0) == FAIL
10016 || check_for_opt_bool_arg(argvars, 1) == FAIL))
10017 return;
10018
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010019 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010020 if (error)
10021 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020010022 if (no < 0 || no >= NSUBEXP)
10023 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +000010024 semsg(_(e_invalid_submatch_number_nr), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +010010025 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020010026 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010027 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaarad304702020-09-06 18:22:53 +020010028 retList = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010029 if (error)
10030 return;
10031
10032 if (retList == 0)
10033 {
10034 rettv->v_type = VAR_STRING;
10035 rettv->vval.v_string = reg_submatch(no);
10036 }
10037 else
10038 {
10039 rettv->v_type = VAR_LIST;
10040 rettv->vval.v_list = reg_submatch_list(no);
10041 }
10042}
10043
10044/*
10045 * "substitute()" function
10046 */
10047 static void
10048f_substitute(typval_T *argvars, typval_T *rettv)
10049{
10050 char_u patbuf[NUMBUFLEN];
10051 char_u subbuf[NUMBUFLEN];
10052 char_u flagsbuf[NUMBUFLEN];
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020010053 char_u *str;
10054 char_u *pat;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010055 char_u *sub = NULL;
10056 typval_T *expr = NULL;
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020010057 char_u *flg;
10058
10059 if (in_vim9script()
10060 && (check_for_string_arg(argvars, 0) == FAIL
10061 || check_for_string_arg(argvars, 1) == FAIL
10062 || check_for_string_arg(argvars, 3) == FAIL))
10063 return;
10064
10065 str = tv_get_string_chk(&argvars[0]);
10066 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
10067 flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010068
LemonBoyf3b48952022-05-05 13:53:03 +010010069 if (argvars[2].v_type == VAR_FUNC
10070 || argvars[2].v_type == VAR_PARTIAL
10071 || argvars[2].v_type == VAR_INSTR)
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010072 expr = &argvars[2];
10073 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010074 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010075
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010076 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010077 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
10078 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010079 rettv->vval.v_string = NULL;
10080 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010081 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010082}
10083
10084/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010085 * "swapinfo(swap_filename)" function
10086 */
10087 static void
10088f_swapinfo(typval_T *argvars, typval_T *rettv)
10089{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010090 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
10091 return;
10092
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010093 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010094 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +020010095}
10096
10097/*
Bram Moolenaar110bd602018-09-16 18:46:59 +020010098 * "swapname(expr)" function
10099 */
10100 static void
10101f_swapname(typval_T *argvars, typval_T *rettv)
10102{
10103 buf_T *buf;
10104
10105 rettv->v_type = VAR_STRING;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010106
10107 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
10108 return;
10109
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010010110 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +020010111 if (buf == NULL || buf->b_ml.ml_mfp == NULL
10112 || buf->b_ml.ml_mfp->mf_fname == NULL)
10113 rettv->vval.v_string = NULL;
10114 else
10115 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
10116}
10117
10118/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010119 * "synID(lnum, col, trans)" function
10120 */
10121 static void
10122f_synID(typval_T *argvars UNUSED, typval_T *rettv)
10123{
10124 int id = 0;
10125#ifdef FEAT_SYN_HL
10126 linenr_T lnum;
10127 colnr_T col;
10128 int trans;
10129 int transerr = FALSE;
10130
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010131 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010132 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010133 || check_for_number_arg(argvars, 1) == FAIL
10134 || check_for_bool_arg(argvars, 2) == FAIL))
10135 return;
10136
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010137 lnum = tv_get_lnum(argvars); // -1 on type error
10138 col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaarfcb6d702020-09-05 21:41:56 +020010139 trans = (int)tv_get_bool_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010140
10141 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10142 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000010143 id = syn_get_id(curwin, lnum, col, trans, NULL, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010144#endif
10145
10146 rettv->vval.v_number = id;
10147}
10148
10149/*
10150 * "synIDattr(id, what [, mode])" function
10151 */
10152 static void
10153f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
10154{
10155 char_u *p = NULL;
10156#ifdef FEAT_SYN_HL
10157 int id;
10158 char_u *what;
10159 char_u *mode;
10160 char_u modebuf[NUMBUFLEN];
10161 int modec;
10162
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020010163 if (in_vim9script()
10164 && (check_for_number_arg(argvars, 0) == FAIL
Yegappan Lakshmananf8dbd582021-09-26 19:04:05 +010010165 || check_for_string_arg(argvars, 1) == FAIL
10166 || check_for_opt_string_arg(argvars, 2) == FAIL))
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020010167 return;
10168
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010169 id = (int)tv_get_number(&argvars[0]);
10170 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010171 if (argvars[2].v_type != VAR_UNKNOWN)
10172 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010173 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010174 modec = TOLOWER_ASC(mode[0]);
10175 if (modec != 't' && modec != 'c' && modec != 'g')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010176 modec = 0; // replace invalid with current
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010177 }
10178 else
10179 {
10180#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
10181 if (USE_24BIT)
10182 modec = 'g';
10183 else
10184#endif
10185 if (t_colors > 1)
Dominique Pelle4781d6f2021-05-18 21:46:31 +020010186 modec = 'c';
10187 else
10188 modec = 't';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010189 }
10190
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010191 switch (TOLOWER_ASC(what[0]))
10192 {
10193 case 'b':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010194 if (TOLOWER_ASC(what[1]) == 'g') // bg[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010195 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010196 else // bold
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010197 p = highlight_has_attr(id, HL_BOLD, modec);
10198 break;
10199
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010200 case 'f': // fg[#] or font
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010201 p = highlight_color(id, what, modec);
10202 break;
10203
10204 case 'i':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010205 if (TOLOWER_ASC(what[1]) == 'n') // inverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010206 p = highlight_has_attr(id, HL_INVERSE, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010207 else // italic
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010208 p = highlight_has_attr(id, HL_ITALIC, modec);
10209 break;
10210
Bram Moolenaarde786322022-07-30 14:56:17 +010010211 case 'n':
10212 if (TOLOWER_ASC(what[1]) == 'o') // nocombine
10213 p = highlight_has_attr(id, HL_NOCOMBINE, modec);
10214 else // name
10215 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010216 break;
10217
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010218 case 'r': // reverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010219 p = highlight_has_attr(id, HL_INVERSE, modec);
10220 break;
10221
10222 case 's':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010223 if (TOLOWER_ASC(what[1]) == 'p') // sp[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010224 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010225 // strikeout
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +020010226 else if (TOLOWER_ASC(what[1]) == 't' &&
10227 TOLOWER_ASC(what[2]) == 'r')
10228 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010229 else // standout
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010230 p = highlight_has_attr(id, HL_STANDOUT, modec);
10231 break;
10232
10233 case 'u':
Bram Moolenaar84f54632022-06-29 18:39:11 +010010234 if (STRLEN(what) >= 9)
10235 {
10236 if (TOLOWER_ASC(what[5]) == 'l')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010237 // underline
Bram Moolenaar84f54632022-06-29 18:39:11 +010010238 p = highlight_has_attr(id, HL_UNDERLINE, modec);
10239 else if (TOLOWER_ASC(what[5]) != 'd')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010240 // undercurl
Bram Moolenaar84f54632022-06-29 18:39:11 +010010241 p = highlight_has_attr(id, HL_UNDERCURL, modec);
10242 else if (TOLOWER_ASC(what[6]) != 'o')
10243 // underdashed
10244 p = highlight_has_attr(id, HL_UNDERDASHED, modec);
10245 else if (TOLOWER_ASC(what[7]) == 'u')
10246 // underdouble
10247 p = highlight_has_attr(id, HL_UNDERDOUBLE, modec);
10248 else
10249 // underdotted
10250 p = highlight_has_attr(id, HL_UNDERDOTTED, modec);
10251 }
10252 else
10253 // ul
10254 p = highlight_color(id, what, modec);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010255 break;
10256 }
10257
10258 if (p != NULL)
10259 p = vim_strsave(p);
10260#endif
10261 rettv->v_type = VAR_STRING;
10262 rettv->vval.v_string = p;
10263}
10264
10265/*
10266 * "synIDtrans(id)" function
10267 */
10268 static void
10269f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
10270{
10271 int id;
10272
10273#ifdef FEAT_SYN_HL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010274 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
10275 return;
10276
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010277 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010278
10279 if (id > 0)
10280 id = syn_get_final_id(id);
10281 else
10282#endif
10283 id = 0;
10284
10285 rettv->vval.v_number = id;
10286}
10287
10288/*
10289 * "synconcealed(lnum, col)" function
10290 */
10291 static void
10292f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
10293{
10294#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
10295 linenr_T lnum;
10296 colnr_T col;
10297 int syntax_flags = 0;
10298 int cchar;
10299 int matchid = 0;
10300 char_u str[NUMBUFLEN];
10301#endif
10302
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010303 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010304
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010305 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010306 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010307 || check_for_number_arg(argvars, 1) == FAIL))
10308 return;
10309
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010310#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010311 lnum = tv_get_lnum(argvars); // -1 on type error
10312 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010313
Bram Moolenaara80faa82020-04-12 19:37:17 +020010314 CLEAR_FIELD(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010315
Bram Moolenaar93a10962022-06-16 11:42:09 +010010316 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010317 {
10318 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10319 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
10320 && curwin->w_p_cole > 0)
10321 {
10322 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
10323 syntax_flags = get_syntax_info(&matchid);
10324
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010325 // get the conceal character
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010326 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
10327 {
10328 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +020010329 if (cchar == NUL && curwin->w_p_cole == 1)
Bram Moolenaareed9d462021-02-15 20:38:25 +010010330 cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' '
10331 : curwin->w_lcs_chars.conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010332 if (cchar != NUL)
10333 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010334 if (has_mbyte)
10335 (*mb_char2bytes)(cchar, str);
10336 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010337 str[0] = cchar;
10338 }
10339 }
10340 }
10341
10342 list_append_number(rettv->vval.v_list,
10343 (syntax_flags & HL_CONCEAL) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010344 // -1 to auto-determine strlen
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010345 list_append_string(rettv->vval.v_list, str, -1);
10346 list_append_number(rettv->vval.v_list, matchid);
10347 }
10348#endif
10349}
10350
10351/*
10352 * "synstack(lnum, col)" function
10353 */
10354 static void
10355f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
10356{
10357#ifdef FEAT_SYN_HL
10358 linenr_T lnum;
10359 colnr_T col;
10360 int i;
10361 int id;
10362#endif
10363
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010364 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010365
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010366 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020010367 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020010368 || check_for_number_arg(argvars, 1) == FAIL))
10369 return;
10370
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010371#ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010372 lnum = tv_get_lnum(argvars); // -1 on type error
10373 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010374
10375 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
10376 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
Bram Moolenaar93a10962022-06-16 11:42:09 +010010377 && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010378 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000010379 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010380 for (i = 0; ; ++i)
10381 {
10382 id = syn_get_stack_item(i);
10383 if (id < 0)
10384 break;
10385 if (list_append_number(rettv->vval.v_list, id) == FAIL)
10386 break;
10387 }
10388 }
10389#endif
10390}
10391
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010392/*
10393 * "tabpagebuflist()" function
10394 */
10395 static void
10396f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10397{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010398 tabpage_T *tp;
10399 win_T *wp = NULL;
10400
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010401 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
10402 return;
10403
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010404 if (argvars[0].v_type == VAR_UNKNOWN)
10405 wp = firstwin;
10406 else
10407 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010408 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010409 if (tp != NULL)
10410 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
10411 }
Bram Moolenaar93a10962022-06-16 11:42:09 +010010412 if (wp != NULL && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010413 {
10414 for (; wp != NULL; wp = wp->w_next)
10415 if (list_append_number(rettv->vval.v_list,
10416 wp->w_buffer->b_fnum) == FAIL)
10417 break;
10418 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010419}
10420
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010421/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010422 * "tagfiles()" function
10423 */
10424 static void
10425f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
10426{
10427 char_u *fname;
10428 tagname_T tn;
10429 int first;
10430
10431 if (rettv_list_alloc(rettv) == FAIL)
10432 return;
10433 fname = alloc(MAXPATHL);
10434 if (fname == NULL)
10435 return;
10436
10437 for (first = TRUE; ; first = FALSE)
10438 if (get_tagfname(&tn, first, fname) == FAIL
10439 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
10440 break;
10441 tagname_free(&tn);
10442 vim_free(fname);
10443}
10444
10445/*
10446 * "taglist()" function
10447 */
10448 static void
10449f_taglist(typval_T *argvars, typval_T *rettv)
10450{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010451 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010452 char_u *tag_pattern;
10453
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010454 if (in_vim9script()
10455 && (check_for_string_arg(argvars, 0) == FAIL
10456 || check_for_opt_string_arg(argvars, 1) == FAIL))
10457 return;
10458
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010459 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010460
10461 rettv->vval.v_number = FALSE;
10462 if (*tag_pattern == NUL)
10463 return;
10464
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010465 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010466 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010467 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010010468 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010469}
10470
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010471/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010472 * "type(expr)" function
10473 */
10474 static void
10475f_type(typval_T *argvars, typval_T *rettv)
10476{
10477 int n = -1;
10478
10479 switch (argvars[0].v_type)
10480 {
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010481 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
10482 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010483 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010010484 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
10485 case VAR_LIST: n = VAR_TYPE_LIST; break;
10486 case VAR_DICT: n = VAR_TYPE_DICT; break;
10487 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
10488 case VAR_BOOL: n = VAR_TYPE_BOOL; break;
10489 case VAR_SPECIAL: n = VAR_TYPE_NONE; break;
Bram Moolenaarf562e722016-07-19 17:25:25 +020010490 case VAR_JOB: n = VAR_TYPE_JOB; break;
10491 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010010492 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaarf18332f2021-05-07 17:55:55 +020010493 case VAR_INSTR: n = VAR_TYPE_INSTR; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010494 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +020010495 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010496 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +010010497 internal_error_no_abort("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010498 n = -1;
10499 break;
10500 }
10501 rettv->vval.v_number = n;
10502}
10503
10504/*
LemonBoy0f7a3e12022-05-26 12:10:37 +010010505 * "virtcol(string, bool)" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010506 */
10507 static void
10508f_virtcol(typval_T *argvars, typval_T *rettv)
10509{
LemonBoy0f7a3e12022-05-26 12:10:37 +010010510 colnr_T vcol_start = 0;
10511 colnr_T vcol_end = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010512 pos_T *fp;
10513 int fnum = curbuf->b_fnum;
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010514 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010515
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010516 if (in_vim9script()
LemonBoy0f7a3e12022-05-26 12:10:37 +010010517 && (check_for_string_or_list_arg(argvars, 0) == FAIL
10518 || (argvars[1].v_type != VAR_UNKNOWN
10519 && check_for_bool_arg(argvars, 1) == FAIL)))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010520 return;
10521
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010522 fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010523 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
LemonBoy0f7a3e12022-05-26 12:10:37 +010010524 && fnum == curbuf->b_fnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010525 {
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010010526 // Limit the column to a valid value, getvvcol() doesn't check.
10527 if (fp->col < 0)
10528 fp->col = 0;
10529 else
10530 {
10531 len = (int)STRLEN(ml_get(fp->lnum));
10532 if (fp->col > len)
10533 fp->col = len;
10534 }
LemonBoy0f7a3e12022-05-26 12:10:37 +010010535 getvvcol(curwin, fp, &vcol_start, NULL, &vcol_end);
10536 ++vcol_start;
10537 ++vcol_end;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010538 }
10539
LemonBoy0f7a3e12022-05-26 12:10:37 +010010540 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
10541 {
10542 if (rettv_list_alloc(rettv) == OK)
10543 {
10544 list_append_number(rettv->vval.v_list, vcol_start);
10545 list_append_number(rettv->vval.v_list, vcol_end);
10546 }
10547 else
10548 rettv->vval.v_number = 0;
10549 }
10550 else
10551 rettv->vval.v_number = vcol_end;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010552}
10553
10554/*
10555 * "visualmode()" function
10556 */
10557 static void
10558f_visualmode(typval_T *argvars, typval_T *rettv)
10559{
10560 char_u str[2];
10561
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010562 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
10563 return;
10564
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010565 rettv->v_type = VAR_STRING;
10566 str[0] = curbuf->b_visual_mode_eval;
10567 str[1] = NUL;
10568 rettv->vval.v_string = vim_strsave(str);
10569
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010570 // A non-zero number or non-empty string argument: reset mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010571 if (non_zero_arg(&argvars[0]))
10572 curbuf->b_visual_mode_eval = NUL;
10573}
10574
10575/*
10576 * "wildmenumode()" function
10577 */
10578 static void
10579f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10580{
Bram Moolenaar24959102022-05-07 20:01:16 +010010581 if (wild_menu_showing || ((State & MODE_CMDLINE) && cmdline_pum_active()))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010582 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010583}
10584
10585/*
Bram Moolenaar0c1e3742019-12-27 13:49:24 +010010586 * "windowsversion()" function
10587 */
10588 static void
10589f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
10590{
10591 rettv->v_type = VAR_STRING;
10592 rettv->vval.v_string = vim_strsave((char_u *)windowsVersion);
10593}
10594
10595/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010596 * "wordcount()" function
10597 */
10598 static void
10599f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
10600{
10601 if (rettv_dict_alloc(rettv) == FAIL)
10602 return;
10603 cursor_pos_info(rettv->vval.v_dict);
10604}
10605
10606/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010607 * "xor(expr, expr)" function
10608 */
10609 static void
10610f_xor(typval_T *argvars, typval_T *rettv)
10611{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010612 if (in_vim9script()
10613 && (check_for_number_arg(argvars, 0) == FAIL
10614 || check_for_number_arg(argvars, 1) == FAIL))
10615 return;
10616
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010617 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
10618 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010619}
10620
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010621#endif // FEAT_EVAL