blob: ec74fdeeae9d270332e63ff5c9c50e328fde715b [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);
32static void byteidx(typval_T *argvars, typval_T *rettv, int comp);
33static void f_byteidx(typval_T *argvars, typval_T *rettv);
34static void f_byteidxcomp(typval_T *argvars, typval_T *rettv);
35static void f_call(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020036static void f_changenr(typval_T *argvars, typval_T *rettv);
37static void f_char2nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010038static void f_charcol(typval_T *argvars, typval_T *rettv);
Bram Moolenaar17793ef2020-12-28 12:56:58 +010039static void f_charidx(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020040static void f_col(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020041static void f_confirm(typval_T *argvars, typval_T *rettv);
42static void f_copy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020043static void f_cursor(typval_T *argsvars, typval_T *rettv);
Bram Moolenaar4f974752019-02-17 17:44:42 +010044#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +020045static void f_debugbreak(typval_T *argvars, typval_T *rettv);
46#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020047static void f_deepcopy(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020048static void f_did_filetype(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4132eb52020-02-14 16:53:00 +010049static void f_echoraw(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020050static void f_empty(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020051static void f_environ(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020052static void f_escape(typval_T *argvars, typval_T *rettv);
53static void f_eval(typval_T *argvars, typval_T *rettv);
54static void f_eventhandler(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020055static void f_execute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020056static void f_exists(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020057static void f_expand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar80dad482019-06-09 17:22:31 +020058static void f_expandcmd(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020059static void f_feedkeys(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020060static void f_fnameescape(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020061static void f_foreground(typval_T *argvars, typval_T *rettv);
Bram Moolenaar437bafe2016-08-01 15:40:54 +020062static void f_funcref(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020063static void f_function(typval_T *argvars, typval_T *rettv);
64static void f_garbagecollect(typval_T *argvars, typval_T *rettv);
65static void f_get(typval_T *argvars, typval_T *rettv);
Bram Moolenaar07ad8162018-02-13 13:59:59 +010066static void f_getchangelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010067static void f_getcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020068static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +020069static void f_getenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020070static void f_getfontname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4f505882018-02-10 21:06:32 +010071static void f_getjumplist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020072static void f_getpid(typval_T *argvars, typval_T *rettv);
73static void f_getcurpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +010074static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020075static void f_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020076static void f_getreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarbb861e22020-06-07 18:16:36 +020077static void f_getreginfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020078static void f_getregtype(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010079static void f_gettagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +020080static void f_gettext(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020081static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
82static void f_hasmapto(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020083static void f_hlID(typval_T *argvars, typval_T *rettv);
84static void f_hlexists(typval_T *argvars, typval_T *rettv);
85static void f_hostname(typval_T *argvars, typval_T *rettv);
86static void f_iconv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020087static void f_index(typval_T *argvars, typval_T *rettv);
88static void f_input(typval_T *argvars, typval_T *rettv);
89static void f_inputdialog(typval_T *argvars, typval_T *rettv);
90static void f_inputlist(typval_T *argvars, typval_T *rettv);
91static void f_inputrestore(typval_T *argvars, typval_T *rettv);
92static void f_inputsave(typval_T *argvars, typval_T *rettv);
93static void f_inputsecret(typval_T *argvars, typval_T *rettv);
Bram Moolenaar67a2deb2019-11-25 00:05:32 +010094static void f_interrupt(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020095static void f_invert(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020096static void f_islocked(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020097static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
98static void f_len(typval_T *argvars, typval_T *rettv);
99static void f_libcall(typval_T *argvars, typval_T *rettv);
100static void f_libcallnr(typval_T *argvars, typval_T *rettv);
101static void f_line(typval_T *argvars, typval_T *rettv);
102static void f_line2byte(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200103#ifdef FEAT_LUA
104static void f_luaeval(typval_T *argvars, typval_T *rettv);
105#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200106static void f_maparg(typval_T *argvars, typval_T *rettv);
107static void f_mapcheck(typval_T *argvars, typval_T *rettv);
108static void f_match(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200109static void f_matchend(typval_T *argvars, typval_T *rettv);
110static void f_matchlist(typval_T *argvars, typval_T *rettv);
111static void f_matchstr(typval_T *argvars, typval_T *rettv);
112static void f_matchstrpos(typval_T *argvars, typval_T *rettv);
113static void f_max(typval_T *argvars, typval_T *rettv);
114static void f_min(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200115#ifdef FEAT_MZSCHEME
116static void f_mzeval(typval_T *argvars, typval_T *rettv);
117#endif
118static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
119static void f_nr2char(typval_T *argvars, typval_T *rettv);
120static void f_or(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200121#ifdef FEAT_PERL
122static void f_perleval(typval_T *argvars, typval_T *rettv);
123#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200124static void f_prevnonblank(typval_T *argvars, typval_T *rettv);
125static void f_printf(typval_T *argvars, typval_T *rettv);
Bram Moolenaare9bd5722019-08-17 19:36:06 +0200126static void f_pum_getpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200127static void f_pumvisible(typval_T *argvars, typval_T *rettv);
128#ifdef FEAT_PYTHON3
129static void f_py3eval(typval_T *argvars, typval_T *rettv);
130#endif
131#ifdef FEAT_PYTHON
132static void f_pyeval(typval_T *argvars, typval_T *rettv);
133#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100134#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
135static void f_pyxeval(typval_T *argvars, typval_T *rettv);
136#endif
Bram Moolenaar4f645c52020-02-08 16:40:39 +0100137static void f_test_srand_seed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100138static void f_rand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200139static void f_range(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200140static void f_reg_executing(typval_T *argvars, typval_T *rettv);
141static void f_reg_recording(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200142static void f_rename(typval_T *argvars, typval_T *rettv);
143static void f_repeat(typval_T *argvars, typval_T *rettv);
Bram Moolenaare99be0e2019-03-26 22:51:09 +0100144#ifdef FEAT_RUBY
145static void f_rubyeval(typval_T *argvars, typval_T *rettv);
146#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200147static void f_screenattr(typval_T *argvars, typval_T *rettv);
148static void f_screenchar(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100149static void f_screenchars(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200150static void f_screencol(typval_T *argvars, typval_T *rettv);
151static void f_screenrow(typval_T *argvars, typval_T *rettv);
Bram Moolenaar2912abb2019-03-29 14:16:42 +0100152static void f_screenstring(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200153static void f_search(typval_T *argvars, typval_T *rettv);
154static void f_searchdecl(typval_T *argvars, typval_T *rettv);
155static void f_searchpair(typval_T *argvars, typval_T *rettv);
156static void f_searchpairpos(typval_T *argvars, typval_T *rettv);
157static void f_searchpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100158static void f_setcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200159static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100160static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar691ddee2019-05-09 14:52:41 +0200161static void f_setenv(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200162static void f_setfperm(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200163static void f_setpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200164static void f_setreg(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100165static void f_settagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200166#ifdef FEAT_CRYPT
167static void f_sha256(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb005cd82019-09-04 15:54:55 +0200168#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200169static void f_shellescape(typval_T *argvars, typval_T *rettv);
170static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200171static void f_soundfold(typval_T *argvars, typval_T *rettv);
172static void f_spellbadword(typval_T *argvars, typval_T *rettv);
173static void f_spellsuggest(typval_T *argvars, typval_T *rettv);
174static void f_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +0100175static void f_srand(typval_T *argvars, typval_T *rettv);
Bram Moolenaar9d401282019-04-06 13:18:12 +0200176static void f_str2list(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200177static void f_str2nr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar70ce8a12021-03-14 19:02:09 +0100178static void f_strcharlen(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200179static void f_strchars(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200180static void f_strgetchar(typval_T *argvars, typval_T *rettv);
181static void f_stridx(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200182static void f_strlen(typval_T *argvars, typval_T *rettv);
183static void f_strcharpart(typval_T *argvars, typval_T *rettv);
184static void f_strpart(typval_T *argvars, typval_T *rettv);
185static void f_strridx(typval_T *argvars, typval_T *rettv);
186static void f_strtrans(typval_T *argvars, typval_T *rettv);
187static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv);
188static void f_strwidth(typval_T *argvars, typval_T *rettv);
189static void f_submatch(typval_T *argvars, typval_T *rettv);
190static void f_substitute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200191static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200192static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200193static void f_synID(typval_T *argvars, typval_T *rettv);
194static void f_synIDattr(typval_T *argvars, typval_T *rettv);
195static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
196static void f_synstack(typval_T *argvars, typval_T *rettv);
197static void f_synconcealed(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200198static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200199static void f_taglist(typval_T *argvars, typval_T *rettv);
200static void f_tagfiles(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200201static void f_tolower(typval_T *argvars, typval_T *rettv);
202static void f_toupper(typval_T *argvars, typval_T *rettv);
203static void f_tr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +0100204static void f_trim(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200205static void f_type(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200206static void f_virtcol(typval_T *argvars, typval_T *rettv);
207static void f_visualmode(typval_T *argvars, typval_T *rettv);
208static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0c1e3742019-12-27 13:49:24 +0100209static void f_windowsversion(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200210static void f_wordcount(typval_T *argvars, typval_T *rettv);
211static void f_xor(typval_T *argvars, typval_T *rettv);
212
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100213
Bram Moolenaar94738d82020-10-21 14:25:07 +0200214/*
215 * Functions that check the argument type of a builtin function.
216 * Each function returns FAIL and gives an error message if the type is wrong.
217 */
218
219// Context passed to an arg_ function.
220typedef struct {
Bram Moolenaarca174532020-10-21 16:42:22 +0200221 int arg_count; // actual argument count
222 type_T **arg_types; // list of argument types
223 int arg_idx; // current argument index (first arg is zero)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100224 cctx_T *arg_cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +0200225} argcontext_T;
226
227// A function to check one argument type. The first argument is the type to
228// check. If needed, other argument types can be obtained with the context.
229// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.
230typedef int (*argcheck_T)(type_T *, argcontext_T *);
231
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100232/*
Bram Moolenaar351ead02021-01-16 16:07:01 +0100233 * Call need_type() to check an argument type.
234 */
235 static int
236check_arg_type(
237 type_T *expected,
238 type_T *actual,
239 argcontext_T *context)
240{
241 // TODO: would be useful to know if "actual" is a constant and pass it to
242 // need_type() to get a compile time error if possible.
243 return need_type(actual, expected,
244 context->arg_idx - context->arg_count, context->arg_idx + 1,
245 context->arg_cctx, FALSE, FALSE);
246}
247
248/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100249 * Check "type" is a float or a number.
250 */
Bram Moolenaar94738d82020-10-21 14:25:07 +0200251 static int
252arg_float_or_nr(type_T *type, argcontext_T *context)
253{
Bram Moolenaarca174532020-10-21 16:42:22 +0200254 if (type->tt_type == VAR_ANY
255 || type->tt_type == VAR_FLOAT || type->tt_type == VAR_NUMBER)
Bram Moolenaar94738d82020-10-21 14:25:07 +0200256 return OK;
257 arg_type_mismatch(&t_number, type, context->arg_idx + 1);
258 return FAIL;
259}
260
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100261/*
262 * Check "type" is a number.
263 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200264 static int
265arg_number(type_T *type, argcontext_T *context)
266{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100267 return check_arg_type(&t_number, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200268}
269
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100270/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200271 * Check "type" is a dict of 'any'.
272 */
273 static int
274arg_dict_any(type_T *type, argcontext_T *context)
275{
276 return check_arg_type(&t_dict_any, type, context);
277}
278
279/*
280 * Check "type" is a list of numbers.
281 */
282 static int
283arg_list_number(type_T *type, argcontext_T *context)
284{
285 return check_arg_type(&t_list_number, type, context);
286}
287
288/*
289 * Check "type" is a list of strings.
290 */
291 static int
292arg_list_string(type_T *type, argcontext_T *context)
293{
294 return check_arg_type(&t_list_string, type, context);
295}
296
297/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100298 * Check "type" is a string.
299 */
300 static int
301arg_string(type_T *type, argcontext_T *context)
302{
Bram Moolenaar351ead02021-01-16 16:07:01 +0100303 return check_arg_type(&t_string, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100304}
305
306/*
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +0100307 * Check "type" is a bool or number 0 or 1.
308 */
309 static int
310arg_bool(type_T *type, argcontext_T *context)
311{
312 if (type->tt_type == VAR_ANY
313 || type->tt_type == VAR_NUMBER || type->tt_type == VAR_BOOL)
314 return OK;
315 return check_arg_type(&t_bool, type, context);
316}
317
318/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100319 * Check "type" is a list or a blob.
320 */
Bram Moolenaarca174532020-10-21 16:42:22 +0200321 static int
322arg_list_or_blob(type_T *type, argcontext_T *context)
323{
324 if (type->tt_type == VAR_ANY
325 || type->tt_type == VAR_LIST || type->tt_type == VAR_BLOB)
326 return OK;
327 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
328 return FAIL;
329}
330
331/*
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200332 * Check "type" is a string or a number
333 */
334 static int
335arg_string_or_nr(type_T *type, argcontext_T *context)
336{
337 if (type->tt_type == VAR_ANY
338 || type->tt_type == VAR_STRING || type->tt_type == VAR_NUMBER)
339 return OK;
340 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
341 return FAIL;
342}
343/*
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200344 * Check "type" is a string or a list of strings.
345 */
346 static int
347arg_string_or_list(type_T *type, argcontext_T *context)
348{
349 if (type->tt_type == VAR_ANY || type->tt_type == VAR_STRING)
350 return OK;
351 if (type->tt_type != VAR_LIST)
352 {
353 arg_type_mismatch(&t_string, type, context->arg_idx + 1);
354 return FAIL;
355 }
356 if (type->tt_member->tt_type == VAR_ANY
357 || type->tt_member->tt_type == VAR_STRING)
358 return OK;
359
360 arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);
361 return FAIL;
362}
363
364/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100365 * Check "type" is a list or a dict.
366 */
367 static int
368arg_list_or_dict(type_T *type, argcontext_T *context)
369{
370 if (type->tt_type == VAR_ANY
371 || type->tt_type == VAR_LIST || type->tt_type == VAR_DICT)
372 return OK;
373 arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);
374 return FAIL;
375}
376
377/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100378 * Check "type" is the same type as the previous argument.
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100379 * Must not be used for the first argcheck_T entry.
380 */
381 static int
382arg_same_as_prev(type_T *type, argcontext_T *context)
383{
384 type_T *prev_type = context->arg_types[context->arg_idx - 1];
385
Bram Moolenaar351ead02021-01-16 16:07:01 +0100386 return check_arg_type(prev_type, type, context);
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100387}
388
389/*
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100390 * Check "type" is the same basic type as the previous argument, checks list or
391 * dict vs other type, but not member type.
392 * Must not be used for the first argcheck_T entry.
393 */
394 static int
395arg_same_struct_as_prev(type_T *type, argcontext_T *context)
396{
397 type_T *prev_type = context->arg_types[context->arg_idx - 1];
398
399 if (prev_type->tt_type != context->arg_types[context->arg_idx]->tt_type)
Bram Moolenaar351ead02021-01-16 16:07:01 +0100400 return check_arg_type(prev_type, type, context);
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100401 return OK;
402}
403
404/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100405 * Check "type" is an item of the list or blob of the previous arg.
Bram Moolenaarca174532020-10-21 16:42:22 +0200406 * Must not be used for the first argcheck_T entry.
407 */
408 static int
409arg_item_of_prev(type_T *type, argcontext_T *context)
410{
411 type_T *prev_type = context->arg_types[context->arg_idx - 1];
412 type_T *expected;
413
414 if (prev_type->tt_type == VAR_LIST)
415 expected = prev_type->tt_member;
416 else if (prev_type->tt_type == VAR_BLOB)
417 expected = &t_number;
418 else
419 // probably VAR_ANY, can't check
420 return OK;
421
Bram Moolenaar351ead02021-01-16 16:07:01 +0100422 return check_arg_type(expected, type, context);
Bram Moolenaarca174532020-10-21 16:42:22 +0200423}
424
Bram Moolenaar94738d82020-10-21 14:25:07 +0200425/*
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100426 * Check "type" which is the third argument of extend().
427 */
428 static int
429arg_extend3(type_T *type, argcontext_T *context)
430{
431 type_T *first_type = context->arg_types[context->arg_idx - 2];
432
433 if (first_type->tt_type == VAR_LIST)
434 return arg_number(type, context);
435 if (first_type->tt_type == VAR_DICT)
436 return arg_string(type, context);
437 return OK;
438}
439
440
441/*
Bram Moolenaar94738d82020-10-21 14:25:07 +0200442 * Lists of functions that check the argument types of a builtin function.
443 */
Bram Moolenaar80ad3e22021-01-31 20:48:58 +0100444argcheck_T arg1_string[] = {arg_string};
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200445argcheck_T arg1_number[] = {arg_number};
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200446argcheck_T arg1_dict[] = {arg_dict_any};
447argcheck_T arg1_list_number[] = {arg_list_number};
448argcheck_T arg1_string_list[] = {arg_list_string};
Bram Moolenaar94738d82020-10-21 14:25:07 +0200449argcheck_T arg1_float_or_nr[] = {arg_float_or_nr};
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200450argcheck_T arg1_string_or_nr[] = {arg_string_or_nr};
451argcheck_T arg1_string_or_list[] = {arg_string_or_list};
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200452argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr};
453argcheck_T arg2_number[] = {arg_number, arg_number};
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200454argcheck_T arg2_string[] = {arg_string, arg_string};
455argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number};
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100456argcheck_T arg2_listblob_item[] = {arg_list_or_blob, arg_item_of_prev};
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200457argcheck_T arg2_execute[] = {arg_string_or_list, arg_string};
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100458argcheck_T arg23_extend[] = {arg_list_or_dict, arg_same_as_prev, arg_extend3};
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100459argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3};
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200460argcheck_T arg3_string[] = {arg_string, arg_string, arg_string};
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200461argcheck_T arg3_number[] = {arg_number, arg_number, arg_number};
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200462argcheck_T arg3_string_nr_bool[] = {arg_string, arg_number, arg_bool};
Bram Moolenaarca174532020-10-21 16:42:22 +0200463argcheck_T arg3_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number};
Bram Moolenaar94738d82020-10-21 14:25:07 +0200464
465/*
466 * Functions that return the return type of a builtin function.
Bram Moolenaara1224cb2020-10-22 12:31:49 +0200467 * Note that "argtypes" is NULL if "argcount" is zero.
Bram Moolenaar94738d82020-10-21 14:25:07 +0200468 */
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100469 static type_T *
470ret_void(int argcount UNUSED, type_T **argtypes UNUSED)
471{
472 return &t_void;
473}
474 static type_T *
475ret_any(int argcount UNUSED, type_T **argtypes UNUSED)
476{
477 return &t_any;
478}
479 static type_T *
Bram Moolenaar403dc312020-10-17 19:29:51 +0200480ret_bool(int argcount UNUSED, type_T **argtypes UNUSED)
481{
482 return &t_bool;
483}
484 static type_T *
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100485ret_number_bool(int argcount UNUSED, type_T **argtypes UNUSED)
486{
487 return &t_number_bool;
488}
489 static type_T *
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100490ret_number(int argcount UNUSED, type_T **argtypes UNUSED)
491{
492 return &t_number;
493}
494 static type_T *
495ret_float(int argcount UNUSED, type_T **argtypes UNUSED)
496{
497 return &t_float;
498}
499 static type_T *
500ret_string(int argcount UNUSED, type_T **argtypes UNUSED)
501{
502 return &t_string;
503}
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200504 static type_T *
505ret_list_any(int argcount UNUSED, type_T **argtypes UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100506{
507 return &t_list_any;
508}
509 static type_T *
510ret_list_number(int argcount UNUSED, type_T **argtypes UNUSED)
511{
512 return &t_list_number;
513}
514 static type_T *
515ret_list_string(int argcount UNUSED, type_T **argtypes UNUSED)
516{
517 return &t_list_string;
518}
519 static type_T *
520ret_list_dict_any(int argcount UNUSED, type_T **argtypes UNUSED)
521{
522 return &t_list_dict_any;
523}
524 static type_T *
525ret_dict_any(int argcount UNUSED, type_T **argtypes UNUSED)
526{
527 return &t_dict_any;
528}
529 static type_T *
Bram Moolenaar64ed4d42021-01-12 21:22:31 +0100530ret_job_info(int argcount, type_T **argtypes UNUSED)
531{
532 if (argcount == 0)
533 return &t_list_job;
534 return &t_dict_any;
535}
536 static type_T *
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100537ret_dict_number(int argcount UNUSED, type_T **argtypes UNUSED)
538{
539 return &t_dict_number;
540}
541 static type_T *
542ret_dict_string(int argcount UNUSED, type_T **argtypes UNUSED)
543{
544 return &t_dict_string;
545}
546 static type_T *
547ret_blob(int argcount UNUSED, type_T **argtypes UNUSED)
548{
549 return &t_blob;
550}
551 static type_T *
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200552ret_func_any(int argcount UNUSED, type_T **argtypes UNUSED)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100553{
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200554 return &t_func_any;
555}
556 static type_T *
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100557ret_channel(int argcount UNUSED, type_T **argtypes UNUSED)
558{
559 return &t_channel;
560}
561 static type_T *
562ret_job(int argcount UNUSED, type_T **argtypes UNUSED)
563{
564 return &t_job;
565}
Bram Moolenaar865af6b2020-06-18 18:45:49 +0200566 static type_T *
567ret_first_arg(int argcount, type_T **argtypes)
568{
569 if (argcount > 0)
570 return argtypes[0];
571 return &t_void;
572}
Bram Moolenaarea696852020-11-09 18:31:39 +0100573// for map(): returns first argument but item type may differ
574 static type_T *
575ret_first_cont(int argcount UNUSED, type_T **argtypes)
576{
577 if (argtypes[0]->tt_type == VAR_LIST)
578 return &t_list_any;
579 if (argtypes[0]->tt_type == VAR_DICT)
580 return &t_dict_any;
581 if (argtypes[0]->tt_type == VAR_BLOB)
582 return argtypes[0];
583 return &t_any;
584}
Bram Moolenaar865af6b2020-06-18 18:45:49 +0200585
Bram Moolenaarf151ad12020-06-30 13:38:01 +0200586/*
587 * Used for getqflist(): returns list if there is no argument, dict if there is
588 * one.
589 */
590 static type_T *
591ret_list_or_dict_0(int argcount, type_T **argtypes UNUSED)
592{
593 if (argcount > 0)
594 return &t_dict_any;
595 return &t_list_dict_any;
596}
597
598/*
599 * Used for getloclist(): returns list if there is one argument, dict if there
600 * are two.
601 */
602 static type_T *
603ret_list_or_dict_1(int argcount, type_T **argtypes UNUSED)
604{
605 if (argcount > 1)
606 return &t_dict_any;
607 return &t_list_dict_any;
608}
609
Bram Moolenaar846178a2020-07-05 17:04:13 +0200610 static type_T *
611ret_argv(int argcount, type_T **argtypes UNUSED)
612{
613 // argv() returns list of strings
614 if (argcount == 0)
615 return &t_list_string;
616
617 // argv(0) returns a string, but argv(-1] returns a list
618 return &t_any;
619}
620
Bram Moolenaarad7c2492020-07-05 20:55:29 +0200621 static type_T *
622ret_remove(int argcount UNUSED, type_T **argtypes)
623{
Bram Moolenaar5e654232020-09-16 15:22:00 +0200624 if (argtypes != NULL)
625 {
626 if (argtypes[0]->tt_type == VAR_LIST
627 || argtypes[0]->tt_type == VAR_DICT)
628 return argtypes[0]->tt_member;
629 if (argtypes[0]->tt_type == VAR_BLOB)
630 return &t_number;
631 }
Bram Moolenaarad7c2492020-07-05 20:55:29 +0200632 return &t_any;
633}
634
Bram Moolenaar3d945cc2020-08-06 21:26:59 +0200635 static type_T *
636ret_getreg(int argcount, type_T **argtypes UNUSED)
637{
638 // Assume that if the third argument is passed it's non-zero
639 if (argcount == 3)
640 return &t_list_string;
641 return &t_string;
642}
643
Bram Moolenaar4a6d1b62020-08-08 17:55:49 +0200644 static type_T *
645ret_maparg(int argcount, type_T **argtypes UNUSED)
646{
647 // Assume that if the fourth argument is passed it's non-zero
648 if (argcount == 4)
649 return &t_dict_any;
650 return &t_string;
651}
652
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100653static type_T *ret_f_function(int argcount, type_T **argtypes);
654
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200655/*
656 * Array with names and number of arguments of all internal functions
657 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
658 */
Bram Moolenaarac92e252019-08-03 21:58:38 +0200659typedef struct
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200660{
Bram Moolenaar25e42232019-08-04 15:04:10 +0200661 char *f_name; // function name
662 char f_min_argc; // minimal number of arguments
663 char f_max_argc; // maximal number of arguments
664 char f_argtype; // for method: FEARG_ values
Bram Moolenaar94738d82020-10-21 14:25:07 +0200665 argcheck_T *f_argcheck; // list of functions to check argument types
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +0100666 type_T *(*f_retfunc)(int argcount, type_T **argtypes);
667 // return type function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200668 void (*f_func)(typval_T *args, typval_T *rvar);
Bram Moolenaar25e42232019-08-04 15:04:10 +0200669 // implementation of function
Bram Moolenaarac92e252019-08-03 21:58:38 +0200670} funcentry_T;
671
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +0200672// values for f_argtype; zero means it cannot be used as a method
673#define FEARG_1 1 // base is the first argument
674#define FEARG_2 2 // base is the second argument
Bram Moolenaar24278d22019-08-16 21:49:22 +0200675#define FEARG_3 3 // base is the third argument
Bram Moolenaaraad222c2019-09-06 22:46:09 +0200676#define FEARG_4 4 // base is the fourth argument
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +0200677#define FEARG_LAST 9 // base is the last argument
678
Bram Moolenaar15c47602020-03-26 22:16:48 +0100679#ifdef FEAT_FLOAT
680# define FLOAT_FUNC(name) name
681#else
682# define FLOAT_FUNC(name) NULL
683#endif
684#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
685# define MATH_FUNC(name) name
686#else
687# define MATH_FUNC(name) NULL
688#endif
689#ifdef FEAT_TIMERS
690# define TIMER_FUNC(name) name
691#else
692# define TIMER_FUNC(name) NULL
693#endif
694#ifdef FEAT_JOB_CHANNEL
695# define JOB_FUNC(name) name
696#else
697# define JOB_FUNC(name) NULL
698#endif
699#ifdef FEAT_PROP_POPUP
700# define PROP_FUNC(name) name
701#else
702# define PROP_FUNC(name) NULL
703#endif
704#ifdef FEAT_SIGNS
705# define SIGN_FUNC(name) name
706#else
707# define SIGN_FUNC(name) NULL
708#endif
709#ifdef FEAT_SOUND
710# define SOUND_FUNC(name) name
711#else
712# define SOUND_FUNC(name) NULL
713#endif
714#ifdef FEAT_TERMINAL
715# define TERM_FUNC(name) name
716#else
717# define TERM_FUNC(name) NULL
718#endif
719
Bram Moolenaarac92e252019-08-03 21:58:38 +0200720static funcentry_T global_functions[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200721{
Bram Moolenaar94738d82020-10-21 14:25:07 +0200722 {"abs", 1, 1, FEARG_1, arg1_float_or_nr,
723 ret_any, FLOAT_FUNC(f_abs)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200724 {"acos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200725 ret_float, FLOAT_FUNC(f_acos)},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100726 {"add", 2, 2, FEARG_1, NULL /* arg2_listblob_item */,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200727 ret_first_arg, f_add},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200728 {"and", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200729 ret_number, f_and},
730 {"append", 2, 2, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100731 ret_number_bool, f_append},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200732 {"appendbufline", 3, 3, FEARG_3, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100733 ret_number_bool, f_appendbufline},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200734 {"argc", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200735 ret_number, f_argc},
736 {"argidx", 0, 0, 0, NULL,
737 ret_number, f_argidx},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200738 {"arglistid", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200739 ret_number, f_arglistid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200740 {"argv", 0, 2, 0, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200741 ret_argv, f_argv},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200742 {"asin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200743 ret_float, FLOAT_FUNC(f_asin)},
744 {"assert_beeps", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100745 ret_number_bool, f_assert_beeps},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200746 {"assert_equal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100747 ret_number_bool, f_assert_equal},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200748 {"assert_equalfile", 2, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100749 ret_number_bool, f_assert_equalfile},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200750 {"assert_exception", 1, 2, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100751 ret_number_bool, f_assert_exception},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200752 {"assert_fails", 1, 5, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100753 ret_number_bool, f_assert_fails},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200754 {"assert_false", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100755 ret_number_bool, f_assert_false},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200756 {"assert_inrange", 3, 4, FEARG_3, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100757 ret_number_bool, f_assert_inrange},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200758 {"assert_match", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100759 ret_number_bool, f_assert_match},
Bram Moolenaar5b8cabf2021-04-02 18:55:57 +0200760 {"assert_nobeep", 1, 2, FEARG_1, NULL,
761 ret_number_bool, f_assert_nobeep},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200762 {"assert_notequal", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100763 ret_number_bool, f_assert_notequal},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200764 {"assert_notmatch", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100765 ret_number_bool, f_assert_notmatch},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200766 {"assert_report", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100767 ret_number_bool, f_assert_report},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200768 {"assert_true", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100769 ret_number_bool, f_assert_true},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200770 {"atan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200771 ret_float, FLOAT_FUNC(f_atan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200772 {"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200773 ret_float, FLOAT_FUNC(f_atan2)},
774 {"balloon_gettext", 0, 0, 0, NULL,
775 ret_string,
Bram Moolenaar59716a22017-03-01 20:32:44 +0100776#ifdef FEAT_BEVAL
Bram Moolenaar15c47602020-03-26 22:16:48 +0100777 f_balloon_gettext
778#else
779 NULL
Bram Moolenaar59716a22017-03-01 20:32:44 +0100780#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +0100781 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200782 {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200783 ret_void,
Bram Moolenaar15c47602020-03-26 22:16:48 +0100784#ifdef FEAT_BEVAL
785 f_balloon_show
786#else
787 NULL
788#endif
789 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200790 {"balloon_split", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200791 ret_list_string,
Bram Moolenaar15c47602020-03-26 22:16:48 +0100792#if defined(FEAT_BEVAL_TERM)
793 f_balloon_split
794#else
795 NULL
796#endif
797 },
Bram Moolenaar94738d82020-10-21 14:25:07 +0200798 {"browse", 4, 4, 0, NULL,
799 ret_string, f_browse},
800 {"browsedir", 2, 2, 0, NULL,
801 ret_string, f_browsedir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200802 {"bufadd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200803 ret_number, f_bufadd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200804 {"bufexists", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100805 ret_number_bool, f_bufexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200806 {"buffer_exists", 1, 1, FEARG_1, arg1_string_or_nr, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100807 ret_number_bool, f_bufexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200808 {"buffer_name", 0, 1, FEARG_1, arg1_string_or_nr, // obsolete
Bram Moolenaarb8f519e2020-10-21 14:49:08 +0200809 ret_string, f_bufname},
810 {"buffer_number", 0, 1, FEARG_1, NULL, // obsolete
811 ret_number, f_bufnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200812 {"buflisted", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100813 ret_number_bool, f_buflisted},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200814 {"bufload", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200815 ret_void, f_bufload},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200816 {"bufloaded", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100817 ret_number_bool, f_bufloaded},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200818 {"bufname", 0, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200819 ret_string, f_bufname},
820 {"bufnr", 0, 2, FEARG_1, NULL,
821 ret_number, f_bufnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200822 {"bufwinid", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200823 ret_number, f_bufwinid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200824 {"bufwinnr", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200825 ret_number, f_bufwinnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200826 {"byte2line", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200827 ret_number, f_byte2line},
828 {"byteidx", 2, 2, FEARG_1, NULL,
829 ret_number, f_byteidx},
830 {"byteidxcomp", 2, 2, FEARG_1, NULL,
831 ret_number, f_byteidxcomp},
832 {"call", 2, 3, FEARG_1, NULL,
833 ret_any, f_call},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200834 {"ceil", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200835 ret_float, FLOAT_FUNC(f_ceil)},
836 {"ch_canread", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100837 ret_number_bool, JOB_FUNC(f_ch_canread)},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200838 {"ch_close", 1, 1, FEARG_1, NULL,
839 ret_void, JOB_FUNC(f_ch_close)},
840 {"ch_close_in", 1, 1, FEARG_1, NULL,
841 ret_void, JOB_FUNC(f_ch_close_in)},
842 {"ch_evalexpr", 2, 3, FEARG_1, NULL,
843 ret_any, JOB_FUNC(f_ch_evalexpr)},
844 {"ch_evalraw", 2, 3, FEARG_1, NULL,
845 ret_any, JOB_FUNC(f_ch_evalraw)},
846 {"ch_getbufnr", 2, 2, FEARG_1, NULL,
847 ret_number, JOB_FUNC(f_ch_getbufnr)},
848 {"ch_getjob", 1, 1, FEARG_1, NULL,
849 ret_job, JOB_FUNC(f_ch_getjob)},
850 {"ch_info", 1, 1, FEARG_1, NULL,
851 ret_dict_any, JOB_FUNC(f_ch_info)},
852 {"ch_log", 1, 2, FEARG_1, NULL,
853 ret_void, JOB_FUNC(f_ch_log)},
854 {"ch_logfile", 1, 2, FEARG_1, NULL,
855 ret_void, JOB_FUNC(f_ch_logfile)},
856 {"ch_open", 1, 2, FEARG_1, NULL,
857 ret_channel, JOB_FUNC(f_ch_open)},
858 {"ch_read", 1, 2, FEARG_1, NULL,
859 ret_string, JOB_FUNC(f_ch_read)},
860 {"ch_readblob", 1, 2, FEARG_1, NULL,
861 ret_blob, JOB_FUNC(f_ch_readblob)},
862 {"ch_readraw", 1, 2, FEARG_1, NULL,
863 ret_string, JOB_FUNC(f_ch_readraw)},
864 {"ch_sendexpr", 2, 3, FEARG_1, NULL,
865 ret_void, JOB_FUNC(f_ch_sendexpr)},
866 {"ch_sendraw", 2, 3, FEARG_1, NULL,
867 ret_void, JOB_FUNC(f_ch_sendraw)},
868 {"ch_setoptions", 2, 2, FEARG_1, NULL,
869 ret_void, JOB_FUNC(f_ch_setoptions)},
870 {"ch_status", 1, 2, FEARG_1, NULL,
871 ret_string, JOB_FUNC(f_ch_status)},
872 {"changenr", 0, 0, 0, NULL,
873 ret_number, f_changenr},
874 {"char2nr", 1, 2, FEARG_1, NULL,
875 ret_number, f_char2nr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200876 {"charclass", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200877 ret_number, f_charclass},
Bram Moolenaar6f02b002021-01-10 20:22:54 +0100878 {"charcol", 1, 1, FEARG_1, NULL,
879 ret_number, f_charcol},
Bram Moolenaar17793ef2020-12-28 12:56:58 +0100880 {"charidx", 2, 3, FEARG_1, NULL,
881 ret_number, f_charidx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200882 {"chdir", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200883 ret_string, f_chdir},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200884 {"cindent", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200885 ret_number, f_cindent},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200886 {"clearmatches", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200887 ret_void, f_clearmatches},
888 {"col", 1, 1, FEARG_1, NULL,
889 ret_number, f_col},
890 {"complete", 2, 2, FEARG_2, NULL,
891 ret_void, f_complete},
892 {"complete_add", 1, 1, FEARG_1, NULL,
893 ret_number, f_complete_add},
894 {"complete_check", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100895 ret_number_bool, f_complete_check},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200896 {"complete_info", 0, 1, FEARG_1, arg1_string_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200897 ret_dict_any, f_complete_info},
898 {"confirm", 1, 4, FEARG_1, NULL,
899 ret_number, f_confirm},
900 {"copy", 1, 1, FEARG_1, NULL,
901 ret_first_arg, f_copy},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200902 {"cos", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200903 ret_float, FLOAT_FUNC(f_cos)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200904 {"cosh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200905 ret_float, FLOAT_FUNC(f_cosh)},
906 {"count", 2, 4, FEARG_1, NULL,
907 ret_number, f_count},
908 {"cscope_connection",0,3, 0, NULL,
909 ret_number, f_cscope_connection},
910 {"cursor", 1, 3, FEARG_1, NULL,
911 ret_number, f_cursor},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200912 {"debugbreak", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200913 ret_number,
Bram Moolenaar4f974752019-02-17 17:44:42 +0100914#ifdef MSWIN
Bram Moolenaar15c47602020-03-26 22:16:48 +0100915 f_debugbreak
916#else
917 NULL
Bram Moolenaar4551c0a2018-06-20 22:38:21 +0200918#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +0100919 },
Bram Moolenaar94738d82020-10-21 14:25:07 +0200920 {"deepcopy", 1, 2, FEARG_1, NULL,
921 ret_first_arg, f_deepcopy},
922 {"delete", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100923 ret_number_bool, f_delete},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200924 {"deletebufline", 2, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100925 ret_number_bool, f_deletebufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200926 {"did_filetype", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100927 ret_number_bool, f_did_filetype},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200928 {"diff_filler", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200929 ret_number, f_diff_filler},
930 {"diff_hlID", 2, 2, FEARG_1, NULL,
931 ret_number, f_diff_hlID},
932 {"echoraw", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100933 ret_void, f_echoraw},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200934 {"empty", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100935 ret_number_bool, f_empty},
Bram Moolenaar94738d82020-10-21 14:25:07 +0200936 {"environ", 0, 0, 0, NULL,
937 ret_dict_string, f_environ},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200938 {"escape", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200939 ret_string, f_escape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200940 {"eval", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200941 ret_any, f_eval},
942 {"eventhandler", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100943 ret_number_bool, f_eventhandler},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200944 {"executable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200945 ret_number, f_executable},
Bram Moolenaarca81f0e2021-06-20 14:41:01 +0200946 {"execute", 1, 2, FEARG_1, arg2_execute,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200947 ret_string, f_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200948 {"exepath", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200949 ret_string, f_exepath},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200950 {"exists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100951 ret_number_bool, f_exists},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200952 {"exp", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200953 ret_float, FLOAT_FUNC(f_exp)},
954 {"expand", 1, 3, FEARG_1, NULL,
955 ret_any, f_expand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200956 {"expandcmd", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200957 ret_string, f_expandcmd},
Bram Moolenaarfbcbffe2020-10-31 19:33:38 +0100958 {"extend", 2, 3, FEARG_1, arg23_extend,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200959 ret_first_arg, f_extend},
Bram Moolenaarb0e6b512021-01-12 20:23:40 +0100960 {"extendnew", 2, 3, FEARG_1, arg23_extendnew,
961 ret_first_cont, f_extendnew},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200962 {"feedkeys", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200963 ret_void, f_feedkeys},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200964 {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100965 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200966 {"filereadable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +0100967 ret_number_bool, f_filereadable},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200968 {"filewritable", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200969 ret_number, f_filewritable},
970 {"filter", 2, 2, FEARG_1, NULL,
971 ret_first_arg, f_filter},
972 {"finddir", 1, 3, FEARG_1, NULL,
973 ret_string, f_finddir},
974 {"findfile", 1, 3, FEARG_1, NULL,
975 ret_string, f_findfile},
976 {"flatten", 1, 2, FEARG_1, NULL,
977 ret_list_any, f_flatten},
Bram Moolenaar3b690062021-02-01 20:14:51 +0100978 {"flattennew", 1, 2, FEARG_1, NULL,
979 ret_list_any, f_flattennew},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200980 {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200981 ret_number, FLOAT_FUNC(f_float2nr)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200982 {"floor", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200983 ret_float, FLOAT_FUNC(f_floor)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +0200984 {"fmod", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200985 ret_float, FLOAT_FUNC(f_fmod)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200986 {"fnameescape", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200987 ret_string, f_fnameescape},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200988 {"fnamemodify", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200989 ret_string, f_fnamemodify},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200990 {"foldclosed", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200991 ret_number, f_foldclosed},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200992 {"foldclosedend", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200993 ret_number, f_foldclosedend},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200994 {"foldlevel", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200995 ret_number, f_foldlevel},
996 {"foldtext", 0, 0, 0, NULL,
997 ret_string, f_foldtext},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +0200998 {"foldtextresult", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +0200999 ret_string, f_foldtextresult},
1000 {"foreground", 0, 0, 0, NULL,
1001 ret_void, f_foreground},
Bram Moolenaar038e09e2021-02-06 12:38:51 +01001002 {"fullcommand", 1, 1, FEARG_1, arg1_string,
1003 ret_string, f_fullcommand},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001004 {"funcref", 1, 3, FEARG_1, NULL,
1005 ret_func_any, f_funcref},
1006 {"function", 1, 3, FEARG_1, NULL,
1007 ret_f_function, f_function},
1008 {"garbagecollect", 0, 1, 0, NULL,
1009 ret_void, f_garbagecollect},
1010 {"get", 2, 3, FEARG_1, NULL,
1011 ret_any, f_get},
1012 {"getbufinfo", 0, 1, FEARG_1, NULL,
1013 ret_list_dict_any, f_getbufinfo},
1014 {"getbufline", 2, 3, FEARG_1, NULL,
1015 ret_list_string, f_getbufline},
1016 {"getbufvar", 2, 3, FEARG_1, NULL,
1017 ret_any, f_getbufvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001018 {"getchangelist", 0, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001019 ret_list_any, f_getchangelist},
1020 {"getchar", 0, 1, 0, NULL,
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001021 ret_any, f_getchar},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001022 {"getcharmod", 0, 0, 0, NULL,
1023 ret_number, f_getcharmod},
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001024 {"getcharpos", 1, 1, FEARG_1, NULL,
1025 ret_list_number, f_getcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001026 {"getcharsearch", 0, 0, 0, NULL,
1027 ret_dict_any, f_getcharsearch},
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02001028 {"getcharstr", 0, 1, 0, NULL,
1029 ret_string, f_getcharstr},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001030 {"getcmdline", 0, 0, 0, NULL,
1031 ret_string, f_getcmdline},
1032 {"getcmdpos", 0, 0, 0, NULL,
1033 ret_number, f_getcmdpos},
1034 {"getcmdtype", 0, 0, 0, NULL,
1035 ret_string, f_getcmdtype},
1036 {"getcmdwintype", 0, 0, 0, NULL,
1037 ret_string, f_getcmdwintype},
1038 {"getcompletion", 2, 3, FEARG_1, NULL,
1039 ret_list_string, f_getcompletion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001040 {"getcurpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001041 ret_list_number, f_getcurpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001042 {"getcursorcharpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001043 ret_list_number, f_getcursorcharpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001044 {"getcwd", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001045 ret_string, f_getcwd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001046 {"getenv", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar7ad67d12021-03-10 16:08:26 +01001047 ret_any, f_getenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001048 {"getfontname", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001049 ret_string, f_getfontname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001050 {"getfperm", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001051 ret_string, f_getfperm},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001052 {"getfsize", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001053 ret_number, f_getfsize},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001054 {"getftime", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001055 ret_number, f_getftime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001056 {"getftype", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001057 ret_string, f_getftype},
1058 {"getimstatus", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001059 ret_number_bool, f_getimstatus},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001060 {"getjumplist", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001061 ret_list_any, f_getjumplist},
1062 {"getline", 1, 2, FEARG_1, NULL,
1063 ret_f_getline, f_getline},
1064 {"getloclist", 1, 2, 0, NULL,
1065 ret_list_or_dict_1, f_getloclist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001066 {"getmarklist", 0, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001067 ret_list_dict_any, f_getmarklist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001068 {"getmatches", 0, 1, 0, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001069 ret_list_dict_any, f_getmatches},
1070 {"getmousepos", 0, 0, 0, NULL,
1071 ret_dict_number, f_getmousepos},
1072 {"getpid", 0, 0, 0, NULL,
1073 ret_number, f_getpid},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001074 {"getpos", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001075 ret_list_number, f_getpos},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001076 {"getqflist", 0, 1, 0, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001077 ret_list_or_dict_0, f_getqflist},
1078 {"getreg", 0, 3, FEARG_1, NULL,
1079 ret_getreg, f_getreg},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001080 {"getreginfo", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001081 ret_dict_any, f_getreginfo},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001082 {"getregtype", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001083 ret_string, f_getregtype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001084 {"gettabinfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001085 ret_list_dict_any, f_gettabinfo},
1086 {"gettabvar", 2, 3, FEARG_1, NULL,
1087 ret_any, f_gettabvar},
1088 {"gettabwinvar", 3, 4, FEARG_1, NULL,
1089 ret_any, f_gettabwinvar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001090 {"gettagstack", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001091 ret_dict_any, f_gettagstack},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001092 {"gettext", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001093 ret_string, f_gettext},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001094 {"getwininfo", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001095 ret_list_dict_any, f_getwininfo},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001096 {"getwinpos", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001097 ret_list_number, f_getwinpos},
1098 {"getwinposx", 0, 0, 0, NULL,
1099 ret_number, f_getwinposx},
1100 {"getwinposy", 0, 0, 0, NULL,
1101 ret_number, f_getwinposy},
1102 {"getwinvar", 2, 3, FEARG_1, NULL,
1103 ret_any, f_getwinvar},
1104 {"glob", 1, 4, FEARG_1, NULL,
1105 ret_any, f_glob},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001106 {"glob2regpat", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001107 ret_string, f_glob2regpat},
1108 {"globpath", 2, 5, FEARG_2, NULL,
1109 ret_any, f_globpath},
1110 {"has", 1, 2, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001111 ret_number_bool, f_has},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001112 {"has_key", 2, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001113 ret_number_bool, f_has_key},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001114 {"haslocaldir", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001115 ret_number, f_haslocaldir},
1116 {"hasmapto", 1, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001117 ret_number_bool, f_hasmapto},
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001118 {"highlightID", 1, 1, FEARG_1, NULL, // obsolete
1119 ret_number, f_hlID},
1120 {"highlight_exists",1, 1, FEARG_1, NULL, // obsolete
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001121 ret_number_bool, f_hlexists},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001122 {"histadd", 2, 2, FEARG_2, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001123 ret_number_bool, f_histadd},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001124 {"histdel", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001125 ret_number_bool, f_histdel},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001126 {"histget", 1, 2, FEARG_1, NULL,
1127 ret_string, f_histget},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001128 {"histnr", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001129 ret_number, f_histnr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001130 {"hlID", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001131 ret_number, f_hlID},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001132 {"hlexists", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001133 ret_number_bool, f_hlexists},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001134 {"hostname", 0, 0, 0, NULL,
1135 ret_string, f_hostname},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001136 {"iconv", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001137 ret_string, f_iconv},
1138 {"indent", 1, 1, FEARG_1, NULL,
1139 ret_number, f_indent},
1140 {"index", 2, 4, FEARG_1, NULL,
1141 ret_number, f_index},
1142 {"input", 1, 3, FEARG_1, NULL,
1143 ret_string, f_input},
1144 {"inputdialog", 1, 3, FEARG_1, NULL,
1145 ret_string, f_inputdialog},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001146 {"inputlist", 1, 1, FEARG_1, arg1_string_list,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001147 ret_number, f_inputlist},
1148 {"inputrestore", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001149 ret_number_bool, f_inputrestore},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001150 {"inputsave", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001151 ret_number_bool, f_inputsave},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001152 {"inputsecret", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001153 ret_string, f_inputsecret},
Bram Moolenaarca174532020-10-21 16:42:22 +02001154 {"insert", 2, 3, FEARG_1, arg3_insert,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001155 ret_first_arg, f_insert},
1156 {"interrupt", 0, 0, 0, NULL,
1157 ret_void, f_interrupt},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001158 {"invert", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001159 ret_number, f_invert},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001160 {"isdirectory", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001161 ret_number_bool, f_isdirectory},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001162 {"isinf", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001163 ret_number, MATH_FUNC(f_isinf)},
1164 {"islocked", 1, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001165 ret_number_bool, f_islocked},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001166 {"isnan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001167 ret_number_bool, MATH_FUNC(f_isnan)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001168 {"items", 1, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001169 ret_list_any, f_items},
1170 {"job_getchannel", 1, 1, FEARG_1, NULL,
1171 ret_channel, JOB_FUNC(f_job_getchannel)},
1172 {"job_info", 0, 1, FEARG_1, NULL,
Bram Moolenaar64ed4d42021-01-12 21:22:31 +01001173 ret_job_info, JOB_FUNC(f_job_info)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001174 {"job_setoptions", 2, 2, FEARG_1, NULL,
1175 ret_void, JOB_FUNC(f_job_setoptions)},
1176 {"job_start", 1, 2, FEARG_1, NULL,
1177 ret_job, JOB_FUNC(f_job_start)},
1178 {"job_status", 1, 1, FEARG_1, NULL,
1179 ret_string, JOB_FUNC(f_job_status)},
1180 {"job_stop", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001181 ret_number_bool, JOB_FUNC(f_job_stop)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001182 {"join", 1, 2, FEARG_1, NULL,
1183 ret_string, f_join},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001184 {"js_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001185 ret_any, f_js_decode},
1186 {"js_encode", 1, 1, FEARG_1, NULL,
1187 ret_string, f_js_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001188 {"json_decode", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001189 ret_any, f_json_decode},
1190 {"json_encode", 1, 1, FEARG_1, NULL,
1191 ret_string, f_json_encode},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001192 {"keys", 1, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001193 ret_list_string, f_keys},
Bram Moolenaarb8f519e2020-10-21 14:49:08 +02001194 {"last_buffer_nr", 0, 0, 0, NULL, // obsolete
1195 ret_number, f_last_buffer_nr},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001196 {"len", 1, 1, FEARG_1, NULL,
1197 ret_number, f_len},
1198 {"libcall", 3, 3, FEARG_3, NULL,
1199 ret_string, f_libcall},
1200 {"libcallnr", 3, 3, FEARG_3, NULL,
1201 ret_number, f_libcallnr},
1202 {"line", 1, 2, FEARG_1, NULL,
1203 ret_number, f_line},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001204 {"line2byte", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001205 ret_number, f_line2byte},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001206 {"lispindent", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001207 ret_number, f_lispindent},
1208 {"list2str", 1, 2, FEARG_1, NULL,
1209 ret_string, f_list2str},
1210 {"listener_add", 1, 2, FEARG_2, NULL,
1211 ret_number, f_listener_add},
1212 {"listener_flush", 0, 1, FEARG_1, NULL,
1213 ret_void, f_listener_flush},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001214 {"listener_remove", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001215 ret_number_bool, f_listener_remove},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001216 {"localtime", 0, 0, 0, NULL,
1217 ret_number, f_localtime},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001218 {"log", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001219 ret_float, FLOAT_FUNC(f_log)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001220 {"log10", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001221 ret_float, FLOAT_FUNC(f_log10)},
1222 {"luaeval", 1, 2, FEARG_1, NULL,
1223 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001224#ifdef FEAT_LUA
Bram Moolenaar15c47602020-03-26 22:16:48 +01001225 f_luaeval
1226#else
1227 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001228#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001229 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001230 {"map", 2, 2, FEARG_1, NULL,
Bram Moolenaarea696852020-11-09 18:31:39 +01001231 ret_first_cont, f_map},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001232 {"maparg", 1, 4, FEARG_1, NULL,
1233 ret_maparg, f_maparg},
1234 {"mapcheck", 1, 3, FEARG_1, NULL,
1235 ret_string, f_mapcheck},
Bram Moolenaarea696852020-11-09 18:31:39 +01001236 {"mapnew", 2, 2, FEARG_1, NULL,
1237 ret_first_cont, f_mapnew},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001238 {"mapset", 3, 3, FEARG_1, NULL,
1239 ret_void, f_mapset},
1240 {"match", 2, 4, FEARG_1, NULL,
1241 ret_any, f_match},
1242 {"matchadd", 2, 5, FEARG_1, NULL,
1243 ret_number, f_matchadd},
1244 {"matchaddpos", 2, 5, FEARG_1, NULL,
1245 ret_number, f_matchaddpos},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001246 {"matcharg", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001247 ret_list_string, f_matcharg},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001248 {"matchdelete", 1, 2, FEARG_1, arg2_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001249 ret_number_bool, f_matchdelete},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001250 {"matchend", 2, 4, FEARG_1, NULL,
1251 ret_number, f_matchend},
1252 {"matchfuzzy", 2, 3, FEARG_1, NULL,
1253 ret_list_string, f_matchfuzzy},
1254 {"matchfuzzypos", 2, 3, FEARG_1, NULL,
1255 ret_list_any, f_matchfuzzypos},
1256 {"matchlist", 2, 4, FEARG_1, NULL,
1257 ret_list_string, f_matchlist},
1258 {"matchstr", 2, 4, FEARG_1, NULL,
1259 ret_string, f_matchstr},
1260 {"matchstrpos", 2, 4, FEARG_1, NULL,
1261 ret_list_any, f_matchstrpos},
1262 {"max", 1, 1, FEARG_1, NULL,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01001263 ret_number, f_max},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001264 {"menu_info", 1, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001265 ret_dict_any,
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01001266#ifdef FEAT_MENU
Bram Moolenaar15c47602020-03-26 22:16:48 +01001267 f_menu_info
1268#else
1269 NULL
Bram Moolenaara2cbdea2020-03-16 21:08:31 +01001270#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001271 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001272 {"min", 1, 1, FEARG_1, NULL,
Bram Moolenaar9ae37052021-01-22 22:31:10 +01001273 ret_number, f_min},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001274 {"mkdir", 1, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001275 ret_number_bool, f_mkdir},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001276 {"mode", 0, 1, FEARG_1, NULL,
1277 ret_string, f_mode},
1278 {"mzeval", 1, 1, FEARG_1, NULL,
1279 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001280#ifdef FEAT_MZSCHEME
Bram Moolenaar15c47602020-03-26 22:16:48 +01001281 f_mzeval
1282#else
1283 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001284#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001285 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001286 {"nextnonblank", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001287 ret_number, f_nextnonblank},
1288 {"nr2char", 1, 2, FEARG_1, NULL,
1289 ret_string, f_nr2char},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001290 {"or", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001291 ret_number, f_or},
1292 {"pathshorten", 1, 2, FEARG_1, NULL,
1293 ret_string, f_pathshorten},
1294 {"perleval", 1, 1, FEARG_1, NULL,
1295 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001296#ifdef FEAT_PERL
Bram Moolenaar15c47602020-03-26 22:16:48 +01001297 f_perleval
1298#else
1299 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001300#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001301 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001302 {"popup_atcursor", 2, 2, FEARG_1, NULL,
1303 ret_number, PROP_FUNC(f_popup_atcursor)},
1304 {"popup_beval", 2, 2, FEARG_1, NULL,
1305 ret_number, PROP_FUNC(f_popup_beval)},
1306 {"popup_clear", 0, 1, 0, NULL,
1307 ret_void, PROP_FUNC(f_popup_clear)},
1308 {"popup_close", 1, 2, FEARG_1, NULL,
1309 ret_void, PROP_FUNC(f_popup_close)},
1310 {"popup_create", 2, 2, FEARG_1, NULL,
1311 ret_number, PROP_FUNC(f_popup_create)},
1312 {"popup_dialog", 2, 2, FEARG_1, NULL,
1313 ret_number, PROP_FUNC(f_popup_dialog)},
1314 {"popup_filter_menu", 2, 2, 0, NULL,
1315 ret_bool, PROP_FUNC(f_popup_filter_menu)},
1316 {"popup_filter_yesno", 2, 2, 0, NULL,
1317 ret_bool, PROP_FUNC(f_popup_filter_yesno)},
1318 {"popup_findinfo", 0, 0, 0, NULL,
1319 ret_number, PROP_FUNC(f_popup_findinfo)},
1320 {"popup_findpreview", 0, 0, 0, NULL,
1321 ret_number, PROP_FUNC(f_popup_findpreview)},
1322 {"popup_getoptions", 1, 1, FEARG_1, NULL,
1323 ret_dict_any, PROP_FUNC(f_popup_getoptions)},
1324 {"popup_getpos", 1, 1, FEARG_1, NULL,
1325 ret_dict_any, PROP_FUNC(f_popup_getpos)},
1326 {"popup_hide", 1, 1, FEARG_1, NULL,
1327 ret_void, PROP_FUNC(f_popup_hide)},
1328 {"popup_list", 0, 0, 0, NULL,
1329 ret_list_number, PROP_FUNC(f_popup_list)},
1330 {"popup_locate", 2, 2, 0, NULL,
1331 ret_number, PROP_FUNC(f_popup_locate)},
1332 {"popup_menu", 2, 2, FEARG_1, NULL,
1333 ret_number, PROP_FUNC(f_popup_menu)},
1334 {"popup_move", 2, 2, FEARG_1, NULL,
1335 ret_void, PROP_FUNC(f_popup_move)},
1336 {"popup_notification", 2, 2, FEARG_1, NULL,
1337 ret_number, PROP_FUNC(f_popup_notification)},
1338 {"popup_setoptions", 2, 2, FEARG_1, NULL,
1339 ret_void, PROP_FUNC(f_popup_setoptions)},
1340 {"popup_settext", 2, 2, FEARG_1, NULL,
1341 ret_void, PROP_FUNC(f_popup_settext)},
1342 {"popup_show", 1, 1, FEARG_1, NULL,
1343 ret_void, PROP_FUNC(f_popup_show)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001344 {"pow", 2, 2, FEARG_1, arg2_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001345 ret_float, FLOAT_FUNC(f_pow)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001346 {"prevnonblank", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001347 ret_number, f_prevnonblank},
1348 {"printf", 1, 19, FEARG_2, NULL,
1349 ret_string, f_printf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001350 {"prompt_getprompt", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001351 ret_string, JOB_FUNC(f_prompt_getprompt)},
1352 {"prompt_setcallback", 2, 2, FEARG_1, NULL,
1353 ret_void, JOB_FUNC(f_prompt_setcallback)},
1354 {"prompt_setinterrupt", 2, 2, FEARG_1, NULL,
1355 ret_void, JOB_FUNC(f_prompt_setinterrupt)},
1356 {"prompt_setprompt", 2, 2, FEARG_1, NULL,
1357 ret_void, JOB_FUNC(f_prompt_setprompt)},
1358 {"prop_add", 3, 3, FEARG_1, NULL,
1359 ret_void, PROP_FUNC(f_prop_add)},
1360 {"prop_clear", 1, 3, FEARG_1, NULL,
1361 ret_void, PROP_FUNC(f_prop_clear)},
1362 {"prop_find", 1, 2, FEARG_1, NULL,
1363 ret_dict_any, PROP_FUNC(f_prop_find)},
1364 {"prop_list", 1, 2, FEARG_1, NULL,
1365 ret_list_dict_any, PROP_FUNC(f_prop_list)},
1366 {"prop_remove", 1, 3, FEARG_1, NULL,
1367 ret_number, PROP_FUNC(f_prop_remove)},
1368 {"prop_type_add", 2, 2, FEARG_1, NULL,
1369 ret_void, PROP_FUNC(f_prop_type_add)},
1370 {"prop_type_change", 2, 2, FEARG_1, NULL,
1371 ret_void, PROP_FUNC(f_prop_type_change)},
1372 {"prop_type_delete", 1, 2, FEARG_1, NULL,
1373 ret_void, PROP_FUNC(f_prop_type_delete)},
1374 {"prop_type_get", 1, 2, FEARG_1, NULL,
1375 ret_dict_any, PROP_FUNC(f_prop_type_get)},
1376 {"prop_type_list", 0, 1, FEARG_1, NULL,
1377 ret_list_string, PROP_FUNC(f_prop_type_list)},
1378 {"pum_getpos", 0, 0, 0, NULL,
1379 ret_dict_number, f_pum_getpos},
1380 {"pumvisible", 0, 0, 0, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001381 ret_number_bool, f_pumvisible},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001382 {"py3eval", 1, 1, FEARG_1, NULL,
1383 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001384#ifdef FEAT_PYTHON3
Bram Moolenaar15c47602020-03-26 22:16:48 +01001385 f_py3eval
1386#else
1387 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001388#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001389 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001390 {"pyeval", 1, 1, FEARG_1, NULL,
1391 ret_any,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001392#ifdef FEAT_PYTHON
Bram Moolenaar15c47602020-03-26 22:16:48 +01001393 f_pyeval
1394#else
1395 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001396#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001397 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001398 {"pyxeval", 1, 1, FEARG_1, NULL,
1399 ret_any,
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01001400#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar15c47602020-03-26 22:16:48 +01001401 f_pyxeval
1402#else
1403 NULL
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01001404#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001405 },
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001406 {"rand", 0, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001407 ret_number, f_rand},
1408 {"range", 1, 3, FEARG_1, NULL,
1409 ret_list_number, f_range},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001410 {"readblob", 1, 1, FEARG_1, arg1_string,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01001411 ret_blob, f_readblob},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001412 {"readdir", 1, 3, FEARG_1, NULL,
1413 ret_list_string, f_readdir},
1414 {"readdirex", 1, 3, FEARG_1, NULL,
1415 ret_list_dict_any, f_readdirex},
1416 {"readfile", 1, 3, FEARG_1, NULL,
Bram Moolenaarc423ad72021-01-13 20:38:03 +01001417 ret_list_string, f_readfile},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001418 {"reduce", 2, 3, FEARG_1, NULL,
1419 ret_any, f_reduce},
1420 {"reg_executing", 0, 0, 0, NULL,
1421 ret_string, f_reg_executing},
1422 {"reg_recording", 0, 0, 0, NULL,
1423 ret_string, f_reg_recording},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001424 {"reltime", 0, 2, FEARG_1, arg2_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001425 ret_list_any, f_reltime},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001426 {"reltimefloat", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001427 ret_float, FLOAT_FUNC(f_reltimefloat)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001428 {"reltimestr", 1, 1, FEARG_1, arg1_list_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001429 ret_string, f_reltimestr},
1430 {"remote_expr", 2, 4, FEARG_1, NULL,
1431 ret_string, f_remote_expr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001432 {"remote_foreground", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001433 ret_string, f_remote_foreground},
1434 {"remote_peek", 1, 2, FEARG_1, NULL,
1435 ret_number, f_remote_peek},
1436 {"remote_read", 1, 2, FEARG_1, NULL,
1437 ret_string, f_remote_read},
1438 {"remote_send", 2, 3, FEARG_1, NULL,
1439 ret_string, f_remote_send},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001440 {"remote_startserver", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001441 ret_void, f_remote_startserver},
1442 {"remove", 2, 3, FEARG_1, NULL,
1443 ret_remove, f_remove},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001444 {"rename", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001445 ret_number_bool, f_rename},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001446 {"repeat", 2, 2, FEARG_1, NULL,
1447 ret_first_arg, f_repeat},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001448 {"resolve", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001449 ret_string, f_resolve},
1450 {"reverse", 1, 1, FEARG_1, NULL,
1451 ret_first_arg, f_reverse},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001452 {"round", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001453 ret_float, FLOAT_FUNC(f_round)},
1454 {"rubyeval", 1, 1, FEARG_1, NULL,
1455 ret_any,
Bram Moolenaare99be0e2019-03-26 22:51:09 +01001456#ifdef FEAT_RUBY
Bram Moolenaar15c47602020-03-26 22:16:48 +01001457 f_rubyeval
1458#else
1459 NULL
Bram Moolenaare99be0e2019-03-26 22:51:09 +01001460#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001461 },
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001462 {"screenattr", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001463 ret_number, f_screenattr},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001464 {"screenchar", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001465 ret_number, f_screenchar},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001466 {"screenchars", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001467 ret_list_number, f_screenchars},
1468 {"screencol", 0, 0, 0, NULL,
1469 ret_number, f_screencol},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001470 {"screenpos", 3, 3, FEARG_1, arg3_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001471 ret_dict_number, f_screenpos},
1472 {"screenrow", 0, 0, 0, NULL,
1473 ret_number, f_screenrow},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001474 {"screenstring", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001475 ret_string, f_screenstring},
1476 {"search", 1, 5, FEARG_1, NULL,
1477 ret_number, f_search},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001478 {"searchcount", 0, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001479 ret_dict_any, f_searchcount},
1480 {"searchdecl", 1, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001481 ret_number_bool, f_searchdecl},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001482 {"searchpair", 3, 7, 0, NULL,
1483 ret_number, f_searchpair},
1484 {"searchpairpos", 3, 7, 0, NULL,
1485 ret_list_number, f_searchpairpos},
1486 {"searchpos", 1, 5, FEARG_1, NULL,
1487 ret_list_number, f_searchpos},
1488 {"server2client", 2, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001489 ret_number_bool, f_server2client},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001490 {"serverlist", 0, 0, 0, NULL,
1491 ret_string, f_serverlist},
1492 {"setbufline", 3, 3, FEARG_3, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001493 ret_number_bool, f_setbufline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001494 {"setbufvar", 3, 3, FEARG_3, NULL,
1495 ret_void, f_setbufvar},
1496 {"setcellwidths", 1, 1, FEARG_1, NULL,
1497 ret_void, f_setcellwidths},
Bram Moolenaar6f02b002021-01-10 20:22:54 +01001498 {"setcharpos", 2, 2, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001499 ret_number_bool, f_setcharpos},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001500 {"setcharsearch", 1, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001501 ret_void, f_setcharsearch},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001502 {"setcmdpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001503 ret_number_bool, f_setcmdpos},
1504 {"setcursorcharpos", 1, 3, FEARG_1, NULL,
1505 ret_number_bool, f_setcursorcharpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001506 {"setenv", 2, 2, FEARG_2, NULL,
1507 ret_void, f_setenv},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001508 {"setfperm", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001509 ret_number_bool, f_setfperm},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001510 {"setline", 2, 2, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001511 ret_number_bool, f_setline},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001512 {"setloclist", 2, 4, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001513 ret_number_bool, f_setloclist},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001514 {"setmatches", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001515 ret_number_bool, f_setmatches},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001516 {"setpos", 2, 2, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001517 ret_number_bool, f_setpos},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001518 {"setqflist", 1, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001519 ret_number_bool, f_setqflist},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001520 {"setreg", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001521 ret_number_bool, f_setreg},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001522 {"settabvar", 3, 3, FEARG_3, NULL,
1523 ret_void, f_settabvar},
1524 {"settabwinvar", 4, 4, FEARG_4, NULL,
1525 ret_void, f_settabwinvar},
1526 {"settagstack", 2, 3, FEARG_2, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001527 ret_number_bool, f_settagstack},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001528 {"setwinvar", 3, 3, FEARG_3, NULL,
1529 ret_void, f_setwinvar},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001530 {"sha256", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001531 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001532#ifdef FEAT_CRYPT
Bram Moolenaar15c47602020-03-26 22:16:48 +01001533 f_sha256
1534#else
1535 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001536#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001537 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001538 {"shellescape", 1, 2, FEARG_1, NULL,
1539 ret_string, f_shellescape},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001540 {"shiftwidth", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001541 ret_number, f_shiftwidth},
1542 {"sign_define", 1, 2, FEARG_1, NULL,
1543 ret_any, SIGN_FUNC(f_sign_define)},
1544 {"sign_getdefined", 0, 1, FEARG_1, NULL,
1545 ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)},
1546 {"sign_getplaced", 0, 2, FEARG_1, NULL,
1547 ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)},
1548 {"sign_jump", 3, 3, FEARG_1, NULL,
1549 ret_number, SIGN_FUNC(f_sign_jump)},
1550 {"sign_place", 4, 5, FEARG_1, NULL,
1551 ret_number, SIGN_FUNC(f_sign_place)},
1552 {"sign_placelist", 1, 1, FEARG_1, NULL,
1553 ret_list_number, SIGN_FUNC(f_sign_placelist)},
1554 {"sign_undefine", 0, 1, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001555 ret_number_bool, SIGN_FUNC(f_sign_undefine)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001556 {"sign_unplace", 1, 2, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001557 ret_number_bool, SIGN_FUNC(f_sign_unplace)},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001558 {"sign_unplacelist", 1, 2, FEARG_1, NULL,
1559 ret_list_number, SIGN_FUNC(f_sign_unplacelist)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001560 {"simplify", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001561 ret_string, f_simplify},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001562 {"sin", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001563 ret_float, FLOAT_FUNC(f_sin)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001564 {"sinh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001565 ret_float, FLOAT_FUNC(f_sinh)},
Bram Moolenaar6601b622021-01-13 21:47:15 +01001566 {"slice", 2, 3, FEARG_1, NULL,
1567 ret_first_arg, f_slice},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001568 {"sort", 1, 3, FEARG_1, NULL,
1569 ret_first_arg, f_sort},
1570 {"sound_clear", 0, 0, 0, NULL,
1571 ret_void, SOUND_FUNC(f_sound_clear)},
1572 {"sound_playevent", 1, 2, FEARG_1, NULL,
1573 ret_number, SOUND_FUNC(f_sound_playevent)},
1574 {"sound_playfile", 1, 2, FEARG_1, NULL,
1575 ret_number, SOUND_FUNC(f_sound_playfile)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001576 {"sound_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001577 ret_void, SOUND_FUNC(f_sound_stop)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001578 {"soundfold", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001579 ret_string, f_soundfold},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001580 {"spellbadword", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001581 ret_list_string, f_spellbadword},
1582 {"spellsuggest", 1, 3, FEARG_1, NULL,
1583 ret_list_string, f_spellsuggest},
1584 {"split", 1, 3, FEARG_1, NULL,
1585 ret_list_string, f_split},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001586 {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001587 ret_float, FLOAT_FUNC(f_sqrt)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001588 {"srand", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001589 ret_list_number, f_srand},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001590 {"state", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001591 ret_string, f_state},
Bram Moolenaar80ad3e22021-01-31 20:48:58 +01001592 {"str2float", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001593 ret_float, FLOAT_FUNC(f_str2float)},
1594 {"str2list", 1, 2, FEARG_1, NULL,
1595 ret_list_number, f_str2list},
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +01001596 {"str2nr", 1, 3, FEARG_1, arg3_string_nr_bool,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001597 ret_number, f_str2nr},
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01001598 {"strcharlen", 1, 1, FEARG_1, NULL,
1599 ret_number, f_strcharlen},
Bram Moolenaar02b4d9b2021-03-14 19:46:45 +01001600 {"strcharpart", 2, 4, FEARG_1, NULL,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001601 ret_string, f_strcharpart},
1602 {"strchars", 1, 2, FEARG_1, NULL,
1603 ret_number, f_strchars},
1604 {"strdisplaywidth", 1, 2, FEARG_1, NULL,
1605 ret_number, f_strdisplaywidth},
1606 {"strftime", 1, 2, FEARG_1, NULL,
1607 ret_string,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001608#ifdef HAVE_STRFTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01001609 f_strftime
1610#else
1611 NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001612#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001613 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001614 {"strgetchar", 2, 2, FEARG_1, NULL,
1615 ret_number, f_strgetchar},
1616 {"stridx", 2, 3, FEARG_1, NULL,
1617 ret_number, f_stridx},
1618 {"string", 1, 1, FEARG_1, NULL,
1619 ret_string, f_string},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001620 {"strlen", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001621 ret_number, f_strlen},
1622 {"strpart", 2, 4, FEARG_1, NULL,
1623 ret_string, f_strpart},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001624 {"strptime", 2, 2, FEARG_1, arg2_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001625 ret_number,
Bram Moolenaar10455d42019-11-21 15:36:18 +01001626#ifdef HAVE_STRPTIME
Bram Moolenaar15c47602020-03-26 22:16:48 +01001627 f_strptime
1628#else
1629 NULL
Bram Moolenaar10455d42019-11-21 15:36:18 +01001630#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001631 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001632 {"strridx", 2, 3, FEARG_1, NULL,
1633 ret_number, f_strridx},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001634 {"strtrans", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001635 ret_string, f_strtrans},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001636 {"strwidth", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001637 ret_number, f_strwidth},
1638 {"submatch", 1, 2, FEARG_1, NULL,
1639 ret_string, f_submatch},
1640 {"substitute", 4, 4, FEARG_1, NULL,
1641 ret_string, f_substitute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001642 {"swapinfo", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001643 ret_dict_any, f_swapinfo},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001644 {"swapname", 1, 1, FEARG_1, arg1_string_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001645 ret_string, f_swapname},
1646 {"synID", 3, 3, 0, NULL,
1647 ret_number, f_synID},
1648 {"synIDattr", 2, 3, FEARG_1, NULL,
1649 ret_string, f_synIDattr},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001650 {"synIDtrans", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001651 ret_number, f_synIDtrans},
1652 {"synconcealed", 2, 2, 0, NULL,
1653 ret_list_any, f_synconcealed},
1654 {"synstack", 2, 2, 0, NULL,
1655 ret_list_number, f_synstack},
1656 {"system", 1, 2, FEARG_1, NULL,
1657 ret_string, f_system},
1658 {"systemlist", 1, 2, FEARG_1, NULL,
1659 ret_list_string, f_systemlist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001660 {"tabpagebuflist", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001661 ret_list_number, f_tabpagebuflist},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001662 {"tabpagenr", 0, 1, 0, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001663 ret_number, f_tabpagenr},
1664 {"tabpagewinnr", 1, 2, FEARG_1, NULL,
1665 ret_number, f_tabpagewinnr},
1666 {"tagfiles", 0, 0, 0, NULL,
1667 ret_list_string, f_tagfiles},
1668 {"taglist", 1, 2, FEARG_1, NULL,
1669 ret_list_dict_any, f_taglist},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001670 {"tan", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001671 ret_float, FLOAT_FUNC(f_tan)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001672 {"tanh", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001673 ret_float, FLOAT_FUNC(f_tanh)},
1674 {"tempname", 0, 0, 0, NULL,
1675 ret_string, f_tempname},
1676 {"term_dumpdiff", 2, 3, FEARG_1, NULL,
1677 ret_number, TERM_FUNC(f_term_dumpdiff)},
1678 {"term_dumpload", 1, 2, FEARG_1, NULL,
1679 ret_number, TERM_FUNC(f_term_dumpload)},
1680 {"term_dumpwrite", 2, 3, FEARG_2, NULL,
1681 ret_void, TERM_FUNC(f_term_dumpwrite)},
1682 {"term_getaltscreen", 1, 1, FEARG_1, NULL,
1683 ret_number, TERM_FUNC(f_term_getaltscreen)},
1684 {"term_getansicolors", 1, 1, FEARG_1, NULL,
1685 ret_list_string,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01001686#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01001687 f_term_getansicolors
1688#else
1689 NULL
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02001690#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001691 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001692 {"term_getattr", 2, 2, FEARG_1, NULL,
1693 ret_number, TERM_FUNC(f_term_getattr)},
1694 {"term_getcursor", 1, 1, FEARG_1, NULL,
1695 ret_list_any, TERM_FUNC(f_term_getcursor)},
1696 {"term_getjob", 1, 1, FEARG_1, NULL,
1697 ret_job, TERM_FUNC(f_term_getjob)},
1698 {"term_getline", 2, 2, FEARG_1, NULL,
1699 ret_string, TERM_FUNC(f_term_getline)},
1700 {"term_getscrolled", 1, 1, FEARG_1, NULL,
1701 ret_number, TERM_FUNC(f_term_getscrolled)},
1702 {"term_getsize", 1, 1, FEARG_1, NULL,
1703 ret_list_number, TERM_FUNC(f_term_getsize)},
1704 {"term_getstatus", 1, 1, FEARG_1, NULL,
1705 ret_string, TERM_FUNC(f_term_getstatus)},
1706 {"term_gettitle", 1, 1, FEARG_1, NULL,
1707 ret_string, TERM_FUNC(f_term_gettitle)},
1708 {"term_gettty", 1, 2, FEARG_1, NULL,
1709 ret_string, TERM_FUNC(f_term_gettty)},
1710 {"term_list", 0, 0, 0, NULL,
1711 ret_list_number, TERM_FUNC(f_term_list)},
1712 {"term_scrape", 2, 2, FEARG_1, NULL,
1713 ret_list_dict_any, TERM_FUNC(f_term_scrape)},
1714 {"term_sendkeys", 2, 2, FEARG_1, NULL,
1715 ret_void, TERM_FUNC(f_term_sendkeys)},
1716 {"term_setansicolors", 2, 2, FEARG_1, NULL,
1717 ret_void,
Bram Moolenaarbd5e6222020-03-26 23:13:34 +01001718#if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
Bram Moolenaar15c47602020-03-26 22:16:48 +01001719 f_term_setansicolors
1720#else
1721 NULL
1722#endif
1723 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001724 {"term_setapi", 2, 2, FEARG_1, NULL,
1725 ret_void, TERM_FUNC(f_term_setapi)},
1726 {"term_setkill", 2, 2, FEARG_1, NULL,
1727 ret_void, TERM_FUNC(f_term_setkill)},
1728 {"term_setrestore", 2, 2, FEARG_1, NULL,
1729 ret_void, TERM_FUNC(f_term_setrestore)},
1730 {"term_setsize", 3, 3, FEARG_1, NULL,
1731 ret_void, TERM_FUNC(f_term_setsize)},
1732 {"term_start", 1, 2, FEARG_1, NULL,
1733 ret_number, TERM_FUNC(f_term_start)},
1734 {"term_wait", 1, 2, FEARG_1, NULL,
1735 ret_void, TERM_FUNC(f_term_wait)},
1736 {"terminalprops", 0, 0, 0, NULL,
1737 ret_dict_string, f_terminalprops},
1738 {"test_alloc_fail", 3, 3, FEARG_1, NULL,
1739 ret_void, f_test_alloc_fail},
1740 {"test_autochdir", 0, 0, 0, NULL,
1741 ret_void, f_test_autochdir},
1742 {"test_feedinput", 1, 1, FEARG_1, NULL,
1743 ret_void, f_test_feedinput},
1744 {"test_garbagecollect_now", 0, 0, 0, NULL,
1745 ret_void, f_test_garbagecollect_now},
1746 {"test_garbagecollect_soon", 0, 0, 0, NULL,
1747 ret_void, f_test_garbagecollect_soon},
1748 {"test_getvalue", 1, 1, FEARG_1, NULL,
1749 ret_number, f_test_getvalue},
Yegappan Lakshmanan18d46582021-06-23 20:46:52 +02001750 {"test_gui_drop_files", 4, 4, 0, NULL,
1751 ret_void, f_test_gui_drop_files},
Yegappan Lakshmananf1e74492021-06-21 18:44:26 +02001752 {"test_gui_mouse_event", 5, 5, 0, NULL,
1753 ret_void, f_test_gui_mouse_event},
Bram Moolenaar94738d82020-10-21 14:25:07 +02001754 {"test_ignore_error", 1, 1, FEARG_1, NULL,
1755 ret_void, f_test_ignore_error},
1756 {"test_null_blob", 0, 0, 0, NULL,
1757 ret_blob, f_test_null_blob},
1758 {"test_null_channel", 0, 0, 0, NULL,
1759 ret_channel, JOB_FUNC(f_test_null_channel)},
1760 {"test_null_dict", 0, 0, 0, NULL,
1761 ret_dict_any, f_test_null_dict},
1762 {"test_null_function", 0, 0, 0, NULL,
1763 ret_func_any, f_test_null_function},
1764 {"test_null_job", 0, 0, 0, NULL,
1765 ret_job, JOB_FUNC(f_test_null_job)},
1766 {"test_null_list", 0, 0, 0, NULL,
1767 ret_list_any, f_test_null_list},
1768 {"test_null_partial", 0, 0, 0, NULL,
1769 ret_func_any, f_test_null_partial},
1770 {"test_null_string", 0, 0, 0, NULL,
1771 ret_string, f_test_null_string},
1772 {"test_option_not_set", 1, 1, FEARG_1, NULL,
1773 ret_void, f_test_option_not_set},
1774 {"test_override", 2, 2, FEARG_2, NULL,
1775 ret_void, f_test_override},
1776 {"test_refcount", 1, 1, FEARG_1, NULL,
1777 ret_number, f_test_refcount},
1778 {"test_scrollbar", 3, 3, FEARG_2, NULL,
1779 ret_void,
Bram Moolenaarab186732018-09-14 21:27:06 +02001780#ifdef FEAT_GUI
Bram Moolenaar15c47602020-03-26 22:16:48 +01001781 f_test_scrollbar
1782#else
1783 NULL
Bram Moolenaarab186732018-09-14 21:27:06 +02001784#endif
Bram Moolenaar15c47602020-03-26 22:16:48 +01001785 },
Bram Moolenaar94738d82020-10-21 14:25:07 +02001786 {"test_setmouse", 2, 2, 0, NULL,
1787 ret_void, f_test_setmouse},
1788 {"test_settime", 1, 1, FEARG_1, NULL,
1789 ret_void, f_test_settime},
1790 {"test_srand_seed", 0, 1, FEARG_1, NULL,
1791 ret_void, f_test_srand_seed},
1792 {"test_unknown", 0, 0, 0, NULL,
1793 ret_any, f_test_unknown},
1794 {"test_void", 0, 0, 0, NULL,
1795 ret_void, f_test_void},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001796 {"timer_info", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001797 ret_list_dict_any, TIMER_FUNC(f_timer_info)},
1798 {"timer_pause", 2, 2, FEARG_1, NULL,
1799 ret_void, TIMER_FUNC(f_timer_pause)},
1800 {"timer_start", 2, 3, FEARG_1, NULL,
1801 ret_number, TIMER_FUNC(f_timer_start)},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001802 {"timer_stop", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001803 ret_void, TIMER_FUNC(f_timer_stop)},
1804 {"timer_stopall", 0, 0, 0, NULL,
1805 ret_void, TIMER_FUNC(f_timer_stopall)},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001806 {"tolower", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001807 ret_string, f_tolower},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001808 {"toupper", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001809 ret_string, f_toupper},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001810 {"tr", 3, 3, FEARG_1, arg3_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001811 ret_string, f_tr},
1812 {"trim", 1, 3, FEARG_1, NULL,
1813 ret_string, f_trim},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001814 {"trunc", 1, 1, FEARG_1, arg1_float_or_nr,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001815 ret_float, FLOAT_FUNC(f_trunc)},
1816 {"type", 1, 1, FEARG_1, NULL,
1817 ret_number, f_type},
Bram Moolenaara47e05f2021-01-12 21:49:00 +01001818 {"typename", 1, 1, FEARG_1, NULL,
1819 ret_string, f_typename},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001820 {"undofile", 1, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001821 ret_string, f_undofile},
1822 {"undotree", 0, 0, 0, NULL,
1823 ret_dict_any, f_undotree},
1824 {"uniq", 1, 3, FEARG_1, NULL,
1825 ret_list_any, f_uniq},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001826 {"values", 1, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001827 ret_list_any, f_values},
1828 {"virtcol", 1, 1, FEARG_1, NULL,
1829 ret_number, f_virtcol},
1830 {"visualmode", 0, 1, 0, NULL,
1831 ret_string, f_visualmode},
1832 {"wildmenumode", 0, 0, 0, NULL,
1833 ret_number, f_wildmenumode},
1834 {"win_execute", 2, 3, FEARG_2, NULL,
1835 ret_string, f_win_execute},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001836 {"win_findbuf", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001837 ret_list_number, f_win_findbuf},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001838 {"win_getid", 0, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001839 ret_number, f_win_getid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001840 {"win_gettype", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001841 ret_string, f_win_gettype},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001842 {"win_gotoid", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001843 ret_number_bool, f_win_gotoid},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001844 {"win_id2tabwin", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001845 ret_list_number, f_win_id2tabwin},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001846 {"win_id2win", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001847 ret_number, f_win_id2win},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001848 {"win_screenpos", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001849 ret_list_number, f_win_screenpos},
1850 {"win_splitmove", 2, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001851 ret_number_bool, f_win_splitmove},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001852 {"winbufnr", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001853 ret_number, f_winbufnr},
1854 {"wincol", 0, 0, 0, NULL,
1855 ret_number, f_wincol},
1856 {"windowsversion", 0, 0, 0, NULL,
1857 ret_string, f_windowsversion},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001858 {"winheight", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001859 ret_number, f_winheight},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001860 {"winlayout", 0, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001861 ret_list_any, f_winlayout},
1862 {"winline", 0, 0, 0, NULL,
1863 ret_number, f_winline},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001864 {"winnr", 0, 1, FEARG_1, arg1_string,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001865 ret_number, f_winnr},
1866 {"winrestcmd", 0, 0, 0, NULL,
1867 ret_string, f_winrestcmd},
Yegappan Lakshmanana26f56f2021-07-03 11:58:12 +02001868 {"winrestview", 1, 1, FEARG_1, arg1_dict,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001869 ret_void, f_winrestview},
1870 {"winsaveview", 0, 0, 0, NULL,
Bram Moolenaar43b69b32021-01-07 20:23:33 +01001871 ret_dict_number, f_winsaveview},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001872 {"winwidth", 1, 1, FEARG_1, arg1_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001873 ret_number, f_winwidth},
1874 {"wordcount", 0, 0, 0, NULL,
1875 ret_dict_number, f_wordcount},
1876 {"writefile", 2, 3, FEARG_1, NULL,
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01001877 ret_number_bool, f_writefile},
Yegappan Lakshmanan7237cab2021-06-22 19:52:27 +02001878 {"xor", 2, 2, FEARG_1, arg2_number,
Bram Moolenaar94738d82020-10-21 14:25:07 +02001879 ret_number, f_xor},
Bram Moolenaarac92e252019-08-03 21:58:38 +02001880};
1881
K.Takataeecf2b32021-06-02 14:56:39 +02001882#if defined(EBCDIC) || defined(PROTO)
1883/*
1884 * Compare funcentry_T by function name.
1885 */
1886 static int
1887compare_func_name(const void *s1, const void *s2)
1888{
1889 funcentry_T *p1 = (funcentry_T *)s1;
1890 funcentry_T *p2 = (funcentry_T *)s2;
1891
1892 return STRCMP(p1->f_name, p2->f_name);
1893}
1894
1895/*
1896 * Sort the function table by function name.
1897 * The sorting of the table above is ASCII dependent.
1898 * On machines using EBCDIC we have to sort it.
1899 */
1900 void
1901sortFunctions(void)
1902{
1903 size_t funcCnt = ARRAY_LENGTH(global_functions);
1904
1905 qsort(global_functions, funcCnt, sizeof(funcentry_T), compare_func_name);
1906}
1907#endif
1908
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001909/*
1910 * Function given to ExpandGeneric() to obtain the list of internal
1911 * or user defined function names.
1912 */
1913 char_u *
1914get_function_name(expand_T *xp, int idx)
1915{
1916 static int intidx = -1;
1917 char_u *name;
1918
1919 if (idx == 0)
1920 intidx = -1;
1921 if (intidx < 0)
1922 {
1923 name = get_user_func_name(xp, idx);
1924 if (name != NULL)
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01001925 {
1926 if (*name != '<' && STRNCMP("g:", xp->xp_pattern, 2) == 0)
1927 return cat_prefix_varname('g', name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001928 return name;
Bram Moolenaar1bb4de52021-01-13 19:48:46 +01001929 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001930 }
K.Takataeeec2542021-06-02 13:28:16 +02001931 if (++intidx < (int)ARRAY_LENGTH(global_functions))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001932 {
Bram Moolenaarac92e252019-08-03 21:58:38 +02001933 STRCPY(IObuff, global_functions[intidx].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001934 STRCAT(IObuff, "(");
Bram Moolenaarac92e252019-08-03 21:58:38 +02001935 if (global_functions[intidx].f_max_argc == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001936 STRCAT(IObuff, ")");
1937 return IObuff;
1938 }
1939
1940 return NULL;
1941}
1942
1943/*
1944 * Function given to ExpandGeneric() to obtain the list of internal or
1945 * user defined variable or function names.
1946 */
1947 char_u *
1948get_expr_name(expand_T *xp, int idx)
1949{
1950 static int intidx = -1;
1951 char_u *name;
1952
1953 if (idx == 0)
1954 intidx = -1;
1955 if (intidx < 0)
1956 {
1957 name = get_function_name(xp, idx);
1958 if (name != NULL)
1959 return name;
1960 }
1961 return get_user_var_name(xp, ++intidx);
1962}
1963
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001964/*
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001965 * Find internal function "name" in table "global_functions".
Bram Moolenaar15c47602020-03-26 22:16:48 +01001966 * Return index, or -1 if not found or "implemented" is TRUE and the function
1967 * is not implemented.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001968 */
Bram Moolenaar15c47602020-03-26 22:16:48 +01001969 static int
1970find_internal_func_opt(char_u *name, int implemented)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001971{
1972 int first = 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02001973 int last;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001974 int cmp;
1975 int x;
1976
K.Takataeeec2542021-06-02 13:28:16 +02001977 last = (int)ARRAY_LENGTH(global_functions) - 1;
Bram Moolenaarac92e252019-08-03 21:58:38 +02001978
1979 // Find the function name in the table. Binary search.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001980 while (first <= last)
1981 {
1982 x = first + ((unsigned)(last - first) >> 1);
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02001983 cmp = STRCMP(name, global_functions[x].f_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001984 if (cmp < 0)
1985 last = x - 1;
1986 else if (cmp > 0)
1987 first = x + 1;
Bram Moolenaar15c47602020-03-26 22:16:48 +01001988 else if (implemented && global_functions[x].f_func == NULL)
1989 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001990 else
1991 return x;
1992 }
1993 return -1;
1994}
1995
Bram Moolenaar15c47602020-03-26 22:16:48 +01001996/*
1997 * Find internal function "name" in table "global_functions".
1998 * Return index, or -1 if not found or the function is not implemented.
1999 */
2000 int
2001find_internal_func(char_u *name)
2002{
2003 return find_internal_func_opt(name, TRUE);
2004}
2005
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002006 int
Bram Moolenaarac92e252019-08-03 21:58:38 +02002007has_internal_func(char_u *name)
2008{
Bram Moolenaar15c47602020-03-26 22:16:48 +01002009 return find_internal_func_opt(name, TRUE) >= 0;
2010}
2011
2012 static int
2013has_internal_func_name(char_u *name)
2014{
2015 return find_internal_func_opt(name, FALSE) >= 0;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002016}
2017
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002018 char *
2019internal_func_name(int idx)
2020{
2021 return global_functions[idx].f_name;
2022}
2023
Bram Moolenaar94738d82020-10-21 14:25:07 +02002024/*
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002025 * Check the argument types for builtin function "idx".
Bram Moolenaar94738d82020-10-21 14:25:07 +02002026 * Uses the list of types on the type stack: "types".
2027 * Return FAIL and gives an error message when a type is wrong.
2028 */
2029 int
Bram Moolenaar351ead02021-01-16 16:07:01 +01002030internal_func_check_arg_types(
2031 type_T **types,
2032 int idx,
2033 int argcount,
2034 cctx_T *cctx)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002035{
2036 argcheck_T *argchecks = global_functions[idx].f_argcheck;
2037 int i;
2038
2039 if (argchecks != NULL)
2040 {
2041 argcontext_T context;
2042
2043 context.arg_count = argcount;
Bram Moolenaarca174532020-10-21 16:42:22 +02002044 context.arg_types = types;
Bram Moolenaar351ead02021-01-16 16:07:01 +01002045 context.arg_cctx = cctx;
Bram Moolenaar94738d82020-10-21 14:25:07 +02002046 for (i = 0; i < argcount; ++i)
2047 if (argchecks[i] != NULL)
2048 {
2049 context.arg_idx = i;
Bram Moolenaarca174532020-10-21 16:42:22 +02002050 if (argchecks[i](types[i], &context) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02002051 return FAIL;
2052 }
2053 }
2054 return OK;
2055}
2056
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002057/*
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02002058 * Get the argument count for function "idx".
2059 * "argcount" is the total argument count, "min_argcount" the non-optional
2060 * argument count.
2061 */
2062 void
2063internal_func_get_argcount(int idx, int *argcount, int *min_argcount)
2064{
2065 *argcount = global_functions[idx].f_max_argc;
2066 *min_argcount = global_functions[idx].f_min_argc;
2067}
2068
2069/*
Bram Moolenaara1224cb2020-10-22 12:31:49 +02002070 * Call the "f_retfunc" function to obtain the return type of function "idx".
2071 * "argtypes" is the list of argument types or NULL when there are no
2072 * arguments.
2073 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002074 type_T *
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01002075internal_func_ret_type(int idx, int argcount, type_T **argtypes)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002076{
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01002077 return global_functions[idx].f_retfunc(argcount, argtypes);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002078}
2079
2080/*
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002081 * Return TRUE if "idx" is for the map() function.
2082 */
2083 int
2084internal_func_is_map(int idx)
2085{
2086 return global_functions[idx].f_func == f_map;
2087}
2088
2089/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002090 * Check the argument count to use for internal function "idx".
Bram Moolenaar389df252020-07-09 21:20:47 +02002091 * Returns -1 for failure, 0 if no method base accepted, 1 if method base is
2092 * first argument, 2 if method base is second argument, etc. 9 if method base
2093 * is last argument.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002094 */
2095 int
2096check_internal_func(int idx, int argcount)
2097{
2098 int res;
2099 char *name;
2100
2101 if (argcount < global_functions[idx].f_min_argc)
2102 res = FCERR_TOOFEW;
2103 else if (argcount > global_functions[idx].f_max_argc)
2104 res = FCERR_TOOMANY;
2105 else
Bram Moolenaar389df252020-07-09 21:20:47 +02002106 return global_functions[idx].f_argtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002107
2108 name = internal_func_name(idx);
2109 if (res == FCERR_TOOMANY)
2110 semsg(_(e_toomanyarg), name);
2111 else
2112 semsg(_(e_toofewarg), name);
Bram Moolenaar389df252020-07-09 21:20:47 +02002113 return -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002114}
2115
Bram Moolenaarac92e252019-08-03 21:58:38 +02002116 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002117call_internal_func(
2118 char_u *name,
2119 int argcount,
2120 typval_T *argvars,
2121 typval_T *rettv)
2122{
2123 int i;
2124
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002125 i = find_internal_func(name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002126 if (i < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002127 return FCERR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002128 if (argcount < global_functions[i].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002129 return FCERR_TOOFEW;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002130 if (argcount > global_functions[i].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002131 return FCERR_TOOMANY;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002132 argvars[argcount].v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002133 global_functions[i].f_func(argvars, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01002134 return FCERR_NONE;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002135}
2136
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002137 void
2138call_internal_func_by_idx(
2139 int idx,
2140 typval_T *argvars,
2141 typval_T *rettv)
2142{
2143 global_functions[idx].f_func(argvars, rettv);
2144}
2145
Bram Moolenaarac92e252019-08-03 21:58:38 +02002146/*
2147 * Invoke a method for base->method().
2148 */
2149 int
2150call_internal_method(
2151 char_u *name,
2152 int argcount,
2153 typval_T *argvars,
2154 typval_T *rettv,
2155 typval_T *basetv)
2156{
2157 int i;
2158 int fi;
2159 typval_T argv[MAX_FUNC_ARGS + 1];
2160
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002161 fi = find_internal_func(name);
Bram Moolenaar91746392019-08-16 22:22:31 +02002162 if (fi < 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002163 return FCERR_UNKNOWN;
Bram Moolenaar91746392019-08-16 22:22:31 +02002164 if (global_functions[fi].f_argtype == 0)
Bram Moolenaaref140542019-12-31 21:27:13 +01002165 return FCERR_NOTMETHOD;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002166 if (argcount + 1 < global_functions[fi].f_min_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002167 return FCERR_TOOFEW;
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002168 if (argcount + 1 > global_functions[fi].f_max_argc)
Bram Moolenaaref140542019-12-31 21:27:13 +01002169 return FCERR_TOOMANY;
Bram Moolenaarac92e252019-08-03 21:58:38 +02002170
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002171 if (global_functions[fi].f_argtype == FEARG_LAST)
Bram Moolenaar25e42232019-08-04 15:04:10 +02002172 {
2173 // base value goes last
2174 for (i = 0; i < argcount; ++i)
2175 argv[i] = argvars[i];
2176 argv[argcount] = *basetv;
2177 }
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002178 else if (global_functions[fi].f_argtype == FEARG_2)
Bram Moolenaar25e42232019-08-04 15:04:10 +02002179 {
2180 // base value goes second
2181 argv[0] = argvars[0];
2182 argv[1] = *basetv;
2183 for (i = 1; i < argcount; ++i)
2184 argv[i + 1] = argvars[i];
2185 }
Bram Moolenaar24278d22019-08-16 21:49:22 +02002186 else if (global_functions[fi].f_argtype == FEARG_3)
2187 {
2188 // base value goes third
2189 argv[0] = argvars[0];
2190 argv[1] = argvars[1];
2191 argv[2] = *basetv;
2192 for (i = 2; i < argcount; ++i)
2193 argv[i + 1] = argvars[i];
2194 }
Bram Moolenaaraad222c2019-09-06 22:46:09 +02002195 else if (global_functions[fi].f_argtype == FEARG_4)
2196 {
2197 // base value goes fourth
2198 argv[0] = argvars[0];
2199 argv[1] = argvars[1];
2200 argv[2] = argvars[2];
2201 argv[3] = *basetv;
2202 for (i = 3; i < argcount; ++i)
2203 argv[i + 1] = argvars[i];
2204 }
Bram Moolenaar25e42232019-08-04 15:04:10 +02002205 else
2206 {
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002207 // FEARG_1: base value goes first
Bram Moolenaar25e42232019-08-04 15:04:10 +02002208 argv[0] = *basetv;
2209 for (i = 0; i < argcount; ++i)
2210 argv[i + 1] = argvars[i];
2211 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02002212 argv[argcount + 1].v_type = VAR_UNKNOWN;
2213
Bram Moolenaar7a4ea1d2019-08-04 21:35:12 +02002214 global_functions[fi].f_func(argv, rettv);
Bram Moolenaaref140542019-12-31 21:27:13 +01002215 return FCERR_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002216}
2217
2218/*
2219 * Return TRUE for a non-zero Number and a non-empty String.
2220 */
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02002221 int
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002222non_zero_arg(typval_T *argvars)
2223{
2224 return ((argvars[0].v_type == VAR_NUMBER
2225 && argvars[0].vval.v_number != 0)
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01002226 || (argvars[0].v_type == VAR_BOOL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002227 && argvars[0].vval.v_number == VVAL_TRUE)
2228 || (argvars[0].v_type == VAR_STRING
2229 && argvars[0].vval.v_string != NULL
2230 && *argvars[0].vval.v_string != NUL));
2231}
2232
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002233/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002234 * "and(expr, expr)" function
2235 */
2236 static void
2237f_and(typval_T *argvars, typval_T *rettv)
2238{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002239 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
2240 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02002241}
2242
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002243/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01002244 * "balloon_show()" function
2245 */
2246#ifdef FEAT_BEVAL
2247 static void
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02002248f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv)
2249{
2250 rettv->v_type = VAR_STRING;
2251 if (balloonEval != NULL)
2252 {
2253 if (balloonEval->msg == NULL)
2254 rettv->vval.v_string = NULL;
2255 else
2256 rettv->vval.v_string = vim_strsave(balloonEval->msg);
2257 }
2258}
2259
2260 static void
Bram Moolenaar59716a22017-03-01 20:32:44 +01002261f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
2262{
Bram Moolenaarcaf64342017-03-02 22:11:33 +01002263 if (balloonEval != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01002264 {
2265 if (argvars[0].v_type == VAR_LIST
2266# ifdef FEAT_GUI
2267 && !gui.in_use
2268# endif
2269 )
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02002270 {
2271 list_T *l = argvars[0].vval.v_list;
2272
2273 // empty list removes the balloon
2274 post_balloon(balloonEval, NULL,
2275 l == NULL || l->lv_len == 0 ? NULL : l);
2276 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01002277 else
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02002278 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01002279 char_u *mesg;
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02002280
Bram Moolenaar32105ae2021-03-27 18:59:25 +01002281 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
2282 return;
2283
2284 mesg = tv_get_string_chk(&argvars[0]);
Bram Moolenaarbe0a2592019-05-09 13:50:16 +02002285 if (mesg != NULL)
2286 // empty string removes the balloon
2287 post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL);
2288 }
Bram Moolenaar246fe032017-11-19 19:56:27 +01002289 }
2290}
2291
Bram Moolenaar669a8282017-11-19 20:13:05 +01002292# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01002293 static void
2294f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
2295{
2296 if (rettv_list_alloc(rettv) == OK)
2297 {
Bram Moolenaar32105ae2021-03-27 18:59:25 +01002298 char_u *msg;
Bram Moolenaar246fe032017-11-19 19:56:27 +01002299
Bram Moolenaar32105ae2021-03-27 18:59:25 +01002300 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
2301 return;
2302 msg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar246fe032017-11-19 19:56:27 +01002303 if (msg != NULL)
2304 {
2305 pumitem_T *array;
2306 int size = split_message(msg, &array);
2307 int i;
2308
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002309 // Skip the first and last item, they are always empty.
Bram Moolenaar246fe032017-11-19 19:56:27 +01002310 for (i = 1; i < size - 1; ++i)
2311 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
Bram Moolenaarb301f6b2018-02-10 15:38:35 +01002312 while (size > 0)
2313 vim_free(array[--size].pum_text);
Bram Moolenaar246fe032017-11-19 19:56:27 +01002314 vim_free(array);
2315 }
2316 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01002317}
Bram Moolenaar669a8282017-11-19 20:13:05 +01002318# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01002319#endif
2320
2321/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01002322 * Get the buffer from "arg" and give an error and return NULL if it is not
2323 * valid.
2324 */
Bram Moolenaara3347722019-05-11 21:14:24 +02002325 buf_T *
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01002326get_buf_arg(typval_T *arg)
2327{
2328 buf_T *buf;
2329
2330 ++emsg_off;
2331 buf = tv_get_buf(arg, FALSE);
2332 --emsg_off;
2333 if (buf == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002334 semsg(_("E158: Invalid buffer name: %s"), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01002335 return buf;
2336}
2337
2338/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002339 * "byte2line(byte)" function
2340 */
2341 static void
2342f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
2343{
2344#ifndef FEAT_BYTEOFF
2345 rettv->vval.v_number = -1;
2346#else
2347 long boff = 0;
2348
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002349 boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002350 if (boff < 0)
2351 rettv->vval.v_number = -1;
2352 else
2353 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
2354 (linenr_T)0, &boff);
2355#endif
2356}
2357
2358 static void
2359byteidx(typval_T *argvars, typval_T *rettv, int comp UNUSED)
2360{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002361 char_u *t;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002362 char_u *str;
2363 varnumber_T idx;
2364
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002365 str = tv_get_string_chk(&argvars[0]);
2366 idx = tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002367 rettv->vval.v_number = -1;
2368 if (str == NULL || idx < 0)
2369 return;
2370
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002371 t = str;
2372 for ( ; idx > 0; idx--)
2373 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002374 if (*t == NUL) // EOL reached
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002375 return;
2376 if (enc_utf8 && comp)
2377 t += utf_ptr2len(t);
2378 else
2379 t += (*mb_ptr2len)(t);
2380 }
2381 rettv->vval.v_number = (varnumber_T)(t - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002382}
2383
2384/*
2385 * "byteidx()" function
2386 */
2387 static void
2388f_byteidx(typval_T *argvars, typval_T *rettv)
2389{
2390 byteidx(argvars, rettv, FALSE);
2391}
2392
2393/*
2394 * "byteidxcomp()" function
2395 */
2396 static void
2397f_byteidxcomp(typval_T *argvars, typval_T *rettv)
2398{
2399 byteidx(argvars, rettv, TRUE);
2400}
2401
2402/*
2403 * "call(func, arglist [, dict])" function
2404 */
2405 static void
2406f_call(typval_T *argvars, typval_T *rettv)
2407{
2408 char_u *func;
2409 partial_T *partial = NULL;
2410 dict_T *selfdict = NULL;
2411
2412 if (argvars[1].v_type != VAR_LIST)
2413 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002414 emsg(_(e_listreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002415 return;
2416 }
2417 if (argvars[1].vval.v_list == NULL)
2418 return;
2419
2420 if (argvars[0].v_type == VAR_FUNC)
2421 func = argvars[0].vval.v_string;
2422 else if (argvars[0].v_type == VAR_PARTIAL)
2423 {
2424 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02002425 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002426 }
2427 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002428 func = tv_get_string(&argvars[0]);
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002429 if (func == NULL || *func == NUL)
2430 return; // type error, empty name or null function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002431
2432 if (argvars[2].v_type != VAR_UNKNOWN)
2433 {
2434 if (argvars[2].v_type != VAR_DICT)
2435 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002436 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002437 return;
2438 }
2439 selfdict = argvars[2].vval.v_dict;
2440 }
2441
2442 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
2443}
2444
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002445/*
2446 * "changenr()" function
2447 */
2448 static void
2449f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
2450{
2451 rettv->vval.v_number = curbuf->b_u_seq_cur;
2452}
2453
2454/*
2455 * "char2nr(string)" function
2456 */
2457 static void
2458f_char2nr(typval_T *argvars, typval_T *rettv)
2459{
Bram Moolenaarc5809432021-03-27 21:23:30 +01002460 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
2461 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002462 if (has_mbyte)
2463 {
2464 int utf8 = 0;
2465
2466 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar24f77502020-09-04 19:50:57 +02002467 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002468
2469 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01002470 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002471 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002472 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002473 }
2474 else
Bram Moolenaar13505972019-01-24 15:04:48 +01002475 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002476}
2477
Bram Moolenaar17793ef2020-12-28 12:56:58 +01002478/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002479 * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE,
2480 * returns the character index of the column. Otherwise, returns the byte index
2481 * of the column.
2482 */
2483 static void
2484get_col(typval_T *argvars, typval_T *rettv, int charcol)
2485{
2486 colnr_T col = 0;
2487 pos_T *fp;
2488 int fnum = curbuf->b_fnum;
2489
2490 fp = var2fpos(&argvars[0], FALSE, &fnum, charcol);
2491 if (fp != NULL && fnum == curbuf->b_fnum)
2492 {
2493 if (fp->col == MAXCOL)
2494 {
2495 // '> can be MAXCOL, get the length of the line then
2496 if (fp->lnum <= curbuf->b_ml.ml_line_count)
2497 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
2498 else
2499 col = MAXCOL;
2500 }
2501 else
2502 {
2503 col = fp->col + 1;
2504 // col(".") when the cursor is on the NUL at the end of the line
2505 // because of "coladd" can be seen as an extra column.
2506 if (virtual_active() && fp == &curwin->w_cursor)
2507 {
2508 char_u *p = ml_get_cursor();
2509
2510 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
2511 curwin->w_virtcol - curwin->w_cursor.coladd))
2512 {
2513 int l;
2514
2515 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
2516 col += l;
2517 }
2518 }
2519 }
2520 }
2521 rettv->vval.v_number = col;
2522}
2523
2524/*
2525 * "charcol()" function
2526 */
2527 static void
2528f_charcol(typval_T *argvars, typval_T *rettv)
2529{
2530 get_col(argvars, rettv, TRUE);
2531}
2532
2533/*
Bram Moolenaar17793ef2020-12-28 12:56:58 +01002534 * "charidx()" function
2535 */
2536 static void
2537f_charidx(typval_T *argvars, typval_T *rettv)
2538{
2539 char_u *str;
2540 varnumber_T idx;
Bram Moolenaar239f8d92021-01-17 13:21:20 +01002541 varnumber_T countcc = FALSE;
Bram Moolenaar17793ef2020-12-28 12:56:58 +01002542 char_u *p;
2543 int len;
2544 int (*ptr2len)(char_u *);
2545
2546 rettv->vval.v_number = -1;
2547
2548 if (argvars[0].v_type != VAR_STRING || argvars[1].v_type != VAR_NUMBER
2549 || (argvars[2].v_type != VAR_UNKNOWN
2550 && argvars[2].v_type != VAR_NUMBER))
2551 {
2552 emsg(_(e_invarg));
2553 return;
2554 }
2555
2556 str = tv_get_string_chk(&argvars[0]);
2557 idx = tv_get_number_chk(&argvars[1], NULL);
2558 if (str == NULL || idx < 0)
2559 return;
2560
2561 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01002562 countcc = tv_get_bool(&argvars[2]);
Bram Moolenaar17793ef2020-12-28 12:56:58 +01002563 if (countcc < 0 || countcc > 1)
2564 {
2565 semsg(_(e_using_number_as_bool_nr), countcc);
2566 return;
2567 }
2568
2569 if (enc_utf8 && countcc)
2570 ptr2len = utf_ptr2len;
2571 else
2572 ptr2len = mb_ptr2len;
2573
2574 for (p = str, len = 0; p <= str + idx; len++)
2575 {
2576 if (*p == NUL)
2577 return;
2578 p += ptr2len(p);
2579 }
2580
2581 rettv->vval.v_number = len > 0 ? len - 1 : 0;
2582}
2583
Bram Moolenaar29b7d7a2019-07-22 23:03:57 +02002584 win_T *
Bram Moolenaaraff74912019-03-30 18:11:49 +01002585get_optional_window(typval_T *argvars, int idx)
2586{
2587 win_T *win = curwin;
2588
2589 if (argvars[idx].v_type != VAR_UNKNOWN)
2590 {
2591 win = find_win_by_nr_or_id(&argvars[idx]);
2592 if (win == NULL)
2593 {
2594 emsg(_(e_invalwindow));
2595 return NULL;
2596 }
2597 }
2598 return win;
2599}
2600
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002601/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002602 * "col(string)" function
2603 */
2604 static void
2605f_col(typval_T *argvars, typval_T *rettv)
2606{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002607 get_col(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002608}
2609
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002610/*
2611 * "confirm(message, buttons[, default [, type]])" function
2612 */
2613 static void
2614f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2615{
2616#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2617 char_u *message;
2618 char_u *buttons = NULL;
2619 char_u buf[NUMBUFLEN];
2620 char_u buf2[NUMBUFLEN];
2621 int def = 1;
2622 int type = VIM_GENERIC;
2623 char_u *typestr;
2624 int error = FALSE;
2625
Bram Moolenaarc5809432021-03-27 21:23:30 +01002626 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
2627 return;
2628
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002629 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002630 if (message == NULL)
2631 error = TRUE;
2632 if (argvars[1].v_type != VAR_UNKNOWN)
2633 {
Bram Moolenaarc5809432021-03-27 21:23:30 +01002634 if (in_vim9script() && check_for_string_arg(argvars, 1) == FAIL)
2635 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002636 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002637 if (buttons == NULL)
2638 error = TRUE;
2639 if (argvars[2].v_type != VAR_UNKNOWN)
2640 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002641 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002642 if (argvars[3].v_type != VAR_UNKNOWN)
2643 {
Bram Moolenaarc5809432021-03-27 21:23:30 +01002644 if (in_vim9script() && check_for_string_arg(argvars, 3) == FAIL)
2645 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002646 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002647 if (typestr == NULL)
2648 error = TRUE;
2649 else
2650 {
2651 switch (TOUPPER_ASC(*typestr))
2652 {
2653 case 'E': type = VIM_ERROR; break;
2654 case 'Q': type = VIM_QUESTION; break;
2655 case 'I': type = VIM_INFO; break;
2656 case 'W': type = VIM_WARNING; break;
2657 case 'G': type = VIM_GENERIC; break;
2658 }
2659 }
2660 }
2661 }
2662 }
2663
2664 if (buttons == NULL || *buttons == NUL)
2665 buttons = (char_u *)_("&Ok");
2666
2667 if (!error)
2668 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
2669 def, NULL, FALSE);
2670#endif
2671}
2672
2673/*
2674 * "copy()" function
2675 */
2676 static void
2677f_copy(typval_T *argvars, typval_T *rettv)
2678{
2679 item_copy(&argvars[0], rettv, FALSE, 0);
2680}
2681
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002682/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002683 * Set the cursor position.
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002684 * If 'charcol' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002685 * Otherwise use the column number as a byte offset.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002686 */
2687 static void
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002688set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002689{
2690 long line, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002691 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002692 int set_curswant = TRUE;
2693
2694 rettv->vval.v_number = -1;
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002695 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002696 {
2697 pos_T pos;
2698 colnr_T curswant = -1;
2699
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002700 if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002701 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002702 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002703 return;
2704 }
2705 line = pos.lnum;
2706 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002707 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002708 if (curswant >= 0)
2709 {
2710 curwin->w_curswant = curswant - 1;
2711 set_curswant = FALSE;
2712 }
2713 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002714 else if ((argvars[0].v_type == VAR_NUMBER ||
2715 argvars[0].v_type == VAR_STRING)
Bram Moolenaar9ebcf232021-01-16 16:52:49 +01002716 && (argvars[1].v_type == VAR_NUMBER ||
2717 argvars[1].v_type == VAR_STRING))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002718 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002719 line = tv_get_lnum(argvars);
Bram Moolenaar9a963372020-12-21 21:58:46 +01002720 if (line < 0)
2721 semsg(_(e_invarg2), tv_get_string(&argvars[0]));
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002722 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002723 if (charcol)
Bram Moolenaar91458462021-01-13 20:08:38 +01002724 col = buf_charidx_to_byteidx(curbuf, line, col) + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002725 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002726 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002727 }
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002728 else
2729 {
2730 emsg(_(e_invarg));
2731 return;
2732 }
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002733 if (line < 0 || col < 0 || coladd < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002734 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002735 if (line > 0)
2736 curwin->w_cursor.lnum = line;
2737 if (col > 0)
2738 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002739 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002740
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002741 // Make sure the cursor is in a valid position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002742 check_cursor();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002743 // Correct cursor for multi-byte character.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002744 if (has_mbyte)
2745 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002746
2747 curwin->w_set_curswant = set_curswant;
2748 rettv->vval.v_number = 0;
2749}
2750
Bram Moolenaar6f02b002021-01-10 20:22:54 +01002751/*
2752 * "cursor(lnum, col)" function, or
2753 * "cursor(list)"
2754 *
2755 * Moves the cursor to the specified line and column.
2756 * Returns 0 when the position could be set, -1 otherwise.
2757 */
2758 static void
2759f_cursor(typval_T *argvars, typval_T *rettv)
2760{
2761 set_cursorpos(argvars, rettv, FALSE);
2762}
2763
Bram Moolenaar4f974752019-02-17 17:44:42 +01002764#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002765/*
2766 * "debugbreak()" function
2767 */
2768 static void
2769f_debugbreak(typval_T *argvars, typval_T *rettv)
2770{
2771 int pid;
2772
2773 rettv->vval.v_number = FAIL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002774 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002775 if (pid == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002776 emsg(_(e_invarg));
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002777 else
2778 {
2779 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
2780
2781 if (hProcess != NULL)
2782 {
2783 DebugBreakProcess(hProcess);
2784 CloseHandle(hProcess);
2785 rettv->vval.v_number = OK;
2786 }
2787 }
2788}
2789#endif
2790
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002791/*
2792 * "deepcopy()" function
2793 */
2794 static void
2795f_deepcopy(typval_T *argvars, typval_T *rettv)
2796{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01002797 varnumber_T noref = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002798 int copyID;
2799
2800 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01002801 noref = tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002802 if (noref < 0 || noref > 1)
Bram Moolenaarbade44e2020-09-26 22:39:24 +02002803 semsg(_(e_using_number_as_bool_nr), noref);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002804 else
2805 {
2806 copyID = get_copyID();
2807 item_copy(&argvars[0], rettv, TRUE, noref == 0 ? copyID : 0);
2808 }
2809}
2810
2811/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002812 * "did_filetype()" function
2813 */
2814 static void
2815f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2816{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002817 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002818}
2819
2820/*
Bram Moolenaar4132eb52020-02-14 16:53:00 +01002821 * "echoraw({expr})" function
2822 */
2823 static void
2824f_echoraw(typval_T *argvars, typval_T *rettv UNUSED)
2825{
2826 char_u *str = tv_get_string_chk(&argvars[0]);
2827
2828 if (str != NULL && *str != NUL)
2829 {
2830 out_str(str);
2831 out_flush();
2832 }
2833}
2834
2835/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002836 * "empty({expr})" function
2837 */
2838 static void
2839f_empty(typval_T *argvars, typval_T *rettv)
2840{
2841 int n = FALSE;
2842
2843 switch (argvars[0].v_type)
2844 {
2845 case VAR_STRING:
2846 case VAR_FUNC:
2847 n = argvars[0].vval.v_string == NULL
2848 || *argvars[0].vval.v_string == NUL;
2849 break;
2850 case VAR_PARTIAL:
2851 n = FALSE;
2852 break;
2853 case VAR_NUMBER:
2854 n = argvars[0].vval.v_number == 0;
2855 break;
2856 case VAR_FLOAT:
2857#ifdef FEAT_FLOAT
2858 n = argvars[0].vval.v_float == 0.0;
2859 break;
2860#endif
2861 case VAR_LIST:
2862 n = argvars[0].vval.v_list == NULL
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002863 || argvars[0].vval.v_list->lv_len == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002864 break;
2865 case VAR_DICT:
2866 n = argvars[0].vval.v_dict == NULL
2867 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
2868 break;
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01002869 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002870 case VAR_SPECIAL:
2871 n = argvars[0].vval.v_number != VVAL_TRUE;
2872 break;
2873
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002874 case VAR_BLOB:
2875 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002876 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
2877 break;
2878
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002879 case VAR_JOB:
2880#ifdef FEAT_JOB_CHANNEL
2881 n = argvars[0].vval.v_job == NULL
2882 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
2883 break;
2884#endif
2885 case VAR_CHANNEL:
2886#ifdef FEAT_JOB_CHANNEL
2887 n = argvars[0].vval.v_channel == NULL
2888 || !channel_is_open(argvars[0].vval.v_channel);
2889 break;
2890#endif
2891 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02002892 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002893 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02002894 case VAR_INSTR:
Bram Moolenaardd589232020-02-29 17:38:12 +01002895 internal_error_no_abort("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002896 n = TRUE;
2897 break;
2898 }
2899
2900 rettv->vval.v_number = n;
2901}
2902
2903/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02002904 * "environ()" function
2905 */
2906 static void
2907f_environ(typval_T *argvars UNUSED, typval_T *rettv)
2908{
2909#if !defined(AMIGA)
2910 int i = 0;
2911 char_u *entry, *value;
2912# ifdef MSWIN
2913 extern wchar_t **_wenviron;
2914# else
2915 extern char **environ;
2916# endif
2917
2918 if (rettv_dict_alloc(rettv) != OK)
2919 return;
2920
2921# ifdef MSWIN
2922 if (*_wenviron == NULL)
2923 return;
2924# else
2925 if (*environ == NULL)
2926 return;
2927# endif
2928
2929 for (i = 0; ; ++i)
2930 {
2931# ifdef MSWIN
2932 short_u *p;
2933
2934 if ((p = (short_u *)_wenviron[i]) == NULL)
2935 return;
2936 entry = utf16_to_enc(p, NULL);
2937# else
2938 if ((entry = (char_u *)environ[i]) == NULL)
2939 return;
2940 entry = vim_strsave(entry);
2941# endif
2942 if (entry == NULL) // out of memory
2943 return;
2944 if ((value = vim_strchr(entry, '=')) == NULL)
2945 {
2946 vim_free(entry);
2947 continue;
2948 }
2949 *value++ = NUL;
2950 dict_add_string(rettv->vval.v_dict, (char *)entry, value);
2951 vim_free(entry);
2952 }
2953#endif
2954}
2955
2956/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002957 * "escape({string}, {chars})" function
2958 */
2959 static void
2960f_escape(typval_T *argvars, typval_T *rettv)
2961{
2962 char_u buf[NUMBUFLEN];
2963
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002964 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
2965 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002966 rettv->v_type = VAR_STRING;
2967}
2968
2969/*
2970 * "eval()" function
2971 */
2972 static void
2973f_eval(typval_T *argvars, typval_T *rettv)
2974{
2975 char_u *s, *p;
2976
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002977 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002978 if (s != NULL)
2979 s = skipwhite(s);
2980
2981 p = s;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002982 if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002983 {
2984 if (p != NULL && !aborting())
Bram Moolenaar108010a2021-06-27 22:03:33 +02002985 semsg(_(e_invalid_expression_str), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002986 need_clr_eos = FALSE;
2987 rettv->v_type = VAR_NUMBER;
2988 rettv->vval.v_number = 0;
2989 }
2990 else if (*s != NUL)
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +02002991 semsg(_(e_trailing_arg), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002992}
2993
2994/*
2995 * "eventhandler()" function
2996 */
2997 static void
2998f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
2999{
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003000 rettv->vval.v_number = vgetc_busy || input_busy;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003001}
3002
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003003static garray_T redir_execute_ga;
3004
3005/*
3006 * Append "value[value_len]" to the execute() output.
3007 */
3008 void
3009execute_redir_str(char_u *value, int value_len)
3010{
3011 int len;
3012
3013 if (value_len == -1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003014 len = (int)STRLEN(value); // Append the entire string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003015 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003016 len = value_len; // Append only "value_len" characters
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003017 if (ga_grow(&redir_execute_ga, len) == OK)
3018 {
3019 mch_memmove((char *)redir_execute_ga.ga_data
3020 + redir_execute_ga.ga_len, value, len);
3021 redir_execute_ga.ga_len += len;
3022 }
3023}
3024
3025/*
3026 * Get next line from a list.
3027 * Called by do_cmdline() to get the next line.
3028 * Returns allocated string, or NULL for end of function.
3029 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003030 static char_u *
3031get_list_line(
3032 int c UNUSED,
3033 void *cookie,
Bram Moolenaare96a2492019-06-25 04:12:16 +02003034 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02003035 getline_opt_T options UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003036{
3037 listitem_T **p = (listitem_T **)cookie;
3038 listitem_T *item = *p;
3039 char_u buf[NUMBUFLEN];
3040 char_u *s;
3041
3042 if (item == NULL)
3043 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003044 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003045 *p = item->li_next;
3046 return s == NULL ? NULL : vim_strsave(s);
3047}
3048
3049/*
3050 * "execute()" function
3051 */
Bram Moolenaar261f3462019-09-07 15:45:32 +02003052 void
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003053execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003054{
3055 char_u *cmd = NULL;
3056 list_T *list = NULL;
3057 int save_msg_silent = msg_silent;
3058 int save_emsg_silent = emsg_silent;
3059 int save_emsg_noredir = emsg_noredir;
3060 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01003061 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003062 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003063 int save_msg_col = msg_col;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003064 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003065
3066 rettv->vval.v_string = NULL;
3067 rettv->v_type = VAR_STRING;
3068
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003069 if (argvars[arg_off].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003070 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003071 list = argvars[arg_off].vval.v_list;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003072 if (list == NULL || list->lv_len == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003073 // empty list, no commands, empty output
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003074 return;
3075 ++list->lv_refcount;
3076 }
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003077 else if (argvars[arg_off].v_type == VAR_JOB
3078 || argvars[arg_off].v_type == VAR_CHANNEL)
3079 {
Bram Moolenaar68db9962021-05-09 23:19:22 +02003080 semsg(_(e_using_invalid_value_as_string_str),
3081 vartype_name(argvars[arg_off].v_type));
Bram Moolenaare2a8f072020-01-08 19:32:18 +01003082 return;
3083 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003084 else
3085 {
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003086 cmd = tv_get_string_chk(&argvars[arg_off]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003087 if (cmd == NULL)
3088 return;
3089 }
3090
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003091 if (argvars[arg_off + 1].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003092 {
3093 char_u buf[NUMBUFLEN];
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02003094 char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf,
3095 in_vim9script());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003096
3097 if (s == NULL)
3098 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003099 if (*s == NUL)
3100 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003101 if (STRNCMP(s, "silent", 6) == 0)
3102 ++msg_silent;
3103 if (STRCMP(s, "silent!") == 0)
3104 {
3105 emsg_silent = TRUE;
3106 emsg_noredir = TRUE;
3107 }
3108 }
3109 else
3110 ++msg_silent;
3111
3112 if (redir_execute)
3113 save_ga = redir_execute_ga;
3114 ga_init2(&redir_execute_ga, (int)sizeof(char), 500);
3115 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01003116 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003117 if (!echo_output)
3118 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003119
3120 if (cmd != NULL)
3121 do_cmdline_cmd(cmd);
3122 else
3123 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003124 listitem_T *item;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003125
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02003126 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003127 item = list->lv_first;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003128 do_cmdline(NULL, get_list_line, (void *)&item,
3129 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3130 --list->lv_refcount;
3131 }
3132
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003133 // Need to append a NUL to the result.
Bram Moolenaard297f352017-01-29 20:31:21 +01003134 if (ga_grow(&redir_execute_ga, 1) == OK)
3135 {
3136 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
3137 rettv->vval.v_string = redir_execute_ga.ga_data;
3138 }
3139 else
3140 {
3141 ga_clear(&redir_execute_ga);
3142 rettv->vval.v_string = NULL;
3143 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003144 msg_silent = save_msg_silent;
3145 emsg_silent = save_emsg_silent;
3146 emsg_noredir = save_emsg_noredir;
3147
3148 redir_execute = save_redir_execute;
3149 if (redir_execute)
3150 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01003151 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003152
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003153 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003154 if (echo_output)
3155 // When not working silently: put it in column zero. A following
3156 // "echon" will overwrite the message, unavoidably.
3157 msg_col = 0;
3158 else
3159 // When working silently: Put it back where it was, since nothing
3160 // should have been written.
3161 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003162}
3163
3164/*
Bram Moolenaar868b7b62019-05-29 21:44:40 +02003165 * "execute()" function
3166 */
3167 static void
3168f_execute(typval_T *argvars, typval_T *rettv)
3169{
3170 execute_common(argvars, rettv, 0);
3171}
3172
3173/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003174 * "exists()" function
3175 */
3176 static void
3177f_exists(typval_T *argvars, typval_T *rettv)
3178{
3179 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003180 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003181
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003182 p = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003183 if (*p == '$') // environment variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003184 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003185 // first try "normal" environment variables (fast)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003186 if (mch_getenv(p + 1) != NULL)
3187 n = TRUE;
3188 else
3189 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003190 // try expanding things like $VIM and ${HOME}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003191 p = expand_env_save(p);
3192 if (p != NULL && *p != '$')
3193 n = TRUE;
3194 vim_free(p);
3195 }
3196 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003197 else if (*p == '&' || *p == '+') // option
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003198 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003199 n = (eval_option(&p, NULL, TRUE) == OK);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003200 if (*skipwhite(p) != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003201 n = FALSE; // trailing garbage
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003202 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003203 else if (*p == '*') // internal or user defined function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003204 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02003205 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003206 }
Bram Moolenaar15c47602020-03-26 22:16:48 +01003207 else if (*p == '?') // internal function only
3208 {
3209 n = has_internal_func_name(p + 1);
3210 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003211 else if (*p == ':')
3212 {
3213 n = cmd_exists(p + 1);
3214 }
3215 else if (*p == '#')
3216 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003217 if (p[1] == '#')
3218 n = autocmd_supported(p + 2);
3219 else
3220 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003221 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003222 else // internal variable
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003223 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01003224 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003225 }
3226
3227 rettv->vval.v_number = n;
3228}
3229
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003230/*
3231 * "expand()" function
3232 */
3233 static void
3234f_expand(typval_T *argvars, typval_T *rettv)
3235{
3236 char_u *s;
3237 int len;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003238 char *errormsg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003239 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
3240 expand_T xpc;
3241 int error = FALSE;
3242 char_u *result;
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02003243#ifdef BACKSLASH_IN_FILENAME
3244 char_u *p_csl_save = p_csl;
3245
3246 // avoid using 'completeslash' here
3247 p_csl = empty_option;
3248#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003249
3250 rettv->v_type = VAR_STRING;
3251 if (argvars[1].v_type != VAR_UNKNOWN
3252 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02003253 && tv_get_bool_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003254 && !error)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02003255 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003256
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003257 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003258 if (*s == '%' || *s == '#' || *s == '<')
3259 {
3260 ++emsg_off;
3261 result = eval_vars(s, s, &len, NULL, &errormsg, NULL);
3262 --emsg_off;
3263 if (rettv->v_type == VAR_LIST)
3264 {
3265 if (rettv_list_alloc(rettv) != FAIL && result != NULL)
3266 list_append_string(rettv->vval.v_list, result, -1);
Bram Moolenaar86173482019-10-01 17:02:16 +02003267 vim_free(result);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003268 }
3269 else
3270 rettv->vval.v_string = result;
3271 }
3272 else
3273 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003274 // When the optional second argument is non-zero, don't remove matches
3275 // for 'wildignore' and don't put matches for 'suffixes' at the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003276 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaar551d25e2020-09-02 21:37:56 +02003277 && tv_get_bool_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003278 options |= WILD_KEEP_ALL;
3279 if (!error)
3280 {
3281 ExpandInit(&xpc);
3282 xpc.xp_context = EXPAND_FILES;
3283 if (p_wic)
3284 options += WILD_ICASE;
3285 if (rettv->v_type == VAR_STRING)
3286 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
3287 options, WILD_ALL);
3288 else if (rettv_list_alloc(rettv) != FAIL)
3289 {
3290 int i;
3291
3292 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
3293 for (i = 0; i < xpc.xp_numfiles; i++)
3294 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
3295 ExpandCleanup(&xpc);
3296 }
3297 }
3298 else
3299 rettv->vval.v_string = NULL;
3300 }
Bram Moolenaar8f187fc2020-09-26 18:47:11 +02003301#ifdef BACKSLASH_IN_FILENAME
3302 p_csl = p_csl_save;
3303#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003304}
3305
3306/*
Bram Moolenaar80dad482019-06-09 17:22:31 +02003307 * "expandcmd()" function
3308 * Expand all the special characters in a command string.
3309 */
3310 static void
3311f_expandcmd(typval_T *argvars, typval_T *rettv)
3312{
3313 exarg_T eap;
3314 char_u *cmdstr;
3315 char *errormsg = NULL;
3316
3317 rettv->v_type = VAR_STRING;
3318 cmdstr = vim_strsave(tv_get_string(&argvars[0]));
3319
3320 memset(&eap, 0, sizeof(eap));
3321 eap.cmd = cmdstr;
3322 eap.arg = cmdstr;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02003323 eap.argt |= EX_NOSPC;
Bram Moolenaar80dad482019-06-09 17:22:31 +02003324 eap.usefilter = FALSE;
3325 eap.nextcmd = NULL;
3326 eap.cmdidx = CMD_USER;
3327
3328 expand_filename(&eap, &cmdstr, &errormsg);
3329 if (errormsg != NULL && *errormsg != NUL)
3330 emsg(errormsg);
3331
3332 rettv->vval.v_string = cmdstr;
3333}
3334
3335/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003336 * "feedkeys()" function
3337 */
3338 static void
3339f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
3340{
3341 int remap = TRUE;
3342 int insert = FALSE;
3343 char_u *keys, *flags;
3344 char_u nbuf[NUMBUFLEN];
3345 int typed = FALSE;
3346 int execute = FALSE;
3347 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003348 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003349 char_u *keys_esc;
3350
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003351 // This is not allowed in the sandbox. If the commands would still be
3352 // executed in the sandbox it would be OK, but it probably happens later,
3353 // when "sandbox" is no longer set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003354 if (check_secure())
3355 return;
3356
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003357 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003358
3359 if (argvars[1].v_type != VAR_UNKNOWN)
3360 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003361 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003362 for ( ; *flags != NUL; ++flags)
3363 {
3364 switch (*flags)
3365 {
3366 case 'n': remap = FALSE; break;
3367 case 'm': remap = TRUE; break;
3368 case 't': typed = TRUE; break;
3369 case 'i': insert = TRUE; break;
3370 case 'x': execute = TRUE; break;
3371 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003372 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003373 }
3374 }
3375 }
3376
3377 if (*keys != NUL || execute)
3378 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003379 // Need to escape K_SPECIAL and CSI before putting the string in the
3380 // typeahead buffer.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003381 keys_esc = vim_strsave_escape_csi(keys);
3382 if (keys_esc != NULL)
3383 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003384 if (lowlevel)
3385 {
3386#ifdef USE_INPUT_BUF
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01003387 int idx;
3388 int len = (int)STRLEN(keys);
3389
3390 for (idx = 0; idx < len; ++idx)
3391 {
3392 // if a CTRL-C was typed, set got_int, similar to what
3393 // happens in fill_input_buf()
3394 if (keys[idx] == 3 && ctrl_c_interrupts && typed)
3395 got_int = TRUE;
3396 add_to_input_buf(keys + idx, 1);
3397 }
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003398#else
3399 emsg(_("E980: lowlevel input not supported"));
3400#endif
3401 }
3402 else
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003403 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003404 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003405 insert ? 0 : typebuf.tb_len, !typed, FALSE);
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003406 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02003407#ifdef FEAT_TIMERS
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003408 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02003409#endif
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003410 || input_busy)
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003411 typebuf_was_filled = TRUE;
3412 }
3413 vim_free(keys_esc);
3414
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003415 if (execute)
3416 {
3417 int save_msg_scroll = msg_scroll;
3418
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003419 // Avoid a 1 second delay when the keys start Insert mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003420 msg_scroll = FALSE;
3421
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003422 if (!dangerous)
Bram Moolenaar4934ad02020-09-28 22:29:58 +02003423 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003424 ++ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02003425 ++in_feedkeys;
3426 }
Bram Moolenaar905dd902019-04-07 14:21:47 +02003427 exec_normal(TRUE, lowlevel, TRUE);
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003428 if (!dangerous)
Bram Moolenaar189832b2020-09-23 12:29:11 +02003429 {
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003430 --ex_normal_busy;
Bram Moolenaar4934ad02020-09-28 22:29:58 +02003431 --in_feedkeys;
Bram Moolenaar189832b2020-09-23 12:29:11 +02003432 }
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003433
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003434 msg_scroll |= save_msg_scroll;
3435 }
3436 }
3437 }
3438}
3439
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003440/*
3441 * "fnameescape({string})" function
3442 */
3443 static void
3444f_fnameescape(typval_T *argvars, typval_T *rettv)
3445{
3446 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003447 tv_get_string(&argvars[0]), FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003448 rettv->v_type = VAR_STRING;
3449}
3450
3451/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003452 * "foreground()" function
3453 */
3454 static void
3455f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3456{
3457#ifdef FEAT_GUI
3458 if (gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02003459 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003460 gui_mch_set_foreground();
Bram Moolenaarafde13b2019-04-28 19:46:49 +02003461 return;
3462 }
3463#endif
3464#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003465 win32_set_foreground();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003466#endif
3467}
3468
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003469 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003470common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003471{
3472 char_u *s;
3473 char_u *name;
3474 int use_string = FALSE;
3475 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003476 char_u *trans_name = NULL;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003477 int is_global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003478
3479 if (argvars[0].v_type == VAR_FUNC)
3480 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003481 // function(MyFunc, [arg], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003482 s = argvars[0].vval.v_string;
3483 }
3484 else if (argvars[0].v_type == VAR_PARTIAL
3485 && argvars[0].vval.v_partial != NULL)
3486 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003487 // function(dict.MyFunc, [arg])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003488 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003489 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003490 }
3491 else
3492 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003493 // function('MyFunc', [arg], dict)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003494 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003495 use_string = TRUE;
3496 }
3497
Bram Moolenaar843b8842016-08-21 14:36:15 +02003498 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003499 {
3500 name = s;
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003501 trans_name = trans_function_name(&name, &is_global, FALSE,
Bram Moolenaar32b3f822021-01-06 21:59:39 +01003502 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF,
3503 NULL, NULL, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003504 if (*name != NUL)
3505 s = NULL;
3506 }
3507
Bram Moolenaar843b8842016-08-21 14:36:15 +02003508 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
3509 || (is_funcref && trans_name == NULL))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003510 semsg(_(e_invarg2), use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003511 // Don't check an autoload name for existence here.
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003512 else if (trans_name != NULL && (is_funcref
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003513 ? find_func(trans_name, is_global, NULL) == NULL
3514 : !translated_function_exists(trans_name, is_global)))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003515 semsg(_("E700: Unknown function: %s"), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003516 else
3517 {
3518 int dict_idx = 0;
3519 int arg_idx = 0;
3520 list_T *list = NULL;
3521
3522 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
3523 {
3524 char sid_buf[25];
3525 int off = *s == 's' ? 2 : 5;
3526
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003527 // Expand s: and <SID> into <SNR>nr_, so that the function can
3528 // also be called from another script. Using trans_function_name()
3529 // would also work, but some plugins depend on the name being
3530 // printable text.
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02003531 sprintf(sid_buf, "<SNR>%ld_", (long)current_sctx.sc_sid);
Bram Moolenaar51e14382019-05-25 20:21:28 +02003532 name = alloc(STRLEN(sid_buf) + STRLEN(s + off) + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003533 if (name != NULL)
3534 {
3535 STRCPY(name, sid_buf);
3536 STRCAT(name, s + off);
3537 }
3538 }
3539 else
3540 name = vim_strsave(s);
3541
3542 if (argvars[1].v_type != VAR_UNKNOWN)
3543 {
3544 if (argvars[2].v_type != VAR_UNKNOWN)
3545 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003546 // function(name, [args], dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003547 arg_idx = 1;
3548 dict_idx = 2;
3549 }
3550 else if (argvars[1].v_type == VAR_DICT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003551 // function(name, dict)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003552 dict_idx = 1;
3553 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003554 // function(name, [args])
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003555 arg_idx = 1;
3556 if (dict_idx > 0)
3557 {
3558 if (argvars[dict_idx].v_type != VAR_DICT)
3559 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003560 emsg(_("E922: expected a dict"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003561 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003562 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003563 }
3564 if (argvars[dict_idx].vval.v_dict == NULL)
3565 dict_idx = 0;
3566 }
3567 if (arg_idx > 0)
3568 {
3569 if (argvars[arg_idx].v_type != VAR_LIST)
3570 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003571 emsg(_("E923: Second argument of function() must be a list or a dict"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003572 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003573 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003574 }
3575 list = argvars[arg_idx].vval.v_list;
3576 if (list == NULL || list->lv_len == 0)
3577 arg_idx = 0;
Bram Moolenaar4c054e92019-11-10 00:13:50 +01003578 else if (list->lv_len > MAX_FUNC_ARGS)
3579 {
Bram Moolenaar2118a302019-11-22 19:29:45 +01003580 emsg_funcname((char *)e_toomanyarg, s);
Bram Moolenaar4c054e92019-11-10 00:13:50 +01003581 vim_free(name);
3582 goto theend;
3583 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003584 }
3585 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003586 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003587 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02003588 partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003589
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003590 // result is a VAR_PARTIAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003591 if (pt == NULL)
3592 vim_free(name);
3593 else
3594 {
3595 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
3596 {
3597 listitem_T *li;
3598 int i = 0;
3599 int arg_len = 0;
3600 int lv_len = 0;
3601
3602 if (arg_pt != NULL)
3603 arg_len = arg_pt->pt_argc;
3604 if (list != NULL)
3605 lv_len = list->lv_len;
3606 pt->pt_argc = arg_len + lv_len;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02003607 pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003608 if (pt->pt_argv == NULL)
3609 {
3610 vim_free(pt);
3611 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003612 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003613 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003614 for (i = 0; i < arg_len; i++)
3615 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
3616 if (lv_len > 0)
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003617 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02003618 CHECK_LIST_MATERIALIZE(list);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003619 FOR_ALL_LIST_ITEMS(list, li)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003620 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003621 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003622 }
3623
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003624 // For "function(dict.func, [], dict)" and "func" is a partial
3625 // use "dict". That is backwards compatible.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003626 if (dict_idx > 0)
3627 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003628 // The dict is bound explicitly, pt_auto is FALSE.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003629 pt->pt_dict = argvars[dict_idx].vval.v_dict;
3630 ++pt->pt_dict->dv_refcount;
3631 }
3632 else if (arg_pt != NULL)
3633 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003634 // If the dict was bound automatically the result is also
3635 // bound automatically.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003636 pt->pt_dict = arg_pt->pt_dict;
3637 pt->pt_auto = arg_pt->pt_auto;
3638 if (pt->pt_dict != NULL)
3639 ++pt->pt_dict->dv_refcount;
3640 }
3641
3642 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003643 if (arg_pt != NULL && arg_pt->pt_func != NULL)
3644 {
3645 pt->pt_func = arg_pt->pt_func;
3646 func_ptr_ref(pt->pt_func);
3647 vim_free(name);
3648 }
3649 else if (is_funcref)
3650 {
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003651 pt->pt_func = find_func(trans_name, is_global, NULL);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003652 func_ptr_ref(pt->pt_func);
3653 vim_free(name);
3654 }
3655 else
3656 {
3657 pt->pt_name = name;
3658 func_ref(name);
3659 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003660 }
3661 rettv->v_type = VAR_PARTIAL;
3662 rettv->vval.v_partial = pt;
3663 }
3664 else
3665 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003666 // result is a VAR_FUNC
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003667 rettv->v_type = VAR_FUNC;
3668 rettv->vval.v_string = name;
3669 func_ref(name);
3670 }
3671 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003672theend:
3673 vim_free(trans_name);
3674}
3675
3676/*
3677 * "funcref()" function
3678 */
3679 static void
3680f_funcref(typval_T *argvars, typval_T *rettv)
3681{
3682 common_function(argvars, rettv, TRUE);
3683}
3684
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01003685 static type_T *
Bram Moolenaardfc33a62020-04-29 22:30:13 +02003686ret_f_function(int argcount, type_T **argtypes)
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01003687{
3688 if (argcount == 1 && argtypes[0]->tt_type == VAR_STRING)
3689 return &t_func_any;
Bram Moolenaar5e654232020-09-16 15:22:00 +02003690 return &t_func_unknown;
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01003691}
3692
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003693/*
3694 * "function()" function
3695 */
3696 static void
3697f_function(typval_T *argvars, typval_T *rettv)
3698{
3699 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003700}
3701
3702/*
3703 * "garbagecollect()" function
3704 */
3705 static void
3706f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
3707{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003708 // This is postponed until we are back at the toplevel, because we may be
3709 // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003710 want_garbage_collect = TRUE;
3711
Bram Moolenaar2df47312020-09-05 17:30:44 +02003712 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003713 garbage_collect_at_exit = TRUE;
3714}
3715
3716/*
3717 * "get()" function
3718 */
3719 static void
3720f_get(typval_T *argvars, typval_T *rettv)
3721{
3722 listitem_T *li;
3723 list_T *l;
3724 dictitem_T *di;
3725 dict_T *d;
3726 typval_T *tv = NULL;
Bram Moolenaarf91aac52019-07-28 13:21:01 +02003727 int what_is_dict = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003728
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003729 if (argvars[0].v_type == VAR_BLOB)
3730 {
3731 int error = FALSE;
3732 int idx = tv_get_number_chk(&argvars[1], &error);
3733
3734 if (!error)
3735 {
3736 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01003737 if (idx < 0)
3738 idx = blob_len(argvars[0].vval.v_blob) + idx;
3739 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
3740 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003741 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01003742 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003743 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01003744 tv = rettv;
3745 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003746 }
3747 }
3748 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003749 {
3750 if ((l = argvars[0].vval.v_list) != NULL)
3751 {
3752 int error = FALSE;
3753
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003754 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003755 if (!error && li != NULL)
3756 tv = &li->li_tv;
3757 }
3758 }
3759 else if (argvars[0].v_type == VAR_DICT)
3760 {
3761 if ((d = argvars[0].vval.v_dict) != NULL)
3762 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003763 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003764 if (di != NULL)
3765 tv = &di->di_tv;
3766 }
3767 }
3768 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
3769 {
3770 partial_T *pt;
3771 partial_T fref_pt;
3772
3773 if (argvars[0].v_type == VAR_PARTIAL)
3774 pt = argvars[0].vval.v_partial;
3775 else
3776 {
Bram Moolenaara80faa82020-04-12 19:37:17 +02003777 CLEAR_FIELD(fref_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003778 fref_pt.pt_name = argvars[0].vval.v_string;
3779 pt = &fref_pt;
3780 }
3781
3782 if (pt != NULL)
3783 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003784 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003785 char_u *n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003786
3787 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
3788 {
3789 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003790 n = partial_name(pt);
3791 if (n == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003792 rettv->vval.v_string = NULL;
3793 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003794 {
3795 rettv->vval.v_string = vim_strsave(n);
3796 if (rettv->v_type == VAR_FUNC)
3797 func_ref(rettv->vval.v_string);
3798 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003799 }
3800 else if (STRCMP(what, "dict") == 0)
Bram Moolenaarf91aac52019-07-28 13:21:01 +02003801 {
3802 what_is_dict = TRUE;
3803 if (pt->pt_dict != NULL)
3804 rettv_dict_set(rettv, pt->pt_dict);
3805 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003806 else if (STRCMP(what, "args") == 0)
3807 {
3808 rettv->v_type = VAR_LIST;
3809 if (rettv_list_alloc(rettv) == OK)
3810 {
3811 int i;
3812
3813 for (i = 0; i < pt->pt_argc; ++i)
3814 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
3815 }
3816 }
3817 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003818 semsg(_(e_invarg2), what);
Bram Moolenaarf91aac52019-07-28 13:21:01 +02003819
3820 // When {what} == "dict" and pt->pt_dict == NULL, evaluate the
3821 // third argument
3822 if (!what_is_dict)
3823 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003824 }
3825 }
3826 else
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01003827 semsg(_(e_listdictblobarg), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003828
3829 if (tv == NULL)
3830 {
3831 if (argvars[2].v_type != VAR_UNKNOWN)
3832 copy_tv(&argvars[2], rettv);
3833 }
3834 else
3835 copy_tv(tv, rettv);
3836}
3837
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02003838/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01003839 * "getchangelist()" function
3840 */
3841 static void
3842f_getchangelist(typval_T *argvars, typval_T *rettv)
3843{
3844#ifdef FEAT_JUMPLIST
3845 buf_T *buf;
3846 int i;
3847 list_T *l;
3848 dict_T *d;
3849#endif
3850
3851 if (rettv_list_alloc(rettv) != OK)
3852 return;
3853
3854#ifdef FEAT_JUMPLIST
Bram Moolenaar4c313b12019-08-24 22:58:31 +02003855 if (argvars[0].v_type == VAR_UNKNOWN)
3856 buf = curbuf;
3857 else
Bram Moolenaara5d38412020-09-02 21:02:35 +02003858 buf = tv_get_buf_from_arg(&argvars[0]);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01003859 if (buf == NULL)
3860 return;
3861
3862 l = list_alloc();
3863 if (l == NULL)
3864 return;
3865
3866 if (list_append_list(rettv->vval.v_list, l) == FAIL)
3867 return;
3868 /*
3869 * The current window change list index tracks only the position in the
3870 * current buffer change list. For other buffers, use the change list
3871 * length as the current index.
3872 */
3873 list_append_number(rettv->vval.v_list,
3874 (varnumber_T)((buf == curwin->w_buffer)
3875 ? curwin->w_changelistidx : buf->b_changelistlen));
3876
3877 for (i = 0; i < buf->b_changelistlen; ++i)
3878 {
3879 if (buf->b_changelist[i].lnum == 0)
3880 continue;
3881 if ((d = dict_alloc()) == NULL)
3882 return;
3883 if (list_append_dict(l, d) == FAIL)
3884 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02003885 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
3886 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02003887 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01003888 }
3889#endif
3890}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003891
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003892 static void
3893getpos_both(
3894 typval_T *argvars,
3895 typval_T *rettv,
3896 int getcurpos,
3897 int charcol)
3898{
3899 pos_T *fp = NULL;
3900 pos_T pos;
3901 win_T *wp = curwin;
3902 list_T *l;
3903 int fnum = -1;
3904
3905 if (rettv_list_alloc(rettv) == OK)
3906 {
3907 l = rettv->vval.v_list;
3908 if (getcurpos)
3909 {
3910 if (argvars[0].v_type != VAR_UNKNOWN)
3911 {
3912 wp = find_win_by_nr_or_id(&argvars[0]);
3913 if (wp != NULL)
3914 fp = &wp->w_cursor;
3915 }
3916 else
3917 fp = &curwin->w_cursor;
3918 if (fp != NULL && charcol)
3919 {
3920 pos = *fp;
Bram Moolenaar91458462021-01-13 20:08:38 +01003921 pos.col =
3922 buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col);
Bram Moolenaar6f02b002021-01-10 20:22:54 +01003923 fp = &pos;
3924 }
3925 }
3926 else
3927 fp = var2fpos(&argvars[0], TRUE, &fnum, charcol);
3928 if (fnum != -1)
3929 list_append_number(l, (varnumber_T)fnum);
3930 else
3931 list_append_number(l, (varnumber_T)0);
3932 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
3933 : (varnumber_T)0);
3934 list_append_number(l, (fp != NULL)
3935 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
3936 : (varnumber_T)0);
3937 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
3938 (varnumber_T)0);
3939 if (getcurpos)
3940 {
3941 int save_set_curswant = curwin->w_set_curswant;
3942 colnr_T save_curswant = curwin->w_curswant;
3943 colnr_T save_virtcol = curwin->w_virtcol;
3944
3945 if (wp == curwin)
3946 update_curswant();
3947 list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL
3948 ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1);
3949
3950 // Do not change "curswant", as it is unexpected that a get
3951 // function has a side effect.
3952 if (wp == curwin && save_set_curswant)
3953 {
3954 curwin->w_set_curswant = save_set_curswant;
3955 curwin->w_curswant = save_curswant;
3956 curwin->w_virtcol = save_virtcol;
3957 curwin->w_valid &= ~VALID_VIRTCOL;
3958 }
3959 }
3960 }
3961 else
3962 rettv->vval.v_number = FALSE;
3963}
3964
3965/*
3966 * "getcharpos()" function
3967 */
3968 static void
3969f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv)
3970{
3971 getpos_both(argvars, rettv, FALSE, TRUE);
3972}
3973
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003974/*
3975 * "getcharsearch()" function
3976 */
3977 static void
3978f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
3979{
3980 if (rettv_dict_alloc(rettv) != FAIL)
3981 {
3982 dict_T *dict = rettv->vval.v_dict;
3983
Bram Moolenaare0be1672018-07-08 16:50:37 +02003984 dict_add_string(dict, "char", last_csearch());
3985 dict_add_number(dict, "forward", last_csearch_forward());
3986 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003987 }
3988}
3989
3990/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02003991 * "getenv()" function
3992 */
3993 static void
3994f_getenv(typval_T *argvars, typval_T *rettv)
3995{
3996 int mustfree = FALSE;
3997 char_u *p = vim_getenv(tv_get_string(&argvars[0]), &mustfree);
3998
3999 if (p == NULL)
4000 {
4001 rettv->v_type = VAR_SPECIAL;
4002 rettv->vval.v_number = VVAL_NULL;
4003 return;
4004 }
4005 if (!mustfree)
4006 p = vim_strsave(p);
4007 rettv->vval.v_string = p;
4008 rettv->v_type = VAR_STRING;
4009}
4010
4011/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004012 * "getfontname()" function
4013 */
4014 static void
4015f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
4016{
4017 rettv->v_type = VAR_STRING;
4018 rettv->vval.v_string = NULL;
4019#ifdef FEAT_GUI
4020 if (gui.in_use)
4021 {
4022 GuiFont font;
4023 char_u *name = NULL;
4024
4025 if (argvars[0].v_type == VAR_UNKNOWN)
4026 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004027 // Get the "Normal" font. Either the name saved by
4028 // hl_set_font_name() or from the font ID.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004029 font = gui.norm_font;
4030 name = hl_get_font_name();
4031 }
4032 else
4033 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004034 name = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004035 if (STRCMP(name, "*") == 0) // don't use font dialog
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004036 return;
4037 font = gui_mch_get_font(name, FALSE);
4038 if (font == NOFONT)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004039 return; // Invalid font name, return empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004040 }
4041 rettv->vval.v_string = gui_mch_get_fontname(font, name);
4042 if (argvars[0].v_type != VAR_UNKNOWN)
4043 gui_mch_free_font(font);
4044 }
4045#endif
4046}
4047
4048/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01004049 * "getjumplist()" function
4050 */
4051 static void
4052f_getjumplist(typval_T *argvars, typval_T *rettv)
4053{
4054#ifdef FEAT_JUMPLIST
4055 win_T *wp;
4056 int i;
4057 list_T *l;
4058 dict_T *d;
4059#endif
4060
4061 if (rettv_list_alloc(rettv) != OK)
4062 return;
4063
4064#ifdef FEAT_JUMPLIST
Bram Moolenaar00aa0692019-04-27 20:37:57 +02004065 wp = find_tabwin(&argvars[0], &argvars[1], NULL);
Bram Moolenaar4f505882018-02-10 21:06:32 +01004066 if (wp == NULL)
4067 return;
4068
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01004069 cleanup_jumplist(wp, TRUE);
4070
Bram Moolenaar4f505882018-02-10 21:06:32 +01004071 l = list_alloc();
4072 if (l == NULL)
4073 return;
4074
4075 if (list_append_list(rettv->vval.v_list, l) == FAIL)
4076 return;
4077 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
4078
4079 for (i = 0; i < wp->w_jumplistlen; ++i)
4080 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01004081 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
4082 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01004083 if ((d = dict_alloc()) == NULL)
4084 return;
4085 if (list_append_dict(l, d) == FAIL)
4086 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004087 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
4088 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004089 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004090 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01004091 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02004092 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01004093 }
4094#endif
4095}
4096
4097/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004098 * "getpid()" function
4099 */
4100 static void
4101f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
4102{
4103 rettv->vval.v_number = mch_get_pid();
4104}
4105
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004106/*
4107 * "getcurpos()" function
4108 */
4109 static void
4110f_getcurpos(typval_T *argvars, typval_T *rettv)
4111{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004112 getpos_both(argvars, rettv, TRUE, FALSE);
4113}
4114
4115 static void
4116f_getcursorcharpos(typval_T *argvars, typval_T *rettv)
4117{
4118 getpos_both(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004119}
4120
4121/*
4122 * "getpos(string)" function
4123 */
4124 static void
4125f_getpos(typval_T *argvars, typval_T *rettv)
4126{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01004127 getpos_both(argvars, rettv, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004128}
4129
4130/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004131 * "getreg()" function
4132 */
4133 static void
4134f_getreg(typval_T *argvars, typval_T *rettv)
4135{
4136 char_u *strregname;
4137 int regname;
4138 int arg2 = FALSE;
4139 int return_list = FALSE;
4140 int error = FALSE;
4141
4142 if (argvars[0].v_type != VAR_UNKNOWN)
4143 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004144 strregname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar418a29f2021-02-10 22:23:41 +01004145 if (strregname == NULL)
4146 error = TRUE;
4147 else if (in_vim9script() && STRLEN(strregname) > 1)
4148 {
4149 semsg(_(e_register_name_must_be_one_char_str), strregname);
4150 error = TRUE;
4151 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004152 if (argvars[1].v_type != VAR_UNKNOWN)
4153 {
Bram Moolenaar67ff97d2020-09-02 21:45:54 +02004154 arg2 = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004155 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar67ff97d2020-09-02 21:45:54 +02004156 return_list = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004157 }
4158 }
4159 else
4160 strregname = get_vim_var_str(VV_REG);
4161
4162 if (error)
4163 return;
4164
4165 regname = (strregname == NULL ? '"' : *strregname);
4166 if (regname == 0)
4167 regname = '"';
4168
4169 if (return_list)
4170 {
4171 rettv->v_type = VAR_LIST;
4172 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
4173 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
4174 if (rettv->vval.v_list == NULL)
4175 (void)rettv_list_alloc(rettv);
4176 else
4177 ++rettv->vval.v_list->lv_refcount;
4178 }
4179 else
4180 {
4181 rettv->v_type = VAR_STRING;
4182 rettv->vval.v_string = get_reg_contents(regname,
4183 arg2 ? GREG_EXPR_SRC : 0);
4184 }
4185}
4186
4187/*
4188 * "getregtype()" function
4189 */
4190 static void
4191f_getregtype(typval_T *argvars, typval_T *rettv)
4192{
4193 char_u *strregname;
4194 int regname;
4195 char_u buf[NUMBUFLEN + 2];
4196 long reglen = 0;
4197
4198 if (argvars[0].v_type != VAR_UNKNOWN)
4199 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004200 strregname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar418a29f2021-02-10 22:23:41 +01004201 if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1)
4202 {
4203 semsg(_(e_register_name_must_be_one_char_str), strregname);
4204 strregname = NULL;
4205 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004206 if (strregname == NULL) // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004207 {
4208 rettv->v_type = VAR_STRING;
4209 rettv->vval.v_string = NULL;
4210 return;
4211 }
4212 }
4213 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004214 // Default to v:register
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004215 strregname = get_vim_var_str(VV_REG);
4216
4217 regname = (strregname == NULL ? '"' : *strregname);
4218 if (regname == 0)
4219 regname = '"';
4220
4221 buf[0] = NUL;
4222 buf[1] = NUL;
4223 switch (get_reg_type(regname, &reglen))
4224 {
4225 case MLINE: buf[0] = 'V'; break;
4226 case MCHAR: buf[0] = 'v'; break;
4227 case MBLOCK:
4228 buf[0] = Ctrl_V;
4229 sprintf((char *)buf + 1, "%ld", reglen + 1);
4230 break;
4231 }
4232 rettv->v_type = VAR_STRING;
4233 rettv->vval.v_string = vim_strsave(buf);
4234}
4235
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004236/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01004237 * "gettagstack()" function
4238 */
4239 static void
4240f_gettagstack(typval_T *argvars, typval_T *rettv)
4241{
4242 win_T *wp = curwin; // default is current window
4243
4244 if (rettv_dict_alloc(rettv) != OK)
4245 return;
4246
4247 if (argvars[0].v_type != VAR_UNKNOWN)
4248 {
4249 wp = find_win_by_nr_or_id(&argvars[0]);
4250 if (wp == NULL)
4251 return;
4252 }
4253
4254 get_tagstack(wp, rettv->vval.v_dict);
4255}
4256
Bram Moolenaar0b39c3f2020-08-30 15:52:10 +02004257/*
4258 * "gettext()" function
4259 */
4260 static void
4261f_gettext(typval_T *argvars, typval_T *rettv)
4262{
4263 if (argvars[0].v_type != VAR_STRING
4264 || argvars[0].vval.v_string == NULL
4265 || *argvars[0].vval.v_string == NUL)
4266 {
4267 semsg(_(e_invarg2), tv_get_string(&argvars[0]));
4268 }
4269 else
4270 {
4271 rettv->v_type = VAR_STRING;
4272 rettv->vval.v_string = vim_strsave(
4273 (char_u *)_(argvars[0].vval.v_string));
4274 }
4275}
4276
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004277// for VIM_VERSION_ defines
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004278#include "version.h"
4279
4280/*
4281 * "has()" function
4282 */
Bram Moolenaara259d8d2020-01-31 20:10:50 +01004283 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004284f_has(typval_T *argvars, typval_T *rettv)
4285{
4286 int i;
4287 char_u *name;
Bram Moolenaar79296512020-03-22 16:17:14 +01004288 int x = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004289 int n = FALSE;
Bram Moolenaar79296512020-03-22 16:17:14 +01004290 typedef struct {
4291 char *name;
4292 short present;
4293 } has_item_T;
4294 static has_item_T has_list[] =
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004295 {
Bram Moolenaar79296512020-03-22 16:17:14 +01004296 {"amiga",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004297#ifdef AMIGA
Bram Moolenaar79296512020-03-22 16:17:14 +01004298 1
Bram Moolenaar39536dd2019-01-29 22:58:21 +01004299#else
Bram Moolenaar79296512020-03-22 16:17:14 +01004300 0
Bram Moolenaar39536dd2019-01-29 22:58:21 +01004301#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004302 },
4303 {"arp",
4304#if defined(AMIGA) && defined(FEAT_ARP)
4305 1
4306#else
4307 0
4308#endif
4309 },
Bram Moolenaar79296512020-03-22 16:17:14 +01004310 {"haiku",
4311#ifdef __HAIKU__
4312 1
4313#else
4314 0
4315#endif
4316 },
4317 {"bsd",
4318#if defined(BSD) && !defined(MACOS_X)
4319 1
4320#else
4321 0
4322#endif
4323 },
4324 {"hpux",
4325#ifdef hpux
4326 1
4327#else
4328 0
4329#endif
4330 },
4331 {"linux",
4332#ifdef __linux__
4333 1
4334#else
4335 0
4336#endif
4337 },
4338 {"mac", // Mac OS X (and, once, Mac OS Classic)
4339#ifdef MACOS_X
4340 1
4341#else
4342 0
4343#endif
4344 },
4345 {"osx", // Mac OS X
4346#ifdef MACOS_X
4347 1
4348#else
4349 0
4350#endif
4351 },
4352 {"macunix", // Mac OS X, with the darwin feature
4353#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
4354 1
4355#else
4356 0
4357#endif
4358 },
4359 {"osxdarwin", // synonym for macunix
4360#if defined(MACOS_X) && defined(MACOS_X_DARWIN)
4361 1
4362#else
4363 0
4364#endif
4365 },
4366 {"qnx",
4367#ifdef __QNX__
4368 1
4369#else
4370 0
4371#endif
4372 },
4373 {"sun",
4374#ifdef SUN_SYSTEM
4375 1
4376#else
4377 0
4378#endif
4379 },
4380 {"unix",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004381#ifdef UNIX
Bram Moolenaar79296512020-03-22 16:17:14 +01004382 1
4383#else
4384 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004385#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004386 },
4387 {"vms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004388#ifdef VMS
Bram Moolenaar79296512020-03-22 16:17:14 +01004389 1
4390#else
4391 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004392#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004393 },
4394 {"win32",
Bram Moolenaar4f974752019-02-17 17:44:42 +01004395#ifdef MSWIN
Bram Moolenaar79296512020-03-22 16:17:14 +01004396 1
4397#else
4398 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004399#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004400 },
4401 {"win32unix",
Bram Moolenaar1eed5322019-02-26 17:03:54 +01004402#if defined(UNIX) && defined(__CYGWIN__)
Bram Moolenaar79296512020-03-22 16:17:14 +01004403 1
4404#else
4405 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004406#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004407 },
4408 {"win64",
Bram Moolenaar44b443c2019-02-18 22:14:18 +01004409#ifdef _WIN64
Bram Moolenaar79296512020-03-22 16:17:14 +01004410 1
4411#else
4412 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004413#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004414 },
4415 {"ebcdic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004416#ifdef EBCDIC
Bram Moolenaar79296512020-03-22 16:17:14 +01004417 1
4418#else
4419 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004420#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004421 },
4422 {"fname_case",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004423#ifndef CASE_INSENSITIVE_FILENAME
Bram Moolenaar79296512020-03-22 16:17:14 +01004424 1
4425#else
4426 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004427#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004428 },
4429 {"acl",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004430#ifdef HAVE_ACL
Bram Moolenaar79296512020-03-22 16:17:14 +01004431 1
4432#else
4433 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004434#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004435 },
4436 {"arabic",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004437#ifdef FEAT_ARABIC
Bram Moolenaar79296512020-03-22 16:17:14 +01004438 1
4439#else
4440 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004441#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004442 },
4443 {"autocmd", 1},
4444 {"autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02004445#ifdef FEAT_AUTOCHDIR
Bram Moolenaar79296512020-03-22 16:17:14 +01004446 1
4447#else
4448 0
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02004449#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004450 },
4451 {"autoservername",
Bram Moolenaare42a6d22017-11-12 19:21:51 +01004452#ifdef FEAT_AUTOSERVERNAME
Bram Moolenaar79296512020-03-22 16:17:14 +01004453 1
4454#else
4455 0
Bram Moolenaare42a6d22017-11-12 19:21:51 +01004456#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004457 },
4458 {"balloon_eval",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01004459#ifdef FEAT_BEVAL_GUI
Bram Moolenaar79296512020-03-22 16:17:14 +01004460 1
4461#else
4462 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004463#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004464 },
4465 {"balloon_multiline",
4466#if defined(FEAT_BEVAL_GUI) && !defined(FEAT_GUI_MSWIN)
4467 // MS-Windows requires runtime check, see below
4468 1
4469#else
4470 0
4471#endif
4472 },
4473 {"balloon_eval_term",
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01004474#ifdef FEAT_BEVAL_TERM
Bram Moolenaar79296512020-03-22 16:17:14 +01004475 1
4476#else
4477 0
Bram Moolenaar51b0f372017-11-18 18:52:04 +01004478#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004479 },
4480 {"builtin_terms",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004481#if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
Bram Moolenaar79296512020-03-22 16:17:14 +01004482 1
4483#else
4484 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004485#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004486 },
4487 {"all_builtin_terms",
4488#if defined(ALL_BUILTIN_TCAPS)
4489 1
4490#else
4491 0
4492#endif
4493 },
4494 {"browsefilter",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004495#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01004496 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004497 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar79296512020-03-22 16:17:14 +01004498 1
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004499#else
Bram Moolenaar79296512020-03-22 16:17:14 +01004500 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004501#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01004502 },
4503 {"byte_offset",
4504#ifdef FEAT_BYTEOFF
4505 1
4506#else
4507 0
4508#endif
4509 },
4510 {"channel",
4511#ifdef FEAT_JOB_CHANNEL
4512 1
4513#else
4514 0
4515#endif
4516 },
4517 {"cindent",
4518#ifdef FEAT_CINDENT
4519 1
4520#else
4521 0
4522#endif
4523 },
4524 {"clientserver",
4525#ifdef FEAT_CLIENTSERVER
4526 1
4527#else
4528 0
4529#endif
4530 },
4531 {"clipboard",
4532#ifdef FEAT_CLIPBOARD
4533 1
4534#else
4535 0
4536#endif
4537 },
4538 {"cmdline_compl", 1},
4539 {"cmdline_hist", 1},
Bram Moolenaar21829c52021-01-26 22:42:21 +01004540 {"cmdwin",
4541#ifdef FEAT_CMDWIN
4542 1
4543#else
4544 0
4545#endif
4546 },
Bram Moolenaar79296512020-03-22 16:17:14 +01004547 {"comments", 1},
4548 {"conceal",
4549#ifdef FEAT_CONCEAL
4550 1
4551#else
4552 0
4553#endif
4554 },
4555 {"cryptv",
4556#ifdef FEAT_CRYPT
4557 1
4558#else
4559 0
4560#endif
4561 },
4562 {"crypt-blowfish",
4563#ifdef FEAT_CRYPT
4564 1
4565#else
4566 0
4567#endif
4568 },
4569 {"crypt-blowfish2",
4570#ifdef FEAT_CRYPT
4571 1
4572#else
4573 0
4574#endif
4575 },
4576 {"cscope",
4577#ifdef FEAT_CSCOPE
4578 1
4579#else
4580 0
4581#endif
4582 },
4583 {"cursorbind", 1},
4584 {"cursorshape",
4585#ifdef CURSOR_SHAPE
4586 1
4587#else
4588 0
4589#endif
4590 },
4591 {"debug",
4592#ifdef DEBUG
4593 1
4594#else
4595 0
4596#endif
4597 },
4598 {"dialog_con",
4599#ifdef FEAT_CON_DIALOG
4600 1
4601#else
4602 0
4603#endif
4604 },
4605 {"dialog_gui",
4606#ifdef FEAT_GUI_DIALOG
4607 1
4608#else
4609 0
4610#endif
4611 },
4612 {"diff",
4613#ifdef FEAT_DIFF
4614 1
4615#else
4616 0
4617#endif
4618 },
4619 {"digraphs",
4620#ifdef FEAT_DIGRAPHS
4621 1
4622#else
4623 0
4624#endif
4625 },
4626 {"directx",
4627#ifdef FEAT_DIRECTX
4628 1
4629#else
4630 0
4631#endif
4632 },
4633 {"dnd",
4634#ifdef FEAT_DND
4635 1
4636#else
4637 0
4638#endif
4639 },
Bram Moolenaar1d1ce612021-06-27 19:02:52 +02004640 {"drop_file",
4641#ifdef HAVE_DROP_FILE
4642 1
4643#else
4644 0
4645#endif
4646 },
Bram Moolenaar79296512020-03-22 16:17:14 +01004647 {"emacs_tags",
4648#ifdef FEAT_EMACS_TAGS
4649 1
4650#else
4651 0
4652#endif
4653 },
4654 {"eval", 1}, // always present, of course!
4655 {"ex_extra", 1}, // graduated feature
4656 {"extra_search",
4657#ifdef FEAT_SEARCH_EXTRA
4658 1
4659#else
4660 0
4661#endif
4662 },
4663 {"file_in_path",
4664#ifdef FEAT_SEARCHPATH
4665 1
4666#else
4667 0
4668#endif
4669 },
4670 {"filterpipe",
4671#if defined(FEAT_FILTERPIPE) && !defined(VIMDLL)
4672 1
4673#else
4674 0
4675#endif
4676 },
4677 {"find_in_path",
4678#ifdef FEAT_FIND_ID
4679 1
4680#else
4681 0
4682#endif
4683 },
4684 {"float",
4685#ifdef FEAT_FLOAT
4686 1
4687#else
4688 0
4689#endif
4690 },
4691 {"folding",
4692#ifdef FEAT_FOLDING
4693 1
4694#else
4695 0
4696#endif
4697 },
4698 {"footer",
4699#ifdef FEAT_FOOTER
4700 1
4701#else
4702 0
4703#endif
4704 },
4705 {"fork",
4706#if !defined(USE_SYSTEM) && defined(UNIX)
4707 1
4708#else
4709 0
4710#endif
4711 },
4712 {"gettext",
4713#ifdef FEAT_GETTEXT
4714 1
4715#else
4716 0
4717#endif
4718 },
4719 {"gui",
4720#ifdef FEAT_GUI
4721 1
4722#else
4723 0
4724#endif
4725 },
4726 {"gui_neXtaw",
4727#if defined(FEAT_GUI_ATHENA) && defined(FEAT_GUI_NEXTAW)
4728 1
4729#else
4730 0
4731#endif
4732 },
4733 {"gui_athena",
4734#if defined(FEAT_GUI_ATHENA) && !defined(FEAT_GUI_NEXTAW)
4735 1
4736#else
4737 0
4738#endif
4739 },
4740 {"gui_gtk",
4741#ifdef FEAT_GUI_GTK
4742 1
4743#else
4744 0
4745#endif
4746 },
4747 {"gui_gtk2",
4748#if defined(FEAT_GUI_GTK) && !defined(USE_GTK3)
4749 1
4750#else
4751 0
4752#endif
4753 },
4754 {"gui_gtk3",
4755#if defined(FEAT_GUI_GTK) && defined(USE_GTK3)
4756 1
4757#else
4758 0
4759#endif
4760 },
4761 {"gui_gnome",
4762#ifdef FEAT_GUI_GNOME
4763 1
4764#else
4765 0
4766#endif
4767 },
4768 {"gui_haiku",
4769#ifdef FEAT_GUI_HAIKU
4770 1
4771#else
4772 0
4773#endif
4774 },
Bram Moolenaar097148e2020-08-11 21:58:20 +02004775 {"gui_mac", 0},
Bram Moolenaar79296512020-03-22 16:17:14 +01004776 {"gui_motif",
4777#ifdef FEAT_GUI_MOTIF
4778 1
4779#else
4780 0
4781#endif
4782 },
4783 {"gui_photon",
4784#ifdef FEAT_GUI_PHOTON
4785 1
4786#else
4787 0
4788#endif
4789 },
4790 {"gui_win32",
4791#ifdef FEAT_GUI_MSWIN
4792 1
4793#else
4794 0
4795#endif
4796 },
4797 {"iconv",
4798#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
4799 1
4800#else
4801 0
4802#endif
4803 },
4804 {"insert_expand", 1},
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02004805 {"ipv6",
4806#ifdef FEAT_IPV6
4807 1
4808#else
4809 0
4810#endif
4811 },
Bram Moolenaar79296512020-03-22 16:17:14 +01004812 {"job",
4813#ifdef FEAT_JOB_CHANNEL
4814 1
4815#else
4816 0
4817#endif
4818 },
4819 {"jumplist",
4820#ifdef FEAT_JUMPLIST
4821 1
4822#else
4823 0
4824#endif
4825 },
4826 {"keymap",
4827#ifdef FEAT_KEYMAP
4828 1
4829#else
4830 0
4831#endif
4832 },
4833 {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure
4834 {"langmap",
4835#ifdef FEAT_LANGMAP
4836 1
4837#else
4838 0
4839#endif
4840 },
4841 {"libcall",
4842#ifdef FEAT_LIBCALL
4843 1
4844#else
4845 0
4846#endif
4847 },
4848 {"linebreak",
4849#ifdef FEAT_LINEBREAK
4850 1
4851#else
4852 0
4853#endif
4854 },
4855 {"lispindent",
4856#ifdef FEAT_LISP
4857 1
4858#else
4859 0
4860#endif
4861 },
4862 {"listcmds", 1},
4863 {"localmap", 1},
4864 {"lua",
4865#if defined(FEAT_LUA) && !defined(DYNAMIC_LUA)
4866 1
4867#else
4868 0
4869#endif
4870 },
4871 {"menu",
4872#ifdef FEAT_MENU
4873 1
4874#else
4875 0
4876#endif
4877 },
4878 {"mksession",
4879#ifdef FEAT_SESSION
4880 1
4881#else
4882 0
4883#endif
4884 },
4885 {"modify_fname", 1},
4886 {"mouse", 1},
4887 {"mouseshape",
4888#ifdef FEAT_MOUSESHAPE
4889 1
4890#else
4891 0
4892#endif
4893 },
4894 {"mouse_dec",
4895#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC)
4896 1
4897#else
4898 0
4899#endif
4900 },
4901 {"mouse_gpm",
4902#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM)
4903 1
4904#else
4905 0
4906#endif
4907 },
4908 {"mouse_jsbterm",
4909#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB)
4910 1
4911#else
4912 0
4913#endif
4914 },
4915 {"mouse_netterm",
4916#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET)
4917 1
4918#else
4919 0
4920#endif
4921 },
4922 {"mouse_pterm",
4923#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM)
4924 1
4925#else
4926 0
4927#endif
4928 },
4929 {"mouse_sgr",
4930#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
4931 1
4932#else
4933 0
4934#endif
4935 },
4936 {"mouse_sysmouse",
4937#if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE)
4938 1
4939#else
4940 0
4941#endif
4942 },
4943 {"mouse_urxvt",
4944#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT)
4945 1
4946#else
4947 0
4948#endif
4949 },
4950 {"mouse_xterm",
4951#if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM)
4952 1
4953#else
4954 0
4955#endif
4956 },
4957 {"multi_byte", 1},
4958 {"multi_byte_ime",
4959#ifdef FEAT_MBYTE_IME
4960 1
4961#else
4962 0
4963#endif
4964 },
4965 {"multi_lang",
4966#ifdef FEAT_MULTI_LANG
4967 1
4968#else
4969 0
4970#endif
4971 },
4972 {"mzscheme",
4973#if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME)
4974 1
4975#else
4976 0
4977#endif
4978 },
4979 {"num64", 1},
4980 {"ole",
4981#ifdef FEAT_OLE
4982 1
4983#else
4984 0
4985#endif
4986 },
4987 {"packages",
4988#ifdef FEAT_EVAL
4989 1
4990#else
4991 0
4992#endif
4993 },
4994 {"path_extra",
4995#ifdef FEAT_PATH_EXTRA
4996 1
4997#else
4998 0
4999#endif
5000 },
5001 {"perl",
5002#if defined(FEAT_PERL) && !defined(DYNAMIC_PERL)
5003 1
5004#else
5005 0
5006#endif
5007 },
5008 {"persistent_undo",
5009#ifdef FEAT_PERSISTENT_UNDO
5010 1
5011#else
5012 0
5013#endif
5014 },
5015 {"python_compiled",
5016#if defined(FEAT_PYTHON)
5017 1
5018#else
5019 0
5020#endif
5021 },
5022 {"python_dynamic",
5023#if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON)
5024 1
5025#else
5026 0
5027#endif
5028 },
5029 {"python",
5030#if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)
5031 1
5032#else
5033 0
5034#endif
5035 },
5036 {"pythonx",
5037#if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \
5038 || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3))
5039 1
5040#else
5041 0
5042#endif
5043 },
5044 {"python3_compiled",
5045#if defined(FEAT_PYTHON3)
5046 1
5047#else
5048 0
5049#endif
5050 },
5051 {"python3_dynamic",
5052#if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3)
5053 1
5054#else
5055 0
5056#endif
5057 },
5058 {"python3",
5059#if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)
5060 1
5061#else
5062 0
5063#endif
5064 },
5065 {"popupwin",
5066#ifdef FEAT_PROP_POPUP
5067 1
5068#else
5069 0
5070#endif
5071 },
5072 {"postscript",
5073#ifdef FEAT_POSTSCRIPT
5074 1
5075#else
5076 0
5077#endif
5078 },
5079 {"printer",
5080#ifdef FEAT_PRINTER
5081 1
5082#else
5083 0
5084#endif
5085 },
5086 {"profile",
5087#ifdef FEAT_PROFILE
5088 1
5089#else
5090 0
5091#endif
5092 },
5093 {"reltime",
5094#ifdef FEAT_RELTIME
5095 1
5096#else
5097 0
5098#endif
5099 },
5100 {"quickfix",
5101#ifdef FEAT_QUICKFIX
5102 1
5103#else
5104 0
5105#endif
5106 },
5107 {"rightleft",
5108#ifdef FEAT_RIGHTLEFT
5109 1
5110#else
5111 0
5112#endif
5113 },
5114 {"ruby",
5115#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
5116 1
5117#else
5118 0
5119#endif
5120 },
5121 {"scrollbind", 1},
5122 {"showcmd",
5123#ifdef FEAT_CMDL_INFO
5124 1
5125#else
5126 0
5127#endif
5128 },
5129 {"cmdline_info",
5130#ifdef FEAT_CMDL_INFO
5131 1
5132#else
5133 0
5134#endif
5135 },
5136 {"signs",
5137#ifdef FEAT_SIGNS
5138 1
5139#else
5140 0
5141#endif
5142 },
5143 {"smartindent",
5144#ifdef FEAT_SMARTINDENT
5145 1
5146#else
5147 0
5148#endif
5149 },
5150 {"startuptime",
5151#ifdef STARTUPTIME
5152 1
5153#else
5154 0
5155#endif
5156 },
5157 {"statusline",
5158#ifdef FEAT_STL_OPT
5159 1
5160#else
5161 0
5162#endif
5163 },
5164 {"netbeans_intg",
5165#ifdef FEAT_NETBEANS_INTG
5166 1
5167#else
5168 0
5169#endif
5170 },
Christian Brabandtf573c6e2021-06-20 14:02:16 +02005171 {"sodium",
5172#ifdef FEAT_SODIUM
5173 1
5174#else
5175 0
5176#endif
5177 },
Bram Moolenaar79296512020-03-22 16:17:14 +01005178 {"sound",
5179#ifdef FEAT_SOUND
5180 1
5181#else
5182 0
5183#endif
5184 },
5185 {"spell",
5186#ifdef FEAT_SPELL
5187 1
5188#else
5189 0
5190#endif
5191 },
5192 {"syntax",
5193#ifdef FEAT_SYN_HL
5194 1
5195#else
5196 0
5197#endif
5198 },
5199 {"system",
5200#if defined(USE_SYSTEM) || !defined(UNIX)
5201 1
5202#else
5203 0
5204#endif
5205 },
5206 {"tag_binary",
5207#ifdef FEAT_TAG_BINS
5208 1
5209#else
5210 0
5211#endif
5212 },
5213 {"tcl",
5214#if defined(FEAT_TCL) && !defined(DYNAMIC_TCL)
5215 1
5216#else
5217 0
5218#endif
5219 },
5220 {"termguicolors",
5221#ifdef FEAT_TERMGUICOLORS
5222 1
5223#else
5224 0
5225#endif
5226 },
5227 {"terminal",
5228#if defined(FEAT_TERMINAL) && !defined(MSWIN)
5229 1
5230#else
5231 0
5232#endif
5233 },
5234 {"terminfo",
5235#ifdef TERMINFO
5236 1
5237#else
5238 0
5239#endif
5240 },
5241 {"termresponse",
5242#ifdef FEAT_TERMRESPONSE
5243 1
5244#else
5245 0
5246#endif
5247 },
5248 {"textobjects",
5249#ifdef FEAT_TEXTOBJ
5250 1
5251#else
5252 0
5253#endif
5254 },
5255 {"textprop",
5256#ifdef FEAT_PROP_POPUP
5257 1
5258#else
5259 0
5260#endif
5261 },
5262 {"tgetent",
5263#ifdef HAVE_TGETENT
5264 1
5265#else
5266 0
5267#endif
5268 },
5269 {"timers",
5270#ifdef FEAT_TIMERS
5271 1
5272#else
5273 0
5274#endif
5275 },
5276 {"title",
5277#ifdef FEAT_TITLE
5278 1
5279#else
5280 0
5281#endif
5282 },
5283 {"toolbar",
5284#ifdef FEAT_TOOLBAR
5285 1
5286#else
5287 0
5288#endif
5289 },
5290 {"unnamedplus",
5291#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
5292 1
5293#else
5294 0
5295#endif
5296 },
5297 {"user-commands", 1}, // was accidentally included in 5.4
5298 {"user_commands", 1},
5299 {"vartabs",
5300#ifdef FEAT_VARTABS
5301 1
5302#else
5303 0
5304#endif
5305 },
5306 {"vertsplit", 1},
5307 {"viminfo",
5308#ifdef FEAT_VIMINFO
5309 1
5310#else
5311 0
5312#endif
5313 },
5314 {"vimscript-1", 1},
5315 {"vimscript-2", 1},
5316 {"vimscript-3", 1},
5317 {"vimscript-4", 1},
5318 {"virtualedit", 1},
5319 {"visual", 1},
5320 {"visualextra", 1},
5321 {"vreplace", 1},
5322 {"vtp",
5323#ifdef FEAT_VTP
5324 1
5325#else
5326 0
5327#endif
5328 },
5329 {"wildignore",
5330#ifdef FEAT_WILDIGN
5331 1
5332#else
5333 0
5334#endif
5335 },
5336 {"wildmenu",
5337#ifdef FEAT_WILDMENU
5338 1
5339#else
5340 0
5341#endif
5342 },
5343 {"windows", 1},
5344 {"winaltkeys",
5345#ifdef FEAT_WAK
5346 1
5347#else
5348 0
5349#endif
5350 },
5351 {"writebackup",
5352#ifdef FEAT_WRITEBACKUP
5353 1
5354#else
5355 0
5356#endif
5357 },
5358 {"xim",
5359#ifdef FEAT_XIM
5360 1
5361#else
5362 0
5363#endif
5364 },
5365 {"xfontset",
5366#ifdef FEAT_XFONTSET
5367 1
5368#else
5369 0
5370#endif
5371 },
5372 {"xpm",
5373#if defined(FEAT_XPM_W32) || defined(HAVE_XPM)
5374 1
5375#else
5376 0
5377#endif
5378 },
5379 {"xpm_w32", // for backward compatibility
5380#ifdef FEAT_XPM_W32
5381 1
5382#else
5383 0
5384#endif
5385 },
5386 {"xsmp",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005387#ifdef USE_XSMP
Bram Moolenaar79296512020-03-22 16:17:14 +01005388 1
5389#else
5390 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005391#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005392 },
5393 {"xsmp_interact",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005394#ifdef USE_XSMP_INTERACT
Bram Moolenaar79296512020-03-22 16:17:14 +01005395 1
5396#else
5397 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005398#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005399 },
5400 {"xterm_clipboard",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005401#ifdef FEAT_XCLIPBOARD
Bram Moolenaar79296512020-03-22 16:17:14 +01005402 1
5403#else
5404 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005405#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005406 },
5407 {"xterm_save",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005408#ifdef FEAT_XTERM_SAVE
Bram Moolenaar79296512020-03-22 16:17:14 +01005409 1
5410#else
5411 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005412#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005413 },
5414 {"X11",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005415#if defined(UNIX) && defined(FEAT_X11)
Bram Moolenaar79296512020-03-22 16:17:14 +01005416 1
5417#else
5418 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005419#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005420 },
5421 {NULL, 0}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005422 };
5423
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005424 name = tv_get_string(&argvars[0]);
Bram Moolenaar79296512020-03-22 16:17:14 +01005425 for (i = 0; has_list[i].name != NULL; ++i)
5426 if (STRICMP(name, has_list[i].name) == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005427 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005428 x = TRUE;
5429 n = has_list[i].present;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005430 break;
5431 }
5432
Bram Moolenaar79296512020-03-22 16:17:14 +01005433 // features also in has_list[] but sometimes enabled at runtime
5434 if (x == TRUE && n == FALSE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005435 {
Bram Moolenaar79296512020-03-22 16:17:14 +01005436 if (0)
Bram Moolenaar86b9a3e2020-04-07 19:57:29 +02005437 {
5438 // intentionally empty
5439 }
Bram Moolenaar4f974752019-02-17 17:44:42 +01005440#if defined(FEAT_BEVAL) && defined(FEAT_GUI_MSWIN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005441 else if (STRICMP(name, "balloon_multiline") == 0)
5442 n = multiline_balloon_available();
5443#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005444#ifdef VIMDLL
5445 else if (STRICMP(name, "filterpipe") == 0)
5446 n = gui.in_use || gui.starting;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005447#endif
5448#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
5449 else if (STRICMP(name, "iconv") == 0)
5450 n = iconv_enabled(FALSE);
5451#endif
5452#ifdef DYNAMIC_LUA
5453 else if (STRICMP(name, "lua") == 0)
5454 n = lua_enabled(FALSE);
5455#endif
5456#ifdef DYNAMIC_MZSCHEME
5457 else if (STRICMP(name, "mzscheme") == 0)
5458 n = mzscheme_enabled(FALSE);
5459#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005460#ifdef DYNAMIC_PERL
5461 else if (STRICMP(name, "perl") == 0)
5462 n = perl_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005463#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005464#ifdef DYNAMIC_PYTHON
5465 else if (STRICMP(name, "python") == 0)
5466 n = python_enabled(FALSE);
5467#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005468#ifdef DYNAMIC_PYTHON3
5469 else if (STRICMP(name, "python3") == 0)
5470 n = python3_enabled(FALSE);
5471#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01005472#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
5473 else if (STRICMP(name, "pythonx") == 0)
5474 {
5475# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
5476 if (p_pyx == 0)
5477 n = python3_enabled(FALSE) || python_enabled(FALSE);
5478 else if (p_pyx == 3)
5479 n = python3_enabled(FALSE);
5480 else if (p_pyx == 2)
5481 n = python_enabled(FALSE);
5482# elif defined(DYNAMIC_PYTHON)
5483 n = python_enabled(FALSE);
5484# elif defined(DYNAMIC_PYTHON3)
5485 n = python3_enabled(FALSE);
5486# endif
5487 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005488#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005489#ifdef DYNAMIC_RUBY
5490 else if (STRICMP(name, "ruby") == 0)
5491 n = ruby_enabled(FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005492#endif
Bram Moolenaar79296512020-03-22 16:17:14 +01005493#ifdef DYNAMIC_TCL
5494 else if (STRICMP(name, "tcl") == 0)
5495 n = tcl_enabled(FALSE);
Bram Moolenaar4b8366b2019-05-04 17:34:34 +02005496#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01005497#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02005498 else if (STRICMP(name, "terminal") == 0)
5499 n = terminal_enabled();
5500#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005501 }
5502
Bram Moolenaar79296512020-03-22 16:17:14 +01005503 // features not in has_list[]
5504 if (x == FALSE)
5505 {
5506 if (STRNICMP(name, "patch", 5) == 0)
5507 {
5508 x = TRUE;
5509 if (name[5] == '-'
5510 && STRLEN(name) >= 11
5511 && vim_isdigit(name[6])
5512 && vim_isdigit(name[8])
5513 && vim_isdigit(name[10]))
5514 {
5515 int major = atoi((char *)name + 6);
5516 int minor = atoi((char *)name + 8);
5517
5518 // Expect "patch-9.9.01234".
5519 n = (major < VIM_VERSION_MAJOR
5520 || (major == VIM_VERSION_MAJOR
5521 && (minor < VIM_VERSION_MINOR
5522 || (minor == VIM_VERSION_MINOR
5523 && has_patch(atoi((char *)name + 10))))));
5524 }
5525 else
5526 n = has_patch(atoi((char *)name + 5));
5527 }
5528 else if (STRICMP(name, "vim_starting") == 0)
5529 {
5530 x = TRUE;
5531 n = (starting != 0);
5532 }
5533 else if (STRICMP(name, "ttyin") == 0)
5534 {
5535 x = TRUE;
5536 n = mch_input_isatty();
5537 }
5538 else if (STRICMP(name, "ttyout") == 0)
5539 {
5540 x = TRUE;
5541 n = stdout_isatty;
5542 }
5543 else if (STRICMP(name, "multi_byte_encoding") == 0)
5544 {
5545 x = TRUE;
5546 n = has_mbyte;
5547 }
5548 else if (STRICMP(name, "gui_running") == 0)
5549 {
5550 x = TRUE;
5551#ifdef FEAT_GUI
5552 n = (gui.in_use || gui.starting);
5553#endif
5554 }
5555 else if (STRICMP(name, "browse") == 0)
5556 {
5557 x = TRUE;
5558#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
5559 n = gui.in_use; // gui_mch_browse() works when GUI is running
5560#endif
5561 }
5562 else if (STRICMP(name, "syntax_items") == 0)
5563 {
5564 x = TRUE;
5565#ifdef FEAT_SYN_HL
5566 n = syntax_present(curwin);
5567#endif
5568 }
5569 else if (STRICMP(name, "vcon") == 0)
5570 {
5571 x = TRUE;
5572#ifdef FEAT_VTP
5573 n = is_term_win32() && has_vtp_working();
5574#endif
5575 }
5576 else if (STRICMP(name, "netbeans_enabled") == 0)
5577 {
5578 x = TRUE;
5579#ifdef FEAT_NETBEANS_INTG
5580 n = netbeans_active();
5581#endif
5582 }
5583 else if (STRICMP(name, "mouse_gpm_enabled") == 0)
5584 {
5585 x = TRUE;
5586#ifdef FEAT_MOUSE_GPM
5587 n = gpm_enabled();
5588#endif
5589 }
5590 else if (STRICMP(name, "conpty") == 0)
5591 {
5592 x = TRUE;
5593#if defined(FEAT_TERMINAL) && defined(MSWIN)
5594 n = use_conpty();
5595#endif
5596 }
5597 else if (STRICMP(name, "clipboard_working") == 0)
5598 {
5599 x = TRUE;
5600#ifdef FEAT_CLIPBOARD
5601 n = clip_star.available;
5602#endif
5603 }
5604 }
5605
Bram Moolenaar04637e22020-09-05 18:45:29 +02005606 if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1]))
Bram Moolenaar79296512020-03-22 16:17:14 +01005607 // return whether feature could ever be enabled
5608 rettv->vval.v_number = x;
5609 else
5610 // return whether feature is enabled
5611 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005612}
5613
5614/*
Bram Moolenaar8cebd432020-11-08 12:49:47 +01005615 * Return TRUE if "feature" can change later.
5616 * Also when checking for the feature has side effects, such as loading a DLL.
5617 */
5618 int
5619dynamic_feature(char_u *feature)
5620{
5621 return (feature == NULL
5622#if defined(FEAT_BEVAL) && defined(FEAT_GUI_MSWIN)
5623 || STRICMP(feature, "balloon_multiline") == 0
5624#endif
5625#if defined(FEAT_GUI) && defined(FEAT_BROWSE)
5626 || (STRICMP(feature, "browse") == 0 && !gui.in_use)
5627#endif
5628#ifdef VIMDLL
5629 || STRICMP(feature, "filterpipe") == 0
5630#endif
Bram Moolenaar29b281b2020-11-10 20:58:00 +01005631#if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL)
Bram Moolenaar8cebd432020-11-08 12:49:47 +01005632 // this can only change on Unix where the ":gui" command could be
5633 // used.
5634 || (STRICMP(feature, "gui_running") == 0 && !gui.in_use)
5635#endif
5636#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
5637 || STRICMP(feature, "iconv") == 0
5638#endif
5639#ifdef DYNAMIC_LUA
5640 || STRICMP(feature, "lua") == 0
5641#endif
5642#ifdef FEAT_MOUSE_GPM
5643 || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled())
5644#endif
5645#ifdef DYNAMIC_MZSCHEME
5646 || STRICMP(feature, "mzscheme") == 0
5647#endif
5648#ifdef FEAT_NETBEANS_INTG
5649 || STRICMP(feature, "netbeans_enabled") == 0
5650#endif
5651#ifdef DYNAMIC_PERL
5652 || STRICMP(feature, "perl") == 0
5653#endif
5654#ifdef DYNAMIC_PYTHON
5655 || STRICMP(feature, "python") == 0
5656#endif
5657#ifdef DYNAMIC_PYTHON3
5658 || STRICMP(feature, "python3") == 0
5659#endif
5660#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
5661 || STRICMP(feature, "pythonx") == 0
5662#endif
5663#ifdef DYNAMIC_RUBY
5664 || STRICMP(feature, "ruby") == 0
5665#endif
5666#ifdef FEAT_SYN_HL
5667 || STRICMP(feature, "syntax_items") == 0
5668#endif
5669#ifdef DYNAMIC_TCL
5670 || STRICMP(feature, "tcl") == 0
5671#endif
5672 // once "starting" is zero it will stay that way
5673 || (STRICMP(feature, "vim_starting") == 0 && starting != 0)
5674 || STRICMP(feature, "multi_byte_encoding") == 0
5675#if defined(FEAT_TERMINAL) && defined(MSWIN)
5676 || STRICMP(feature, "conpty") == 0
5677#endif
5678 );
5679}
5680
5681/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005682 * "haslocaldir()" function
5683 */
5684 static void
5685f_haslocaldir(typval_T *argvars, typval_T *rettv)
5686{
Bram Moolenaar00aa0692019-04-27 20:37:57 +02005687 tabpage_T *tp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005688 win_T *wp = NULL;
5689
Bram Moolenaar00aa0692019-04-27 20:37:57 +02005690 wp = find_tabwin(&argvars[0], &argvars[1], &tp);
5691
5692 // Check for window-local and tab-local directories
5693 if (wp != NULL && wp->w_localdir != NULL)
5694 rettv->vval.v_number = 1;
5695 else if (tp != NULL && tp->tp_localdir != NULL)
5696 rettv->vval.v_number = 2;
5697 else
5698 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005699}
5700
5701/*
5702 * "hasmapto()" function
5703 */
5704 static void
5705f_hasmapto(typval_T *argvars, typval_T *rettv)
5706{
5707 char_u *name;
5708 char_u *mode;
5709 char_u buf[NUMBUFLEN];
5710 int abbr = FALSE;
5711
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005712 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005713 if (argvars[1].v_type == VAR_UNKNOWN)
5714 mode = (char_u *)"nvo";
5715 else
5716 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005717 mode = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005718 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar04d594b2020-09-02 22:25:35 +02005719 abbr = (int)tv_get_bool(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005720 }
5721
5722 if (map_to_exists(name, mode, abbr))
5723 rettv->vval.v_number = TRUE;
5724 else
5725 rettv->vval.v_number = FALSE;
5726}
5727
5728/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005729 * "highlightID(name)" function
5730 */
5731 static void
5732f_hlID(typval_T *argvars, typval_T *rettv)
5733{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005734 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005735}
5736
5737/*
5738 * "highlight_exists()" function
5739 */
5740 static void
5741f_hlexists(typval_T *argvars, typval_T *rettv)
5742{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005743 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005744}
5745
5746/*
5747 * "hostname()" function
5748 */
5749 static void
5750f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
5751{
5752 char_u hostname[256];
5753
5754 mch_get_host_name(hostname, 256);
5755 rettv->v_type = VAR_STRING;
5756 rettv->vval.v_string = vim_strsave(hostname);
5757}
5758
5759/*
5760 * iconv() function
5761 */
5762 static void
5763f_iconv(typval_T *argvars UNUSED, typval_T *rettv)
5764{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005765 char_u buf1[NUMBUFLEN];
5766 char_u buf2[NUMBUFLEN];
5767 char_u *from, *to, *str;
5768 vimconv_T vimconv;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005769
5770 rettv->v_type = VAR_STRING;
5771 rettv->vval.v_string = NULL;
5772
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005773 str = tv_get_string(&argvars[0]);
5774 from = enc_canonize(enc_skip(tv_get_string_buf(&argvars[1], buf1)));
5775 to = enc_canonize(enc_skip(tv_get_string_buf(&argvars[2], buf2)));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005776 vimconv.vc_type = CONV_NONE;
5777 convert_setup(&vimconv, from, to);
5778
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005779 // If the encodings are equal, no conversion needed.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005780 if (vimconv.vc_type == CONV_NONE)
5781 rettv->vval.v_string = vim_strsave(str);
5782 else
5783 rettv->vval.v_string = string_convert(&vimconv, str, NULL);
5784
5785 convert_setup(&vimconv, NULL, NULL);
5786 vim_free(from);
5787 vim_free(to);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005788}
5789
5790/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005791 * "index()" function
5792 */
5793 static void
5794f_index(typval_T *argvars, typval_T *rettv)
5795{
5796 list_T *l;
5797 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005798 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005799 long idx = 0;
5800 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005801 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005802
5803 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005804 if (argvars[0].v_type == VAR_BLOB)
5805 {
5806 typval_T tv;
5807 int start = 0;
5808
5809 if (argvars[2].v_type != VAR_UNKNOWN)
5810 {
5811 start = tv_get_number_chk(&argvars[2], &error);
5812 if (error)
5813 return;
5814 }
5815 b = argvars[0].vval.v_blob;
5816 if (b == NULL)
5817 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01005818 if (start < 0)
5819 {
5820 start = blob_len(b) + start;
5821 if (start < 0)
5822 start = 0;
5823 }
5824
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005825 for (idx = start; idx < blob_len(b); ++idx)
5826 {
5827 tv.v_type = VAR_NUMBER;
5828 tv.vval.v_number = blob_get(b, idx);
5829 if (tv_equal(&tv, &argvars[1], ic, FALSE))
5830 {
5831 rettv->vval.v_number = idx;
5832 return;
5833 }
5834 }
5835 return;
5836 }
5837 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005838 {
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01005839 emsg(_(e_listblobreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005840 return;
5841 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01005842
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005843 l = argvars[0].vval.v_list;
5844 if (l != NULL)
5845 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02005846 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005847 item = l->lv_first;
5848 if (argvars[2].v_type != VAR_UNKNOWN)
5849 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005850 // Start at specified item. Use the cached index that list_find()
5851 // sets, so that a negative number also works.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005852 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01005853 idx = l->lv_u.mat.lv_idx;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005854 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaar6c553f92020-09-02 22:10:34 +02005855 ic = (int)tv_get_bool_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005856 if (error)
5857 item = NULL;
5858 }
5859
5860 for ( ; item != NULL; item = item->li_next, ++idx)
5861 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
5862 {
5863 rettv->vval.v_number = idx;
5864 break;
5865 }
5866 }
5867}
5868
5869static int inputsecret_flag = 0;
5870
5871/*
5872 * "input()" function
5873 * Also handles inputsecret() when inputsecret is set.
5874 */
5875 static void
5876f_input(typval_T *argvars, typval_T *rettv)
5877{
5878 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
5879}
5880
5881/*
5882 * "inputdialog()" function
5883 */
5884 static void
5885f_inputdialog(typval_T *argvars, typval_T *rettv)
5886{
5887#if defined(FEAT_GUI_TEXTDIALOG)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005888 // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions'
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005889 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
5890 {
5891 char_u *message;
5892 char_u buf[NUMBUFLEN];
5893 char_u *defstr = (char_u *)"";
5894
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005895 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005896 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005897 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005898 vim_strncpy(IObuff, defstr, IOSIZE - 1);
5899 else
5900 IObuff[0] = NUL;
5901 if (message != NULL && defstr != NULL
5902 && do_dialog(VIM_QUESTION, NULL, message,
5903 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
5904 rettv->vval.v_string = vim_strsave(IObuff);
5905 else
5906 {
5907 if (message != NULL && defstr != NULL
5908 && argvars[1].v_type != VAR_UNKNOWN
5909 && argvars[2].v_type != VAR_UNKNOWN)
5910 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005911 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005912 else
5913 rettv->vval.v_string = NULL;
5914 }
5915 rettv->v_type = VAR_STRING;
5916 }
5917 else
5918#endif
5919 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
5920}
5921
5922/*
5923 * "inputlist()" function
5924 */
5925 static void
5926f_inputlist(typval_T *argvars, typval_T *rettv)
5927{
Bram Moolenaar50985eb2020-01-27 22:09:39 +01005928 list_T *l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005929 listitem_T *li;
5930 int selected;
5931 int mouse_used;
5932
5933#ifdef NO_CONSOLE_INPUT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005934 // While starting up, there is no place to enter text. When running tests
5935 // with --not-a-term we assume feedkeys() will be used.
Bram Moolenaar91d348a2017-07-29 20:16:03 +02005936 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005937 return;
5938#endif
5939 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
5940 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005941 semsg(_(e_listarg), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005942 return;
5943 }
5944
5945 msg_start();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005946 msg_row = Rows - 1; // for when 'cmdheight' > 1
5947 lines_left = Rows; // avoid more prompt
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005948 msg_scroll = TRUE;
5949 msg_clr_eos();
5950
Bram Moolenaar50985eb2020-01-27 22:09:39 +01005951 l = argvars[0].vval.v_list;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02005952 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02005953 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005954 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005955 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005956 msg_putchar('\n');
5957 }
5958
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005959 // Ask for choice.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005960 selected = prompt_for_number(&mouse_used);
5961 if (mouse_used)
5962 selected -= lines_left;
5963
5964 rettv->vval.v_number = selected;
5965}
5966
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005967static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
5968
5969/*
5970 * "inputrestore()" function
5971 */
5972 static void
5973f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
5974{
5975 if (ga_userinput.ga_len > 0)
5976 {
5977 --ga_userinput.ga_len;
5978 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
Bram Moolenaarc41badb2021-06-07 22:04:52 +02005979 + ga_userinput.ga_len, TRUE);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005980 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005981 }
5982 else if (p_verbose > 1)
5983 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005984 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005985 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005986 }
5987}
5988
5989/*
5990 * "inputsave()" function
5991 */
5992 static void
5993f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
5994{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005995 // Add an entry to the stack of typeahead storage.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005996 if (ga_grow(&ga_userinput, 1) == OK)
5997 {
5998 save_typeahead((tasave_T *)(ga_userinput.ga_data)
5999 + ga_userinput.ga_len);
6000 ++ga_userinput.ga_len;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006001 // default return is zero == OK
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006002 }
6003 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006004 rettv->vval.v_number = 1; // Failed
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006005}
6006
6007/*
6008 * "inputsecret()" function
6009 */
6010 static void
6011f_inputsecret(typval_T *argvars, typval_T *rettv)
6012{
6013 ++cmdline_star;
6014 ++inputsecret_flag;
6015 f_input(argvars, rettv);
6016 --cmdline_star;
6017 --inputsecret_flag;
6018}
6019
6020/*
Bram Moolenaar67a2deb2019-11-25 00:05:32 +01006021 * "interrupt()" function
6022 */
6023 static void
6024f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
6025{
6026 got_int = TRUE;
6027}
6028
6029/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006030 * "invert(expr)" function
6031 */
6032 static void
6033f_invert(typval_T *argvars, typval_T *rettv)
6034{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006035 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006036}
6037
6038/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006039 * "islocked()" function
6040 */
6041 static void
6042f_islocked(typval_T *argvars, typval_T *rettv)
6043{
6044 lval_T lv;
6045 char_u *end;
6046 dictitem_T *di;
6047
6048 rettv->vval.v_number = -1;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006049 end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
Bram Moolenaar3a257732017-02-21 20:47:13 +01006050 GLV_NO_AUTOLOAD | GLV_READ_ONLY, FNE_CHECK_START);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006051 if (end != NULL && lv.ll_name != NULL)
6052 {
6053 if (*end != NUL)
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +02006054 semsg(_(e_trailing_arg), end);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006055 else
6056 {
6057 if (lv.ll_tv == NULL)
6058 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01006059 di = find_var(lv.ll_name, NULL, TRUE);
6060 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006061 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006062 // Consider a variable locked when:
6063 // 1. the variable itself is locked
6064 // 2. the value of the variable is locked.
6065 // 3. the List or Dict value is locked.
Bram Moolenaar79518e22017-02-17 16:31:35 +01006066 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
6067 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006068 }
6069 }
6070 else if (lv.ll_range)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006071 emsg(_("E786: Range not allowed"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006072 else if (lv.ll_newkey != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006073 semsg(_(e_dictkey), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006074 else if (lv.ll_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006075 // List item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006076 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
6077 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006078 // Dictionary item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006079 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
6080 }
6081 }
6082
6083 clear_lval(&lv);
6084}
6085
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006086/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006087 * "last_buffer_nr()" function.
6088 */
6089 static void
6090f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
6091{
6092 int n = 0;
6093 buf_T *buf;
6094
Bram Moolenaar29323592016-07-24 22:04:11 +02006095 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006096 if (n < buf->b_fnum)
6097 n = buf->b_fnum;
6098
6099 rettv->vval.v_number = n;
6100}
6101
6102/*
6103 * "len()" function
6104 */
6105 static void
6106f_len(typval_T *argvars, typval_T *rettv)
6107{
6108 switch (argvars[0].v_type)
6109 {
6110 case VAR_STRING:
6111 case VAR_NUMBER:
6112 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006113 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006114 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01006115 case VAR_BLOB:
6116 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
6117 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006118 case VAR_LIST:
6119 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
6120 break;
6121 case VAR_DICT:
6122 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
6123 break;
6124 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02006125 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006126 case VAR_VOID:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01006127 case VAR_BOOL:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006128 case VAR_SPECIAL:
6129 case VAR_FLOAT:
6130 case VAR_FUNC:
6131 case VAR_PARTIAL:
6132 case VAR_JOB:
6133 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02006134 case VAR_INSTR:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006135 emsg(_("E701: Invalid type for len()"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006136 break;
6137 }
6138}
6139
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006140 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01006141libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006142{
6143#ifdef FEAT_LIBCALL
6144 char_u *string_in;
6145 char_u **string_result;
6146 int nr_result;
6147#endif
6148
6149 rettv->v_type = type;
6150 if (type != VAR_NUMBER)
6151 rettv->vval.v_string = NULL;
6152
6153 if (check_restricted() || check_secure())
6154 return;
6155
6156#ifdef FEAT_LIBCALL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006157 // The first two args must be strings, otherwise it's meaningless
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006158 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
6159 {
6160 string_in = NULL;
6161 if (argvars[2].v_type == VAR_STRING)
6162 string_in = argvars[2].vval.v_string;
6163 if (type == VAR_NUMBER)
6164 string_result = NULL;
6165 else
6166 string_result = &rettv->vval.v_string;
6167 if (mch_libcall(argvars[0].vval.v_string,
6168 argvars[1].vval.v_string,
6169 string_in,
6170 argvars[2].vval.v_number,
6171 string_result,
6172 &nr_result) == OK
6173 && type == VAR_NUMBER)
6174 rettv->vval.v_number = nr_result;
6175 }
6176#endif
6177}
6178
6179/*
6180 * "libcall()" function
6181 */
6182 static void
6183f_libcall(typval_T *argvars, typval_T *rettv)
6184{
6185 libcall_common(argvars, rettv, VAR_STRING);
6186}
6187
6188/*
6189 * "libcallnr()" function
6190 */
6191 static void
6192f_libcallnr(typval_T *argvars, typval_T *rettv)
6193{
6194 libcall_common(argvars, rettv, VAR_NUMBER);
6195}
6196
6197/*
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006198 * "line(string, [winid])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006199 */
6200 static void
6201f_line(typval_T *argvars, typval_T *rettv)
6202{
6203 linenr_T lnum = 0;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006204 pos_T *fp = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006205 int fnum;
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006206 int id;
6207 tabpage_T *tp;
6208 win_T *wp;
6209 win_T *save_curwin;
6210 tabpage_T *save_curtab;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006211
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006212 if (argvars[1].v_type != VAR_UNKNOWN)
6213 {
6214 // use window specified in the second argument
6215 id = (int)tv_get_number(&argvars[1]);
6216 wp = win_id2wp_tp(id, &tp);
6217 if (wp != NULL && tp != NULL)
6218 {
6219 if (switch_win_noblock(&save_curwin, &save_curtab, wp, tp, TRUE)
6220 == OK)
6221 {
6222 check_cursor();
Bram Moolenaar6f02b002021-01-10 20:22:54 +01006223 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006224 }
6225 restore_win_noblock(save_curwin, save_curtab, TRUE);
6226 }
6227 }
6228 else
6229 // use current window
Bram Moolenaar6f02b002021-01-10 20:22:54 +01006230 fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE);
Bram Moolenaar8e0a8e72019-09-02 22:56:24 +02006231
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006232 if (fp != NULL)
6233 lnum = fp->lnum;
6234 rettv->vval.v_number = lnum;
6235}
6236
6237/*
6238 * "line2byte(lnum)" function
6239 */
6240 static void
6241f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
6242{
6243#ifndef FEAT_BYTEOFF
6244 rettv->vval.v_number = -1;
6245#else
6246 linenr_T lnum;
6247
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006248 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006249 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
6250 rettv->vval.v_number = -1;
6251 else
6252 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
6253 if (rettv->vval.v_number >= 0)
6254 ++rettv->vval.v_number;
6255#endif
6256}
6257
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006258#ifdef FEAT_LUA
6259/*
6260 * "luaeval()" function
6261 */
6262 static void
6263f_luaeval(typval_T *argvars, typval_T *rettv)
6264{
6265 char_u *str;
6266 char_u buf[NUMBUFLEN];
6267
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006268 if (check_restricted() || check_secure())
6269 return;
6270
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006271 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006272 do_luaeval(str, argvars + 1, rettv);
6273}
6274#endif
6275
6276/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006277 * "maparg()" function
6278 */
6279 static void
6280f_maparg(typval_T *argvars, typval_T *rettv)
6281{
6282 get_maparg(argvars, rettv, TRUE);
6283}
6284
6285/*
6286 * "mapcheck()" function
6287 */
6288 static void
6289f_mapcheck(typval_T *argvars, typval_T *rettv)
6290{
6291 get_maparg(argvars, rettv, FALSE);
6292}
6293
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006294typedef enum
6295{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006296 MATCH_END, // matchend()
6297 MATCH_MATCH, // match()
6298 MATCH_STR, // matchstr()
6299 MATCH_LIST, // matchlist()
6300 MATCH_POS // matchstrpos()
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006301} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006302
6303 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006304find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006305{
6306 char_u *str = NULL;
6307 long len = 0;
6308 char_u *expr = NULL;
6309 char_u *pat;
6310 regmatch_T regmatch;
6311 char_u patbuf[NUMBUFLEN];
6312 char_u strbuf[NUMBUFLEN];
6313 char_u *save_cpo;
6314 long start = 0;
6315 long nth = 1;
6316 colnr_T startcol = 0;
6317 int match = 0;
6318 list_T *l = NULL;
6319 listitem_T *li = NULL;
6320 long idx = 0;
6321 char_u *tofree = NULL;
6322
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006323 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006324 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01006325 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006326
6327 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006328 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006329 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006330 // type MATCH_LIST: return empty list when there are no matches.
6331 // type MATCH_POS: return ["", -1, -1, -1]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006332 if (rettv_list_alloc(rettv) == FAIL)
6333 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006334 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006335 && (list_append_string(rettv->vval.v_list,
6336 (char_u *)"", 0) == FAIL
6337 || list_append_number(rettv->vval.v_list,
6338 (varnumber_T)-1) == FAIL
6339 || list_append_number(rettv->vval.v_list,
6340 (varnumber_T)-1) == FAIL
6341 || list_append_number(rettv->vval.v_list,
6342 (varnumber_T)-1) == FAIL))
6343 {
6344 list_free(rettv->vval.v_list);
6345 rettv->vval.v_list = NULL;
6346 goto theend;
6347 }
6348 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006349 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006350 {
6351 rettv->v_type = VAR_STRING;
6352 rettv->vval.v_string = NULL;
6353 }
6354
6355 if (argvars[0].v_type == VAR_LIST)
6356 {
6357 if ((l = argvars[0].vval.v_list) == NULL)
6358 goto theend;
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02006359 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006360 li = l->lv_first;
6361 }
6362 else
6363 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006364 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006365 len = (long)STRLEN(str);
6366 }
6367
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006368 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006369 if (pat == NULL)
6370 goto theend;
6371
6372 if (argvars[2].v_type != VAR_UNKNOWN)
6373 {
6374 int error = FALSE;
6375
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006376 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006377 if (error)
6378 goto theend;
6379 if (l != NULL)
6380 {
6381 li = list_find(l, start);
6382 if (li == NULL)
6383 goto theend;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006384 idx = l->lv_u.mat.lv_idx; // use the cached index
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006385 }
6386 else
6387 {
6388 if (start < 0)
6389 start = 0;
6390 if (start > len)
6391 goto theend;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006392 // When "count" argument is there ignore matches before "start",
6393 // otherwise skip part of the string. Differs when pattern is "^"
6394 // or "\<".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006395 if (argvars[3].v_type != VAR_UNKNOWN)
6396 startcol = start;
6397 else
6398 {
6399 str += start;
6400 len -= start;
6401 }
6402 }
6403
6404 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006405 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006406 if (error)
6407 goto theend;
6408 }
6409
6410 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
6411 if (regmatch.regprog != NULL)
6412 {
6413 regmatch.rm_ic = p_ic;
6414
6415 for (;;)
6416 {
6417 if (l != NULL)
6418 {
6419 if (li == NULL)
6420 {
6421 match = FALSE;
6422 break;
6423 }
6424 vim_free(tofree);
6425 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
6426 if (str == NULL)
6427 break;
6428 }
6429
6430 match = vim_regexec_nl(&regmatch, str, (colnr_T)startcol);
6431
6432 if (match && --nth <= 0)
6433 break;
6434 if (l == NULL && !match)
6435 break;
6436
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006437 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006438 if (l != NULL)
6439 {
6440 li = li->li_next;
6441 ++idx;
6442 }
6443 else
6444 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006445 startcol = (colnr_T)(regmatch.startp[0]
6446 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006447 if (startcol > (colnr_T)len
6448 || str + startcol <= regmatch.startp[0])
6449 {
6450 match = FALSE;
6451 break;
6452 }
6453 }
6454 }
6455
6456 if (match)
6457 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006458 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006459 {
6460 listitem_T *li1 = rettv->vval.v_list->lv_first;
6461 listitem_T *li2 = li1->li_next;
6462 listitem_T *li3 = li2->li_next;
6463 listitem_T *li4 = li3->li_next;
6464
6465 vim_free(li1->li_tv.vval.v_string);
6466 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02006467 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006468 li3->li_tv.vval.v_number =
6469 (varnumber_T)(regmatch.startp[0] - expr);
6470 li4->li_tv.vval.v_number =
6471 (varnumber_T)(regmatch.endp[0] - expr);
6472 if (l != NULL)
6473 li2->li_tv.vval.v_number = (varnumber_T)idx;
6474 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006475 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006476 {
6477 int i;
6478
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006479 // return list with matched string and submatches
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006480 for (i = 0; i < NSUBEXP; ++i)
6481 {
6482 if (regmatch.endp[i] == NULL)
6483 {
6484 if (list_append_string(rettv->vval.v_list,
6485 (char_u *)"", 0) == FAIL)
6486 break;
6487 }
6488 else if (list_append_string(rettv->vval.v_list,
6489 regmatch.startp[i],
6490 (int)(regmatch.endp[i] - regmatch.startp[i]))
6491 == FAIL)
6492 break;
6493 }
6494 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006495 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006496 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006497 // return matched string
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006498 if (l != NULL)
6499 copy_tv(&li->li_tv, rettv);
6500 else
6501 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
Bram Moolenaardf44a272020-06-07 20:49:05 +02006502 regmatch.endp[0] - regmatch.startp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006503 }
6504 else if (l != NULL)
6505 rettv->vval.v_number = idx;
6506 else
6507 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006508 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006509 rettv->vval.v_number =
6510 (varnumber_T)(regmatch.startp[0] - str);
6511 else
6512 rettv->vval.v_number =
6513 (varnumber_T)(regmatch.endp[0] - str);
6514 rettv->vval.v_number += (varnumber_T)(str - expr);
6515 }
6516 }
6517 vim_regfree(regmatch.regprog);
6518 }
6519
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006520theend:
6521 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006522 // matchstrpos() without a list: drop the second item.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006523 listitem_remove(rettv->vval.v_list,
6524 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006525 vim_free(tofree);
6526 p_cpo = save_cpo;
6527}
6528
6529/*
6530 * "match()" function
6531 */
6532 static void
6533f_match(typval_T *argvars, typval_T *rettv)
6534{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006535 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006536}
6537
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006538/*
6539 * "matchend()" function
6540 */
6541 static void
6542f_matchend(typval_T *argvars, typval_T *rettv)
6543{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006544 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006545}
6546
6547/*
6548 * "matchlist()" function
6549 */
6550 static void
6551f_matchlist(typval_T *argvars, typval_T *rettv)
6552{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006553 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006554}
6555
6556/*
6557 * "matchstr()" function
6558 */
6559 static void
6560f_matchstr(typval_T *argvars, typval_T *rettv)
6561{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006562 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006563}
6564
6565/*
6566 * "matchstrpos()" function
6567 */
6568 static void
6569f_matchstrpos(typval_T *argvars, typval_T *rettv)
6570{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02006571 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006572}
6573
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006574 static void
6575max_min(typval_T *argvars, typval_T *rettv, int domax)
6576{
6577 varnumber_T n = 0;
6578 varnumber_T i;
6579 int error = FALSE;
6580
6581 if (argvars[0].v_type == VAR_LIST)
6582 {
6583 list_T *l;
6584 listitem_T *li;
6585
6586 l = argvars[0].vval.v_list;
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006587 if (l != NULL && l->lv_len > 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006588 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006589 if (l->lv_first == &range_list_item)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006590 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006591 if ((l->lv_u.nonmat.lv_stride > 0) ^ domax)
6592 n = l->lv_u.nonmat.lv_start;
6593 else
6594 n = l->lv_u.nonmat.lv_start + (l->lv_len - 1)
6595 * l->lv_u.nonmat.lv_stride;
6596 }
6597 else
6598 {
6599 li = l->lv_first;
6600 if (li != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006601 {
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006602 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01006603 if (error)
6604 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006605 for (;;)
6606 {
6607 li = li->li_next;
6608 if (li == NULL)
6609 break;
6610 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01006611 if (error)
6612 return; // type error; errmsg already given
Bram Moolenaar9f2d0202020-01-30 16:40:10 +01006613 if (domax ? i > n : i < n)
6614 n = i;
6615 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006616 }
6617 }
6618 }
6619 }
6620 else if (argvars[0].v_type == VAR_DICT)
6621 {
6622 dict_T *d;
6623 int first = TRUE;
6624 hashitem_T *hi;
6625 int todo;
6626
6627 d = argvars[0].vval.v_dict;
6628 if (d != NULL)
6629 {
6630 todo = (int)d->dv_hashtab.ht_used;
6631 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
6632 {
6633 if (!HASHITEM_EMPTY(hi))
6634 {
6635 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006636 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaarab65fc72021-02-04 22:07:16 +01006637 if (error)
6638 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006639 if (first)
6640 {
6641 n = i;
6642 first = FALSE;
6643 }
6644 else if (domax ? i > n : i < n)
6645 n = i;
6646 }
6647 }
6648 }
6649 }
6650 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006651 semsg(_(e_listdictarg), domax ? "max()" : "min()");
Bram Moolenaarab65fc72021-02-04 22:07:16 +01006652
6653 rettv->vval.v_number = n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006654}
6655
6656/*
6657 * "max()" function
6658 */
6659 static void
6660f_max(typval_T *argvars, typval_T *rettv)
6661{
6662 max_min(argvars, rettv, TRUE);
6663}
6664
6665/*
6666 * "min()" function
6667 */
6668 static void
6669f_min(typval_T *argvars, typval_T *rettv)
6670{
6671 max_min(argvars, rettv, FALSE);
6672}
6673
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006674#if defined(FEAT_MZSCHEME) || defined(PROTO)
6675/*
6676 * "mzeval()" function
6677 */
6678 static void
6679f_mzeval(typval_T *argvars, typval_T *rettv)
6680{
6681 char_u *str;
6682 char_u buf[NUMBUFLEN];
6683
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006684 if (check_restricted() || check_secure())
6685 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006686 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006687 do_mzeval(str, rettv);
6688}
6689
6690 void
6691mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
6692{
6693 typval_T argvars[3];
6694
6695 argvars[0].v_type = VAR_STRING;
6696 argvars[0].vval.v_string = name;
6697 copy_tv(args, &argvars[1]);
6698 argvars[2].v_type = VAR_UNKNOWN;
6699 f_call(argvars, rettv);
6700 clear_tv(&argvars[1]);
6701}
6702#endif
6703
6704/*
6705 * "nextnonblank()" function
6706 */
6707 static void
6708f_nextnonblank(typval_T *argvars, typval_T *rettv)
6709{
6710 linenr_T lnum;
6711
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006712 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006713 {
6714 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
6715 {
6716 lnum = 0;
6717 break;
6718 }
6719 if (*skipwhite(ml_get(lnum)) != NUL)
6720 break;
6721 }
6722 rettv->vval.v_number = lnum;
6723}
6724
6725/*
6726 * "nr2char()" function
6727 */
6728 static void
6729f_nr2char(typval_T *argvars, typval_T *rettv)
6730{
6731 char_u buf[NUMBUFLEN];
6732
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006733 if (has_mbyte)
6734 {
6735 int utf8 = 0;
6736
6737 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaared6a4302020-09-05 20:29:41 +02006738 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006739 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01006740 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006741 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006742 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006743 }
6744 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006745 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006746 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006747 buf[1] = NUL;
6748 }
6749 rettv->v_type = VAR_STRING;
6750 rettv->vval.v_string = vim_strsave(buf);
6751}
6752
6753/*
6754 * "or(expr, expr)" function
6755 */
6756 static void
6757f_or(typval_T *argvars, typval_T *rettv)
6758{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006759 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
6760 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006761}
6762
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006763#ifdef FEAT_PERL
6764/*
6765 * "perleval()" function
6766 */
6767 static void
6768f_perleval(typval_T *argvars, typval_T *rettv)
6769{
6770 char_u *str;
6771 char_u buf[NUMBUFLEN];
6772
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006773 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006774 do_perleval(str, rettv);
6775}
6776#endif
6777
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006778/*
6779 * "prevnonblank()" function
6780 */
6781 static void
6782f_prevnonblank(typval_T *argvars, typval_T *rettv)
6783{
6784 linenr_T lnum;
6785
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006786 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006787 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
6788 lnum = 0;
6789 else
6790 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
6791 --lnum;
6792 rettv->vval.v_number = lnum;
6793}
6794
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006795// This dummy va_list is here because:
6796// - passing a NULL pointer doesn't work when va_list isn't a pointer
6797// - locally in the function results in a "used before set" warning
6798// - using va_start() to initialize it gives "function with fixed args" error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006799static va_list ap;
6800
6801/*
6802 * "printf()" function
6803 */
6804 static void
6805f_printf(typval_T *argvars, typval_T *rettv)
6806{
6807 char_u buf[NUMBUFLEN];
6808 int len;
6809 char_u *s;
6810 int saved_did_emsg = did_emsg;
6811 char *fmt;
6812
6813 rettv->v_type = VAR_STRING;
6814 rettv->vval.v_string = NULL;
6815
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01006816 // Get the required length, allocate the buffer and do it for real.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006817 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006818 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02006819 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006820 if (!did_emsg)
6821 {
6822 s = alloc(len + 1);
6823 if (s != NULL)
6824 {
6825 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02006826 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
6827 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006828 }
6829 }
6830 did_emsg |= saved_did_emsg;
6831}
6832
6833/*
Bram Moolenaare9bd5722019-08-17 19:36:06 +02006834 * "pum_getpos()" function
6835 */
6836 static void
6837f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
6838{
6839 if (rettv_dict_alloc(rettv) != OK)
6840 return;
Bram Moolenaare9bd5722019-08-17 19:36:06 +02006841 pum_set_event_info(rettv->vval.v_dict);
Bram Moolenaare9bd5722019-08-17 19:36:06 +02006842}
6843
6844/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006845 * "pumvisible()" function
6846 */
6847 static void
6848f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
6849{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006850 if (pum_visible())
6851 rettv->vval.v_number = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006852}
6853
6854#ifdef FEAT_PYTHON3
6855/*
6856 * "py3eval()" function
6857 */
6858 static void
6859f_py3eval(typval_T *argvars, typval_T *rettv)
6860{
6861 char_u *str;
6862 char_u buf[NUMBUFLEN];
6863
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006864 if (check_restricted() || check_secure())
6865 return;
6866
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006867 if (p_pyx == 0)
6868 p_pyx = 3;
6869
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006870 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006871 do_py3eval(str, rettv);
6872}
6873#endif
6874
6875#ifdef FEAT_PYTHON
6876/*
6877 * "pyeval()" function
6878 */
6879 static void
6880f_pyeval(typval_T *argvars, typval_T *rettv)
6881{
6882 char_u *str;
6883 char_u buf[NUMBUFLEN];
6884
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006885 if (check_restricted() || check_secure())
6886 return;
6887
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006888 if (p_pyx == 0)
6889 p_pyx = 2;
6890
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006891 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006892 do_pyeval(str, rettv);
6893}
6894#endif
6895
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006896#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
6897/*
6898 * "pyxeval()" function
6899 */
6900 static void
6901f_pyxeval(typval_T *argvars, typval_T *rettv)
6902{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006903 if (check_restricted() || check_secure())
6904 return;
6905
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006906# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
6907 init_pyxversion();
6908 if (p_pyx == 2)
6909 f_pyeval(argvars, rettv);
6910 else
6911 f_py3eval(argvars, rettv);
6912# elif defined(FEAT_PYTHON)
6913 f_pyeval(argvars, rettv);
6914# elif defined(FEAT_PYTHON3)
6915 f_py3eval(argvars, rettv);
6916# endif
6917}
6918#endif
6919
Bram Moolenaar4f645c52020-02-08 16:40:39 +01006920static UINT32_T srand_seed_for_testing = 0;
6921static int srand_seed_for_testing_is_used = FALSE;
6922
6923 static void
6924f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED)
6925{
6926 if (argvars[0].v_type == VAR_UNKNOWN)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02006927 srand_seed_for_testing_is_used = FALSE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01006928 else
6929 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02006930 srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]);
6931 srand_seed_for_testing_is_used = TRUE;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01006932 }
6933}
6934
6935 static void
6936init_srand(UINT32_T *x)
6937{
6938#ifndef MSWIN
6939 static int dev_urandom_state = NOTDONE; // FAIL or OK once tried
6940#endif
6941
6942 if (srand_seed_for_testing_is_used)
6943 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02006944 *x = srand_seed_for_testing;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01006945 return;
6946 }
6947#ifndef MSWIN
6948 if (dev_urandom_state != FAIL)
6949 {
6950 int fd = open("/dev/urandom", O_RDONLY);
6951 struct {
6952 union {
6953 UINT32_T number;
6954 char bytes[sizeof(UINT32_T)];
6955 } contents;
6956 } buf;
6957
6958 // Attempt reading /dev/urandom.
6959 if (fd == -1)
6960 dev_urandom_state = FAIL;
6961 else
6962 {
6963 buf.contents.number = 0;
6964 if (read(fd, buf.contents.bytes, sizeof(UINT32_T))
6965 != sizeof(UINT32_T))
6966 dev_urandom_state = FAIL;
6967 else
6968 {
6969 dev_urandom_state = OK;
6970 *x = buf.contents.number;
6971 }
6972 close(fd);
6973 }
6974 }
6975 if (dev_urandom_state != OK)
6976 // Reading /dev/urandom doesn't work, fall back to time().
6977#endif
6978 *x = vim_time();
6979}
6980
6981#define ROTL(x, k) ((x << k) | (x >> (32 - k)))
6982#define SPLITMIX32(x, z) ( \
6983 z = (x += 0x9e3779b9), \
6984 z = (z ^ (z >> 16)) * 0x85ebca6b, \
6985 z = (z ^ (z >> 13)) * 0xc2b2ae35, \
6986 z ^ (z >> 16) \
6987 )
6988#define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \
6989 result = ROTL(y * 5, 7) * 9; \
6990 t = y << 9; \
6991 z ^= x; \
6992 w ^= y; \
6993 y ^= z, x ^= w; \
6994 z ^= t; \
6995 w = ROTL(w, 11);
6996
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006997/*
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01006998 * "rand()" function
6999 */
7000 static void
7001f_rand(typval_T *argvars, typval_T *rettv)
7002{
7003 list_T *l = NULL;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007004 static UINT32_T gx, gy, gz, gw;
7005 static int initialized = FALSE;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007006 listitem_T *lx, *ly, *lz, *lw;
Bram Moolenaar0fd797e2020-11-05 20:46:32 +01007007 UINT32_T x = 0, y, z, w, t, result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007008
7009 if (argvars[0].v_type == VAR_UNKNOWN)
7010 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007011 // When no argument is given use the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007012 if (initialized == FALSE)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007013 {
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007014 // Initialize the global seed list.
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007015 init_srand(&x);
7016
7017 gx = SPLITMIX32(x, z);
7018 gy = SPLITMIX32(x, z);
7019 gz = SPLITMIX32(x, z);
7020 gw = SPLITMIX32(x, z);
7021 initialized = TRUE;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007022 }
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007023
7024 SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw);
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007025 }
7026 else if (argvars[0].v_type == VAR_LIST)
7027 {
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007028 l = argvars[0].vval.v_list;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007029 if (l == NULL || list_len(l) != 4)
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007030 goto theend;
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007031
7032 lx = list_find(l, 0L);
7033 ly = list_find(l, 1L);
7034 lz = list_find(l, 2L);
7035 lw = list_find(l, 3L);
7036 if (lx->li_tv.v_type != VAR_NUMBER) goto theend;
7037 if (ly->li_tv.v_type != VAR_NUMBER) goto theend;
7038 if (lz->li_tv.v_type != VAR_NUMBER) goto theend;
7039 if (lw->li_tv.v_type != VAR_NUMBER) goto theend;
7040 x = (UINT32_T)lx->li_tv.vval.v_number;
7041 y = (UINT32_T)ly->li_tv.vval.v_number;
7042 z = (UINT32_T)lz->li_tv.vval.v_number;
7043 w = (UINT32_T)lw->li_tv.vval.v_number;
7044
7045 SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w);
7046
7047 lx->li_tv.vval.v_number = (varnumber_T)x;
7048 ly->li_tv.vval.v_number = (varnumber_T)y;
7049 lz->li_tv.vval.v_number = (varnumber_T)z;
7050 lw->li_tv.vval.v_number = (varnumber_T)w;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007051 }
7052 else
7053 goto theend;
7054
7055 rettv->v_type = VAR_NUMBER;
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007056 rettv->vval.v_number = (varnumber_T)result;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007057 return;
7058
7059theend:
7060 semsg(_(e_invarg2), tv_get_string(&argvars[0]));
Bram Moolenaarf8c1f922019-11-28 22:13:14 +01007061 rettv->v_type = VAR_NUMBER;
7062 rettv->vval.v_number = -1;
Bram Moolenaar06b0b4b2019-11-25 15:40:55 +01007063}
7064
7065/*
Bram Moolenaar4f645c52020-02-08 16:40:39 +01007066 * "srand()" function
7067 */
7068 static void
7069f_srand(typval_T *argvars, typval_T *rettv)
7070{
7071 UINT32_T x = 0, z;
7072
7073 if (rettv_list_alloc(rettv) == FAIL)
7074 return;
7075 if (argvars[0].v_type == VAR_UNKNOWN)
7076 {
7077 init_srand(&x);
7078 }
7079 else
7080 {
7081 int error = FALSE;
7082
7083 x = (UINT32_T)tv_get_number_chk(&argvars[0], &error);
7084 if (error)
7085 return;
7086 }
7087
7088 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
7089 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
7090 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
7091 list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z));
7092}
7093
7094#undef ROTL
7095#undef SPLITMIX32
7096#undef SHUFFLE_XOSHIRO128STARSTAR
7097
7098/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007099 * "range()" function
7100 */
7101 static void
7102f_range(typval_T *argvars, typval_T *rettv)
7103{
7104 varnumber_T start;
7105 varnumber_T end;
7106 varnumber_T stride = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007107 int error = FALSE;
7108
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007109 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007110 if (argvars[1].v_type == VAR_UNKNOWN)
7111 {
7112 end = start - 1;
7113 start = 0;
7114 }
7115 else
7116 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007117 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007118 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007119 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007120 }
7121
7122 if (error)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007123 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007124 if (stride == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007125 emsg(_("E726: Stride is zero"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007126 else if (stride > 0 ? end + 1 < start : end - 1 > start)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007127 emsg(_("E727: Start past end"));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007128 else if (rettv_list_alloc(rettv) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007129 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007130 list_T *list = rettv->vval.v_list;
7131
7132 // Create a non-materialized list. This is much more efficient and
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007133 // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007134 // be called.
7135 list->lv_first = &range_list_item;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007136 list->lv_u.nonmat.lv_start = start;
7137 list->lv_u.nonmat.lv_end = end;
7138 list->lv_u.nonmat.lv_stride = stride;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01007139 list->lv_len = (end - start) / stride + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007140 }
7141}
7142
7143/*
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007144 * Materialize "list".
7145 * Do not call directly, use CHECK_LIST_MATERIALIZE()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007146 */
7147 void
7148range_list_materialize(list_T *list)
7149{
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007150 varnumber_T start = list->lv_u.nonmat.lv_start;
7151 varnumber_T end = list->lv_u.nonmat.lv_end;
7152 int stride = list->lv_u.nonmat.lv_stride;
7153 varnumber_T i;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007154
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02007155 list->lv_first = NULL;
7156 list->lv_u.mat.lv_last = NULL;
7157 list->lv_len = 0;
7158 list->lv_u.mat.lv_idx_item = NULL;
7159 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
7160 if (list_append_number(list, (varnumber_T)i) == FAIL)
7161 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007162}
7163
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007164/*
7165 * "getreginfo()" function
7166 */
7167 static void
7168f_getreginfo(typval_T *argvars, typval_T *rettv)
7169{
7170 char_u *strregname;
7171 int regname;
7172 char_u buf[NUMBUFLEN + 2];
7173 long reglen = 0;
7174 dict_T *dict;
7175 list_T *list;
7176
7177 if (argvars[0].v_type != VAR_UNKNOWN)
7178 {
7179 strregname = tv_get_string_chk(&argvars[0]);
7180 if (strregname == NULL)
7181 return;
Bram Moolenaar418a29f2021-02-10 22:23:41 +01007182 if (in_vim9script() && STRLEN(strregname) > 1)
7183 {
7184 semsg(_(e_register_name_must_be_one_char_str), strregname);
7185 return;
7186 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007187 }
7188 else
7189 strregname = get_vim_var_str(VV_REG);
7190
7191 regname = (strregname == NULL ? '"' : *strregname);
7192 if (regname == 0 || regname == '@')
7193 regname = '"';
7194
7195 if (rettv_dict_alloc(rettv) == FAIL)
7196 return;
7197 dict = rettv->vval.v_dict;
7198
7199 list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
7200 if (list == NULL)
7201 return;
Bram Moolenaar91639192020-06-29 19:55:58 +02007202 (void)dict_add_list(dict, "regcontents", list);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007203
7204 buf[0] = NUL;
7205 buf[1] = NUL;
7206 switch (get_reg_type(regname, &reglen))
7207 {
7208 case MLINE: buf[0] = 'V'; break;
7209 case MCHAR: buf[0] = 'v'; break;
7210 case MBLOCK:
7211 vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
7212 reglen + 1);
7213 break;
7214 }
Bram Moolenaar91639192020-06-29 19:55:58 +02007215 (void)dict_add_string(dict, (char *)"regtype", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007216
7217 buf[0] = get_register_name(get_unname_register());
7218 buf[1] = NUL;
7219 if (regname == '"')
Bram Moolenaar91639192020-06-29 19:55:58 +02007220 (void)dict_add_string(dict, (char *)"points_to", buf);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007221 else
7222 {
7223 dictitem_T *item = dictitem_alloc((char_u *)"isunnamed");
7224
7225 if (item != NULL)
7226 {
7227 item->di_tv.v_type = VAR_SPECIAL;
7228 item->di_tv.vval.v_number = regname == buf[0]
Bram Moolenaar418a29f2021-02-10 22:23:41 +01007229 ? VVAL_TRUE : VVAL_FALSE;
Bram Moolenaar91639192020-06-29 19:55:58 +02007230 (void)dict_add(dict, item);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02007231 }
7232 }
7233}
7234
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02007235 static void
7236return_register(int regname, typval_T *rettv)
7237{
7238 char_u buf[2] = {0, 0};
7239
7240 buf[0] = (char_u)regname;
7241 rettv->v_type = VAR_STRING;
7242 rettv->vval.v_string = vim_strsave(buf);
7243}
7244
7245/*
7246 * "reg_executing()" function
7247 */
7248 static void
7249f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
7250{
7251 return_register(reg_executing, rettv);
7252}
7253
7254/*
7255 * "reg_recording()" function
7256 */
7257 static void
7258f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
7259{
7260 return_register(reg_recording, rettv);
7261}
7262
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01007263/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007264 * "rename({from}, {to})" function
7265 */
7266 static void
7267f_rename(typval_T *argvars, typval_T *rettv)
7268{
7269 char_u buf[NUMBUFLEN];
7270
7271 if (check_restricted() || check_secure())
7272 rettv->vval.v_number = -1;
7273 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007274 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
7275 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007276}
7277
7278/*
7279 * "repeat()" function
7280 */
7281 static void
7282f_repeat(typval_T *argvars, typval_T *rettv)
7283{
7284 char_u *p;
7285 int n;
7286 int slen;
7287 int len;
7288 char_u *r;
7289 int i;
7290
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007291 n = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007292 if (argvars[0].v_type == VAR_LIST)
7293 {
7294 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
7295 while (n-- > 0)
7296 if (list_extend(rettv->vval.v_list,
7297 argvars[0].vval.v_list, NULL) == FAIL)
7298 break;
7299 }
7300 else
7301 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007302 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007303 rettv->v_type = VAR_STRING;
7304 rettv->vval.v_string = NULL;
7305
7306 slen = (int)STRLEN(p);
7307 len = slen * n;
7308 if (len <= 0)
7309 return;
7310
7311 r = alloc(len + 1);
7312 if (r != NULL)
7313 {
7314 for (i = 0; i < n; i++)
7315 mch_memmove(r + i * slen, p, (size_t)slen);
7316 r[len] = NUL;
7317 }
7318
7319 rettv->vval.v_string = r;
7320 }
7321}
7322
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007323#define SP_NOMOVE 0x01 // don't move cursor
7324#define SP_REPEAT 0x02 // repeat to find outer pair
7325#define SP_RETCOUNT 0x04 // return matchcount
7326#define SP_SETPCMARK 0x08 // set previous context mark
7327#define SP_START 0x10 // accept match at start position
7328#define SP_SUBPAT 0x20 // return nr of matching sub-pattern
7329#define SP_END 0x40 // leave cursor at end of match
7330#define SP_COLUMN 0x80 // start at cursor column
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007331
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007332/*
7333 * Get flags for a search function.
7334 * Possibly sets "p_ws".
7335 * Returns BACKWARD, FORWARD or zero (for an error).
7336 */
7337 static int
7338get_search_arg(typval_T *varp, int *flagsp)
7339{
7340 int dir = FORWARD;
7341 char_u *flags;
7342 char_u nbuf[NUMBUFLEN];
7343 int mask;
7344
7345 if (varp->v_type != VAR_UNKNOWN)
7346 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007347 flags = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007348 if (flags == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007349 return 0; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007350 while (*flags != NUL)
7351 {
7352 switch (*flags)
7353 {
7354 case 'b': dir = BACKWARD; break;
7355 case 'w': p_ws = TRUE; break;
7356 case 'W': p_ws = FALSE; break;
7357 default: mask = 0;
7358 if (flagsp != NULL)
7359 switch (*flags)
7360 {
7361 case 'c': mask = SP_START; break;
7362 case 'e': mask = SP_END; break;
7363 case 'm': mask = SP_RETCOUNT; break;
7364 case 'n': mask = SP_NOMOVE; break;
7365 case 'p': mask = SP_SUBPAT; break;
7366 case 'r': mask = SP_REPEAT; break;
7367 case 's': mask = SP_SETPCMARK; break;
7368 case 'z': mask = SP_COLUMN; break;
7369 }
7370 if (mask == 0)
7371 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007372 semsg(_(e_invarg2), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007373 dir = 0;
7374 }
7375 else
7376 *flagsp |= mask;
7377 }
7378 if (dir == 0)
7379 break;
7380 ++flags;
7381 }
7382 }
7383 return dir;
7384}
7385
7386/*
7387 * Shared by search() and searchpos() functions.
7388 */
7389 static int
7390search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
7391{
7392 int flags;
7393 char_u *pat;
7394 pos_T pos;
7395 pos_T save_cursor;
7396 int save_p_ws = p_ws;
7397 int dir;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007398 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007399 long lnum_stop = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007400#ifdef FEAT_RELTIME
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007401 proftime_T tm;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007402 long time_limit = 0;
7403#endif
7404 int options = SEARCH_KEEP;
7405 int subpatnum;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007406 searchit_arg_T sia;
Bram Moolenaara9c01042020-06-07 14:50:50 +02007407 int use_skip = FALSE;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007408 pos_T firstpos;
7409
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007410 pat = tv_get_string(&argvars[0]);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007411 dir = get_search_arg(&argvars[1], flagsp); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007412 if (dir == 0)
7413 goto theend;
7414 flags = *flagsp;
7415 if (flags & SP_START)
7416 options |= SEARCH_START;
7417 if (flags & SP_END)
7418 options |= SEARCH_END;
7419 if (flags & SP_COLUMN)
7420 options |= SEARCH_COL;
7421
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007422 // Optional arguments: line number to stop searching, timeout and skip.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007423 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
7424 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007425 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007426 if (lnum_stop < 0)
7427 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007428 if (argvars[3].v_type != VAR_UNKNOWN)
7429 {
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007430#ifdef FEAT_RELTIME
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007431 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007432 if (time_limit < 0)
7433 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007434#endif
Bram Moolenaara9c01042020-06-07 14:50:50 +02007435 use_skip = eval_expr_valid_arg(&argvars[4]);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007436 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007437 }
7438
7439#ifdef FEAT_RELTIME
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007440 // Set the time limit, if there is one.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007441 profile_setlimit(time_limit, &tm);
7442#endif
7443
7444 /*
7445 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
7446 * Check to make sure only those flags are set.
7447 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
7448 * flags cannot be set. Check for that condition also.
7449 */
7450 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
7451 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
7452 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007453 semsg(_(e_invarg2), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007454 goto theend;
7455 }
7456
7457 pos = save_cursor = curwin->w_cursor;
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007458 CLEAR_FIELD(firstpos);
Bram Moolenaara80faa82020-04-12 19:37:17 +02007459 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007460 sia.sa_stop_lnum = (linenr_T)lnum_stop;
7461#ifdef FEAT_RELTIME
7462 sia.sa_tm = &tm;
7463#endif
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007464
7465 // Repeat until {skip} returns FALSE.
7466 for (;;)
7467 {
7468 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007469 options, RE_SEARCH, &sia);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007470 // finding the first match again means there is no match where {skip}
7471 // evaluates to zero.
7472 if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))
7473 subpatnum = FAIL;
7474
Bram Moolenaara9c01042020-06-07 14:50:50 +02007475 if (subpatnum == FAIL || !use_skip)
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007476 // didn't find it or no skip argument
7477 break;
7478 firstpos = pos;
7479
Bram Moolenaara9c01042020-06-07 14:50:50 +02007480 // If the skip expression matches, ignore this match.
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007481 {
7482 int do_skip;
7483 int err;
7484 pos_T save_pos = curwin->w_cursor;
7485
7486 curwin->w_cursor = pos;
Bram Moolenaara9c01042020-06-07 14:50:50 +02007487 err = FALSE;
7488 do_skip = eval_expr_to_bool(&argvars[4], &err);
Bram Moolenaaradc17a52020-06-06 18:37:51 +02007489 curwin->w_cursor = save_pos;
7490 if (err)
7491 {
7492 // Evaluating {skip} caused an error, break here.
7493 subpatnum = FAIL;
7494 break;
7495 }
7496 if (!do_skip)
7497 break;
7498 }
7499 }
7500
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007501 if (subpatnum != FAIL)
7502 {
7503 if (flags & SP_SUBPAT)
7504 retval = subpatnum;
7505 else
7506 retval = pos.lnum;
7507 if (flags & SP_SETPCMARK)
7508 setpcmark();
7509 curwin->w_cursor = pos;
7510 if (match_pos != NULL)
7511 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007512 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007513 match_pos->lnum = pos.lnum;
7514 match_pos->col = pos.col + 1;
7515 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007516 // "/$" will put the cursor after the end of the line, may need to
7517 // correct that here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007518 check_cursor();
7519 }
7520
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007521 // If 'n' flag is used: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007522 if (flags & SP_NOMOVE)
7523 curwin->w_cursor = save_cursor;
7524 else
7525 curwin->w_set_curswant = TRUE;
7526theend:
7527 p_ws = save_p_ws;
7528
7529 return retval;
7530}
7531
Bram Moolenaare99be0e2019-03-26 22:51:09 +01007532#ifdef FEAT_RUBY
7533/*
7534 * "rubyeval()" function
7535 */
7536 static void
7537f_rubyeval(typval_T *argvars, typval_T *rettv)
7538{
7539 char_u *str;
7540 char_u buf[NUMBUFLEN];
7541
7542 str = tv_get_string_buf(&argvars[0], buf);
7543 do_rubyeval(str, rettv);
7544}
7545#endif
7546
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007547/*
7548 * "screenattr()" function
7549 */
7550 static void
7551f_screenattr(typval_T *argvars, typval_T *rettv)
7552{
7553 int row;
7554 int col;
7555 int c;
7556
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007557 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
7558 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007559 if (row < 0 || row >= screen_Rows
7560 || col < 0 || col >= screen_Columns)
7561 c = -1;
7562 else
7563 c = ScreenAttrs[LineOffset[row] + col];
7564 rettv->vval.v_number = c;
7565}
7566
7567/*
7568 * "screenchar()" function
7569 */
7570 static void
7571f_screenchar(typval_T *argvars, typval_T *rettv)
7572{
7573 int row;
7574 int col;
7575 int off;
7576 int c;
7577
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007578 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
7579 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar2912abb2019-03-29 14:16:42 +01007580 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007581 c = -1;
7582 else
7583 {
7584 off = LineOffset[row] + col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007585 if (enc_utf8 && ScreenLinesUC[off] != 0)
7586 c = ScreenLinesUC[off];
7587 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007588 c = ScreenLines[off];
7589 }
7590 rettv->vval.v_number = c;
7591}
7592
7593/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01007594 * "screenchars()" function
7595 */
7596 static void
7597f_screenchars(typval_T *argvars, typval_T *rettv)
7598{
7599 int row;
7600 int col;
7601 int off;
7602 int c;
7603 int i;
7604
7605 if (rettv_list_alloc(rettv) == FAIL)
7606 return;
7607 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
7608 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
7609 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
7610 return;
7611
7612 off = LineOffset[row] + col;
7613 if (enc_utf8 && ScreenLinesUC[off] != 0)
7614 c = ScreenLinesUC[off];
7615 else
7616 c = ScreenLines[off];
7617 list_append_number(rettv->vval.v_list, (varnumber_T)c);
7618
7619 if (enc_utf8)
7620
7621 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
7622 list_append_number(rettv->vval.v_list,
7623 (varnumber_T)ScreenLinesC[i][off]);
7624}
7625
7626/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007627 * "screencol()" function
7628 *
7629 * First column is 1 to be consistent with virtcol().
7630 */
7631 static void
7632f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
7633{
7634 rettv->vval.v_number = screen_screencol() + 1;
7635}
7636
7637/*
7638 * "screenrow()" function
7639 */
7640 static void
7641f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
7642{
7643 rettv->vval.v_number = screen_screenrow() + 1;
7644}
7645
7646/*
Bram Moolenaar2912abb2019-03-29 14:16:42 +01007647 * "screenstring()" function
7648 */
7649 static void
7650f_screenstring(typval_T *argvars, typval_T *rettv)
7651{
7652 int row;
7653 int col;
7654 int off;
7655 int c;
7656 int i;
7657 char_u buf[MB_MAXBYTES + 1];
7658 int buflen = 0;
7659
7660 rettv->vval.v_string = NULL;
7661 rettv->v_type = VAR_STRING;
7662
7663 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
7664 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
7665 if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns)
7666 return;
7667
7668 off = LineOffset[row] + col;
7669 if (enc_utf8 && ScreenLinesUC[off] != 0)
7670 c = ScreenLinesUC[off];
7671 else
7672 c = ScreenLines[off];
7673 buflen += mb_char2bytes(c, buf);
7674
Bram Moolenaarf1387282021-03-22 17:11:15 +01007675 if (enc_utf8 && ScreenLinesUC[off] != 0)
Bram Moolenaar2912abb2019-03-29 14:16:42 +01007676 for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i)
7677 buflen += mb_char2bytes(ScreenLinesC[i][off], buf + buflen);
7678
7679 buf[buflen] = NUL;
7680 rettv->vval.v_string = vim_strsave(buf);
7681}
7682
7683/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007684 * "search()" function
7685 */
7686 static void
7687f_search(typval_T *argvars, typval_T *rettv)
7688{
7689 int flags = 0;
7690
7691 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
7692}
7693
7694/*
7695 * "searchdecl()" function
7696 */
7697 static void
7698f_searchdecl(typval_T *argvars, typval_T *rettv)
7699{
Bram Moolenaar30788d32020-09-05 21:35:16 +02007700 int locally = TRUE;
7701 int thisblock = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007702 int error = FALSE;
7703 char_u *name;
7704
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007705 rettv->vval.v_number = 1; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007706
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007707 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007708 if (argvars[1].v_type != VAR_UNKNOWN)
7709 {
Bram Moolenaar30788d32020-09-05 21:35:16 +02007710 locally = !(int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007711 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar30788d32020-09-05 21:35:16 +02007712 thisblock = (int)tv_get_bool_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007713 }
7714 if (!error && name != NULL)
7715 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
7716 locally, thisblock, SEARCH_KEEP) == FAIL;
7717}
7718
7719/*
7720 * Used by searchpair() and searchpairpos()
7721 */
7722 static int
7723searchpair_cmn(typval_T *argvars, pos_T *match_pos)
7724{
7725 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +01007726 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007727 int save_p_ws = p_ws;
7728 int dir;
7729 int flags = 0;
7730 char_u nbuf1[NUMBUFLEN];
7731 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007732 int retval = 0; // default: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007733 long lnum_stop = 0;
7734 long time_limit = 0;
7735
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007736 // Get the three pattern arguments: start, middle, end. Will result in an
7737 // error if not a valid argument.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007738 spat = tv_get_string_chk(&argvars[0]);
7739 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
7740 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007741 if (spat == NULL || mpat == NULL || epat == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007742 goto theend; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007743
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007744 // Handle the optional fourth argument: flags
7745 dir = get_search_arg(&argvars[3], &flags); // may set p_ws
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007746 if (dir == 0)
7747 goto theend;
7748
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007749 // Don't accept SP_END or SP_SUBPAT.
7750 // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007751 if ((flags & (SP_END | SP_SUBPAT)) != 0
7752 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
7753 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007754 semsg(_(e_invarg2), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007755 goto theend;
7756 }
7757
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007758 // Using 'r' implies 'W', otherwise it doesn't work.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007759 if (flags & SP_REPEAT)
7760 p_ws = FALSE;
7761
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007762 // Optional fifth argument: skip expression
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007763 if (argvars[3].v_type == VAR_UNKNOWN
7764 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +01007765 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007766 else
7767 {
Bram Moolenaara9c01042020-06-07 14:50:50 +02007768 // Type is checked later.
Bram Moolenaar48570482017-10-30 21:48:41 +01007769 skip = &argvars[4];
Bram Moolenaara9c01042020-06-07 14:50:50 +02007770
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007771 if (argvars[5].v_type != VAR_UNKNOWN)
7772 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007773 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007774 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02007775 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007776 semsg(_(e_invarg2), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007777 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02007778 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007779#ifdef FEAT_RELTIME
7780 if (argvars[6].v_type != VAR_UNKNOWN)
7781 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007782 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007783 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +02007784 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007785 semsg(_(e_invarg2), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007786 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +02007787 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007788 }
7789#endif
7790 }
7791 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007792
7793 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
7794 match_pos, lnum_stop, time_limit);
7795
7796theend:
7797 p_ws = save_p_ws;
7798
7799 return retval;
7800}
7801
7802/*
7803 * "searchpair()" function
7804 */
7805 static void
7806f_searchpair(typval_T *argvars, typval_T *rettv)
7807{
7808 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
7809}
7810
7811/*
7812 * "searchpairpos()" function
7813 */
7814 static void
7815f_searchpairpos(typval_T *argvars, typval_T *rettv)
7816{
7817 pos_T match_pos;
7818 int lnum = 0;
7819 int col = 0;
7820
7821 if (rettv_list_alloc(rettv) == FAIL)
7822 return;
7823
7824 if (searchpair_cmn(argvars, &match_pos) > 0)
7825 {
7826 lnum = match_pos.lnum;
7827 col = match_pos.col;
7828 }
7829
7830 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
7831 list_append_number(rettv->vval.v_list, (varnumber_T)col);
7832}
7833
7834/*
7835 * Search for a start/middle/end thing.
7836 * Used by searchpair(), see its documentation for the details.
7837 * Returns 0 or -1 for no match,
7838 */
7839 long
7840do_searchpair(
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007841 char_u *spat, // start pattern
7842 char_u *mpat, // middle pattern
7843 char_u *epat, // end pattern
7844 int dir, // BACKWARD or FORWARD
7845 typval_T *skip, // skip expression
7846 int flags, // SP_SETPCMARK and other SP_ values
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007847 pos_T *match_pos,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007848 linenr_T lnum_stop, // stop at this line if not zero
7849 long time_limit UNUSED) // stop after this many msec
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007850{
7851 char_u *save_cpo;
7852 char_u *pat, *pat2 = NULL, *pat3 = NULL;
7853 long retval = 0;
7854 pos_T pos;
7855 pos_T firstpos;
7856 pos_T foundpos;
7857 pos_T save_cursor;
7858 pos_T save_pos;
7859 int n;
7860 int r;
7861 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +01007862 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007863 int err;
7864 int options = SEARCH_KEEP;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007865#ifdef FEAT_RELTIME
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007866 proftime_T tm;
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007867#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007868
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007869 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007870 save_cpo = p_cpo;
7871 p_cpo = empty_option;
7872
7873#ifdef FEAT_RELTIME
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007874 // Set the time limit, if there is one.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007875 profile_setlimit(time_limit, &tm);
7876#endif
7877
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007878 // Make two search patterns: start/end (pat2, for in nested pairs) and
7879 // start/middle/end (pat3, for the top pair).
Bram Moolenaar964b3742019-05-24 18:54:09 +02007880 pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17);
7881 pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007882 if (pat2 == NULL || pat3 == NULL)
7883 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +01007884 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007885 if (*mpat == NUL)
7886 STRCPY(pat3, pat2);
7887 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +01007888 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007889 spat, epat, mpat);
7890 if (flags & SP_START)
7891 options |= SEARCH_START;
7892
Bram Moolenaar48570482017-10-30 21:48:41 +01007893 if (skip != NULL)
Bram Moolenaara9c01042020-06-07 14:50:50 +02007894 use_skip = eval_expr_valid_arg(skip);
Bram Moolenaar48570482017-10-30 21:48:41 +01007895
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007896 save_cursor = curwin->w_cursor;
7897 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01007898 CLEAR_POS(&firstpos);
7899 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007900 pat = pat3;
7901 for (;;)
7902 {
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007903 searchit_arg_T sia;
7904
Bram Moolenaara80faa82020-04-12 19:37:17 +02007905 CLEAR_FIELD(sia);
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007906 sia.sa_stop_lnum = lnum_stop;
7907#ifdef FEAT_RELTIME
7908 sia.sa_tm = &tm;
7909#endif
Bram Moolenaar5d24a222018-12-23 19:10:09 +01007910 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02007911 options, RE_SEARCH, &sia);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01007912 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007913 // didn't find it or found the first match again: FAIL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007914 break;
7915
7916 if (firstpos.lnum == 0)
7917 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01007918 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007919 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007920 // Found the same position again. Can happen with a pattern that
7921 // has "\zs" at the end and searching backwards. Advance one
7922 // character and try again.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007923 if (dir == BACKWARD)
7924 decl(&pos);
7925 else
7926 incl(&pos);
7927 }
7928 foundpos = pos;
7929
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007930 // clear the start flag to avoid getting stuck here
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007931 options &= ~SEARCH_START;
7932
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007933 // If the skip pattern matches, ignore this match.
Bram Moolenaar48570482017-10-30 21:48:41 +01007934 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007935 {
7936 save_pos = curwin->w_cursor;
7937 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +01007938 err = FALSE;
7939 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007940 curwin->w_cursor = save_pos;
7941 if (err)
7942 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007943 // Evaluating {skip} caused an error, break here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007944 curwin->w_cursor = save_cursor;
7945 retval = -1;
7946 break;
7947 }
7948 if (r)
7949 continue;
7950 }
7951
7952 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
7953 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007954 // Found end when searching backwards or start when searching
7955 // forward: nested pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007956 ++nest;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007957 pat = pat2; // nested, don't search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007958 }
7959 else
7960 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007961 // Found end when searching forward or start when searching
7962 // backward: end of (nested) pair; or found middle in outer pair.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007963 if (--nest == 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007964 pat = pat3; // outer level, search for middle
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007965 }
7966
7967 if (nest == 0)
7968 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007969 // Found the match: return matchcount or line number.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007970 if (flags & SP_RETCOUNT)
7971 ++retval;
7972 else
7973 retval = pos.lnum;
7974 if (flags & SP_SETPCMARK)
7975 setpcmark();
7976 curwin->w_cursor = pos;
7977 if (!(flags & SP_REPEAT))
7978 break;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007979 nest = 1; // search for next unmatched
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007980 }
7981 }
7982
7983 if (match_pos != NULL)
7984 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007985 // Store the match cursor position
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007986 match_pos->lnum = curwin->w_cursor.lnum;
7987 match_pos->col = curwin->w_cursor.col + 1;
7988 }
7989
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01007990 // If 'n' flag is used or search failed: restore cursor position.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007991 if ((flags & SP_NOMOVE) || retval == 0)
7992 curwin->w_cursor = save_cursor;
7993
7994theend:
7995 vim_free(pat2);
7996 vim_free(pat3);
7997 if (p_cpo == empty_option)
7998 p_cpo = save_cpo;
7999 else
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01008000 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008001 // Darn, evaluating the {skip} expression changed the value.
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01008002 // If it's still empty it was changed and restored, need to restore in
8003 // the complicated way.
8004 if (*p_cpo == NUL)
8005 set_option_value((char_u *)"cpo", 0L, save_cpo, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008006 free_string_option(save_cpo);
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01008007 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008008
8009 return retval;
8010}
8011
8012/*
8013 * "searchpos()" function
8014 */
8015 static void
8016f_searchpos(typval_T *argvars, typval_T *rettv)
8017{
8018 pos_T match_pos;
8019 int lnum = 0;
8020 int col = 0;
8021 int n;
8022 int flags = 0;
8023
8024 if (rettv_list_alloc(rettv) == FAIL)
8025 return;
8026
8027 n = search_cmn(argvars, &match_pos, &flags);
8028 if (n > 0)
8029 {
8030 lnum = match_pos.lnum;
8031 col = match_pos.col;
8032 }
8033
8034 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
8035 list_append_number(rettv->vval.v_list, (varnumber_T)col);
8036 if (flags & SP_SUBPAT)
8037 list_append_number(rettv->vval.v_list, (varnumber_T)n);
8038}
8039
Bram Moolenaar6f02b002021-01-10 20:22:54 +01008040/*
8041 * Set the cursor or mark position.
Christian Brabandt98703d72021-06-24 19:55:27 +02008042 * If 'charpos' is TRUE, then use the column number as a character offset.
Bram Moolenaar6f02b002021-01-10 20:22:54 +01008043 * Otherwise use the column number as a byte offset.
8044 */
8045 static void
8046set_position(typval_T *argvars, typval_T *rettv, int charpos)
8047{
8048 pos_T pos;
8049 int fnum;
8050 char_u *name;
8051 colnr_T curswant = -1;
8052
8053 rettv->vval.v_number = -1;
8054
8055 name = tv_get_string_chk(argvars);
8056 if (name != NULL)
8057 {
8058 if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) == OK)
8059 {
8060 if (pos.col != MAXCOL && --pos.col < 0)
8061 pos.col = 0;
8062 if ((name[0] == '.' && name[1] == NUL))
8063 {
8064 // set cursor; "fnum" is ignored
8065 curwin->w_cursor = pos;
8066 if (curswant >= 0)
8067 {
8068 curwin->w_curswant = curswant - 1;
8069 curwin->w_set_curswant = FALSE;
8070 }
8071 check_cursor();
8072 rettv->vval.v_number = 0;
8073 }
8074 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
8075 {
8076 // set mark
8077 if (setmark_pos(name[1], &pos, fnum) == OK)
8078 rettv->vval.v_number = 0;
8079 }
8080 else
8081 emsg(_(e_invarg));
8082 }
8083 }
8084}
8085/*
8086 * "setcharpos()" function
8087 */
8088 static void
8089f_setcharpos(typval_T *argvars, typval_T *rettv)
8090{
8091 set_position(argvars, rettv, TRUE);
8092}
8093
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008094 static void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008095f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
8096{
8097 dict_T *d;
8098 dictitem_T *di;
8099 char_u *csearch;
8100
8101 if (argvars[0].v_type != VAR_DICT)
8102 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008103 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008104 return;
8105 }
8106
8107 if ((d = argvars[0].vval.v_dict) != NULL)
8108 {
Bram Moolenaar8f667172018-12-14 15:38:31 +01008109 csearch = dict_get_string(d, (char_u *)"char", FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008110 if (csearch != NULL)
8111 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008112 if (enc_utf8)
8113 {
8114 int pcc[MAX_MCO];
8115 int c = utfc_ptr2char(csearch, pcc);
8116
8117 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
8118 }
8119 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008120 set_last_csearch(PTR2CHAR(csearch),
Bram Moolenaar1614a142019-10-06 22:00:13 +02008121 csearch, mb_ptr2len(csearch));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008122 }
8123
8124 di = dict_find(d, (char_u *)"forward", -1);
8125 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008126 set_csearch_direction((int)tv_get_number(&di->di_tv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008127 ? FORWARD : BACKWARD);
8128
8129 di = dict_find(d, (char_u *)"until", -1);
8130 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008131 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008132 }
8133}
8134
8135/*
Bram Moolenaar6f02b002021-01-10 20:22:54 +01008136 * "setcursorcharpos" function
8137 */
8138 static void
Bram Moolenaar3af15ab2021-01-17 16:16:23 +01008139f_setcursorcharpos(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6f02b002021-01-10 20:22:54 +01008140{
8141 set_cursorpos(argvars, rettv, TRUE);
8142}
8143
8144/*
Bram Moolenaar691ddee2019-05-09 14:52:41 +02008145 * "setenv()" function
8146 */
8147 static void
8148f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
8149{
8150 char_u namebuf[NUMBUFLEN];
8151 char_u valbuf[NUMBUFLEN];
8152 char_u *name = tv_get_string_buf(&argvars[0], namebuf);
8153
8154 if (argvars[1].v_type == VAR_SPECIAL
8155 && argvars[1].vval.v_number == VVAL_NULL)
8156 vim_unsetenv(name);
8157 else
8158 vim_setenv(name, tv_get_string_buf(&argvars[1], valbuf));
8159}
8160
8161/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008162 * "setfperm({fname}, {mode})" function
8163 */
8164 static void
8165f_setfperm(typval_T *argvars, typval_T *rettv)
8166{
8167 char_u *fname;
8168 char_u modebuf[NUMBUFLEN];
8169 char_u *mode_str;
8170 int i;
8171 int mask;
8172 int mode = 0;
8173
8174 rettv->vval.v_number = 0;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008175 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008176 if (fname == NULL)
8177 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008178 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008179 if (mode_str == NULL)
8180 return;
8181 if (STRLEN(mode_str) != 9)
8182 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008183 semsg(_(e_invarg2), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008184 return;
8185 }
8186
8187 mask = 1;
8188 for (i = 8; i >= 0; --i)
8189 {
8190 if (mode_str[i] != '-')
8191 mode |= mask;
8192 mask = mask << 1;
8193 }
8194 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
8195}
8196
8197/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008198 * "setpos()" function
8199 */
8200 static void
8201f_setpos(typval_T *argvars, typval_T *rettv)
8202{
Bram Moolenaar6f02b002021-01-10 20:22:54 +01008203 set_position(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008204}
8205
8206/*
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008207 * Translate a register type string to the yank type and block length
8208 */
8209 static int
8210get_yank_type(char_u **pp, char_u *yank_type, long *block_len)
8211{
8212 char_u *stropt = *pp;
8213 switch (*stropt)
8214 {
8215 case 'v': case 'c': // character-wise selection
8216 *yank_type = MCHAR;
8217 break;
8218 case 'V': case 'l': // line-wise selection
8219 *yank_type = MLINE;
8220 break;
8221 case 'b': case Ctrl_V: // block-wise selection
8222 *yank_type = MBLOCK;
8223 if (VIM_ISDIGIT(stropt[1]))
8224 {
8225 ++stropt;
8226 *block_len = getdigits(&stropt) - 1;
8227 --stropt;
8228 }
8229 break;
8230 default:
8231 return FAIL;
8232 }
8233 *pp = stropt;
8234 return OK;
8235}
8236
8237/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008238 * "setreg()" function
8239 */
8240 static void
8241f_setreg(typval_T *argvars, typval_T *rettv)
8242{
8243 int regname;
8244 char_u *strregname;
8245 char_u *stropt;
8246 char_u *strval;
8247 int append;
8248 char_u yank_type;
8249 long block_len;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008250 typval_T *regcontents;
8251 int pointreg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008252
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008253 pointreg = 0;
8254 regcontents = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008255 block_len = -1;
8256 yank_type = MAUTO;
8257 append = FALSE;
8258
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008259 strregname = tv_get_string_chk(argvars);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008260 rettv->vval.v_number = 1; // FAIL is default
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008261
8262 if (strregname == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008263 return; // type error; errmsg already given
Bram Moolenaar418a29f2021-02-10 22:23:41 +01008264 if (in_vim9script() && STRLEN(strregname) > 1)
8265 {
8266 semsg(_(e_register_name_must_be_one_char_str), strregname);
8267 return;
8268 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008269 regname = *strregname;
8270 if (regname == 0 || regname == '@')
8271 regname = '"';
8272
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008273 if (argvars[1].v_type == VAR_DICT)
8274 {
8275 dict_T *d = argvars[1].vval.v_dict;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008276 dictitem_T *di;
8277
8278 if (d == NULL || d->dv_hashtab.ht_used == 0)
8279 {
8280 // Empty dict, clear the register (like setreg(0, []))
8281 char_u *lstval[2] = {NULL, NULL};
8282 write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1);
8283 return;
8284 }
8285
8286 di = dict_find(d, (char_u *)"regcontents", -1);
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008287 if (di != NULL)
8288 regcontents = &di->di_tv;
8289
8290 stropt = dict_get_string(d, (char_u *)"regtype", FALSE);
8291 if (stropt != NULL)
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008292 {
8293 int ret = get_yank_type(&stropt, &yank_type, &block_len);
8294
8295 if (ret == FAIL || *++stropt != NUL)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008296 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008297 semsg(_(e_invargval), "value");
8298 return;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008299 }
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008300 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008301
8302 if (regname == '"')
8303 {
8304 stropt = dict_get_string(d, (char_u *)"points_to", FALSE);
8305 if (stropt != NULL)
8306 {
8307 pointreg = *stropt;
8308 regname = pointreg;
8309 }
8310 }
Bram Moolenaar6a950582020-08-28 16:39:33 +02008311 else if (dict_get_bool(d, (char_u *)"isunnamed", -1) > 0)
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008312 pointreg = regname;
8313 }
8314 else
8315 regcontents = &argvars[1];
8316
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008317 if (argvars[2].v_type != VAR_UNKNOWN)
8318 {
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008319 if (yank_type != MAUTO)
8320 {
8321 semsg(_(e_toomanyarg), "setreg");
8322 return;
8323 }
8324
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008325 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008326 if (stropt == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008327 return; // type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008328 for (; *stropt != NUL; ++stropt)
8329 switch (*stropt)
8330 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008331 case 'a': case 'A': // append
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008332 append = TRUE;
8333 break;
Bram Moolenaar7633fe52020-06-22 19:10:56 +02008334 default:
8335 get_yank_type(&stropt, &yank_type, &block_len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008336 }
8337 }
8338
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008339 if (regcontents && regcontents->v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008340 {
8341 char_u **lstval;
8342 char_u **allocval;
8343 char_u buf[NUMBUFLEN];
8344 char_u **curval;
8345 char_u **curallocval;
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008346 list_T *ll = regcontents->vval.v_list;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008347 listitem_T *li;
8348 int len;
8349
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008350 // If the list is NULL handle like an empty list.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008351 len = ll == NULL ? 0 : ll->lv_len;
8352
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008353 // First half: use for pointers to result lines; second half: use for
8354 // pointers to allocated copies.
Bram Moolenaarc799fe22019-05-28 23:08:19 +02008355 lstval = ALLOC_MULT(char_u *, (len + 1) * 2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008356 if (lstval == NULL)
8357 return;
8358 curval = lstval;
8359 allocval = lstval + len + 2;
8360 curallocval = allocval;
8361
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008362 if (ll != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008363 {
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02008364 CHECK_LIST_MATERIALIZE(ll);
Bram Moolenaar00d253e2020-04-06 22:13:01 +02008365 FOR_ALL_LIST_ITEMS(ll, li)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008366 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008367 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008368 if (strval == NULL)
8369 goto free_lstval;
Bram Moolenaar50985eb2020-01-27 22:09:39 +01008370 if (strval == buf)
8371 {
8372 // Need to make a copy, next tv_get_string_buf_chk() will
8373 // overwrite the string.
8374 strval = vim_strsave(buf);
8375 if (strval == NULL)
8376 goto free_lstval;
8377 *curallocval++ = strval;
8378 }
8379 *curval++ = strval;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008380 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008381 }
8382 *curval++ = NULL;
8383
8384 write_reg_contents_lst(regname, lstval, -1,
8385 append, yank_type, block_len);
8386free_lstval:
8387 while (curallocval > allocval)
8388 vim_free(*--curallocval);
8389 vim_free(lstval);
8390 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008391 else if (regcontents)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008392 {
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008393 strval = tv_get_string_chk(regcontents);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008394 if (strval == NULL)
8395 return;
8396 write_reg_contents_ex(regname, strval, -1,
8397 append, yank_type, block_len);
8398 }
Bram Moolenaarbb861e22020-06-07 18:16:36 +02008399 if (pointreg != 0)
8400 get_yank_register(pointreg, TRUE);
8401
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008402 rettv->vval.v_number = 0;
8403}
8404
8405/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008406 * "settagstack()" function
8407 */
8408 static void
8409f_settagstack(typval_T *argvars, typval_T *rettv)
8410{
8411 static char *e_invact2 = N_("E962: Invalid action: '%s'");
8412 win_T *wp;
8413 dict_T *d;
8414 int action = 'r';
8415
8416 rettv->vval.v_number = -1;
8417
8418 // first argument: window number or id
8419 wp = find_win_by_nr_or_id(&argvars[0]);
8420 if (wp == NULL)
8421 return;
8422
8423 // second argument: dict with items to set in the tag stack
8424 if (argvars[1].v_type != VAR_DICT)
8425 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008426 emsg(_(e_dictreq));
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008427 return;
8428 }
8429 d = argvars[1].vval.v_dict;
8430 if (d == NULL)
8431 return;
8432
8433 // third argument: action - 'a' for append and 'r' for replace.
8434 // default is to replace the stack.
8435 if (argvars[2].v_type == VAR_UNKNOWN)
8436 action = 'r';
8437 else if (argvars[2].v_type == VAR_STRING)
8438 {
8439 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008440 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008441 if (actstr == NULL)
8442 return;
Bram Moolenaar271fa082020-01-02 14:02:16 +01008443 if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't')
8444 && actstr[1] == NUL)
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008445 action = *actstr;
8446 else
8447 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008448 semsg(_(e_invact2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008449 return;
8450 }
8451 }
8452 else
8453 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008454 emsg(_(e_stringreq));
Bram Moolenaarf49cc602018-11-11 15:21:05 +01008455 return;
8456 }
8457
8458 if (set_tagstack(wp, d, action) == OK)
8459 rettv->vval.v_number = 0;
8460}
8461
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008462#ifdef FEAT_CRYPT
8463/*
8464 * "sha256({string})" function
8465 */
8466 static void
8467f_sha256(typval_T *argvars, typval_T *rettv)
8468{
8469 char_u *p;
8470
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008471 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008472 rettv->vval.v_string = vim_strsave(
8473 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
8474 rettv->v_type = VAR_STRING;
8475}
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008476#endif // FEAT_CRYPT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008477
8478/*
8479 * "shellescape({string})" function
8480 */
8481 static void
8482f_shellescape(typval_T *argvars, typval_T *rettv)
8483{
Bram Moolenaar20615522017-06-05 18:46:26 +02008484 int do_special = non_zero_arg(&argvars[1]);
8485
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008486 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008487 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008488 rettv->v_type = VAR_STRING;
8489}
8490
8491/*
8492 * shiftwidth() function
8493 */
8494 static void
8495f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
8496{
Bram Moolenaarf9514162018-11-22 03:08:29 +01008497 rettv->vval.v_number = 0;
8498
8499 if (argvars[0].v_type != VAR_UNKNOWN)
8500 {
8501 long col;
8502
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008503 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +01008504 if (col < 0)
8505 return; // type error; errmsg already given
8506#ifdef FEAT_VARTABS
8507 rettv->vval.v_number = get_sw_value_col(curbuf, col);
8508 return;
8509#endif
8510 }
8511
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008512 rettv->vval.v_number = get_sw_value(curbuf);
8513}
8514
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008515/*
8516 * "soundfold({word})" function
8517 */
8518 static void
8519f_soundfold(typval_T *argvars, typval_T *rettv)
8520{
8521 char_u *s;
8522
8523 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008524 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008525#ifdef FEAT_SPELL
8526 rettv->vval.v_string = eval_soundfold(s);
8527#else
8528 rettv->vval.v_string = vim_strsave(s);
8529#endif
8530}
8531
8532/*
8533 * "spellbadword()" function
8534 */
8535 static void
8536f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
8537{
8538 char_u *word = (char_u *)"";
8539 hlf_T attr = HLF_COUNT;
8540 int len = 0;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008541#ifdef FEAT_SPELL
8542 int wo_spell_save = curwin->w_p_spell;
8543
8544 if (!curwin->w_p_spell)
8545 {
8546 did_set_spelllang(curwin);
8547 curwin->w_p_spell = TRUE;
8548 }
8549
8550 if (*curwin->w_s->b_p_spl == NUL)
8551 {
8552 emsg(_(e_no_spell));
8553 curwin->w_p_spell = wo_spell_save;
8554 return;
8555 }
8556#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008557
8558 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008559 {
8560#ifdef FEAT_SPELL
8561 curwin->w_p_spell = wo_spell_save;
8562#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008563 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008564 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008565
8566#ifdef FEAT_SPELL
8567 if (argvars[0].v_type == VAR_UNKNOWN)
8568 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008569 // Find the start and length of the badly spelled word.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008570 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
8571 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +01008572 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008573 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +01008574 curwin->w_set_curswant = TRUE;
8575 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008576 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008577 else if (*curbuf->b_s.b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008578 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008579 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008580 int capcol = -1;
8581
8582 if (str != NULL)
8583 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008584 // Check the argument for spelling.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008585 while (*str != NUL)
8586 {
8587 len = spell_check(curwin, str, &attr, &capcol, FALSE);
8588 if (attr != HLF_COUNT)
8589 {
8590 word = str;
8591 break;
8592 }
8593 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +02008594 capcol -= len;
Bram Moolenaar0c779e82019-08-09 17:01:02 +02008595 len = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008596 }
8597 }
8598 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008599 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008600#endif
8601
8602 list_append_string(rettv->vval.v_list, word, len);
8603 list_append_string(rettv->vval.v_list, (char_u *)(
8604 attr == HLF_SPB ? "bad" :
8605 attr == HLF_SPR ? "rare" :
8606 attr == HLF_SPL ? "local" :
8607 attr == HLF_SPC ? "caps" :
8608 ""), -1);
8609}
8610
8611/*
8612 * "spellsuggest()" function
8613 */
8614 static void
8615f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
8616{
8617#ifdef FEAT_SPELL
8618 char_u *str;
8619 int typeerr = FALSE;
8620 int maxcount;
8621 garray_T ga;
8622 int i;
8623 listitem_T *li;
8624 int need_capital = FALSE;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008625 int wo_spell_save = curwin->w_p_spell;
8626
8627 if (!curwin->w_p_spell)
8628 {
8629 did_set_spelllang(curwin);
8630 curwin->w_p_spell = TRUE;
8631 }
8632
8633 if (*curwin->w_s->b_p_spl == NUL)
8634 {
8635 emsg(_(e_no_spell));
8636 curwin->w_p_spell = wo_spell_save;
8637 return;
8638 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008639#endif
8640
8641 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008642 {
8643#ifdef FEAT_SPELL
8644 curwin->w_p_spell = wo_spell_save;
8645#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008646 return;
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008647 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008648
8649#ifdef FEAT_SPELL
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008650 if (*curwin->w_s->b_p_spl != NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008651 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008652 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008653 if (argvars[1].v_type != VAR_UNKNOWN)
8654 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008655 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008656 if (maxcount <= 0)
8657 return;
8658 if (argvars[2].v_type != VAR_UNKNOWN)
8659 {
Bram Moolenaar7c27f332020-09-05 22:45:55 +02008660 need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008661 if (typeerr)
8662 return;
8663 }
8664 }
8665 else
8666 maxcount = 25;
8667
8668 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
8669
8670 for (i = 0; i < ga.ga_len; ++i)
8671 {
8672 str = ((char_u **)ga.ga_data)[i];
8673
8674 li = listitem_alloc();
8675 if (li == NULL)
8676 vim_free(str);
8677 else
8678 {
8679 li->li_tv.v_type = VAR_STRING;
8680 li->li_tv.v_lock = 0;
8681 li->li_tv.vval.v_string = str;
8682 list_append(rettv->vval.v_list, li);
8683 }
8684 }
8685 ga_clear(&ga);
8686 }
Bram Moolenaar152e79e2020-06-10 15:32:08 +02008687 curwin->w_p_spell = wo_spell_save;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008688#endif
8689}
8690
8691 static void
8692f_split(typval_T *argvars, typval_T *rettv)
8693{
8694 char_u *str;
8695 char_u *end;
8696 char_u *pat = NULL;
8697 regmatch_T regmatch;
8698 char_u patbuf[NUMBUFLEN];
8699 char_u *save_cpo;
8700 int match;
8701 colnr_T col = 0;
8702 int keepempty = FALSE;
8703 int typeerr = FALSE;
8704
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008705 // Make 'cpoptions' empty, the 'l' flag should not be used here.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008706 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01008707 p_cpo = empty_option;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008708
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008709 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008710 if (argvars[1].v_type != VAR_UNKNOWN)
8711 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008712 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008713 if (pat == NULL)
8714 typeerr = TRUE;
8715 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar3986b942020-09-06 16:09:04 +02008716 keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008717 }
8718 if (pat == NULL || *pat == NUL)
8719 pat = (char_u *)"[\\x01- ]\\+";
8720
8721 if (rettv_list_alloc(rettv) == FAIL)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02008722 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008723 if (typeerr)
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02008724 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008725
8726 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
8727 if (regmatch.regprog != NULL)
8728 {
8729 regmatch.rm_ic = FALSE;
8730 while (*str != NUL || keepempty)
8731 {
8732 if (*str == NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008733 match = FALSE; // empty item at the end
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008734 else
8735 match = vim_regexec_nl(&regmatch, str, col);
8736 if (match)
8737 end = regmatch.startp[0];
8738 else
8739 end = str + STRLEN(str);
8740 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
8741 && *str != NUL && match && end < regmatch.endp[0]))
8742 {
8743 if (list_append_string(rettv->vval.v_list, str,
8744 (int)(end - str)) == FAIL)
8745 break;
8746 }
8747 if (!match)
8748 break;
Bram Moolenaar13505972019-01-24 15:04:48 +01008749 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008750 if (regmatch.endp[0] > str)
8751 col = 0;
8752 else
Bram Moolenaar13505972019-01-24 15:04:48 +01008753 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008754 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008755 str = regmatch.endp[0];
8756 }
8757
8758 vim_regfree(regmatch.regprog);
8759 }
8760
Bram Moolenaar7d5e7442020-07-21 22:25:51 +02008761theend:
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008762 p_cpo = save_cpo;
8763}
8764
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008765/*
Bram Moolenaar9d401282019-04-06 13:18:12 +02008766 * "str2list()" function
8767 */
8768 static void
8769f_str2list(typval_T *argvars, typval_T *rettv)
8770{
8771 char_u *p;
8772 int utf8 = FALSE;
8773
8774 if (rettv_list_alloc(rettv) == FAIL)
8775 return;
8776
8777 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaara48f7862020-09-05 20:16:57 +02008778 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
Bram Moolenaar9d401282019-04-06 13:18:12 +02008779
8780 p = tv_get_string(&argvars[0]);
8781
8782 if (has_mbyte || utf8)
8783 {
8784 int (*ptr2len)(char_u *);
8785 int (*ptr2char)(char_u *);
8786
8787 if (utf8 || enc_utf8)
8788 {
8789 ptr2len = utf_ptr2len;
8790 ptr2char = utf_ptr2char;
8791 }
8792 else
8793 {
8794 ptr2len = mb_ptr2len;
8795 ptr2char = mb_ptr2char;
8796 }
8797
8798 for ( ; *p != NUL; p += (*ptr2len)(p))
8799 list_append_number(rettv->vval.v_list, (*ptr2char)(p));
8800 }
8801 else
8802 for ( ; *p != NUL; ++p)
8803 list_append_number(rettv->vval.v_list, *p);
8804}
8805
8806/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008807 * "str2nr()" function
8808 */
8809 static void
8810f_str2nr(typval_T *argvars, typval_T *rettv)
8811{
8812 int base = 10;
8813 char_u *p;
8814 varnumber_T n;
Bram Moolenaar60a8de22019-09-15 14:33:22 +02008815 int what = 0;
Bram Moolenaar08243d22017-01-10 16:12:29 +01008816 int isneg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008817
8818 if (argvars[1].v_type != VAR_UNKNOWN)
8819 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008820 base = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008821 if (base != 2 && base != 8 && base != 10 && base != 16)
8822 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008823 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008824 return;
8825 }
Bram Moolenaar3986b942020-09-06 16:09:04 +02008826 if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2]))
Bram Moolenaar60a8de22019-09-15 14:33:22 +02008827 what |= STR2NR_QUOTE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008828 }
8829
Bram Moolenaarf2b26bc2021-01-30 23:05:11 +01008830 p = skipwhite(tv_get_string_strict(&argvars[0]));
Bram Moolenaar08243d22017-01-10 16:12:29 +01008831 isneg = (*p == '-');
8832 if (*p == '+' || *p == '-')
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008833 p = skipwhite(p + 1);
8834 switch (base)
8835 {
Bram Moolenaar60a8de22019-09-15 14:33:22 +02008836 case 2: what |= STR2NR_BIN + STR2NR_FORCE; break;
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02008837 case 8: what |= STR2NR_OCT + STR2NR_OOCT + STR2NR_FORCE; break;
Bram Moolenaar60a8de22019-09-15 14:33:22 +02008838 case 16: what |= STR2NR_HEX + STR2NR_FORCE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008839 }
Bram Moolenaar16e9b852019-05-19 19:59:35 +02008840 vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, FALSE);
8841 // Text after the number is silently ignored.
Bram Moolenaar08243d22017-01-10 16:12:29 +01008842 if (isneg)
8843 rettv->vval.v_number = -n;
8844 else
8845 rettv->vval.v_number = n;
8846
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008847}
8848
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008849/*
8850 * "strgetchar()" function
8851 */
8852 static void
8853f_strgetchar(typval_T *argvars, typval_T *rettv)
8854{
8855 char_u *str;
8856 int len;
8857 int error = FALSE;
8858 int charidx;
Bram Moolenaar13505972019-01-24 15:04:48 +01008859 int byteidx = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008860
8861 rettv->vval.v_number = -1;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008862 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008863 if (str == NULL)
8864 return;
8865 len = (int)STRLEN(str);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008866 charidx = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008867 if (error)
8868 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008869
Bram Moolenaar13505972019-01-24 15:04:48 +01008870 while (charidx >= 0 && byteidx < len)
8871 {
8872 if (charidx == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008873 {
Bram Moolenaar13505972019-01-24 15:04:48 +01008874 rettv->vval.v_number = mb_ptr2char(str + byteidx);
8875 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008876 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008877 --charidx;
8878 byteidx += MB_CPTR2LEN(str + byteidx);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008879 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008880}
8881
8882/*
8883 * "stridx()" function
8884 */
8885 static void
8886f_stridx(typval_T *argvars, typval_T *rettv)
8887{
8888 char_u buf[NUMBUFLEN];
8889 char_u *needle;
8890 char_u *haystack;
8891 char_u *save_haystack;
8892 char_u *pos;
8893 int start_idx;
8894
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008895 needle = tv_get_string_chk(&argvars[1]);
8896 save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008897 rettv->vval.v_number = -1;
8898 if (needle == NULL || haystack == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008899 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008900
8901 if (argvars[2].v_type != VAR_UNKNOWN)
8902 {
8903 int error = FALSE;
8904
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008905 start_idx = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008906 if (error || start_idx >= (int)STRLEN(haystack))
8907 return;
8908 if (start_idx >= 0)
8909 haystack += start_idx;
8910 }
8911
8912 pos = (char_u *)strstr((char *)haystack, (char *)needle);
8913 if (pos != NULL)
8914 rettv->vval.v_number = (varnumber_T)(pos - save_haystack);
8915}
8916
8917/*
8918 * "string()" function
8919 */
Bram Moolenaar461a7fc2018-12-22 13:28:07 +01008920 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008921f_string(typval_T *argvars, typval_T *rettv)
8922{
8923 char_u *tofree;
8924 char_u numbuf[NUMBUFLEN];
8925
8926 rettv->v_type = VAR_STRING;
8927 rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf,
8928 get_copyID());
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01008929 // Make a copy if we have a value but it's not in allocated memory.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008930 if (rettv->vval.v_string != NULL && tofree == NULL)
8931 rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
8932}
8933
8934/*
8935 * "strlen()" function
8936 */
8937 static void
8938f_strlen(typval_T *argvars, typval_T *rettv)
8939{
8940 rettv->vval.v_number = (varnumber_T)(STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008941 tv_get_string(&argvars[0])));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008942}
8943
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01008944 static void
8945strchar_common(typval_T *argvars, typval_T *rettv, int skipcc)
8946{
8947 char_u *s = tv_get_string(&argvars[0]);
8948 varnumber_T len = 0;
8949 int (*func_mb_ptr2char_adv)(char_u **pp);
8950
8951 func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;
8952 while (*s != NUL)
8953 {
8954 func_mb_ptr2char_adv(&s);
8955 ++len;
8956 }
8957 rettv->vval.v_number = len;
8958}
8959
8960/*
8961 * "strcharlen()" function
8962 */
8963 static void
8964f_strcharlen(typval_T *argvars, typval_T *rettv)
8965{
8966 strchar_common(argvars, rettv, TRUE);
8967}
8968
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008969/*
8970 * "strchars()" function
8971 */
8972 static void
8973f_strchars(typval_T *argvars, typval_T *rettv)
8974{
Bram Moolenaar239f8d92021-01-17 13:21:20 +01008975 varnumber_T skipcc = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008976
8977 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaar239f8d92021-01-17 13:21:20 +01008978 skipcc = tv_get_bool(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008979 if (skipcc < 0 || skipcc > 1)
Bram Moolenaarbade44e2020-09-26 22:39:24 +02008980 semsg(_(e_using_number_as_bool_nr), skipcc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008981 else
Bram Moolenaar70ce8a12021-03-14 19:02:09 +01008982 strchar_common(argvars, rettv, skipcc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008983}
8984
8985/*
8986 * "strdisplaywidth()" function
8987 */
8988 static void
8989f_strdisplaywidth(typval_T *argvars, typval_T *rettv)
8990{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008991 char_u *s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008992 int col = 0;
8993
8994 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008995 col = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008996
8997 rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col);
8998}
8999
9000/*
9001 * "strwidth()" function
9002 */
9003 static void
9004f_strwidth(typval_T *argvars, typval_T *rettv)
9005{
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +02009006 char_u *s = tv_get_string_strict(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009007
Bram Moolenaar13505972019-01-24 15:04:48 +01009008 rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009009}
9010
9011/*
9012 * "strcharpart()" function
9013 */
9014 static void
9015f_strcharpart(typval_T *argvars, typval_T *rettv)
9016{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009017 char_u *p;
9018 int nchar;
9019 int nbyte = 0;
9020 int charlen;
Bram Moolenaar02b4d9b2021-03-14 19:46:45 +01009021 int skipcc = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009022 int len = 0;
9023 int slen;
9024 int error = FALSE;
9025
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009026 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009027 slen = (int)STRLEN(p);
9028
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009029 nchar = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009030 if (!error)
9031 {
Bram Moolenaar02b4d9b2021-03-14 19:46:45 +01009032 if (argvars[2].v_type != VAR_UNKNOWN
9033 && argvars[3].v_type != VAR_UNKNOWN)
9034 {
9035 skipcc = tv_get_bool(&argvars[3]);
9036 if (skipcc < 0 || skipcc > 1)
9037 {
9038 semsg(_(e_using_number_as_bool_nr), skipcc);
9039 return;
9040 }
9041 }
9042
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009043 if (nchar > 0)
9044 while (nchar > 0 && nbyte < slen)
9045 {
Bram Moolenaar02b4d9b2021-03-14 19:46:45 +01009046 if (skipcc)
9047 nbyte += mb_ptr2len(p + nbyte);
9048 else
9049 nbyte += MB_CPTR2LEN(p + nbyte);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009050 --nchar;
9051 }
9052 else
9053 nbyte = nchar;
9054 if (argvars[2].v_type != VAR_UNKNOWN)
9055 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009056 charlen = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009057 while (charlen > 0 && nbyte + len < slen)
9058 {
9059 int off = nbyte + len;
9060
9061 if (off < 0)
9062 len += 1;
9063 else
Bram Moolenaar02b4d9b2021-03-14 19:46:45 +01009064 {
9065 if (skipcc)
9066 len += mb_ptr2len(p + off);
9067 else
9068 len += MB_CPTR2LEN(p + off);
9069 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009070 --charlen;
9071 }
9072 }
9073 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009074 len = slen - nbyte; // default: all bytes that are available.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009075 }
9076
9077 /*
9078 * Only return the overlap between the specified part and the actual
9079 * string.
9080 */
9081 if (nbyte < 0)
9082 {
9083 len += nbyte;
9084 nbyte = 0;
9085 }
9086 else if (nbyte > slen)
9087 nbyte = slen;
9088 if (len < 0)
9089 len = 0;
9090 else if (nbyte + len > slen)
9091 len = slen - nbyte;
9092
9093 rettv->v_type = VAR_STRING;
9094 rettv->vval.v_string = vim_strnsave(p + nbyte, len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009095}
9096
9097/*
9098 * "strpart()" function
9099 */
9100 static void
9101f_strpart(typval_T *argvars, typval_T *rettv)
9102{
9103 char_u *p;
9104 int n;
9105 int len;
9106 int slen;
9107 int error = FALSE;
9108
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009109 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009110 slen = (int)STRLEN(p);
9111
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009112 n = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009113 if (error)
9114 len = 0;
9115 else if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009116 len = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009117 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009118 len = slen - n; // default len: all bytes that are available.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009119
Bram Moolenaar6c53fca2020-08-23 17:34:46 +02009120 // Only return the overlap between the specified part and the actual
9121 // string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009122 if (n < 0)
9123 {
9124 len += n;
9125 n = 0;
9126 }
9127 else if (n > slen)
9128 n = slen;
9129 if (len < 0)
9130 len = 0;
9131 else if (n + len > slen)
9132 len = slen - n;
9133
Bram Moolenaar6c53fca2020-08-23 17:34:46 +02009134 if (argvars[2].v_type != VAR_UNKNOWN && argvars[3].v_type != VAR_UNKNOWN)
9135 {
9136 int off;
9137
9138 // length in characters
9139 for (off = n; off < slen && len > 0; --len)
9140 off += mb_ptr2len(p + off);
9141 len = off - n;
9142 }
9143
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009144 rettv->v_type = VAR_STRING;
9145 rettv->vval.v_string = vim_strnsave(p + n, len);
9146}
9147
9148/*
9149 * "strridx()" function
9150 */
9151 static void
9152f_strridx(typval_T *argvars, typval_T *rettv)
9153{
9154 char_u buf[NUMBUFLEN];
9155 char_u *needle;
9156 char_u *haystack;
9157 char_u *rest;
9158 char_u *lastmatch = NULL;
9159 int haystack_len, end_idx;
9160
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009161 needle = tv_get_string_chk(&argvars[1]);
9162 haystack = tv_get_string_buf_chk(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009163
9164 rettv->vval.v_number = -1;
9165 if (needle == NULL || haystack == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009166 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009167
9168 haystack_len = (int)STRLEN(haystack);
9169 if (argvars[2].v_type != VAR_UNKNOWN)
9170 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009171 // Third argument: upper limit for index
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009172 end_idx = (int)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009173 if (end_idx < 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009174 return; // can never find a match
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009175 }
9176 else
9177 end_idx = haystack_len;
9178
9179 if (*needle == NUL)
9180 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009181 // Empty string matches past the end.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009182 lastmatch = haystack + end_idx;
9183 }
9184 else
9185 {
9186 for (rest = haystack; *rest != '\0'; ++rest)
9187 {
9188 rest = (char_u *)strstr((char *)rest, (char *)needle);
9189 if (rest == NULL || rest > haystack + end_idx)
9190 break;
9191 lastmatch = rest;
9192 }
9193 }
9194
9195 if (lastmatch == NULL)
9196 rettv->vval.v_number = -1;
9197 else
9198 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
9199}
9200
9201/*
9202 * "strtrans()" function
9203 */
9204 static void
9205f_strtrans(typval_T *argvars, typval_T *rettv)
9206{
9207 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009208 rettv->vval.v_string = transstr(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009209}
9210
9211/*
9212 * "submatch()" function
9213 */
9214 static void
9215f_submatch(typval_T *argvars, typval_T *rettv)
9216{
9217 int error = FALSE;
9218 int no;
9219 int retList = 0;
9220
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009221 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009222 if (error)
9223 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +02009224 if (no < 0 || no >= NSUBEXP)
9225 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009226 semsg(_("E935: invalid submatch number: %d"), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +01009227 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +02009228 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009229 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaarad304702020-09-06 18:22:53 +02009230 retList = (int)tv_get_bool_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009231 if (error)
9232 return;
9233
9234 if (retList == 0)
9235 {
9236 rettv->v_type = VAR_STRING;
9237 rettv->vval.v_string = reg_submatch(no);
9238 }
9239 else
9240 {
9241 rettv->v_type = VAR_LIST;
9242 rettv->vval.v_list = reg_submatch_list(no);
9243 }
9244}
9245
9246/*
9247 * "substitute()" function
9248 */
9249 static void
9250f_substitute(typval_T *argvars, typval_T *rettv)
9251{
9252 char_u patbuf[NUMBUFLEN];
9253 char_u subbuf[NUMBUFLEN];
9254 char_u flagsbuf[NUMBUFLEN];
9255
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009256 char_u *str = tv_get_string_chk(&argvars[0]);
9257 char_u *pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009258 char_u *sub = NULL;
9259 typval_T *expr = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009260 char_u *flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009261
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009262 if (argvars[2].v_type == VAR_FUNC || argvars[2].v_type == VAR_PARTIAL)
9263 expr = &argvars[2];
9264 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009265 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009266
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009267 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009268 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
9269 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009270 rettv->vval.v_string = NULL;
9271 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009272 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009273}
9274
9275/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +02009276 * "swapinfo(swap_filename)" function
9277 */
9278 static void
9279f_swapinfo(typval_T *argvars, typval_T *rettv)
9280{
9281 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009282 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +02009283}
9284
9285/*
Bram Moolenaar110bd602018-09-16 18:46:59 +02009286 * "swapname(expr)" function
9287 */
9288 static void
9289f_swapname(typval_T *argvars, typval_T *rettv)
9290{
9291 buf_T *buf;
9292
9293 rettv->v_type = VAR_STRING;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01009294 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +02009295 if (buf == NULL || buf->b_ml.ml_mfp == NULL
9296 || buf->b_ml.ml_mfp->mf_fname == NULL)
9297 rettv->vval.v_string = NULL;
9298 else
9299 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
9300}
9301
9302/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009303 * "synID(lnum, col, trans)" function
9304 */
9305 static void
9306f_synID(typval_T *argvars UNUSED, typval_T *rettv)
9307{
9308 int id = 0;
9309#ifdef FEAT_SYN_HL
9310 linenr_T lnum;
9311 colnr_T col;
9312 int trans;
9313 int transerr = FALSE;
9314
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009315 lnum = tv_get_lnum(argvars); // -1 on type error
9316 col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaarfcb6d702020-09-05 21:41:56 +02009317 trans = (int)tv_get_bool_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009318
9319 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
9320 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
9321 id = syn_get_id(curwin, lnum, (colnr_T)col, trans, NULL, FALSE);
9322#endif
9323
9324 rettv->vval.v_number = id;
9325}
9326
9327/*
9328 * "synIDattr(id, what [, mode])" function
9329 */
9330 static void
9331f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
9332{
9333 char_u *p = NULL;
9334#ifdef FEAT_SYN_HL
9335 int id;
9336 char_u *what;
9337 char_u *mode;
9338 char_u modebuf[NUMBUFLEN];
9339 int modec;
9340
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009341 id = (int)tv_get_number(&argvars[0]);
9342 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009343 if (argvars[2].v_type != VAR_UNKNOWN)
9344 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009345 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009346 modec = TOLOWER_ASC(mode[0]);
9347 if (modec != 't' && modec != 'c' && modec != 'g')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009348 modec = 0; // replace invalid with current
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009349 }
9350 else
9351 {
9352#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
9353 if (USE_24BIT)
9354 modec = 'g';
9355 else
9356#endif
9357 if (t_colors > 1)
Dominique Pelle4781d6f2021-05-18 21:46:31 +02009358 modec = 'c';
9359 else
9360 modec = 't';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009361 }
9362
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009363 switch (TOLOWER_ASC(what[0]))
9364 {
9365 case 'b':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009366 if (TOLOWER_ASC(what[1]) == 'g') // bg[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009367 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009368 else // bold
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009369 p = highlight_has_attr(id, HL_BOLD, modec);
9370 break;
9371
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009372 case 'f': // fg[#] or font
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009373 p = highlight_color(id, what, modec);
9374 break;
9375
9376 case 'i':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009377 if (TOLOWER_ASC(what[1]) == 'n') // inverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009378 p = highlight_has_attr(id, HL_INVERSE, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009379 else // italic
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009380 p = highlight_has_attr(id, HL_ITALIC, modec);
9381 break;
9382
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009383 case 'n': // name
Bram Moolenaarc96272e2017-03-26 13:50:09 +02009384 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009385 break;
9386
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009387 case 'r': // reverse
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009388 p = highlight_has_attr(id, HL_INVERSE, modec);
9389 break;
9390
9391 case 's':
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009392 if (TOLOWER_ASC(what[1]) == 'p') // sp[#]
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009393 p = highlight_color(id, what, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009394 // strikeout
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +02009395 else if (TOLOWER_ASC(what[1]) == 't' &&
9396 TOLOWER_ASC(what[2]) == 'r')
9397 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009398 else // standout
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009399 p = highlight_has_attr(id, HL_STANDOUT, modec);
9400 break;
9401
9402 case 'u':
Bram Moolenaar391c3622020-09-29 20:59:17 +02009403 if (TOLOWER_ASC(what[1]) == 'l') // ul
9404 p = highlight_color(id, what, modec);
9405 else if (STRLEN(what) <= 5 || TOLOWER_ASC(what[5]) != 'c')
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009406 // underline
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009407 p = highlight_has_attr(id, HL_UNDERLINE, modec);
9408 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009409 // undercurl
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009410 p = highlight_has_attr(id, HL_UNDERCURL, modec);
9411 break;
9412 }
9413
9414 if (p != NULL)
9415 p = vim_strsave(p);
9416#endif
9417 rettv->v_type = VAR_STRING;
9418 rettv->vval.v_string = p;
9419}
9420
9421/*
9422 * "synIDtrans(id)" function
9423 */
9424 static void
9425f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
9426{
9427 int id;
9428
9429#ifdef FEAT_SYN_HL
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009430 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009431
9432 if (id > 0)
9433 id = syn_get_final_id(id);
9434 else
9435#endif
9436 id = 0;
9437
9438 rettv->vval.v_number = id;
9439}
9440
9441/*
9442 * "synconcealed(lnum, col)" function
9443 */
9444 static void
9445f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
9446{
9447#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
9448 linenr_T lnum;
9449 colnr_T col;
9450 int syntax_flags = 0;
9451 int cchar;
9452 int matchid = 0;
9453 char_u str[NUMBUFLEN];
9454#endif
9455
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02009456 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009457
9458#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009459 lnum = tv_get_lnum(argvars); // -1 on type error
9460 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009461
Bram Moolenaara80faa82020-04-12 19:37:17 +02009462 CLEAR_FIELD(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009463
9464 if (rettv_list_alloc(rettv) != FAIL)
9465 {
9466 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
9467 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
9468 && curwin->w_p_cole > 0)
9469 {
9470 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
9471 syntax_flags = get_syntax_info(&matchid);
9472
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009473 // get the conceal character
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009474 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
9475 {
9476 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +02009477 if (cchar == NUL && curwin->w_p_cole == 1)
Bram Moolenaareed9d462021-02-15 20:38:25 +01009478 cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' '
9479 : curwin->w_lcs_chars.conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009480 if (cchar != NUL)
9481 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009482 if (has_mbyte)
9483 (*mb_char2bytes)(cchar, str);
9484 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009485 str[0] = cchar;
9486 }
9487 }
9488 }
9489
9490 list_append_number(rettv->vval.v_list,
9491 (syntax_flags & HL_CONCEAL) != 0);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009492 // -1 to auto-determine strlen
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009493 list_append_string(rettv->vval.v_list, str, -1);
9494 list_append_number(rettv->vval.v_list, matchid);
9495 }
9496#endif
9497}
9498
9499/*
9500 * "synstack(lnum, col)" function
9501 */
9502 static void
9503f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
9504{
9505#ifdef FEAT_SYN_HL
9506 linenr_T lnum;
9507 colnr_T col;
9508 int i;
9509 int id;
9510#endif
9511
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02009512 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009513
9514#ifdef FEAT_SYN_HL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009515 lnum = tv_get_lnum(argvars); // -1 on type error
9516 col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009517
9518 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
9519 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
9520 && rettv_list_alloc(rettv) != FAIL)
9521 {
9522 (void)syn_get_id(curwin, lnum, (colnr_T)col, FALSE, NULL, TRUE);
9523 for (i = 0; ; ++i)
9524 {
9525 id = syn_get_stack_item(i);
9526 if (id < 0)
9527 break;
9528 if (list_append_number(rettv->vval.v_list, id) == FAIL)
9529 break;
9530 }
9531 }
9532#endif
9533}
9534
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009535/*
9536 * "tabpagebuflist()" function
9537 */
9538 static void
9539f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9540{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009541 tabpage_T *tp;
9542 win_T *wp = NULL;
9543
9544 if (argvars[0].v_type == VAR_UNKNOWN)
9545 wp = firstwin;
9546 else
9547 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009548 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009549 if (tp != NULL)
9550 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
9551 }
9552 if (wp != NULL && rettv_list_alloc(rettv) != FAIL)
9553 {
9554 for (; wp != NULL; wp = wp->w_next)
9555 if (list_append_number(rettv->vval.v_list,
9556 wp->w_buffer->b_fnum) == FAIL)
9557 break;
9558 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009559}
9560
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009561/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009562 * "tagfiles()" function
9563 */
9564 static void
9565f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
9566{
9567 char_u *fname;
9568 tagname_T tn;
9569 int first;
9570
9571 if (rettv_list_alloc(rettv) == FAIL)
9572 return;
9573 fname = alloc(MAXPATHL);
9574 if (fname == NULL)
9575 return;
9576
9577 for (first = TRUE; ; first = FALSE)
9578 if (get_tagfname(&tn, first, fname) == FAIL
9579 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
9580 break;
9581 tagname_free(&tn);
9582 vim_free(fname);
9583}
9584
9585/*
9586 * "taglist()" function
9587 */
9588 static void
9589f_taglist(typval_T *argvars, typval_T *rettv)
9590{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +01009591 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009592 char_u *tag_pattern;
9593
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009594 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009595
9596 rettv->vval.v_number = FALSE;
9597 if (*tag_pattern == NUL)
9598 return;
9599
Bram Moolenaarc6aafba2017-03-21 17:09:10 +01009600 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009601 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009602 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +01009603 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009604}
9605
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009606/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009607 * "tolower(string)" function
9608 */
9609 static void
9610f_tolower(typval_T *argvars, typval_T *rettv)
9611{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009612 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009613 rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009614}
9615
9616/*
9617 * "toupper(string)" function
9618 */
9619 static void
9620f_toupper(typval_T *argvars, typval_T *rettv)
9621{
9622 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009623 rettv->vval.v_string = strup_save(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009624}
9625
9626/*
9627 * "tr(string, fromstr, tostr)" function
9628 */
9629 static void
9630f_tr(typval_T *argvars, typval_T *rettv)
9631{
9632 char_u *in_str;
9633 char_u *fromstr;
9634 char_u *tostr;
9635 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009636 int inlen;
9637 int fromlen;
9638 int tolen;
9639 int idx;
9640 char_u *cpstr;
9641 int cplen;
9642 int first = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009643 char_u buf[NUMBUFLEN];
9644 char_u buf2[NUMBUFLEN];
9645 garray_T ga;
9646
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009647 in_str = tv_get_string(&argvars[0]);
9648 fromstr = tv_get_string_buf_chk(&argvars[1], buf);
9649 tostr = tv_get_string_buf_chk(&argvars[2], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009650
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009651 // Default return value: empty string.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009652 rettv->v_type = VAR_STRING;
9653 rettv->vval.v_string = NULL;
9654 if (fromstr == NULL || tostr == NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009655 return; // type error; errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009656 ga_init2(&ga, (int)sizeof(char), 80);
9657
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009658 if (!has_mbyte)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009659 // not multi-byte: fromstr and tostr must be the same length
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009660 if (STRLEN(fromstr) != STRLEN(tostr))
9661 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009662error:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009663 semsg(_(e_invarg2), fromstr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009664 ga_clear(&ga);
9665 return;
9666 }
9667
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009668 // fromstr and tostr have to contain the same number of chars
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009669 while (*in_str != NUL)
9670 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009671 if (has_mbyte)
9672 {
9673 inlen = (*mb_ptr2len)(in_str);
9674 cpstr = in_str;
9675 cplen = inlen;
9676 idx = 0;
9677 for (p = fromstr; *p != NUL; p += fromlen)
9678 {
9679 fromlen = (*mb_ptr2len)(p);
9680 if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0)
9681 {
9682 for (p = tostr; *p != NUL; p += tolen)
9683 {
9684 tolen = (*mb_ptr2len)(p);
9685 if (idx-- == 0)
9686 {
9687 cplen = tolen;
9688 cpstr = p;
9689 break;
9690 }
9691 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009692 if (*p == NUL) // tostr is shorter than fromstr
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009693 goto error;
9694 break;
9695 }
9696 ++idx;
9697 }
9698
9699 if (first && cpstr == in_str)
9700 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009701 // Check that fromstr and tostr have the same number of
9702 // (multi-byte) characters. Done only once when a character
9703 // of in_str doesn't appear in fromstr.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009704 first = FALSE;
9705 for (p = tostr; *p != NUL; p += tolen)
9706 {
9707 tolen = (*mb_ptr2len)(p);
9708 --idx;
9709 }
9710 if (idx != 0)
9711 goto error;
9712 }
9713
9714 (void)ga_grow(&ga, cplen);
9715 mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen);
9716 ga.ga_len += cplen;
9717
9718 in_str += inlen;
9719 }
9720 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009721 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009722 // When not using multi-byte chars we can do it faster.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009723 p = vim_strchr(fromstr, *in_str);
9724 if (p != NULL)
9725 ga_append(&ga, tostr[p - fromstr]);
9726 else
9727 ga_append(&ga, *in_str);
9728 ++in_str;
9729 }
9730 }
9731
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009732 // add a terminating NUL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009733 (void)ga_grow(&ga, 1);
9734 ga_append(&ga, NUL);
9735
9736 rettv->vval.v_string = ga.ga_data;
9737}
9738
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009739/*
9740 * "trim({expr})" function
9741 */
9742 static void
9743f_trim(typval_T *argvars, typval_T *rettv)
9744{
9745 char_u buf1[NUMBUFLEN];
9746 char_u buf2[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009747 char_u *head = tv_get_string_buf_chk(&argvars[0], buf1);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009748 char_u *mask = NULL;
9749 char_u *tail;
9750 char_u *prev;
9751 char_u *p;
9752 int c1;
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009753 int dir = 0;
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009754
9755 rettv->v_type = VAR_STRING;
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009756 rettv->vval.v_string = NULL;
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009757 if (head == NULL)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009758 return;
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009759
9760 if (argvars[1].v_type == VAR_STRING)
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009761 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009762 mask = tv_get_string_buf_chk(&argvars[1], buf2);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009763
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009764 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009765 {
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009766 int error = 0;
9767
9768 // leading or trailing characters to trim
9769 dir = (int)tv_get_number_chk(&argvars[2], &error);
9770 if (error)
9771 return;
9772 if (dir < 0 || dir > 2)
9773 {
9774 semsg(_(e_invarg2), tv_get_string(&argvars[2]));
9775 return;
9776 }
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009777 }
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009778 }
9779
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009780 if (dir == 0 || dir == 1)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009781 {
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009782 // Trim leading characters
9783 while (*head != NUL)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009784 {
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009785 c1 = PTR2CHAR(head);
9786 if (mask == NULL)
9787 {
9788 if (c1 > ' ' && c1 != 0xa0)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009789 break;
Bram Moolenaar2245ae12020-05-31 22:20:36 +02009790 }
9791 else
9792 {
9793 for (p = mask; *p != NUL; MB_PTR_ADV(p))
9794 if (c1 == PTR2CHAR(p))
9795 break;
9796 if (*p == NUL)
9797 break;
9798 }
9799 MB_PTR_ADV(head);
9800 }
9801 }
9802
9803 tail = head + STRLEN(head);
9804 if (dir == 0 || dir == 2)
9805 {
9806 // Trim trailing characters
9807 for (; tail > head; tail = prev)
9808 {
9809 prev = tail;
9810 MB_PTR_BACK(head, prev);
9811 c1 = PTR2CHAR(prev);
9812 if (mask == NULL)
9813 {
9814 if (c1 > ' ' && c1 != 0xa0)
9815 break;
9816 }
9817 else
9818 {
9819 for (p = mask; *p != NUL; MB_PTR_ADV(p))
9820 if (c1 == PTR2CHAR(p))
9821 break;
9822 if (*p == NUL)
9823 break;
9824 }
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009825 }
9826 }
Bram Moolenaardf44a272020-06-07 20:49:05 +02009827 rettv->vval.v_string = vim_strnsave(head, tail - head);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01009828}
9829
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009830/*
9831 * "type(expr)" function
9832 */
9833 static void
9834f_type(typval_T *argvars, typval_T *rettv)
9835{
9836 int n = -1;
9837
9838 switch (argvars[0].v_type)
9839 {
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01009840 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
9841 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009842 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01009843 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
9844 case VAR_LIST: n = VAR_TYPE_LIST; break;
9845 case VAR_DICT: n = VAR_TYPE_DICT; break;
9846 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
9847 case VAR_BOOL: n = VAR_TYPE_BOOL; break;
9848 case VAR_SPECIAL: n = VAR_TYPE_NONE; break;
Bram Moolenaarf562e722016-07-19 17:25:25 +02009849 case VAR_JOB: n = VAR_TYPE_JOB; break;
9850 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009851 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaarf18332f2021-05-07 17:55:55 +02009852 case VAR_INSTR: n = VAR_TYPE_INSTR; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009853 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02009854 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009855 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +01009856 internal_error_no_abort("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009857 n = -1;
9858 break;
9859 }
9860 rettv->vval.v_number = n;
9861}
9862
9863/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009864 * "virtcol(string)" function
9865 */
9866 static void
9867f_virtcol(typval_T *argvars, typval_T *rettv)
9868{
9869 colnr_T vcol = 0;
9870 pos_T *fp;
9871 int fnum = curbuf->b_fnum;
Bram Moolenaarb3d33d82020-01-15 20:36:55 +01009872 int len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009873
Bram Moolenaar6f02b002021-01-10 20:22:54 +01009874 fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009875 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
9876 && fnum == curbuf->b_fnum)
9877 {
Bram Moolenaarb3d33d82020-01-15 20:36:55 +01009878 // Limit the column to a valid value, getvvcol() doesn't check.
9879 if (fp->col < 0)
9880 fp->col = 0;
9881 else
9882 {
9883 len = (int)STRLEN(ml_get(fp->lnum));
9884 if (fp->col > len)
9885 fp->col = len;
9886 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009887 getvvcol(curwin, fp, NULL, NULL, &vcol);
9888 ++vcol;
9889 }
9890
9891 rettv->vval.v_number = vcol;
9892}
9893
9894/*
9895 * "visualmode()" function
9896 */
9897 static void
9898f_visualmode(typval_T *argvars, typval_T *rettv)
9899{
9900 char_u str[2];
9901
9902 rettv->v_type = VAR_STRING;
9903 str[0] = curbuf->b_visual_mode_eval;
9904 str[1] = NUL;
9905 rettv->vval.v_string = vim_strsave(str);
9906
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009907 // A non-zero number or non-empty string argument: reset mode.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009908 if (non_zero_arg(&argvars[0]))
9909 curbuf->b_visual_mode_eval = NUL;
9910}
9911
9912/*
9913 * "wildmenumode()" function
9914 */
9915 static void
9916f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9917{
9918#ifdef FEAT_WILDMENU
9919 if (wild_menu_showing)
9920 rettv->vval.v_number = 1;
9921#endif
9922}
9923
9924/*
Bram Moolenaar0c1e3742019-12-27 13:49:24 +01009925 * "windowsversion()" function
9926 */
9927 static void
9928f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9929{
9930 rettv->v_type = VAR_STRING;
9931 rettv->vval.v_string = vim_strsave((char_u *)windowsVersion);
9932}
9933
9934/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009935 * "wordcount()" function
9936 */
9937 static void
9938f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
9939{
9940 if (rettv_dict_alloc(rettv) == FAIL)
9941 return;
9942 cursor_pos_info(rettv->vval.v_dict);
9943}
9944
9945/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009946 * "xor(expr, expr)" function
9947 */
9948 static void
9949f_xor(typval_T *argvars, typval_T *rettv)
9950{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009951 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
9952 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009953}
9954
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01009955#endif // FEAT_EVAL