blob: 1b394f00a5d49e5b7eed465cd9c5b6cfab247c2c [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 Moolenaar80adaa82023-07-07 18:57:40 +010048static void f_err_teapot(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020049static void f_escape(typval_T *argvars, typval_T *rettv);
50static void f_eval(typval_T *argvars, typval_T *rettv);
51static void f_eventhandler(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020052static void f_execute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar26735992021-08-08 14:43:22 +020053static void f_exists_compiled(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020054static void f_expand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar80dad482019-06-09 17:22:31 +020055static void f_expandcmd(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020056static void f_feedkeys(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020057static void f_fnameescape(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020058static void f_foreground(typval_T *argvars, typval_T *rettv);
Bram Moolenaar437bafe2016-08-01 15:40:54 +020059static void f_funcref(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020060static void f_function(typval_T *argvars, typval_T *rettv);
61static void f_garbagecollect(typval_T *argvars, typval_T *rettv);
62static void f_get(typval_T *argvars, typval_T *rettv);
Bram Moolenaar07ad8162018-02-13 13:59:59 +010063static void f_getchangelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010064static void f_getcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020065static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +010066static void f_getcurpos(typval_T *argvars, typval_T *rettv);
67static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020068static void f_getenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020069static void f_getfontname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4f505882018-02-10 21:06:32 +010070static void f_getjumplist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020071static void f_getpid(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020072static void f_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020073static void f_getreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020074static void f_getreginfo(typval_T *argvars, typval_T *rettv);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +010075static void f_getregion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020076static void f_getregtype(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010077static void f_gettagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +020078static void f_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020079static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020080static void f_hlID(typval_T *argvars, typval_T *rettv);
81static void f_hlexists(typval_T *argvars, typval_T *rettv);
82static void f_hostname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020083static void f_index(typval_T *argvars, typval_T *rettv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +010084static void f_indexof(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020085static void f_input(typval_T *argvars, typval_T *rettv);
86static void f_inputdialog(typval_T *argvars, typval_T *rettv);
87static void f_inputlist(typval_T *argvars, typval_T *rettv);
88static void f_inputrestore(typval_T *argvars, typval_T *rettv);
89static void f_inputsave(typval_T *argvars, typval_T *rettv);
90static void f_inputsecret(typval_T *argvars, typval_T *rettv);
Bram Moolenaar67a2deb2019-11-25 00:05:32 +010091static void f_interrupt(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020092static void f_invert(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020093static void f_islocked(typval_T *argvars, typval_T *rettv);
zeertzjqcdc83932022-09-12 13:38:41 +010094static void f_keytrans(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020095static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020096static void f_libcall(typval_T *argvars, typval_T *rettv);
97static void f_libcallnr(typval_T *argvars, typval_T *rettv);
98static void f_line(typval_T *argvars, typval_T *rettv);
99static void f_line2byte(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200100#ifdef FEAT_LUA
101static void f_luaeval(typval_T *argvars, typval_T *rettv);
102#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200103static void f_match(typval_T *argvars, typval_T *rettv);
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +0100104static void f_matchbufline(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200105static void f_matchend(typval_T *argvars, typval_T *rettv);
106static void f_matchlist(typval_T *argvars, typval_T *rettv);
107static void f_matchstr(typval_T *argvars, typval_T *rettv);
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +0100108static void f_matchstrlist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200109static void f_matchstrpos(typval_T *argvars, typval_T *rettv);
110static void f_max(typval_T *argvars, typval_T *rettv);
111static void f_min(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200112#ifdef FEAT_MZSCHEME
113static void f_mzeval(typval_T *argvars, typval_T *rettv);
114#endif
115static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
116static void f_nr2char(typval_T *argvars, typval_T *rettv);
117static void f_or(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200118#ifdef FEAT_PERL
119static void f_perleval(typval_T *argvars, typval_T *rettv);
120#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200121static void f_prevnonblank(typval_T *argvars, typval_T *rettv);
122static void f_printf(typval_T *argvars, typval_T *rettv);
Bram Moolenaare9bd5722019-08-17 19:36:06 +0200123static void f_pum_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200124static void f_pumvisible(typval_T *argvars, typval_T *rettv);
125#ifdef FEAT_PYTHON3
126static void f_py3eval(typval_T *argvars, typval_T *rettv);
127#endif
128#ifdef FEAT_PYTHON
129static void f_pyeval(typval_T *argvars, typval_T *rettv);
130#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100131#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
132static void f_pyxeval(typval_T *argvars, typval_T *rettv);
133#endif
Bram Moolenaar4f645c52020-02-08 16:40:39 +0100134static void f_test_srand_seed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100135static void f_rand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200136static void f_range(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200137static void f_reg_executing(typval_T *argvars, typval_T *rettv);
138static void f_reg_recording(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200139static void f_rename(typval_T *argvars, typval_T *rettv);
140static void f_repeat(typval_T *argvars, typval_T *rettv);
Bram Moolenaare99be0e2019-03-26 22:51:09 +0100141#ifdef FEAT_RUBY
142static void f_rubyeval(typval_T *argvars, typval_T *rettv);
143#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200144static void f_screenattr(typval_T *argvars, typval_T *rettv);
145static void f_screenchar(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100146static void f_screenchars(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200147static void f_screencol(typval_T *argvars, typval_T *rettv);
148static void f_screenrow(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100149static void f_screenstring(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200150static void f_search(typval_T *argvars, typval_T *rettv);
151static void f_searchdecl(typval_T *argvars, typval_T *rettv);
152static void f_searchpair(typval_T *argvars, typval_T *rettv);
153static void f_searchpairpos(typval_T *argvars, typval_T *rettv);
154static void f_searchpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100155static void f_setcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200156static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100157static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +0200158static void f_setenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200159static void f_setfperm(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200160static void f_setpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200161static void f_setreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100162static void f_settagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200163#ifdef FEAT_CRYPT
164static void f_sha256(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb005cd82019-09-04 15:54:55 +0200165#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200166static void f_shellescape(typval_T *argvars, typval_T *rettv);
167static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200168static void f_soundfold(typval_T *argvars, typval_T *rettv);
169static void f_spellbadword(typval_T *argvars, typval_T *rettv);
170static void f_spellsuggest(typval_T *argvars, typval_T *rettv);
171static void f_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100172static void f_srand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200173static void f_submatch(typval_T *argvars, typval_T *rettv);
174static void f_substitute(typval_T *argvars, typval_T *rettv);
Bram Moolenaarc216a7a2022-12-05 13:50:55 +0000175static void f_swapfilelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200176static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200177static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200178static void f_synID(typval_T *argvars, typval_T *rettv);
179static void f_synIDattr(typval_T *argvars, typval_T *rettv);
180static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
181static void f_synstack(typval_T *argvars, typval_T *rettv);
182static void f_synconcealed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200183static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200184static void f_taglist(typval_T *argvars, typval_T *rettv);
185static void f_tagfiles(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200186static void f_type(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200187static void f_virtcol(typval_T *argvars, typval_T *rettv);
188static void f_visualmode(typval_T *argvars, typval_T *rettv);
189static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0c1e3742019-12-27 13:49:24 +0100190static void f_windowsversion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200191static void f_wordcount(typval_T *argvars, typval_T *rettv);
192static void f_xor(typval_T *argvars, typval_T *rettv);
193
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100194
Bram Moolenaar94738d82020-10-21 14:25:07 +0200195/*
196 * Functions that check the argument type of a builtin function.
197 * Each function returns FAIL and gives an error message if the type is wrong.
198 */
199
200// Context passed to an arg_ function.
201typedef struct {
Bram Moolenaarca174532020-10-21 16:42:22 +0200202 int arg_count; // actual argument count
Bram Moolenaar078a4612022-01-04 15:17:03 +0000203 type2_T *arg_types; // list of argument types
Bram Moolenaarca174532020-10-21 16:42:22 +0200204 int arg_idx; // current argument index (first arg is zero)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100205 cctx_T *arg_cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +0200206} argcontext_T;
207
208// A function to check one argument type. The first argument is the type to
209// check. If needed, other argument types can be obtained with the context.
210// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.
Ernie Raela8f7f922023-12-14 20:17:04 +0100211// NOTE: Use "arg_any", not NULL, in funcentry_T.f_argcheck array
212// to accept an argument of any type.
Bram Moolenaar078a4612022-01-04 15:17:03 +0000213typedef int (*argcheck_T)(type_T *, type_T *, argcontext_T *);
Bram Moolenaar94738d82020-10-21 14:25:07 +0200214
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100215/*
Bram Moolenaar351ead02021-01-16 16:07:01 +0100216 * Call need_type() to check an argument type.
217 */
218 static int
219check_arg_type(
220 type_T *expected,
221 type_T *actual,
222 argcontext_T *context)
223{
Bram Moolenaarc6951a72022-12-29 20:56:24 +0000224 return need_type(actual, expected, FALSE,
Bram Moolenaar351ead02021-01-16 16:07:01 +0100225 context->arg_idx - context->arg_count, context->arg_idx + 1,
226 context->arg_cctx, FALSE, FALSE);
227}
228
229/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100230 * Call need_type() to check an argument type and that it is modifiable
231 */
232 static int
233check_arg_type_mod(
234 type_T *expected,
235 type_T *actual,
236 argcontext_T *context)
237{
Bram Moolenaarc6951a72022-12-29 20:56:24 +0000238 if (need_type(actual, expected, FALSE,
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100239 context->arg_idx - context->arg_count, context->arg_idx + 1,
240 context->arg_cctx, FALSE, FALSE) == FAIL)
241 return FAIL;
242 return arg_type_modifiable(actual, context->arg_idx + 1);
243}
244
245/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100246 * Give an error if "type" is a constant.
247 */
248 int
249arg_type_modifiable(type_T *type, int arg_idx)
250{
251 char *tofree;
252
253 if ((type->tt_flags & TTFLAG_CONST) == 0)
254 return OK;
255 semsg(_(e_argument_nr_trying_to_modify_const_str),
256 arg_idx, type_name(type, &tofree));
257 vim_free(tofree);
258 return FAIL;
259}
260
261/*
Ernie Raela8f7f922023-12-14 20:17:04 +0100262 * Return OK for any type unconditionally.
263 */
264 static int
265arg_any(type_T *type UNUSED,
266 type_T *decl_type UNUSED,
267 argcontext_T *context UNUSED)
268{
269 return OK;
270}
271
272/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100273 * Check "type" is a float or a number.
274 */
Bram Moolenaar94738d82020-10-21 14:25:07 +0200275 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000276arg_float_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200277{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100278 if (type->tt_type == VAR_FLOAT
279 || type->tt_type == VAR_NUMBER
280 || type_any_or_unknown(type))
Bram Moolenaar94738d82020-10-21 14:25:07 +0200281 return OK;
282 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
283 return FAIL;
284}
285
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100286/*
287 * Check "type" is a number.
288 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200289 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000290arg_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200291{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100292 return check_arg_type(&t_number, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200293}
294
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100295/*
LemonBoyafe04662023-08-23 21:08:11 +0200296 * Check "type" is an object.
297 */
298 static int
299arg_object(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
300{
Yegappan Lakshmananb49ad282023-08-27 19:08:40 +0200301 if (type->tt_type == VAR_OBJECT
302 || type_any_or_unknown(type))
303 return OK;
304 arg_type_mismatch(&t_object, type, context->arg_idx + 1);
305 return FAIL;
LemonBoyafe04662023-08-23 21:08:11 +0200306}
307
308/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200309 * Check "type" is a dict of 'any'.
310 */
311 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000312arg_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200313{
314 return check_arg_type(&t_dict_any, type, context);
315}
316
317/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200318 * Check "type" is a list of 'any'.
319 */
320 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000321arg_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200322{
323 return check_arg_type(&t_list_any, type, context);
324}
325
326/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100327 * Check "type" is a list of 'any' and modifiable
328 */
329 static int
330arg_list_any_mod(
331 type_T *type,
332 type_T *decl_type UNUSED,
333 argcontext_T *context)
334{
335 return check_arg_type_mod(&t_list_any, type, context);
336}
337
338/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200339 * Check "type" is a list of numbers.
340 */
341 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000342arg_list_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200343{
344 return check_arg_type(&t_list_number, type, context);
345}
346
347/*
348 * Check "type" is a list of strings.
349 */
350 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000351arg_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200352{
353 return check_arg_type(&t_list_string, type, context);
354}
355
356/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100357 * Check "type" is a string.
358 */
359 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000360arg_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100361{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100362 return check_arg_type(&t_string, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100363}
364
365/*
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200366 * Check "type" is a blob
367 */
368 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000369arg_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +0200370{
371 return check_arg_type(&t_blob, type, context);
372}
373
374/*
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100375 * Check "type" is a bool or number 0 or 1.
376 */
377 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000378arg_bool(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100379{
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100380 return check_arg_type(&t_bool, type, context);
381}
382
383/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200384 * Check "type" is a list of 'any' or a blob.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100385 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200386 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000387arg_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200388{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100389 if (type->tt_type == VAR_LIST
390 || type->tt_type == VAR_BLOB
391 || type_any_or_unknown(type))
Bram Moolenaarca174532020-10-21 16:42:22 +0200392 return OK;
393 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
394 return FAIL;
395}
396
397/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100398 * Check "type" is a modifiable list of 'any' or a blob.
399 */
400 static int
401arg_list_or_blob_mod(
402 type_T *type,
403 type_T *decl_type,
404 argcontext_T *context)
405{
406 if (arg_list_or_blob(type, decl_type, context) == FAIL)
407 return FAIL;
408 return arg_type_modifiable(type, context->arg_idx + 1);
409}
410
411/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200412 * Check "type" is a string or a number
413 */
414 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000415arg_string_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200416{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100417 if (type->tt_type == VAR_STRING
418 || type->tt_type == VAR_NUMBER
419 || type_any_or_unknown(type))
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200420 return OK;
421 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
422 return FAIL;
423}
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200424
425/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200426 * Check "type" is a buffer (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200427 */
428 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000429arg_buffer(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200430{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100431 if (type->tt_type == VAR_STRING
432 || type->tt_type == VAR_NUMBER
433 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200434 return OK;
435 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
436 return FAIL;
437}
438
439/*
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200440 * Check "type" is a buffer or a dict of any
441 */
442 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000443arg_buffer_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200444{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100445 if (type->tt_type == VAR_STRING
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200446 || type->tt_type == VAR_NUMBER
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100447 || type->tt_type == VAR_DICT
448 || type_any_or_unknown(type))
Yegappan Lakshmanancd917202021-07-21 19:09:09 +0200449 return OK;
450 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
451 return FAIL;
452}
453
454/*
455 * Check "type" is a line (string or a number)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200456 */
457 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000458arg_lnum(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200459{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100460 if (type->tt_type == VAR_STRING
461 || type->tt_type == VAR_NUMBER
462 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200463 return OK;
464 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
465 return FAIL;
466}
467
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200468/*
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200469 * Check "type" is a string or a list of strings.
470 */
471 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000472arg_string_or_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200473{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100474 if (type->tt_type == VAR_STRING
475 || type_any_or_unknown(type))
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200476 return OK;
477 if (type->tt_type != VAR_LIST)
478 {
479 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
480 return FAIL;
481 }
482 if (type->tt_member->tt_type == VAR_ANY
483 || type->tt_member->tt_type == VAR_STRING)
484 return OK;
485
486 arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);
487 return FAIL;
488}
489
490/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200491 * Check "type" is a string or a list of 'any'
492 */
493 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000494arg_string_or_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200495{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100496 if (type->tt_type == VAR_STRING
497 || type->tt_type == VAR_LIST
498 || type_any_or_unknown(type))
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200499 return OK;
500 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
501 return FAIL;
502}
503
504/*
Ernie Rael51d04d12022-05-04 15:40:22 +0100505 * Check "type" is a string or a dict of 'any'
506 */
507 static int
508arg_string_or_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
509{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100510 if (type->tt_type == VAR_STRING
511 || type->tt_type == VAR_DICT
512 || type_any_or_unknown(type))
Ernie Rael51d04d12022-05-04 15:40:22 +0100513 return OK;
514 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
515 return FAIL;
516}
517
518/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200519 * Check "type" is a string or a blob
520 */
521 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000522arg_string_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200523{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100524 if (type->tt_type == VAR_STRING
525 || type->tt_type == VAR_BLOB
526 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200527 return OK;
528 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
529 return FAIL;
530}
531
532/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200533 * Check "type" is a list of 'any' or a dict of 'any'.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100534 */
535 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000536arg_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100537{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100538 if (type->tt_type == VAR_LIST
539 || type->tt_type == VAR_DICT
540 || type_any_or_unknown(type))
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100541 return OK;
542 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
543 return FAIL;
544}
545
546/*
Bram Moolenaarfa103972022-09-29 19:14:42 +0100547 * Check "type" is a list of 'any' or a dict of 'any'. And modifiable.
548 */
549 static int
550arg_list_or_dict_mod(
551 type_T *type,
552 type_T *decl_type,
553 argcontext_T *context)
554{
555 if (arg_list_or_dict(type, decl_type, context) == FAIL)
556 return FAIL;
557 return arg_type_modifiable(type, context->arg_idx + 1);
558}
559
560/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200561 * Check "type" is a list of 'any' or a dict of 'any' or a blob.
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100562 * Also check if "type" is modifiable.
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200563 */
564 static int
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100565arg_list_or_dict_or_blob_mod(
566 type_T *type,
567 type_T *decl_type UNUSED,
568 argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200569{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100570 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000571 || type->tt_type == VAR_DICT
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100572 || type->tt_type == VAR_BLOB
573 || type_any_or_unknown(type))
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100574 return arg_type_modifiable(type, context->arg_idx + 1);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200575 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
576 return FAIL;
577}
578
579/*
Bram Moolenaar2d877592021-12-16 08:21:09 +0000580 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
581 */
582 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000583arg_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 +0000584{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100585 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000586 || type->tt_type == VAR_DICT
587 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100588 || type->tt_type == VAR_STRING
589 || type_any_or_unknown(type))
Bram Moolenaar2d877592021-12-16 08:21:09 +0000590 return OK;
591 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
592 return FAIL;
593}
594
595/*
Bram Moolenaara5d1a672022-09-30 17:57:47 +0100596 * Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.
597 * Also check the value is modifiable.
598 */
599 static int
600arg_list_or_dict_or_blob_or_string_mod(
601 type_T *type,
602 type_T *decl_type,
603 argcontext_T *context)
604{
605 if (arg_list_or_dict_or_blob_or_string(type, decl_type, context) == FAIL)
606 return FAIL;
607 return arg_type_modifiable(type, context->arg_idx + 1);
608}
609
610/*
Ernie Raele79e2072024-01-13 11:47:33 +0100611 * Check second argument of map(), filter(), foreach().
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000612 */
613 static int
Ernie Raele79e2072024-01-13 11:47:33 +0100614check_map_filter_arg2(type_T *type, argcontext_T *context,
615 filtermap_T filtermap)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000616{
617 type_T *expected_member = NULL;
618 type_T *(args[2]);
Bram Moolenaarb1e32ac2023-02-21 12:38:51 +0000619 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, NULL, NULL, args};
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000620
621 if (context->arg_types[0].type_curr->tt_type == VAR_LIST
622 || context->arg_types[0].type_curr->tt_type == VAR_DICT)
623 {
624 // Use the declared type if possible, so that an error is given if
625 // a declared list changes type, but not if a constant list changes
626 // type.
627 if (context->arg_types[0].type_decl->tt_type == VAR_LIST
628 || context->arg_types[0].type_decl->tt_type == VAR_DICT)
629 expected_member = context->arg_types[0].type_decl->tt_member;
630 else
631 expected_member = context->arg_types[0].type_curr->tt_member;
632 }
633 else if (context->arg_types[0].type_curr->tt_type == VAR_STRING)
634 expected_member = &t_string;
635 else if (context->arg_types[0].type_curr->tt_type == VAR_BLOB)
636 expected_member = &t_number;
637
638 args[0] = NULL;
639 args[1] = &t_unknown;
640 if (type->tt_argcount != -1)
641 {
642 if (!(type->tt_argcount == 2 || (type->tt_argcount == 1
643 && (type->tt_flags & TTFLAG_VARARGS))))
644 {
645 emsg(_(e_invalid_number_of_arguments));
646 return FAIL;
647 }
648 if (type->tt_flags & TTFLAG_VARARGS)
649 // check the argument types at runtime
650 t_func_exp.tt_argcount = -1;
651 else
652 {
653 if (context->arg_types[0].type_curr->tt_type == VAR_STRING
654 || context->arg_types[0].type_curr->tt_type == VAR_BLOB
655 || context->arg_types[0].type_curr->tt_type == VAR_LIST)
656 args[0] = &t_number;
657 else if (context->arg_types[0].type_decl->tt_type == VAR_DICT)
658 args[0] = &t_string;
659 if (args[0] != NULL)
660 args[1] = expected_member;
661 }
662 }
663
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100664 if (!type_any_or_unknown(type->tt_member) || args[0] != NULL)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000665 {
666 where_T where = WHERE_INIT;
667
Ernie Raele79e2072024-01-13 11:47:33 +0100668 if (filtermap == FILTERMAP_MAP)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000669 t_func_exp.tt_member = expected_member == NULL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100670 || type_any_or_unknown(type->tt_member)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000671 ? &t_any : expected_member;
Ernie Raele79e2072024-01-13 11:47:33 +0100672 else if (filtermap == FILTERMAP_FILTER)
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000673 t_func_exp.tt_member = &t_bool;
Ernie Raele79e2072024-01-13 11:47:33 +0100674 else // filtermap == FILTERMAP_FOREACH
675 t_func_exp.tt_member = &t_unknown;
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000676 if (args[0] == NULL)
677 args[0] = &t_unknown;
Bram Moolenaar6e1a3872022-02-23 19:11:49 +0000678 if (type->tt_argcount == -1)
679 t_func_exp.tt_argcount = -1;
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000680
681 where.wt_index = 2;
LemonBoyc5d27442023-08-19 13:02:35 +0200682 where.wt_kind = WT_ARGUMENT;
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000683 return check_type(&t_func_exp, type, TRUE, where);
684 }
685 return OK;
686}
687
688/*
Bram Moolenaar18024052021-12-25 21:43:28 +0000689 * Check second argument of filter(): func must return a bool.
690 */
691 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000692arg_filter_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000693{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000694 if (type->tt_type == VAR_STRING
695 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100696 || type_any_or_unknown(type))
Bram Moolenaar1080c482022-01-26 18:26:21 +0000697 return OK;
698
699 if (type->tt_type == VAR_FUNC)
Ernie Raele79e2072024-01-13 11:47:33 +0100700 return check_map_filter_arg2(type, context, FILTERMAP_FILTER);
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000701 semsg(_(e_string_or_function_required_for_argument_nr), 2);
702 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000703}
704
705/*
Bram Moolenaareddd4fc2022-02-20 15:52:28 +0000706 * Check second argument of map(), the function.
Bram Moolenaar18024052021-12-25 21:43:28 +0000707 */
708 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000709arg_map_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar18024052021-12-25 21:43:28 +0000710{
Bram Moolenaar1080c482022-01-26 18:26:21 +0000711 if (type->tt_type == VAR_STRING
712 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100713 || type_any_or_unknown(type))
Bram Moolenaar1080c482022-01-26 18:26:21 +0000714 return OK;
715
716 if (type->tt_type == VAR_FUNC)
Ernie Raele79e2072024-01-13 11:47:33 +0100717 return check_map_filter_arg2(type, context, FILTERMAP_MAP);
718 semsg(_(e_string_or_function_required_for_argument_nr), 2);
719 return FAIL;
720}
721
722/*
723 * Check second argument of foreach(), the function.
724 */
725 static int
726arg_foreach_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
727{
728 if (type->tt_type == VAR_STRING
729 || type->tt_type == VAR_PARTIAL
730 || type_any_or_unknown(type))
731 return OK;
732
733 if (type->tt_type == VAR_FUNC)
734 return check_map_filter_arg2(type, context, FILTERMAP_FOREACH);
Bram Moolenaar16f6c8a2022-02-22 15:12:14 +0000735 semsg(_(e_string_or_function_required_for_argument_nr), 2);
736 return FAIL;
Bram Moolenaar18024052021-12-25 21:43:28 +0000737}
738
739/*
Bram Moolenaare843efc2022-02-22 21:54:44 +0000740 * Check second argument of sort() and uniq(), the "how" argument.
741 */
742 static int
743arg_sort_how(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
744{
745 if (type->tt_type == VAR_STRING
746 || type->tt_type == VAR_PARTIAL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100747 || type_any_or_unknown(type))
Bram Moolenaare843efc2022-02-22 21:54:44 +0000748 return OK;
749
750 if (type->tt_type == VAR_FUNC)
751 {
752 type_T *(args[2]);
Bram Moolenaarb1e32ac2023-02-21 12:38:51 +0000753 type_T t_func_exp = {VAR_FUNC, 2, 0, 0, &t_number, NULL, args};
Bram Moolenaare843efc2022-02-22 21:54:44 +0000754
755 if (context->arg_types[0].type_curr->tt_type == VAR_LIST)
756 args[0] = context->arg_types[0].type_curr->tt_member;
757 else
758 args[0] = &t_unknown;
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100759 if (!type_any_or_unknown(type->tt_member) || args[0] != &t_unknown)
Bram Moolenaare843efc2022-02-22 21:54:44 +0000760 {
761 where_T where = WHERE_INIT;
762
763 args[1] = args[0];
Bram Moolenaarfa026162022-02-23 21:03:32 +0000764 if (type->tt_argcount == -1)
765 t_func_exp.tt_argcount = -1;
Bram Moolenaare843efc2022-02-22 21:54:44 +0000766 where.wt_index = 2;
LemonBoyc5d27442023-08-19 13:02:35 +0200767 where.wt_kind = WT_ARGUMENT;
Bram Moolenaare843efc2022-02-22 21:54:44 +0000768 return check_type(&t_func_exp, type, TRUE, where);
769 }
770
771 return OK;
772 }
773 semsg(_(e_string_or_function_required_for_argument_nr), 2);
774 return FAIL;
775}
776
777/*
Bram Moolenaar73199812021-12-26 17:18:14 +0000778 * Check an expression argument, can be a string, funcref or partial.
779 * Also accept a bool, a constant resulting from compiling a string argument.
780 * Also accept a number, one and zero are accepted.
781 */
782 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000783arg_string_or_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaar73199812021-12-26 17:18:14 +0000784{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100785 if (type->tt_type == VAR_STRING
Bram Moolenaar73199812021-12-26 17:18:14 +0000786 || type->tt_type == VAR_PARTIAL
787 || type->tt_type == VAR_FUNC
788 || type->tt_type == VAR_BOOL
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100789 || type->tt_type == VAR_NUMBER
790 || type_any_or_unknown(type))
Bram Moolenaar73199812021-12-26 17:18:14 +0000791 return OK;
792 arg_type_mismatch(&t_func_any, type, context->arg_idx + 1);
793 return FAIL;
794}
795
796/*
Ernie Rael2025af12023-12-12 16:58:00 +0100797 * Check varargs' "type" are class.
LemonBoyafe04662023-08-23 21:08:11 +0200798 */
799 static int
Ernie Rael2025af12023-12-12 16:58:00 +0100800varargs_class(type_T *type UNUSED,
801 type_T *decl_type UNUSED,
802 argcontext_T *context)
LemonBoyafe04662023-08-23 21:08:11 +0200803{
Ernie Rael2025af12023-12-12 16:58:00 +0100804 for (int i = context->arg_idx; i < context->arg_count; ++i)
805 {
806 type2_T *types = &context->arg_types[i];
807 if (types->type_curr->tt_type != VAR_CLASS)
808 {
809 semsg(_(e_class_or_typealias_required_for_argument_nr), i + 1);
810 return FAIL;
811 }
812 }
813 return OK;
LemonBoyafe04662023-08-23 21:08:11 +0200814}
815
816/*
rbtnn0ccb5842021-12-18 18:33:46 +0000817 * Check "type" is a list of 'any' or a blob or a string.
818 */
819 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000820arg_string_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
rbtnn0ccb5842021-12-18 18:33:46 +0000821{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100822 if (type->tt_type == VAR_LIST
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000823 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100824 || type->tt_type == VAR_STRING
825 || type_any_or_unknown(type))
rbtnn0ccb5842021-12-18 18:33:46 +0000826 return OK;
827 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
828 return FAIL;
829}
830
831/*
Yegappan Lakshmananf9dc2782023-05-11 15:02:56 +0100832 * Check "type" is a modifiable list of 'any' or a blob or a string.
833 */
834 static int
835arg_string_list_or_blob_mod(type_T *type, type_T *decl_type, argcontext_T *context)
836{
837 if (arg_string_list_or_blob(type, decl_type, context) == FAIL)
838 return FAIL;
839 return arg_type_modifiable(type, context->arg_idx + 1);
840}
841
842/*
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200843 * Check "type" is a job.
844 */
845 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000846arg_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +0200847{
848 return check_arg_type(&t_job, type, context);
849}
850
851/*
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200852 * Check "type" is a channel or a job.
853 */
854 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000855arg_chan_or_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200856{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100857 if (type->tt_type == VAR_CHANNEL
858 || type->tt_type == VAR_JOB
859 || type_any_or_unknown(type))
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +0200860 return OK;
861 arg_type_mismatch(&t_channel, type, context->arg_idx + 1);
862 return FAIL;
863}
864
865/*
Bram Moolenaar078a4612022-01-04 15:17:03 +0000866 * Check "type" can be used as the type_decl of the previous argument.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100867 * Must not be used for the first argcheck_T entry.
868 */
869 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000870arg_same_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100871{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000872 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_decl;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100873
Bram Moolenaar351ead02021-01-16 16:07:01 +0100874 return check_arg_type(prev_type, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100875}
876
877/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100878 * Check "type" is the same basic type as the previous argument, checks list or
879 * dict vs other type, but not member type.
880 * Must not be used for the first argcheck_T entry.
881 */
882 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000883arg_same_struct_as_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100884{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000885 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100886
Bram Moolenaar078a4612022-01-04 15:17:03 +0000887 if (prev_type->tt_type != context->arg_types[context->arg_idx].type_curr->tt_type)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100888 return check_arg_type(prev_type, type, context);
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100889 return OK;
890}
891
892/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100893 * Check "type" is an item of the list or blob of the previous arg.
Bram Moolenaarca174532020-10-21 16:42:22 +0200894 * Must not be used for the first argcheck_T entry.
895 */
896 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000897arg_item_of_prev(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Bram Moolenaarca174532020-10-21 16:42:22 +0200898{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000899 type_T *prev_type = context->arg_types[context->arg_idx - 1].type_curr;
Bram Moolenaarca174532020-10-21 16:42:22 +0200900 type_T *expected;
901
902 if (prev_type->tt_type == VAR_LIST)
903 expected = prev_type->tt_member;
904 else if (prev_type->tt_type == VAR_BLOB)
905 expected = &t_number;
906 else
907 // probably VAR_ANY, can't check
908 return OK;
909
Bram Moolenaar351ead02021-01-16 16:07:01 +0100910 return check_arg_type(expected, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200911}
912
Bram Moolenaar94738d82020-10-21 14:25:07 +0200913/*
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200914 * Check "type" is a string or a number or a list
915 */
916 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000917arg_str_or_nr_or_list(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200918{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100919 if (type->tt_type == VAR_STRING
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000920 || type->tt_type == VAR_NUMBER
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100921 || type->tt_type == VAR_LIST
922 || type_any_or_unknown(type))
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +0200923 return OK;
924 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
925 return FAIL;
926}
927
928/*
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200929 * Check "type" is a dict of 'any' or a string
930 */
931 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000932arg_dict_any_or_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200933{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100934 if (type->tt_type == VAR_DICT
935 || type->tt_type == VAR_STRING
936 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200937 return OK;
938 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
939 return FAIL;
940}
941
942/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200943 * Check "type" which is the third argument of extend() (number or string or
944 * any)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100945 */
946 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000947arg_extend3(type_T *type, type_T *decl_type, argcontext_T *context)
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100948{
Bram Moolenaar078a4612022-01-04 15:17:03 +0000949 type_T *first_type = context->arg_types[context->arg_idx - 2].type_curr;
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100950
951 if (first_type->tt_type == VAR_LIST)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000952 return arg_number(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100953 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000954 return arg_string(type, decl_type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100955 return OK;
956}
957
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +0200958/*
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200959 * Check "type" which is the first argument of get() (blob or list or dict or
960 * funcref)
961 */
962 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000963arg_get1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200964{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100965 if (type->tt_type == VAR_BLOB
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200966 || type->tt_type == VAR_LIST
967 || type->tt_type == VAR_DICT
968 || type->tt_type == VAR_FUNC
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100969 || type->tt_type == VAR_PARTIAL
970 || type_any_or_unknown(type))
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200971 return OK;
972
973 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
974 return FAIL;
975}
976
977/*
978 * Check "type" which is the first argument of len() (number or string or
979 * blob or list or dict)
980 */
981 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +0000982arg_len1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200983{
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100984 if (type->tt_type == VAR_STRING
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200985 || type->tt_type == VAR_NUMBER
986 || type->tt_type == VAR_BLOB
987 || type->tt_type == VAR_LIST
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100988 || type->tt_type == VAR_DICT
Yegappan Lakshmanand3eae7b2024-03-03 16:26:58 +0100989 || type->tt_type == VAR_OBJECT
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100990 || type_any_or_unknown(type))
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200991 return OK;
992
993 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
994 return FAIL;
995}
996
997/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +0200998 * Check "type" which is the second argument of remove() (number or string or
999 * any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001000 */
1001 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +00001002arg_remove2(type_T *type, type_T *decl_type, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001003{
Bram Moolenaar078a4612022-01-04 15:17:03 +00001004 type_T *first_type = context->arg_types[context->arg_idx - 1].type_curr;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001005
1006 if (first_type->tt_type == VAR_LIST || first_type->tt_type == VAR_BLOB)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001007 return arg_number(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001008 if (first_type->tt_type == VAR_DICT)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001009 return arg_string_or_nr(type, decl_type, context);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001010 return OK;
1011}
1012
1013/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001014 * Check "type" which is the first argument of repeat() (string or number or
1015 * list or any)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001016 */
1017 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +00001018arg_repeat1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001019{
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001020 if (type->tt_type == VAR_STRING
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001021 || type->tt_type == VAR_NUMBER
Bakudankun375141e2022-09-09 18:46:47 +01001022 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001023 || type->tt_type == VAR_LIST
1024 || type_any_or_unknown(type))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001025 return OK;
1026
1027 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
1028 return FAIL;
1029}
1030
1031/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001032 * Check "type" which is the first argument of slice() (list or blob or string
1033 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001034 */
1035 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +00001036arg_slice1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001037{
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001038 if (type->tt_type == VAR_LIST
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001039 || type->tt_type == VAR_BLOB
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001040 || type->tt_type == VAR_STRING
1041 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001042 return OK;
1043
1044 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
1045 return FAIL;
1046}
1047
1048/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001049 * Check "type" which is the first argument of count() (string or list or dict
1050 * or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001051 */
1052 static int
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001053arg_string_or_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001054{
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001055 if (type->tt_type == VAR_STRING
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001056 || type->tt_type == VAR_LIST
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001057 || type->tt_type == VAR_DICT
1058 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001059 return OK;
1060
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001061 semsg(_(e_string_list_or_dict_required_for_argument_nr),
1062 context->arg_idx + 1);
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001063 return FAIL;
1064}
1065
1066/*
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001067 * Check "type" which is the first argument of cursor() (number or string or
1068 * list or any)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001069 */
1070 static int
Bram Moolenaar078a4612022-01-04 15:17:03 +00001071arg_cursor1(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001072{
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001073 if (type->tt_type == VAR_NUMBER
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001074 || type->tt_type == VAR_STRING
Bram Moolenaar330d64d2022-10-09 12:55:33 +01001075 || type->tt_type == VAR_LIST
1076 || type_any_or_unknown(type))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001077 return OK;
1078
1079 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
1080 return FAIL;
1081}
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +01001082
1083/*
Bram Moolenaar94738d82020-10-21 14:25:07 +02001084 * Lists of functions that check the argument types of a builtin function.
1085 */
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001086static argcheck_T arg1_blob[] = {arg_blob};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001087static argcheck_T arg1_bool[] = {arg_bool};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001088static argcheck_T arg1_buffer[] = {arg_buffer};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001089static argcheck_T arg1_buffer_or_dict_any[] = {arg_buffer_or_dict_any};
1090static argcheck_T arg1_chan_or_job[] = {arg_chan_or_job};
1091static argcheck_T arg1_dict_any[] = {arg_dict_any};
1092static argcheck_T arg1_dict_or_string[] = {arg_dict_any_or_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001093static argcheck_T arg1_float_or_nr[] = {arg_float_or_nr};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001094static argcheck_T arg1_job[] = {arg_job};
1095static argcheck_T arg1_list_any[] = {arg_list_any};
1096static argcheck_T arg1_list_number[] = {arg_list_number};
Yegappan Lakshmananf9dc2782023-05-11 15:02:56 +01001097static argcheck_T arg1_string_or_list_or_blob_mod[] = {arg_string_list_or_blob_mod};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001098static argcheck_T arg1_list_or_dict[] = {arg_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001099static argcheck_T arg1_list_string[] = {arg_list_string};
Bram Moolenaar3e518a82022-08-30 17:45:33 +01001100static argcheck_T arg1_string_or_list_or_dict[] = {arg_string_or_list_or_dict};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001101static argcheck_T arg1_lnum[] = {arg_lnum};
1102static argcheck_T arg1_number[] = {arg_number};
1103static argcheck_T arg1_string[] = {arg_string};
1104static argcheck_T arg1_string_or_list_any[] = {arg_string_or_list_any};
1105static argcheck_T arg1_string_or_list_string[] = {arg_string_or_list_string};
1106static argcheck_T arg1_string_or_nr[] = {arg_string_or_nr};
Ernie Raela8f7f922023-12-14 20:17:04 +01001107static argcheck_T arg2_any_buffer[] = {arg_any, arg_buffer};
1108static argcheck_T arg2_buffer_any[] = {arg_buffer, arg_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001109static argcheck_T arg2_buffer_bool[] = {arg_buffer, arg_bool};
1110static argcheck_T arg2_buffer_list_any[] = {arg_buffer, arg_list_any};
1111static argcheck_T arg2_buffer_lnum[] = {arg_buffer, arg_lnum};
1112static argcheck_T arg2_buffer_number[] = {arg_buffer, arg_number};
1113static argcheck_T arg2_buffer_string[] = {arg_buffer, arg_string};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001114static argcheck_T arg2_chan_or_job_dict[] = {arg_chan_or_job, arg_dict_any};
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001115static argcheck_T arg2_chan_or_job_string[] = {arg_chan_or_job, arg_string};
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02001116static argcheck_T arg2_dict_any_list_any[] = {arg_dict_any, arg_list_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001117static argcheck_T arg2_dict_any_string_or_nr[] = {arg_dict_any, arg_string_or_nr};
1118static argcheck_T arg2_dict_string[] = {arg_dict_any, arg_string};
1119static argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr};
1120static argcheck_T arg2_job_dict[] = {arg_job, arg_dict_any};
1121static argcheck_T arg2_job_string_or_number[] = {arg_job, arg_string_or_nr};
1122static argcheck_T arg2_list_any_number[] = {arg_list_any, arg_number};
1123static argcheck_T arg2_list_any_string[] = {arg_list_any, arg_string};
1124static argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number};
1125static argcheck_T arg2_list_number_bool[] = {arg_list_number, arg_bool};
Bram Moolenaarfa103972022-09-29 19:14:42 +01001126static argcheck_T arg2_listblobmod_item[] = {arg_list_or_blob_mod, arg_item_of_prev};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001127static argcheck_T arg2_lnum[] = {arg_lnum, arg_lnum};
1128static argcheck_T arg2_lnum_number[] = {arg_lnum, arg_number};
1129static argcheck_T arg2_number[] = {arg_number, arg_number};
Ernie Raela8f7f922023-12-14 20:17:04 +01001130static argcheck_T arg2_number_any[] = {arg_number, arg_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001131static argcheck_T arg2_number_bool[] = {arg_number, arg_bool};
1132static argcheck_T arg2_number_dict_any[] = {arg_number, arg_dict_any};
1133static argcheck_T arg2_number_list[] = {arg_number, arg_list_any};
1134static argcheck_T arg2_number_string[] = {arg_number, arg_string};
1135static argcheck_T arg2_number_string_or_list[] = {arg_number, arg_string_or_list_any};
1136static argcheck_T arg2_str_or_nr_or_list_dict[] = {arg_str_or_nr_or_list, arg_dict_any};
1137static argcheck_T arg2_string[] = {arg_string, arg_string};
Ernie Raela8f7f922023-12-14 20:17:04 +01001138static argcheck_T arg2_string_any[] = {arg_string, arg_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001139static argcheck_T arg2_string_bool[] = {arg_string, arg_bool};
1140static argcheck_T arg2_string_chan_or_job[] = {arg_string, arg_chan_or_job};
1141static argcheck_T arg2_string_dict[] = {arg_string, arg_dict_any};
1142static argcheck_T arg2_string_list_number[] = {arg_string, arg_list_number};
1143static argcheck_T arg2_string_number[] = {arg_string, arg_number};
1144static argcheck_T arg2_string_or_list_dict[] = {arg_string_or_list_any, arg_dict_any};
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001145static argcheck_T arg2_string_or_list_number[] = {arg_string_or_list_any, arg_number};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001146static argcheck_T arg2_string_string_or_number[] = {arg_string, arg_string_or_nr};
Ernie Raela8f7f922023-12-14 20:17:04 +01001147static argcheck_T arg3_any_list_dict[] = {arg_any, arg_list_any, arg_dict_any};
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001148static argcheck_T arg3_buffer_lnum_lnum[] = {arg_buffer, arg_lnum, arg_lnum};
1149static argcheck_T arg3_buffer_number_number[] = {arg_buffer, arg_number, arg_number};
Ernie Raela8f7f922023-12-14 20:17:04 +01001150static argcheck_T arg3_buffer_string_any[] = {arg_buffer, arg_string, arg_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001151static argcheck_T arg3_buffer_string_dict[] = {arg_buffer, arg_string, arg_dict_any};
1152static argcheck_T arg3_dict_number_number[] = {arg_dict_any, arg_number, arg_number};
Yegappan Lakshmananfa378352024-02-01 22:05:27 +01001153static argcheck_T arg3_diff[] = {arg_list_string, arg_list_string, arg_dict_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001154static argcheck_T arg3_list_string_dict[] = {arg_list_any, arg_string, arg_dict_any};
Shougo Matsushita19b71882024-02-28 22:48:12 +01001155static argcheck_T arg3_list_list_dict[] = {arg_list_any, arg_list_any, arg_dict_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001156static argcheck_T arg3_lnum_number_bool[] = {arg_lnum, arg_number, arg_bool};
1157static argcheck_T arg3_number[] = {arg_number, arg_number, arg_number};
Ernie Raela8f7f922023-12-14 20:17:04 +01001158static argcheck_T arg3_number_any_dict[] = {arg_number, arg_any, arg_dict_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001159static argcheck_T arg3_number_number_dict[] = {arg_number, arg_number, arg_dict_any};
Ernie Raela8f7f922023-12-14 20:17:04 +01001160static argcheck_T arg3_number_string_any[] = {arg_number, arg_string, arg_any};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001161static argcheck_T arg3_number_string_buffer[] = {arg_number, arg_string, arg_buffer};
1162static argcheck_T arg3_number_string_string[] = {arg_number, arg_string, arg_string};
1163static argcheck_T arg3_string[] = {arg_string, arg_string, arg_string};
Ernie Raela8f7f922023-12-14 20:17:04 +01001164static argcheck_T arg3_string_any_dict[] = {arg_string, arg_any, arg_dict_any};
1165static argcheck_T arg3_string_any_string[] = {arg_string, arg_any, arg_string};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001166static argcheck_T arg3_string_bool_bool[] = {arg_string, arg_bool, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001167static argcheck_T arg3_string_number_bool[] = {arg_string, arg_number, arg_bool};
K.Takata11df3ae2022-10-19 14:02:40 +01001168static argcheck_T arg3_string_number_number[] = {arg_string, arg_number, arg_number};
Ernie Rael51d04d12022-05-04 15:40:22 +01001169static argcheck_T arg3_string_or_dict_bool_dict[] = {arg_string_or_dict_any, arg_bool, arg_dict_any};
zeertzjq825cf812023-08-17 22:55:25 +02001170static argcheck_T arg3_string_or_list_bool_number[] = {arg_string_or_list_any, arg_bool, arg_number};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001171static argcheck_T arg3_string_string_bool[] = {arg_string, arg_string, arg_bool};
1172static argcheck_T arg3_string_string_dict[] = {arg_string, arg_string, arg_dict_any};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001173static argcheck_T arg3_string_string_number[] = {arg_string, arg_string, arg_number};
Ernie Raela8f7f922023-12-14 20:17:04 +01001174static argcheck_T arg4_number_number_string_any[] = {arg_number, arg_number, arg_string, arg_any};
1175static argcheck_T arg4_string_string_any_string[] = {arg_string, arg_string, arg_any, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001176static argcheck_T arg4_string_string_number_string[] = {arg_string, arg_string, arg_number, arg_string};
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001177static argcheck_T arg4_string_number_bool_bool[] = {arg_string, arg_number, arg_bool, arg_bool};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001178/* Function specific argument types (not covered by the above) */
Ernie Raela8f7f922023-12-14 20:17:04 +01001179static argcheck_T arg15_assert_fails[] = {arg_string_or_nr, arg_string_or_list_any, arg_any, arg_number, arg_string};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001180static 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 +02001181static argcheck_T arg4_browse[] = {arg_bool, arg_string, arg_string, arg_string};
Ernie Raela8f7f922023-12-14 20:17:04 +01001182static argcheck_T arg23_chanexpr[] = {arg_chan_or_job, arg_any, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001183static argcheck_T arg23_chanraw[] = {arg_chan_or_job, arg_string_or_blob, arg_dict_any};
Ernie Raela8f7f922023-12-14 20:17:04 +01001184static argcheck_T arg24_count[] = {arg_string_or_list_or_dict, arg_any, arg_bool, arg_number};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001185static argcheck_T arg13_cursor[] = {arg_cursor1, arg_number, arg_number};
Ernie Raela8f7f922023-12-14 20:17:04 +01001186static argcheck_T arg12_deepcopy[] = {arg_any, arg_bool};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001187static argcheck_T arg12_execute[] = {arg_string_or_list_string, arg_string};
Bram Moolenaarfa103972022-09-29 19:14:42 +01001188static argcheck_T arg23_extend[] = {arg_list_or_dict_mod, arg_same_as_prev, arg_extend3};
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001189static argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3};
Ernie Raela8f7f922023-12-14 20:17:04 +01001190static argcheck_T arg23_get[] = {arg_get1, arg_string_or_nr, arg_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001191static argcheck_T arg14_glob[] = {arg_string, arg_bool, arg_bool, arg_bool};
1192static argcheck_T arg25_globpath[] = {arg_string, arg_string, arg_bool, arg_bool, arg_bool};
1193static argcheck_T arg24_index[] = {arg_list_or_blob, arg_item_of_prev, arg_number, arg_bool};
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01001194static argcheck_T arg23_index[] = {arg_list_or_blob, arg_filter_func, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001195static argcheck_T arg23_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number};
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001196static argcheck_T arg1_len[] = {arg_len1};
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001197static argcheck_T arg3_libcall[] = {arg_string, arg_string, arg_string_or_nr};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001198static argcheck_T arg14_maparg[] = {arg_string, arg_string, arg_bool, arg_bool};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001199static argcheck_T arg2_filter[] = {arg_list_or_dict_or_blob_or_string_mod, arg_filter_func};
Ernie Raele79e2072024-01-13 11:47:33 +01001200static argcheck_T arg2_foreach[] = {arg_list_or_dict_or_blob_or_string, arg_foreach_func};
Ernie Rael2025af12023-12-12 16:58:00 +01001201static argcheck_T arg2_instanceof[] = {arg_object, varargs_class, NULL };
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001202static argcheck_T arg2_map[] = {arg_list_or_dict_or_blob_or_string_mod, arg_map_func};
Ernie Raela8f7f922023-12-14 20:17:04 +01001203static argcheck_T arg2_mapnew[] = {arg_list_or_dict_or_blob_or_string, arg_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001204static argcheck_T arg25_matchadd[] = {arg_string, arg_string, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001205static argcheck_T arg25_matchaddpos[] = {arg_string, arg_list_any, arg_number, arg_number, arg_dict_any};
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +01001206static argcheck_T arg23_matchstrlist[] = {arg_list_string, arg_string, arg_dict_any};
1207static argcheck_T arg45_matchbufline[] = {arg_buffer, arg_string, arg_lnum, arg_lnum, arg_dict_any};
Ernie Raela8f7f922023-12-14 20:17:04 +01001208static argcheck_T arg119_printf[] = {arg_string_or_nr, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any, arg_any};
1209static argcheck_T arg23_reduce[] = {arg_string_list_or_blob, arg_any, arg_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001210static argcheck_T arg24_remote_expr[] = {arg_string, arg_string, arg_string, arg_number};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001211static argcheck_T arg23_remove[] = {arg_list_or_dict_or_blob_mod, arg_remove2, arg_number};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001212static argcheck_T arg2_repeat[] = {arg_repeat1, arg_number};
Bram Moolenaar73199812021-12-26 17:18:14 +00001213static argcheck_T arg15_search[] = {arg_string, arg_string, arg_number, arg_number, arg_string_or_func};
1214static 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 +02001215static argcheck_T arg3_setbufline[] = {arg_buffer, arg_lnum, arg_str_or_nr_or_list};
Ernie Raela8f7f922023-12-14 20:17:04 +01001216static argcheck_T arg2_setline[] = {arg_lnum, arg_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001217static argcheck_T arg24_setloclist[] = {arg_number, arg_list_any, arg_string, arg_dict_any};
1218static argcheck_T arg13_setqflist[] = {arg_list_any, arg_string, arg_dict_any};
1219static argcheck_T arg23_settagstack[] = {arg_number, arg_dict_any, arg_string};
1220static argcheck_T arg02_sign_getplaced[] = {arg_buffer, arg_dict_any};
1221static argcheck_T arg45_sign_place[] = {arg_number, arg_string, arg_string, arg_buffer, arg_dict_any};
1222static argcheck_T arg23_slice[] = {arg_slice1, arg_number, arg_number};
Bram Moolenaara5d1a672022-09-30 17:57:47 +01001223static argcheck_T arg13_sortuniq[] = {arg_list_any_mod, arg_sort_how, arg_dict_any};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001224static argcheck_T arg24_strpart[] = {arg_string, arg_number, arg_number, arg_bool};
1225static argcheck_T arg12_system[] = {arg_string, arg_str_or_nr_or_list};
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001226static argcheck_T arg23_win_execute[] = {arg_number, arg_string_or_list_string, arg_string};
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001227static argcheck_T arg23_writefile[] = {arg_list_or_blob, arg_string, arg_string};
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001228static argcheck_T arg24_match_func[] = {arg_string_or_list_any, arg_string, arg_number, arg_number};
Bram Moolenaarcd268012021-07-22 19:11:08 +02001229
Bram Moolenaar32517c42023-01-15 18:17:12 +00001230// Can be used by functions called through "f_retfunc" to create new types.
1231static garray_T *current_type_gap = NULL;
Bram Moolenaar94738d82020-10-21 14:25:07 +02001232
1233/*
1234 * Functions that return the return type of a builtin function.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001235 * Note that "argtypes" is NULL if "argcount" is zero.
Bram Moolenaar94738d82020-10-21 14:25:07 +02001236 */
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001237 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001238ret_void(int argcount UNUSED,
1239 type2_T *argtypes UNUSED,
1240 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001241{
1242 return &t_void;
1243}
1244 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001245ret_any(int argcount UNUSED,
1246 type2_T *argtypes UNUSED,
1247 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001248{
1249 return &t_any;
1250}
1251 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001252ret_bool(int argcount UNUSED,
1253 type2_T *argtypes UNUSED,
1254 type_T **decl_type UNUSED)
Bram Moolenaar403dc312020-10-17 19:29:51 +02001255{
1256 return &t_bool;
1257}
1258 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001259ret_number_bool(int argcount UNUSED,
1260 type2_T *argtypes UNUSED,
1261 type_T **decl_type UNUSED)
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001262{
1263 return &t_number_bool;
1264}
1265 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001266ret_number(int argcount UNUSED,
1267 type2_T *argtypes UNUSED,
1268 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001269{
1270 return &t_number;
1271}
1272 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001273ret_float(int argcount UNUSED,
1274 type2_T *argtypes UNUSED,
1275 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001276{
1277 return &t_float;
1278}
1279 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001280ret_string(int argcount UNUSED,
1281 type2_T *argtypes UNUSED,
1282 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001283{
1284 return &t_string;
1285}
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001286 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001287ret_list_any(int argcount UNUSED,
1288 type2_T *argtypes UNUSED,
1289 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001290{
1291 return &t_list_any;
1292}
1293 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001294ret_list_number(int argcount UNUSED,
1295 type2_T *argtypes UNUSED,
Bram Moolenaar81330182022-02-01 12:11:58 +00001296 type_T **decl_type)
1297{
Bram Moolenaar81330182022-02-01 12:11:58 +00001298 *decl_type = &t_list_any;
1299 return &t_list_number;
1300}
1301 static type_T *
1302ret_list_string(int argcount UNUSED,
1303 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001304 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001305{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001306 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001307 return &t_list_string;
1308}
1309 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001310ret_list_dict_any(int argcount UNUSED,
1311 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001312 type_T **decl_type)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001313{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001314 *decl_type = &t_list_any;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001315 return &t_list_dict_any;
1316}
1317 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001318ret_list_items(int argcount UNUSED,
1319 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001320 type_T **decl_type)
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001321{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001322 *decl_type = &t_list_any;
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001323 return &t_list_list_any;
1324}
mityu61065042021-07-19 20:07:21 +02001325
1326 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001327ret_list_string_items(int argcount UNUSED,
1328 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001329 type_T **decl_type)
mityu61065042021-07-19 20:07:21 +02001330{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001331 *decl_type = &t_list_any;
mityu61065042021-07-19 20:07:21 +02001332 return &t_list_list_string;
1333}
Bram Moolenaarefc5db52021-07-07 21:21:30 +02001334 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001335ret_dict_any(int argcount UNUSED,
1336 type2_T *argtypes UNUSED,
1337 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001338{
1339 return &t_dict_any;
1340}
1341 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001342ret_job_info(int argcount,
1343 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001344 type_T **decl_type)
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001345{
1346 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001347 {
1348 *decl_type = &t_list_any;
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001349 return &t_list_job;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001350 }
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001351 return &t_dict_any;
1352}
1353 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001354ret_dict_number(int argcount UNUSED,
1355 type2_T *argtypes UNUSED,
1356 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001357{
1358 return &t_dict_number;
1359}
1360 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001361ret_dict_string(int argcount UNUSED,
1362 type2_T *argtypes UNUSED,
1363 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001364{
1365 return &t_dict_string;
1366}
1367 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001368ret_blob(int argcount UNUSED,
1369 type2_T *argtypes UNUSED,
1370 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001371{
1372 return &t_blob;
1373}
1374 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001375ret_func_any(int argcount UNUSED,
1376 type2_T *argtypes UNUSED,
1377 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001378{
Bram Moolenaare69f6d02020-04-01 22:11:01 +02001379 return &t_func_any;
1380}
1381 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001382ret_func_unknown(int argcount UNUSED,
1383 type2_T *argtypes UNUSED,
1384 type_T **decl_type UNUSED)
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00001385{
1386 return &t_func_unknown;
1387}
1388 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001389ret_channel(int argcount UNUSED,
1390 type2_T *argtypes UNUSED,
1391 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001392{
1393 return &t_channel;
1394}
1395 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001396ret_job(int argcount UNUSED,
1397 type2_T *argtypes UNUSED,
1398 type_T **decl_type UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001399{
1400 return &t_job;
1401}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001402 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001403ret_first_arg(int argcount,
1404 type2_T *argtypes,
1405 type_T **decl_type)
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001406{
1407 if (argcount > 0)
Bram Moolenaar81330182022-02-01 12:11:58 +00001408 {
1409 *decl_type = argtypes[0].type_decl;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001410 return argtypes[0].type_curr;
Bram Moolenaar81330182022-02-01 12:11:58 +00001411 }
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001412 return &t_void;
1413}
Bram Moolenaar1780f082021-07-31 22:03:59 +02001414 static type_T *
Bram Moolenaar00eb9952022-02-05 19:23:18 +00001415ret_slice(int argcount,
1416 type2_T *argtypes,
1417 type_T **decl_type)
1418{
1419 if (argcount > 0)
1420 {
1421 if (argtypes[0].type_decl != NULL)
1422 {
1423 switch (argtypes[0].type_decl->tt_type)
1424 {
1425 case VAR_STRING: *decl_type = &t_string; break;
1426 case VAR_BLOB: *decl_type = &t_blob; break;
1427 case VAR_LIST: *decl_type = &t_list_any; break;
1428 default: break;
1429 }
1430 }
1431 return argtypes[0].type_curr;
1432 }
1433 return &t_void;
1434}
1435 static type_T *
Bram Moolenaar381692b2022-02-02 20:01:27 +00001436ret_copy(int argcount,
1437 type2_T *argtypes,
1438 type_T **decl_type)
1439{
1440 if (argcount > 0)
1441 {
1442 if (argtypes[0].type_decl != NULL)
1443 {
1444 if (argtypes[0].type_decl->tt_type == VAR_LIST)
1445 *decl_type = &t_list_any;
1446 else if (argtypes[0].type_decl->tt_type == VAR_DICT)
1447 *decl_type = &t_dict_any;
1448 else
1449 *decl_type = argtypes[0].type_decl;
1450 }
1451 if (argtypes[0].type_curr != NULL)
1452 {
1453 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1454 return &t_list_any;
1455 else if (argtypes[0].type_curr->tt_type == VAR_DICT)
1456 return &t_dict_any;
1457 }
1458 return argtypes[0].type_curr;
1459 }
1460 return &t_void;
1461}
1462 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001463ret_extend(int argcount,
1464 type2_T *argtypes,
1465 type_T **decl_type)
1466{
1467 if (argcount > 0)
1468 {
1469 *decl_type = argtypes[0].type_decl;
1470 // if the second argument has a different current type then the current
1471 // type is "any"
1472 if (argcount > 1 && !equal_type(argtypes[0].type_curr,
1473 argtypes[1].type_curr, 0))
1474 {
1475 if (argtypes[0].type_curr->tt_type == VAR_LIST)
1476 return &t_list_any;
1477 if (argtypes[0].type_curr->tt_type == VAR_DICT)
1478 return &t_dict_any;
1479 }
1480 return argtypes[0].type_curr;
1481 }
1482 return &t_void;
1483}
1484 static type_T *
1485ret_repeat(int argcount,
1486 type2_T *argtypes,
1487 type_T **decl_type UNUSED)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001488{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001489 if (argcount == 0)
1490 return &t_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001491 if (argtypes[0].type_curr == &t_number)
Bram Moolenaar1780f082021-07-31 22:03:59 +02001492 return &t_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001493 return argtypes[0].type_curr;
Bram Moolenaar1780f082021-07-31 22:03:59 +02001494}
Bram Moolenaarea696852020-11-09 18:31:39 +01001495// for map(): returns first argument but item type may differ
1496 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001497ret_first_cont(int argcount,
1498 type2_T *argtypes,
1499 type_T **decl_type UNUSED)
Bram Moolenaarea696852020-11-09 18:31:39 +01001500{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001501 if (argcount > 0)
1502 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001503 if (argtypes[0].type_curr->tt_type == VAR_LIST)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001504 return &t_list_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001505 if (argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001506 return &t_dict_any;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001507 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
1508 return argtypes[0].type_curr;
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001509 }
Bram Moolenaarea696852020-11-09 18:31:39 +01001510 return &t_any;
1511}
Bram Moolenaar078a4612022-01-04 15:17:03 +00001512// for getline()
1513 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001514ret_getline(int argcount,
1515 type2_T *argtypes UNUSED,
1516 type_T **decl_type UNUSED)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001517{
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001518 if (argcount == 1)
1519 return &t_string;
1520 *decl_type = &t_list_any;
1521 return &t_list_string;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001522}
Bram Moolenaar08018222021-12-22 18:45:37 +00001523// for finddir()
1524 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001525ret_finddir(int argcount,
1526 type2_T *argtypes UNUSED,
1527 type_T **decl_type UNUSED)
Bram Moolenaar08018222021-12-22 18:45:37 +00001528{
1529 if (argcount < 3)
1530 return &t_string;
1531 // Depending on the count would be a string or a list of strings.
1532 return &t_any;
1533}
Bram Moolenaar32517c42023-01-15 18:17:12 +00001534// for values(): list of member of first argument
1535 static type_T *
1536ret_list_member(int argcount,
1537 type2_T *argtypes,
1538 type_T **decl_type)
1539{
1540 if (argcount > 0)
1541 {
1542 type_T *t = argtypes[0].type_decl;
1543 if (current_type_gap != NULL
1544 && (t->tt_type == VAR_DICT || t->tt_type == VAR_LIST))
1545 t = get_list_type(t->tt_member, current_type_gap);
1546 else
1547 t = &t_list_any;
1548 *decl_type = t;
1549
1550 t = argtypes[0].type_curr;
1551 if (current_type_gap != NULL
1552 && (t->tt_type == VAR_DICT || t->tt_type == VAR_LIST))
1553 return get_list_type(t->tt_member, current_type_gap);
1554 }
1555 return &t_list_any;
1556}
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001557
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001558/*
1559 * Used for getqflist(): returns list if there is no argument, dict if there is
1560 * one.
1561 */
1562 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001563ret_list_or_dict_0(int argcount,
1564 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001565 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001566{
1567 if (argcount > 0)
1568 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001569 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001570 return &t_list_dict_any;
1571}
1572
1573/*
1574 * Used for getloclist(): returns list if there is one argument, dict if there
1575 * are two.
1576 */
1577 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001578ret_list_or_dict_1(int argcount,
1579 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001580 type_T **decl_type)
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001581{
1582 if (argcount > 1)
1583 return &t_dict_any;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001584 *decl_type = &t_list_any;
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001585 return &t_list_dict_any;
1586}
1587
Bram Moolenaar846178a2020-07-05 17:04:13 +02001588 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001589ret_argv(int argcount,
1590 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001591 type_T **decl_type)
Bram Moolenaar846178a2020-07-05 17:04:13 +02001592{
1593 // argv() returns list of strings
1594 if (argcount == 0)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001595 {
1596 *decl_type = &t_list_any;
Bram Moolenaar846178a2020-07-05 17:04:13 +02001597 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001598 }
Bram Moolenaar846178a2020-07-05 17:04:13 +02001599
1600 // argv(0) returns a string, but argv(-1] returns a list
1601 return &t_any;
1602}
1603
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001604 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001605ret_remove(int argcount,
1606 type2_T *argtypes,
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001607 type_T **decl_type)
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001608{
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02001609 if (argcount > 0)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001610 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001611 if (argtypes[0].type_curr->tt_type == VAR_LIST
1612 || argtypes[0].type_curr->tt_type == VAR_DICT)
Bram Moolenaar81330182022-02-01 12:11:58 +00001613 {
Bram Moolenaar2ac037f2022-05-09 14:12:14 +01001614 if (argcount == 3)
1615 {
1616 *decl_type = argtypes[0].type_decl;
1617 return argtypes[0].type_curr;
1618 }
Bram Moolenaar81330182022-02-01 12:11:58 +00001619 if (argtypes[0].type_curr->tt_type
1620 == argtypes[0].type_decl->tt_type)
1621 *decl_type = argtypes[0].type_decl->tt_member;
Bram Moolenaar078a4612022-01-04 15:17:03 +00001622 return argtypes[0].type_curr->tt_member;
Bram Moolenaar81330182022-02-01 12:11:58 +00001623 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001624 if (argtypes[0].type_curr->tt_type == VAR_BLOB)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001625 return &t_number;
1626 }
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001627 return &t_any;
1628}
1629
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001630 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001631ret_getreg(int argcount,
1632 type2_T *argtypes UNUSED,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001633 type_T **decl_type)
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001634{
1635 // Assume that if the third argument is passed it's non-zero
1636 if (argcount == 3)
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001637 {
1638 *decl_type = &t_list_any;
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001639 return &t_list_string;
Bram Moolenaar82e46e52022-02-05 18:12:34 +00001640 }
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001641 return &t_string;
1642}
1643
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001644 static type_T *
LemonBoy0f7a3e12022-05-26 12:10:37 +01001645ret_virtcol(int argcount,
1646 type2_T *argtypes UNUSED,
1647 type_T **decl_type)
1648{
1649 // Assume that if the second argument is passed it's non-zero
zeertzjq825cf812023-08-17 22:55:25 +02001650 if (argcount > 1)
LemonBoy0f7a3e12022-05-26 12:10:37 +01001651 {
1652 *decl_type = &t_list_any;
1653 return &t_list_number;
1654 }
1655 return &t_number;
1656}
1657
1658 static type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00001659ret_maparg(int argcount,
1660 type2_T *argtypes UNUSED,
1661 type_T **decl_type UNUSED)
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +02001662{
1663 // Assume that if the fourth argument is passed it's non-zero
1664 if (argcount == 4)
1665 return &t_dict_any;
1666 return &t_string;
1667}
1668
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001669/*
1670 * Array with names and number of arguments of all internal functions
1671 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
Ernie Rael2025af12023-12-12 16:58:00 +01001672 *
Ernie Raela8f7f922023-12-14 20:17:04 +01001673 * The builtin function may be varargs. In that case
Ernie Rael2025af12023-12-12 16:58:00 +01001674 * - f_max_argc == VARGS
Ernie Raela8f7f922023-12-14 20:17:04 +01001675 * - For varargs, f_argcheck must be NULL terminated. The last non-null
1676 * entry in f_argcheck should validate all the remaining args.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001677 */
Bram Moolenaarac92e252019-08-03 21:58:38 +02001678typedef struct
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001679{
Bram Moolenaar25e42232019-08-04 15:04:10 +02001680 char *f_name; // function name
1681 char f_min_argc; // minimal number of arguments
1682 char f_max_argc; // maximal number of arguments
Ernie Raeld8bf87c2023-12-16 14:03:33 +01001683 char f_argtype; // for method: FEARG_ values; bits FE_
Ernie Raela8f7f922023-12-14 20:17:04 +01001684 argcheck_T *f_argcheck; // list of functions to check argument types;
1685 // use "arg_any" (not NULL) to accept an
1686 // argument of any type
Bram Moolenaar81330182022-02-01 12:11:58 +00001687 type_T *(*f_retfunc)(int argcount, type2_T *argtypes,
1688 type_T **decl_type);
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001689 // return type function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001690 void (*f_func)(typval_T *args, typval_T *rvar);
Bram Moolenaar25e42232019-08-04 15:04:10 +02001691 // implementation of function
Bram Moolenaarac92e252019-08-03 21:58:38 +02001692} funcentry_T;
1693
Ernie Rael2025af12023-12-12 16:58:00 +01001694// Set f_max_argc to VARGS for varargs.
1695#define VARGS CHAR_MAX
1696
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001697// values for f_argtype; zero means it cannot be used as a method
Ernie Raeld8bf87c2023-12-16 14:03:33 +01001698#define FEARG_1 0x01 // base is the first argument
1699#define FEARG_2 0x02 // base is the second argument
1700#define FEARG_3 0x03 // base is the third argument
1701#define FEARG_4 0x04 // base is the fourth argument
1702#define FEARG_MASK 0x0F // bits in f_argtype used as argument index
1703#define FE_X 0x10 // builtin accepts a non-value (class, typealias)
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001704
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001705#if defined(HAVE_MATH_H)
Bram Moolenaar15c47602020-03-26 22:16:48 +01001706# define MATH_FUNC(name) name
1707#else
1708# define MATH_FUNC(name) NULL
1709#endif
1710#ifdef FEAT_TIMERS
1711# define TIMER_FUNC(name) name
1712#else
1713# define TIMER_FUNC(name) NULL
1714#endif
1715#ifdef FEAT_JOB_CHANNEL
1716# define JOB_FUNC(name) name
1717#else
1718# define JOB_FUNC(name) NULL
1719#endif
1720#ifdef FEAT_PROP_POPUP
1721# define PROP_FUNC(name) name
1722#else
1723# define PROP_FUNC(name) NULL
1724#endif
1725#ifdef FEAT_SIGNS
1726# define SIGN_FUNC(name) name
1727#else
1728# define SIGN_FUNC(name) NULL
1729#endif
1730#ifdef FEAT_SOUND
1731# define SOUND_FUNC(name) name
1732#else
1733# define SOUND_FUNC(name) NULL
1734#endif
1735#ifdef FEAT_TERMINAL
1736# define TERM_FUNC(name) name
1737#else
1738# define TERM_FUNC(name) NULL
1739#endif
1740
Bram Moolenaarac92e252019-08-03 21:58:38 +02001741static funcentry_T global_functions[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001742{
Bram Moolenaar94738d82020-10-21 14:25:07 +02001743 {"abs", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001744 ret_any, f_abs},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001745 {"acos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001746 ret_float, f_acos},
Bram Moolenaarfa103972022-09-29 19:14:42 +01001747 {"add", 2, 2, FEARG_1, arg2_listblobmod_item,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001748 ret_first_arg, f_add},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001749 {"and", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001750 ret_number, f_and},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001751 {"append", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001752 ret_number_bool, f_append},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001753 {"appendbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001754 ret_number_bool, f_appendbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001755 {"argc", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001756 ret_number, f_argc},
1757 {"argidx", 0, 0, 0, NULL,
1758 ret_number, f_argidx},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001759 {"arglistid", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001760 ret_number, f_arglistid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001761 {"argv", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001762 ret_argv, f_argv},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001763 {"asin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001764 ret_float, f_asin},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001765 {"assert_beeps", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001766 ret_number_bool, f_assert_beeps},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001767 {"assert_equal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001768 ret_number_bool, f_assert_equal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001769 {"assert_equalfile", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001770 ret_number_bool, f_assert_equalfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001771 {"assert_exception", 1, 2, 0, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001772 ret_number_bool, f_assert_exception},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001773 {"assert_fails", 1, 5, FEARG_1, arg15_assert_fails,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001774 ret_number_bool, f_assert_fails},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001775 {"assert_false", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001776 ret_number_bool, f_assert_false},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02001777 {"assert_inrange", 3, 4, FEARG_3, arg34_assert_inrange,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001778 ret_number_bool, f_assert_inrange},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001779 {"assert_match", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001780 ret_number_bool, f_assert_match},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001781 {"assert_nobeep", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar5b8cabf2021-04-02 18:55:57 +02001782 ret_number_bool, f_assert_nobeep},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001783 {"assert_notequal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001784 ret_number_bool, f_assert_notequal},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001785 {"assert_notmatch", 2, 3, FEARG_2, arg3_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001786 ret_number_bool, f_assert_notmatch},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001787 {"assert_report", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001788 ret_number_bool, f_assert_report},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001789 {"assert_true", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001790 ret_number_bool, f_assert_true},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001791 {"atan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001792 ret_float, f_atan},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001793 {"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001794 ret_float, f_atan2},
Yegappan Lakshmanan1755a912022-05-19 10:31:47 +01001795 {"autocmd_add", 1, 1, FEARG_1, arg1_list_any,
1796 ret_number_bool, f_autocmd_add},
1797 {"autocmd_delete", 1, 1, FEARG_1, arg1_list_any,
1798 ret_number_bool, f_autocmd_delete},
1799 {"autocmd_get", 0, 1, FEARG_1, arg1_dict_any,
1800 ret_list_dict_any, f_autocmd_get},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001801 {"balloon_gettext", 0, 0, 0, NULL,
1802 ret_string,
Bram Moolenaar59716a22017-03-01 20:32:44 +01001803#ifdef FEAT_BEVAL
Bram Moolenaar15c47602020-03-26 22:16:48 +01001804 f_balloon_gettext
1805#else
1806 NULL
Bram Moolenaar59716a22017-03-01 20:32:44 +01001807#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001808 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02001809 {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001810 ret_void,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001811#ifdef FEAT_BEVAL
1812 f_balloon_show
1813#else
1814 NULL
1815#endif
1816 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001817 {"balloon_split", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001818 ret_list_string,
Bram Moolenaar15c47602020-03-26 22:16:48 +01001819#if defined(FEAT_BEVAL_TERM)
1820 f_balloon_split
1821#else
1822 NULL
1823#endif
1824 },
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02001825 {"blob2list", 1, 1, FEARG_1, arg1_blob,
1826 ret_list_number, f_blob2list},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001827 {"browse", 4, 4, 0, arg4_browse,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001828 ret_string, f_browse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001829 {"browsedir", 2, 2, 0, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001830 ret_string, f_browsedir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001831 {"bufadd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001832 ret_number, f_bufadd},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001833 {"bufexists", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001834 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001835 {"buffer_exists", 1, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001836 ret_number_bool, f_bufexists},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001837 {"buffer_name", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001838 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001839 {"buffer_number", 0, 1, FEARG_1, arg1_buffer, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001840 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001841 {"buflisted", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001842 ret_number_bool, f_buflisted},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001843 {"bufload", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001844 ret_void, f_bufload},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001845 {"bufloaded", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001846 ret_number_bool, f_bufloaded},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001847 {"bufname", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001848 ret_string, f_bufname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001849 {"bufnr", 0, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001850 ret_number, f_bufnr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001851 {"bufwinid", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001852 ret_number, f_bufwinid},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001853 {"bufwinnr", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001854 ret_number, f_bufwinnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001855 {"byte2line", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001856 ret_number, f_byte2line},
Christian Brabandt67672ef2023-04-24 21:09:54 +01001857 {"byteidx", 2, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001858 ret_number, f_byteidx},
Christian Brabandt67672ef2023-04-24 21:09:54 +01001859 {"byteidxcomp", 2, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001860 ret_number, f_byteidxcomp},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02001861 {"call", 2, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001862 ret_any, f_call},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001863 {"ceil", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001864 ret_float, f_ceil},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001865 {"ch_canread", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001866 ret_number_bool, JOB_FUNC(f_ch_canread)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001867 {"ch_close", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001868 ret_void, JOB_FUNC(f_ch_close)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001869 {"ch_close_in", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001870 ret_void, JOB_FUNC(f_ch_close_in)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001871 {"ch_evalexpr", 2, 3, FEARG_1, arg23_chanexpr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001872 ret_any, JOB_FUNC(f_ch_evalexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001873 {"ch_evalraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001874 ret_any, JOB_FUNC(f_ch_evalraw)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001875 {"ch_getbufnr", 2, 2, FEARG_1, arg2_chan_or_job_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001876 ret_number, JOB_FUNC(f_ch_getbufnr)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001877 {"ch_getjob", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001878 ret_job, JOB_FUNC(f_ch_getjob)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001879 {"ch_info", 1, 1, FEARG_1, arg1_chan_or_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001880 ret_dict_any, JOB_FUNC(f_ch_info)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001881 {"ch_log", 1, 2, FEARG_1, arg2_string_chan_or_job,
Bram Moolenaar4c5678f2022-11-30 18:12:19 +00001882 ret_void, f_ch_log},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001883 {"ch_logfile", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar4c5678f2022-11-30 18:12:19 +00001884 ret_void, f_ch_logfile},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001885 {"ch_open", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001886 ret_channel, JOB_FUNC(f_ch_open)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001887 {"ch_read", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001888 ret_string, JOB_FUNC(f_ch_read)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001889 {"ch_readblob", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001890 ret_blob, JOB_FUNC(f_ch_readblob)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001891 {"ch_readraw", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001892 ret_string, JOB_FUNC(f_ch_readraw)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001893 {"ch_sendexpr", 2, 3, FEARG_1, arg23_chanexpr,
Yegappan Lakshmanan3b470ae2022-04-16 10:41:27 +01001894 ret_any, JOB_FUNC(f_ch_sendexpr)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001895 {"ch_sendraw", 2, 3, FEARG_1, arg23_chanraw,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001896 ret_void, JOB_FUNC(f_ch_sendraw)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001897 {"ch_setoptions", 2, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001898 ret_void, JOB_FUNC(f_ch_setoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001899 {"ch_status", 1, 2, FEARG_1, arg2_chan_or_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001900 ret_string, JOB_FUNC(f_ch_status)},
1901 {"changenr", 0, 0, 0, NULL,
1902 ret_number, f_changenr},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001903 {"char2nr", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001904 ret_number, f_char2nr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001905 {"charclass", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001906 ret_number, f_charclass},
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001907 {"charcol", 1, 2, FEARG_1, arg2_string_or_list_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001908 ret_number, f_charcol},
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001909 {"charidx", 2, 4, FEARG_1, arg4_string_number_bool_bool,
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001910 ret_number, f_charidx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001911 {"chdir", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001912 ret_string, f_chdir},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001913 {"cindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001914 ret_number, f_cindent},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001915 {"clearmatches", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001916 ret_void, f_clearmatches},
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001917 {"col", 1, 2, FEARG_1, arg2_string_or_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001918 ret_number, f_col},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001919 {"complete", 2, 2, FEARG_2, arg2_number_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001920 ret_void, f_complete},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001921 {"complete_add", 1, 1, FEARG_1, arg1_dict_or_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001922 ret_number, f_complete_add},
1923 {"complete_check", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001924 ret_number_bool, f_complete_check},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001925 {"complete_info", 0, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001926 ret_dict_any, f_complete_info},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001927 {"confirm", 1, 4, FEARG_1, arg4_string_string_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001928 ret_number, f_confirm},
1929 {"copy", 1, 1, FEARG_1, NULL,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001930 ret_copy, f_copy},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001931 {"cos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001932 ret_float, f_cos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001933 {"cosh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001934 ret_float, f_cosh},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001935 {"count", 2, 4, FEARG_1, arg24_count,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001936 ret_number, f_count},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02001937 {"cscope_connection",0,3, 0, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001938 ret_number, f_cscope_connection},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001939 {"cursor", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001940 ret_number, f_cursor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001941 {"debugbreak", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001942 ret_number,
Bram Moolenaar4f974752019-02-17 17:44:42 +01001943#ifdef MSWIN
Bram Moolenaar15c47602020-03-26 22:16:48 +01001944 f_debugbreak
1945#else
1946 NULL
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02001947#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001948 },
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001949 {"deepcopy", 1, 2, FEARG_1, arg12_deepcopy,
Bram Moolenaar381692b2022-02-02 20:01:27 +00001950 ret_copy, f_deepcopy},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02001951 {"delete", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001952 ret_number_bool, f_delete},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001953 {"deletebufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001954 ret_number_bool, f_deletebufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001955 {"did_filetype", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001956 ret_number_bool, f_did_filetype},
Yegappan Lakshmananfa378352024-02-01 22:05:27 +01001957 {"diff", 2, 3, FEARG_1, arg3_diff,
Yegappan Lakshmanana0010a12024-02-12 20:21:26 +01001958 ret_any, f_diff},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001959 {"diff_filler", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001960 ret_number, f_diff_filler},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02001961 {"diff_hlID", 2, 2, FEARG_1, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001962 ret_number, f_diff_hlID},
h-east29b85712021-07-26 21:54:04 +02001963 {"digraph_get", 1, 1, FEARG_1, arg1_string,
1964 ret_string, f_digraph_get},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001965 {"digraph_getlist",0, 1, FEARG_1, arg1_bool,
h-east29b85712021-07-26 21:54:04 +02001966 ret_list_string_items, f_digraph_getlist},
Yegappan Lakshmananfc3b7752021-09-08 14:57:42 +02001967 {"digraph_set", 2, 2, FEARG_1, arg2_string,
h-east29b85712021-07-26 21:54:04 +02001968 ret_bool, f_digraph_set},
1969 {"digraph_setlist",1, 1, FEARG_1, arg1_list_string,
1970 ret_bool, f_digraph_setlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001971 {"echoraw", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001972 ret_void, f_echoraw},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001973 {"empty", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001974 ret_number_bool, f_empty},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001975 {"environ", 0, 0, 0, NULL,
1976 ret_dict_string, f_environ},
Bram Moolenaar80adaa82023-07-07 18:57:40 +01001977 {"err_teapot", 0, 1, 0, NULL,
1978 ret_number_bool, f_err_teapot},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001979 {"escape", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001980 ret_string, f_escape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001981 {"eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001982 ret_any, f_eval},
1983 {"eventhandler", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001984 ret_number_bool, f_eventhandler},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001985 {"executable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001986 ret_number, f_executable},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02001987 {"execute", 1, 2, FEARG_1, arg12_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001988 ret_string, f_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001989 {"exepath", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001990 ret_string, f_exepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001991 {"exists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001992 ret_number_bool, f_exists},
Bram Moolenaar26735992021-08-08 14:43:22 +02001993 {"exists_compiled", 1, 1, FEARG_1, arg1_string,
1994 ret_number_bool, f_exists_compiled},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001995 {"exp", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001996 ret_float, f_exp},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001997 {"expand", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001998 ret_any, f_expand},
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01001999 {"expandcmd", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002000 ret_string, f_expandcmd},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +01002001 {"extend", 2, 3, FEARG_1, arg23_extend,
Bram Moolenaar81330182022-02-01 12:11:58 +00002002 ret_extend, f_extend},
Bram Moolenaarb0e6b512021-01-12 20:23:40 +01002003 {"extendnew", 2, 3, FEARG_1, arg23_extendnew,
2004 ret_first_cont, f_extendnew},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002005 {"feedkeys", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002006 ret_void, f_feedkeys},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002007 {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002008 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002009 {"filereadable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002010 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002011 {"filewritable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002012 ret_number, f_filewritable},
Bram Moolenaar18024052021-12-25 21:43:28 +00002013 {"filter", 2, 2, FEARG_1, arg2_filter,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002014 ret_first_arg, f_filter},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002015 {"finddir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar08018222021-12-22 18:45:37 +00002016 ret_finddir, f_finddir},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002017 {"findfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar10c83dd2021-09-04 14:49:56 +02002018 ret_any, f_findfile},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002019 {"flatten", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002020 ret_list_any, f_flatten},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002021 {"flattennew", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3b690062021-02-01 20:14:51 +01002022 ret_list_any, f_flattennew},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002023 {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002024 ret_number, f_float2nr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002025 {"floor", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002026 ret_float, f_floor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002027 {"fmod", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002028 ret_float, f_fmod},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002029 {"fnameescape", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002030 ret_string, f_fnameescape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002031 {"fnamemodify", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002032 ret_string, f_fnamemodify},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002033 {"foldclosed", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002034 ret_number, f_foldclosed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002035 {"foldclosedend", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002036 ret_number, f_foldclosedend},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002037 {"foldlevel", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002038 ret_number, f_foldlevel},
2039 {"foldtext", 0, 0, 0, NULL,
2040 ret_string, f_foldtext},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002041 {"foldtextresult", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002042 ret_string, f_foldtextresult},
Ernie Raele79e2072024-01-13 11:47:33 +01002043 {"foreach", 2, 2, FEARG_1, arg2_foreach,
2044 ret_first_arg, f_foreach},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002045 {"foreground", 0, 0, 0, NULL,
2046 ret_void, f_foreground},
Bram Moolenaardd44b582022-09-15 22:03:57 +01002047 {"fullcommand", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar038e09e2021-02-06 12:38:51 +01002048 ret_string, f_fullcommand},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002049 {"funcref", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00002050 ret_func_unknown, f_funcref},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002051 {"function", 1, 3, FEARG_1, arg3_any_list_dict,
Bram Moolenaar2f9f4cc2021-12-20 09:36:27 +00002052 ret_func_unknown, f_function},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002053 {"garbagecollect", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002054 ret_void, f_garbagecollect},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002055 {"get", 2, 3, FEARG_1, arg23_get,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002056 ret_any, f_get},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002057 {"getbufinfo", 0, 1, FEARG_1, arg1_buffer_or_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002058 ret_list_dict_any, f_getbufinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002059 {"getbufline", 2, 3, FEARG_1, arg3_buffer_lnum_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002060 ret_list_string, f_getbufline},
Bram Moolenaarce30ccc2022-11-21 19:57:04 +00002061 {"getbufoneline", 2, 2, FEARG_1, arg2_buffer_lnum,
2062 ret_string, f_getbufoneline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002063 {"getbufvar", 2, 3, FEARG_1, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002064 ret_any, f_getbufvar},
Kota Kato66bb9ae2023-01-17 18:31:56 +00002065 {"getcellwidths", 0, 0, 0, NULL,
2066 ret_list_any, f_getcellwidths},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002067 {"getchangelist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002068 ret_list_any, f_getchangelist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002069 {"getchar", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02002070 ret_any, f_getchar},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002071 {"getcharmod", 0, 0, 0, NULL,
2072 ret_number, f_getcharmod},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002073 {"getcharpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002074 ret_list_number, f_getcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002075 {"getcharsearch", 0, 0, 0, NULL,
2076 ret_dict_any, f_getcharsearch},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002077 {"getcharstr", 0, 1, 0, arg1_bool,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02002078 ret_string, f_getcharstr},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01002079 {"getcmdcompltype", 0, 0, 0, NULL,
2080 ret_string, f_getcmdcompltype},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002081 {"getcmdline", 0, 0, 0, NULL,
2082 ret_string, f_getcmdline},
2083 {"getcmdpos", 0, 0, 0, NULL,
2084 ret_number, f_getcmdpos},
Shougo Matsushita79d599b2022-05-07 12:48:29 +01002085 {"getcmdscreenpos", 0, 0, 0, NULL,
2086 ret_number, f_getcmdscreenpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002087 {"getcmdtype", 0, 0, 0, NULL,
2088 ret_string, f_getcmdtype},
2089 {"getcmdwintype", 0, 0, 0, NULL,
2090 ret_string, f_getcmdwintype},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002091 {"getcompletion", 2, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002092 ret_list_string, f_getcompletion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002093 {"getcurpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002094 ret_list_number, f_getcurpos},
Bram Moolenaar82e46e52022-02-05 18:12:34 +00002095 {"getcursorcharpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002096 ret_list_number, f_getcursorcharpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002097 {"getcwd", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002098 ret_string, f_getcwd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002099 {"getenv", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar7ad67d12021-03-10 16:08:26 +01002100 ret_any, f_getenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002101 {"getfontname", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002102 ret_string, f_getfontname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002103 {"getfperm", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002104 ret_string, f_getfperm},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002105 {"getfsize", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002106 ret_number, f_getfsize},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002107 {"getftime", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002108 ret_number, f_getftime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002109 {"getftype", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002110 ret_string, f_getftype},
2111 {"getimstatus", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002112 ret_number_bool, f_getimstatus},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002113 {"getjumplist", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002114 ret_list_any, f_getjumplist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002115 {"getline", 1, 2, FEARG_1, arg2_lnum,
Bram Moolenaar078a4612022-01-04 15:17:03 +00002116 ret_getline, f_getline},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002117 {"getloclist", 1, 2, 0, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002118 ret_list_or_dict_1, f_getloclist},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002119 {"getmarklist", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002120 ret_list_dict_any, f_getmarklist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002121 {"getmatches", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002122 ret_list_dict_any, f_getmatches},
2123 {"getmousepos", 0, 0, 0, NULL,
2124 ret_dict_number, f_getmousepos},
Bram Moolenaar24dc19c2022-11-14 19:49:15 +00002125 {"getmouseshape", 0, 0, 0, NULL,
2126 ret_string, f_getmouseshape},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002127 {"getpid", 0, 0, 0, NULL,
2128 ret_number, f_getpid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002129 {"getpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002130 ret_list_number, f_getpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002131 {"getqflist", 0, 1, 0, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002132 ret_list_or_dict_0, f_getqflist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002133 {"getreg", 0, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002134 ret_getreg, f_getreg},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002135 {"getreginfo", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002136 ret_dict_any, f_getreginfo},
Shougo Matsushita19b71882024-02-28 22:48:12 +01002137 {"getregion", 2, 3, FEARG_1, arg3_list_list_dict,
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01002138 ret_list_string, f_getregion},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002139 {"getregtype", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002140 ret_string, f_getregtype},
Yegappan Lakshmanan520f6ef2022-08-25 17:40:40 +01002141 {"getscriptinfo", 0, 1, 0, arg1_dict_any,
Yegappan Lakshmananf768c3d2022-08-22 13:15:13 +01002142 ret_list_dict_any, f_getscriptinfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002143 {"gettabinfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002144 ret_list_dict_any, f_gettabinfo},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002145 {"gettabvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002146 ret_any, f_gettabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002147 {"gettabwinvar", 3, 4, FEARG_1, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002148 ret_any, f_gettabwinvar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002149 {"gettagstack", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002150 ret_dict_any, f_gettagstack},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002151 {"gettext", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002152 ret_string, f_gettext},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002153 {"getwininfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002154 ret_list_dict_any, f_getwininfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002155 {"getwinpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002156 ret_list_number, f_getwinpos},
2157 {"getwinposx", 0, 0, 0, NULL,
2158 ret_number, f_getwinposx},
2159 {"getwinposy", 0, 0, 0, NULL,
2160 ret_number, f_getwinposy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002161 {"getwinvar", 2, 3, FEARG_1, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002162 ret_any, f_getwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002163 {"glob", 1, 4, FEARG_1, arg14_glob,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002164 ret_any, f_glob},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002165 {"glob2regpat", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002166 ret_string, f_glob2regpat},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002167 {"globpath", 2, 5, FEARG_2, arg25_globpath,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002168 ret_any, f_globpath},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002169 {"has", 1, 2, 0, arg2_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002170 ret_number_bool, f_has},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002171 {"has_key", 2, 2, FEARG_1, arg2_dict_any_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002172 ret_number_bool, f_has_key},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002173 {"haslocaldir", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002174 ret_number, f_haslocaldir},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002175 {"hasmapto", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002176 ret_number_bool, f_hasmapto},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002177 {"highlightID", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02002178 ret_number, f_hlID},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002179 {"highlight_exists",1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002180 ret_number_bool, f_hlexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002181 {"histadd", 2, 2, FEARG_2, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002182 ret_number_bool, f_histadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002183 {"histdel", 1, 2, FEARG_1, arg2_string_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002184 ret_number_bool, f_histdel},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002185 {"histget", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002186 ret_string, f_histget},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002187 {"histnr", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002188 ret_number, f_histnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002189 {"hlID", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002190 ret_number, f_hlID},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002191 {"hlexists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002192 ret_number_bool, f_hlexists},
Yegappan Lakshmanand1a8d652021-11-03 21:56:45 +00002193 {"hlget", 0, 2, FEARG_1, arg2_string_bool,
2194 ret_list_dict_any, f_hlget},
2195 {"hlset", 1, 1, FEARG_1, arg1_list_any,
2196 ret_number_bool, f_hlset},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002197 {"hostname", 0, 0, 0, NULL,
2198 ret_string, f_hostname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002199 {"iconv", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002200 ret_string, f_iconv},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002201 {"indent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002202 ret_number, f_indent},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002203 {"index", 2, 4, FEARG_1, arg24_index,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002204 ret_number, f_index},
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01002205 {"indexof", 2, 3, FEARG_1, arg23_index,
2206 ret_number, f_indexof},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002207 {"input", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002208 ret_string, f_input},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002209 {"inputdialog", 1, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002210 ret_string, f_inputdialog},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002211 {"inputlist", 1, 1, FEARG_1, arg1_list_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002212 ret_number, f_inputlist},
2213 {"inputrestore", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002214 ret_number_bool, f_inputrestore},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002215 {"inputsave", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002216 ret_number_bool, f_inputsave},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002217 {"inputsecret", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002218 ret_string, f_inputsecret},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002219 {"insert", 2, 3, FEARG_1, arg23_insert,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002220 ret_first_arg, f_insert},
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002221 {"instanceof", 2, VARGS, FEARG_1|FE_X, arg2_instanceof,
LemonBoyafe04662023-08-23 21:08:11 +02002222 ret_bool, f_instanceof},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002223 {"interrupt", 0, 0, 0, NULL,
2224 ret_void, f_interrupt},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002225 {"invert", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002226 ret_number, f_invert},
LemonBoydca1d402022-04-28 15:26:33 +01002227 {"isabsolutepath", 1, 1, FEARG_1, arg1_string,
2228 ret_number_bool, f_isabsolutepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002229 {"isdirectory", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002230 ret_number_bool, f_isdirectory},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002231 {"isinf", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002232 ret_number, MATH_FUNC(f_isinf)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002233 {"islocked", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002234 ret_number_bool, f_islocked},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002235 {"isnan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002236 ret_number_bool, MATH_FUNC(f_isnan)},
Bram Moolenaar3e518a82022-08-30 17:45:33 +01002237 {"items", 1, 1, FEARG_1, arg1_string_or_list_or_dict,
Bram Moolenaarefc5db52021-07-07 21:21:30 +02002238 ret_list_items, f_items},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002239 {"job_getchannel", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002240 ret_channel, JOB_FUNC(f_job_getchannel)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002241 {"job_info", 0, 1, FEARG_1, arg1_job,
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01002242 ret_job_info, JOB_FUNC(f_job_info)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002243 {"job_setoptions", 2, 2, FEARG_1, arg2_job_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002244 ret_void, JOB_FUNC(f_job_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002245 {"job_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002246 ret_job, JOB_FUNC(f_job_start)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002247 {"job_status", 1, 1, FEARG_1, arg1_job,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002248 ret_string, JOB_FUNC(f_job_status)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002249 {"job_stop", 1, 2, FEARG_1, arg2_job_string_or_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002250 ret_number_bool, JOB_FUNC(f_job_stop)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002251 {"join", 1, 2, FEARG_1, arg2_list_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002252 ret_string, f_join},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002253 {"js_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002254 ret_any, f_js_decode},
2255 {"js_encode", 1, 1, FEARG_1, NULL,
2256 ret_string, f_js_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002257 {"json_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002258 ret_any, f_json_decode},
2259 {"json_encode", 1, 1, FEARG_1, NULL,
2260 ret_string, f_json_encode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002261 {"keys", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002262 ret_list_string, f_keys},
zeertzjqcdc83932022-09-12 13:38:41 +01002263 {"keytrans", 1, 1, FEARG_1, arg1_string,
2264 ret_string, f_keytrans},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002265 {"last_buffer_nr", 0, 0, 0, NULL, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02002266 ret_number, f_last_buffer_nr},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002267 {"len", 1, 1, FEARG_1, arg1_len,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002268 ret_number, f_len},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002269 {"libcall", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002270 ret_string, f_libcall},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002271 {"libcallnr", 3, 3, FEARG_3, arg3_libcall,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002272 ret_number, f_libcallnr},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002273 {"line", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002274 ret_number, f_line},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002275 {"line2byte", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002276 ret_number, f_line2byte},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002277 {"lispindent", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002278 ret_number, f_lispindent},
Yegappan Lakshmanan5dfe4672021-09-14 17:54:30 +02002279 {"list2blob", 1, 1, FEARG_1, arg1_list_number,
2280 ret_blob, f_list2blob},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002281 {"list2str", 1, 2, FEARG_1, arg2_list_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002282 ret_string, f_list2str},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002283 {"listener_add", 1, 2, FEARG_2, arg2_any_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002284 ret_number, f_listener_add},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002285 {"listener_flush", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002286 ret_void, f_listener_flush},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002287 {"listener_remove", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002288 ret_number_bool, f_listener_remove},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002289 {"localtime", 0, 0, 0, NULL,
2290 ret_number, f_localtime},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002291 {"log", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002292 ret_float, f_log},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002293 {"log10", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002294 ret_float, f_log10},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002295 {"luaeval", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002296 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002297#ifdef FEAT_LUA
Bram Moolenaar15c47602020-03-26 22:16:48 +01002298 f_luaeval
2299#else
2300 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002301#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002302 },
Bram Moolenaar18024052021-12-25 21:43:28 +00002303 {"map", 2, 2, FEARG_1, arg2_map,
Bram Moolenaarea696852020-11-09 18:31:39 +01002304 ret_first_cont, f_map},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002305 {"maparg", 1, 4, FEARG_1, arg14_maparg,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002306 ret_maparg, f_maparg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002307 {"mapcheck", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002308 ret_string, f_mapcheck},
Ernie Rael09661202022-04-25 14:40:44 +01002309 {"maplist", 0, 1, 0, arg1_bool,
2310 ret_list_dict_any, f_maplist},
Bram Moolenaar18024052021-12-25 21:43:28 +00002311 {"mapnew", 2, 2, FEARG_1, arg2_mapnew,
Bram Moolenaarea696852020-11-09 18:31:39 +01002312 ret_first_cont, f_mapnew},
Ernie Rael51d04d12022-05-04 15:40:22 +01002313 {"mapset", 1, 3, FEARG_1, arg3_string_or_dict_bool_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002314 ret_void, f_mapset},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002315 {"match", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002316 ret_any, f_match},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002317 {"matchadd", 2, 5, FEARG_1, arg25_matchadd,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002318 ret_number, f_matchadd},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002319 {"matchaddpos", 2, 5, FEARG_1, arg25_matchaddpos,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002320 ret_number, f_matchaddpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002321 {"matcharg", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002322 ret_list_string, f_matcharg},
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +01002323 {"matchbufline", 4, 5, FEARG_1, arg45_matchbufline,
2324 ret_list_any, f_matchbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002325 {"matchdelete", 1, 2, FEARG_1, arg2_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002326 ret_number_bool, f_matchdelete},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002327 {"matchend", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002328 ret_number, f_matchend},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002329 {"matchfuzzy", 2, 3, FEARG_1, arg3_list_string_dict,
Yegappan Lakshmanan2d8e9982023-06-24 16:42:25 +01002330 ret_list_any, f_matchfuzzy},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002331 {"matchfuzzypos", 2, 3, FEARG_1, arg3_list_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002332 ret_list_any, f_matchfuzzypos},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002333 {"matchlist", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002334 ret_list_string, f_matchlist},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002335 {"matchstr", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002336 ret_string, f_matchstr},
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +01002337 {"matchstrlist", 2, 3, FEARG_1, arg23_matchstrlist,
2338 ret_list_any, f_matchstrlist},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002339 {"matchstrpos", 2, 4, FEARG_1, arg24_match_func,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002340 ret_list_any, f_matchstrpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002341 {"max", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002342 ret_number, f_max},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002343 {"menu_info", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002344 ret_dict_any,
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002345#ifdef FEAT_MENU
Bram Moolenaar15c47602020-03-26 22:16:48 +01002346 f_menu_info
2347#else
2348 NULL
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01002349#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002350 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002351 {"min", 1, 1, FEARG_1, arg1_list_or_dict,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01002352 ret_number, f_min},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002353 {"mkdir", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002354 ret_number_bool, f_mkdir},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002355 {"mode", 0, 1, FEARG_1, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002356 ret_string, f_mode},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002357 {"mzeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002358 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002359#ifdef FEAT_MZSCHEME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002360 f_mzeval
2361#else
2362 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002363#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002364 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002365 {"nextnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002366 ret_number, f_nextnonblank},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002367 {"nr2char", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002368 ret_string, f_nr2char},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002369 {"or", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002370 ret_number, f_or},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002371 {"pathshorten", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002372 ret_string, f_pathshorten},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002373 {"perleval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002374 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002375#ifdef FEAT_PERL
Bram Moolenaar15c47602020-03-26 22:16:48 +01002376 f_perleval
2377#else
2378 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002379#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002380 },
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002381 {"popup_atcursor", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002382 ret_number, PROP_FUNC(f_popup_atcursor)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002383 {"popup_beval", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002384 ret_number, PROP_FUNC(f_popup_beval)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002385 {"popup_clear", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002386 ret_void, PROP_FUNC(f_popup_clear)},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002387 {"popup_close", 1, 2, FEARG_1, arg2_number_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002388 ret_void, PROP_FUNC(f_popup_close)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002389 {"popup_create", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002390 ret_number, PROP_FUNC(f_popup_create)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002391 {"popup_dialog", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002392 ret_number, PROP_FUNC(f_popup_dialog)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002393 {"popup_filter_menu", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002394 ret_bool, PROP_FUNC(f_popup_filter_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002395 {"popup_filter_yesno", 2, 2, 0, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002396 ret_bool, PROP_FUNC(f_popup_filter_yesno)},
Bram Moolenaarbdc09a12022-10-07 14:31:45 +01002397 {"popup_findecho", 0, 0, 0, NULL,
2398 ret_number, PROP_FUNC(f_popup_findecho)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002399 {"popup_findinfo", 0, 0, 0, NULL,
2400 ret_number, PROP_FUNC(f_popup_findinfo)},
2401 {"popup_findpreview", 0, 0, 0, NULL,
2402 ret_number, PROP_FUNC(f_popup_findpreview)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002403 {"popup_getoptions", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002404 ret_dict_any, PROP_FUNC(f_popup_getoptions)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002405 {"popup_getpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002406 ret_dict_any, PROP_FUNC(f_popup_getpos)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002407 {"popup_hide", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002408 ret_void, PROP_FUNC(f_popup_hide)},
2409 {"popup_list", 0, 0, 0, NULL,
2410 ret_list_number, PROP_FUNC(f_popup_list)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002411 {"popup_locate", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002412 ret_number, PROP_FUNC(f_popup_locate)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002413 {"popup_menu", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002414 ret_number, PROP_FUNC(f_popup_menu)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002415 {"popup_move", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002416 ret_void, PROP_FUNC(f_popup_move)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002417 {"popup_notification", 2, 2, FEARG_1, arg2_str_or_nr_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002418 ret_number, PROP_FUNC(f_popup_notification)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002419 {"popup_setoptions", 2, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002420 ret_void, PROP_FUNC(f_popup_setoptions)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002421 {"popup_settext", 2, 2, FEARG_1, arg2_number_string_or_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002422 ret_void, PROP_FUNC(f_popup_settext)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002423 {"popup_show", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002424 ret_void, PROP_FUNC(f_popup_show)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002425 {"pow", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002426 ret_float, f_pow},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002427 {"prevnonblank", 1, 1, FEARG_1, arg1_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002428 ret_number, f_prevnonblank},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002429 {"printf", 1, 19, FEARG_2, arg119_printf,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002430 ret_string, f_printf},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002431 {"prompt_getprompt", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002432 ret_string, JOB_FUNC(f_prompt_getprompt)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002433 {"prompt_setcallback", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002434 ret_void, JOB_FUNC(f_prompt_setcallback)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002435 {"prompt_setinterrupt", 2, 2, FEARG_1, arg2_buffer_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002436 ret_void, JOB_FUNC(f_prompt_setinterrupt)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002437 {"prompt_setprompt", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002438 ret_void, JOB_FUNC(f_prompt_setprompt)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002439 {"prop_add", 3, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01002440 ret_number, PROP_FUNC(f_prop_add)},
Yegappan Lakshmananccfb7c62021-08-16 21:39:09 +02002441 {"prop_add_list", 2, 2, FEARG_1, arg2_dict_any_list_any,
2442 ret_void, PROP_FUNC(f_prop_add_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002443 {"prop_clear", 1, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002444 ret_void, PROP_FUNC(f_prop_clear)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002445 {"prop_find", 1, 2, FEARG_1, arg2_dict_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002446 ret_dict_any, PROP_FUNC(f_prop_find)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002447 {"prop_list", 1, 2, FEARG_1, arg2_number_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002448 ret_list_dict_any, PROP_FUNC(f_prop_list)},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002449 {"prop_remove", 1, 3, FEARG_1, arg3_dict_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002450 ret_number, PROP_FUNC(f_prop_remove)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002451 {"prop_type_add", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002452 ret_void, PROP_FUNC(f_prop_type_add)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002453 {"prop_type_change", 2, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002454 ret_void, PROP_FUNC(f_prop_type_change)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002455 {"prop_type_delete", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002456 ret_void, PROP_FUNC(f_prop_type_delete)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002457 {"prop_type_get", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002458 ret_dict_any, PROP_FUNC(f_prop_type_get)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002459 {"prop_type_list", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002460 ret_list_string, PROP_FUNC(f_prop_type_list)},
2461 {"pum_getpos", 0, 0, 0, NULL,
2462 ret_dict_number, f_pum_getpos},
2463 {"pumvisible", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002464 ret_number_bool, f_pumvisible},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002465 {"py3eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002466 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002467#ifdef FEAT_PYTHON3
Bram Moolenaar15c47602020-03-26 22:16:48 +01002468 f_py3eval
2469#else
2470 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002471#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002472 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002473 {"pyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002474 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002475#ifdef FEAT_PYTHON
Bram Moolenaar15c47602020-03-26 22:16:48 +01002476 f_pyeval
2477#else
2478 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002479#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002480 },
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002481 {"pyxeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002482 ret_any,
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002483#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar15c47602020-03-26 22:16:48 +01002484 f_pyxeval
2485#else
2486 NULL
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01002487#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002488 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002489 {"rand", 0, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002490 ret_number, f_rand},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002491 {"range", 1, 3, FEARG_1, arg3_number,
Bram Moolenaar82e46e52022-02-05 18:12:34 +00002492 ret_list_number, f_range},
K.Takata11df3ae2022-10-19 14:02:40 +01002493 {"readblob", 1, 3, FEARG_1, arg3_string_number_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002494 ret_blob, f_readblob},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002495 {"readdir", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002496 ret_list_string, f_readdir},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002497 {"readdirex", 1, 3, FEARG_1, arg3_string_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002498 ret_list_dict_any, f_readdirex},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002499 {"readfile", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01002500 ret_list_string, f_readfile},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002501 {"reduce", 2, 3, FEARG_1, arg23_reduce,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002502 ret_any, f_reduce},
2503 {"reg_executing", 0, 0, 0, NULL,
2504 ret_string, f_reg_executing},
2505 {"reg_recording", 0, 0, 0, NULL,
2506 ret_string, f_reg_recording},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002507 {"reltime", 0, 2, FEARG_1, arg2_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002508 ret_list_any, f_reltime},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002509 {"reltimefloat", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002510 ret_float, f_reltimefloat},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002511 {"reltimestr", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002512 ret_string, f_reltimestr},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002513 {"remote_expr", 2, 4, FEARG_1, arg24_remote_expr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002514 ret_string, f_remote_expr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002515 {"remote_foreground", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002516 ret_string, f_remote_foreground},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002517 {"remote_peek", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002518 ret_number, f_remote_peek},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002519 {"remote_read", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002520 ret_string, f_remote_read},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002521 {"remote_send", 2, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002522 ret_string, f_remote_send},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002523 {"remote_startserver", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002524 ret_void, f_remote_startserver},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002525 {"remove", 2, 3, FEARG_1, arg23_remove,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002526 ret_remove, f_remove},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002527 {"rename", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002528 ret_number_bool, f_rename},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002529 {"repeat", 2, 2, FEARG_1, arg2_repeat,
Bram Moolenaar1780f082021-07-31 22:03:59 +02002530 ret_repeat, f_repeat},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002531 {"resolve", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002532 ret_string, f_resolve},
Yegappan Lakshmananf9dc2782023-05-11 15:02:56 +01002533 {"reverse", 1, 1, FEARG_1, arg1_string_or_list_or_blob_mod,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002534 ret_first_arg, f_reverse},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002535 {"round", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002536 ret_float, f_round},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002537 {"rubyeval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002538 ret_any,
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002539#ifdef FEAT_RUBY
Bram Moolenaar15c47602020-03-26 22:16:48 +01002540 f_rubyeval
2541#else
2542 NULL
Bram Moolenaare99be0e2019-03-26 22:51:09 +01002543#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002544 },
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002545 {"screenattr", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002546 ret_number, f_screenattr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002547 {"screenchar", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002548 ret_number, f_screenchar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002549 {"screenchars", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002550 ret_list_number, f_screenchars},
2551 {"screencol", 0, 0, 0, NULL,
2552 ret_number, f_screencol},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002553 {"screenpos", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002554 ret_dict_number, f_screenpos},
2555 {"screenrow", 0, 0, 0, NULL,
2556 ret_number, f_screenrow},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002557 {"screenstring", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002558 ret_string, f_screenstring},
Bram Moolenaarcd268012021-07-22 19:11:08 +02002559 {"search", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002560 ret_number, f_search},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002561 {"searchcount", 0, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002562 ret_dict_any, f_searchcount},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002563 {"searchdecl", 1, 3, FEARG_1, arg3_string_bool_bool,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002564 ret_number_bool, f_searchdecl},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002565 {"searchpair", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002566 ret_number, f_searchpair},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002567 {"searchpairpos", 3, 7, 0, arg37_searchpair,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002568 ret_list_number, f_searchpairpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002569 {"searchpos", 1, 5, FEARG_1, arg15_search,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002570 ret_list_number, f_searchpos},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002571 {"server2client", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002572 ret_number_bool, f_server2client},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002573 {"serverlist", 0, 0, 0, NULL,
2574 ret_string, f_serverlist},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002575 {"setbufline", 3, 3, FEARG_3, arg3_setbufline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002576 ret_number_bool, f_setbufline},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002577 {"setbufvar", 3, 3, FEARG_3, arg3_buffer_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002578 ret_void, f_setbufvar},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002579 {"setcellwidths", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002580 ret_void, f_setcellwidths},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002581 {"setcharpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002582 ret_number_bool, f_setcharpos},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002583 {"setcharsearch", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002584 ret_void, f_setcharsearch},
Shougo Matsushita07ea5f12022-08-27 12:22:25 +01002585 {"setcmdline", 1, 2, FEARG_1, arg2_string_number,
2586 ret_number_bool, f_setcmdline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002587 {"setcmdpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002588 ret_number_bool, f_setcmdpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002589 {"setcursorcharpos", 1, 3, FEARG_1, arg13_cursor,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002590 ret_number_bool, f_setcursorcharpos},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002591 {"setenv", 2, 2, FEARG_2, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002592 ret_void, f_setenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002593 {"setfperm", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002594 ret_number_bool, f_setfperm},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002595 {"setline", 2, 2, FEARG_2, arg2_setline,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002596 ret_number_bool, f_setline},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002597 {"setloclist", 2, 4, FEARG_2, arg24_setloclist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002598 ret_number_bool, f_setloclist},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002599 {"setmatches", 1, 2, FEARG_1, arg2_list_any_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002600 ret_number_bool, f_setmatches},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002601 {"setpos", 2, 2, FEARG_2, arg2_string_list_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002602 ret_number_bool, f_setpos},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002603 {"setqflist", 1, 3, FEARG_1, arg13_setqflist,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002604 ret_number_bool, f_setqflist},
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02002605 {"setreg", 2, 3, FEARG_2, arg3_string_any_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002606 ret_number_bool, f_setreg},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002607 {"settabvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002608 ret_void, f_settabvar},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002609 {"settabwinvar", 4, 4, FEARG_4, arg4_number_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002610 ret_void, f_settabwinvar},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002611 {"settagstack", 2, 3, FEARG_2, arg23_settagstack,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002612 ret_number_bool, f_settagstack},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002613 {"setwinvar", 3, 3, FEARG_3, arg3_number_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002614 ret_void, f_setwinvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002615 {"sha256", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002616 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002617#ifdef FEAT_CRYPT
Bram Moolenaar15c47602020-03-26 22:16:48 +01002618 f_sha256
2619#else
2620 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002621#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002622 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002623 {"shellescape", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002624 ret_string, f_shellescape},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002625 {"shiftwidth", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002626 ret_number, f_shiftwidth},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002627 {"sign_define", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002628 ret_any, SIGN_FUNC(f_sign_define)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002629 {"sign_getdefined", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002630 ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002631 {"sign_getplaced", 0, 2, FEARG_1, arg02_sign_getplaced,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002632 ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002633 {"sign_jump", 3, 3, FEARG_1, arg3_number_string_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002634 ret_number, SIGN_FUNC(f_sign_jump)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002635 {"sign_place", 4, 5, FEARG_1, arg45_sign_place,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002636 ret_number, SIGN_FUNC(f_sign_place)},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002637 {"sign_placelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002638 ret_list_number, SIGN_FUNC(f_sign_placelist)},
Yegappan Lakshmananc72bdd22021-07-11 19:44:18 +02002639 {"sign_undefine", 0, 1, FEARG_1, arg1_string_or_list_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002640 ret_number_bool, SIGN_FUNC(f_sign_undefine)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002641 {"sign_unplace", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002642 ret_number_bool, SIGN_FUNC(f_sign_unplace)},
Sean Dewara63780b2021-11-03 13:15:47 +00002643 {"sign_unplacelist", 1, 1, FEARG_1, arg1_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002644 ret_list_number, SIGN_FUNC(f_sign_unplacelist)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002645 {"simplify", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002646 ret_string, f_simplify},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002647 {"sin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002648 ret_float, f_sin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002649 {"sinh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002650 ret_float, f_sinh},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002651 {"slice", 2, 3, FEARG_1, arg23_slice,
Bram Moolenaar00eb9952022-02-05 19:23:18 +00002652 ret_slice, f_slice},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002653 {"sort", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002654 ret_first_arg, f_sort},
2655 {"sound_clear", 0, 0, 0, NULL,
2656 ret_void, SOUND_FUNC(f_sound_clear)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002657 {"sound_playevent", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002658 ret_number, SOUND_FUNC(f_sound_playevent)},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002659 {"sound_playfile", 1, 2, FEARG_1, arg2_string_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002660 ret_number, SOUND_FUNC(f_sound_playfile)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002661 {"sound_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002662 ret_void, SOUND_FUNC(f_sound_stop)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002663 {"soundfold", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002664 ret_string, f_soundfold},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002665 {"spellbadword", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002666 ret_list_string, f_spellbadword},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002667 {"spellsuggest", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002668 ret_list_string, f_spellsuggest},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002669 {"split", 1, 3, FEARG_1, arg3_string_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002670 ret_list_string, f_split},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002671 {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002672 ret_float, f_sqrt},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002673 {"srand", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002674 ret_list_number, f_srand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002675 {"state", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002676 ret_string, f_state},
Bram Moolenaar80a070c2021-08-08 15:51:10 +02002677 {"str2float", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002678 ret_float, f_str2float},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002679 {"str2list", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002680 ret_list_number, f_str2list},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002681 {"str2nr", 1, 3, FEARG_1, arg3_string_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002682 ret_number, f_str2nr},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002683 {"strcharlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01002684 ret_number, f_strcharlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002685 {"strcharpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002686 ret_string, f_strcharpart},
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02002687 {"strchars", 1, 2, FEARG_1, arg2_string_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002688 ret_number, f_strchars},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002689 {"strdisplaywidth", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002690 ret_number, f_strdisplaywidth},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002691 {"strftime", 1, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002692 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002693#ifdef HAVE_STRFTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002694 f_strftime
2695#else
2696 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002697#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002698 },
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002699 {"strgetchar", 2, 2, FEARG_1, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002700 ret_number, f_strgetchar},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002701 {"stridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002702 ret_number, f_stridx},
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002703 {"string", 1, 1, FEARG_1|FE_X, NULL,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002704 ret_string, f_string},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002705 {"strlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002706 ret_number, f_strlen},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002707 {"strpart", 2, 4, FEARG_1, arg24_strpart,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002708 ret_string, f_strpart},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002709 {"strptime", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002710 ret_number,
Bram Moolenaar10455d42019-11-21 15:36:18 +01002711#ifdef HAVE_STRPTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01002712 f_strptime
2713#else
2714 NULL
Bram Moolenaar10455d42019-11-21 15:36:18 +01002715#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002716 },
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002717 {"strridx", 2, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002718 ret_number, f_strridx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002719 {"strtrans", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002720 ret_string, f_strtrans},
Christian Brabandt67672ef2023-04-24 21:09:54 +01002721 {"strutf16len", 1, 2, FEARG_1, arg2_string_bool,
2722 ret_number, f_strutf16len},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002723 {"strwidth", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002724 ret_number, f_strwidth},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002725 {"submatch", 1, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002726 ret_string, f_submatch},
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02002727 {"substitute", 4, 4, FEARG_1, arg4_string_string_any_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002728 ret_string, f_substitute},
Bram Moolenaarc216a7a2022-12-05 13:50:55 +00002729 {"swapfilelist", 0, 0, 0, NULL,
2730 ret_list_string, f_swapfilelist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002731 {"swapinfo", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002732 ret_dict_any, f_swapinfo},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002733 {"swapname", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002734 ret_string, f_swapname},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002735 {"synID", 3, 3, 0, arg3_lnum_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002736 ret_number, f_synID},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002737 {"synIDattr", 2, 3, FEARG_1, arg3_number_string_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002738 ret_string, f_synIDattr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002739 {"synIDtrans", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002740 ret_number, f_synIDtrans},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002741 {"synconcealed", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002742 ret_list_any, f_synconcealed},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002743 {"synstack", 2, 2, 0, arg2_lnum_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002744 ret_list_number, f_synstack},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002745 {"system", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002746 ret_string, f_system},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002747 {"systemlist", 1, 2, FEARG_1, arg12_system,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002748 ret_list_string, f_systemlist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002749 {"tabpagebuflist", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002750 ret_list_number, f_tabpagebuflist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002751 {"tabpagenr", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002752 ret_number, f_tabpagenr},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002753 {"tabpagewinnr", 1, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002754 ret_number, f_tabpagewinnr},
2755 {"tagfiles", 0, 0, 0, NULL,
2756 ret_list_string, f_tagfiles},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002757 {"taglist", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002758 ret_list_dict_any, f_taglist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002759 {"tan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002760 ret_float, f_tan},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002761 {"tanh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002762 ret_float, f_tanh},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002763 {"tempname", 0, 0, 0, NULL,
2764 ret_string, f_tempname},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002765 {"term_dumpdiff", 2, 3, FEARG_1, arg3_string_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002766 ret_number, TERM_FUNC(f_term_dumpdiff)},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002767 {"term_dumpload", 1, 2, FEARG_1, arg2_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002768 ret_number, TERM_FUNC(f_term_dumpload)},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002769 {"term_dumpwrite", 2, 3, FEARG_2, arg3_buffer_string_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002770 ret_void, TERM_FUNC(f_term_dumpwrite)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002771 {"term_getaltscreen", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002772 ret_number, TERM_FUNC(f_term_getaltscreen)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002773 {"term_getansicolors", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002774 ret_list_string,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002775#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002776 f_term_getansicolors
2777#else
2778 NULL
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02002779#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01002780 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002781 {"term_getattr", 2, 2, FEARG_1, arg2_number_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002782 ret_number, TERM_FUNC(f_term_getattr)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002783 {"term_getcursor", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002784 ret_list_any, TERM_FUNC(f_term_getcursor)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002785 {"term_getjob", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002786 ret_job, TERM_FUNC(f_term_getjob)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002787 {"term_getline", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002788 ret_string, TERM_FUNC(f_term_getline)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002789 {"term_getscrolled", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002790 ret_number, TERM_FUNC(f_term_getscrolled)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002791 {"term_getsize", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002792 ret_list_number, TERM_FUNC(f_term_getsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002793 {"term_getstatus", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002794 ret_string, TERM_FUNC(f_term_getstatus)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002795 {"term_gettitle", 1, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002796 ret_string, TERM_FUNC(f_term_gettitle)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002797 {"term_gettty", 1, 2, FEARG_1, arg2_buffer_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002798 ret_string, TERM_FUNC(f_term_gettty)},
2799 {"term_list", 0, 0, 0, NULL,
2800 ret_list_number, TERM_FUNC(f_term_list)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002801 {"term_scrape", 2, 2, FEARG_1, arg2_buffer_lnum,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002802 ret_list_dict_any, TERM_FUNC(f_term_scrape)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002803 {"term_sendkeys", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002804 ret_void, TERM_FUNC(f_term_sendkeys)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002805 {"term_setansicolors", 2, 2, FEARG_1, arg2_buffer_list_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002806 ret_void,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01002807#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01002808 f_term_setansicolors
2809#else
2810 NULL
2811#endif
2812 },
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002813 {"term_setapi", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002814 ret_void, TERM_FUNC(f_term_setapi)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002815 {"term_setkill", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002816 ret_void, TERM_FUNC(f_term_setkill)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002817 {"term_setrestore", 2, 2, FEARG_1, arg2_buffer_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002818 ret_void, TERM_FUNC(f_term_setrestore)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002819 {"term_setsize", 3, 3, FEARG_1, arg3_buffer_number_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002820 ret_void, TERM_FUNC(f_term_setsize)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002821 {"term_start", 1, 2, FEARG_1, arg2_string_or_list_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002822 ret_number, TERM_FUNC(f_term_start)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002823 {"term_wait", 1, 2, FEARG_1, arg2_buffer_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002824 ret_void, TERM_FUNC(f_term_wait)},
2825 {"terminalprops", 0, 0, 0, NULL,
2826 ret_dict_string, f_terminalprops},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002827 {"test_alloc_fail", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002828 ret_void, f_test_alloc_fail},
2829 {"test_autochdir", 0, 0, 0, NULL,
2830 ret_void, f_test_autochdir},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002831 {"test_feedinput", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002832 ret_void, f_test_feedinput},
2833 {"test_garbagecollect_now", 0, 0, 0, NULL,
2834 ret_void, f_test_garbagecollect_now},
2835 {"test_garbagecollect_soon", 0, 0, 0, NULL,
2836 ret_void, f_test_garbagecollect_soon},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002837 {"test_getvalue", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002838 ret_number, f_test_getvalue},
Yegappan Lakshmanan06011e12022-01-30 12:37:29 +00002839 {"test_gui_event", 2, 2, FEARG_1, arg2_string_dict,
2840 ret_bool, f_test_gui_event},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002841 {"test_ignore_error", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002842 ret_void, f_test_ignore_error},
Christopher Plewright20b795e2022-12-20 20:01:58 +00002843 {"test_mswin_event", 2, 2, FEARG_1, arg2_string_dict,
2844 ret_number, f_test_mswin_event},
Bram Moolenaar94738d82020-10-21 14:25:07 +02002845 {"test_null_blob", 0, 0, 0, NULL,
2846 ret_blob, f_test_null_blob},
2847 {"test_null_channel", 0, 0, 0, NULL,
2848 ret_channel, JOB_FUNC(f_test_null_channel)},
2849 {"test_null_dict", 0, 0, 0, NULL,
2850 ret_dict_any, f_test_null_dict},
2851 {"test_null_function", 0, 0, 0, NULL,
2852 ret_func_any, f_test_null_function},
2853 {"test_null_job", 0, 0, 0, NULL,
2854 ret_job, JOB_FUNC(f_test_null_job)},
2855 {"test_null_list", 0, 0, 0, NULL,
2856 ret_list_any, f_test_null_list},
2857 {"test_null_partial", 0, 0, 0, NULL,
2858 ret_func_any, f_test_null_partial},
2859 {"test_null_string", 0, 0, 0, NULL,
2860 ret_string, f_test_null_string},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002861 {"test_option_not_set", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002862 ret_void, f_test_option_not_set},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002863 {"test_override", 2, 2, FEARG_2, arg2_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002864 ret_void, f_test_override},
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002865 {"test_refcount", 1, 1, FEARG_1|FE_X, NULL,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002866 ret_number, f_test_refcount},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002867 {"test_setmouse", 2, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002868 ret_void, f_test_setmouse},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002869 {"test_settime", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002870 ret_void, f_test_settime},
Yegappan Lakshmanan5b739922021-07-10 13:15:41 +02002871 {"test_srand_seed", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002872 ret_void, f_test_srand_seed},
2873 {"test_unknown", 0, 0, 0, NULL,
2874 ret_any, f_test_unknown},
2875 {"test_void", 0, 0, 0, NULL,
2876 ret_void, f_test_void},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002877 {"timer_info", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002878 ret_list_dict_any, TIMER_FUNC(f_timer_info)},
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02002879 {"timer_pause", 2, 2, FEARG_1, arg2_number_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002880 ret_void, TIMER_FUNC(f_timer_pause)},
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02002881 {"timer_start", 2, 3, FEARG_1, arg3_number_any_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002882 ret_number, TIMER_FUNC(f_timer_start)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002883 {"timer_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002884 ret_void, TIMER_FUNC(f_timer_stop)},
2885 {"timer_stopall", 0, 0, 0, NULL,
2886 ret_void, TIMER_FUNC(f_timer_stopall)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002887 {"tolower", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002888 ret_string, f_tolower},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002889 {"toupper", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002890 ret_string, f_toupper},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002891 {"tr", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002892 ret_string, f_tr},
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02002893 {"trim", 1, 3, FEARG_1, arg3_string_string_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002894 ret_string, f_trim},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002895 {"trunc", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002896 ret_float, f_trunc},
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002897 {"type", 1, 1, FEARG_1|FE_X, NULL,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002898 ret_number, f_type},
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002899 {"typename", 1, 1, FEARG_1|FE_X, NULL,
Bram Moolenaara47e05f2021-01-12 21:49:00 +01002900 ret_string, f_typename},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002901 {"undofile", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002902 ret_string, f_undofile},
Devin J. Pohly5fee1112023-04-23 20:26:59 -05002903 {"undotree", 0, 1, FEARG_1, arg1_buffer,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002904 ret_dict_any, f_undotree},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002905 {"uniq", 1, 3, FEARG_1, arg13_sortuniq,
Bram Moolenaar08018222021-12-22 18:45:37 +00002906 ret_first_arg, f_uniq},
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01002907 {"utf16idx", 2, 4, FEARG_1, arg4_string_number_bool_bool,
Christian Brabandt67672ef2023-04-24 21:09:54 +01002908 ret_number, f_utf16idx},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002909 {"values", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar32517c42023-01-15 18:17:12 +00002910 ret_list_member, f_values},
zeertzjq825cf812023-08-17 22:55:25 +02002911 {"virtcol", 1, 3, FEARG_1, arg3_string_or_list_bool_number,
LemonBoy0f7a3e12022-05-26 12:10:37 +01002912 ret_virtcol, f_virtcol},
Bram Moolenaar5a6ec102022-05-27 21:58:00 +01002913 {"virtcol2col", 3, 3, FEARG_1, arg3_number,
2914 ret_number, f_virtcol2col},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002915 {"visualmode", 0, 1, 0, arg1_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002916 ret_string, f_visualmode},
2917 {"wildmenumode", 0, 0, 0, NULL,
2918 ret_number, f_wildmenumode},
Bram Moolenaar52312242021-07-11 18:23:19 +02002919 {"win_execute", 2, 3, FEARG_2, arg23_win_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002920 ret_string, f_win_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002921 {"win_findbuf", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002922 ret_list_number, f_win_findbuf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002923 {"win_getid", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002924 ret_number, f_win_getid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002925 {"win_gettype", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002926 ret_string, f_win_gettype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002927 {"win_gotoid", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002928 ret_number_bool, f_win_gotoid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002929 {"win_id2tabwin", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002930 ret_list_number, f_win_id2tabwin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002931 {"win_id2win", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002932 ret_number, f_win_id2win},
Daniel Steinbergee630312022-01-10 13:36:34 +00002933 {"win_move_separator", 2, 2, FEARG_1, arg2_number,
2934 ret_number_bool, f_win_move_separator},
2935 {"win_move_statusline", 2, 2, FEARG_1, arg2_number,
2936 ret_number_bool, f_win_move_statusline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002937 {"win_screenpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002938 ret_list_number, f_win_screenpos},
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02002939 {"win_splitmove", 2, 3, FEARG_1, arg3_number_number_dict,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002940 ret_number_bool, f_win_splitmove},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002941 {"winbufnr", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002942 ret_number, f_winbufnr},
2943 {"wincol", 0, 0, 0, NULL,
2944 ret_number, f_wincol},
2945 {"windowsversion", 0, 0, 0, NULL,
2946 ret_string, f_windowsversion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002947 {"winheight", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002948 ret_number, f_winheight},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002949 {"winlayout", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002950 ret_list_any, f_winlayout},
2951 {"winline", 0, 0, 0, NULL,
2952 ret_number, f_winline},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02002953 {"winnr", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002954 ret_number, f_winnr},
2955 {"winrestcmd", 0, 0, 0, NULL,
2956 ret_string, f_winrestcmd},
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02002957 {"winrestview", 1, 1, FEARG_1, arg1_dict_any,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002958 ret_void, f_winrestview},
2959 {"winsaveview", 0, 0, 0, NULL,
Bram Moolenaar43b69b32021-01-07 20:23:33 +01002960 ret_dict_number, f_winsaveview},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002961 {"winwidth", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002962 ret_number, f_winwidth},
2963 {"wordcount", 0, 0, 0, NULL,
2964 ret_dict_number, f_wordcount},
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02002965 {"writefile", 2, 3, FEARG_1, arg23_writefile,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01002966 ret_number_bool, f_writefile},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02002967 {"xor", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02002968 ret_number, f_xor},
Bram Moolenaarac92e252019-08-03 21:58:38 +02002969};
2970
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002971/*
Ernie Raeld8bf87c2023-12-16 14:03:33 +01002972 * Return true if specified function allows a type as an argument.
2973 */
2974 static int
2975func_allows_type(int idx)
2976{
2977 return (global_functions[idx].f_argtype & FE_X) != 0;
2978}
2979
2980/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002981 * Function given to ExpandGeneric() to obtain the list of internal
2982 * or user defined function names.
2983 */
2984 char_u *
2985get_function_name(expand_T *xp, int idx)
2986{
2987 static int intidx = -1;
2988 char_u *name;
2989
2990 if (idx == 0)
2991 intidx = -1;
2992 if (intidx < 0)
2993 {
2994 name = get_user_func_name(xp, idx);
naohiro ono5aec7552021-08-19 21:20:41 +02002995 if (name != NULL)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002996 {
naohiro ono5aec7552021-08-19 21:20:41 +02002997 if (*name != NUL && *name != '<'
2998 && STRNCMP("g:", xp->xp_pattern, 2) == 0)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01002999 return cat_prefix_varname('g', name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003000 return name;
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01003001 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003002 }
K.Takataeeec2542021-06-02 13:28:16 +02003003 if (++intidx < (int)ARRAY_LENGTH(global_functions))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003004 {
Kota Kato90c23532023-01-18 15:27:38 +00003005 // Skip if the function doesn't have an implementation (feature not
3006 // implemented).
3007 if (global_functions[intidx].f_func == NULL)
3008 return (char_u *)"";
Bram Moolenaarac92e252019-08-03 21:58:38 +02003009 STRCPY(IObuff, global_functions[intidx].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003010 STRCAT(IObuff, "(");
Bram Moolenaarac92e252019-08-03 21:58:38 +02003011 if (global_functions[intidx].f_max_argc == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003012 STRCAT(IObuff, ")");
3013 return IObuff;
3014 }
3015
3016 return NULL;
3017}
3018
3019/*
3020 * Function given to ExpandGeneric() to obtain the list of internal or
3021 * user defined variable or function names.
3022 */
3023 char_u *
3024get_expr_name(expand_T *xp, int idx)
3025{
3026 static int intidx = -1;
3027 char_u *name;
3028
3029 if (idx == 0)
3030 intidx = -1;
3031 if (intidx < 0)
3032 {
3033 name = get_function_name(xp, idx);
3034 if (name != NULL)
3035 return name;
3036 }
3037 return get_user_var_name(xp, ++intidx);
3038}
3039
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003040/*
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003041 * Find internal function "name" in table "global_functions".
Bram Moolenaar15c47602020-03-26 22:16:48 +01003042 * Return index, or -1 if not found or "implemented" is TRUE and the function
3043 * is not implemented.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003044 */
Bram Moolenaar15c47602020-03-26 22:16:48 +01003045 static int
3046find_internal_func_opt(char_u *name, int implemented)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003047{
3048 int first = 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003049 int last;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003050 int cmp;
3051 int x;
3052
K.Takataeeec2542021-06-02 13:28:16 +02003053 last = (int)ARRAY_LENGTH(global_functions) - 1;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003054
3055 // Find the function name in the table. Binary search.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003056 while (first <= last)
3057 {
3058 x = first + ((unsigned)(last - first) >> 1);
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003059 cmp = STRCMP(name, global_functions[x].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003060 if (cmp < 0)
3061 last = x - 1;
3062 else if (cmp > 0)
3063 first = x + 1;
Bram Moolenaar15c47602020-03-26 22:16:48 +01003064 else if (implemented && global_functions[x].f_func == NULL)
3065 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003066 else
3067 return x;
3068 }
3069 return -1;
3070}
3071
Bram Moolenaar15c47602020-03-26 22:16:48 +01003072/*
3073 * Find internal function "name" in table "global_functions".
3074 * Return index, or -1 if not found or the function is not implemented.
3075 */
3076 int
3077find_internal_func(char_u *name)
3078{
3079 return find_internal_func_opt(name, TRUE);
3080}
3081
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003082 int
Bram Moolenaarac92e252019-08-03 21:58:38 +02003083has_internal_func(char_u *name)
3084{
Bram Moolenaar15c47602020-03-26 22:16:48 +01003085 return find_internal_func_opt(name, TRUE) >= 0;
3086}
3087
3088 static int
3089has_internal_func_name(char_u *name)
3090{
3091 return find_internal_func_opt(name, FALSE) >= 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003092}
3093
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003094 char *
3095internal_func_name(int idx)
3096{
3097 return global_functions[idx].f_name;
3098}
3099
Bram Moolenaar94738d82020-10-21 14:25:07 +02003100/*
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003101 * Check the argument types for builtin function "idx".
Bram Moolenaar94738d82020-10-21 14:25:07 +02003102 * Uses the list of types on the type stack: "types".
3103 * Return FAIL and gives an error message when a type is wrong.
3104 */
3105 int
Bram Moolenaar351ead02021-01-16 16:07:01 +01003106internal_func_check_arg_types(
Bram Moolenaar078a4612022-01-04 15:17:03 +00003107 type2_T *types,
Bram Moolenaar351ead02021-01-16 16:07:01 +01003108 int idx,
3109 int argcount,
3110 cctx_T *cctx)
Bram Moolenaar94738d82020-10-21 14:25:07 +02003111{
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003112 // Some internal functions accept types like Class as arguments. For other
3113 // functions, check the arguments are not types.
3114 if (!(func_allows_type(idx)))
3115 {
3116 for (int i = 0; i < argcount; ++i)
3117 if (check_type_is_value(types[i].type_curr) == FAIL)
3118 return FAIL;
3119 }
3120
Bram Moolenaar94738d82020-10-21 14:25:07 +02003121 argcheck_T *argchecks = global_functions[idx].f_argcheck;
Bram Moolenaar94738d82020-10-21 14:25:07 +02003122
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00003123 if (argchecks == NULL)
3124 return OK;
Bram Moolenaar94738d82020-10-21 14:25:07 +02003125
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00003126 argcontext_T context;
3127
3128 context.arg_count = argcount;
3129 context.arg_types = types;
3130 context.arg_cctx = cctx;
Ernie Raela8f7f922023-12-14 20:17:04 +01003131 for (int i = 0; i < argcount && argchecks[i] != NULL; ++i)
3132 {
3133 context.arg_idx = i;
3134 if (argchecks[i](types[i].type_curr, types[i].type_decl,
3135 &context) == FAIL)
3136 return FAIL;
3137 }
Bram Moolenaar94738d82020-10-21 14:25:07 +02003138 return OK;
3139}
3140
Bram Moolenaara1224cb2020-10-22 12:31:49 +02003141/*
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02003142 * Get the argument count for function "idx".
3143 * "argcount" is the total argument count, "min_argcount" the non-optional
3144 * argument count.
3145 */
3146 void
3147internal_func_get_argcount(int idx, int *argcount, int *min_argcount)
3148{
3149 *argcount = global_functions[idx].f_max_argc;
3150 *min_argcount = global_functions[idx].f_min_argc;
3151}
3152
3153/*
Bram Moolenaara1224cb2020-10-22 12:31:49 +02003154 * Call the "f_retfunc" function to obtain the return type of function "idx".
Bram Moolenaar81330182022-02-01 12:11:58 +00003155 * "decl_type" is set to the declared type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02003156 * "argtypes" is the list of argument types or NULL when there are no
3157 * arguments.
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003158 * "argcount" may be less than the actual count when only getting the type.
Bram Moolenaara1224cb2020-10-22 12:31:49 +02003159 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003160 type_T *
Bram Moolenaar81330182022-02-01 12:11:58 +00003161internal_func_ret_type(
3162 int idx,
3163 int argcount,
3164 type2_T *argtypes,
Bram Moolenaar32517c42023-01-15 18:17:12 +00003165 type_T **decl_type,
3166 garray_T *type_gap)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003167{
Bram Moolenaar81330182022-02-01 12:11:58 +00003168 type_T *ret;
3169
Bram Moolenaar32517c42023-01-15 18:17:12 +00003170 current_type_gap = type_gap;
Bram Moolenaar81330182022-02-01 12:11:58 +00003171 *decl_type = NULL;
3172 ret = global_functions[idx].f_retfunc(argcount, argtypes, decl_type);
3173 if (*decl_type == NULL)
3174 *decl_type = ret;
Bram Moolenaar32517c42023-01-15 18:17:12 +00003175 current_type_gap = NULL;
Bram Moolenaar81330182022-02-01 12:11:58 +00003176 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003177}
3178
3179/*
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003180 * Return TRUE if "idx" is for the map() function.
3181 */
3182 int
3183internal_func_is_map(int idx)
3184{
3185 return global_functions[idx].f_func == f_map;
3186}
3187
3188/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003189 * Check the argument count to use for internal function "idx".
Bram Moolenaar389df252020-07-09 21:20:47 +02003190 * Returns -1 for failure, 0 if no method base accepted, 1 if method base is
3191 * first argument, 2 if method base is second argument, etc. 9 if method base
3192 * is last argument.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003193 */
3194 int
3195check_internal_func(int idx, int argcount)
3196{
Bram Moolenaar0917e862023-02-18 14:42:44 +00003197 funcerror_T res;
3198 char *name;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003199
3200 if (argcount < global_functions[idx].f_min_argc)
3201 res = FCERR_TOOFEW;
3202 else if (argcount > global_functions[idx].f_max_argc)
3203 res = FCERR_TOOMANY;
3204 else
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003205 return global_functions[idx].f_argtype & FEARG_MASK;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003206
3207 name = internal_func_name(idx);
3208 if (res == FCERR_TOOMANY)
Bram Moolenaare1242042021-12-16 20:56:57 +00003209 semsg(_(e_too_many_arguments_for_function_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003210 else
Bram Moolenaare1242042021-12-16 20:56:57 +00003211 semsg(_(e_not_enough_arguments_for_function_str), name);
Bram Moolenaar389df252020-07-09 21:20:47 +02003212 return -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003213}
3214
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003215/*
3216 * Some internal functions accept types like Class as arguments. For other
3217 * functions, check the arguments are not types.
3218 *
3219 * Return OK/FAIL.
3220 */
3221 static int
3222check_args_for_type(int idx, int argcount, typval_T *argvars)
3223{
3224 if (!func_allows_type(idx))
3225 {
3226 for (int i = 0; i < argcount; ++i)
3227 if (check_typval_is_value(&argvars[i]) == FAIL)
3228 return FAIL;
3229 }
3230 return OK;
3231}
3232
Bram Moolenaar0917e862023-02-18 14:42:44 +00003233 funcerror_T
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003234call_internal_func(
3235 char_u *name,
3236 int argcount,
3237 typval_T *argvars,
3238 typval_T *rettv)
3239{
3240 int i;
3241
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003242 i = find_internal_func(name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003243 if (i < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003244 return FCERR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003245 if (argcount < global_functions[i].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003246 return FCERR_TOOFEW;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003247 if (argcount > global_functions[i].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003248 return FCERR_TOOMANY;
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003249 if (check_args_for_type(i, argcount, argvars) == FAIL)
3250 return FCERR_OTHER;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003251 argvars[argcount].v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003252 global_functions[i].f_func(argvars, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01003253 return FCERR_NONE;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003254}
3255
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003256 void
3257call_internal_func_by_idx(
3258 int idx,
3259 typval_T *argvars,
3260 typval_T *rettv)
3261{
3262 global_functions[idx].f_func(argvars, rettv);
3263}
3264
Bram Moolenaarac92e252019-08-03 21:58:38 +02003265/*
3266 * Invoke a method for base->method().
3267 */
Bram Moolenaar0917e862023-02-18 14:42:44 +00003268 funcerror_T
Bram Moolenaarac92e252019-08-03 21:58:38 +02003269call_internal_method(
3270 char_u *name,
3271 int argcount,
3272 typval_T *argvars,
3273 typval_T *rettv,
3274 typval_T *basetv)
3275{
Bram Moolenaarac92e252019-08-03 21:58:38 +02003276 int fi;
3277 typval_T argv[MAX_FUNC_ARGS + 1];
3278
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003279 fi = find_internal_func(name);
Bram Moolenaar91746392019-08-16 22:22:31 +02003280 if (fi < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003281 return FCERR_UNKNOWN;
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003282 if ((global_functions[fi].f_argtype & FEARG_MASK) == 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01003283 return FCERR_NOTMETHOD;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003284 if (argcount + 1 < global_functions[fi].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003285 return FCERR_TOOFEW;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003286 if (argcount + 1 > global_functions[fi].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01003287 return FCERR_TOOMANY;
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003288 if (check_args_for_type(fi, argcount, argvars) == FAIL)
3289 return FCERR_OTHER;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003290
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003291 if ((global_functions[fi].f_argtype & FEARG_MASK) == FEARG_2)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003292 {
Bram Moolenaarb7f22702023-04-27 16:24:07 +01003293 if (argcount < 1)
3294 return FCERR_TOOFEW;
3295
Bram Moolenaar25e42232019-08-04 15:04:10 +02003296 // base value goes second
3297 argv[0] = argvars[0];
3298 argv[1] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003299 for (int i = 1; i < argcount; ++i)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003300 argv[i + 1] = argvars[i];
3301 }
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003302 else if ((global_functions[fi].f_argtype & FEARG_MASK) == FEARG_3)
Bram Moolenaar24278d22019-08-16 21:49:22 +02003303 {
Bram Moolenaarb7f22702023-04-27 16:24:07 +01003304 if (argcount < 2)
3305 return FCERR_TOOFEW;
3306
Bram Moolenaar24278d22019-08-16 21:49:22 +02003307 // base value goes third
3308 argv[0] = argvars[0];
3309 argv[1] = argvars[1];
3310 argv[2] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003311 for (int i = 2; i < argcount; ++i)
Bram Moolenaar24278d22019-08-16 21:49:22 +02003312 argv[i + 1] = argvars[i];
3313 }
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003314 else if ((global_functions[fi].f_argtype & FEARG_MASK) == FEARG_4)
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003315 {
Bram Moolenaarb7f22702023-04-27 16:24:07 +01003316 if (argcount < 3)
3317 return FCERR_TOOFEW;
3318
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003319 // base value goes fourth
3320 argv[0] = argvars[0];
3321 argv[1] = argvars[1];
3322 argv[2] = argvars[2];
3323 argv[3] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003324 for (int i = 3; i < argcount; ++i)
Bram Moolenaaraad222c2019-09-06 22:46:09 +02003325 argv[i + 1] = argvars[i];
3326 }
Bram Moolenaar25e42232019-08-04 15:04:10 +02003327 else
3328 {
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003329 // FEARG_1: base value goes first
Bram Moolenaar25e42232019-08-04 15:04:10 +02003330 argv[0] = *basetv;
Bram Moolenaar848db572022-09-20 19:04:32 +01003331 for (int i = 0; i < argcount; ++i)
Bram Moolenaar25e42232019-08-04 15:04:10 +02003332 argv[i + 1] = argvars[i];
3333 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02003334 argv[argcount + 1].v_type = VAR_UNKNOWN;
3335
Ernie Raeld8bf87c2023-12-16 14:03:33 +01003336 if (check_args_for_type(fi, argcount + 1, argv) == FAIL)
3337 return FCERR_OTHER;
3338
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02003339 global_functions[fi].f_func(argv, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01003340 return FCERR_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003341}
3342
3343/*
3344 * Return TRUE for a non-zero Number and a non-empty String.
3345 */
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003346 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003347non_zero_arg(typval_T *argvars)
3348{
3349 return ((argvars[0].v_type == VAR_NUMBER
3350 && argvars[0].vval.v_number != 0)
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003351 || (argvars[0].v_type == VAR_BOOL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003352 && argvars[0].vval.v_number == VVAL_TRUE)
3353 || (argvars[0].v_type == VAR_STRING
3354 && argvars[0].vval.v_string != NULL
3355 && *argvars[0].vval.v_string != NUL));
3356}
3357
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003358/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003359 * "and(expr, expr)" function
3360 */
3361 static void
3362f_and(typval_T *argvars, typval_T *rettv)
3363{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003364 if (in_vim9script()
3365 && (check_for_number_arg(argvars, 0) == FAIL
3366 || check_for_number_arg(argvars, 1) == FAIL))
3367 return;
3368
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003369 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
3370 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02003371}
3372
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003373/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01003374 * "balloon_show()" function
3375 */
3376#ifdef FEAT_BEVAL
3377 static void
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003378f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv)
3379{
3380 rettv->v_type = VAR_STRING;
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003381 if (balloonEval == NULL)
3382 return;
3383
3384 if (balloonEval->msg == NULL)
3385 rettv->vval.v_string = NULL;
3386 else
3387 rettv->vval.v_string = vim_strsave(balloonEval->msg);
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02003388}
3389
3390 static void
Bram Moolenaar59716a22017-03-01 20:32:44 +01003391f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
3392{
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003393 if (balloonEval == NULL)
3394 return;
3395
3396 if (in_vim9script()
3397 && check_for_string_or_list_arg(argvars, 0) == FAIL)
3398 return;
3399
3400 if (argvars[0].v_type == VAR_LIST
3401# ifdef FEAT_GUI
3402 && !gui.in_use
3403# endif
3404 )
Bram Moolenaar246fe032017-11-19 19:56:27 +01003405 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003406 list_T *l = argvars[0].vval.v_list;
3407
3408 // empty list removes the balloon
3409 post_balloon(balloonEval, NULL,
3410 l == NULL || l->lv_len == 0 ? NULL : l);
3411 }
3412 else
3413 {
3414 char_u *mesg;
3415
3416 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003417 return;
3418
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003419 mesg = tv_get_string_chk(&argvars[0]);
3420 if (mesg != NULL)
3421 // empty string removes the balloon
3422 post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003423 }
3424}
3425
Bram Moolenaar669a8282017-11-19 20:13:05 +01003426# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003427 static void
3428f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
3429{
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003430 if (rettv_list_alloc(rettv) != OK)
3431 return;
3432
3433 char_u *msg;
3434
3435 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3436 return;
3437 msg = tv_get_string_chk(&argvars[0]);
3438 if (msg != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01003439 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003440 pumitem_T *array;
3441 int size = split_message(msg, &array);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003442
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003443 // Skip the first and last item, they are always empty.
3444 for (int i = 1; i < size - 1; ++i)
3445 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
3446 while (size > 0)
3447 vim_free(array[--size].pum_text);
3448 vim_free(array);
Bram Moolenaar246fe032017-11-19 19:56:27 +01003449 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01003450}
Bram Moolenaar669a8282017-11-19 20:13:05 +01003451# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01003452#endif
3453
3454/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003455 * Get the buffer from "arg" and give an error and return NULL if it is not
3456 * valid.
3457 */
Bram Moolenaara3347722019-05-11 21:14:24 +02003458 buf_T *
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003459get_buf_arg(typval_T *arg)
3460{
3461 buf_T *buf;
3462
3463 ++emsg_off;
3464 buf = tv_get_buf(arg, FALSE);
3465 --emsg_off;
3466 if (buf == NULL)
Bram Moolenaard82a47d2022-01-05 20:24:39 +00003467 semsg(_(e_invalid_buffer_name_str), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01003468 return buf;
3469}
3470
3471/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003472 * "byte2line(byte)" function
3473 */
3474 static void
3475f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
3476{
3477#ifndef FEAT_BYTEOFF
3478 rettv->vval.v_number = -1;
3479#else
3480 long boff = 0;
3481
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003482 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3483 return;
3484
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003485 boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003486 if (boff < 0)
3487 rettv->vval.v_number = -1;
3488 else
3489 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
3490 (linenr_T)0, &boff);
3491#endif
3492}
3493
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003494/*
3495 * "call(func, arglist [, dict])" function
3496 */
3497 static void
3498f_call(typval_T *argvars, typval_T *rettv)
3499{
3500 char_u *func;
3501 partial_T *partial = NULL;
3502 dict_T *selfdict = NULL;
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003503 char_u *dot;
3504 char_u *tofree = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003505
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003506 if (in_vim9script()
Bram Moolenaar223d0a62021-12-25 19:29:21 +00003507 && (check_for_string_or_func_arg(argvars, 0) == FAIL
3508 || check_for_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02003509 || check_for_opt_dict_arg(argvars, 2) == FAIL))
3510 return;
3511
Bram Moolenaard83392a2022-09-01 12:22:46 +01003512 if (check_for_list_arg(argvars, 1) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003513 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003514 if (argvars[1].vval.v_list == NULL)
3515 return;
3516
3517 if (argvars[0].v_type == VAR_FUNC)
3518 func = argvars[0].vval.v_string;
3519 else if (argvars[0].v_type == VAR_PARTIAL)
3520 {
3521 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003522 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003523 }
3524 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003525 func = tv_get_string(&argvars[0]);
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02003526 if (func == NULL || *func == NUL)
3527 return; // type error, empty name or null function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003528
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003529 dot = vim_strchr(func, '.');
3530 if (dot != NULL)
3531 {
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00003532 imported_T *import = find_imported(func, dot - func, TRUE);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003533
3534 if (import != NULL && SCRIPT_ID_VALID(import->imp_sid))
3535 {
3536 scriptitem_T *si = SCRIPT_ITEM(import->imp_sid);
3537
3538 if (si->sn_autoload_prefix != NULL)
3539 {
3540 // Turn "import.Func" into "scriptname#Func".
3541 tofree = concat_str(si->sn_autoload_prefix, dot + 1);
3542 if (tofree == NULL)
3543 return;
3544 func = tofree;
3545 }
3546 }
3547 }
3548
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003549 if (argvars[2].v_type != VAR_UNKNOWN)
3550 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003551 if (check_for_dict_arg(argvars, 2) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003552 return;
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01003553
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003554 selfdict = argvars[2].vval.v_dict;
3555 }
3556
3557 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00003558
3559 vim_free(tofree);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003560}
3561
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003562/*
3563 * "changenr()" function
3564 */
3565 static void
3566f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
3567{
3568 rettv->vval.v_number = curbuf->b_u_seq_cur;
3569}
3570
3571/*
3572 * "char2nr(string)" function
3573 */
3574 static void
3575f_char2nr(typval_T *argvars, typval_T *rettv)
3576{
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003577 if (in_vim9script()
3578 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003579 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003580 return;
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02003581
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003582 if (has_mbyte)
3583 {
3584 int utf8 = 0;
3585
3586 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar24f77502020-09-04 19:50:57 +02003587 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003588
3589 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01003590 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003591 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003592 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003593 }
3594 else
Bram Moolenaar13505972019-01-24 15:04:48 +01003595 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003596}
3597
Bram Moolenaar17793ef2020-12-28 12:56:58 +01003598/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003599 * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE,
3600 * returns the character index of the column. Otherwise, returns the byte index
3601 * of the column.
3602 */
3603 static void
3604get_col(typval_T *argvars, typval_T *rettv, int charcol)
3605{
3606 colnr_T col = 0;
3607 pos_T *fp;
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003608 switchwin_T switchwin;
3609 int winchanged = FALSE;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003610
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003611 if (check_for_string_or_list_arg(argvars, 0) == FAIL
3612 || check_for_opt_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003613 return;
3614
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003615 if (argvars[1].v_type != VAR_UNKNOWN)
3616 {
3617 tabpage_T *tp;
3618 win_T *wp;
3619
3620 // use the window specified in the second argument
3621 wp = win_id2wp_tp((int)tv_get_number(&argvars[1]), &tp);
3622 if (wp == NULL || tp == NULL)
3623 return;
3624
3625 if (switch_win_noblock(&switchwin, wp, tp, TRUE) != OK)
3626 return;
3627
3628 check_cursor();
3629 winchanged = TRUE;
3630 }
3631
3632 int fnum = curbuf->b_fnum;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003633 fp = var2fpos(&argvars[0], FALSE, &fnum, charcol);
3634 if (fp != NULL && fnum == curbuf->b_fnum)
3635 {
3636 if (fp->col == MAXCOL)
3637 {
3638 // '> can be MAXCOL, get the length of the line then
3639 if (fp->lnum <= curbuf->b_ml.ml_line_count)
3640 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
3641 else
3642 col = MAXCOL;
3643 }
3644 else
3645 {
3646 col = fp->col + 1;
3647 // col(".") when the cursor is on the NUL at the end of the line
3648 // because of "coladd" can be seen as an extra column.
3649 if (virtual_active() && fp == &curwin->w_cursor)
3650 {
3651 char_u *p = ml_get_cursor();
3652
3653 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
3654 curwin->w_virtcol - curwin->w_cursor.coladd))
3655 {
3656 int l;
3657
3658 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
3659 col += l;
3660 }
3661 }
3662 }
3663 }
3664 rettv->vval.v_number = col;
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00003665
3666 if (winchanged)
3667 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003668}
3669
3670/*
3671 * "charcol()" function
3672 */
3673 static void
3674f_charcol(typval_T *argvars, typval_T *rettv)
3675{
3676 get_col(argvars, rettv, TRUE);
3677}
3678
Bram Moolenaar29b7d7a2019-07-22 23:03:57 +02003679 win_T *
Bram Moolenaaraff74912019-03-30 18:11:49 +01003680get_optional_window(typval_T *argvars, int idx)
3681{
3682 win_T *win = curwin;
3683
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00003684 if (argvars[idx].v_type == VAR_UNKNOWN)
3685 return curwin;
3686
3687 win = find_win_by_nr_or_id(&argvars[idx]);
3688 if (win == NULL)
Bram Moolenaaraff74912019-03-30 18:11:49 +01003689 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00003690 emsg(_(e_invalid_window_number));
3691 return NULL;
Bram Moolenaaraff74912019-03-30 18:11:49 +01003692 }
3693 return win;
3694}
3695
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003696/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003697 * "col(string)" function
3698 */
3699 static void
3700f_col(typval_T *argvars, typval_T *rettv)
3701{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003702 get_col(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003703}
3704
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003705/*
3706 * "confirm(message, buttons[, default [, type]])" function
3707 */
3708 static void
3709f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3710{
3711#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3712 char_u *message;
3713 char_u *buttons = NULL;
3714 char_u buf[NUMBUFLEN];
3715 char_u buf2[NUMBUFLEN];
3716 int def = 1;
3717 int type = VIM_GENERIC;
3718 char_u *typestr;
3719 int error = FALSE;
3720
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02003721 if (in_vim9script()
3722 && (check_for_string_arg(argvars, 0) == FAIL
3723 || (check_for_opt_string_arg(argvars, 1) == FAIL
3724 || (argvars[1].v_type != VAR_UNKNOWN
3725 && (check_for_opt_number_arg(argvars, 2) == FAIL
3726 || (argvars[2].v_type != VAR_UNKNOWN
3727 && check_for_opt_string_arg(argvars, 3) == FAIL))))))
Bram Moolenaarc5809432021-03-27 21:23:30 +01003728 return;
3729
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003730 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003731 if (message == NULL)
3732 error = TRUE;
3733 if (argvars[1].v_type != VAR_UNKNOWN)
3734 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003735 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003736 if (buttons == NULL)
3737 error = TRUE;
3738 if (argvars[2].v_type != VAR_UNKNOWN)
3739 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003740 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003741 if (argvars[3].v_type != VAR_UNKNOWN)
3742 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003743 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003744 if (typestr == NULL)
3745 error = TRUE;
3746 else
3747 {
3748 switch (TOUPPER_ASC(*typestr))
3749 {
3750 case 'E': type = VIM_ERROR; break;
3751 case 'Q': type = VIM_QUESTION; break;
3752 case 'I': type = VIM_INFO; break;
3753 case 'W': type = VIM_WARNING; break;
3754 case 'G': type = VIM_GENERIC; break;
3755 }
3756 }
3757 }
3758 }
3759 }
3760
3761 if (buttons == NULL || *buttons == NUL)
3762 buttons = (char_u *)_("&Ok");
3763
3764 if (!error)
3765 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
3766 def, NULL, FALSE);
3767#endif
3768}
3769
3770/*
3771 * "copy()" function
3772 */
3773 static void
3774f_copy(typval_T *argvars, typval_T *rettv)
3775{
Bram Moolenaar381692b2022-02-02 20:01:27 +00003776 item_copy(&argvars[0], rettv, FALSE, TRUE, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003777}
3778
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003779/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003780 * Set the cursor position.
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01003781 * If "charcol" is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003782 * Otherwise use the column number as a byte offset.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003783 */
3784 static void
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003785set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003786{
Bram Moolenaar79f23442022-10-10 12:42:57 +01003787 long lnum, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003788 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003789 int set_curswant = TRUE;
3790
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003791 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003792 && (check_for_string_or_number_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanancd917202021-07-21 19:09:09 +02003793 || check_for_opt_number_arg(argvars, 1) == FAIL
3794 || (argvars[1].v_type != VAR_UNKNOWN
3795 && check_for_opt_number_arg(argvars, 2) == FAIL)))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003796 return;
3797
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003798 rettv->vval.v_number = -1;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003799 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003800 {
3801 pos_T pos;
3802 colnr_T curswant = -1;
3803
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003804 if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003805 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003806 emsg(_(e_invalid_argument));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003807 return;
3808 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003809 lnum = pos.lnum;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003810 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003811 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003812 if (curswant >= 0)
3813 {
3814 curwin->w_curswant = curswant - 1;
3815 set_curswant = FALSE;
3816 }
3817 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003818 else if ((argvars[0].v_type == VAR_NUMBER
3819 || argvars[0].v_type == VAR_STRING)
3820 && (argvars[1].v_type == VAR_NUMBER
3821 || argvars[1].v_type == VAR_STRING))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003822 {
Bram Moolenaar79f23442022-10-10 12:42:57 +01003823 lnum = tv_get_lnum(argvars);
3824 if (lnum < 0)
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003825 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaar79f23442022-10-10 12:42:57 +01003826 else if (lnum == 0)
3827 lnum = curwin->w_cursor.lnum;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003828 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003829 if (charcol)
Bram Moolenaar79f23442022-10-10 12:42:57 +01003830 col = buf_charidx_to_byteidx(curbuf, lnum, col) + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003831 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003832 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003833 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003834 else
3835 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00003836 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003837 return;
3838 }
Bram Moolenaar79f23442022-10-10 12:42:57 +01003839 if (lnum < 0 || col < 0 || coladd < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003840 return; // type error; errmsg already given
Bram Moolenaar79f23442022-10-10 12:42:57 +01003841 if (lnum > 0)
3842 curwin->w_cursor.lnum = lnum;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003843 if (col > 0)
3844 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003845 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003846
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003847 // Make sure the cursor is in a valid position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003848 check_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003849 // Correct cursor for multi-byte character.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003850 if (has_mbyte)
3851 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003852
3853 curwin->w_set_curswant = set_curswant;
3854 rettv->vval.v_number = 0;
3855}
3856
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003857/*
3858 * "cursor(lnum, col)" function, or
3859 * "cursor(list)"
3860 *
3861 * Moves the cursor to the specified line and column.
3862 * Returns 0 when the position could be set, -1 otherwise.
3863 */
3864 static void
3865f_cursor(typval_T *argvars, typval_T *rettv)
3866{
3867 set_cursorpos(argvars, rettv, FALSE);
3868}
3869
Bram Moolenaar4f974752019-02-17 17:44:42 +01003870#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003871/*
3872 * "debugbreak()" function
3873 */
3874 static void
3875f_debugbreak(typval_T *argvars, typval_T *rettv)
3876{
3877 int pid;
3878
3879 rettv->vval.v_number = FAIL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02003880 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
3881 return;
3882
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003883 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003884 if (pid == 0)
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003885 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003886 emsg(_(e_invalid_argument));
3887 return;
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003888 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00003889
3890 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
3891 if (hProcess == NULL)
3892 return;
3893
3894 DebugBreakProcess(hProcess);
3895 CloseHandle(hProcess);
3896 rettv->vval.v_number = OK;
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02003897}
3898#endif
3899
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003900/*
3901 * "deepcopy()" function
3902 */
3903 static void
3904f_deepcopy(typval_T *argvars, typval_T *rettv)
3905{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003906 varnumber_T noref = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003907
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01003908 if (check_for_opt_bool_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02003909 return;
3910
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003911 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01003912 noref = tv_get_bool_chk(&argvars[1], NULL);
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01003913
3914 item_copy(&argvars[0], rettv, TRUE, TRUE, noref == 0 ? get_copyID() : 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003915}
3916
3917/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003918 * "did_filetype()" function
3919 */
3920 static void
3921f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3922{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003923 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003924}
3925
3926/*
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003927 * "echoraw({expr})" function
3928 */
3929 static void
3930f_echoraw(typval_T *argvars, typval_T *rettv UNUSED)
3931{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003932 char_u *str;
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003933
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02003934 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
3935 return;
3936
3937 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003938 if (str != NULL && *str != NUL)
3939 {
3940 out_str(str);
3941 out_flush();
3942 }
3943}
3944
3945/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003946 * "empty({expr})" function
3947 */
3948 static void
3949f_empty(typval_T *argvars, typval_T *rettv)
3950{
3951 int n = FALSE;
3952
3953 switch (argvars[0].v_type)
3954 {
3955 case VAR_STRING:
3956 case VAR_FUNC:
3957 n = argvars[0].vval.v_string == NULL
3958 || *argvars[0].vval.v_string == NUL;
3959 break;
3960 case VAR_PARTIAL:
3961 n = FALSE;
3962 break;
3963 case VAR_NUMBER:
3964 n = argvars[0].vval.v_number == 0;
3965 break;
3966 case VAR_FLOAT:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003967 n = argvars[0].vval.v_float == 0.0;
3968 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003969 case VAR_LIST:
3970 n = argvars[0].vval.v_list == NULL
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003971 || argvars[0].vval.v_list->lv_len == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003972 break;
3973 case VAR_DICT:
3974 n = argvars[0].vval.v_dict == NULL
3975 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
3976 break;
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003977 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003978 case VAR_SPECIAL:
3979 n = argvars[0].vval.v_number != VVAL_TRUE;
3980 break;
Bram Moolenaar00b28d62022-12-08 15:32:33 +00003981 case VAR_CLASS:
3982 n = argvars[0].vval.v_class != NULL;
3983 break;
3984 case VAR_OBJECT:
Yegappan Lakshmanand3eae7b2024-03-03 16:26:58 +01003985 n = object_empty(argvars[0].vval.v_object);
Bram Moolenaar00b28d62022-12-08 15:32:33 +00003986 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003987
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003988 case VAR_BLOB:
3989 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003990 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
3991 break;
3992
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003993 case VAR_JOB:
3994#ifdef FEAT_JOB_CHANNEL
3995 n = argvars[0].vval.v_job == NULL
3996 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
3997 break;
3998#endif
3999 case VAR_CHANNEL:
4000#ifdef FEAT_JOB_CHANNEL
4001 n = argvars[0].vval.v_channel == NULL
4002 || !channel_is_open(argvars[0].vval.v_channel);
4003 break;
4004#endif
Yegappan Lakshmananec3cebb2023-10-27 19:35:26 +02004005 case VAR_TYPEALIAS:
4006 n = argvars[0].vval.v_typealias == NULL
4007 || argvars[0].vval.v_typealias->ta_name == NULL
4008 || *argvars[0].vval.v_typealias->ta_name == NUL;
4009 break;
4010
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004011 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02004012 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004013 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02004014 case VAR_INSTR:
Bram Moolenaardd589232020-02-29 17:38:12 +01004015 internal_error_no_abort("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004016 n = TRUE;
4017 break;
4018 }
4019
4020 rettv->vval.v_number = n;
4021}
4022
4023/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004024 * "environ()" function
4025 */
4026 static void
4027f_environ(typval_T *argvars UNUSED, typval_T *rettv)
4028{
4029#if !defined(AMIGA)
4030 int i = 0;
4031 char_u *entry, *value;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01004032# if defined (MSWIN)
4033# if !defined(_UCRT)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004034 extern wchar_t **_wenviron;
Bram Moolenaar68aaff42022-04-17 10:57:44 +01004035# endif
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004036# else
4037 extern char **environ;
4038# endif
4039
Bram Moolenaar93a10962022-06-16 11:42:09 +01004040 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaar691ddee2019-05-09 14:52:41 +02004041 return;
4042
4043# ifdef MSWIN
4044 if (*_wenviron == NULL)
4045 return;
4046# else
4047 if (*environ == NULL)
4048 return;
4049# endif
4050
4051 for (i = 0; ; ++i)
4052 {
4053# ifdef MSWIN
4054 short_u *p;
4055
4056 if ((p = (short_u *)_wenviron[i]) == NULL)
4057 return;
4058 entry = utf16_to_enc(p, NULL);
4059# else
4060 if ((entry = (char_u *)environ[i]) == NULL)
4061 return;
4062 entry = vim_strsave(entry);
4063# endif
4064 if (entry == NULL) // out of memory
4065 return;
4066 if ((value = vim_strchr(entry, '=')) == NULL)
4067 {
4068 vim_free(entry);
4069 continue;
4070 }
4071 *value++ = NUL;
4072 dict_add_string(rettv->vval.v_dict, (char *)entry, value);
4073 vim_free(entry);
4074 }
4075#endif
4076}
4077
4078/*
Bram Moolenaar80adaa82023-07-07 18:57:40 +01004079 * "err_teapot()" function
4080 */
4081 static void
4082f_err_teapot(typval_T *argvars, typval_T *rettv UNUSED)
4083{
4084 if (argvars[0].v_type != VAR_UNKNOWN)
4085 {
4086 if (argvars[0].v_type == VAR_STRING)
4087 {
4088 char_u *s = tv_get_string_strict(&argvars[0]);
Sean Dewarb0efa492023-07-08 10:35:19 +01004089 if (*skipwhite(s) == NUL)
Bram Moolenaar80adaa82023-07-07 18:57:40 +01004090 return;
4091 }
4092
4093 int err = FALSE;
4094 int do_503 = eval_expr_to_bool(&argvars[0], &err);
4095 if (!err && do_503)
4096 {
4097 emsg(_(e_coffee_currently_not_available));
4098 return;
4099 }
4100 }
4101
4102 emsg(_(e_im_a_teapot));
4103}
4104
4105/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004106 * "escape({string}, {chars})" function
4107 */
4108 static void
4109f_escape(typval_T *argvars, typval_T *rettv)
4110{
4111 char_u buf[NUMBUFLEN];
4112
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004113 if (in_vim9script()
4114 && (check_for_string_arg(argvars, 0) == FAIL
4115 || check_for_string_arg(argvars, 1) == FAIL))
4116 return;
4117
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004118 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
4119 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004120 rettv->v_type = VAR_STRING;
4121}
4122
4123/*
4124 * "eval()" function
4125 */
4126 static void
4127f_eval(typval_T *argvars, typval_T *rettv)
4128{
4129 char_u *s, *p;
4130
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004131 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4132 return;
4133
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004134 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004135 if (s != NULL)
4136 s = skipwhite(s);
4137
4138 p = s;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02004139 if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004140 {
4141 if (p != NULL && !aborting())
Bram Moolenaar108010a2021-06-27 22:03:33 +02004142 semsg(_(e_invalid_expression_str), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004143 need_clr_eos = FALSE;
4144 rettv->v_type = VAR_NUMBER;
4145 rettv->vval.v_number = 0;
4146 }
4147 else if (*s != NUL)
Bram Moolenaar74409f62022-01-01 15:58:22 +00004148 semsg(_(e_trailing_characters_str), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004149}
4150
4151/*
4152 * "eventhandler()" function
4153 */
4154 static void
4155f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
4156{
Bram Moolenaardfc33a62020-04-29 22:30:13 +02004157 rettv->vval.v_number = vgetc_busy || input_busy;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004158}
4159
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004160static garray_T redir_execute_ga;
4161
4162/*
4163 * Append "value[value_len]" to the execute() output.
4164 */
4165 void
4166execute_redir_str(char_u *value, int value_len)
4167{
4168 int len;
4169
4170 if (value_len == -1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004171 len = (int)STRLEN(value); // Append the entire string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004172 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004173 len = value_len; // Append only "value_len" characters
Yegappan Lakshmananfadc02a2023-01-27 21:03:12 +00004174 if (ga_grow(&redir_execute_ga, len) == FAIL)
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00004175 return;
4176
4177 mch_memmove((char *)redir_execute_ga.ga_data
4178 + redir_execute_ga.ga_len, value, len);
4179 redir_execute_ga.ga_len += len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004180}
4181
Dominique Pelle748b3082022-01-08 12:41:16 +00004182#if defined(FEAT_LUA) || defined(PROTO)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004183/*
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02004184 * Get next line from a string containing NL separated lines.
4185 * Called by do_cmdline() to get the next line.
4186 * Returns an allocated string, or NULL when at the end of the string.
4187 */
4188 static char_u *
4189get_str_line(
4190 int c UNUSED,
4191 void *cookie,
4192 int indent UNUSED,
4193 getline_opt_T options UNUSED)
4194{
4195 char_u *start = *(char_u **)cookie;
4196 char_u *line;
4197 char_u *p;
4198
4199 p = start;
4200 if (p == NULL || *p == NUL)
4201 return NULL;
4202 p = vim_strchr(p, '\n');
4203 if (p == NULL)
4204 line = vim_strsave(start);
4205 else
4206 {
4207 line = vim_strnsave(start, p - start);
4208 p++;
4209 }
4210
4211 *(char_u **)cookie = p;
4212 return line;
4213}
4214
4215/*
4216 * Execute a series of Ex commands in 'str'
4217 */
4218 void
4219execute_cmds_from_string(char_u *str)
4220{
4221 do_cmdline(NULL, get_str_line, (void *)&str,
4222 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
4223}
Dominique Pelle748b3082022-01-08 12:41:16 +00004224#endif
Yegappan Lakshmanan11328bc2021-08-06 21:34:38 +02004225
4226/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004227 * Get next line from a list.
4228 * Called by do_cmdline() to get the next line.
4229 * Returns allocated string, or NULL for end of function.
4230 */
Bram Moolenaara7583c42022-05-07 21:14:05 +01004231 char_u *
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004232get_list_line(
4233 int c UNUSED,
4234 void *cookie,
Bram Moolenaare96a2492019-06-25 04:12:16 +02004235 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02004236 getline_opt_T options UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004237{
4238 listitem_T **p = (listitem_T **)cookie;
4239 listitem_T *item = *p;
4240 char_u buf[NUMBUFLEN];
4241 char_u *s;
4242
4243 if (item == NULL)
4244 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004245 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004246 *p = item->li_next;
4247 return s == NULL ? NULL : vim_strsave(s);
4248}
4249
4250/*
4251 * "execute()" function
4252 */
Bram Moolenaar261f3462019-09-07 15:45:32 +02004253 void
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004254execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004255{
4256 char_u *cmd = NULL;
4257 list_T *list = NULL;
4258 int save_msg_silent = msg_silent;
4259 int save_emsg_silent = emsg_silent;
4260 int save_emsg_noredir = emsg_noredir;
4261 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01004262 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004263 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01004264 int save_msg_col = msg_col;
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004265 int save_sticky_cmdmod_flags = sticky_cmdmod_flags;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004266 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004267
4268 rettv->vval.v_string = NULL;
4269 rettv->v_type = VAR_STRING;
4270
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004271 if (argvars[arg_off].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004272 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004273 list = argvars[arg_off].vval.v_list;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004274 if (list == NULL || list->lv_len == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004275 // empty list, no commands, empty output
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004276 return;
4277 ++list->lv_refcount;
4278 }
Bram Moolenaare2a8f072020-01-08 19:32:18 +01004279 else if (argvars[arg_off].v_type == VAR_JOB
4280 || argvars[arg_off].v_type == VAR_CHANNEL)
4281 {
Bram Moolenaar68db9962021-05-09 23:19:22 +02004282 semsg(_(e_using_invalid_value_as_string_str),
4283 vartype_name(argvars[arg_off].v_type));
Bram Moolenaare2a8f072020-01-08 19:32:18 +01004284 return;
4285 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004286 else
4287 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004288 cmd = tv_get_string_chk(&argvars[arg_off]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004289 if (cmd == NULL)
4290 return;
4291 }
4292
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004293 if (argvars[arg_off + 1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004294 {
4295 char_u buf[NUMBUFLEN];
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02004296 char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf,
4297 in_vim9script());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004298
4299 if (s == NULL)
4300 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004301 if (*s == NUL)
4302 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004303 if (STRNCMP(s, "silent", 6) == 0)
4304 ++msg_silent;
4305 if (STRCMP(s, "silent!") == 0)
4306 {
4307 emsg_silent = TRUE;
4308 emsg_noredir = TRUE;
4309 }
4310 }
4311 else
4312 ++msg_silent;
4313
4314 if (redir_execute)
4315 save_ga = redir_execute_ga;
Bram Moolenaar04935fb2022-01-08 16:19:22 +00004316 ga_init2(&redir_execute_ga, sizeof(char), 500);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004317 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01004318 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004319 if (!echo_output)
4320 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004321
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004322 // For "legacy call execute('cmd')" and "vim9cmd execute('cmd')" apply the
4323 // command modifiers to "cmd".
4324 sticky_cmdmod_flags = cmdmod.cmod_flags & (CMOD_LEGACY | CMOD_VIM9CMD);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004325 if (cmd != NULL)
4326 do_cmdline_cmd(cmd);
4327 else
4328 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004329 listitem_T *item;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004330
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004331 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004332 item = list->lv_first;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004333 do_cmdline(NULL, get_list_line, (void *)&item,
4334 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
4335 --list->lv_refcount;
4336 }
Kota Kato3d3f6ac2022-08-04 18:50:14 +01004337 sticky_cmdmod_flags = save_sticky_cmdmod_flags;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004338
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004339 // Need to append a NUL to the result.
Bram Moolenaard297f352017-01-29 20:31:21 +01004340 if (ga_grow(&redir_execute_ga, 1) == OK)
4341 {
4342 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
4343 rettv->vval.v_string = redir_execute_ga.ga_data;
4344 }
4345 else
4346 {
4347 ga_clear(&redir_execute_ga);
4348 rettv->vval.v_string = NULL;
4349 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004350 msg_silent = save_msg_silent;
4351 emsg_silent = save_emsg_silent;
4352 emsg_noredir = save_emsg_noredir;
4353
4354 redir_execute = save_redir_execute;
4355 if (redir_execute)
4356 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01004357 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004358
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01004359 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01004360 if (echo_output)
4361 // When not working silently: put it in column zero. A following
4362 // "echon" will overwrite the message, unavoidably.
4363 msg_col = 0;
4364 else
4365 // When working silently: Put it back where it was, since nothing
4366 // should have been written.
4367 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004368}
4369
4370/*
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004371 * "execute()" function
4372 */
4373 static void
4374f_execute(typval_T *argvars, typval_T *rettv)
4375{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004376 if (in_vim9script()
4377 && (check_for_string_or_list_arg(argvars, 0) == FAIL
4378 || check_for_opt_string_arg(argvars, 1) == FAIL))
4379 return;
4380
Bram Moolenaar868b7b62019-05-29 21:44:40 +02004381 execute_common(argvars, rettv, 0);
4382}
4383
4384/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004385 * "exists()" function
4386 */
Bram Moolenaarbb7ee7a2021-08-02 20:06:50 +02004387 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004388f_exists(typval_T *argvars, typval_T *rettv)
4389{
4390 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004391 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004392
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004393 if (in_vim9script() && check_for_nonempty_string_arg(argvars, 0) == FAIL)
4394 return;
4395
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004396 p = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004397 if (*p == '$') // environment variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004398 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004399 // first try "normal" environment variables (fast)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004400 if (mch_getenv(p + 1) != NULL)
4401 n = TRUE;
4402 else
4403 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004404 // try expanding things like $VIM and ${HOME}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004405 p = expand_env_save(p);
4406 if (p != NULL && *p != '$')
4407 n = TRUE;
4408 vim_free(p);
4409 }
4410 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004411 else if (*p == '&' || *p == '+') // option
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004412 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004413 n = (eval_option(&p, NULL, TRUE) == OK);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004414 if (*skipwhite(p) != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004415 n = FALSE; // trailing garbage
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004416 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004417 else if (*p == '*') // internal or user defined function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004418 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02004419 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004420 }
Bram Moolenaar15c47602020-03-26 22:16:48 +01004421 else if (*p == '?') // internal function only
4422 {
4423 n = has_internal_func_name(p + 1);
4424 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004425 else if (*p == ':')
4426 {
4427 n = cmd_exists(p + 1);
4428 }
4429 else if (*p == '#')
4430 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004431 if (p[1] == '#')
4432 n = autocmd_supported(p + 2);
4433 else
4434 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004435 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004436 else // internal variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004437 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01004438 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004439 }
4440
4441 rettv->vval.v_number = n;
4442}
4443
Bram Moolenaar26735992021-08-08 14:43:22 +02004444 static void
4445f_exists_compiled(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4446{
4447 emsg(_(e_exists_compiled_can_only_be_used_in_def_function));
4448}
4449
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004450/*
4451 * "expand()" function
4452 */
4453 static void
4454f_expand(typval_T *argvars, typval_T *rettv)
4455{
4456 char_u *s;
4457 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004458 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4459 expand_T xpc;
4460 int error = FALSE;
4461 char_u *result;
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004462#ifdef BACKSLASH_IN_FILENAME
4463 char_u *p_csl_save = p_csl;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004464#endif
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004465
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02004466 if (in_vim9script()
4467 && (check_for_string_arg(argvars, 0) == FAIL
4468 || check_for_opt_bool_arg(argvars, 1) == FAIL
4469 || (argvars[1].v_type != VAR_UNKNOWN
4470 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
4471 return;
4472
4473#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004474 // avoid using 'completeslash' here
4475 p_csl = empty_option;
4476#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004477
4478 rettv->v_type = VAR_STRING;
4479 if (argvars[1].v_type != VAR_UNKNOWN
4480 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004481 && tv_get_bool_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004482 && !error)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004483 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004484
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004485 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004486 if (*s == '%' || *s == '#' || *s == '<')
4487 {
Bram Moolenaar57544522022-04-12 12:54:11 +01004488 char *errormsg = NULL;
4489
4490 if (p_verbose == 0)
4491 ++emsg_off;
Bram Moolenaara96edb72022-04-28 17:52:24 +01004492 result = eval_vars(s, s, &len, NULL, &errormsg, NULL, FALSE);
Bram Moolenaar57544522022-04-12 12:54:11 +01004493 if (p_verbose == 0)
4494 --emsg_off;
4495 else if (errormsg != NULL)
4496 emsg(errormsg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004497 if (rettv->v_type == VAR_LIST)
4498 {
Bram Moolenaar93a10962022-06-16 11:42:09 +01004499 if (rettv_list_alloc(rettv) == OK && result != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004500 list_append_string(rettv->vval.v_list, result, -1);
Bram Moolenaar86173482019-10-01 17:02:16 +02004501 vim_free(result);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004502 }
4503 else
4504 rettv->vval.v_string = result;
4505 }
4506 else
4507 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004508 // When the optional second argument is non-zero, don't remove matches
4509 // for 'wildignore' and don't put matches for 'suffixes' at the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004510 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02004511 && tv_get_bool_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004512 options |= WILD_KEEP_ALL;
4513 if (!error)
4514 {
4515 ExpandInit(&xpc);
4516 xpc.xp_context = EXPAND_FILES;
4517 if (p_wic)
4518 options += WILD_ICASE;
4519 if (rettv->v_type == VAR_STRING)
4520 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
4521 options, WILD_ALL);
Bram Moolenaar93a10962022-06-16 11:42:09 +01004522 else if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004523 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004524 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
Bram Moolenaar848db572022-09-20 19:04:32 +01004525 for (int i = 0; i < xpc.xp_numfiles; i++)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004526 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
4527 ExpandCleanup(&xpc);
4528 }
4529 }
4530 else
4531 rettv->vval.v_string = NULL;
4532 }
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02004533#ifdef BACKSLASH_IN_FILENAME
4534 p_csl = p_csl_save;
4535#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004536}
4537
4538/*
Bram Moolenaar80dad482019-06-09 17:22:31 +02004539 * "expandcmd()" function
4540 * Expand all the special characters in a command string.
4541 */
4542 static void
4543f_expandcmd(typval_T *argvars, typval_T *rettv)
4544{
4545 exarg_T eap;
4546 char_u *cmdstr;
4547 char *errormsg = NULL;
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004548 int emsgoff = TRUE;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004549
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004550 if (in_vim9script()
4551 && (check_for_string_arg(argvars, 0) == FAIL
4552 || check_for_opt_dict_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004553 return;
4554
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004555 if (argvars[1].v_type == VAR_DICT
Bram Moolenaard61efa52022-07-23 09:52:04 +01004556 && dict_get_bool(argvars[1].vval.v_dict, "errmsg", VVAL_FALSE))
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004557 emsgoff = FALSE;
4558
Bram Moolenaar80dad482019-06-09 17:22:31 +02004559 rettv->v_type = VAR_STRING;
4560 cmdstr = vim_strsave(tv_get_string(&argvars[0]));
4561
Yegappan Lakshmanan960dcbd2023-03-07 17:45:11 +00004562 CLEAR_FIELD(eap);
Bram Moolenaar80dad482019-06-09 17:22:31 +02004563 eap.cmd = cmdstr;
4564 eap.arg = cmdstr;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004565 eap.argt |= EX_NOSPC;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004566 eap.usefilter = FALSE;
4567 eap.nextcmd = NULL;
4568 eap.cmdidx = CMD_USER;
4569
Yegappan Lakshmanan2b74b682022-04-03 21:30:32 +01004570 if (emsgoff)
4571 ++emsg_off;
4572 if (expand_filename(&eap, &cmdstr, &errormsg) == FAIL)
4573 if (!emsgoff && errormsg != NULL && *errormsg != NUL)
4574 emsg(errormsg);
4575 if (emsgoff)
4576 --emsg_off;
Bram Moolenaar80dad482019-06-09 17:22:31 +02004577
4578 rettv->vval.v_string = cmdstr;
4579}
4580
4581/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004582 * "feedkeys()" function
4583 */
4584 static void
4585f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
4586{
4587 int remap = TRUE;
4588 int insert = FALSE;
4589 char_u *keys, *flags;
4590 char_u nbuf[NUMBUFLEN];
4591 int typed = FALSE;
4592 int execute = FALSE;
Bram Moolenaara9725222022-01-16 13:30:33 +00004593 int context = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004594 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004595 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004596
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004597 // This is not allowed in the sandbox. If the commands would still be
4598 // executed in the sandbox it would be OK, but it probably happens later,
4599 // when "sandbox" is no longer set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004600 if (check_secure())
4601 return;
4602
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004603 if (in_vim9script()
4604 && (check_for_string_arg(argvars, 0) == FAIL
4605 || check_for_opt_string_arg(argvars, 1) == FAIL))
4606 return;
4607
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004608 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004609
4610 if (argvars[1].v_type != VAR_UNKNOWN)
4611 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004612 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004613 for ( ; *flags != NUL; ++flags)
4614 {
4615 switch (*flags)
4616 {
4617 case 'n': remap = FALSE; break;
4618 case 'm': remap = TRUE; break;
4619 case 't': typed = TRUE; break;
4620 case 'i': insert = TRUE; break;
4621 case 'x': execute = TRUE; break;
Bram Moolenaara9725222022-01-16 13:30:33 +00004622 case 'c': context = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004623 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004624 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004625 }
4626 }
4627 }
4628
4629 if (*keys != NUL || execute)
4630 {
Christopher Plewright20b795e2022-12-20 20:01:58 +00004631 if (lowlevel
4632#ifdef FEAT_VTP
4633 && (!is_term_win32()
4634 || (keys[0] == 3 && ctrl_c_interrupts && typed))
4635#endif
4636 )
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004637 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004638#ifdef USE_INPUT_BUF
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004639 ch_log(NULL, "feedkeys() lowlevel: %s", keys);
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01004640
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004641 int len = (int)STRLEN(keys);
4642 for (int idx = 0; idx < len; ++idx)
4643 {
4644 // if a CTRL-C was typed, set got_int, similar to what
4645 // happens in fill_input_buf()
4646 if (keys[idx] == 3 && ctrl_c_interrupts && typed)
4647 got_int = TRUE;
4648 add_to_input_buf(keys + idx, 1);
4649 }
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004650#else
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004651 emsg(_(e_lowlevel_input_not_supported));
Bram Moolenaar5e66b422019-01-24 21:58:10 +01004652#endif
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004653 }
4654 else
4655 {
4656 // Need to escape K_SPECIAL and CSI before putting the string in
4657 // the typeahead buffer.
4658 char_u *keys_esc = vim_strsave_escape_csi(keys);
4659 if (keys_esc == NULL)
4660 return;
4661
4662 ch_log(NULL, "feedkeys(%s): %s", typed ? "typed" : "", keys);
4663
4664 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
4665 insert ? 0 : typebuf.tb_len, !typed, FALSE);
4666 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004667#ifdef FEAT_TIMERS
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004668 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02004669#endif
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004670 || input_busy)
4671 typebuf_was_filled = TRUE;
4672
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004673 vim_free(keys_esc);
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004674 }
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01004675
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004676 if (execute)
4677 {
4678 int save_msg_scroll = msg_scroll;
4679 sctx_T save_sctx;
4680
4681 // Avoid a 1 second delay when the keys start Insert mode.
4682 msg_scroll = FALSE;
4683
4684 ch_log(NULL, "feedkeys() executing");
4685
4686 if (context)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004687 {
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004688 save_sctx = current_sctx;
4689 current_sctx.sc_sid = 0;
4690 current_sctx.sc_version = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004691 }
Bram Moolenaarb55ae8c2022-12-02 13:37:36 +00004692
4693 if (!dangerous)
4694 {
4695 ++ex_normal_busy;
4696 ++in_feedkeys;
4697 }
4698 exec_normal(TRUE, lowlevel, TRUE);
4699 if (!dangerous)
4700 {
4701 --ex_normal_busy;
4702 --in_feedkeys;
4703 }
4704
4705 msg_scroll |= save_msg_scroll;
4706
4707 if (context)
4708 current_sctx = save_sctx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004709 }
4710 }
4711}
4712
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004713/*
4714 * "fnameescape({string})" function
4715 */
4716 static void
4717f_fnameescape(typval_T *argvars, typval_T *rettv)
4718{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004719 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
4720 return;
4721
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004722 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaar21c1a0c2021-10-17 17:20:23 +01004723 tv_get_string(&argvars[0]), VSE_NONE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004724 rettv->v_type = VAR_STRING;
4725}
4726
4727/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004728 * "foreground()" function
4729 */
4730 static void
4731f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4732{
4733#ifdef FEAT_GUI
4734 if (gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004735 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004736 gui_mch_set_foreground();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004737 return;
4738 }
4739#endif
4740#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004741 win32_set_foreground();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004742#endif
4743}
4744
Bakudankun375141e2022-09-09 18:46:47 +01004745/*
4746 * "function()" function
4747 * "funcref()" function
4748 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004749 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004750common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004751{
4752 char_u *s;
4753 char_u *name;
4754 int use_string = FALSE;
4755 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004756 char_u *trans_name = NULL;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004757 int is_global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004758
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004759 if (in_vim9script()
Bram Moolenaarae1068a2021-12-25 19:43:44 +00004760 && (check_for_string_or_func_arg(argvars, 0) == FAIL
4761 || check_for_opt_list_arg(argvars, 1) == FAIL
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02004762 || (argvars[1].v_type != VAR_UNKNOWN
4763 && check_for_opt_dict_arg(argvars, 2) == FAIL)))
4764 return;
4765
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004766 if (argvars[0].v_type == VAR_FUNC)
4767 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004768 // function(MyFunc, [arg], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004769 s = argvars[0].vval.v_string;
4770 }
4771 else if (argvars[0].v_type == VAR_PARTIAL
4772 && argvars[0].vval.v_partial != NULL)
4773 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004774 // function(dict.MyFunc, [arg])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004775 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004776 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004777 }
4778 else
4779 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004780 // function('MyFunc', [arg], dict)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004781 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004782 use_string = TRUE;
4783 }
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004784 if (s == NULL)
4785 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00004786 semsg(_(e_invalid_argument_str), "NULL");
Bram Moolenaar60b6e6f2021-08-28 12:49:27 +02004787 return;
4788 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004789
Bram Moolenaar843b8842016-08-21 14:36:15 +02004790 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004791 {
4792 name = s;
Bram Moolenaareba3b7f2021-11-30 18:25:08 +00004793 trans_name = save_function_name(&name, &is_global, FALSE,
4794 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004795 if (*name != NUL)
4796 s = NULL;
4797 }
4798
Bram Moolenaar843b8842016-08-21 14:36:15 +02004799 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
4800 || (is_funcref && trans_name == NULL))
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00004801 semsg(_(e_invalid_argument_str),
4802 use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004803 // Don't check an autoload name for existence here.
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004804 else if (trans_name != NULL && (is_funcref
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004805 ? find_func(trans_name, is_global) == NULL
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02004806 : !translated_function_exists(trans_name, is_global)))
Bram Moolenaara6f79292022-01-04 21:30:47 +00004807 semsg(_(e_unknown_function_str_2), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004808 else
4809 {
4810 int dict_idx = 0;
4811 int arg_idx = 0;
4812 list_T *list = NULL;
4813
4814 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004815 // Expand s: and <SID> into <SNR>nr_, so that the function can
4816 // also be called from another script. Using trans_function_name()
4817 // would also work, but some plugins depend on the name being
4818 // printable text.
Yegappan Lakshmanane7f4abd2021-12-24 20:47:38 +00004819 name = get_scriptlocal_funcname(s);
Bram Moolenaarc2f17f72022-02-21 13:13:50 +00004820 else if (trans_name != NULL && *trans_name == K_SPECIAL)
4821 name = alloc_printable_func_name(trans_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004822 else
4823 name = vim_strsave(s);
4824
4825 if (argvars[1].v_type != VAR_UNKNOWN)
4826 {
4827 if (argvars[2].v_type != VAR_UNKNOWN)
4828 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004829 // function(name, [args], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004830 arg_idx = 1;
4831 dict_idx = 2;
4832 }
4833 else if (argvars[1].v_type == VAR_DICT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004834 // function(name, dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004835 dict_idx = 1;
4836 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004837 // function(name, [args])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004838 arg_idx = 1;
4839 if (dict_idx > 0)
4840 {
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01004841 if (check_for_dict_arg(argvars, dict_idx) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004842 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004843 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004844 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004845 }
4846 if (argvars[dict_idx].vval.v_dict == NULL)
4847 dict_idx = 0;
4848 }
4849 if (arg_idx > 0)
4850 {
4851 if (argvars[arg_idx].v_type != VAR_LIST)
4852 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00004853 emsg(_(e_second_argument_of_function_must_be_list_or_dict));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004854 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004855 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004856 }
4857 list = argvars[arg_idx].vval.v_list;
4858 if (list == NULL || list->lv_len == 0)
4859 arg_idx = 0;
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004860 else if (list->lv_len > MAX_FUNC_ARGS)
4861 {
Yegappan Lakshmanan5018a832022-04-02 21:12:21 +01004862 emsg_funcname(e_too_many_arguments_for_function_str, s);
Bram Moolenaar4c054e92019-11-10 00:13:50 +01004863 vim_free(name);
4864 goto theend;
4865 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004866 }
4867 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004868 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004869 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004870 partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004871
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004872 // result is a VAR_PARTIAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004873 if (pt == NULL)
4874 vim_free(name);
4875 else
4876 {
4877 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
4878 {
4879 listitem_T *li;
4880 int i = 0;
4881 int arg_len = 0;
4882 int lv_len = 0;
4883
4884 if (arg_pt != NULL)
4885 arg_len = arg_pt->pt_argc;
4886 if (list != NULL)
4887 lv_len = list->lv_len;
4888 pt->pt_argc = arg_len + lv_len;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004889 pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004890 if (pt->pt_argv == NULL)
4891 {
4892 vim_free(pt);
4893 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004894 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004895 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004896 for (i = 0; i < arg_len; i++)
4897 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
4898 if (lv_len > 0)
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004899 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02004900 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004901 FOR_ALL_LIST_ITEMS(list, li)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004902 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004903 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004904 }
4905
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004906 // For "function(dict.func, [], dict)" and "func" is a partial
4907 // use "dict". That is backwards compatible.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004908 if (dict_idx > 0)
4909 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004910 // The dict is bound explicitly, pt_auto is FALSE.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004911 pt->pt_dict = argvars[dict_idx].vval.v_dict;
4912 ++pt->pt_dict->dv_refcount;
4913 }
4914 else if (arg_pt != NULL)
4915 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004916 // If the dict was bound automatically the result is also
4917 // bound automatically.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004918 pt->pt_dict = arg_pt->pt_dict;
4919 pt->pt_auto = arg_pt->pt_auto;
4920 if (pt->pt_dict != NULL)
4921 ++pt->pt_dict->dv_refcount;
Yegappan Lakshmanan29bb67f2023-10-14 11:18:50 +02004922 pt->pt_obj = arg_pt->pt_obj;
4923 if (pt->pt_obj != NULL)
4924 ++pt->pt_obj->obj_refcount;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004925 }
4926
4927 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004928 if (arg_pt != NULL && arg_pt->pt_func != NULL)
4929 {
4930 pt->pt_func = arg_pt->pt_func;
4931 func_ptr_ref(pt->pt_func);
4932 vim_free(name);
4933 }
4934 else if (is_funcref)
4935 {
Bram Moolenaard9d2fd02022-01-13 21:15:21 +00004936 pt->pt_func = find_func(trans_name, is_global);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004937 func_ptr_ref(pt->pt_func);
4938 vim_free(name);
4939 }
4940 else
4941 {
4942 pt->pt_name = name;
4943 func_ref(name);
4944 }
Bram Moolenaar92368aa2022-02-07 17:50:39 +00004945
4946 if (arg_pt != NULL)
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00004947 {
4948 pt->pt_outer_partial = arg_pt;
4949 ++arg_pt->pt_refcount;
4950 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004951 }
4952 rettv->v_type = VAR_PARTIAL;
4953 rettv->vval.v_partial = pt;
4954 }
4955 else
4956 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004957 // result is a VAR_FUNC
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004958 rettv->v_type = VAR_FUNC;
4959 rettv->vval.v_string = name;
4960 func_ref(name);
4961 }
4962 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004963theend:
4964 vim_free(trans_name);
4965}
4966
4967/*
4968 * "funcref()" function
4969 */
4970 static void
4971f_funcref(typval_T *argvars, typval_T *rettv)
4972{
4973 common_function(argvars, rettv, TRUE);
4974}
4975
4976/*
4977 * "function()" function
4978 */
4979 static void
4980f_function(typval_T *argvars, typval_T *rettv)
4981{
4982 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004983}
4984
4985/*
4986 * "garbagecollect()" function
4987 */
4988 static void
4989f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
4990{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02004991 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
4992 return;
4993
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004994 // This is postponed until we are back at the toplevel, because we may be
4995 // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004996 want_garbage_collect = TRUE;
4997
Bram Moolenaar2df47312020-09-05 17:30:44 +02004998 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004999 garbage_collect_at_exit = TRUE;
5000}
5001
5002/*
5003 * "get()" function
5004 */
5005 static void
5006f_get(typval_T *argvars, typval_T *rettv)
5007{
5008 listitem_T *li;
5009 list_T *l;
5010 dictitem_T *di;
5011 dict_T *d;
5012 typval_T *tv = NULL;
Bram Moolenaarf91aac52019-07-28 13:21:01 +02005013 int what_is_dict = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005014
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005015 if (argvars[0].v_type == VAR_BLOB)
5016 {
5017 int error = FALSE;
5018 int idx = tv_get_number_chk(&argvars[1], &error);
5019
5020 if (!error)
5021 {
5022 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01005023 if (idx < 0)
5024 idx = blob_len(argvars[0].vval.v_blob) + idx;
5025 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
5026 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005027 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01005028 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005029 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01005030 tv = rettv;
5031 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005032 }
5033 }
5034 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005035 {
5036 if ((l = argvars[0].vval.v_list) != NULL)
5037 {
5038 int error = FALSE;
5039
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005040 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005041 if (!error && li != NULL)
5042 tv = &li->li_tv;
5043 }
5044 }
5045 else if (argvars[0].v_type == VAR_DICT)
5046 {
5047 if ((d = argvars[0].vval.v_dict) != NULL)
5048 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005049 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005050 if (di != NULL)
5051 tv = &di->di_tv;
5052 }
5053 }
5054 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
5055 {
5056 partial_T *pt;
5057 partial_T fref_pt;
5058
5059 if (argvars[0].v_type == VAR_PARTIAL)
5060 pt = argvars[0].vval.v_partial;
5061 else
5062 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02005063 CLEAR_FIELD(fref_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005064 fref_pt.pt_name = argvars[0].vval.v_string;
5065 pt = &fref_pt;
5066 }
5067
5068 if (pt != NULL)
5069 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005070 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005071
5072 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
5073 {
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01005074 char_u *name = partial_name(pt);
5075
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005076 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01005077 if (name == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005078 rettv->vval.v_string = NULL;
5079 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005080 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005081 if (rettv->v_type == VAR_FUNC)
Bram Moolenaar1ae8c262022-06-27 11:45:52 +01005082 func_ref(name);
5083 if (*what == 'n' && pt->pt_name == NULL
5084 && pt->pt_func != NULL)
5085 // use <SNR> instead of the byte code
5086 name = printable_func_name(pt->pt_func);
5087 rettv->vval.v_string = vim_strsave(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005088 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005089 }
5090 else if (STRCMP(what, "dict") == 0)
Bram Moolenaarf91aac52019-07-28 13:21:01 +02005091 {
5092 what_is_dict = TRUE;
5093 if (pt->pt_dict != NULL)
5094 rettv_dict_set(rettv, pt->pt_dict);
5095 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005096 else if (STRCMP(what, "args") == 0)
5097 {
5098 rettv->v_type = VAR_LIST;
5099 if (rettv_list_alloc(rettv) == OK)
5100 {
5101 int i;
5102
5103 for (i = 0; i < pt->pt_argc; ++i)
5104 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
5105 }
5106 }
5107 else
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00005108 semsg(_(e_invalid_argument_str), what);
Bram Moolenaarf91aac52019-07-28 13:21:01 +02005109
5110 // When {what} == "dict" and pt->pt_dict == NULL, evaluate the
5111 // third argument
5112 if (!what_is_dict)
5113 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005114 }
5115 }
5116 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00005117 semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005118
5119 if (tv == NULL)
5120 {
5121 if (argvars[2].v_type != VAR_UNKNOWN)
5122 copy_tv(&argvars[2], rettv);
5123 }
5124 else
5125 copy_tv(tv, rettv);
5126}
5127
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005128/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005129 * "getchangelist()" function
5130 */
5131 static void
5132f_getchangelist(typval_T *argvars, typval_T *rettv)
5133{
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005134 buf_T *buf;
5135 int i;
5136 list_T *l;
5137 dict_T *d;
LemonBoydb0ea7f2022-04-10 17:59:26 +01005138 int changelistindex;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005139
Bram Moolenaar93a10962022-06-16 11:42:09 +01005140 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005141 return;
5142
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005143 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
5144 return;
5145
Bram Moolenaar4c313b12019-08-24 22:58:31 +02005146 if (argvars[0].v_type == VAR_UNKNOWN)
5147 buf = curbuf;
5148 else
Bram Moolenaara5d38412020-09-02 21:02:35 +02005149 buf = tv_get_buf_from_arg(&argvars[0]);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005150 if (buf == NULL)
5151 return;
5152
5153 l = list_alloc();
5154 if (l == NULL)
5155 return;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005156 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005157 {
5158 vim_free(l);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005159 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005160 }
5161
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005162 /*
LemonBoydb0ea7f2022-04-10 17:59:26 +01005163 * The current window change list index tracks only the position for the
5164 * current buffer. For other buffers use the stored index for the current
5165 * window, or, if that's not available, the change list length.
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005166 */
LemonBoydb0ea7f2022-04-10 17:59:26 +01005167 if (buf == curwin->w_buffer)
5168 {
5169 changelistindex = curwin->w_changelistidx;
5170 }
5171 else
5172 {
5173 wininfo_T *wip;
5174
5175 FOR_ALL_BUF_WININFO(buf, wip)
5176 if (wip->wi_win == curwin)
5177 break;
5178 changelistindex = wip != NULL ? wip->wi_changelistidx
5179 : buf->b_changelistlen;
5180 }
5181 list_append_number(rettv->vval.v_list, (varnumber_T)changelistindex);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005182
5183 for (i = 0; i < buf->b_changelistlen; ++i)
5184 {
5185 if (buf->b_changelist[i].lnum == 0)
5186 continue;
5187 if ((d = dict_alloc()) == NULL)
5188 return;
5189 if (list_append_dict(l, d) == FAIL)
5190 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005191 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
5192 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005193 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005194 }
Bram Moolenaar07ad8162018-02-13 13:59:59 +01005195}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005196
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005197 static void
5198getpos_both(
5199 typval_T *argvars,
5200 typval_T *rettv,
5201 int getcurpos,
5202 int charcol)
5203{
5204 pos_T *fp = NULL;
5205 pos_T pos;
5206 win_T *wp = curwin;
5207 list_T *l;
5208 int fnum = -1;
5209
5210 if (rettv_list_alloc(rettv) == OK)
5211 {
5212 l = rettv->vval.v_list;
5213 if (getcurpos)
5214 {
5215 if (argvars[0].v_type != VAR_UNKNOWN)
5216 {
5217 wp = find_win_by_nr_or_id(&argvars[0]);
5218 if (wp != NULL)
5219 fp = &wp->w_cursor;
5220 }
5221 else
5222 fp = &curwin->w_cursor;
5223 if (fp != NULL && charcol)
5224 {
5225 pos = *fp;
Bram Moolenaar91458462021-01-13 20:08:38 +01005226 pos.col =
5227 buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005228 fp = &pos;
5229 }
5230 }
5231 else
5232 fp = var2fpos(&argvars[0], TRUE, &fnum, charcol);
5233 if (fnum != -1)
5234 list_append_number(l, (varnumber_T)fnum);
5235 else
5236 list_append_number(l, (varnumber_T)0);
5237 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
5238 : (varnumber_T)0);
5239 list_append_number(l, (fp != NULL)
5240 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
5241 : (varnumber_T)0);
5242 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
5243 (varnumber_T)0);
5244 if (getcurpos)
5245 {
5246 int save_set_curswant = curwin->w_set_curswant;
5247 colnr_T save_curswant = curwin->w_curswant;
5248 colnr_T save_virtcol = curwin->w_virtcol;
5249
5250 if (wp == curwin)
5251 update_curswant();
5252 list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL
5253 ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1);
5254
5255 // Do not change "curswant", as it is unexpected that a get
5256 // function has a side effect.
5257 if (wp == curwin && save_set_curswant)
5258 {
5259 curwin->w_set_curswant = save_set_curswant;
5260 curwin->w_curswant = save_curswant;
5261 curwin->w_virtcol = save_virtcol;
5262 curwin->w_valid &= ~VALID_VIRTCOL;
5263 }
5264 }
5265 }
5266 else
5267 rettv->vval.v_number = FALSE;
5268}
5269
5270/*
5271 * "getcharpos()" function
5272 */
5273 static void
5274f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv)
5275{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005276 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5277 return;
5278
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005279 getpos_both(argvars, rettv, FALSE, TRUE);
5280}
5281
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005282/*
5283 * "getcharsearch()" function
5284 */
5285 static void
5286f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
5287{
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00005288 if (rettv_dict_alloc(rettv) != OK)
5289 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005290
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00005291 dict_T *dict = rettv->vval.v_dict;
5292
5293 dict_add_string(dict, "char", last_csearch());
5294 dict_add_number(dict, "forward", last_csearch_forward());
5295 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005296}
5297
5298/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005299 * "getenv()" function
5300 */
5301 static void
5302f_getenv(typval_T *argvars, typval_T *rettv)
5303{
5304 int mustfree = FALSE;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005305 char_u *p;
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005306
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005307 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5308 return;
5309
5310 p = vim_getenv(tv_get_string(&argvars[0]), &mustfree);
Bram Moolenaar691ddee2019-05-09 14:52:41 +02005311 if (p == NULL)
5312 {
5313 rettv->v_type = VAR_SPECIAL;
5314 rettv->vval.v_number = VVAL_NULL;
5315 return;
5316 }
5317 if (!mustfree)
5318 p = vim_strsave(p);
5319 rettv->vval.v_string = p;
5320 rettv->v_type = VAR_STRING;
5321}
5322
5323/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005324 * "getfontname()" function
5325 */
5326 static void
5327f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
5328{
5329 rettv->v_type = VAR_STRING;
5330 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005331
5332 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5333 return;
5334
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005335#ifdef FEAT_GUI
5336 if (gui.in_use)
5337 {
5338 GuiFont font;
5339 char_u *name = NULL;
5340
5341 if (argvars[0].v_type == VAR_UNKNOWN)
5342 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005343 // Get the "Normal" font. Either the name saved by
5344 // hl_set_font_name() or from the font ID.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005345 font = gui.norm_font;
5346 name = hl_get_font_name();
5347 }
5348 else
5349 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005350 name = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005351 if (STRCMP(name, "*") == 0) // don't use font dialog
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005352 return;
5353 font = gui_mch_get_font(name, FALSE);
5354 if (font == NOFONT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005355 return; // Invalid font name, return empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005356 }
5357 rettv->vval.v_string = gui_mch_get_fontname(font, name);
5358 if (argvars[0].v_type != VAR_UNKNOWN)
5359 gui_mch_free_font(font);
5360 }
5361#endif
5362}
5363
5364/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01005365 * "getjumplist()" function
5366 */
5367 static void
5368f_getjumplist(typval_T *argvars, typval_T *rettv)
5369{
Bram Moolenaar4f505882018-02-10 21:06:32 +01005370 win_T *wp;
5371 int i;
5372 list_T *l;
5373 dict_T *d;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005374
Bram Moolenaar93a10962022-06-16 11:42:09 +01005375 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar4f505882018-02-10 21:06:32 +01005376 return;
5377
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005378 if (in_vim9script()
5379 && (check_for_opt_number_arg(argvars, 0) == FAIL
5380 || (argvars[0].v_type != VAR_UNKNOWN
5381 && check_for_opt_number_arg(argvars, 1) == FAIL)))
5382 return;
5383
Bram Moolenaar00aa0692019-04-27 20:37:57 +02005384 wp = find_tabwin(&argvars[0], &argvars[1], NULL);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005385 if (wp == NULL)
5386 return;
5387
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01005388 cleanup_jumplist(wp, TRUE);
5389
Bram Moolenaar4f505882018-02-10 21:06:32 +01005390 l = list_alloc();
5391 if (l == NULL)
5392 return;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005393 if (list_append_list(rettv->vval.v_list, l) == FAIL)
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005394 {
5395 vim_free(l);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005396 return;
Bram Moolenaar9ba61942022-08-31 11:25:06 +01005397 }
5398
Bram Moolenaar4f505882018-02-10 21:06:32 +01005399 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
5400
5401 for (i = 0; i < wp->w_jumplistlen; ++i)
5402 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005403 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
5404 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005405 if ((d = dict_alloc()) == NULL)
5406 return;
5407 if (list_append_dict(l, d) == FAIL)
5408 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005409 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
5410 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005411 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005412 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005413 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02005414 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005415 }
Bram Moolenaar4f505882018-02-10 21:06:32 +01005416}
5417
5418/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005419 * "getpid()" function
5420 */
5421 static void
5422f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
5423{
5424 rettv->vval.v_number = mch_get_pid();
5425}
5426
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005427/*
5428 * "getcurpos()" function
5429 */
5430 static void
5431f_getcurpos(typval_T *argvars, typval_T *rettv)
5432{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005433 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5434 return;
5435
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005436 getpos_both(argvars, rettv, TRUE, FALSE);
5437}
5438
5439 static void
5440f_getcursorcharpos(typval_T *argvars, typval_T *rettv)
5441{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005442 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5443 return;
5444
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005445 getpos_both(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005446}
5447
5448/*
5449 * "getpos(string)" function
5450 */
5451 static void
5452f_getpos(typval_T *argvars, typval_T *rettv)
5453{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005454 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
5455 return;
5456
Bram Moolenaar6f02b002021-01-10 20:22:54 +01005457 getpos_both(argvars, rettv, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005458}
5459
5460/*
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005461 * Convert from block_def to string
5462 */
5463 static char_u *
5464block_def2str(struct block_def *bd)
5465{
5466 char_u *p, *ret;
5467 size_t size = bd->startspaces + bd->endspaces + bd->textlen;
5468
5469 ret = alloc(size + 1);
5470 if (ret != NULL)
5471 {
5472 p = ret;
5473 vim_memset(p, ' ', bd->startspaces);
5474 p += bd->startspaces;
5475 mch_memmove(p, bd->textstart, bd->textlen);
5476 p += bd->textlen;
5477 vim_memset(p, ' ', bd->endspaces);
5478 *(p + bd->endspaces) = NUL;
5479 }
5480 return ret;
5481}
5482
5483/*
5484 * "getregion()" function
5485 */
5486 static void
5487f_getregion(typval_T *argvars, typval_T *rettv)
5488{
5489 linenr_T lnum;
zeertzjq5e3674b2024-02-22 19:51:34 +01005490 oparg_T oa;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005491 struct block_def bd;
5492 char_u *akt = NULL;
5493 int inclusive = TRUE;
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005494 int fnum1 = -1, fnum2 = -1;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005495 pos_T p1, p2;
Shougo Matsushita19b71882024-02-28 22:48:12 +01005496 char_u *type;
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005497 buf_T *save_curbuf = curbuf;
zeertzjq26dd09a2024-03-10 15:46:58 +01005498 buf_T *findbuf = curbuf;
Shougo Matsushita19b71882024-02-28 22:48:12 +01005499 char_u default_type[] = "v";
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005500 int save_virtual = -1;
5501 int l;
5502 int region_type = -1;
Shougo Matsushita19b71882024-02-28 22:48:12 +01005503 int is_select_exclusive;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005504
5505 if (rettv_list_alloc(rettv) == FAIL)
5506 return;
5507
Shougo Matsushita19b71882024-02-28 22:48:12 +01005508 if (check_for_list_arg(argvars, 0) == FAIL
5509 || check_for_list_arg(argvars, 1) == FAIL
5510 || check_for_opt_dict_arg(argvars, 2) == FAIL)
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005511 return;
5512
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005513 if (list2fpos(&argvars[0], &p1, &fnum1, NULL, FALSE) != OK
5514 || list2fpos(&argvars[1], &p2, &fnum2, NULL, FALSE) != OK
5515 || fnum1 != fnum2)
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005516 return;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005517
Shougo Matsushita19b71882024-02-28 22:48:12 +01005518 if (argvars[2].v_type == VAR_DICT)
5519 {
5520 is_select_exclusive = dict_get_bool(
5521 argvars[2].vval.v_dict, "exclusive", *p_sel == 'e');
5522 type = dict_get_string(
5523 argvars[2].vval.v_dict, "type", FALSE);
5524 if (type == NULL)
5525 type = default_type;
5526 }
5527 else
5528 {
5529 is_select_exclusive = *p_sel == 'e';
5530 type = default_type;
5531 }
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005532
5533 if (type[0] == 'v' && type[1] == NUL)
5534 region_type = MCHAR;
5535 else if (type[0] == 'V' && type[1] == NUL)
5536 region_type = MLINE;
5537 else if (type[0] == Ctrl_V && type[1] == NUL)
5538 region_type = MBLOCK;
5539 else
zeertzjq26dd09a2024-03-10 15:46:58 +01005540 {
5541 semsg(_(e_invalid_value_for_argument_str_str), "type", type);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005542 return;
zeertzjq26dd09a2024-03-10 15:46:58 +01005543 }
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005544
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005545 if (fnum1 != 0)
5546 {
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005547 findbuf = buflist_findnr(fnum1);
5548 // buffer not loaded
5549 if (findbuf == NULL || findbuf->b_ml.ml_mfp == NULL)
zeertzjq26dd09a2024-03-10 15:46:58 +01005550 {
5551 emsg(_(e_buffer_is_not_loaded));
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005552 return;
zeertzjq26dd09a2024-03-10 15:46:58 +01005553 }
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005554 }
5555
zeertzjq26dd09a2024-03-10 15:46:58 +01005556 if (p1.lnum < 1 || p1.lnum > findbuf->b_ml.ml_line_count)
5557 {
5558 semsg(_(e_invalid_line_number_nr), p1.lnum);
5559 return;
5560 }
5561 if (p1.col < 1 || p1.col > ml_get_buf_len(findbuf, p1.lnum) + 1)
5562 {
5563 semsg(_(e_invalid_column_number_nr), p1.col);
5564 return;
5565 }
5566 if (p2.lnum < 1 || p2.lnum > findbuf->b_ml.ml_line_count)
5567 {
5568 semsg(_(e_invalid_line_number_nr), p2.lnum);
5569 return;
5570 }
5571 if (p2.col < 1 || p2.col > ml_get_buf_len(findbuf, p2.lnum) + 1)
5572 {
5573 semsg(_(e_invalid_column_number_nr), p2.col);
5574 return;
5575 }
5576
5577 curbuf = findbuf;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005578 save_virtual = virtual_op;
5579 virtual_op = virtual_active();
5580
Shougo Matsushita19b71882024-02-28 22:48:12 +01005581 // NOTE: Adjust is needed.
5582 p1.col--;
5583 p2.col--;
5584
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005585 if (!LT_POS(p1, p2))
5586 {
5587 // swap position
5588 pos_T p;
5589
5590 p = p1;
5591 p1 = p2;
5592 p2 = p;
5593 }
5594
5595 if (region_type == MCHAR)
5596 {
5597 // handle 'selection' == "exclusive"
Shougo Matsushita19b71882024-02-28 22:48:12 +01005598 if (is_select_exclusive && !EQUAL_POS(p1, p2))
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005599 {
5600 if (p2.coladd > 0)
5601 p2.coladd--;
5602 else if (p2.col > 0)
5603 {
5604 p2.col--;
5605
5606 mb_adjustpos(curbuf, &p2);
5607 }
5608 else if (p2.lnum > 1)
5609 {
5610 p2.lnum--;
zeertzjq26dd09a2024-03-10 15:46:58 +01005611 p2.col = ml_get_len(p2.lnum);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005612 if (p2.col > 0)
5613 {
5614 p2.col--;
5615
5616 mb_adjustpos(curbuf, &p2);
5617 }
5618 }
5619 }
5620 // if fp2 is on NUL (empty line) inclusive becomes false
5621 if (*ml_get_pos(&p2) == NUL && !virtual_op)
5622 inclusive = FALSE;
5623 }
5624 else if (region_type == MBLOCK)
5625 {
5626 colnr_T sc1, ec1, sc2, ec2;
5627
5628 getvvcol(curwin, &p1, &sc1, NULL, &ec1);
5629 getvvcol(curwin, &p2, &sc2, NULL, &ec2);
zeertzjq5e3674b2024-02-22 19:51:34 +01005630 oa.motion_type = MBLOCK;
5631 oa.inclusive = TRUE;
5632 oa.op_type = OP_NOP;
5633 oa.start = p1;
5634 oa.end = p2;
5635 oa.start_vcol = MIN(sc1, sc2);
Shougo Matsushita19b71882024-02-28 22:48:12 +01005636 if (is_select_exclusive && ec1 < sc2 && 0 < sc2 && ec2 > ec1)
zeertzjq5e3674b2024-02-22 19:51:34 +01005637 oa.end_vcol = sc2 - 1;
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005638 else
zeertzjq5e3674b2024-02-22 19:51:34 +01005639 oa.end_vcol = MAX(ec1, ec2);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005640 }
5641
5642 // Include the trailing byte of a multi-byte char.
5643 l = utfc_ptr2len((char_u *)ml_get_pos(&p2));
5644 if (l > 1)
5645 p2.col += l - 1;
5646
5647 for (lnum = p1.lnum; lnum <= p2.lnum; lnum++)
5648 {
5649 int ret = 0;
5650
5651 if (region_type == MLINE)
5652 akt = vim_strsave(ml_get(lnum));
5653 else if (region_type == MBLOCK)
5654 {
zeertzjq5e3674b2024-02-22 19:51:34 +01005655 block_prep(&oa, &bd, lnum, FALSE);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005656 akt = block_def2str(&bd);
5657 }
5658 else if (p1.lnum < lnum && lnum < p2.lnum)
5659 akt = vim_strsave(ml_get(lnum));
5660 else
5661 {
5662 charwise_block_prep(p1, p2, &bd, lnum, inclusive);
5663 akt = block_def2str(&bd);
5664 }
5665
5666 if (akt)
5667 {
5668 ret = list_append_string(rettv->vval.v_list, akt, -1);
5669 vim_free(akt);
5670 }
5671
5672 if (akt == NULL || ret == FAIL)
5673 {
zeertzjq5e3674b2024-02-22 19:51:34 +01005674 clear_tv(rettv);
5675 (void)rettv_list_alloc(rettv);
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005676 break;
5677 }
5678 }
5679
Shougo Matsushita84bf6e62024-03-06 21:10:18 +01005680 if (curbuf != save_curbuf)
5681 curbuf = save_curbuf;
5682
Shougo Matsushita3f905ab2024-02-21 00:02:45 +01005683 virtual_op = save_virtual;
5684}
5685
5686/*
zeertzjqd3f00f52021-12-24 12:02:43 +00005687 * Common between getreg(), getreginfo() and getregtype(): get the register
5688 * name from the first argument.
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005689 * Returns zero on error.
5690 */
5691 static int
5692getreg_get_regname(typval_T *argvars)
5693{
5694 char_u *strregname;
5695
5696 if (argvars[0].v_type != VAR_UNKNOWN)
5697 {
5698 strregname = tv_get_string_chk(&argvars[0]);
5699 if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1)
5700 {
5701 semsg(_(e_register_name_must_be_one_char_str), strregname);
5702 strregname = NULL;
5703 }
5704 if (strregname == NULL) // type error; errmsg already given
5705 return 0;
5706 }
5707 else
5708 // Default to v:register
5709 strregname = get_vim_var_str(VV_REG);
5710
5711 return *strregname == 0 ? '"' : *strregname;
5712}
5713
5714/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005715 * "getreg()" function
5716 */
5717 static void
5718f_getreg(typval_T *argvars, typval_T *rettv)
5719{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005720 int regname;
5721 int arg2 = FALSE;
5722 int return_list = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005723
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005724 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005725 && (check_for_opt_string_arg(argvars, 0) == FAIL
5726 || (argvars[0].v_type != VAR_UNKNOWN
5727 && (check_for_opt_bool_arg(argvars, 1) == FAIL
5728 || (argvars[1].v_type != VAR_UNKNOWN
5729 && check_for_opt_bool_arg(argvars, 2) == FAIL)))))
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02005730 return;
5731
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005732 regname = getreg_get_regname(argvars);
5733 if (regname == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005734 return;
5735
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005736 if (argvars[0].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_UNKNOWN)
5737 {
5738 int error = FALSE;
5739
5740 arg2 = (int)tv_get_bool_chk(&argvars[1], &error);
5741
5742 if (!error && argvars[2].v_type != VAR_UNKNOWN)
5743 return_list = (int)tv_get_bool_chk(&argvars[2], &error);
5744 if (error)
5745 return;
5746 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005747
5748 if (return_list)
5749 {
5750 rettv->v_type = VAR_LIST;
5751 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
5752 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
5753 if (rettv->vval.v_list == NULL)
5754 (void)rettv_list_alloc(rettv);
5755 else
5756 ++rettv->vval.v_list->lv_refcount;
5757 }
5758 else
5759 {
5760 rettv->v_type = VAR_STRING;
5761 rettv->vval.v_string = get_reg_contents(regname,
5762 arg2 ? GREG_EXPR_SRC : 0);
5763 }
5764}
5765
5766/*
5767 * "getregtype()" function
5768 */
5769 static void
5770f_getregtype(typval_T *argvars, typval_T *rettv)
5771{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005772 int regname;
5773 char_u buf[NUMBUFLEN + 2];
5774 long reglen = 0;
5775
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005776 // on error return an empty string
5777 rettv->v_type = VAR_STRING;
5778 rettv->vval.v_string = NULL;
5779
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005780 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
5781 return;
5782
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005783 regname = getreg_get_regname(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005784 if (regname == 0)
Bram Moolenaar51e64b22021-12-24 10:48:30 +00005785 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005786
5787 buf[0] = NUL;
5788 buf[1] = NUL;
5789 switch (get_reg_type(regname, &reglen))
5790 {
5791 case MLINE: buf[0] = 'V'; break;
5792 case MCHAR: buf[0] = 'v'; break;
5793 case MBLOCK:
5794 buf[0] = Ctrl_V;
5795 sprintf((char *)buf + 1, "%ld", reglen + 1);
5796 break;
5797 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005798 rettv->vval.v_string = vim_strsave(buf);
5799}
5800
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005801/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005802 * "gettagstack()" function
5803 */
5804 static void
5805f_gettagstack(typval_T *argvars, typval_T *rettv)
5806{
5807 win_T *wp = curwin; // default is current window
5808
Bram Moolenaar93a10962022-06-16 11:42:09 +01005809 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005810 return;
5811
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005812 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
5813 return;
5814
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005815 if (argvars[0].v_type != VAR_UNKNOWN)
5816 {
5817 wp = find_win_by_nr_or_id(&argvars[0]);
5818 if (wp == NULL)
5819 return;
5820 }
5821
5822 get_tagstack(wp, rettv->vval.v_dict);
5823}
5824
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005825/*
5826 * "gettext()" function
5827 */
5828 static void
5829f_gettext(typval_T *argvars, typval_T *rettv)
5830{
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01005831 if (check_for_nonempty_string_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02005832 return;
5833
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01005834 rettv->v_type = VAR_STRING;
5835 rettv->vval.v_string = vim_strsave((char_u *)_(argvars[0].vval.v_string));
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02005836}
5837
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005838// for VIM_VERSION_ defines
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005839#include "version.h"
5840
5841/*
5842 * "has()" function
5843 */
Bram Moolenaara259d8d2020-01-31 20:10:50 +01005844 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005845f_has(typval_T *argvars, typval_T *rettv)
5846{
5847 int i;
5848 char_u *name;
Bram Moolenaar79296512020-03-22 16:17:14 +01005849 int x = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005850 int n = FALSE;
Bram Moolenaar79296512020-03-22 16:17:14 +01005851 typedef struct {
5852 char *name;
5853 short present;
5854 } has_item_T;
5855 static has_item_T has_list[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005856 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005857 {"amiga",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005858#ifdef AMIGA
Bram Moolenaar79296512020-03-22 16:17:14 +01005859 1
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005860#else
Bram Moolenaar79296512020-03-22 16:17:14 +01005861 0
Bram Moolenaar39536dd2019-01-29 22:58:21 +01005862#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005863 },
5864 {"arp",
5865#if defined(AMIGA) && defined(FEAT_ARP)
5866 1
5867#else
5868 0
5869#endif
5870 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005871 {"haiku",
5872#ifdef __HAIKU__
5873 1
5874#else
5875 0
5876#endif
5877 },
5878 {"bsd",
5879#if defined(BSD) && !defined(MACOS_X)
5880 1
5881#else
5882 0
5883#endif
5884 },
5885 {"hpux",
5886#ifdef hpux
5887 1
5888#else
5889 0
5890#endif
5891 },
5892 {"linux",
5893#ifdef __linux__
5894 1
5895#else
5896 0
5897#endif
5898 },
5899 {"mac", // Mac OS X (and, once, Mac OS Classic)
5900#ifdef MACOS_X
5901 1
5902#else
5903 0
5904#endif
5905 },
5906 {"osx", // Mac OS X
5907#ifdef MACOS_X
5908 1
5909#else
5910 0
5911#endif
5912 },
5913 {"macunix", // Mac OS X, with the darwin feature
5914#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5915 1
5916#else
5917 0
5918#endif
5919 },
5920 {"osxdarwin", // synonym for macunix
5921#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
5922 1
5923#else
5924 0
5925#endif
5926 },
5927 {"qnx",
5928#ifdef __QNX__
5929 1
5930#else
5931 0
5932#endif
5933 },
5934 {"sun",
5935#ifdef SUN_SYSTEM
5936 1
5937#else
5938 0
5939#endif
5940 },
5941 {"unix",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005942#ifdef UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005943 1
5944#else
5945 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005946#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005947 },
5948 {"vms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005949#ifdef VMS
Bram Moolenaar79296512020-03-22 16:17:14 +01005950 1
5951#else
5952 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005953#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005954 },
5955 {"win32",
Bram Moolenaar4f974752019-02-17 17:44:42 +01005956#ifdef MSWIN
Bram Moolenaar79296512020-03-22 16:17:14 +01005957 1
5958#else
5959 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005960#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005961 },
5962 {"win32unix",
K.Takata972db232022-02-04 10:45:38 +00005963#ifdef WIN32UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01005964 1
5965#else
5966 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005967#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005968 },
5969 {"win64",
Bram Moolenaar44b443c2019-02-18 22:14:18 +01005970#ifdef _WIN64
Bram Moolenaar79296512020-03-22 16:17:14 +01005971 1
5972#else
5973 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005974#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005975 },
Bram Moolenaar424bcae2022-01-31 14:59:41 +00005976 {"ebcdic", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005977 {"fname_case",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005978#ifndef CASE_INSENSITIVE_FILENAME
Bram Moolenaar79296512020-03-22 16:17:14 +01005979 1
5980#else
5981 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005982#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005983 },
5984 {"acl",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005985#ifdef HAVE_ACL
Bram Moolenaar79296512020-03-22 16:17:14 +01005986 1
5987#else
5988 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005989#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005990 },
5991 {"arabic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005992#ifdef FEAT_ARABIC
Bram Moolenaar79296512020-03-22 16:17:14 +01005993 1
5994#else
5995 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005996#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005997 },
5998 {"autocmd", 1},
5999 {"autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02006000#ifdef FEAT_AUTOCHDIR
Bram Moolenaar79296512020-03-22 16:17:14 +01006001 1
6002#else
6003 0
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02006004#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006005 },
6006 {"autoservername",
Bram Moolenaare42a6d22017-11-12 19:21:51 +01006007#ifdef FEAT_AUTOSERVERNAME
Bram Moolenaar79296512020-03-22 16:17:14 +01006008 1
6009#else
6010 0
Bram Moolenaare42a6d22017-11-12 19:21:51 +01006011#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006012 },
6013 {"balloon_eval",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01006014#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01006015 1
6016#else
6017 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006018#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006019 },
6020 {"balloon_multiline",
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00006021#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01006022 1
6023#else
6024 0
6025#endif
6026 },
6027 {"balloon_eval_term",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01006028#ifdef FEAT_BEVAL_TERM
Bram Moolenaar79296512020-03-22 16:17:14 +01006029 1
6030#else
6031 0
Bram Moolenaar51b0f372017-11-18 18:52:04 +01006032#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006033 },
Bram Moolenaar2ee347f2022-08-26 17:53:44 +01006034 {"builtin_terms", 1},
6035 {"all_builtin_terms", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006036 {"browsefilter",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006037#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01006038 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006039 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar79296512020-03-22 16:17:14 +01006040 1
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006041#else
Bram Moolenaar79296512020-03-22 16:17:14 +01006042 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006043#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006044 },
6045 {"byte_offset",
6046#ifdef FEAT_BYTEOFF
6047 1
6048#else
6049 0
6050#endif
6051 },
6052 {"channel",
6053#ifdef FEAT_JOB_CHANNEL
6054 1
6055#else
6056 0
6057#endif
6058 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01006059 {"cindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006060 {"clientserver",
6061#ifdef FEAT_CLIENTSERVER
6062 1
6063#else
6064 0
6065#endif
6066 },
6067 {"clipboard",
6068#ifdef FEAT_CLIPBOARD
6069 1
6070#else
6071 0
6072#endif
6073 },
6074 {"cmdline_compl", 1},
6075 {"cmdline_hist", 1},
Martin Tournoij7904fa42022-10-04 16:28:45 +01006076 {"cmdwin", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006077 {"comments", 1},
6078 {"conceal",
6079#ifdef FEAT_CONCEAL
6080 1
6081#else
6082 0
6083#endif
6084 },
6085 {"cryptv",
6086#ifdef FEAT_CRYPT
6087 1
6088#else
6089 0
6090#endif
6091 },
6092 {"crypt-blowfish",
6093#ifdef FEAT_CRYPT
6094 1
6095#else
6096 0
6097#endif
6098 },
6099 {"crypt-blowfish2",
6100#ifdef FEAT_CRYPT
6101 1
6102#else
6103 0
6104#endif
6105 },
6106 {"cscope",
6107#ifdef FEAT_CSCOPE
6108 1
6109#else
6110 0
6111#endif
6112 },
6113 {"cursorbind", 1},
6114 {"cursorshape",
6115#ifdef CURSOR_SHAPE
6116 1
6117#else
6118 0
6119#endif
6120 },
6121 {"debug",
6122#ifdef DEBUG
6123 1
6124#else
6125 0
6126#endif
6127 },
6128 {"dialog_con",
6129#ifdef FEAT_CON_DIALOG
6130 1
6131#else
6132 0
6133#endif
6134 },
6135 {"dialog_gui",
6136#ifdef FEAT_GUI_DIALOG
6137 1
6138#else
6139 0
6140#endif
6141 },
6142 {"diff",
6143#ifdef FEAT_DIFF
6144 1
6145#else
6146 0
6147#endif
6148 },
6149 {"digraphs",
6150#ifdef FEAT_DIGRAPHS
6151 1
6152#else
6153 0
6154#endif
6155 },
6156 {"directx",
6157#ifdef FEAT_DIRECTX
6158 1
6159#else
6160 0
6161#endif
6162 },
6163 {"dnd",
6164#ifdef FEAT_DND
6165 1
6166#else
6167 0
6168#endif
6169 },
Bram Moolenaar1d1ce612021-06-27 19:02:52 +02006170 {"drop_file",
6171#ifdef HAVE_DROP_FILE
6172 1
6173#else
6174 0
6175#endif
6176 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006177 {"emacs_tags",
6178#ifdef FEAT_EMACS_TAGS
6179 1
6180#else
6181 0
6182#endif
6183 },
6184 {"eval", 1}, // always present, of course!
6185 {"ex_extra", 1}, // graduated feature
6186 {"extra_search",
6187#ifdef FEAT_SEARCH_EXTRA
6188 1
6189#else
6190 0
6191#endif
6192 },
Bram Moolenaarf80f40a2022-08-25 16:02:23 +01006193 {"file_in_path", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006194 {"filterpipe",
6195#if defined(FEAT_FILTERPIPE) && !defined(VIMDLL)
6196 1
6197#else
6198 0
6199#endif
6200 },
6201 {"find_in_path",
6202#ifdef FEAT_FIND_ID
6203 1
6204#else
6205 0
6206#endif
6207 },
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01006208 {"float", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006209 {"folding",
6210#ifdef FEAT_FOLDING
6211 1
6212#else
6213 0
6214#endif
6215 },
Bram Moolenaarc8ac3a02022-09-04 12:29:28 +01006216 {"footer", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01006217 {"fork",
6218#if !defined(USE_SYSTEM) && defined(UNIX)
6219 1
6220#else
6221 0
6222#endif
6223 },
6224 {"gettext",
6225#ifdef FEAT_GETTEXT
6226 1
6227#else
6228 0
6229#endif
6230 },
6231 {"gui",
6232#ifdef FEAT_GUI
6233 1
6234#else
6235 0
6236#endif
6237 },
Bram Moolenaar0b962e52022-04-03 18:02:37 +01006238 {"gui_neXtaw", 0 },
6239 {"gui_athena", 0 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006240 {"gui_gtk",
6241#ifdef FEAT_GUI_GTK
6242 1
6243#else
6244 0
6245#endif
6246 },
6247 {"gui_gtk2",
6248#if defined(FEAT_GUI_GTK) && !defined(USE_GTK3)
6249 1
6250#else
6251 0
6252#endif
6253 },
6254 {"gui_gtk3",
6255#if defined(FEAT_GUI_GTK) && defined(USE_GTK3)
6256 1
6257#else
6258 0
6259#endif
6260 },
6261 {"gui_gnome",
6262#ifdef FEAT_GUI_GNOME
6263 1
6264#else
6265 0
6266#endif
6267 },
6268 {"gui_haiku",
6269#ifdef FEAT_GUI_HAIKU
6270 1
6271#else
6272 0
6273#endif
6274 },
Bram Moolenaar097148e2020-08-11 21:58:20 +02006275 {"gui_mac", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01006276 {"gui_motif",
6277#ifdef FEAT_GUI_MOTIF
6278 1
6279#else
6280 0
6281#endif
6282 },
6283 {"gui_photon",
6284#ifdef FEAT_GUI_PHOTON
6285 1
6286#else
6287 0
6288#endif
6289 },
6290 {"gui_win32",
6291#ifdef FEAT_GUI_MSWIN
6292 1
6293#else
6294 0
6295#endif
6296 },
6297 {"iconv",
6298#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
6299 1
6300#else
6301 0
6302#endif
6303 },
6304 {"insert_expand", 1},
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02006305 {"ipv6",
6306#ifdef FEAT_IPV6
6307 1
6308#else
6309 0
6310#endif
6311 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006312 {"job",
6313#ifdef FEAT_JOB_CHANNEL
6314 1
6315#else
6316 0
6317#endif
6318 },
Bram Moolenaar739f13a2021-12-13 13:12:53 +00006319 {"jumplist", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006320 {"keymap",
6321#ifdef FEAT_KEYMAP
6322 1
6323#else
6324 0
6325#endif
6326 },
6327 {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure
6328 {"langmap",
6329#ifdef FEAT_LANGMAP
6330 1
6331#else
6332 0
6333#endif
6334 },
6335 {"libcall",
6336#ifdef FEAT_LIBCALL
6337 1
6338#else
6339 0
6340#endif
6341 },
6342 {"linebreak",
6343#ifdef FEAT_LINEBREAK
6344 1
6345#else
6346 0
6347#endif
6348 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01006349 {"lispindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006350 {"listcmds", 1},
6351 {"localmap", 1},
6352 {"lua",
6353#if defined(FEAT_LUA) && !defined(DYNAMIC_LUA)
6354 1
6355#else
6356 0
6357#endif
6358 },
6359 {"menu",
6360#ifdef FEAT_MENU
6361 1
6362#else
6363 0
6364#endif
6365 },
6366 {"mksession",
6367#ifdef FEAT_SESSION
6368 1
6369#else
6370 0
6371#endif
6372 },
6373 {"modify_fname", 1},
6374 {"mouse", 1},
6375 {"mouseshape",
6376#ifdef FEAT_MOUSESHAPE
6377 1
6378#else
6379 0
6380#endif
6381 },
6382 {"mouse_dec",
6383#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC)
6384 1
6385#else
6386 0
6387#endif
6388 },
6389 {"mouse_gpm",
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00006390#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM) && !defined(DYNAMIC_GPM)
Bram Moolenaar79296512020-03-22 16:17:14 +01006391 1
6392#else
6393 0
6394#endif
6395 },
6396 {"mouse_jsbterm",
6397#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB)
6398 1
6399#else
6400 0
6401#endif
6402 },
6403 {"mouse_netterm",
6404#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET)
6405 1
6406#else
6407 0
6408#endif
6409 },
6410 {"mouse_pterm",
6411#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM)
6412 1
6413#else
6414 0
6415#endif
6416 },
6417 {"mouse_sgr",
6418#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
6419 1
6420#else
6421 0
6422#endif
6423 },
6424 {"mouse_sysmouse",
6425#if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE)
6426 1
6427#else
6428 0
6429#endif
6430 },
6431 {"mouse_urxvt",
6432#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT)
6433 1
6434#else
6435 0
6436#endif
6437 },
6438 {"mouse_xterm",
6439#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
6440 1
6441#else
6442 0
6443#endif
6444 },
6445 {"multi_byte", 1},
6446 {"multi_byte_ime",
6447#ifdef FEAT_MBYTE_IME
6448 1
6449#else
6450 0
6451#endif
6452 },
6453 {"multi_lang",
6454#ifdef FEAT_MULTI_LANG
6455 1
6456#else
6457 0
6458#endif
6459 },
6460 {"mzscheme",
6461#if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME)
6462 1
6463#else
6464 0
6465#endif
6466 },
Leah Neukirchen0a7984a2021-10-14 21:27:55 +01006467 {"nanotime",
6468#ifdef ST_MTIM_NSEC
6469 1
6470#else
6471 0
6472#endif
6473 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006474 {"num64", 1},
6475 {"ole",
6476#ifdef FEAT_OLE
6477 1
6478#else
6479 0
6480#endif
6481 },
6482 {"packages",
6483#ifdef FEAT_EVAL
6484 1
6485#else
6486 0
6487#endif
6488 },
Bram Moolenaar2bd9dbc2022-08-25 18:12:06 +01006489 {"path_extra", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006490 {"perl",
6491#if defined(FEAT_PERL) && !defined(DYNAMIC_PERL)
6492 1
6493#else
6494 0
6495#endif
6496 },
6497 {"persistent_undo",
6498#ifdef FEAT_PERSISTENT_UNDO
6499 1
6500#else
6501 0
6502#endif
6503 },
6504 {"python_compiled",
6505#if defined(FEAT_PYTHON)
6506 1
6507#else
6508 0
6509#endif
6510 },
6511 {"python_dynamic",
6512#if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON)
6513 1
6514#else
6515 0
6516#endif
6517 },
6518 {"python",
6519#if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)
6520 1
6521#else
6522 0
6523#endif
6524 },
6525 {"pythonx",
6526#if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \
6527 || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3))
6528 1
6529#else
6530 0
6531#endif
6532 },
6533 {"python3_compiled",
6534#if defined(FEAT_PYTHON3)
6535 1
6536#else
6537 0
6538#endif
6539 },
6540 {"python3_dynamic",
6541#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3)
6542 1
6543#else
6544 0
6545#endif
6546 },
Yee Cheng Chinc13b3d12023-08-20 21:18:38 +02006547 {"python3_stable",
6548#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3_STABLE_ABI)
6549 1
6550#else
6551 0
6552#endif
6553 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006554 {"python3",
6555#if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)
6556 1
6557#else
6558 0
6559#endif
6560 },
6561 {"popupwin",
6562#ifdef FEAT_PROP_POPUP
6563 1
6564#else
6565 0
6566#endif
6567 },
6568 {"postscript",
6569#ifdef FEAT_POSTSCRIPT
6570 1
6571#else
6572 0
6573#endif
6574 },
6575 {"printer",
6576#ifdef FEAT_PRINTER
6577 1
6578#else
6579 0
6580#endif
6581 },
6582 {"profile",
6583#ifdef FEAT_PROFILE
6584 1
6585#else
6586 0
6587#endif
6588 },
Ernie Rael076de792023-03-16 21:43:15 +00006589 {"prof_nsec",
Bram Moolenaar08210f82023-04-13 19:15:54 +01006590#ifdef PROF_NSEC
Ernie Rael076de792023-03-16 21:43:15 +00006591 1
6592#else
6593 0
6594#endif
6595 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006596 {"reltime",
6597#ifdef FEAT_RELTIME
6598 1
6599#else
6600 0
6601#endif
6602 },
6603 {"quickfix",
6604#ifdef FEAT_QUICKFIX
6605 1
6606#else
6607 0
6608#endif
6609 },
6610 {"rightleft",
6611#ifdef FEAT_RIGHTLEFT
6612 1
6613#else
6614 0
6615#endif
6616 },
6617 {"ruby",
6618#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
6619 1
6620#else
6621 0
6622#endif
6623 },
6624 {"scrollbind", 1},
Martin Tournoijba43e762022-10-13 22:12:15 +01006625 {"showcmd", 1},
6626 {"cmdline_info", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006627 {"signs",
6628#ifdef FEAT_SIGNS
6629 1
6630#else
6631 0
6632#endif
6633 },
Bram Moolenaar8e145b82022-05-21 20:17:31 +01006634 {"smartindent", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006635 {"startuptime",
6636#ifdef STARTUPTIME
6637 1
6638#else
6639 0
6640#endif
6641 },
6642 {"statusline",
6643#ifdef FEAT_STL_OPT
6644 1
6645#else
6646 0
6647#endif
6648 },
6649 {"netbeans_intg",
6650#ifdef FEAT_NETBEANS_INTG
6651 1
6652#else
6653 0
6654#endif
6655 },
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006656 {"sodium",
K.Takatad68b2fc2022-02-12 11:18:37 +00006657#if defined(FEAT_SODIUM) && !defined(DYNAMIC_SODIUM)
Christian Brabandtf573c6e2021-06-20 14:02:16 +02006658 1
6659#else
6660 0
6661#endif
6662 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006663 {"sound",
6664#ifdef FEAT_SOUND
6665 1
6666#else
6667 0
6668#endif
6669 },
6670 {"spell",
6671#ifdef FEAT_SPELL
6672 1
6673#else
6674 0
6675#endif
6676 },
6677 {"syntax",
6678#ifdef FEAT_SYN_HL
6679 1
6680#else
6681 0
6682#endif
6683 },
6684 {"system",
6685#if defined(USE_SYSTEM) || !defined(UNIX)
6686 1
6687#else
6688 0
6689#endif
6690 },
Yegappan Lakshmanan655b7342022-03-06 14:27:10 +00006691 {"tag_binary", 1}, // graduated feature
Bram Moolenaar79296512020-03-22 16:17:14 +01006692 {"tcl",
6693#if defined(FEAT_TCL) && !defined(DYNAMIC_TCL)
6694 1
6695#else
6696 0
6697#endif
6698 },
6699 {"termguicolors",
6700#ifdef FEAT_TERMGUICOLORS
6701 1
6702#else
6703 0
6704#endif
6705 },
6706 {"terminal",
6707#if defined(FEAT_TERMINAL) && !defined(MSWIN)
6708 1
6709#else
6710 0
6711#endif
6712 },
6713 {"terminfo",
6714#ifdef TERMINFO
6715 1
6716#else
6717 0
6718#endif
6719 },
6720 {"termresponse",
6721#ifdef FEAT_TERMRESPONSE
6722 1
6723#else
6724 0
6725#endif
6726 },
Bram Moolenaar88774872022-08-16 20:24:29 +01006727 {"textobjects", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006728 {"textprop",
6729#ifdef FEAT_PROP_POPUP
6730 1
6731#else
6732 0
6733#endif
6734 },
6735 {"tgetent",
6736#ifdef HAVE_TGETENT
6737 1
6738#else
6739 0
6740#endif
6741 },
6742 {"timers",
6743#ifdef FEAT_TIMERS
6744 1
6745#else
6746 0
6747#endif
6748 },
Bram Moolenaar651fca82021-11-29 20:39:38 +00006749 {"title", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006750 {"toolbar",
6751#ifdef FEAT_TOOLBAR
6752 1
6753#else
6754 0
6755#endif
6756 },
6757 {"unnamedplus",
6758#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
6759 1
6760#else
6761 0
6762#endif
6763 },
6764 {"user-commands", 1}, // was accidentally included in 5.4
6765 {"user_commands", 1},
6766 {"vartabs",
6767#ifdef FEAT_VARTABS
6768 1
6769#else
6770 0
6771#endif
6772 },
6773 {"vertsplit", 1},
6774 {"viminfo",
6775#ifdef FEAT_VIMINFO
6776 1
6777#else
6778 0
6779#endif
6780 },
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +00006781 {"vim9script", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006782 {"vimscript-1", 1},
6783 {"vimscript-2", 1},
6784 {"vimscript-3", 1},
6785 {"vimscript-4", 1},
6786 {"virtualedit", 1},
6787 {"visual", 1},
6788 {"visualextra", 1},
6789 {"vreplace", 1},
6790 {"vtp",
6791#ifdef FEAT_VTP
6792 1
6793#else
6794 0
6795#endif
6796 },
Bram Moolenaar074fbd42022-08-26 16:41:14 +01006797 {"wildignore", 1},
Bram Moolenaar54162322022-08-26 16:58:51 +01006798 {"wildmenu", 1},
Bram Moolenaar79296512020-03-22 16:17:14 +01006799 {"windows", 1},
6800 {"winaltkeys",
6801#ifdef FEAT_WAK
6802 1
6803#else
6804 0
6805#endif
6806 },
6807 {"writebackup",
6808#ifdef FEAT_WRITEBACKUP
6809 1
6810#else
6811 0
6812#endif
6813 },
Christian Brabandte085dfd2023-09-30 12:49:18 +02006814 {"xattr",
6815#ifdef FEAT_XATTR
6816 1
6817#else
6818 0
6819#endif
6820 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006821 {"xim",
6822#ifdef FEAT_XIM
6823 1
6824#else
6825 0
6826#endif
6827 },
6828 {"xfontset",
6829#ifdef FEAT_XFONTSET
6830 1
6831#else
6832 0
6833#endif
6834 },
6835 {"xpm",
6836#if defined(FEAT_XPM_W32) || defined(HAVE_XPM)
6837 1
6838#else
6839 0
6840#endif
6841 },
6842 {"xpm_w32", // for backward compatibility
6843#ifdef FEAT_XPM_W32
6844 1
6845#else
6846 0
6847#endif
6848 },
6849 {"xsmp",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006850#ifdef USE_XSMP
Bram Moolenaar79296512020-03-22 16:17:14 +01006851 1
6852#else
6853 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006854#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006855 },
6856 {"xsmp_interact",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006857#ifdef USE_XSMP_INTERACT
Bram Moolenaar79296512020-03-22 16:17:14 +01006858 1
6859#else
6860 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006861#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006862 },
6863 {"xterm_clipboard",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006864#ifdef FEAT_XCLIPBOARD
Bram Moolenaar79296512020-03-22 16:17:14 +01006865 1
6866#else
6867 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006868#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006869 },
6870 {"xterm_save",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006871#ifdef FEAT_XTERM_SAVE
Bram Moolenaar79296512020-03-22 16:17:14 +01006872 1
6873#else
6874 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006875#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006876 },
6877 {"X11",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006878#if defined(UNIX) && defined(FEAT_X11)
Bram Moolenaar79296512020-03-22 16:17:14 +01006879 1
6880#else
6881 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006882#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006883 },
Bram Moolenaar80adaa82023-07-07 18:57:40 +01006884 {":tearoff",
6885// same #ifdef as used for ex_tearoff().
6886#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
6887 1
6888#else
6889 0
6890#endif
6891 },
Bram Moolenaar79296512020-03-22 16:17:14 +01006892 {NULL, 0}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006893 };
6894
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02006895 if (in_vim9script()
6896 && (check_for_string_arg(argvars, 0) == FAIL
6897 || check_for_opt_bool_arg(argvars, 1) == FAIL))
6898 return;
6899
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006900 name = tv_get_string(&argvars[0]);
Bram Moolenaar79296512020-03-22 16:17:14 +01006901 for (i = 0; has_list[i].name != NULL; ++i)
6902 if (STRICMP(name, has_list[i].name) == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006903 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006904 x = TRUE;
6905 n = has_list[i].present;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006906 break;
6907 }
6908
Bram Moolenaar79296512020-03-22 16:17:14 +01006909 // features also in has_list[] but sometimes enabled at runtime
6910 if (x == TRUE && n == FALSE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006911 {
Bram Moolenaar79296512020-03-22 16:17:14 +01006912 if (0)
Bram Moolenaar86b9a3e2020-04-07 19:57:29 +02006913 {
6914 // intentionally empty
6915 }
Bram Moolenaar79296512020-03-22 16:17:14 +01006916#ifdef VIMDLL
6917 else if (STRICMP(name, "filterpipe") == 0)
6918 n = gui.in_use || gui.starting;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006919#endif
6920#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6921 else if (STRICMP(name, "iconv") == 0)
6922 n = iconv_enabled(FALSE);
6923#endif
6924#ifdef DYNAMIC_LUA
6925 else if (STRICMP(name, "lua") == 0)
6926 n = lua_enabled(FALSE);
6927#endif
6928#ifdef DYNAMIC_MZSCHEME
6929 else if (STRICMP(name, "mzscheme") == 0)
6930 n = mzscheme_enabled(FALSE);
6931#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006932#ifdef DYNAMIC_PERL
6933 else if (STRICMP(name, "perl") == 0)
6934 n = perl_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006935#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006936#ifdef DYNAMIC_PYTHON
6937 else if (STRICMP(name, "python") == 0)
6938 n = python_enabled(FALSE);
6939#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006940#ifdef DYNAMIC_PYTHON3
6941 else if (STRICMP(name, "python3") == 0)
6942 n = python3_enabled(FALSE);
6943#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006944#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6945 else if (STRICMP(name, "pythonx") == 0)
6946 {
6947# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
6948 if (p_pyx == 0)
6949 n = python3_enabled(FALSE) || python_enabled(FALSE);
6950 else if (p_pyx == 3)
6951 n = python3_enabled(FALSE);
6952 else if (p_pyx == 2)
6953 n = python_enabled(FALSE);
6954# elif defined(DYNAMIC_PYTHON)
6955 n = python_enabled(FALSE);
6956# elif defined(DYNAMIC_PYTHON3)
6957 n = python3_enabled(FALSE);
6958# endif
6959 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006960#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006961#ifdef DYNAMIC_RUBY
6962 else if (STRICMP(name, "ruby") == 0)
6963 n = ruby_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006964#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01006965#ifdef DYNAMIC_TCL
6966 else if (STRICMP(name, "tcl") == 0)
6967 n = tcl_enabled(FALSE);
Bram Moolenaar4b8366b2019-05-04 17:34:34 +02006968#endif
K.Takatad68b2fc2022-02-12 11:18:37 +00006969#ifdef DYNAMIC_SODIUM
6970 else if (STRICMP(name, "sodium") == 0)
6971 n = sodium_enabled(FALSE);
6972#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006973#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02006974 else if (STRICMP(name, "terminal") == 0)
6975 n = terminal_enabled();
6976#endif
Bram Moolenaar33fc4a62022-02-23 18:07:38 +00006977#ifdef DYNAMIC_GPM
6978 else if (STRICMP(name, "mouse_gpm") == 0)
6979 n = gpm_available();
6980#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006981 }
6982
Bram Moolenaar79296512020-03-22 16:17:14 +01006983 // features not in has_list[]
6984 if (x == FALSE)
6985 {
6986 if (STRNICMP(name, "patch", 5) == 0)
6987 {
6988 x = TRUE;
6989 if (name[5] == '-'
6990 && STRLEN(name) >= 11
K.Takatad90f91f2022-07-30 15:43:59 +01006991 && (name[6] >= '1' && name[6] <= '9'))
Bram Moolenaar79296512020-03-22 16:17:14 +01006992 {
K.Takatad90f91f2022-07-30 15:43:59 +01006993 char *end;
6994 int major, minor;
Bram Moolenaar79296512020-03-22 16:17:14 +01006995
K.Takatad90f91f2022-07-30 15:43:59 +01006996 // This works for patch-8.1.2, patch-9.0.3, patch-10.0.4, etc.
6997 // Not for patch-9.10.5.
6998 major = (int)strtoul((char *)name + 6, &end, 10);
6999 if (*end == '.' && vim_isdigit(end[1])
7000 && end[2] == '.' && vim_isdigit(end[3]))
7001 {
7002 minor = atoi(end + 1);
7003
7004 // Expect "patch-9.9.01234".
7005 n = (major < VIM_VERSION_MAJOR
7006 || (major == VIM_VERSION_MAJOR
7007 && (minor < VIM_VERSION_MINOR
7008 || (minor == VIM_VERSION_MINOR
7009 && has_patch(atoi(end + 3))))));
7010 }
Bram Moolenaar79296512020-03-22 16:17:14 +01007011 }
Keith Thompson184f71c2024-01-04 21:19:04 +01007012 else if (SAFE_isdigit(name[5]))
Bram Moolenaar79296512020-03-22 16:17:14 +01007013 n = has_patch(atoi((char *)name + 5));
7014 }
7015 else if (STRICMP(name, "vim_starting") == 0)
7016 {
7017 x = TRUE;
7018 n = (starting != 0);
7019 }
7020 else if (STRICMP(name, "ttyin") == 0)
7021 {
7022 x = TRUE;
7023 n = mch_input_isatty();
7024 }
7025 else if (STRICMP(name, "ttyout") == 0)
7026 {
7027 x = TRUE;
7028 n = stdout_isatty;
7029 }
7030 else if (STRICMP(name, "multi_byte_encoding") == 0)
7031 {
7032 x = TRUE;
7033 n = has_mbyte;
7034 }
7035 else if (STRICMP(name, "gui_running") == 0)
7036 {
7037 x = TRUE;
7038#ifdef FEAT_GUI
7039 n = (gui.in_use || gui.starting);
7040#endif
7041 }
7042 else if (STRICMP(name, "browse") == 0)
7043 {
7044 x = TRUE;
7045#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
7046 n = gui.in_use; // gui_mch_browse() works when GUI is running
7047#endif
7048 }
7049 else if (STRICMP(name, "syntax_items") == 0)
7050 {
7051 x = TRUE;
7052#ifdef FEAT_SYN_HL
7053 n = syntax_present(curwin);
7054#endif
7055 }
7056 else if (STRICMP(name, "vcon") == 0)
7057 {
7058 x = TRUE;
7059#ifdef FEAT_VTP
7060 n = is_term_win32() && has_vtp_working();
7061#endif
7062 }
7063 else if (STRICMP(name, "netbeans_enabled") == 0)
7064 {
7065 x = TRUE;
7066#ifdef FEAT_NETBEANS_INTG
7067 n = netbeans_active();
7068#endif
7069 }
7070 else if (STRICMP(name, "mouse_gpm_enabled") == 0)
7071 {
7072 x = TRUE;
7073#ifdef FEAT_MOUSE_GPM
7074 n = gpm_enabled();
7075#endif
7076 }
7077 else if (STRICMP(name, "conpty") == 0)
7078 {
7079 x = TRUE;
7080#if defined(FEAT_TERMINAL) && defined(MSWIN)
7081 n = use_conpty();
7082#endif
7083 }
7084 else if (STRICMP(name, "clipboard_working") == 0)
7085 {
7086 x = TRUE;
7087#ifdef FEAT_CLIPBOARD
7088 n = clip_star.available;
7089#endif
7090 }
7091 }
7092
Bram Moolenaar04637e22020-09-05 18:45:29 +02007093 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
Bram Moolenaar79296512020-03-22 16:17:14 +01007094 // return whether feature could ever be enabled
7095 rettv->vval.v_number = x;
7096 else
7097 // return whether feature is enabled
7098 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007099}
7100
7101/*
Bram Moolenaar8cebd432020-11-08 12:49:47 +01007102 * Return TRUE if "feature" can change later.
7103 * Also when checking for the feature has side effects, such as loading a DLL.
7104 */
7105 int
7106dynamic_feature(char_u *feature)
7107{
7108 return (feature == NULL
Bram Moolenaar8cebd432020-11-08 12:49:47 +01007109#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
7110 || (STRICMP(feature, "browse") == 0 && !gui.in_use)
7111#endif
7112#ifdef VIMDLL
7113 || STRICMP(feature, "filterpipe") == 0
7114#endif
Bram Moolenaar29b281b2020-11-10 20:58:00 +01007115#if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL)
Bram Moolenaar8cebd432020-11-08 12:49:47 +01007116 // this can only change on Unix where the ":gui" command could be
7117 // used.
7118 || (STRICMP(feature, "gui_running") == 0 && !gui.in_use)
7119#endif
7120#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
7121 || STRICMP(feature, "iconv") == 0
7122#endif
7123#ifdef DYNAMIC_LUA
7124 || STRICMP(feature, "lua") == 0
7125#endif
7126#ifdef FEAT_MOUSE_GPM
7127 || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled())
7128#endif
7129#ifdef DYNAMIC_MZSCHEME
7130 || STRICMP(feature, "mzscheme") == 0
7131#endif
7132#ifdef FEAT_NETBEANS_INTG
7133 || STRICMP(feature, "netbeans_enabled") == 0
7134#endif
7135#ifdef DYNAMIC_PERL
7136 || STRICMP(feature, "perl") == 0
7137#endif
7138#ifdef DYNAMIC_PYTHON
7139 || STRICMP(feature, "python") == 0
7140#endif
7141#ifdef DYNAMIC_PYTHON3
7142 || STRICMP(feature, "python3") == 0
7143#endif
7144#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
7145 || STRICMP(feature, "pythonx") == 0
7146#endif
7147#ifdef DYNAMIC_RUBY
7148 || STRICMP(feature, "ruby") == 0
7149#endif
7150#ifdef FEAT_SYN_HL
7151 || STRICMP(feature, "syntax_items") == 0
7152#endif
7153#ifdef DYNAMIC_TCL
7154 || STRICMP(feature, "tcl") == 0
7155#endif
7156 // once "starting" is zero it will stay that way
7157 || (STRICMP(feature, "vim_starting") == 0 && starting != 0)
7158 || STRICMP(feature, "multi_byte_encoding") == 0
7159#if defined(FEAT_TERMINAL) && defined(MSWIN)
7160 || STRICMP(feature, "conpty") == 0
7161#endif
7162 );
7163}
7164
7165/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007166 * "haslocaldir()" function
7167 */
7168 static void
7169f_haslocaldir(typval_T *argvars, typval_T *rettv)
7170{
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007171 tabpage_T *tp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007172 win_T *wp = NULL;
7173
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007174 if (in_vim9script()
7175 && (check_for_opt_number_arg(argvars, 0) == FAIL
7176 || (argvars[0].v_type != VAR_UNKNOWN
7177 && check_for_opt_number_arg(argvars, 1) == FAIL)))
7178 return;
7179
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007180 wp = find_tabwin(&argvars[0], &argvars[1], &tp);
7181
7182 // Check for window-local and tab-local directories
7183 if (wp != NULL && wp->w_localdir != NULL)
7184 rettv->vval.v_number = 1;
7185 else if (tp != NULL && tp->tp_localdir != NULL)
7186 rettv->vval.v_number = 2;
7187 else
7188 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007189}
7190
7191/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007192 * "highlightID(name)" function
7193 */
7194 static void
7195f_hlID(typval_T *argvars, typval_T *rettv)
7196{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007197 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7198 return;
7199
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007200 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007201}
7202
7203/*
7204 * "highlight_exists()" function
7205 */
7206 static void
7207f_hlexists(typval_T *argvars, typval_T *rettv)
7208{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007209 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7210 return;
7211
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007212 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007213}
7214
7215/*
7216 * "hostname()" function
7217 */
7218 static void
7219f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
7220{
7221 char_u hostname[256];
7222
7223 mch_get_host_name(hostname, 256);
7224 rettv->v_type = VAR_STRING;
7225 rettv->vval.v_string = vim_strsave(hostname);
7226}
7227
7228/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007229 * "index()" function
7230 */
7231 static void
7232f_index(typval_T *argvars, typval_T *rettv)
7233{
7234 list_T *l;
7235 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007236 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007237 long idx = 0;
7238 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007239 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007240
7241 rettv->vval.v_number = -1;
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007242
7243 if (in_vim9script()
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02007244 && (check_for_list_or_blob_arg(argvars, 0) == FAIL
7245 || (argvars[0].v_type == VAR_BLOB
7246 && check_for_number_arg(argvars, 1) == FAIL)
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007247 || check_for_opt_number_arg(argvars, 2) == FAIL
7248 || (argvars[2].v_type != VAR_UNKNOWN
7249 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
7250 return;
7251
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007252 if (argvars[0].v_type == VAR_BLOB)
7253 {
7254 typval_T tv;
7255 int start = 0;
7256
7257 if (argvars[2].v_type != VAR_UNKNOWN)
7258 {
7259 start = tv_get_number_chk(&argvars[2], &error);
7260 if (error)
7261 return;
7262 }
7263 b = argvars[0].vval.v_blob;
7264 if (b == NULL)
7265 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01007266 if (start < 0)
7267 {
7268 start = blob_len(b) + start;
7269 if (start < 0)
7270 start = 0;
7271 }
7272
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007273 for (idx = start; idx < blob_len(b); ++idx)
7274 {
7275 tv.v_type = VAR_NUMBER;
7276 tv.vval.v_number = blob_get(b, idx);
7277 if (tv_equal(&tv, &argvars[1], ic, FALSE))
7278 {
7279 rettv->vval.v_number = idx;
7280 return;
7281 }
7282 }
7283 return;
7284 }
7285 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007286 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00007287 emsg(_(e_list_or_blob_required));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007288 return;
7289 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007290
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007291 l = argvars[0].vval.v_list;
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00007292 if (l == NULL)
7293 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007294
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00007295 CHECK_LIST_MATERIALIZE(l);
7296 item = l->lv_first;
7297 if (argvars[2].v_type != VAR_UNKNOWN)
7298 {
7299 // Start at specified item. Use the cached index that list_find()
7300 // sets, so that a negative number also works.
7301 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
7302 idx = l->lv_u.mat.lv_idx;
7303 if (argvars[3].v_type != VAR_UNKNOWN)
7304 ic = (int)tv_get_bool_chk(&argvars[3], &error);
7305 if (error)
7306 item = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007307 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00007308
7309 for ( ; item != NULL; item = item->li_next, ++idx)
7310 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
7311 {
7312 rettv->vval.v_number = idx;
7313 break;
7314 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007315}
7316
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007317/*
7318 * Evaluate 'expr' with the v:key and v:val arguments and return the result.
7319 * The expression is expected to return a boolean value. The caller should set
7320 * the VV_KEY and VV_VAL vim variables before calling this function.
7321 */
7322 static int
7323indexof_eval_expr(typval_T *expr)
7324{
7325 typval_T argv[3];
7326 typval_T newtv;
7327 varnumber_T found;
7328 int error = FALSE;
7329
7330 argv[0] = *get_vim_var_tv(VV_KEY);
7331 argv[1] = *get_vim_var_tv(VV_VAL);
7332 newtv.v_type = VAR_UNKNOWN;
7333
zeertzjqad0c4422023-08-17 22:15:47 +02007334 if (eval_expr_typval(expr, FALSE, argv, 2, NULL, &newtv) == FAIL)
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007335 return FALSE;
7336
7337 found = tv_get_bool_chk(&newtv, &error);
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01007338 clear_tv(&newtv);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007339
7340 return error ? FALSE : found;
7341}
7342
7343/*
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01007344 * Evaluate 'expr' for each byte in the Blob 'b' starting with the byte at
7345 * 'startidx' and return the index of the byte where 'expr' is TRUE. Returns
7346 * -1 if 'expr' doesn't evaluate to TRUE for any of the bytes.
7347 */
7348 static int
7349indexof_blob(blob_T *b, long startidx, typval_T *expr)
7350{
7351 long idx = 0;
7352
7353 if (b == NULL)
7354 return -1;
7355
7356 if (startidx < 0)
7357 {
7358 // negative index: index from the last byte
7359 startidx = blob_len(b) + startidx;
7360 if (startidx < 0)
7361 startidx = 0;
7362 }
7363
7364 set_vim_var_type(VV_KEY, VAR_NUMBER);
7365 set_vim_var_type(VV_VAL, VAR_NUMBER);
7366
7367 for (idx = startidx; idx < blob_len(b); ++idx)
7368 {
7369 set_vim_var_nr(VV_KEY, idx);
7370 set_vim_var_nr(VV_VAL, blob_get(b, idx));
7371
7372 if (indexof_eval_expr(expr))
7373 return idx;
7374 }
7375
7376 return -1;
7377}
7378
7379/*
7380 * Evaluate 'expr' for each item in the List 'l' starting with the item at
7381 * 'startidx' and return the index of the item where 'expr' is TRUE. Returns
7382 * -1 if 'expr' doesn't evaluate to TRUE for any of the items.
7383 */
7384 static int
7385indexof_list(list_T *l, long startidx, typval_T *expr)
7386{
7387 listitem_T *item;
7388 long idx = 0;
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01007389 int found;
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01007390
7391 if (l == NULL)
7392 return -1;
7393
7394 CHECK_LIST_MATERIALIZE(l);
7395
7396 if (startidx == 0)
7397 item = l->lv_first;
7398 else
7399 {
7400 // Start at specified item. Use the cached index that list_find()
7401 // sets, so that a negative number also works.
7402 item = list_find(l, startidx);
7403 if (item != NULL)
7404 idx = l->lv_u.mat.lv_idx;
7405 }
7406
7407 set_vim_var_type(VV_KEY, VAR_NUMBER);
7408
7409 for ( ; item != NULL; item = item->li_next, ++idx)
7410 {
7411 set_vim_var_nr(VV_KEY, idx);
7412 copy_tv(&item->li_tv, get_vim_var_tv(VV_VAL));
7413
Yegappan Lakshmanan63acae12022-08-14 12:07:11 +01007414 found = indexof_eval_expr(expr);
7415 clear_tv(get_vim_var_tv(VV_VAL));
7416
7417 if (found)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01007418 return idx;
7419 }
7420
7421 return -1;
7422}
7423
7424/*
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007425 * "indexof()" function
7426 */
7427 static void
7428f_indexof(typval_T *argvars, typval_T *rettv)
7429{
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007430 long startidx = 0;
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007431 typval_T save_val;
7432 typval_T save_key;
7433 int save_did_emsg;
7434
7435 rettv->vval.v_number = -1;
7436
7437 if (check_for_list_or_blob_arg(argvars, 0) == FAIL
7438 || check_for_string_or_func_arg(argvars, 1) == FAIL
7439 || check_for_opt_dict_arg(argvars, 2) == FAIL)
7440 return;
7441
7442 if ((argvars[1].v_type == VAR_STRING && argvars[1].vval.v_string == NULL)
7443 || (argvars[1].v_type == VAR_FUNC
7444 && argvars[1].vval.v_partial == NULL))
7445 return;
7446
7447 if (argvars[2].v_type == VAR_DICT)
7448 startidx = dict_get_number_def(argvars[2].vval.v_dict, "startidx", 0);
7449
7450 prepare_vimvar(VV_VAL, &save_val);
7451 prepare_vimvar(VV_KEY, &save_key);
7452
7453 // We reset "did_emsg" to be able to detect whether an error occurred
7454 // during evaluation of the expression.
7455 save_did_emsg = did_emsg;
7456 did_emsg = FALSE;
7457
7458 if (argvars[0].v_type == VAR_BLOB)
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01007459 rettv->vval.v_number = indexof_blob(argvars[0].vval.v_blob, startidx,
7460 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007461 else
Yegappan Lakshmanan3fbf6cd2022-08-13 21:35:13 +01007462 rettv->vval.v_number = indexof_list(argvars[0].vval.v_list, startidx,
7463 &argvars[1]);
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007464
Yegappan Lakshmananb2186552022-08-13 13:09:20 +01007465 restore_vimvar(VV_KEY, &save_key);
7466 restore_vimvar(VV_VAL, &save_val);
7467 did_emsg |= save_did_emsg;
7468}
7469
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007470static int inputsecret_flag = 0;
7471
7472/*
7473 * "input()" function
7474 * Also handles inputsecret() when inputsecret is set.
7475 */
7476 static void
7477f_input(typval_T *argvars, typval_T *rettv)
7478{
7479 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
7480}
7481
7482/*
7483 * "inputdialog()" function
7484 */
7485 static void
7486f_inputdialog(typval_T *argvars, typval_T *rettv)
7487{
7488#if defined(FEAT_GUI_TEXTDIALOG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007489 // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions'
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007490 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
7491 {
7492 char_u *message;
7493 char_u buf[NUMBUFLEN];
7494 char_u *defstr = (char_u *)"";
7495
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007496 if (in_vim9script()
7497 && (check_for_string_arg(argvars, 0) == FAIL
7498 || check_for_opt_string_arg(argvars, 1) == FAIL
7499 || (argvars[1].v_type != VAR_UNKNOWN
7500 && check_for_opt_string_arg(argvars, 2) == FAIL)))
7501 return;
7502
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007503 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007504 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007505 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007506 vim_strncpy(IObuff, defstr, IOSIZE - 1);
7507 else
7508 IObuff[0] = NUL;
7509 if (message != NULL && defstr != NULL
7510 && do_dialog(VIM_QUESTION, NULL, message,
7511 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
7512 rettv->vval.v_string = vim_strsave(IObuff);
7513 else
7514 {
7515 if (message != NULL && defstr != NULL
7516 && argvars[1].v_type != VAR_UNKNOWN
7517 && argvars[2].v_type != VAR_UNKNOWN)
7518 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007519 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007520 else
7521 rettv->vval.v_string = NULL;
7522 }
7523 rettv->v_type = VAR_STRING;
7524 }
7525 else
7526#endif
7527 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
7528}
7529
7530/*
7531 * "inputlist()" function
7532 */
7533 static void
7534f_inputlist(typval_T *argvars, typval_T *rettv)
7535{
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007536 list_T *l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007537 listitem_T *li;
7538 int selected;
7539 int mouse_used;
7540
7541#ifdef NO_CONSOLE_INPUT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007542 // While starting up, there is no place to enter text. When running tests
7543 // with --not-a-term we assume feedkeys() will be used.
Bram Moolenaar91d348a2017-07-29 20:16:03 +02007544 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007545 return;
7546#endif
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007547 if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
7548 return;
7549
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007550 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
7551 {
Bram Moolenaar3a846e62022-01-01 16:21:00 +00007552 semsg(_(e_argument_of_str_must_be_list), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007553 return;
7554 }
7555
7556 msg_start();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007557 msg_row = Rows - 1; // for when 'cmdheight' > 1
7558 lines_left = Rows; // avoid more prompt
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007559 msg_scroll = TRUE;
7560 msg_clr_eos();
7561
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007562 l = argvars[0].vval.v_list;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007563 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02007564 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007565 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007566 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007567 msg_putchar('\n');
7568 }
7569
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007570 // Ask for choice.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007571 selected = prompt_for_number(&mouse_used);
7572 if (mouse_used)
7573 selected -= lines_left;
7574
7575 rettv->vval.v_number = selected;
7576}
7577
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007578static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
7579
7580/*
7581 * "inputrestore()" function
7582 */
7583 static void
7584f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
7585{
7586 if (ga_userinput.ga_len > 0)
7587 {
7588 --ga_userinput.ga_len;
7589 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
Bram Moolenaarc41badb2021-06-07 22:04:52 +02007590 + ga_userinput.ga_len, TRUE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007591 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007592 }
7593 else if (p_verbose > 1)
7594 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007595 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007596 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007597 }
7598}
7599
7600/*
7601 * "inputsave()" function
7602 */
7603 static void
7604f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
7605{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007606 // Add an entry to the stack of typeahead storage.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007607 if (ga_grow(&ga_userinput, 1) == OK)
7608 {
7609 save_typeahead((tasave_T *)(ga_userinput.ga_data)
7610 + ga_userinput.ga_len);
7611 ++ga_userinput.ga_len;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007612 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007613 }
7614 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007615 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007616}
7617
7618/*
7619 * "inputsecret()" function
7620 */
7621 static void
7622f_inputsecret(typval_T *argvars, typval_T *rettv)
7623{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007624 if (in_vim9script()
7625 && (check_for_string_arg(argvars, 0) == FAIL
7626 || check_for_opt_string_arg(argvars, 1) == FAIL))
7627 return;
7628
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007629 ++cmdline_star;
7630 ++inputsecret_flag;
7631 f_input(argvars, rettv);
7632 --cmdline_star;
7633 --inputsecret_flag;
7634}
7635
7636/*
Bram Moolenaar67a2deb2019-11-25 00:05:32 +01007637 * "interrupt()" function
7638 */
7639 static void
7640f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
7641{
7642 got_int = TRUE;
7643}
7644
7645/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007646 * "invert(expr)" function
7647 */
7648 static void
7649f_invert(typval_T *argvars, typval_T *rettv)
7650{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02007651 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
7652 return;
7653
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007654 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007655}
7656
7657/*
Ernie Rael4c8da022023-10-11 21:35:11 +02007658 * Free resources in lval_root allocated by fill_exec_lval_root().
7659 */
7660 static void
7661free_lval_root(lval_root_T *root)
7662{
7663 if (root->lr_tv != NULL)
7664 free_tv(root->lr_tv);
7665 class_unref(root->lr_cl_exec);
7666 root->lr_tv = NULL;
7667 root->lr_cl_exec = NULL;
7668}
7669
7670/*
7671 * This is used if executing in a method, the argument string is a
Ernie Rael0f058d12023-10-14 11:25:04 +02007672 * variable/item expr/reference. It may start with a potential class/object
7673 * variable.
Ernie Rael4c8da022023-10-11 21:35:11 +02007674 *
Ernie Rael0f058d12023-10-14 11:25:04 +02007675 * Adjust "root" as needed; lr_tv may be changed or freed.
Ernie Rael4c8da022023-10-11 21:35:11 +02007676 *
7677 * Always returns OK.
7678 * Free resources and return FAIL if the root should not be used. Otherwise OK.
7679 */
7680
7681 static int
Ernie Rael0f058d12023-10-14 11:25:04 +02007682fix_variable_reference_lval_root(lval_root_T *root, char_u *name)
Ernie Rael4c8da022023-10-11 21:35:11 +02007683{
Ernie Rael4c8da022023-10-11 21:35:11 +02007684
Ernie Rael0f058d12023-10-14 11:25:04 +02007685 // Check if lr_tv is the name of an object/class reference: name start with
7686 // "this" or name is class variable. Clear lr_tv if neither.
7687 int found_member = FALSE;
Ernie Rael4c8da022023-10-11 21:35:11 +02007688 if (root->lr_tv->v_type == VAR_OBJECT)
7689 {
Ernie Rael0f058d12023-10-14 11:25:04 +02007690 if (STRNCMP("this.", name, 5) == 0 ||STRCMP("this", name) == 0)
7691 found_member = TRUE;
Ernie Rael4c8da022023-10-11 21:35:11 +02007692 }
Ernie Rael0f058d12023-10-14 11:25:04 +02007693 if (!found_member) // not object member, try class member
Ernie Rael4c8da022023-10-11 21:35:11 +02007694 {
7695 // Explicitly check if the name is a class member.
7696 // If it's not then do nothing.
Ernie Rael0f058d12023-10-14 11:25:04 +02007697 char_u *end;
Ernie Rael4c8da022023-10-11 21:35:11 +02007698 for (end = name; ASCII_ISALNUM(*end) || *end == '_'; ++end)
7699 ;
Ernie Rael0f058d12023-10-14 11:25:04 +02007700 int idx = class_member_idx(root->lr_cl_exec, name, end - name);
7701 if (idx >= 0)
Ernie Rael4c8da022023-10-11 21:35:11 +02007702 {
Ernie Rael0f058d12023-10-14 11:25:04 +02007703 // A class variable, replace lr_tv with it
7704 clear_tv(root->lr_tv);
7705 copy_tv(&root->lr_cl_exec->class_members_tv[idx], root->lr_tv);
7706 found_member = TRUE;
Ernie Rael4c8da022023-10-11 21:35:11 +02007707 }
7708 }
Ernie Rael0f058d12023-10-14 11:25:04 +02007709 if (!found_member)
Ernie Rael4c8da022023-10-11 21:35:11 +02007710 {
7711 free_tv(root->lr_tv);
7712 root->lr_tv = NULL; // Not a member variable
7713 }
Ernie Rael4c8da022023-10-11 21:35:11 +02007714 // If FAIL, then must free_lval_root(root);
7715 return OK;
7716}
7717
7718/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007719 * "islocked()" function
7720 */
7721 static void
7722f_islocked(typval_T *argvars, typval_T *rettv)
7723{
7724 lval_T lv;
7725 char_u *end;
7726 dictitem_T *di;
7727
7728 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007729
7730 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
7731 return;
7732
Ernie Rael4c8da022023-10-11 21:35:11 +02007733 char_u *name = tv_get_string(&argvars[0]);
7734#ifdef LOG_LOCKVAR
7735 ch_log(NULL, "LKVAR: f_islocked(): name: %s", name);
7736#endif
7737
7738 lval_root_T aroot; // fully initialized in fill_exec_lval_root
7739 lval_root_T *root = NULL;
7740
7741 // Set up lval_root if executing in a method.
7742 if (fill_exec_lval_root(&aroot) == OK)
7743 {
7744 // Almost always produces a valid lval_root since lr_cl_exec is used
7745 // for access verification, lr_tv may be set to NULL.
Ernie Rael0f058d12023-10-14 11:25:04 +02007746 if (fix_variable_reference_lval_root(&aroot, name) == OK)
Ernie Rael4c8da022023-10-11 21:35:11 +02007747 root = &aroot;
Ernie Rael4c8da022023-10-11 21:35:11 +02007748 }
7749
7750 lval_root_T *lval_root_save = lval_root;
7751 lval_root = root;
7752 end = get_lval(name, NULL, &lv, FALSE, FALSE,
Bram Moolenaarbd77aa92021-08-12 17:06:05 +02007753 GLV_NO_AUTOLOAD | GLV_READ_ONLY | GLV_NO_DECL,
7754 FNE_CHECK_START);
Ernie Rael4c8da022023-10-11 21:35:11 +02007755 lval_root = lval_root_save;
7756
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007757 if (end != NULL && lv.ll_name != NULL)
7758 {
7759 if (*end != NUL)
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007760 {
7761 semsg(_(lv.ll_name == lv.ll_name_end
Bram Moolenaar0bd663a2022-01-22 10:24:47 +00007762 ? e_invalid_argument_str : e_trailing_characters_str), end);
Bram Moolenaar1840a7b2021-07-13 20:32:29 +02007763 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007764 else
7765 {
7766 if (lv.ll_tv == NULL)
7767 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01007768 di = find_var(lv.ll_name, NULL, TRUE);
7769 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007770 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007771 // Consider a variable locked when:
7772 // 1. the variable itself is locked
7773 // 2. the value of the variable is locked.
7774 // 3. the List or Dict value is locked.
Bram Moolenaar79518e22017-02-17 16:31:35 +01007775 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
7776 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007777 }
7778 }
Ernie Rael4c8da022023-10-11 21:35:11 +02007779 else if (lv.ll_is_root)
7780 {
7781 rettv->vval.v_number = tv_islocked(lv.ll_tv);
7782 }
Ernie Rael9771b2a2023-10-07 22:05:40 +02007783 else if (lv.ll_object != NULL)
7784 {
7785 typval_T *tv = ((typval_T *)(lv.ll_object + 1)) + lv.ll_oi;
7786 rettv->vval.v_number = tv_islocked(tv);
7787#ifdef LOG_LOCKVAR
7788 ch_log(NULL, "LKVAR: f_islocked(): name %s (obj)", lv.ll_name);
7789#endif
7790 }
7791 else if (lv.ll_class != NULL)
7792 {
7793 typval_T *tv = &lv.ll_class->class_members_tv[lv.ll_oi];
7794 rettv->vval.v_number = tv_islocked(tv);
7795#ifdef LOG_LOCKVAR
7796 ch_log(NULL, "LKVAR: f_islocked(): name %s (cl)", lv.ll_name);
7797#endif
7798 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007799 else if (lv.ll_range)
Bram Moolenaar677658a2022-01-05 16:09:06 +00007800 emsg(_(e_range_not_allowed));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007801 else if (lv.ll_newkey != NULL)
Bram Moolenaara9fa8c52023-01-02 18:10:04 +00007802 semsg(_(e_key_not_present_in_dictionary_str), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007803 else if (lv.ll_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007804 // List item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007805 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
7806 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007807 // Dictionary item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007808 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
7809 }
7810 }
7811
Ernie Rael4c8da022023-10-11 21:35:11 +02007812 if (root != NULL)
7813 free_lval_root(root);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007814 clear_lval(&lv);
7815}
7816
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007817/*
zeertzjqcdc83932022-09-12 13:38:41 +01007818 * "keytrans()" function
7819 */
7820 static void
7821f_keytrans(typval_T *argvars, typval_T *rettv)
7822{
7823 char_u *escaped;
7824
7825 rettv->v_type = VAR_STRING;
7826 if (check_for_string_arg(argvars, 0) == FAIL
7827 || argvars[0].vval.v_string == NULL)
7828 return;
7829 // Need to escape K_SPECIAL and CSI for mb_unescape().
7830 escaped = vim_strsave_escape_csi(argvars[0].vval.v_string);
7831 rettv->vval.v_string = str2special_save(escaped, TRUE, TRUE);
7832 vim_free(escaped);
7833}
7834
7835/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007836 * "last_buffer_nr()" function.
7837 */
7838 static void
7839f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
7840{
7841 int n = 0;
7842 buf_T *buf;
7843
Bram Moolenaar29323592016-07-24 22:04:11 +02007844 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007845 if (n < buf->b_fnum)
7846 n = buf->b_fnum;
7847
7848 rettv->vval.v_number = n;
7849}
7850
7851/*
7852 * "len()" function
7853 */
LemonBoy58f331a2022-04-02 21:59:06 +01007854 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007855f_len(typval_T *argvars, typval_T *rettv)
7856{
7857 switch (argvars[0].v_type)
7858 {
7859 case VAR_STRING:
7860 case VAR_NUMBER:
7861 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007862 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007863 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007864 case VAR_BLOB:
7865 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
7866 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007867 case VAR_LIST:
7868 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
7869 break;
7870 case VAR_DICT:
7871 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
7872 break;
Yegappan Lakshmanand3eae7b2024-03-03 16:26:58 +01007873 case VAR_OBJECT:
7874 rettv->vval.v_number = object_len(argvars[0].vval.v_object);
7875 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007876 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02007877 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007878 case VAR_VOID:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01007879 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007880 case VAR_SPECIAL:
7881 case VAR_FLOAT:
7882 case VAR_FUNC:
7883 case VAR_PARTIAL:
7884 case VAR_JOB:
7885 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02007886 case VAR_INSTR:
Bram Moolenaar00b28d62022-12-08 15:32:33 +00007887 case VAR_CLASS:
Yegappan Lakshmananec3cebb2023-10-27 19:35:26 +02007888 case VAR_TYPEALIAS:
Bram Moolenaara6f79292022-01-04 21:30:47 +00007889 emsg(_(e_invalid_type_for_len));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007890 break;
7891 }
7892}
7893
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007894 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01007895libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007896{
7897#ifdef FEAT_LIBCALL
7898 char_u *string_in;
7899 char_u **string_result;
7900 int nr_result;
7901#endif
7902
7903 rettv->v_type = type;
7904 if (type != VAR_NUMBER)
7905 rettv->vval.v_string = NULL;
7906
7907 if (check_restricted() || check_secure())
7908 return;
7909
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +02007910 if (in_vim9script()
7911 && (check_for_string_arg(argvars, 0) == FAIL
7912 || check_for_string_arg(argvars, 1) == FAIL
7913 || check_for_string_or_number_arg(argvars, 2) == FAIL))
7914 return;
7915
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007916#ifdef FEAT_LIBCALL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007917 // The first two args must be strings, otherwise it's meaningless
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007918 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
7919 {
7920 string_in = NULL;
7921 if (argvars[2].v_type == VAR_STRING)
7922 string_in = argvars[2].vval.v_string;
7923 if (type == VAR_NUMBER)
Bram Moolenaar87e15872021-09-02 19:53:07 +02007924 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007925 string_result = NULL;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007926 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007927 else
Bram Moolenaar87e15872021-09-02 19:53:07 +02007928 {
7929 rettv->vval.v_string = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007930 string_result = &rettv->vval.v_string;
Bram Moolenaar87e15872021-09-02 19:53:07 +02007931 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007932 if (mch_libcall(argvars[0].vval.v_string,
7933 argvars[1].vval.v_string,
7934 string_in,
7935 argvars[2].vval.v_number,
7936 string_result,
7937 &nr_result) == OK
7938 && type == VAR_NUMBER)
7939 rettv->vval.v_number = nr_result;
7940 }
7941#endif
7942}
7943
7944/*
7945 * "libcall()" function
7946 */
7947 static void
7948f_libcall(typval_T *argvars, typval_T *rettv)
7949{
7950 libcall_common(argvars, rettv, VAR_STRING);
7951}
7952
7953/*
7954 * "libcallnr()" function
7955 */
7956 static void
7957f_libcallnr(typval_T *argvars, typval_T *rettv)
7958{
7959 libcall_common(argvars, rettv, VAR_NUMBER);
7960}
7961
7962/*
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007963 * "line(string, [winid])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007964 */
7965 static void
7966f_line(typval_T *argvars, typval_T *rettv)
7967{
7968 linenr_T lnum = 0;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007969 pos_T *fp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007970 int fnum;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007971 int id;
7972 tabpage_T *tp;
7973 win_T *wp;
Bram Moolenaar18f47402022-01-06 13:24:51 +00007974 switchwin_T switchwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007975
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007976 if (in_vim9script()
7977 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02007978 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02007979 return;
7980
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007981 if (argvars[1].v_type != VAR_UNKNOWN)
7982 {
7983 // use window specified in the second argument
7984 id = (int)tv_get_number(&argvars[1]);
7985 wp = win_id2wp_tp(id, &tp);
7986 if (wp != NULL && tp != NULL)
7987 {
Bram Moolenaar18f47402022-01-06 13:24:51 +00007988 if (switch_win_noblock(&switchwin, wp, tp, TRUE) == OK)
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007989 {
7990 check_cursor();
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007991 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007992 }
Bram Moolenaar18f47402022-01-06 13:24:51 +00007993 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007994 }
7995 }
7996 else
7997 // use current window
Bram Moolenaar6f02b002021-01-10 20:22:54 +01007998 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02007999
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008000 if (fp != NULL)
8001 lnum = fp->lnum;
8002 rettv->vval.v_number = lnum;
8003}
8004
8005/*
8006 * "line2byte(lnum)" function
8007 */
8008 static void
8009f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
8010{
8011#ifndef FEAT_BYTEOFF
8012 rettv->vval.v_number = -1;
8013#else
8014 linenr_T lnum;
8015
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008016 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
8017 return;
8018
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008019 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008020 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
8021 rettv->vval.v_number = -1;
8022 else
8023 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
8024 if (rettv->vval.v_number >= 0)
8025 ++rettv->vval.v_number;
8026#endif
8027}
8028
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008029#ifdef FEAT_LUA
8030/*
8031 * "luaeval()" function
8032 */
8033 static void
8034f_luaeval(typval_T *argvars, typval_T *rettv)
8035{
8036 char_u *str;
8037 char_u buf[NUMBUFLEN];
8038
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008039 if (check_restricted() || check_secure())
8040 return;
8041
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02008042 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8043 return;
8044
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008045 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008046 do_luaeval(str, argvars + 1, rettv);
8047}
8048#endif
8049
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008050typedef enum
8051{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008052 MATCH_END, // matchend()
8053 MATCH_MATCH, // match()
8054 MATCH_STR, // matchstr()
8055 MATCH_LIST, // matchlist()
8056 MATCH_POS // matchstrpos()
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008057} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008058
8059 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008060find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008061{
8062 char_u *str = NULL;
8063 long len = 0;
8064 char_u *expr = NULL;
8065 char_u *pat;
8066 regmatch_T regmatch;
8067 char_u patbuf[NUMBUFLEN];
8068 char_u strbuf[NUMBUFLEN];
8069 char_u *save_cpo;
8070 long start = 0;
8071 long nth = 1;
8072 colnr_T startcol = 0;
8073 int match = 0;
8074 list_T *l = NULL;
8075 listitem_T *li = NULL;
8076 long idx = 0;
8077 char_u *tofree = NULL;
8078
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008079 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008080 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01008081 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008082
8083 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008084 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008085 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008086 // type MATCH_LIST: return empty list when there are no matches.
8087 // type MATCH_POS: return ["", -1, -1, -1]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008088 if (rettv_list_alloc(rettv) == FAIL)
8089 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008090 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008091 && (list_append_string(rettv->vval.v_list,
8092 (char_u *)"", 0) == FAIL
8093 || list_append_number(rettv->vval.v_list,
8094 (varnumber_T)-1) == FAIL
8095 || list_append_number(rettv->vval.v_list,
8096 (varnumber_T)-1) == FAIL
8097 || list_append_number(rettv->vval.v_list,
8098 (varnumber_T)-1) == FAIL))
8099 {
8100 list_free(rettv->vval.v_list);
8101 rettv->vval.v_list = NULL;
8102 goto theend;
8103 }
8104 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008105 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008106 {
8107 rettv->v_type = VAR_STRING;
8108 rettv->vval.v_string = NULL;
8109 }
8110
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02008111 if (in_vim9script()
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008112 && (check_for_string_or_list_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02008113 || check_for_string_arg(argvars, 1) == FAIL
8114 || check_for_opt_number_arg(argvars, 2) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02008115 || (argvars[2].v_type != VAR_UNKNOWN
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02008116 && check_for_opt_number_arg(argvars, 3) == FAIL)))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02008117 goto theend;
8118
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008119 if (argvars[0].v_type == VAR_LIST)
8120 {
8121 if ((l = argvars[0].vval.v_list) == NULL)
8122 goto theend;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008123 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008124 li = l->lv_first;
8125 }
8126 else
8127 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008128 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008129 len = (long)STRLEN(str);
8130 }
8131
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008132 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008133 if (pat == NULL)
8134 goto theend;
8135
8136 if (argvars[2].v_type != VAR_UNKNOWN)
8137 {
8138 int error = FALSE;
8139
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008140 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008141 if (error)
8142 goto theend;
8143 if (l != NULL)
8144 {
8145 li = list_find(l, start);
8146 if (li == NULL)
8147 goto theend;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008148 idx = l->lv_u.mat.lv_idx; // use the cached index
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008149 }
8150 else
8151 {
8152 if (start < 0)
8153 start = 0;
8154 if (start > len)
8155 goto theend;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008156 // When "count" argument is there ignore matches before "start",
8157 // otherwise skip part of the string. Differs when pattern is "^"
8158 // or "\<".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008159 if (argvars[3].v_type != VAR_UNKNOWN)
8160 startcol = start;
8161 else
8162 {
8163 str += start;
8164 len -= start;
8165 }
8166 }
8167
8168 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008169 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008170 if (error)
8171 goto theend;
8172 }
8173
8174 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
8175 if (regmatch.regprog != NULL)
8176 {
8177 regmatch.rm_ic = p_ic;
8178
8179 for (;;)
8180 {
8181 if (l != NULL)
8182 {
8183 if (li == NULL)
8184 {
8185 match = FALSE;
8186 break;
8187 }
8188 vim_free(tofree);
8189 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
8190 if (str == NULL)
8191 break;
8192 }
8193
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00008194 match = vim_regexec_nl(&regmatch, str, startcol);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008195
8196 if (match && --nth <= 0)
8197 break;
8198 if (l == NULL && !match)
8199 break;
8200
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008201 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008202 if (l != NULL)
8203 {
8204 li = li->li_next;
8205 ++idx;
8206 }
8207 else
8208 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008209 startcol = (colnr_T)(regmatch.startp[0]
8210 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008211 if (startcol > (colnr_T)len
8212 || str + startcol <= regmatch.startp[0])
8213 {
8214 match = FALSE;
8215 break;
8216 }
8217 }
8218 }
8219
8220 if (match)
8221 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008222 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008223 {
8224 listitem_T *li1 = rettv->vval.v_list->lv_first;
8225 listitem_T *li2 = li1->li_next;
8226 listitem_T *li3 = li2->li_next;
8227 listitem_T *li4 = li3->li_next;
8228
8229 vim_free(li1->li_tv.vval.v_string);
8230 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02008231 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008232 li3->li_tv.vval.v_number =
8233 (varnumber_T)(regmatch.startp[0] - expr);
8234 li4->li_tv.vval.v_number =
8235 (varnumber_T)(regmatch.endp[0] - expr);
8236 if (l != NULL)
8237 li2->li_tv.vval.v_number = (varnumber_T)idx;
8238 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008239 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008240 {
8241 int i;
8242
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008243 // return list with matched string and submatches
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008244 for (i = 0; i < NSUBEXP; ++i)
8245 {
8246 if (regmatch.endp[i] == NULL)
8247 {
8248 if (list_append_string(rettv->vval.v_list,
8249 (char_u *)"", 0) == FAIL)
8250 break;
8251 }
8252 else if (list_append_string(rettv->vval.v_list,
8253 regmatch.startp[i],
8254 (int)(regmatch.endp[i] - regmatch.startp[i]))
8255 == FAIL)
8256 break;
8257 }
8258 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008259 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008260 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008261 // return matched string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008262 if (l != NULL)
8263 copy_tv(&li->li_tv, rettv);
8264 else
8265 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02008266 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008267 }
8268 else if (l != NULL)
8269 rettv->vval.v_number = idx;
8270 else
8271 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008272 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008273 rettv->vval.v_number =
8274 (varnumber_T)(regmatch.startp[0] - str);
8275 else
8276 rettv->vval.v_number =
8277 (varnumber_T)(regmatch.endp[0] - str);
8278 rettv->vval.v_number += (varnumber_T)(str - expr);
8279 }
8280 }
8281 vim_regfree(regmatch.regprog);
8282 }
8283
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008284theend:
8285 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008286 // matchstrpos() without a list: drop the second item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008287 listitem_remove(rettv->vval.v_list,
8288 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008289 vim_free(tofree);
8290 p_cpo = save_cpo;
8291}
8292
8293/*
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +01008294 * Return all the matches in string "str" for pattern "rmp".
8295 * The matches are returned in the List "mlist".
8296 * If "submatches" is TRUE, then submatch information is also returned.
8297 * "matchbuf" is TRUE when called for matchbufline().
8298 */
8299 static int
8300get_matches_in_str(
8301 char_u *str,
8302 regmatch_T *rmp,
8303 list_T *mlist,
8304 int idx,
8305 int submatches,
8306 int matchbuf)
8307{
8308 long len = (long)STRLEN(str);
8309 int match = 0;
8310 colnr_T startidx = 0;
8311
8312 for (;;)
8313 {
8314 match = vim_regexec_nl(rmp, str, startidx);
8315 if (!match)
8316 break;
8317
8318 dict_T *d = dict_alloc();
8319 if (d == NULL)
8320 return FAIL;
8321 if (list_append_dict(mlist, d) == FAIL)
8322 return FAIL;;
8323
8324 if (dict_add_number(d, matchbuf ? "lnum" : "idx", idx) == FAIL)
8325 return FAIL;
8326
8327 if (dict_add_number(d, "byteidx",
8328 (colnr_T)(rmp->startp[0] - str)) == FAIL)
8329 return FAIL;
8330
8331 if (dict_add_string_len(d, "text", rmp->startp[0],
8332 (int)(rmp->endp[0] - rmp->startp[0])) == FAIL)
8333 return FAIL;
8334
8335 if (submatches)
8336 {
8337 list_T *sml = list_alloc();
8338 if (sml == NULL)
8339 return FAIL;
8340
8341 if (dict_add_list(d, "submatches", sml) == FAIL)
8342 return FAIL;
8343
8344 // return a list with the submatches
8345 for (int i = 1; i < NSUBEXP; ++i)
8346 {
8347 if (rmp->endp[i] == NULL)
8348 {
8349 if (list_append_string(sml, (char_u *)"", 0) == FAIL)
8350 return FAIL;
8351 }
8352 else if (list_append_string(sml, rmp->startp[i],
8353 (int)(rmp->endp[i] - rmp->startp[i])) == FAIL)
8354 return FAIL;
8355 }
8356 }
8357 startidx = (colnr_T)(rmp->endp[0] - str);
8358 if (startidx >= (colnr_T)len || str + startidx <= rmp->startp[0])
8359 break;
8360 }
8361
8362 return OK;
8363}
8364
8365/*
8366 * "matchbufline()" function
8367 */
8368 static void
8369f_matchbufline(typval_T *argvars, typval_T *rettv)
8370{
8371 list_T *retlist = NULL;
8372 char_u *save_cpo;
8373 char_u patbuf[NUMBUFLEN];
8374 regmatch_T regmatch;
8375
8376 rettv->vval.v_number = -1;
8377 if (rettv_list_alloc(rettv) != OK)
8378 return;
8379 retlist = rettv->vval.v_list;
8380
8381 if (check_for_buffer_arg(argvars, 0) == FAIL
8382 || check_for_string_arg(argvars, 1) == FAIL
8383 || check_for_lnum_arg(argvars, 2) == FAIL
8384 || check_for_lnum_arg(argvars, 3) == FAIL
8385 || check_for_opt_dict_arg(argvars, 4) == FAIL)
8386 return;
8387
8388 int prev_did_emsg = did_emsg;
8389 buf_T *buf = tv_get_buf(&argvars[0], FALSE);
8390 if (buf == NULL)
8391 {
8392 if (did_emsg == prev_did_emsg)
8393 semsg(_(e_invalid_buffer_name_str), tv_get_string(&argvars[0]));
8394 return;
8395 }
8396 if (buf->b_ml.ml_mfp == NULL)
8397 {
8398 emsg(_(e_buffer_is_not_loaded));
8399 return;
8400 }
8401
8402 char_u *pat = tv_get_string_buf(&argvars[1], patbuf);
8403
8404 int did_emsg_before = did_emsg;
8405 linenr_T slnum = tv_get_lnum_buf(&argvars[2], buf);
8406 if (did_emsg > did_emsg_before)
8407 return;
8408 if (slnum < 1)
8409 {
8410 semsg(_(e_invalid_value_for_argument_str), "lnum");
8411 return;
8412 }
8413
8414 linenr_T elnum = tv_get_lnum_buf(&argvars[3], buf);
8415 if (did_emsg > did_emsg_before)
8416 return;
8417 if (elnum < 1 || elnum < slnum)
8418 {
8419 semsg(_(e_invalid_value_for_argument_str), "end_lnum");
8420 return;
8421 }
8422
8423 if (elnum > buf->b_ml.ml_line_count)
8424 elnum = buf->b_ml.ml_line_count;
8425
8426 int submatches = FALSE;
8427 if (argvars[4].v_type != VAR_UNKNOWN)
8428 {
8429 dict_T *d = argvars[4].vval.v_dict;
8430 if (d != NULL)
8431 {
8432 dictitem_T *di = dict_find(d, (char_u *)"submatches", -1);
8433 if (di != NULL)
8434 {
8435 if (di->di_tv.v_type != VAR_BOOL)
8436 {
8437 semsg(_(e_invalid_value_for_argument_str), "submatches");
8438 return;
8439 }
8440 submatches = tv_get_bool(&di->di_tv);
8441 }
8442 }
8443 }
8444
8445 // Make 'cpoptions' empty, the 'l' flag should not be used here.
8446 save_cpo = p_cpo;
8447 p_cpo = empty_option;
8448
8449 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
8450 if (regmatch.regprog == NULL)
8451 goto theend;
8452 regmatch.rm_ic = p_ic;
8453
8454 while (slnum <= elnum)
8455 {
8456 char_u *str = ml_get_buf(buf, slnum, FALSE);
8457 if (get_matches_in_str(str, &regmatch, retlist, slnum, submatches,
8458 TRUE) == FAIL)
8459 goto cleanup;
8460 slnum++;
8461 }
8462
8463cleanup:
8464 vim_regfree(regmatch.regprog);
8465
8466theend:
8467 p_cpo = save_cpo;
8468}
8469
8470/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008471 * "match()" function
8472 */
8473 static void
8474f_match(typval_T *argvars, typval_T *rettv)
8475{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008476 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008477}
8478
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008479/*
8480 * "matchend()" function
8481 */
8482 static void
8483f_matchend(typval_T *argvars, typval_T *rettv)
8484{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008485 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008486}
8487
8488/*
8489 * "matchlist()" function
8490 */
8491 static void
8492f_matchlist(typval_T *argvars, typval_T *rettv)
8493{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008494 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008495}
8496
8497/*
8498 * "matchstr()" function
8499 */
8500 static void
8501f_matchstr(typval_T *argvars, typval_T *rettv)
8502{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008503 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008504}
8505
8506/*
Yegappan Lakshmananf93b1c82024-01-04 22:28:46 +01008507 * "matchstrlist()" function
8508 */
8509 static void
8510f_matchstrlist(typval_T *argvars, typval_T *rettv)
8511{
8512 list_T *retlist = NULL;
8513 char_u *save_cpo;
8514 list_T *l = NULL;
8515 listitem_T *li = NULL;
8516 char_u patbuf[NUMBUFLEN];
8517 regmatch_T regmatch;
8518
8519 rettv->vval.v_number = -1;
8520 if (rettv_list_alloc(rettv) != OK)
8521 return;
8522 retlist = rettv->vval.v_list;
8523
8524 if (check_for_list_arg(argvars, 0) == FAIL
8525 || check_for_string_arg(argvars, 1) == FAIL
8526 || check_for_opt_dict_arg(argvars, 2) == FAIL)
8527 return;
8528
8529 if ((l = argvars[0].vval.v_list) == NULL)
8530 return;
8531
8532 char_u *pat = tv_get_string_buf_chk(&argvars[1], patbuf);
8533 if (pat == NULL)
8534 return;
8535
8536 // Make 'cpoptions' empty, the 'l' flag should not be used here.
8537 save_cpo = p_cpo;
8538 p_cpo = empty_option;
8539
8540 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
8541 if (regmatch.regprog == NULL)
8542 goto theend;
8543 regmatch.rm_ic = p_ic;
8544
8545 int submatches = FALSE;
8546 if (argvars[2].v_type != VAR_UNKNOWN)
8547 {
8548 dict_T *d = argvars[2].vval.v_dict;
8549 if (d != NULL)
8550 {
8551 dictitem_T *di = dict_find(d, (char_u *)"submatches", -1);
8552 if (di != NULL)
8553 {
8554 if (di->di_tv.v_type != VAR_BOOL)
8555 {
8556 semsg(_(e_invalid_value_for_argument_str), "submatches");
8557 goto cleanup;
8558 }
8559 submatches = tv_get_bool(&di->di_tv);
8560 }
8561 }
8562 }
8563
8564 int idx = 0;
8565 CHECK_LIST_MATERIALIZE(l);
8566 FOR_ALL_LIST_ITEMS(l, li)
8567 {
8568 if (li->li_tv.v_type == VAR_STRING && li->li_tv.vval.v_string != NULL)
8569 {
8570 char_u *str = li->li_tv.vval.v_string;
8571 if (get_matches_in_str(str, &regmatch, retlist, idx, submatches,
8572 FALSE) == FAIL)
8573 goto cleanup;
8574 }
8575 idx++;
8576 }
8577
8578cleanup:
8579 vim_regfree(regmatch.regprog);
8580
8581theend:
8582 p_cpo = save_cpo;
8583}
8584
8585/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008586 * "matchstrpos()" function
8587 */
8588 static void
8589f_matchstrpos(typval_T *argvars, typval_T *rettv)
8590{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008591 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008592}
8593
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008594 static void
8595max_min(typval_T *argvars, typval_T *rettv, int domax)
8596{
8597 varnumber_T n = 0;
8598 varnumber_T i;
8599 int error = FALSE;
8600
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008601 if (in_vim9script() && check_for_list_or_dict_arg(argvars, 0) == FAIL)
8602 return;
8603
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008604 if (argvars[0].v_type == VAR_LIST)
8605 {
8606 list_T *l;
8607 listitem_T *li;
8608
8609 l = argvars[0].vval.v_list;
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008610 if (l != NULL && l->lv_len > 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008611 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008612 if (l->lv_first == &range_list_item)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008613 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008614 if ((l->lv_u.nonmat.lv_stride > 0) ^ domax)
8615 n = l->lv_u.nonmat.lv_start;
8616 else
=?UTF-8?q?Dundar=20G=C3=B6c?=d5cec1f2022-01-29 15:19:23 +00008617 n = l->lv_u.nonmat.lv_start + ((varnumber_T)l->lv_len - 1)
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008618 * l->lv_u.nonmat.lv_stride;
8619 }
8620 else
8621 {
8622 li = l->lv_first;
8623 if (li != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008624 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008625 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01008626 if (error)
8627 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008628 for (;;)
8629 {
8630 li = li->li_next;
8631 if (li == NULL)
8632 break;
8633 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01008634 if (error)
8635 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01008636 if (domax ? i > n : i < n)
8637 n = i;
8638 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008639 }
8640 }
8641 }
8642 }
8643 else if (argvars[0].v_type == VAR_DICT)
8644 {
8645 dict_T *d;
8646 int first = TRUE;
8647 hashitem_T *hi;
8648 int todo;
8649
8650 d = argvars[0].vval.v_dict;
8651 if (d != NULL)
8652 {
8653 todo = (int)d->dv_hashtab.ht_used;
Yegappan Lakshmanan14113fd2023-03-07 17:13:51 +00008654 FOR_ALL_HASHTAB_ITEMS(&d->dv_hashtab, hi, todo)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008655 {
8656 if (!HASHITEM_EMPTY(hi))
8657 {
8658 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008659 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01008660 if (error)
8661 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008662 if (first)
8663 {
8664 n = i;
8665 first = FALSE;
8666 }
8667 else if (domax ? i > n : i < n)
8668 n = i;
8669 }
8670 }
8671 }
8672 }
8673 else
Bram Moolenaar460ae5d2022-01-01 14:19:49 +00008674 semsg(_(e_argument_of_str_must_be_list_or_dictionary), domax ? "max()" : "min()");
Bram Moolenaarab65fc72021-02-04 22:07:16 +01008675
8676 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008677}
8678
8679/*
8680 * "max()" function
8681 */
8682 static void
8683f_max(typval_T *argvars, typval_T *rettv)
8684{
8685 max_min(argvars, rettv, TRUE);
8686}
8687
8688/*
8689 * "min()" function
8690 */
8691 static void
8692f_min(typval_T *argvars, typval_T *rettv)
8693{
8694 max_min(argvars, rettv, FALSE);
8695}
8696
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008697#if defined(FEAT_MZSCHEME) || defined(PROTO)
8698/*
8699 * "mzeval()" function
8700 */
8701 static void
8702f_mzeval(typval_T *argvars, typval_T *rettv)
8703{
8704 char_u *str;
8705 char_u buf[NUMBUFLEN];
8706
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008707 if (check_restricted() || check_secure())
8708 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008709
8710 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8711 return;
8712
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008713 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008714 do_mzeval(str, rettv);
8715}
8716
8717 void
8718mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
8719{
8720 typval_T argvars[3];
8721
8722 argvars[0].v_type = VAR_STRING;
8723 argvars[0].vval.v_string = name;
8724 copy_tv(args, &argvars[1]);
8725 argvars[2].v_type = VAR_UNKNOWN;
8726 f_call(argvars, rettv);
8727 clear_tv(&argvars[1]);
8728}
8729#endif
8730
8731/*
8732 * "nextnonblank()" function
8733 */
8734 static void
8735f_nextnonblank(typval_T *argvars, typval_T *rettv)
8736{
8737 linenr_T lnum;
8738
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008739 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
8740 return;
8741
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008742 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008743 {
8744 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
8745 {
8746 lnum = 0;
8747 break;
8748 }
8749 if (*skipwhite(ml_get(lnum)) != NUL)
8750 break;
8751 }
8752 rettv->vval.v_number = lnum;
8753}
8754
8755/*
8756 * "nr2char()" function
8757 */
8758 static void
8759f_nr2char(typval_T *argvars, typval_T *rettv)
8760{
8761 char_u buf[NUMBUFLEN];
8762
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02008763 if (in_vim9script()
8764 && (check_for_number_arg(argvars, 0) == FAIL
8765 || check_for_opt_bool_arg(argvars, 1) == FAIL))
8766 return;
8767
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008768 if (has_mbyte)
8769 {
8770 int utf8 = 0;
8771
8772 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaared6a4302020-09-05 20:29:41 +02008773 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008774 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01008775 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008776 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008777 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008778 }
8779 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008780 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008781 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008782 buf[1] = NUL;
8783 }
8784 rettv->v_type = VAR_STRING;
8785 rettv->vval.v_string = vim_strsave(buf);
8786}
8787
8788/*
8789 * "or(expr, expr)" function
8790 */
8791 static void
8792f_or(typval_T *argvars, typval_T *rettv)
8793{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008794 if (in_vim9script()
8795 && (check_for_number_arg(argvars, 0) == FAIL
8796 || check_for_number_arg(argvars, 1) == FAIL))
8797 return;
8798
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008799 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
8800 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008801}
8802
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008803#ifdef FEAT_PERL
8804/*
8805 * "perleval()" function
8806 */
8807 static void
8808f_perleval(typval_T *argvars, typval_T *rettv)
8809{
8810 char_u *str;
8811 char_u buf[NUMBUFLEN];
8812
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008813 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8814 return;
8815
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008816 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008817 do_perleval(str, rettv);
8818}
8819#endif
8820
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008821/*
8822 * "prevnonblank()" function
8823 */
8824 static void
8825f_prevnonblank(typval_T *argvars, typval_T *rettv)
8826{
8827 linenr_T lnum;
8828
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008829 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
8830 return;
8831
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008832 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008833 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
8834 lnum = 0;
8835 else
8836 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
8837 --lnum;
8838 rettv->vval.v_number = lnum;
8839}
8840
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008841// This dummy va_list is here because:
8842// - passing a NULL pointer doesn't work when va_list isn't a pointer
8843// - locally in the function results in a "used before set" warning
8844// - using va_start() to initialize it gives "function with fixed args" error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008845static va_list ap;
8846
8847/*
8848 * "printf()" function
8849 */
8850 static void
8851f_printf(typval_T *argvars, typval_T *rettv)
8852{
8853 char_u buf[NUMBUFLEN];
8854 int len;
8855 char_u *s;
8856 int saved_did_emsg = did_emsg;
8857 char *fmt;
8858
8859 rettv->v_type = VAR_STRING;
8860 rettv->vval.v_string = NULL;
8861
Yegappan Lakshmanana764e732021-07-25 15:57:32 +02008862 if (in_vim9script() && check_for_string_or_number_arg(argvars, 0) == FAIL)
8863 return;
8864
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008865 // Get the required length, allocate the buffer and do it for real.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008866 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008867 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008868 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008869 if (!did_emsg)
8870 {
8871 s = alloc(len + 1);
8872 if (s != NULL)
8873 {
8874 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008875 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
8876 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008877 }
8878 }
8879 did_emsg |= saved_did_emsg;
8880}
8881
8882/*
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008883 * "pum_getpos()" function
8884 */
8885 static void
8886f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8887{
Bram Moolenaar93a10962022-06-16 11:42:09 +01008888 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008889 return;
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008890 pum_set_event_info(rettv->vval.v_dict);
Bram Moolenaare9bd5722019-08-17 19:36:06 +02008891}
8892
8893/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008894 * "pumvisible()" function
8895 */
8896 static void
8897f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8898{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008899 if (pum_visible())
8900 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008901}
8902
8903#ifdef FEAT_PYTHON3
8904/*
8905 * "py3eval()" function
8906 */
8907 static void
8908f_py3eval(typval_T *argvars, typval_T *rettv)
8909{
8910 char_u *str;
8911 char_u buf[NUMBUFLEN];
8912
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008913 if (check_restricted() || check_secure())
8914 return;
8915
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008916 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8917 return;
8918
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008919 if (p_pyx == 0)
8920 p_pyx = 3;
8921
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008922 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008923 do_py3eval(str, rettv);
8924}
8925#endif
8926
8927#ifdef FEAT_PYTHON
8928/*
8929 * "pyeval()" function
8930 */
8931 static void
8932f_pyeval(typval_T *argvars, typval_T *rettv)
8933{
8934 char_u *str;
8935 char_u buf[NUMBUFLEN];
8936
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008937 if (check_restricted() || check_secure())
8938 return;
8939
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008940 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8941 return;
8942
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008943 if (p_pyx == 0)
8944 p_pyx = 2;
8945
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008946 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008947 do_pyeval(str, rettv);
8948}
8949#endif
8950
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008951#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
8952/*
8953 * "pyxeval()" function
8954 */
8955 static void
8956f_pyxeval(typval_T *argvars, typval_T *rettv)
8957{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008958 if (check_restricted() || check_secure())
8959 return;
8960
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008961 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
8962 return;
8963
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008964# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
8965 init_pyxversion();
8966 if (p_pyx == 2)
8967 f_pyeval(argvars, rettv);
8968 else
8969 f_py3eval(argvars, rettv);
8970# elif defined(FEAT_PYTHON)
8971 f_pyeval(argvars, rettv);
8972# elif defined(FEAT_PYTHON3)
8973 f_py3eval(argvars, rettv);
8974# endif
8975}
8976#endif
8977
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008978static UINT32_T srand_seed_for_testing = 0;
8979static int srand_seed_for_testing_is_used = FALSE;
8980
8981 static void
8982f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED)
8983{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02008984 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
8985 return;
8986
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008987 if (argvars[0].v_type == VAR_UNKNOWN)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008988 srand_seed_for_testing_is_used = FALSE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008989 else
8990 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008991 srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]);
8992 srand_seed_for_testing_is_used = TRUE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01008993 }
8994}
8995
8996 static void
8997init_srand(UINT32_T *x)
8998{
8999#ifndef MSWIN
9000 static int dev_urandom_state = NOTDONE; // FAIL or OK once tried
9001#endif
9002
9003 if (srand_seed_for_testing_is_used)
9004 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02009005 *x = srand_seed_for_testing;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009006 return;
9007 }
9008#ifndef MSWIN
9009 if (dev_urandom_state != FAIL)
9010 {
9011 int fd = open("/dev/urandom", O_RDONLY);
9012 struct {
9013 union {
9014 UINT32_T number;
9015 char bytes[sizeof(UINT32_T)];
9016 } contents;
9017 } buf;
9018
9019 // Attempt reading /dev/urandom.
9020 if (fd == -1)
9021 dev_urandom_state = FAIL;
9022 else
9023 {
9024 buf.contents.number = 0;
9025 if (read(fd, buf.contents.bytes, sizeof(UINT32_T))
9026 != sizeof(UINT32_T))
9027 dev_urandom_state = FAIL;
9028 else
9029 {
9030 dev_urandom_state = OK;
9031 *x = buf.contents.number;
9032 }
9033 close(fd);
9034 }
9035 }
9036 if (dev_urandom_state != OK)
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009037#endif
Yasuhiro Matsumotof0a9c002022-12-05 21:55:55 +00009038 {
9039 // Reading /dev/urandom doesn't work, fall back to:
9040 // - randombytes_random()
9041 // - reltime() or time()
9042 // - XOR with process ID
9043#if defined(FEAT_SODIUM)
K.Takataa8cdb4e2022-12-06 16:17:01 +00009044 if (crypt_sodium_init() >= 0)
9045 *x = crypt_sodium_randombytes_random();
Yasuhiro Matsumotof0a9c002022-12-05 21:55:55 +00009046 else
9047#endif
9048 {
9049#if defined(FEAT_RELTIME)
9050 proftime_T res;
9051 profile_start(&res);
9052# if defined(MSWIN)
9053 *x = (UINT32_T)res.LowPart;
9054# else
Ernie Rael076de792023-03-16 21:43:15 +00009055 *x = (UINT32_T)res.tv_fsec;
Yasuhiro Matsumotof0a9c002022-12-05 21:55:55 +00009056# endif
9057#else
9058 *x = vim_time();
9059#endif
9060 *x ^= mch_get_pid();
9061 }
9062 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009063}
9064
kylo252ae6f1d82022-02-16 19:24:07 +00009065#define ROTL(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009066#define SPLITMIX32(x, z) ( \
kylo252ae6f1d82022-02-16 19:24:07 +00009067 (z) = ((x) += 0x9e3779b9), \
9068 (z) = ((z) ^ ((z) >> 16)) * 0x85ebca6b, \
9069 (z) = ((z) ^ ((z) >> 13)) * 0xc2b2ae35, \
9070 (z) ^ ((z) >> 16) \
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009071 )
9072#define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \
kylo252ae6f1d82022-02-16 19:24:07 +00009073 result = ROTL((y) * 5, 7) * 9; \
9074 t = (y) << 9; \
9075 (z) ^= (x); \
9076 (w) ^= (y); \
9077 (y) ^= (z), (x) ^= (w); \
9078 (z) ^= t; \
9079 (w) = ROTL(w, 11);
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009080
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009081/*
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009082 * "rand()" function
9083 */
9084 static void
9085f_rand(typval_T *argvars, typval_T *rettv)
9086{
9087 list_T *l = NULL;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009088 static UINT32_T gx, gy, gz, gw;
9089 static int initialized = FALSE;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009090 listitem_T *lx, *ly, *lz, *lw;
Bram Moolenaar0fd797e2020-11-05 20:46:32 +01009091 UINT32_T x = 0, y, z, w, t, result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009092
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009093 if (in_vim9script() && check_for_opt_list_arg(argvars, 0) == FAIL)
9094 return;
9095
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009096 if (argvars[0].v_type == VAR_UNKNOWN)
9097 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009098 // When no argument is given use the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009099 if (initialized == FALSE)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009100 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009101 // Initialize the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009102 init_srand(&x);
9103
9104 gx = SPLITMIX32(x, z);
9105 gy = SPLITMIX32(x, z);
9106 gz = SPLITMIX32(x, z);
9107 gw = SPLITMIX32(x, z);
9108 initialized = TRUE;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009109 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009110
9111 SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009112 }
9113 else if (argvars[0].v_type == VAR_LIST)
9114 {
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009115 l = argvars[0].vval.v_list;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009116 if (l == NULL || list_len(l) != 4)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009117 goto theend;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009118
9119 lx = list_find(l, 0L);
9120 ly = list_find(l, 1L);
9121 lz = list_find(l, 2L);
9122 lw = list_find(l, 3L);
9123 if (lx->li_tv.v_type != VAR_NUMBER) goto theend;
9124 if (ly->li_tv.v_type != VAR_NUMBER) goto theend;
9125 if (lz->li_tv.v_type != VAR_NUMBER) goto theend;
9126 if (lw->li_tv.v_type != VAR_NUMBER) goto theend;
9127 x = (UINT32_T)lx->li_tv.vval.v_number;
9128 y = (UINT32_T)ly->li_tv.vval.v_number;
9129 z = (UINT32_T)lz->li_tv.vval.v_number;
9130 w = (UINT32_T)lw->li_tv.vval.v_number;
9131
9132 SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w);
9133
9134 lx->li_tv.vval.v_number = (varnumber_T)x;
9135 ly->li_tv.vval.v_number = (varnumber_T)y;
9136 lz->li_tv.vval.v_number = (varnumber_T)z;
9137 lw->li_tv.vval.v_number = (varnumber_T)w;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009138 }
9139 else
9140 goto theend;
9141
9142 rettv->v_type = VAR_NUMBER;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009143 rettv->vval.v_number = (varnumber_T)result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009144 return;
9145
9146theend:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009147 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01009148 rettv->v_type = VAR_NUMBER;
9149 rettv->vval.v_number = -1;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01009150}
9151
9152/*
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009153 * "srand()" function
9154 */
9155 static void
9156f_srand(typval_T *argvars, typval_T *rettv)
9157{
9158 UINT32_T x = 0, z;
9159
9160 if (rettv_list_alloc(rettv) == FAIL)
9161 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009162
9163 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
9164 return;
9165
Bram Moolenaar4f645c52020-02-08 16:40:39 +01009166 if (argvars[0].v_type == VAR_UNKNOWN)
9167 {
9168 init_srand(&x);
9169 }
9170 else
9171 {
9172 int error = FALSE;
9173
9174 x = (UINT32_T)tv_get_number_chk(&argvars[0], &error);
9175 if (error)
9176 return;
9177 }
9178
9179 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
9180 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
9181 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
9182 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
9183}
9184
9185#undef ROTL
9186#undef SPLITMIX32
9187#undef SHUFFLE_XOSHIRO128STARSTAR
9188
9189/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009190 * "range()" function
9191 */
9192 static void
9193f_range(typval_T *argvars, typval_T *rettv)
9194{
9195 varnumber_T start;
9196 varnumber_T end;
9197 varnumber_T stride = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009198 int error = FALSE;
9199
Bram Moolenaar93a10962022-06-16 11:42:09 +01009200 if (rettv_list_alloc(rettv) == FAIL)
Yegappan Lakshmananca195cc2022-06-14 13:42:26 +01009201 return;
9202
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009203 if (in_vim9script()
9204 && (check_for_number_arg(argvars, 0) == FAIL
9205 || check_for_opt_number_arg(argvars, 1) == FAIL
9206 || (argvars[1].v_type != VAR_UNKNOWN
9207 && check_for_opt_number_arg(argvars, 2) == FAIL)))
9208 return;
9209
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009210 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009211 if (argvars[1].v_type == VAR_UNKNOWN)
9212 {
9213 end = start - 1;
9214 start = 0;
9215 }
9216 else
9217 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009218 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009219 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009220 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009221 }
9222
9223 if (error)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009224 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009225 if (stride == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009226 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00009227 emsg(_(e_stride_is_zero));
9228 return;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009229 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +00009230 if (stride > 0 ? end + 1 < start : end - 1 > start)
9231 {
9232 emsg(_(e_start_past_end));
9233 return;
9234 }
9235
9236 list_T *list = rettv->vval.v_list;
9237
9238 // Create a non-materialized list. This is much more efficient and
9239 // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must
9240 // be called.
9241 list->lv_first = &range_list_item;
9242 list->lv_u.nonmat.lv_start = start;
9243 list->lv_u.nonmat.lv_end = end;
9244 list->lv_u.nonmat.lv_stride = stride;
Christian Brabandtdf63da92023-11-23 20:14:28 +01009245 if (stride > 0 ? end < start : end > start)
9246 list->lv_len = 0;
9247 else
9248 list->lv_len = (end - start) / stride + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009249}
9250
9251/*
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009252 * Materialize "list".
9253 * Do not call directly, use CHECK_LIST_MATERIALIZE()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009254 */
9255 void
9256range_list_materialize(list_T *list)
9257{
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009258 varnumber_T start = list->lv_u.nonmat.lv_start;
9259 varnumber_T end = list->lv_u.nonmat.lv_end;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00009260 int stride = list->lv_u.nonmat.lv_stride;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009261 varnumber_T i;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009262
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009263 list->lv_first = NULL;
9264 list->lv_u.mat.lv_last = NULL;
9265 list->lv_len = 0;
9266 list->lv_u.mat.lv_idx_item = NULL;
9267 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
Bram Moolenaar70c43d82022-01-26 21:01:15 +00009268 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00009269 if (list_append_number(list, i) == FAIL)
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02009270 break;
Bram Moolenaar70c43d82022-01-26 21:01:15 +00009271 if (list->lv_lock & VAR_ITEMS_LOCKED)
9272 list->lv_u.mat.lv_last->li_tv.v_lock = VAR_LOCKED;
9273 }
9274 list->lv_lock &= ~VAR_ITEMS_LOCKED;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009275}
9276
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009277/*
9278 * "getreginfo()" function
9279 */
9280 static void
9281f_getreginfo(typval_T *argvars, typval_T *rettv)
9282{
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009283 int regname;
9284 char_u buf[NUMBUFLEN + 2];
9285 long reglen = 0;
9286 dict_T *dict;
9287 list_T *list;
9288
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009289 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
9290 return;
9291
zeertzjqd3f00f52021-12-24 12:02:43 +00009292 regname = getreg_get_regname(argvars);
9293 if (regname == 0)
9294 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009295
zeertzjqd3f00f52021-12-24 12:02:43 +00009296 if (regname == '@')
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009297 regname = '"';
9298
9299 if (rettv_dict_alloc(rettv) == FAIL)
9300 return;
9301 dict = rettv->vval.v_dict;
9302
9303 list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
9304 if (list == NULL)
9305 return;
Bram Moolenaar91639192020-06-29 19:55:58 +02009306 (void)dict_add_list(dict, "regcontents", list);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009307
9308 buf[0] = NUL;
9309 buf[1] = NUL;
9310 switch (get_reg_type(regname, &reglen))
9311 {
9312 case MLINE: buf[0] = 'V'; break;
9313 case MCHAR: buf[0] = 'v'; break;
9314 case MBLOCK:
9315 vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
9316 reglen + 1);
9317 break;
9318 }
Bram Moolenaar91639192020-06-29 19:55:58 +02009319 (void)dict_add_string(dict, (char *)"regtype", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009320
9321 buf[0] = get_register_name(get_unname_register());
9322 buf[1] = NUL;
9323 if (regname == '"')
Bram Moolenaar91639192020-06-29 19:55:58 +02009324 (void)dict_add_string(dict, (char *)"points_to", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009325 else
9326 {
9327 dictitem_T *item = dictitem_alloc((char_u *)"isunnamed");
9328
9329 if (item != NULL)
9330 {
Bram Moolenaar82946e12022-11-24 11:31:29 +00009331 item->di_tv.v_type = VAR_BOOL;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009332 item->di_tv.vval.v_number = regname == buf[0]
Bram Moolenaar418a29f2021-02-10 22:23:41 +01009333 ? VVAL_TRUE : VVAL_FALSE;
Bram Moolenaar91639192020-06-29 19:55:58 +02009334 (void)dict_add(dict, item);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02009335 }
9336 }
9337}
9338
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02009339 static void
9340return_register(int regname, typval_T *rettv)
9341{
9342 char_u buf[2] = {0, 0};
9343
9344 buf[0] = (char_u)regname;
9345 rettv->v_type = VAR_STRING;
9346 rettv->vval.v_string = vim_strsave(buf);
9347}
9348
9349/*
9350 * "reg_executing()" function
9351 */
9352 static void
9353f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
9354{
9355 return_register(reg_executing, rettv);
9356}
9357
9358/*
9359 * "reg_recording()" function
9360 */
9361 static void
9362f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
9363{
9364 return_register(reg_recording, rettv);
9365}
9366
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01009367/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009368 * "rename({from}, {to})" function
9369 */
9370 static void
9371f_rename(typval_T *argvars, typval_T *rettv)
9372{
9373 char_u buf[NUMBUFLEN];
9374
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009375 rettv->vval.v_number = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009376 if (check_restricted() || check_secure())
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009377 return;
9378
9379 if (in_vim9script()
9380 && (check_for_string_arg(argvars, 0) == FAIL
9381 || check_for_string_arg(argvars, 1) == FAIL))
9382 return;
9383
9384 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009385 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009386}
9387
9388/*
9389 * "repeat()" function
9390 */
9391 static void
9392f_repeat(typval_T *argvars, typval_T *rettv)
9393{
9394 char_u *p;
Bakudankun375141e2022-09-09 18:46:47 +01009395 varnumber_T n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009396 int slen;
9397 int len;
9398 char_u *r;
9399 int i;
9400
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02009401 if (in_vim9script()
Bakudankun375141e2022-09-09 18:46:47 +01009402 && (check_for_string_or_number_or_list_or_blob_arg(argvars, 0)
9403 == FAIL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009404 || check_for_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02009405 return;
9406
Bakudankun375141e2022-09-09 18:46:47 +01009407 n = tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009408 if (argvars[0].v_type == VAR_LIST)
9409 {
9410 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
9411 while (n-- > 0)
9412 if (list_extend(rettv->vval.v_list,
9413 argvars[0].vval.v_list, NULL) == FAIL)
9414 break;
9415 }
Bakudankun375141e2022-09-09 18:46:47 +01009416 else if (argvars[0].v_type == VAR_BLOB)
9417 {
9418 if (rettv_blob_alloc(rettv) == FAIL
9419 || argvars[0].vval.v_blob == NULL
9420 || n <= 0)
9421 return;
9422
9423 slen = argvars[0].vval.v_blob->bv_ga.ga_len;
9424 len = (int)slen * n;
9425 if (len <= 0)
9426 return;
9427
9428 if (ga_grow(&rettv->vval.v_blob->bv_ga, len) == FAIL)
9429 return;
9430
9431 rettv->vval.v_blob->bv_ga.ga_len = len;
9432
9433 for (i = 0; i < slen; ++i)
9434 if (blob_get(argvars[0].vval.v_blob, i) != 0)
9435 break;
9436
9437 if (i == slen)
9438 // No need to copy since all bytes are already zero
9439 return;
9440
9441 for (i = 0; i < n; ++i)
9442 blob_set_range(rettv->vval.v_blob,
9443 (long)i * slen, ((long)i + 1) * slen - 1, argvars);
9444 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009445 else
9446 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009447 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009448 rettv->v_type = VAR_STRING;
9449 rettv->vval.v_string = NULL;
9450
9451 slen = (int)STRLEN(p);
9452 len = slen * n;
9453 if (len <= 0)
9454 return;
9455
9456 r = alloc(len + 1);
9457 if (r != NULL)
9458 {
9459 for (i = 0; i < n; i++)
9460 mch_memmove(r + i * slen, p, (size_t)slen);
9461 r[len] = NUL;
9462 }
9463
9464 rettv->vval.v_string = r;
9465 }
9466}
9467
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009468#define SP_NOMOVE 0x01 // don't move cursor
9469#define SP_REPEAT 0x02 // repeat to find outer pair
9470#define SP_RETCOUNT 0x04 // return matchcount
9471#define SP_SETPCMARK 0x08 // set previous context mark
9472#define SP_START 0x10 // accept match at start position
9473#define SP_SUBPAT 0x20 // return nr of matching sub-pattern
9474#define SP_END 0x40 // leave cursor at end of match
9475#define SP_COLUMN 0x80 // start at cursor column
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009476
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009477/*
9478 * Get flags for a search function.
9479 * Possibly sets "p_ws".
9480 * Returns BACKWARD, FORWARD or zero (for an error).
9481 */
9482 static int
9483get_search_arg(typval_T *varp, int *flagsp)
9484{
9485 int dir = FORWARD;
9486 char_u *flags;
9487 char_u nbuf[NUMBUFLEN];
9488 int mask;
9489
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009490 if (varp->v_type == VAR_UNKNOWN)
9491 return FORWARD;
9492
9493 flags = tv_get_string_buf_chk(varp, nbuf);
9494 if (flags == NULL)
9495 return 0; // type error; errmsg already given
9496 while (*flags != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009497 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009498 switch (*flags)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009499 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009500 case 'b': dir = BACKWARD; break;
9501 case 'w': p_ws = TRUE; break;
9502 case 'W': p_ws = FALSE; break;
9503 default: mask = 0;
9504 if (flagsp != NULL)
9505 switch (*flags)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009506 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009507 case 'c': mask = SP_START; break;
9508 case 'e': mask = SP_END; break;
9509 case 'm': mask = SP_RETCOUNT; break;
9510 case 'n': mask = SP_NOMOVE; break;
9511 case 'p': mask = SP_SUBPAT; break;
9512 case 'r': mask = SP_REPEAT; break;
9513 case 's': mask = SP_SETPCMARK; break;
9514 case 'z': mask = SP_COLUMN; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009515 }
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009516 if (mask == 0)
9517 {
9518 semsg(_(e_invalid_argument_str), flags);
9519 dir = 0;
9520 }
9521 else
9522 *flagsp |= mask;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009523 }
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +00009524 if (dir == 0)
9525 break;
9526 ++flags;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009527 }
9528 return dir;
9529}
9530
9531/*
9532 * Shared by search() and searchpos() functions.
9533 */
9534 static int
9535search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
9536{
9537 int flags;
9538 char_u *pat;
9539 pos_T pos;
9540 pos_T save_cursor;
9541 int save_p_ws = p_ws;
9542 int dir;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009543 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009544 long lnum_stop = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009545#ifdef FEAT_RELTIME
9546 long time_limit = 0;
9547#endif
9548 int options = SEARCH_KEEP;
9549 int subpatnum;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009550 searchit_arg_T sia;
Bram Moolenaara9c01042020-06-07 14:50:50 +02009551 int use_skip = FALSE;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009552 pos_T firstpos;
9553
Yegappan Lakshmanan0ad871d2021-07-23 20:37:56 +02009554 if (in_vim9script()
9555 && (check_for_string_arg(argvars, 0) == FAIL
9556 || check_for_opt_string_arg(argvars, 1) == FAIL
9557 || (argvars[1].v_type != VAR_UNKNOWN
9558 && (check_for_opt_number_arg(argvars, 2) == FAIL
9559 || (argvars[2].v_type != VAR_UNKNOWN
9560 && check_for_opt_number_arg(argvars, 3) == FAIL)))))
9561 goto theend;
9562
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009563 pat = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009564 dir = get_search_arg(&argvars[1], flagsp); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009565 if (dir == 0)
9566 goto theend;
9567 flags = *flagsp;
9568 if (flags & SP_START)
9569 options |= SEARCH_START;
9570 if (flags & SP_END)
9571 options |= SEARCH_END;
9572 if (flags & SP_COLUMN)
9573 options |= SEARCH_COL;
9574
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009575 // Optional arguments: line number to stop searching, timeout and skip.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009576 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
9577 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009578 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009579 if (lnum_stop < 0)
9580 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009581 if (argvars[3].v_type != VAR_UNKNOWN)
9582 {
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009583#ifdef FEAT_RELTIME
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009584 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009585 if (time_limit < 0)
9586 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009587#endif
Bram Moolenaara9c01042020-06-07 14:50:50 +02009588 use_skip = eval_expr_valid_arg(&argvars[4]);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009589 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009590 }
9591
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009592 /*
9593 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
9594 * Check to make sure only those flags are set.
9595 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
9596 * flags cannot be set. Check for that condition also.
9597 */
9598 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
9599 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
9600 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009601 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009602 goto theend;
9603 }
9604
9605 pos = save_cursor = curwin->w_cursor;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009606 CLEAR_FIELD(firstpos);
Bram Moolenaara80faa82020-04-12 19:37:17 +02009607 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009608 sia.sa_stop_lnum = (linenr_T)lnum_stop;
9609#ifdef FEAT_RELTIME
Paul Ollis65745772022-06-05 16:55:54 +01009610 sia.sa_tm = time_limit;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009611#endif
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009612
9613 // Repeat until {skip} returns FALSE.
9614 for (;;)
9615 {
9616 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02009617 options, RE_SEARCH, &sia);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009618 // finding the first match again means there is no match where {skip}
9619 // evaluates to zero.
9620 if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))
9621 subpatnum = FAIL;
9622
Bram Moolenaara9c01042020-06-07 14:50:50 +02009623 if (subpatnum == FAIL || !use_skip)
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009624 // didn't find it or no skip argument
9625 break;
Bram Moolenaar3d79f0a2023-01-22 20:14:26 +00009626 if (firstpos.lnum == 0)
9627 firstpos = pos;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009628
Bram Moolenaara9c01042020-06-07 14:50:50 +02009629 // If the skip expression matches, ignore this match.
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009630 {
9631 int do_skip;
9632 int err;
9633 pos_T save_pos = curwin->w_cursor;
9634
9635 curwin->w_cursor = pos;
Bram Moolenaara9c01042020-06-07 14:50:50 +02009636 err = FALSE;
9637 do_skip = eval_expr_to_bool(&argvars[4], &err);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009638 curwin->w_cursor = save_pos;
9639 if (err)
9640 {
9641 // Evaluating {skip} caused an error, break here.
9642 subpatnum = FAIL;
9643 break;
9644 }
9645 if (!do_skip)
9646 break;
9647 }
zeertzjq180246c2022-06-23 12:04:46 +01009648
9649 // clear the start flag to avoid getting stuck here
9650 options &= ~SEARCH_START;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02009651 }
9652
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009653 if (subpatnum != FAIL)
9654 {
9655 if (flags & SP_SUBPAT)
9656 retval = subpatnum;
9657 else
9658 retval = pos.lnum;
9659 if (flags & SP_SETPCMARK)
9660 setpcmark();
9661 curwin->w_cursor = pos;
9662 if (match_pos != NULL)
9663 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009664 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009665 match_pos->lnum = pos.lnum;
9666 match_pos->col = pos.col + 1;
9667 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009668 // "/$" will put the cursor after the end of the line, may need to
9669 // correct that here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009670 check_cursor();
9671 }
9672
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009673 // If 'n' flag is used: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009674 if (flags & SP_NOMOVE)
9675 curwin->w_cursor = save_cursor;
9676 else
9677 curwin->w_set_curswant = TRUE;
9678theend:
9679 p_ws = save_p_ws;
9680
9681 return retval;
9682}
9683
Bram Moolenaare99be0e2019-03-26 22:51:09 +01009684#ifdef FEAT_RUBY
9685/*
9686 * "rubyeval()" function
9687 */
9688 static void
9689f_rubyeval(typval_T *argvars, typval_T *rettv)
9690{
9691 char_u *str;
9692 char_u buf[NUMBUFLEN];
9693
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009694 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
9695 return;
9696
Bram Moolenaare99be0e2019-03-26 22:51:09 +01009697 str = tv_get_string_buf(&argvars[0], buf);
9698 do_rubyeval(str, rettv);
9699}
9700#endif
9701
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009702/*
9703 * "screenattr()" function
9704 */
9705 static void
9706f_screenattr(typval_T *argvars, typval_T *rettv)
9707{
9708 int row;
9709 int col;
9710 int c;
9711
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009712 if (in_vim9script()
9713 && (check_for_number_arg(argvars, 0) == FAIL
9714 || check_for_number_arg(argvars, 1) == FAIL))
9715 return;
9716
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009717 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
9718 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009719 if (row < 0 || row >= screen_Rows
9720 || col < 0 || col >= screen_Columns)
9721 c = -1;
9722 else
9723 c = ScreenAttrs[LineOffset[row] + col];
9724 rettv->vval.v_number = c;
9725}
9726
9727/*
9728 * "screenchar()" function
9729 */
9730 static void
9731f_screenchar(typval_T *argvars, typval_T *rettv)
9732{
9733 int row;
9734 int col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009735 int c;
9736
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009737 if (in_vim9script()
9738 && (check_for_number_arg(argvars, 0) == FAIL
9739 || check_for_number_arg(argvars, 1) == FAIL))
9740 return;
9741
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009742 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
9743 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009744 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009745 c = -1;
9746 else
9747 {
zeertzjq47eec672023-06-01 20:26:55 +01009748 char_u buf[MB_MAXBYTES + 1];
9749 screen_getbytes(row, col, buf, NULL);
9750 c = (*mb_ptr2char)(buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009751 }
9752 rettv->vval.v_number = c;
9753}
9754
9755/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009756 * "screenchars()" function
9757 */
9758 static void
9759f_screenchars(typval_T *argvars, typval_T *rettv)
9760{
9761 int row;
9762 int col;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009763 int c;
9764 int i;
9765
9766 if (rettv_list_alloc(rettv) == FAIL)
9767 return;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009768
9769 if (in_vim9script()
9770 && (check_for_number_arg(argvars, 0) == FAIL
9771 || check_for_number_arg(argvars, 1) == FAIL))
9772 return;
9773
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009774 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
9775 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
9776 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
9777 return;
9778
zeertzjq47eec672023-06-01 20:26:55 +01009779 char_u buf[MB_MAXBYTES + 1];
9780 screen_getbytes(row, col, buf, NULL);
9781 int pcc[MAX_MCO];
9782 if (enc_utf8)
9783 c = utfc_ptr2char(buf, pcc);
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009784 else
zeertzjq47eec672023-06-01 20:26:55 +01009785 c = (*mb_ptr2char)(buf);
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009786 list_append_number(rettv->vval.v_list, (varnumber_T)c);
9787
9788 if (enc_utf8)
zeertzjq47eec672023-06-01 20:26:55 +01009789 for (i = 0; i < Screen_mco && pcc[i] != 0; ++i)
9790 list_append_number(rettv->vval.v_list, (varnumber_T)pcc[i]);
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009791}
9792
9793/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009794 * "screencol()" function
9795 *
9796 * First column is 1 to be consistent with virtcol().
9797 */
9798 static void
9799f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
9800{
9801 rettv->vval.v_number = screen_screencol() + 1;
9802}
9803
9804/*
9805 * "screenrow()" function
9806 */
9807 static void
9808f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
9809{
9810 rettv->vval.v_number = screen_screenrow() + 1;
9811}
9812
9813/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009814 * "screenstring()" function
9815 */
9816 static void
9817f_screenstring(typval_T *argvars, typval_T *rettv)
9818{
9819 int row;
9820 int col;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009821 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009822
9823 rettv->vval.v_string = NULL;
9824 rettv->v_type = VAR_STRING;
9825
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02009826 if (in_vim9script()
9827 && (check_for_number_arg(argvars, 0) == FAIL
9828 || check_for_number_arg(argvars, 1) == FAIL))
9829 return;
9830
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009831 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
9832 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
9833 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
9834 return;
9835
zeertzjq47eec672023-06-01 20:26:55 +01009836 screen_getbytes(row, col, buf, NULL);
Bram Moolenaar2912abb2019-03-29 14:16:42 +01009837 rettv->vval.v_string = vim_strsave(buf);
9838}
9839
9840/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009841 * "search()" function
9842 */
9843 static void
9844f_search(typval_T *argvars, typval_T *rettv)
9845{
9846 int flags = 0;
9847
9848 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
9849}
9850
9851/*
9852 * "searchdecl()" function
9853 */
9854 static void
9855f_searchdecl(typval_T *argvars, typval_T *rettv)
9856{
Bram Moolenaar30788d32020-09-05 21:35:16 +02009857 int locally = TRUE;
9858 int thisblock = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009859 int error = FALSE;
9860 char_u *name;
9861
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009862 rettv->vval.v_number = 1; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009863
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02009864 if (in_vim9script()
9865 && (check_for_string_arg(argvars, 0) == FAIL
9866 || check_for_opt_bool_arg(argvars, 1) == FAIL
9867 || (argvars[1].v_type != VAR_UNKNOWN
9868 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
9869 return;
9870
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009871 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009872 if (argvars[1].v_type != VAR_UNKNOWN)
9873 {
Bram Moolenaar30788d32020-09-05 21:35:16 +02009874 locally = !(int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009875 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar30788d32020-09-05 21:35:16 +02009876 thisblock = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009877 }
9878 if (!error && name != NULL)
9879 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
9880 locally, thisblock, SEARCH_KEEP) == FAIL;
9881}
9882
9883/*
9884 * Used by searchpair() and searchpairpos()
9885 */
9886 static int
9887searchpair_cmn(typval_T *argvars, pos_T *match_pos)
9888{
9889 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +01009890 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009891 int save_p_ws = p_ws;
9892 int dir;
9893 int flags = 0;
9894 char_u nbuf1[NUMBUFLEN];
9895 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009896 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009897 long lnum_stop = 0;
9898 long time_limit = 0;
9899
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +02009900 if (in_vim9script()
9901 && (check_for_string_arg(argvars, 0) == FAIL
9902 || check_for_string_arg(argvars, 1) == FAIL
9903 || check_for_string_arg(argvars, 2) == FAIL
9904 || check_for_opt_string_arg(argvars, 3) == FAIL
9905 || (argvars[3].v_type != VAR_UNKNOWN
9906 && argvars[4].v_type != VAR_UNKNOWN
9907 && (check_for_opt_number_arg(argvars, 5) == FAIL
9908 || (argvars[5].v_type != VAR_UNKNOWN
9909 && check_for_opt_number_arg(argvars, 6) == FAIL)))))
9910 goto theend;
9911
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009912 // Get the three pattern arguments: start, middle, end. Will result in an
9913 // error if not a valid argument.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009914 spat = tv_get_string_chk(&argvars[0]);
9915 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
9916 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009917 if (spat == NULL || mpat == NULL || epat == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009918 goto theend; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009919
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009920 // Handle the optional fourth argument: flags
9921 dir = get_search_arg(&argvars[3], &flags); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009922 if (dir == 0)
9923 goto theend;
9924
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009925 // Don't accept SP_END or SP_SUBPAT.
9926 // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009927 if ((flags & (SP_END | SP_SUBPAT)) != 0
9928 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
9929 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009930 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009931 goto theend;
9932 }
9933
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009934 // Using 'r' implies 'W', otherwise it doesn't work.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009935 if (flags & SP_REPEAT)
9936 p_ws = FALSE;
9937
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009938 // Optional fifth argument: skip expression
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009939 if (argvars[3].v_type == VAR_UNKNOWN
9940 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +01009941 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009942 else
9943 {
Bram Moolenaara9c01042020-06-07 14:50:50 +02009944 // Type is checked later.
Bram Moolenaar48570482017-10-30 21:48:41 +01009945 skip = &argvars[4];
Bram Moolenaara9c01042020-06-07 14:50:50 +02009946
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009947 if (argvars[5].v_type != VAR_UNKNOWN)
9948 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009949 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009950 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009951 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009952 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009953 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009954 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009955#ifdef FEAT_RELTIME
9956 if (argvars[6].v_type != VAR_UNKNOWN)
9957 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009958 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009959 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009960 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00009961 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009962 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02009963 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009964 }
9965#endif
9966 }
9967 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009968
9969 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
9970 match_pos, lnum_stop, time_limit);
9971
9972theend:
9973 p_ws = save_p_ws;
9974
9975 return retval;
9976}
9977
9978/*
9979 * "searchpair()" function
9980 */
9981 static void
9982f_searchpair(typval_T *argvars, typval_T *rettv)
9983{
9984 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
9985}
9986
9987/*
9988 * "searchpairpos()" function
9989 */
9990 static void
9991f_searchpairpos(typval_T *argvars, typval_T *rettv)
9992{
9993 pos_T match_pos;
9994 int lnum = 0;
9995 int col = 0;
9996
9997 if (rettv_list_alloc(rettv) == FAIL)
9998 return;
9999
10000 if (searchpair_cmn(argvars, &match_pos) > 0)
10001 {
10002 lnum = match_pos.lnum;
10003 col = match_pos.col;
10004 }
10005
10006 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
10007 list_append_number(rettv->vval.v_list, (varnumber_T)col);
10008}
10009
10010/*
10011 * Search for a start/middle/end thing.
10012 * Used by searchpair(), see its documentation for the details.
10013 * Returns 0 or -1 for no match,
10014 */
10015 long
10016do_searchpair(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010017 char_u *spat, // start pattern
10018 char_u *mpat, // middle pattern
10019 char_u *epat, // end pattern
10020 int dir, // BACKWARD or FORWARD
10021 typval_T *skip, // skip expression
10022 int flags, // SP_SETPCMARK and other SP_ values
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010023 pos_T *match_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010024 linenr_T lnum_stop, // stop at this line if not zero
10025 long time_limit UNUSED) // stop after this many msec
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010026{
10027 char_u *save_cpo;
10028 char_u *pat, *pat2 = NULL, *pat3 = NULL;
10029 long retval = 0;
10030 pos_T pos;
10031 pos_T firstpos;
10032 pos_T foundpos;
10033 pos_T save_cursor;
10034 pos_T save_pos;
10035 int n;
10036 int r;
10037 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +010010038 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010039 int err;
10040 int options = SEARCH_KEEP;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010041
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010042 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010043 save_cpo = p_cpo;
10044 p_cpo = empty_option;
10045
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010046 // Make two search patterns: start/end (pat2, for in nested pairs) and
10047 // start/middle/end (pat3, for the top pair).
Bram Moolenaar964b3742019-05-24 18:54:09 +020010048 pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17);
10049 pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010050 if (pat2 == NULL || pat3 == NULL)
10051 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +010010052 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010053 if (*mpat == NUL)
10054 STRCPY(pat3, pat2);
10055 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +010010056 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010057 spat, epat, mpat);
10058 if (flags & SP_START)
10059 options |= SEARCH_START;
10060
Bram Moolenaar48570482017-10-30 21:48:41 +010010061 if (skip != NULL)
Bram Moolenaara9c01042020-06-07 14:50:50 +020010062 use_skip = eval_expr_valid_arg(skip);
Bram Moolenaar48570482017-10-30 21:48:41 +010010063
Bram Moolenaar5ea38d12022-06-16 21:20:48 +010010064#ifdef FEAT_RELTIME
10065 if (time_limit > 0)
10066 init_regexp_timeout(time_limit);
10067#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010068 save_cursor = curwin->w_cursor;
10069 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010070 CLEAR_POS(&firstpos);
10071 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010072 pat = pat3;
10073 for (;;)
10074 {
Bram Moolenaar92ea26b2019-10-18 20:53:34 +020010075 searchit_arg_T sia;
10076
Bram Moolenaara80faa82020-04-12 19:37:17 +020010077 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +020010078 sia.sa_stop_lnum = lnum_stop;
Bram Moolenaar5d24a222018-12-23 19:10:09 +010010079 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +020010080 options, RE_SEARCH, &sia);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010081 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010082 // didn't find it or found the first match again: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010083 break;
10084
10085 if (firstpos.lnum == 0)
10086 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010087 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010088 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010089 // Found the same position again. Can happen with a pattern that
10090 // has "\zs" at the end and searching backwards. Advance one
10091 // character and try again.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010092 if (dir == BACKWARD)
10093 decl(&pos);
10094 else
10095 incl(&pos);
10096 }
10097 foundpos = pos;
10098
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010099 // clear the start flag to avoid getting stuck here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010100 options &= ~SEARCH_START;
10101
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010102 // If the skip pattern matches, ignore this match.
Bram Moolenaar48570482017-10-30 21:48:41 +010010103 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010104 {
10105 save_pos = curwin->w_cursor;
10106 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +010010107 err = FALSE;
10108 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010109 curwin->w_cursor = save_pos;
10110 if (err)
10111 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010112 // Evaluating {skip} caused an error, break here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010113 curwin->w_cursor = save_cursor;
10114 retval = -1;
10115 break;
10116 }
10117 if (r)
10118 continue;
10119 }
10120
10121 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
10122 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010123 // Found end when searching backwards or start when searching
10124 // forward: nested pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010125 ++nest;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010126 pat = pat2; // nested, don't search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010127 }
10128 else
10129 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010130 // Found end when searching forward or start when searching
10131 // backward: end of (nested) pair; or found middle in outer pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010132 if (--nest == 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010133 pat = pat3; // outer level, search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010134 }
10135
10136 if (nest == 0)
10137 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010138 // Found the match: return matchcount or line number.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010139 if (flags & SP_RETCOUNT)
10140 ++retval;
10141 else
10142 retval = pos.lnum;
10143 if (flags & SP_SETPCMARK)
10144 setpcmark();
10145 curwin->w_cursor = pos;
10146 if (!(flags & SP_REPEAT))
10147 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010148 nest = 1; // search for next unmatched
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010149 }
10150 }
10151
10152 if (match_pos != NULL)
10153 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010154 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010155 match_pos->lnum = curwin->w_cursor.lnum;
10156 match_pos->col = curwin->w_cursor.col + 1;
10157 }
10158
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010159 // If 'n' flag is used or search failed: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010160 if ((flags & SP_NOMOVE) || retval == 0)
10161 curwin->w_cursor = save_cursor;
10162
10163theend:
Bram Moolenaar5ea38d12022-06-16 21:20:48 +010010164#ifdef FEAT_RELTIME
Bram Moolenaar0f618382022-08-26 21:33:04 +010010165 if (time_limit > 0)
10166 disable_regexp_timeout();
Bram Moolenaar5ea38d12022-06-16 21:20:48 +010010167#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010168 vim_free(pat2);
10169 vim_free(pat3);
10170 if (p_cpo == empty_option)
10171 p_cpo = save_cpo;
10172 else
Bram Moolenaare5a2dc82021-01-03 19:52:05 +010010173 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010174 // Darn, evaluating the {skip} expression changed the value.
Bram Moolenaare5a2dc82021-01-03 19:52:05 +010010175 // If it's still empty it was changed and restored, need to restore in
10176 // the complicated way.
10177 if (*p_cpo == NUL)
Bram Moolenaar31e5c602022-04-15 13:53:33 +010010178 set_option_value_give_err((char_u *)"cpo", 0L, save_cpo, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010179 free_string_option(save_cpo);
Bram Moolenaare5a2dc82021-01-03 19:52:05 +010010180 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010181
10182 return retval;
10183}
10184
10185/*
10186 * "searchpos()" function
10187 */
10188 static void
10189f_searchpos(typval_T *argvars, typval_T *rettv)
10190{
10191 pos_T match_pos;
10192 int lnum = 0;
10193 int col = 0;
10194 int n;
10195 int flags = 0;
10196
10197 if (rettv_list_alloc(rettv) == FAIL)
10198 return;
10199
10200 n = search_cmn(argvars, &match_pos, &flags);
10201 if (n > 0)
10202 {
10203 lnum = match_pos.lnum;
10204 col = match_pos.col;
10205 }
10206
10207 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
10208 list_append_number(rettv->vval.v_list, (varnumber_T)col);
10209 if (flags & SP_SUBPAT)
10210 list_append_number(rettv->vval.v_list, (varnumber_T)n);
10211}
10212
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010213/*
10214 * Set the cursor or mark position.
zeertzjq47eec672023-06-01 20:26:55 +010010215 * If "charpos" is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010216 * Otherwise use the column number as a byte offset.
10217 */
10218 static void
10219set_position(typval_T *argvars, typval_T *rettv, int charpos)
10220{
10221 pos_T pos;
10222 int fnum;
10223 char_u *name;
10224 colnr_T curswant = -1;
10225
10226 rettv->vval.v_number = -1;
10227
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010228 if (in_vim9script()
10229 && (check_for_string_arg(argvars, 0) == FAIL
10230 || check_for_list_arg(argvars, 1) == FAIL))
10231 return;
10232
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010233 name = tv_get_string_chk(argvars);
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010234 if (name == NULL)
10235 return;
10236
10237 if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) != OK)
10238 return;
10239
10240 if (pos.col != MAXCOL && --pos.col < 0)
10241 pos.col = 0;
10242 if ((name[0] == '.' && name[1] == NUL))
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010243 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010244 // set cursor; "fnum" is ignored
10245 curwin->w_cursor = pos;
10246 if (curswant >= 0)
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010247 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010248 curwin->w_curswant = curswant - 1;
10249 curwin->w_set_curswant = FALSE;
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010250 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010251 check_cursor();
10252 rettv->vval.v_number = 0;
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010253 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010254 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
10255 {
10256 // set mark
10257 if (setmark_pos(name[1], &pos, fnum) == OK)
10258 rettv->vval.v_number = 0;
10259 }
10260 else
10261 emsg(_(e_invalid_argument));
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010262}
10263/*
10264 * "setcharpos()" function
10265 */
10266 static void
10267f_setcharpos(typval_T *argvars, typval_T *rettv)
10268{
10269 set_position(argvars, rettv, TRUE);
10270}
10271
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010272 static void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010273f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
10274{
10275 dict_T *d;
10276 dictitem_T *di;
10277 char_u *csearch;
10278
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +010010279 if (check_for_dict_arg(argvars, 0) == FAIL)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010280 return;
10281
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010282 if ((d = argvars[0].vval.v_dict) == NULL)
10283 return;
10284
10285 csearch = dict_get_string(d, "char", FALSE);
10286 if (csearch != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010287 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010288 if (enc_utf8)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010289 {
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010290 int pcc[MAX_MCO];
10291 int c = utfc_ptr2char(csearch, pcc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010292
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010293 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010294 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010295 else
10296 set_last_csearch(PTR2CHAR(csearch),
10297 csearch, mb_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010298 }
Yegappan Lakshmanandc4daa32023-01-02 16:54:53 +000010299
10300 di = dict_find(d, (char_u *)"forward", -1);
10301 if (di != NULL)
10302 set_csearch_direction((int)tv_get_number(&di->di_tv)
10303 ? FORWARD : BACKWARD);
10304
10305 di = dict_find(d, (char_u *)"until", -1);
10306 if (di != NULL)
10307 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010308}
10309
10310/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010311 * "setcursorcharpos" function
10312 */
10313 static void
Bram Moolenaar3af15ab2021-01-17 16:16:23 +010010314f_setcursorcharpos(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010315{
10316 set_cursorpos(argvars, rettv, TRUE);
10317}
10318
10319/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +020010320 * "setenv()" function
10321 */
10322 static void
10323f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
10324{
10325 char_u namebuf[NUMBUFLEN];
10326 char_u valbuf[NUMBUFLEN];
Yegappan Lakshmanana764e732021-07-25 15:57:32 +020010327 char_u *name;
Bram Moolenaar691ddee2019-05-09 14:52:41 +020010328
Yegappan Lakshmanana764e732021-07-25 15:57:32 +020010329 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
10330 return;
10331
zeertzjqfcaeb3d2023-11-28 20:46:29 +010010332 // setting an environment variable may be dangerous, e.g. you could
Christian Brabandt6b89dd62023-10-26 22:14:17 +020010333 // setenv GCONV_PATH=/tmp and then have iconv() unexpectedly call
10334 // a shell command using some shared library:
10335 if (check_restricted() || check_secure())
10336 return;
10337
Yegappan Lakshmanana764e732021-07-25 15:57:32 +020010338 name = tv_get_string_buf(&argvars[0], namebuf);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020010339 if (argvars[1].v_type == VAR_SPECIAL
10340 && argvars[1].vval.v_number == VVAL_NULL)
LemonBoy77142312022-04-15 20:50:46 +010010341 vim_unsetenv_ext(name);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020010342 else
LemonBoy77142312022-04-15 20:50:46 +010010343 vim_setenv_ext(name, tv_get_string_buf(&argvars[1], valbuf));
Bram Moolenaar691ddee2019-05-09 14:52:41 +020010344}
10345
10346/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010347 * "setfperm({fname}, {mode})" function
10348 */
10349 static void
10350f_setfperm(typval_T *argvars, typval_T *rettv)
10351{
10352 char_u *fname;
10353 char_u modebuf[NUMBUFLEN];
10354 char_u *mode_str;
10355 int i;
10356 int mask;
10357 int mode = 0;
10358
10359 rettv->vval.v_number = 0;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010360
10361 if (in_vim9script()
10362 && (check_for_string_arg(argvars, 0) == FAIL
10363 || check_for_string_arg(argvars, 1) == FAIL))
10364 return;
10365
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010366 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010367 if (fname == NULL)
10368 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010369 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010370 if (mode_str == NULL)
10371 return;
10372 if (STRLEN(mode_str) != 9)
10373 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +000010374 semsg(_(e_invalid_argument_str), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010375 return;
10376 }
10377
10378 mask = 1;
10379 for (i = 8; i >= 0; --i)
10380 {
10381 if (mode_str[i] != '-')
10382 mode |= mask;
10383 mask = mask << 1;
10384 }
10385 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
10386}
10387
10388/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010389 * "setpos()" function
10390 */
10391 static void
10392f_setpos(typval_T *argvars, typval_T *rettv)
10393{
Bram Moolenaar6f02b002021-01-10 20:22:54 +010010394 set_position(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010395}
10396
10397/*
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010398 * Translate a register type string to the yank type and block length
10399 */
10400 static int
10401get_yank_type(char_u **pp, char_u *yank_type, long *block_len)
10402{
10403 char_u *stropt = *pp;
10404 switch (*stropt)
10405 {
10406 case 'v': case 'c': // character-wise selection
10407 *yank_type = MCHAR;
10408 break;
10409 case 'V': case 'l': // line-wise selection
10410 *yank_type = MLINE;
10411 break;
10412 case 'b': case Ctrl_V: // block-wise selection
10413 *yank_type = MBLOCK;
10414 if (VIM_ISDIGIT(stropt[1]))
10415 {
10416 ++stropt;
10417 *block_len = getdigits(&stropt) - 1;
10418 --stropt;
10419 }
10420 break;
10421 default:
10422 return FAIL;
10423 }
10424 *pp = stropt;
10425 return OK;
10426}
10427
10428/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010429 * "setreg()" function
10430 */
10431 static void
10432f_setreg(typval_T *argvars, typval_T *rettv)
10433{
10434 int regname;
10435 char_u *strregname;
10436 char_u *stropt;
10437 char_u *strval;
10438 int append;
10439 char_u yank_type;
10440 long block_len;
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010441 typval_T *regcontents;
10442 int pointreg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010443
Yegappan Lakshmanana764e732021-07-25 15:57:32 +020010444 if (in_vim9script()
10445 && (check_for_string_arg(argvars, 0) == FAIL
10446 || check_for_opt_string_arg(argvars, 2) == FAIL))
10447 return;
10448
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010449 pointreg = 0;
10450 regcontents = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010451 block_len = -1;
10452 yank_type = MAUTO;
10453 append = FALSE;
10454
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010455 strregname = tv_get_string_chk(argvars);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010456 rettv->vval.v_number = 1; // FAIL is default
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010457
10458 if (strregname == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010459 return; // type error; errmsg already given
Bram Moolenaar418a29f2021-02-10 22:23:41 +010010460 if (in_vim9script() && STRLEN(strregname) > 1)
10461 {
10462 semsg(_(e_register_name_must_be_one_char_str), strregname);
10463 return;
10464 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010465 regname = *strregname;
10466 if (regname == 0 || regname == '@')
10467 regname = '"';
10468
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010469 if (argvars[1].v_type == VAR_DICT)
10470 {
10471 dict_T *d = argvars[1].vval.v_dict;
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010472 dictitem_T *di;
10473
10474 if (d == NULL || d->dv_hashtab.ht_used == 0)
10475 {
10476 // Empty dict, clear the register (like setreg(0, []))
10477 char_u *lstval[2] = {NULL, NULL};
10478 write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1);
10479 return;
10480 }
10481
10482 di = dict_find(d, (char_u *)"regcontents", -1);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010483 if (di != NULL)
10484 regcontents = &di->di_tv;
10485
Bram Moolenaard61efa52022-07-23 09:52:04 +010010486 stropt = dict_get_string(d, "regtype", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010487 if (stropt != NULL)
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010488 {
10489 int ret = get_yank_type(&stropt, &yank_type, &block_len);
10490
10491 if (ret == FAIL || *++stropt != NUL)
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010492 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +000010493 semsg(_(e_invalid_value_for_argument_str), "value");
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010494 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010495 }
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010496 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010497
10498 if (regname == '"')
10499 {
Bram Moolenaard61efa52022-07-23 09:52:04 +010010500 stropt = dict_get_string(d, "points_to", FALSE);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010501 if (stropt != NULL)
10502 {
10503 pointreg = *stropt;
10504 regname = pointreg;
10505 }
10506 }
Bram Moolenaard61efa52022-07-23 09:52:04 +010010507 else if (dict_get_bool(d, "isunnamed", -1) > 0)
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010508 pointreg = regname;
10509 }
10510 else
10511 regcontents = &argvars[1];
10512
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010513 if (argvars[2].v_type != VAR_UNKNOWN)
10514 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010515 if (yank_type != MAUTO)
10516 {
Bram Moolenaare1242042021-12-16 20:56:57 +000010517 semsg(_(e_too_many_arguments_for_function_str), "setreg");
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010518 return;
10519 }
10520
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010521 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010522 if (stropt == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010523 return; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010524 for (; *stropt != NUL; ++stropt)
10525 switch (*stropt)
10526 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010527 case 'a': case 'A': // append
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010528 append = TRUE;
10529 break;
Bram Moolenaar7633fe52020-06-22 19:10:56 +020010530 default:
10531 get_yank_type(&stropt, &yank_type, &block_len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010532 }
10533 }
10534
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010535 if (regcontents && regcontents->v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010536 {
10537 char_u **lstval;
10538 char_u **allocval;
10539 char_u buf[NUMBUFLEN];
10540 char_u **curval;
10541 char_u **curallocval;
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010542 list_T *ll = regcontents->vval.v_list;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010543 listitem_T *li;
10544 int len;
10545
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010546 // If the list is NULL handle like an empty list.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010547 len = ll == NULL ? 0 : ll->lv_len;
10548
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010549 // First half: use for pointers to result lines; second half: use for
10550 // pointers to allocated copies.
Bram Moolenaarc799fe22019-05-28 23:08:19 +020010551 lstval = ALLOC_MULT(char_u *, (len + 1) * 2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010552 if (lstval == NULL)
10553 return;
10554 curval = lstval;
10555 allocval = lstval + len + 2;
10556 curallocval = allocval;
10557
Bram Moolenaar50985eb2020-01-27 22:09:39 +010010558 if (ll != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010559 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +020010560 CHECK_LIST_MATERIALIZE(ll);
Bram Moolenaar00d253e2020-04-06 22:13:01 +020010561 FOR_ALL_LIST_ITEMS(ll, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010562 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +010010563 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010564 if (strval == NULL)
10565 goto free_lstval;
Bram Moolenaar50985eb2020-01-27 22:09:39 +010010566 if (strval == buf)
10567 {
10568 // Need to make a copy, next tv_get_string_buf_chk() will
10569 // overwrite the string.
10570 strval = vim_strsave(buf);
10571 if (strval == NULL)
10572 goto free_lstval;
10573 *curallocval++ = strval;
10574 }
10575 *curval++ = strval;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010576 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010577 }
10578 *curval++ = NULL;
10579
10580 write_reg_contents_lst(regname, lstval, -1,
10581 append, yank_type, block_len);
10582free_lstval:
10583 while (curallocval > allocval)
10584 vim_free(*--curallocval);
10585 vim_free(lstval);
10586 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010587 else if (regcontents)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010588 {
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010589 strval = tv_get_string_chk(regcontents);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010590 if (strval == NULL)
10591 return;
10592 write_reg_contents_ex(regname, strval, -1,
10593 append, yank_type, block_len);
10594 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +020010595 if (pointreg != 0)
10596 get_yank_register(pointreg, TRUE);
10597
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010598 rettv->vval.v_number = 0;
10599}
10600
10601/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010602 * "settagstack()" function
10603 */
10604 static void
10605f_settagstack(typval_T *argvars, typval_T *rettv)
10606{
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010607 win_T *wp;
10608 dict_T *d;
10609 int action = 'r';
10610
10611 rettv->vval.v_number = -1;
10612
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010613 if (in_vim9script()
10614 && (check_for_number_arg(argvars, 0) == FAIL
10615 || check_for_dict_arg(argvars, 1) == FAIL
10616 || check_for_opt_string_arg(argvars, 2) == FAIL))
10617 return;
10618
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010619 // first argument: window number or id
10620 wp = find_win_by_nr_or_id(&argvars[0]);
10621 if (wp == NULL)
10622 return;
10623
10624 // second argument: dict with items to set in the tag stack
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +010010625 if (check_for_dict_arg(argvars, 1) == FAIL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010626 return;
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010627 d = argvars[1].vval.v_dict;
10628 if (d == NULL)
10629 return;
10630
10631 // third argument: action - 'a' for append and 'r' for replace.
10632 // default is to replace the stack.
10633 if (argvars[2].v_type == VAR_UNKNOWN)
10634 action = 'r';
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +010010635 else if (check_for_string_arg(argvars, 2) == FAIL)
10636 return;
10637 else
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010638 {
10639 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010640 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010641 if (actstr == NULL)
10642 return;
Bram Moolenaar271fa082020-01-02 14:02:16 +010010643 if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't')
10644 && actstr[1] == NUL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010645 action = *actstr;
10646 else
10647 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +000010648 semsg(_(e_invalid_action_str_2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010649 return;
10650 }
10651 }
Bram Moolenaarf49cc602018-11-11 15:21:05 +010010652
10653 if (set_tagstack(wp, d, action) == OK)
10654 rettv->vval.v_number = 0;
10655}
10656
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010657#ifdef FEAT_CRYPT
10658/*
10659 * "sha256({string})" function
10660 */
10661 static void
10662f_sha256(typval_T *argvars, typval_T *rettv)
10663{
10664 char_u *p;
10665
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010666 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
10667 return;
10668
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010669 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010670 rettv->vval.v_string = vim_strsave(
10671 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
10672 rettv->v_type = VAR_STRING;
10673}
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010674#endif // FEAT_CRYPT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010675
10676/*
10677 * "shellescape({string})" function
10678 */
10679 static void
10680f_shellescape(typval_T *argvars, typval_T *rettv)
10681{
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010682 int do_special;
Bram Moolenaar20615522017-06-05 18:46:26 +020010683
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010684 if (in_vim9script()
10685 && (check_for_string_arg(argvars, 0) == FAIL
10686 || check_for_opt_bool_arg(argvars, 1) == FAIL))
10687 return;
10688
10689 do_special = non_zero_arg(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010690 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010691 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010692 rettv->v_type = VAR_STRING;
10693}
10694
10695/*
10696 * shiftwidth() function
10697 */
10698 static void
10699f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
10700{
Bram Moolenaarf9514162018-11-22 03:08:29 +010010701 rettv->vval.v_number = 0;
10702
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010703 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
10704 return;
10705
Bram Moolenaarf9514162018-11-22 03:08:29 +010010706 if (argvars[0].v_type != VAR_UNKNOWN)
10707 {
10708 long col;
10709
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010710 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +010010711 if (col < 0)
10712 return; // type error; errmsg already given
10713#ifdef FEAT_VARTABS
10714 rettv->vval.v_number = get_sw_value_col(curbuf, col);
10715 return;
10716#endif
10717 }
10718
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010719 rettv->vval.v_number = get_sw_value(curbuf);
10720}
10721
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010722/*
10723 * "soundfold({word})" function
10724 */
10725 static void
10726f_soundfold(typval_T *argvars, typval_T *rettv)
10727{
10728 char_u *s;
10729
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010730 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
10731 return;
10732
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010733 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010734 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010735#ifdef FEAT_SPELL
10736 rettv->vval.v_string = eval_soundfold(s);
10737#else
10738 rettv->vval.v_string = vim_strsave(s);
10739#endif
10740}
10741
10742/*
10743 * "spellbadword()" function
10744 */
10745 static void
10746f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
10747{
10748 char_u *word = (char_u *)"";
10749 hlf_T attr = HLF_COUNT;
10750 int len = 0;
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010751#ifdef FEAT_SPELL
10752 int wo_spell_save = curwin->w_p_spell;
10753
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020010754 if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
10755 return;
10756
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010757 if (!curwin->w_p_spell)
10758 {
Yegappan Lakshmananaf936912023-02-20 12:16:39 +000010759 parse_spelllang(curwin);
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010760 curwin->w_p_spell = TRUE;
10761 }
10762
10763 if (*curwin->w_s->b_p_spl == NUL)
10764 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +000010765 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010766 curwin->w_p_spell = wo_spell_save;
10767 return;
10768 }
10769#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010770
10771 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010772 {
10773#ifdef FEAT_SPELL
10774 curwin->w_p_spell = wo_spell_save;
10775#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010776 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010777 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010778
10779#ifdef FEAT_SPELL
10780 if (argvars[0].v_type == VAR_UNKNOWN)
10781 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010782 // Find the start and length of the badly spelled word.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010783 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
10784 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +010010785 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010786 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +010010787 curwin->w_set_curswant = TRUE;
10788 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010789 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010790 else if (*curbuf->b_s.b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010791 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010792 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010793 int capcol = -1;
10794
10795 if (str != NULL)
10796 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010797 // Check the argument for spelling.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010798 while (*str != NUL)
10799 {
10800 len = spell_check(curwin, str, &attr, &capcol, FALSE);
10801 if (attr != HLF_COUNT)
10802 {
10803 word = str;
10804 break;
10805 }
10806 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +020010807 capcol -= len;
Bram Moolenaar0c779e82019-08-09 17:01:02 +020010808 len = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010809 }
10810 }
10811 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010812 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010813#endif
10814
10815 list_append_string(rettv->vval.v_list, word, len);
10816 list_append_string(rettv->vval.v_list, (char_u *)(
10817 attr == HLF_SPB ? "bad" :
10818 attr == HLF_SPR ? "rare" :
10819 attr == HLF_SPL ? "local" :
10820 attr == HLF_SPC ? "caps" :
10821 ""), -1);
10822}
10823
10824/*
10825 * "spellsuggest()" function
10826 */
10827 static void
10828f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
10829{
10830#ifdef FEAT_SPELL
10831 char_u *str;
10832 int typeerr = FALSE;
10833 int maxcount;
10834 garray_T ga;
10835 int i;
10836 listitem_T *li;
10837 int need_capital = FALSE;
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010838 int wo_spell_save = curwin->w_p_spell;
10839
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010840 if (in_vim9script()
10841 && (check_for_string_arg(argvars, 0) == FAIL
10842 || check_for_opt_number_arg(argvars, 1) == FAIL
10843 || (argvars[1].v_type != VAR_UNKNOWN
10844 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
10845 return;
10846
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010847 if (!curwin->w_p_spell)
10848 {
Yegappan Lakshmananaf936912023-02-20 12:16:39 +000010849 parse_spelllang(curwin);
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010850 curwin->w_p_spell = TRUE;
10851 }
10852
10853 if (*curwin->w_s->b_p_spl == NUL)
10854 {
Bram Moolenaar460ae5d2022-01-01 14:19:49 +000010855 emsg(_(e_spell_checking_is_not_possible));
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010856 curwin->w_p_spell = wo_spell_save;
10857 return;
10858 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010859#endif
10860
10861 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010862 {
10863#ifdef FEAT_SPELL
10864 curwin->w_p_spell = wo_spell_save;
10865#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010866 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010867 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010868
10869#ifdef FEAT_SPELL
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010870 str = tv_get_string(&argvars[0]);
10871 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010872 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010873 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
10874 if (maxcount <= 0)
10875 return;
10876 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010877 {
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010878 need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr);
10879 if (typeerr)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010880 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010881 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010882 }
=?UTF-8?q?Dundar=20G=C3=B6c?=dd410372022-05-15 13:59:11 +010010883 else
10884 maxcount = 25;
10885
10886 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
10887
10888 for (i = 0; i < ga.ga_len; ++i)
10889 {
10890 str = ((char_u **)ga.ga_data)[i];
10891
10892 li = listitem_alloc();
10893 if (li == NULL)
10894 vim_free(str);
10895 else
10896 {
10897 li->li_tv.v_type = VAR_STRING;
10898 li->li_tv.v_lock = 0;
10899 li->li_tv.vval.v_string = str;
10900 list_append(rettv->vval.v_list, li);
10901 }
10902 }
10903 ga_clear(&ga);
Bram Moolenaar152e79e2020-06-10 15:32:08 +020010904 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010905#endif
10906}
10907
10908 static void
10909f_split(typval_T *argvars, typval_T *rettv)
10910{
10911 char_u *str;
10912 char_u *end;
10913 char_u *pat = NULL;
10914 regmatch_T regmatch;
10915 char_u patbuf[NUMBUFLEN];
10916 char_u *save_cpo;
10917 int match;
10918 colnr_T col = 0;
10919 int keepempty = FALSE;
10920 int typeerr = FALSE;
10921
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010922 if (in_vim9script()
10923 && (check_for_string_arg(argvars, 0) == FAIL
10924 || check_for_opt_string_arg(argvars, 1) == FAIL
10925 || (argvars[1].v_type != VAR_UNKNOWN
10926 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
10927 return;
10928
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010929 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010930 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +010010931 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010932
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010933 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010934 if (argvars[1].v_type != VAR_UNKNOWN)
10935 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010936 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010937 if (pat == NULL)
10938 typeerr = TRUE;
10939 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar3986b942020-09-06 16:09:04 +020010940 keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010941 }
10942 if (pat == NULL || *pat == NUL)
10943 pat = (char_u *)"[\\x01- ]\\+";
10944
10945 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010946 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010947 if (typeerr)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010948 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010949
10950 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
10951 if (regmatch.regprog != NULL)
10952 {
10953 regmatch.rm_ic = FALSE;
10954 while (*str != NUL || keepempty)
10955 {
10956 if (*str == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010010957 match = FALSE; // empty item at the end
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010958 else
10959 match = vim_regexec_nl(&regmatch, str, col);
10960 if (match)
10961 end = regmatch.startp[0];
10962 else
10963 end = str + STRLEN(str);
10964 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
10965 && *str != NUL && match && end < regmatch.endp[0]))
10966 {
10967 if (list_append_string(rettv->vval.v_list, str,
10968 (int)(end - str)) == FAIL)
10969 break;
10970 }
10971 if (!match)
10972 break;
Bram Moolenaar13505972019-01-24 15:04:48 +010010973 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010974 if (regmatch.endp[0] > str)
10975 col = 0;
10976 else
Bram Moolenaar13505972019-01-24 15:04:48 +010010977 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010978 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010979 str = regmatch.endp[0];
10980 }
10981
10982 vim_regfree(regmatch.regprog);
10983 }
10984
Bram Moolenaar7d5e7442020-07-21 22:25:51 +020010985theend:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010986 p_cpo = save_cpo;
10987}
10988
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010989/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010990 * "submatch()" function
10991 */
10992 static void
10993f_submatch(typval_T *argvars, typval_T *rettv)
10994{
10995 int error = FALSE;
10996 int no;
10997 int retList = 0;
10998
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020010999 if (in_vim9script()
11000 && (check_for_number_arg(argvars, 0) == FAIL
11001 || check_for_opt_bool_arg(argvars, 1) == FAIL))
11002 return;
11003
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011004 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011005 if (error)
11006 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020011007 if (no < 0 || no >= NSUBEXP)
11008 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +000011009 semsg(_(e_invalid_submatch_number_nr), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +010011010 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020011011 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011012 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaarad304702020-09-06 18:22:53 +020011013 retList = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011014 if (error)
11015 return;
11016
11017 if (retList == 0)
11018 {
11019 rettv->v_type = VAR_STRING;
11020 rettv->vval.v_string = reg_submatch(no);
11021 }
11022 else
11023 {
11024 rettv->v_type = VAR_LIST;
11025 rettv->vval.v_list = reg_submatch_list(no);
11026 }
11027}
11028
11029/*
11030 * "substitute()" function
11031 */
11032 static void
11033f_substitute(typval_T *argvars, typval_T *rettv)
11034{
11035 char_u patbuf[NUMBUFLEN];
11036 char_u subbuf[NUMBUFLEN];
11037 char_u flagsbuf[NUMBUFLEN];
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020011038 char_u *str;
11039 char_u *pat;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020011040 char_u *sub = NULL;
11041 typval_T *expr = NULL;
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +020011042 char_u *flg;
11043
11044 if (in_vim9script()
11045 && (check_for_string_arg(argvars, 0) == FAIL
11046 || check_for_string_arg(argvars, 1) == FAIL
11047 || check_for_string_arg(argvars, 3) == FAIL))
11048 return;
11049
11050 str = tv_get_string_chk(&argvars[0]);
11051 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
11052 flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011053
LemonBoyf3b48952022-05-05 13:53:03 +010011054 if (argvars[2].v_type == VAR_FUNC
11055 || argvars[2].v_type == VAR_PARTIAL
Bram Moolenaar00b28d62022-12-08 15:32:33 +000011056 || argvars[2].v_type == VAR_INSTR
11057 || argvars[2].v_type == VAR_CLASS
11058 || argvars[2].v_type == VAR_OBJECT)
Bram Moolenaar72ab7292016-07-19 19:10:51 +020011059 expr = &argvars[2];
11060 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011061 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +020011062
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011063 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020011064 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
11065 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011066 rettv->vval.v_string = NULL;
11067 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +020011068 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011069}
11070
11071/*
Bram Moolenaarc216a7a2022-12-05 13:50:55 +000011072 * "swapfilelist()" function
11073 */
11074 static void
11075f_swapfilelist(typval_T *argvars UNUSED, typval_T *rettv)
11076{
11077 if (rettv_list_alloc(rettv) == FAIL)
11078 return;
11079 recover_names(NULL, FALSE, rettv->vval.v_list, 0, NULL);
11080}
11081
11082/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +020011083 * "swapinfo(swap_filename)" function
11084 */
11085 static void
11086f_swapinfo(typval_T *argvars, typval_T *rettv)
11087{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011088 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
11089 return;
11090
Bram Moolenaar00f123a2018-08-21 20:28:54 +020011091 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011092 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +020011093}
11094
11095/*
Bram Moolenaar110bd602018-09-16 18:46:59 +020011096 * "swapname(expr)" function
11097 */
11098 static void
11099f_swapname(typval_T *argvars, typval_T *rettv)
11100{
11101 buf_T *buf;
11102
11103 rettv->v_type = VAR_STRING;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011104
11105 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
11106 return;
11107
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010011108 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +020011109 if (buf == NULL || buf->b_ml.ml_mfp == NULL
11110 || buf->b_ml.ml_mfp->mf_fname == NULL)
11111 rettv->vval.v_string = NULL;
11112 else
11113 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
11114}
11115
11116/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011117 * "synID(lnum, col, trans)" function
11118 */
11119 static void
11120f_synID(typval_T *argvars UNUSED, typval_T *rettv)
11121{
11122 int id = 0;
11123#ifdef FEAT_SYN_HL
11124 linenr_T lnum;
11125 colnr_T col;
11126 int trans;
11127 int transerr = FALSE;
11128
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020011129 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020011130 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +020011131 || check_for_number_arg(argvars, 1) == FAIL
11132 || check_for_bool_arg(argvars, 2) == FAIL))
11133 return;
11134
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011135 lnum = tv_get_lnum(argvars); // -1 on type error
11136 col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaarfcb6d702020-09-05 21:41:56 +020011137 trans = (int)tv_get_bool_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011138
11139 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
11140 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000011141 id = syn_get_id(curwin, lnum, col, trans, NULL, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011142#endif
11143
11144 rettv->vval.v_number = id;
11145}
11146
11147/*
11148 * "synIDattr(id, what [, mode])" function
11149 */
11150 static void
11151f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
11152{
11153 char_u *p = NULL;
11154#ifdef FEAT_SYN_HL
11155 int id;
11156 char_u *what;
11157 char_u *mode;
11158 char_u modebuf[NUMBUFLEN];
11159 int modec;
11160
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020011161 if (in_vim9script()
11162 && (check_for_number_arg(argvars, 0) == FAIL
Yegappan Lakshmananf8dbd582021-09-26 19:04:05 +010011163 || check_for_string_arg(argvars, 1) == FAIL
11164 || check_for_opt_string_arg(argvars, 2) == FAIL))
Yegappan Lakshmanan7973de32021-07-24 16:16:15 +020011165 return;
11166
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011167 id = (int)tv_get_number(&argvars[0]);
11168 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011169 if (argvars[2].v_type != VAR_UNKNOWN)
11170 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011171 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011172 modec = TOLOWER_ASC(mode[0]);
11173 if (modec != 't' && modec != 'c' && modec != 'g')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011174 modec = 0; // replace invalid with current
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011175 }
11176 else
11177 {
11178#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
11179 if (USE_24BIT)
11180 modec = 'g';
11181 else
11182#endif
11183 if (t_colors > 1)
Dominique Pelle4781d6f2021-05-18 21:46:31 +020011184 modec = 'c';
11185 else
11186 modec = 't';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011187 }
11188
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011189 switch (TOLOWER_ASC(what[0]))
11190 {
11191 case 'b':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011192 if (TOLOWER_ASC(what[1]) == 'g') // bg[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011193 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011194 else // bold
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011195 p = highlight_has_attr(id, HL_BOLD, modec);
11196 break;
11197
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011198 case 'f': // fg[#] or font
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011199 p = highlight_color(id, what, modec);
11200 break;
11201
11202 case 'i':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011203 if (TOLOWER_ASC(what[1]) == 'n') // inverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011204 p = highlight_has_attr(id, HL_INVERSE, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011205 else // italic
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011206 p = highlight_has_attr(id, HL_ITALIC, modec);
11207 break;
11208
Martin Tournoijba43e762022-10-13 22:12:15 +010011209 case 'n':
Bram Moolenaarde786322022-07-30 14:56:17 +010011210 if (TOLOWER_ASC(what[1]) == 'o') // nocombine
11211 p = highlight_has_attr(id, HL_NOCOMBINE, modec);
11212 else // name
11213 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011214 break;
11215
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011216 case 'r': // reverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011217 p = highlight_has_attr(id, HL_INVERSE, modec);
11218 break;
11219
11220 case 's':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011221 if (TOLOWER_ASC(what[1]) == 'p') // sp[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011222 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011223 // strikeout
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +020011224 else if (TOLOWER_ASC(what[1]) == 't' &&
11225 TOLOWER_ASC(what[2]) == 'r')
11226 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011227 else // standout
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011228 p = highlight_has_attr(id, HL_STANDOUT, modec);
11229 break;
11230
11231 case 'u':
Bram Moolenaar84f54632022-06-29 18:39:11 +010011232 if (STRLEN(what) >= 9)
11233 {
11234 if (TOLOWER_ASC(what[5]) == 'l')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011235 // underline
Bram Moolenaar84f54632022-06-29 18:39:11 +010011236 p = highlight_has_attr(id, HL_UNDERLINE, modec);
11237 else if (TOLOWER_ASC(what[5]) != 'd')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011238 // undercurl
Bram Moolenaar84f54632022-06-29 18:39:11 +010011239 p = highlight_has_attr(id, HL_UNDERCURL, modec);
11240 else if (TOLOWER_ASC(what[6]) != 'o')
11241 // underdashed
11242 p = highlight_has_attr(id, HL_UNDERDASHED, modec);
11243 else if (TOLOWER_ASC(what[7]) == 'u')
11244 // underdouble
11245 p = highlight_has_attr(id, HL_UNDERDOUBLE, modec);
11246 else
11247 // underdotted
11248 p = highlight_has_attr(id, HL_UNDERDOTTED, modec);
11249 }
11250 else
11251 // ul
11252 p = highlight_color(id, what, modec);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011253 break;
11254 }
11255
11256 if (p != NULL)
11257 p = vim_strsave(p);
11258#endif
11259 rettv->v_type = VAR_STRING;
11260 rettv->vval.v_string = p;
11261}
11262
11263/*
11264 * "synIDtrans(id)" function
11265 */
11266 static void
11267f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
11268{
11269 int id;
11270
11271#ifdef FEAT_SYN_HL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011272 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
11273 return;
11274
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011275 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011276
11277 if (id > 0)
11278 id = syn_get_final_id(id);
11279 else
11280#endif
11281 id = 0;
11282
11283 rettv->vval.v_number = id;
11284}
11285
11286/*
11287 * "synconcealed(lnum, col)" function
11288 */
11289 static void
11290f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
11291{
11292#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
11293 linenr_T lnum;
11294 colnr_T col;
11295 int syntax_flags = 0;
11296 int cchar;
11297 int matchid = 0;
11298 char_u str[NUMBUFLEN];
11299#endif
11300
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020011301 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011302
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020011303 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020011304 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020011305 || check_for_number_arg(argvars, 1) == FAIL))
11306 return;
11307
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011308#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011309 lnum = tv_get_lnum(argvars); // -1 on type error
11310 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011311
Bram Moolenaara80faa82020-04-12 19:37:17 +020011312 CLEAR_FIELD(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011313
Bram Moolenaar93a10962022-06-16 11:42:09 +010011314 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011315 {
11316 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
11317 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
11318 && curwin->w_p_cole > 0)
11319 {
11320 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
11321 syntax_flags = get_syntax_info(&matchid);
11322
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011323 // get the conceal character
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011324 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
11325 {
11326 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +020011327 if (cchar == NUL && curwin->w_p_cole == 1)
Bram Moolenaareed9d462021-02-15 20:38:25 +010011328 cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' '
11329 : curwin->w_lcs_chars.conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011330 if (cchar != NUL)
11331 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011332 if (has_mbyte)
11333 (*mb_char2bytes)(cchar, str);
11334 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011335 str[0] = cchar;
11336 }
11337 }
11338 }
11339
11340 list_append_number(rettv->vval.v_list,
11341 (syntax_flags & HL_CONCEAL) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011342 // -1 to auto-determine strlen
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011343 list_append_string(rettv->vval.v_list, str, -1);
11344 list_append_number(rettv->vval.v_list, matchid);
11345 }
11346#endif
11347}
11348
11349/*
11350 * "synstack(lnum, col)" function
11351 */
11352 static void
11353f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
11354{
11355#ifdef FEAT_SYN_HL
11356 linenr_T lnum;
11357 colnr_T col;
11358 int i;
11359 int id;
11360#endif
11361
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020011362 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011363
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020011364 if (in_vim9script()
Yegappan Lakshmanancd917202021-07-21 19:09:09 +020011365 && (check_for_lnum_arg(argvars, 0) == FAIL
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +020011366 || check_for_number_arg(argvars, 1) == FAIL))
11367 return;
11368
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011369#ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011370 lnum = tv_get_lnum(argvars); // -1 on type error
11371 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011372
11373 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
11374 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
Bram Moolenaar93a10962022-06-16 11:42:09 +010011375 && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011376 {
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +000011377 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011378 for (i = 0; ; ++i)
11379 {
11380 id = syn_get_stack_item(i);
11381 if (id < 0)
11382 break;
11383 if (list_append_number(rettv->vval.v_list, id) == FAIL)
11384 break;
11385 }
11386 }
11387#endif
11388}
11389
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011390/*
11391 * "tabpagebuflist()" function
11392 */
11393 static void
11394f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
11395{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011396 tabpage_T *tp;
11397 win_T *wp = NULL;
11398
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011399 if (in_vim9script() && check_for_opt_number_arg(argvars, 0) == FAIL)
11400 return;
11401
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011402 if (argvars[0].v_type == VAR_UNKNOWN)
11403 wp = firstwin;
11404 else
11405 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011406 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011407 if (tp != NULL)
11408 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
11409 }
Bram Moolenaar93a10962022-06-16 11:42:09 +010011410 if (wp != NULL && rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011411 {
11412 for (; wp != NULL; wp = wp->w_next)
11413 if (list_append_number(rettv->vval.v_list,
11414 wp->w_buffer->b_fnum) == FAIL)
11415 break;
11416 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011417}
11418
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011419/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011420 * "tagfiles()" function
11421 */
11422 static void
11423f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
11424{
11425 char_u *fname;
11426 tagname_T tn;
11427 int first;
11428
11429 if (rettv_list_alloc(rettv) == FAIL)
11430 return;
11431 fname = alloc(MAXPATHL);
11432 if (fname == NULL)
11433 return;
11434
11435 for (first = TRUE; ; first = FALSE)
11436 if (get_tagfname(&tn, first, fname) == FAIL
11437 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
11438 break;
11439 tagname_free(&tn);
11440 vim_free(fname);
11441}
11442
11443/*
11444 * "taglist()" function
11445 */
11446 static void
11447f_taglist(typval_T *argvars, typval_T *rettv)
11448{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010011449 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011450 char_u *tag_pattern;
11451
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011452 if (in_vim9script()
11453 && (check_for_string_arg(argvars, 0) == FAIL
11454 || check_for_opt_string_arg(argvars, 1) == FAIL))
11455 return;
11456
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011457 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011458
11459 rettv->vval.v_number = FALSE;
11460 if (*tag_pattern == NUL)
11461 return;
11462
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010011463 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011464 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011465 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010011466 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011467}
11468
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011469/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011470 * "type(expr)" function
11471 */
11472 static void
11473f_type(typval_T *argvars, typval_T *rettv)
11474{
11475 int n = -1;
11476
11477 switch (argvars[0].v_type)
11478 {
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010011479 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
11480 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011481 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +010011482 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
11483 case VAR_LIST: n = VAR_TYPE_LIST; break;
11484 case VAR_DICT: n = VAR_TYPE_DICT; break;
11485 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
11486 case VAR_BOOL: n = VAR_TYPE_BOOL; break;
11487 case VAR_SPECIAL: n = VAR_TYPE_NONE; break;
Bram Moolenaarf562e722016-07-19 17:25:25 +020011488 case VAR_JOB: n = VAR_TYPE_JOB; break;
11489 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010011490 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaarf18332f2021-05-07 17:55:55 +020011491 case VAR_INSTR: n = VAR_TYPE_INSTR; break;
Bram Moolenaar00b28d62022-12-08 15:32:33 +000011492 case VAR_CLASS: n = VAR_TYPE_CLASS; break;
11493 case VAR_OBJECT: n = VAR_TYPE_OBJECT; break;
Yegappan Lakshmananec3cebb2023-10-27 19:35:26 +020011494 case VAR_TYPEALIAS: n = VAR_TYPE_TYPEALIAS; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011495 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +020011496 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010011497 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +010011498 internal_error_no_abort("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011499 n = -1;
11500 break;
11501 }
11502 rettv->vval.v_number = n;
11503}
11504
11505/*
zeertzjq825cf812023-08-17 22:55:25 +020011506 * "virtcol({expr}, [, {list} [, {winid}]])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011507 */
11508 static void
11509f_virtcol(typval_T *argvars, typval_T *rettv)
11510{
LemonBoy0f7a3e12022-05-26 12:10:37 +010011511 colnr_T vcol_start = 0;
11512 colnr_T vcol_end = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011513 pos_T *fp;
zeertzjq825cf812023-08-17 22:55:25 +020011514 switchwin_T switchwin;
11515 int winchanged = FALSE;
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010011516 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011517
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011518 if (in_vim9script()
LemonBoy0f7a3e12022-05-26 12:10:37 +010011519 && (check_for_string_or_list_arg(argvars, 0) == FAIL
11520 || (argvars[1].v_type != VAR_UNKNOWN
zeertzjq825cf812023-08-17 22:55:25 +020011521 && (check_for_bool_arg(argvars, 1) == FAIL
11522 || check_for_opt_number_arg(argvars, 2) == FAIL))))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011523 return;
11524
zeertzjq825cf812023-08-17 22:55:25 +020011525 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
11526 {
11527 tabpage_T *tp;
11528 win_T *wp;
11529
11530 // use the window specified in the third argument
11531 wp = win_id2wp_tp((int)tv_get_number(&argvars[2]), &tp);
11532 if (wp == NULL || tp == NULL)
11533 goto theend;
11534
11535 if (switch_win_noblock(&switchwin, wp, tp, TRUE) != OK)
11536 goto theend;
11537
11538 check_cursor();
11539 winchanged = TRUE;
11540 }
11541
11542 int fnum = curbuf->b_fnum;
Bram Moolenaar6f02b002021-01-10 20:22:54 +010011543 fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011544 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
LemonBoy0f7a3e12022-05-26 12:10:37 +010011545 && fnum == curbuf->b_fnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011546 {
Bram Moolenaarb3d33d82020-01-15 20:36:55 +010011547 // Limit the column to a valid value, getvvcol() doesn't check.
11548 if (fp->col < 0)
11549 fp->col = 0;
11550 else
11551 {
11552 len = (int)STRLEN(ml_get(fp->lnum));
11553 if (fp->col > len)
11554 fp->col = len;
11555 }
LemonBoy0f7a3e12022-05-26 12:10:37 +010011556 getvvcol(curwin, fp, &vcol_start, NULL, &vcol_end);
11557 ++vcol_start;
11558 ++vcol_end;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011559 }
11560
zeertzjq825cf812023-08-17 22:55:25 +020011561theend:
LemonBoy0f7a3e12022-05-26 12:10:37 +010011562 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
11563 {
11564 if (rettv_list_alloc(rettv) == OK)
11565 {
11566 list_append_number(rettv->vval.v_list, vcol_start);
11567 list_append_number(rettv->vval.v_list, vcol_end);
11568 }
11569 else
11570 rettv->vval.v_number = 0;
11571 }
11572 else
11573 rettv->vval.v_number = vcol_end;
zeertzjq825cf812023-08-17 22:55:25 +020011574
11575 if (winchanged)
11576 restore_win_noblock(&switchwin, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011577}
11578
11579/*
11580 * "visualmode()" function
11581 */
11582 static void
11583f_visualmode(typval_T *argvars, typval_T *rettv)
11584{
11585 char_u str[2];
11586
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011587 if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
11588 return;
11589
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011590 rettv->v_type = VAR_STRING;
11591 str[0] = curbuf->b_visual_mode_eval;
11592 str[1] = NUL;
11593 rettv->vval.v_string = vim_strsave(str);
11594
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011595 // A non-zero number or non-empty string argument: reset mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011596 if (non_zero_arg(&argvars[0]))
11597 curbuf->b_visual_mode_eval = NUL;
11598}
11599
11600/*
11601 * "wildmenumode()" function
11602 */
11603 static void
11604f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
11605{
Bram Moolenaar24959102022-05-07 20:01:16 +010011606 if (wild_menu_showing || ((State & MODE_CMDLINE) && cmdline_pum_active()))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011607 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011608}
11609
11610/*
Bram Moolenaar0c1e3742019-12-27 13:49:24 +010011611 * "windowsversion()" function
11612 */
11613 static void
11614f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
11615{
11616 rettv->v_type = VAR_STRING;
11617 rettv->vval.v_string = vim_strsave((char_u *)windowsVersion);
11618}
11619
11620/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011621 * "wordcount()" function
11622 */
11623 static void
11624f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
11625{
11626 if (rettv_dict_alloc(rettv) == FAIL)
11627 return;
11628 cursor_pos_info(rettv->vval.v_dict);
11629}
11630
11631/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011632 * "xor(expr, expr)" function
11633 */
11634 static void
11635f_xor(typval_T *argvars, typval_T *rettv)
11636{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +020011637 if (in_vim9script()
11638 && (check_for_number_arg(argvars, 0) == FAIL
11639 || check_for_number_arg(argvars, 1) == FAIL))
11640 return;
11641
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011642 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
11643 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011644}
11645
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010011646#endif // FEAT_EVAL