blob: 2f75cbf222e4755f6a9d58301936356843959c52 [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
19#ifdef AMIGA
20# include <time.h> /* for strftime() */
21#endif
22
23#ifdef VMS
24# include <float.h>
25#endif
26
Bram Moolenaard0573012017-10-28 21:11:06 +020027#ifdef MACOS_X
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020028# include <time.h> /* for time_t */
29#endif
30
31static char *e_listarg = N_("E686: Argument of %s must be a List");
Bram Moolenaarbf821bc2019-01-23 21:15:02 +010032static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020033static char *e_stringreq = N_("E928: String required");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020034
35#ifdef FEAT_FLOAT
36static void f_abs(typval_T *argvars, typval_T *rettv);
37static void f_acos(typval_T *argvars, typval_T *rettv);
38#endif
39static void f_add(typval_T *argvars, typval_T *rettv);
40static void f_and(typval_T *argvars, typval_T *rettv);
41static void f_append(typval_T *argvars, typval_T *rettv);
Bram Moolenaarca851592018-06-06 21:04:07 +020042static void f_appendbufline(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020043static void f_argc(typval_T *argvars, typval_T *rettv);
44static void f_argidx(typval_T *argvars, typval_T *rettv);
45static void f_arglistid(typval_T *argvars, typval_T *rettv);
46static void f_argv(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb48e96f2018-02-13 12:26:14 +010047static void f_assert_beeps(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020048static void f_assert_equal(typval_T *argvars, typval_T *rettv);
Bram Moolenaard96ff162018-02-18 22:13:29 +010049static void f_assert_equalfile(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020050static void f_assert_exception(typval_T *argvars, typval_T *rettv);
51static void f_assert_fails(typval_T *argvars, typval_T *rettv);
52static void f_assert_false(typval_T *argvars, typval_T *rettv);
Bram Moolenaar61c04492016-07-23 15:35:35 +020053static void f_assert_inrange(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020054static void f_assert_match(typval_T *argvars, typval_T *rettv);
55static void f_assert_notequal(typval_T *argvars, typval_T *rettv);
56static void f_assert_notmatch(typval_T *argvars, typval_T *rettv);
Bram Moolenaar42205552017-03-18 19:42:22 +010057static void f_assert_report(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020058static void f_assert_true(typval_T *argvars, typval_T *rettv);
59#ifdef FEAT_FLOAT
60static void f_asin(typval_T *argvars, typval_T *rettv);
61static void f_atan(typval_T *argvars, typval_T *rettv);
62static void f_atan2(typval_T *argvars, typval_T *rettv);
63#endif
Bram Moolenaar59716a22017-03-01 20:32:44 +010064#ifdef FEAT_BEVAL
65static void f_balloon_show(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010066# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +010067static void f_balloon_split(typval_T *argvars, typval_T *rettv);
Bram Moolenaar669a8282017-11-19 20:13:05 +010068# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +010069#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020070static void f_browse(typval_T *argvars, typval_T *rettv);
71static void f_browsedir(typval_T *argvars, typval_T *rettv);
72static void f_bufexists(typval_T *argvars, typval_T *rettv);
73static void f_buflisted(typval_T *argvars, typval_T *rettv);
74static void f_bufloaded(typval_T *argvars, typval_T *rettv);
75static void f_bufname(typval_T *argvars, typval_T *rettv);
76static void f_bufnr(typval_T *argvars, typval_T *rettv);
77static void f_bufwinid(typval_T *argvars, typval_T *rettv);
78static void f_bufwinnr(typval_T *argvars, typval_T *rettv);
79static void f_byte2line(typval_T *argvars, typval_T *rettv);
80static void byteidx(typval_T *argvars, typval_T *rettv, int comp);
81static void f_byteidx(typval_T *argvars, typval_T *rettv);
82static void f_byteidxcomp(typval_T *argvars, typval_T *rettv);
83static void f_call(typval_T *argvars, typval_T *rettv);
84#ifdef FEAT_FLOAT
85static void f_ceil(typval_T *argvars, typval_T *rettv);
86#endif
87#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar4b785f62016-11-29 21:54:44 +010088static void f_ch_canread(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020089static void f_ch_close(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0874a832016-09-01 15:11:51 +020090static void f_ch_close_in(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020091static void f_ch_evalexpr(typval_T *argvars, typval_T *rettv);
92static void f_ch_evalraw(typval_T *argvars, typval_T *rettv);
93static void f_ch_getbufnr(typval_T *argvars, typval_T *rettv);
94static void f_ch_getjob(typval_T *argvars, typval_T *rettv);
95static void f_ch_info(typval_T *argvars, typval_T *rettv);
96static void f_ch_log(typval_T *argvars, typval_T *rettv);
97static void f_ch_logfile(typval_T *argvars, typval_T *rettv);
98static void f_ch_open(typval_T *argvars, typval_T *rettv);
99static void f_ch_read(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +0100100static void f_ch_readblob(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200101static void f_ch_readraw(typval_T *argvars, typval_T *rettv);
102static void f_ch_sendexpr(typval_T *argvars, typval_T *rettv);
103static void f_ch_sendraw(typval_T *argvars, typval_T *rettv);
104static void f_ch_setoptions(typval_T *argvars, typval_T *rettv);
105static void f_ch_status(typval_T *argvars, typval_T *rettv);
106#endif
107static void f_changenr(typval_T *argvars, typval_T *rettv);
108static void f_char2nr(typval_T *argvars, typval_T *rettv);
109static void f_cindent(typval_T *argvars, typval_T *rettv);
110static void f_clearmatches(typval_T *argvars, typval_T *rettv);
111static void f_col(typval_T *argvars, typval_T *rettv);
112#if defined(FEAT_INS_EXPAND)
113static void f_complete(typval_T *argvars, typval_T *rettv);
114static void f_complete_add(typval_T *argvars, typval_T *rettv);
115static void f_complete_check(typval_T *argvars, typval_T *rettv);
116#endif
117static void f_confirm(typval_T *argvars, typval_T *rettv);
118static void f_copy(typval_T *argvars, typval_T *rettv);
119#ifdef FEAT_FLOAT
120static void f_cos(typval_T *argvars, typval_T *rettv);
121static void f_cosh(typval_T *argvars, typval_T *rettv);
122#endif
123static void f_count(typval_T *argvars, typval_T *rettv);
124static void f_cscope_connection(typval_T *argvars, typval_T *rettv);
125static void f_cursor(typval_T *argsvars, typval_T *rettv);
Bram Moolenaar4f974752019-02-17 17:44:42 +0100126#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +0200127static void f_debugbreak(typval_T *argvars, typval_T *rettv);
128#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200129static void f_deepcopy(typval_T *argvars, typval_T *rettv);
130static void f_delete(typval_T *argvars, typval_T *rettv);
Bram Moolenaard79a2622018-06-07 18:17:46 +0200131static void f_deletebufline(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200132static void f_did_filetype(typval_T *argvars, typval_T *rettv);
133static void f_diff_filler(typval_T *argvars, typval_T *rettv);
134static void f_diff_hlID(typval_T *argvars, typval_T *rettv);
135static void f_empty(typval_T *argvars, typval_T *rettv);
136static void f_escape(typval_T *argvars, typval_T *rettv);
137static void f_eval(typval_T *argvars, typval_T *rettv);
138static void f_eventhandler(typval_T *argvars, typval_T *rettv);
139static void f_executable(typval_T *argvars, typval_T *rettv);
140static void f_execute(typval_T *argvars, typval_T *rettv);
141static void f_exepath(typval_T *argvars, typval_T *rettv);
142static void f_exists(typval_T *argvars, typval_T *rettv);
143#ifdef FEAT_FLOAT
144static void f_exp(typval_T *argvars, typval_T *rettv);
145#endif
146static void f_expand(typval_T *argvars, typval_T *rettv);
147static void f_extend(typval_T *argvars, typval_T *rettv);
148static void f_feedkeys(typval_T *argvars, typval_T *rettv);
149static void f_filereadable(typval_T *argvars, typval_T *rettv);
150static void f_filewritable(typval_T *argvars, typval_T *rettv);
151static void f_filter(typval_T *argvars, typval_T *rettv);
152static void f_finddir(typval_T *argvars, typval_T *rettv);
153static void f_findfile(typval_T *argvars, typval_T *rettv);
154#ifdef FEAT_FLOAT
155static void f_float2nr(typval_T *argvars, typval_T *rettv);
156static void f_floor(typval_T *argvars, typval_T *rettv);
157static void f_fmod(typval_T *argvars, typval_T *rettv);
158#endif
159static void f_fnameescape(typval_T *argvars, typval_T *rettv);
160static void f_fnamemodify(typval_T *argvars, typval_T *rettv);
161static void f_foldclosed(typval_T *argvars, typval_T *rettv);
162static void f_foldclosedend(typval_T *argvars, typval_T *rettv);
163static void f_foldlevel(typval_T *argvars, typval_T *rettv);
164static void f_foldtext(typval_T *argvars, typval_T *rettv);
165static void f_foldtextresult(typval_T *argvars, typval_T *rettv);
166static void f_foreground(typval_T *argvars, typval_T *rettv);
Bram Moolenaar437bafe2016-08-01 15:40:54 +0200167static void f_funcref(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200168static void f_function(typval_T *argvars, typval_T *rettv);
169static void f_garbagecollect(typval_T *argvars, typval_T *rettv);
170static void f_get(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200171static void f_getbufinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200172static void f_getbufline(typval_T *argvars, typval_T *rettv);
173static void f_getbufvar(typval_T *argvars, typval_T *rettv);
Bram Moolenaar07ad8162018-02-13 13:59:59 +0100174static void f_getchangelist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200175static void f_getchar(typval_T *argvars, typval_T *rettv);
176static void f_getcharmod(typval_T *argvars, typval_T *rettv);
177static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
178static void f_getcmdline(typval_T *argvars, typval_T *rettv);
179#if defined(FEAT_CMDL_COMPL)
180static void f_getcompletion(typval_T *argvars, typval_T *rettv);
181#endif
182static void f_getcmdpos(typval_T *argvars, typval_T *rettv);
183static void f_getcmdtype(typval_T *argvars, typval_T *rettv);
184static void f_getcmdwintype(typval_T *argvars, typval_T *rettv);
185static void f_getcwd(typval_T *argvars, typval_T *rettv);
186static void f_getfontname(typval_T *argvars, typval_T *rettv);
187static void f_getfperm(typval_T *argvars, typval_T *rettv);
188static void f_getfsize(typval_T *argvars, typval_T *rettv);
189static void f_getftime(typval_T *argvars, typval_T *rettv);
190static void f_getftype(typval_T *argvars, typval_T *rettv);
Bram Moolenaar4f505882018-02-10 21:06:32 +0100191static void f_getjumplist(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200192static void f_getline(typval_T *argvars, typval_T *rettv);
Bram Moolenaard823fa92016-08-12 16:29:27 +0200193static void f_getloclist(typval_T *argvars UNUSED, typval_T *rettv UNUSED);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200194static void f_getmatches(typval_T *argvars, typval_T *rettv);
195static void f_getpid(typval_T *argvars, typval_T *rettv);
196static void f_getcurpos(typval_T *argvars, typval_T *rettv);
197static void f_getpos(typval_T *argvars, typval_T *rettv);
198static void f_getqflist(typval_T *argvars, typval_T *rettv);
199static void f_getreg(typval_T *argvars, typval_T *rettv);
200static void f_getregtype(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200201static void f_gettabinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200202static void f_gettabvar(typval_T *argvars, typval_T *rettv);
203static void f_gettabwinvar(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100204static void f_gettagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200205static void f_getwininfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar3f54fd32018-03-03 21:29:55 +0100206static void f_getwinpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200207static void f_getwinposx(typval_T *argvars, typval_T *rettv);
208static void f_getwinposy(typval_T *argvars, typval_T *rettv);
209static void f_getwinvar(typval_T *argvars, typval_T *rettv);
210static void f_glob(typval_T *argvars, typval_T *rettv);
211static void f_globpath(typval_T *argvars, typval_T *rettv);
212static void f_glob2regpat(typval_T *argvars, typval_T *rettv);
213static void f_has(typval_T *argvars, typval_T *rettv);
214static void f_has_key(typval_T *argvars, typval_T *rettv);
215static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
216static void f_hasmapto(typval_T *argvars, typval_T *rettv);
217static void f_histadd(typval_T *argvars, typval_T *rettv);
218static void f_histdel(typval_T *argvars, typval_T *rettv);
219static void f_histget(typval_T *argvars, typval_T *rettv);
220static void f_histnr(typval_T *argvars, typval_T *rettv);
221static void f_hlID(typval_T *argvars, typval_T *rettv);
222static void f_hlexists(typval_T *argvars, typval_T *rettv);
223static void f_hostname(typval_T *argvars, typval_T *rettv);
224static void f_iconv(typval_T *argvars, typval_T *rettv);
225static void f_indent(typval_T *argvars, typval_T *rettv);
226static void f_index(typval_T *argvars, typval_T *rettv);
227static void f_input(typval_T *argvars, typval_T *rettv);
228static void f_inputdialog(typval_T *argvars, typval_T *rettv);
229static void f_inputlist(typval_T *argvars, typval_T *rettv);
230static void f_inputrestore(typval_T *argvars, typval_T *rettv);
231static void f_inputsave(typval_T *argvars, typval_T *rettv);
232static void f_inputsecret(typval_T *argvars, typval_T *rettv);
233static void f_insert(typval_T *argvars, typval_T *rettv);
234static void f_invert(typval_T *argvars, typval_T *rettv);
235static void f_isdirectory(typval_T *argvars, typval_T *rettv);
236static void f_islocked(typval_T *argvars, typval_T *rettv);
237#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
238static void f_isnan(typval_T *argvars, typval_T *rettv);
239#endif
240static void f_items(typval_T *argvars, typval_T *rettv);
241#ifdef FEAT_JOB_CHANNEL
242static void f_job_getchannel(typval_T *argvars, typval_T *rettv);
243static void f_job_info(typval_T *argvars, typval_T *rettv);
244static void f_job_setoptions(typval_T *argvars, typval_T *rettv);
245static void f_job_start(typval_T *argvars, typval_T *rettv);
246static void f_job_stop(typval_T *argvars, typval_T *rettv);
247static void f_job_status(typval_T *argvars, typval_T *rettv);
248#endif
249static void f_join(typval_T *argvars, typval_T *rettv);
250static void f_js_decode(typval_T *argvars, typval_T *rettv);
251static void f_js_encode(typval_T *argvars, typval_T *rettv);
252static void f_json_decode(typval_T *argvars, typval_T *rettv);
253static void f_json_encode(typval_T *argvars, typval_T *rettv);
254static void f_keys(typval_T *argvars, typval_T *rettv);
255static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);
256static void f_len(typval_T *argvars, typval_T *rettv);
257static void f_libcall(typval_T *argvars, typval_T *rettv);
258static void f_libcallnr(typval_T *argvars, typval_T *rettv);
259static void f_line(typval_T *argvars, typval_T *rettv);
260static void f_line2byte(typval_T *argvars, typval_T *rettv);
261static void f_lispindent(typval_T *argvars, typval_T *rettv);
262static void f_localtime(typval_T *argvars, typval_T *rettv);
263#ifdef FEAT_FLOAT
264static void f_log(typval_T *argvars, typval_T *rettv);
265static void f_log10(typval_T *argvars, typval_T *rettv);
266#endif
267#ifdef FEAT_LUA
268static void f_luaeval(typval_T *argvars, typval_T *rettv);
269#endif
270static void f_map(typval_T *argvars, typval_T *rettv);
271static void f_maparg(typval_T *argvars, typval_T *rettv);
272static void f_mapcheck(typval_T *argvars, typval_T *rettv);
273static void f_match(typval_T *argvars, typval_T *rettv);
274static void f_matchadd(typval_T *argvars, typval_T *rettv);
275static void f_matchaddpos(typval_T *argvars, typval_T *rettv);
276static void f_matcharg(typval_T *argvars, typval_T *rettv);
277static void f_matchdelete(typval_T *argvars, typval_T *rettv);
278static void f_matchend(typval_T *argvars, typval_T *rettv);
279static void f_matchlist(typval_T *argvars, typval_T *rettv);
280static void f_matchstr(typval_T *argvars, typval_T *rettv);
281static void f_matchstrpos(typval_T *argvars, typval_T *rettv);
282static void f_max(typval_T *argvars, typval_T *rettv);
283static void f_min(typval_T *argvars, typval_T *rettv);
284#ifdef vim_mkdir
285static void f_mkdir(typval_T *argvars, typval_T *rettv);
286#endif
287static void f_mode(typval_T *argvars, typval_T *rettv);
288#ifdef FEAT_MZSCHEME
289static void f_mzeval(typval_T *argvars, typval_T *rettv);
290#endif
291static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
292static void f_nr2char(typval_T *argvars, typval_T *rettv);
293static void f_or(typval_T *argvars, typval_T *rettv);
294static void f_pathshorten(typval_T *argvars, typval_T *rettv);
295#ifdef FEAT_PERL
296static void f_perleval(typval_T *argvars, typval_T *rettv);
297#endif
298#ifdef FEAT_FLOAT
299static void f_pow(typval_T *argvars, typval_T *rettv);
300#endif
301static void f_prevnonblank(typval_T *argvars, typval_T *rettv);
302static void f_printf(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf2732452018-06-03 14:47:35 +0200303#ifdef FEAT_JOB_CHANNEL
304static void f_prompt_setcallback(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0e5979a2018-06-17 19:36:33 +0200305static void f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf2732452018-06-03 14:47:35 +0200306static void f_prompt_setprompt(typval_T *argvars, typval_T *rettv);
307#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200308static void f_pumvisible(typval_T *argvars, typval_T *rettv);
309#ifdef FEAT_PYTHON3
310static void f_py3eval(typval_T *argvars, typval_T *rettv);
311#endif
312#ifdef FEAT_PYTHON
313static void f_pyeval(typval_T *argvars, typval_T *rettv);
314#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100315#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
316static void f_pyxeval(typval_T *argvars, typval_T *rettv);
317#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200318static void f_range(typval_T *argvars, typval_T *rettv);
319static void f_readfile(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200320static void f_reg_executing(typval_T *argvars, typval_T *rettv);
321static void f_reg_recording(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200322static void f_reltime(typval_T *argvars, typval_T *rettv);
323#ifdef FEAT_FLOAT
324static void f_reltimefloat(typval_T *argvars, typval_T *rettv);
325#endif
326static void f_reltimestr(typval_T *argvars, typval_T *rettv);
327static void f_remote_expr(typval_T *argvars, typval_T *rettv);
328static void f_remote_foreground(typval_T *argvars, typval_T *rettv);
329static void f_remote_peek(typval_T *argvars, typval_T *rettv);
330static void f_remote_read(typval_T *argvars, typval_T *rettv);
331static void f_remote_send(typval_T *argvars, typval_T *rettv);
Bram Moolenaar7416f3e2017-03-18 18:10:13 +0100332static void f_remote_startserver(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200333static void f_remove(typval_T *argvars, typval_T *rettv);
334static void f_rename(typval_T *argvars, typval_T *rettv);
335static void f_repeat(typval_T *argvars, typval_T *rettv);
336static void f_resolve(typval_T *argvars, typval_T *rettv);
337static void f_reverse(typval_T *argvars, typval_T *rettv);
338#ifdef FEAT_FLOAT
339static void f_round(typval_T *argvars, typval_T *rettv);
340#endif
341static void f_screenattr(typval_T *argvars, typval_T *rettv);
342static void f_screenchar(typval_T *argvars, typval_T *rettv);
343static void f_screencol(typval_T *argvars, typval_T *rettv);
344static void f_screenrow(typval_T *argvars, typval_T *rettv);
345static void f_search(typval_T *argvars, typval_T *rettv);
346static void f_searchdecl(typval_T *argvars, typval_T *rettv);
347static void f_searchpair(typval_T *argvars, typval_T *rettv);
348static void f_searchpairpos(typval_T *argvars, typval_T *rettv);
349static void f_searchpos(typval_T *argvars, typval_T *rettv);
350static void f_server2client(typval_T *argvars, typval_T *rettv);
351static void f_serverlist(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +0200352static void f_setbufline(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200353static void f_setbufvar(typval_T *argvars, typval_T *rettv);
354static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
355static void f_setcmdpos(typval_T *argvars, typval_T *rettv);
356static void f_setfperm(typval_T *argvars, typval_T *rettv);
357static void f_setline(typval_T *argvars, typval_T *rettv);
358static void f_setloclist(typval_T *argvars, typval_T *rettv);
359static void f_setmatches(typval_T *argvars, typval_T *rettv);
360static void f_setpos(typval_T *argvars, typval_T *rettv);
361static void f_setqflist(typval_T *argvars, typval_T *rettv);
362static void f_setreg(typval_T *argvars, typval_T *rettv);
363static void f_settabvar(typval_T *argvars, typval_T *rettv);
364static void f_settabwinvar(typval_T *argvars, typval_T *rettv);
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100365static void f_settagstack(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200366static void f_setwinvar(typval_T *argvars, typval_T *rettv);
367#ifdef FEAT_CRYPT
368static void f_sha256(typval_T *argvars, typval_T *rettv);
369#endif /* FEAT_CRYPT */
370static void f_shellescape(typval_T *argvars, typval_T *rettv);
371static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
Bram Moolenaar162b7142018-12-21 15:17:36 +0100372#ifdef FEAT_SIGNS
373static void f_sign_define(typval_T *argvars, typval_T *rettv);
374static void f_sign_getdefined(typval_T *argvars, typval_T *rettv);
375static void f_sign_getplaced(typval_T *argvars, typval_T *rettv);
Bram Moolenaar6b7b7192019-01-11 13:42:41 +0100376static void f_sign_jump(typval_T *argvars, typval_T *rettv);
Bram Moolenaar162b7142018-12-21 15:17:36 +0100377static void f_sign_place(typval_T *argvars, typval_T *rettv);
378static void f_sign_undefine(typval_T *argvars, typval_T *rettv);
379static void f_sign_unplace(typval_T *argvars, typval_T *rettv);
380#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200381static void f_simplify(typval_T *argvars, typval_T *rettv);
382#ifdef FEAT_FLOAT
383static void f_sin(typval_T *argvars, typval_T *rettv);
384static void f_sinh(typval_T *argvars, typval_T *rettv);
385#endif
386static void f_sort(typval_T *argvars, typval_T *rettv);
387static void f_soundfold(typval_T *argvars, typval_T *rettv);
388static void f_spellbadword(typval_T *argvars, typval_T *rettv);
389static void f_spellsuggest(typval_T *argvars, typval_T *rettv);
390static void f_split(typval_T *argvars, typval_T *rettv);
391#ifdef FEAT_FLOAT
392static void f_sqrt(typval_T *argvars, typval_T *rettv);
393static void f_str2float(typval_T *argvars, typval_T *rettv);
394#endif
395static void f_str2nr(typval_T *argvars, typval_T *rettv);
396static void f_strchars(typval_T *argvars, typval_T *rettv);
397#ifdef HAVE_STRFTIME
398static void f_strftime(typval_T *argvars, typval_T *rettv);
399#endif
400static void f_strgetchar(typval_T *argvars, typval_T *rettv);
401static void f_stridx(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200402static void f_strlen(typval_T *argvars, typval_T *rettv);
403static void f_strcharpart(typval_T *argvars, typval_T *rettv);
404static void f_strpart(typval_T *argvars, typval_T *rettv);
405static void f_strridx(typval_T *argvars, typval_T *rettv);
406static void f_strtrans(typval_T *argvars, typval_T *rettv);
407static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv);
408static void f_strwidth(typval_T *argvars, typval_T *rettv);
409static void f_submatch(typval_T *argvars, typval_T *rettv);
410static void f_substitute(typval_T *argvars, typval_T *rettv);
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200411static void f_swapinfo(typval_T *argvars, typval_T *rettv);
Bram Moolenaar110bd602018-09-16 18:46:59 +0200412static void f_swapname(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200413static void f_synID(typval_T *argvars, typval_T *rettv);
414static void f_synIDattr(typval_T *argvars, typval_T *rettv);
415static void f_synIDtrans(typval_T *argvars, typval_T *rettv);
416static void f_synstack(typval_T *argvars, typval_T *rettv);
417static void f_synconcealed(typval_T *argvars, typval_T *rettv);
418static void f_system(typval_T *argvars, typval_T *rettv);
419static void f_systemlist(typval_T *argvars, typval_T *rettv);
420static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);
421static void f_tabpagenr(typval_T *argvars, typval_T *rettv);
422static void f_tabpagewinnr(typval_T *argvars, typval_T *rettv);
423static void f_taglist(typval_T *argvars, typval_T *rettv);
424static void f_tagfiles(typval_T *argvars, typval_T *rettv);
425static void f_tempname(typval_T *argvars, typval_T *rettv);
426static void f_test_alloc_fail(typval_T *argvars, typval_T *rettv);
427static void f_test_autochdir(typval_T *argvars, typval_T *rettv);
Bram Moolenaar5e80de32017-09-03 15:48:12 +0200428static void f_test_feedinput(typval_T *argvars, typval_T *rettv);
Bram Moolenaarfe8ef982018-09-13 20:31:54 +0200429static void f_test_option_not_set(typval_T *argvars, typval_T *rettv);
Bram Moolenaareb992cb2017-03-09 18:20:16 +0100430static void f_test_override(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200431static void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv);
Bram Moolenaare0c31f62017-03-01 15:07:05 +0100432static void f_test_ignore_error(typval_T *argvars, typval_T *rettv);
Bram Moolenaarc0f5a782019-01-13 15:16:13 +0100433static void f_test_null_blob(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200434#ifdef FEAT_JOB_CHANNEL
435static void f_test_null_channel(typval_T *argvars, typval_T *rettv);
436#endif
437static void f_test_null_dict(typval_T *argvars, typval_T *rettv);
438#ifdef FEAT_JOB_CHANNEL
439static void f_test_null_job(typval_T *argvars, typval_T *rettv);
440#endif
441static void f_test_null_list(typval_T *argvars, typval_T *rettv);
442static void f_test_null_partial(typval_T *argvars, typval_T *rettv);
443static void f_test_null_string(typval_T *argvars, typval_T *rettv);
Bram Moolenaarab186732018-09-14 21:27:06 +0200444#ifdef FEAT_GUI
445static void f_test_scrollbar(typval_T *argvars, typval_T *rettv);
446#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200447static void f_test_settime(typval_T *argvars, typval_T *rettv);
448#ifdef FEAT_FLOAT
449static void f_tan(typval_T *argvars, typval_T *rettv);
450static void f_tanh(typval_T *argvars, typval_T *rettv);
451#endif
452#ifdef FEAT_TIMERS
Bram Moolenaar8e97bd72016-08-06 22:05:07 +0200453static void f_timer_info(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb73598e2016-08-07 18:22:53 +0200454static void f_timer_pause(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200455static void f_timer_start(typval_T *argvars, typval_T *rettv);
456static void f_timer_stop(typval_T *argvars, typval_T *rettv);
Bram Moolenaarb73598e2016-08-07 18:22:53 +0200457static void f_timer_stopall(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200458#endif
459static void f_tolower(typval_T *argvars, typval_T *rettv);
460static void f_toupper(typval_T *argvars, typval_T *rettv);
461static void f_tr(typval_T *argvars, typval_T *rettv);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +0100462static void f_trim(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200463#ifdef FEAT_FLOAT
464static void f_trunc(typval_T *argvars, typval_T *rettv);
465#endif
466static void f_type(typval_T *argvars, typval_T *rettv);
467static void f_undofile(typval_T *argvars, typval_T *rettv);
468static void f_undotree(typval_T *argvars, typval_T *rettv);
469static void f_uniq(typval_T *argvars, typval_T *rettv);
470static void f_values(typval_T *argvars, typval_T *rettv);
471static void f_virtcol(typval_T *argvars, typval_T *rettv);
472static void f_visualmode(typval_T *argvars, typval_T *rettv);
473static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
474static void f_win_findbuf(typval_T *argvars, typval_T *rettv);
475static void f_win_getid(typval_T *argvars, typval_T *rettv);
476static void f_win_gotoid(typval_T *argvars, typval_T *rettv);
477static void f_win_id2tabwin(typval_T *argvars, typval_T *rettv);
478static void f_win_id2win(typval_T *argvars, typval_T *rettv);
Bram Moolenaar22044dc2017-12-02 15:43:37 +0100479static void f_win_screenpos(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200480static void f_winbufnr(typval_T *argvars, typval_T *rettv);
481static void f_wincol(typval_T *argvars, typval_T *rettv);
482static void f_winheight(typval_T *argvars, typval_T *rettv);
Bram Moolenaar0f6b4f02018-08-21 16:56:34 +0200483static void f_winlayout(typval_T *argvars, typval_T *rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200484static void f_winline(typval_T *argvars, typval_T *rettv);
485static void f_winnr(typval_T *argvars, typval_T *rettv);
486static void f_winrestcmd(typval_T *argvars, typval_T *rettv);
487static void f_winrestview(typval_T *argvars, typval_T *rettv);
488static void f_winsaveview(typval_T *argvars, typval_T *rettv);
489static void f_winwidth(typval_T *argvars, typval_T *rettv);
490static void f_writefile(typval_T *argvars, typval_T *rettv);
491static void f_wordcount(typval_T *argvars, typval_T *rettv);
492static void f_xor(typval_T *argvars, typval_T *rettv);
493
494/*
495 * Array with names and number of arguments of all internal functions
496 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
497 */
498static struct fst
499{
500 char *f_name; /* function name */
501 char f_min_argc; /* minimal number of arguments */
502 char f_max_argc; /* maximal number of arguments */
503 void (*f_func)(typval_T *args, typval_T *rvar);
504 /* implementation of function */
505} functions[] =
506{
507#ifdef FEAT_FLOAT
508 {"abs", 1, 1, f_abs},
509 {"acos", 1, 1, f_acos}, /* WJMc */
510#endif
511 {"add", 2, 2, f_add},
512 {"and", 2, 2, f_and},
513 {"append", 2, 2, f_append},
Bram Moolenaarca851592018-06-06 21:04:07 +0200514 {"appendbufline", 3, 3, f_appendbufline},
Bram Moolenaare6e39892018-10-25 12:32:11 +0200515 {"argc", 0, 1, f_argc},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200516 {"argidx", 0, 0, f_argidx},
517 {"arglistid", 0, 2, f_arglistid},
Bram Moolenaare6e39892018-10-25 12:32:11 +0200518 {"argv", 0, 2, f_argv},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200519#ifdef FEAT_FLOAT
520 {"asin", 1, 1, f_asin}, /* WJMc */
521#endif
Bram Moolenaarb48e96f2018-02-13 12:26:14 +0100522 {"assert_beeps", 1, 2, f_assert_beeps},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200523 {"assert_equal", 2, 3, f_assert_equal},
Bram Moolenaard96ff162018-02-18 22:13:29 +0100524 {"assert_equalfile", 2, 2, f_assert_equalfile},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200525 {"assert_exception", 1, 2, f_assert_exception},
Bram Moolenaar1307d1c2018-10-07 20:16:49 +0200526 {"assert_fails", 1, 3, f_assert_fails},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200527 {"assert_false", 1, 2, f_assert_false},
Bram Moolenaar34215662016-12-04 13:37:41 +0100528 {"assert_inrange", 3, 4, f_assert_inrange},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200529 {"assert_match", 2, 3, f_assert_match},
530 {"assert_notequal", 2, 3, f_assert_notequal},
531 {"assert_notmatch", 2, 3, f_assert_notmatch},
Bram Moolenaar42205552017-03-18 19:42:22 +0100532 {"assert_report", 1, 1, f_assert_report},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200533 {"assert_true", 1, 2, f_assert_true},
534#ifdef FEAT_FLOAT
535 {"atan", 1, 1, f_atan},
536 {"atan2", 2, 2, f_atan2},
537#endif
Bram Moolenaar59716a22017-03-01 20:32:44 +0100538#ifdef FEAT_BEVAL
539 {"balloon_show", 1, 1, f_balloon_show},
Bram Moolenaar669a8282017-11-19 20:13:05 +0100540# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +0100541 {"balloon_split", 1, 1, f_balloon_split},
Bram Moolenaar669a8282017-11-19 20:13:05 +0100542# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +0100543#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200544 {"browse", 4, 4, f_browse},
545 {"browsedir", 2, 2, f_browsedir},
546 {"bufexists", 1, 1, f_bufexists},
547 {"buffer_exists", 1, 1, f_bufexists}, /* obsolete */
548 {"buffer_name", 1, 1, f_bufname}, /* obsolete */
549 {"buffer_number", 1, 1, f_bufnr}, /* obsolete */
550 {"buflisted", 1, 1, f_buflisted},
551 {"bufloaded", 1, 1, f_bufloaded},
552 {"bufname", 1, 1, f_bufname},
553 {"bufnr", 1, 2, f_bufnr},
554 {"bufwinid", 1, 1, f_bufwinid},
555 {"bufwinnr", 1, 1, f_bufwinnr},
556 {"byte2line", 1, 1, f_byte2line},
557 {"byteidx", 2, 2, f_byteidx},
558 {"byteidxcomp", 2, 2, f_byteidxcomp},
559 {"call", 2, 3, f_call},
560#ifdef FEAT_FLOAT
561 {"ceil", 1, 1, f_ceil},
562#endif
563#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar4b785f62016-11-29 21:54:44 +0100564 {"ch_canread", 1, 1, f_ch_canread},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200565 {"ch_close", 1, 1, f_ch_close},
Bram Moolenaar0874a832016-09-01 15:11:51 +0200566 {"ch_close_in", 1, 1, f_ch_close_in},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200567 {"ch_evalexpr", 2, 3, f_ch_evalexpr},
568 {"ch_evalraw", 2, 3, f_ch_evalraw},
569 {"ch_getbufnr", 2, 2, f_ch_getbufnr},
570 {"ch_getjob", 1, 1, f_ch_getjob},
571 {"ch_info", 1, 1, f_ch_info},
572 {"ch_log", 1, 2, f_ch_log},
573 {"ch_logfile", 1, 2, f_ch_logfile},
574 {"ch_open", 1, 2, f_ch_open},
575 {"ch_read", 1, 2, f_ch_read},
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +0100576 {"ch_readblob", 1, 2, f_ch_readblob},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200577 {"ch_readraw", 1, 2, f_ch_readraw},
578 {"ch_sendexpr", 2, 3, f_ch_sendexpr},
579 {"ch_sendraw", 2, 3, f_ch_sendraw},
580 {"ch_setoptions", 2, 2, f_ch_setoptions},
Bram Moolenaar7ef38102016-09-26 22:36:58 +0200581 {"ch_status", 1, 2, f_ch_status},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200582#endif
583 {"changenr", 0, 0, f_changenr},
584 {"char2nr", 1, 2, f_char2nr},
585 {"cindent", 1, 1, f_cindent},
586 {"clearmatches", 0, 0, f_clearmatches},
587 {"col", 1, 1, f_col},
588#if defined(FEAT_INS_EXPAND)
589 {"complete", 2, 2, f_complete},
590 {"complete_add", 1, 1, f_complete_add},
591 {"complete_check", 0, 0, f_complete_check},
592#endif
593 {"confirm", 1, 4, f_confirm},
594 {"copy", 1, 1, f_copy},
595#ifdef FEAT_FLOAT
596 {"cos", 1, 1, f_cos},
597 {"cosh", 1, 1, f_cosh},
598#endif
599 {"count", 2, 4, f_count},
600 {"cscope_connection",0,3, f_cscope_connection},
601 {"cursor", 1, 3, f_cursor},
Bram Moolenaar4f974752019-02-17 17:44:42 +0100602#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +0200603 {"debugbreak", 1, 1, f_debugbreak},
604#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200605 {"deepcopy", 1, 2, f_deepcopy},
606 {"delete", 1, 2, f_delete},
Bram Moolenaard79a2622018-06-07 18:17:46 +0200607 {"deletebufline", 2, 3, f_deletebufline},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200608 {"did_filetype", 0, 0, f_did_filetype},
609 {"diff_filler", 1, 1, f_diff_filler},
610 {"diff_hlID", 2, 2, f_diff_hlID},
611 {"empty", 1, 1, f_empty},
612 {"escape", 2, 2, f_escape},
613 {"eval", 1, 1, f_eval},
614 {"eventhandler", 0, 0, f_eventhandler},
615 {"executable", 1, 1, f_executable},
616 {"execute", 1, 2, f_execute},
617 {"exepath", 1, 1, f_exepath},
618 {"exists", 1, 1, f_exists},
619#ifdef FEAT_FLOAT
620 {"exp", 1, 1, f_exp},
621#endif
622 {"expand", 1, 3, f_expand},
623 {"extend", 2, 3, f_extend},
624 {"feedkeys", 1, 2, f_feedkeys},
625 {"file_readable", 1, 1, f_filereadable}, /* obsolete */
626 {"filereadable", 1, 1, f_filereadable},
627 {"filewritable", 1, 1, f_filewritable},
628 {"filter", 2, 2, f_filter},
629 {"finddir", 1, 3, f_finddir},
630 {"findfile", 1, 3, f_findfile},
631#ifdef FEAT_FLOAT
632 {"float2nr", 1, 1, f_float2nr},
633 {"floor", 1, 1, f_floor},
634 {"fmod", 2, 2, f_fmod},
635#endif
636 {"fnameescape", 1, 1, f_fnameescape},
637 {"fnamemodify", 2, 2, f_fnamemodify},
638 {"foldclosed", 1, 1, f_foldclosed},
639 {"foldclosedend", 1, 1, f_foldclosedend},
640 {"foldlevel", 1, 1, f_foldlevel},
641 {"foldtext", 0, 0, f_foldtext},
642 {"foldtextresult", 1, 1, f_foldtextresult},
643 {"foreground", 0, 0, f_foreground},
Bram Moolenaar437bafe2016-08-01 15:40:54 +0200644 {"funcref", 1, 3, f_funcref},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200645 {"function", 1, 3, f_function},
646 {"garbagecollect", 0, 1, f_garbagecollect},
647 {"get", 2, 3, f_get},
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200648 {"getbufinfo", 0, 1, f_getbufinfo},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200649 {"getbufline", 2, 3, f_getbufline},
650 {"getbufvar", 2, 3, f_getbufvar},
Bram Moolenaar07ad8162018-02-13 13:59:59 +0100651 {"getchangelist", 1, 1, f_getchangelist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200652 {"getchar", 0, 1, f_getchar},
653 {"getcharmod", 0, 0, f_getcharmod},
654 {"getcharsearch", 0, 0, f_getcharsearch},
655 {"getcmdline", 0, 0, f_getcmdline},
656 {"getcmdpos", 0, 0, f_getcmdpos},
657 {"getcmdtype", 0, 0, f_getcmdtype},
658 {"getcmdwintype", 0, 0, f_getcmdwintype},
659#if defined(FEAT_CMDL_COMPL)
Bram Moolenaare9d58a62016-08-13 15:07:41 +0200660 {"getcompletion", 2, 3, f_getcompletion},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200661#endif
662 {"getcurpos", 0, 0, f_getcurpos},
663 {"getcwd", 0, 2, f_getcwd},
664 {"getfontname", 0, 1, f_getfontname},
665 {"getfperm", 1, 1, f_getfperm},
666 {"getfsize", 1, 1, f_getfsize},
667 {"getftime", 1, 1, f_getftime},
668 {"getftype", 1, 1, f_getftype},
Bram Moolenaar4f505882018-02-10 21:06:32 +0100669 {"getjumplist", 0, 2, f_getjumplist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200670 {"getline", 1, 2, f_getline},
Bram Moolenaard823fa92016-08-12 16:29:27 +0200671 {"getloclist", 1, 2, f_getloclist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200672 {"getmatches", 0, 0, f_getmatches},
673 {"getpid", 0, 0, f_getpid},
674 {"getpos", 1, 1, f_getpos},
Bram Moolenaard823fa92016-08-12 16:29:27 +0200675 {"getqflist", 0, 1, f_getqflist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200676 {"getreg", 0, 3, f_getreg},
677 {"getregtype", 0, 1, f_getregtype},
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200678 {"gettabinfo", 0, 1, f_gettabinfo},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200679 {"gettabvar", 2, 3, f_gettabvar},
680 {"gettabwinvar", 3, 4, f_gettabwinvar},
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100681 {"gettagstack", 0, 1, f_gettagstack},
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +0200682 {"getwininfo", 0, 1, f_getwininfo},
Bram Moolenaar3f54fd32018-03-03 21:29:55 +0100683 {"getwinpos", 0, 1, f_getwinpos},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200684 {"getwinposx", 0, 0, f_getwinposx},
685 {"getwinposy", 0, 0, f_getwinposy},
686 {"getwinvar", 2, 3, f_getwinvar},
687 {"glob", 1, 4, f_glob},
688 {"glob2regpat", 1, 1, f_glob2regpat},
689 {"globpath", 2, 5, f_globpath},
690 {"has", 1, 1, f_has},
691 {"has_key", 2, 2, f_has_key},
692 {"haslocaldir", 0, 2, f_haslocaldir},
693 {"hasmapto", 1, 3, f_hasmapto},
694 {"highlightID", 1, 1, f_hlID}, /* obsolete */
695 {"highlight_exists",1, 1, f_hlexists}, /* obsolete */
696 {"histadd", 2, 2, f_histadd},
697 {"histdel", 1, 2, f_histdel},
698 {"histget", 1, 2, f_histget},
699 {"histnr", 1, 1, f_histnr},
700 {"hlID", 1, 1, f_hlID},
701 {"hlexists", 1, 1, f_hlexists},
702 {"hostname", 0, 0, f_hostname},
703 {"iconv", 3, 3, f_iconv},
704 {"indent", 1, 1, f_indent},
705 {"index", 2, 4, f_index},
706 {"input", 1, 3, f_input},
707 {"inputdialog", 1, 3, f_inputdialog},
708 {"inputlist", 1, 1, f_inputlist},
709 {"inputrestore", 0, 0, f_inputrestore},
710 {"inputsave", 0, 0, f_inputsave},
711 {"inputsecret", 1, 2, f_inputsecret},
712 {"insert", 2, 3, f_insert},
713 {"invert", 1, 1, f_invert},
714 {"isdirectory", 1, 1, f_isdirectory},
715 {"islocked", 1, 1, f_islocked},
716#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
717 {"isnan", 1, 1, f_isnan},
718#endif
719 {"items", 1, 1, f_items},
720#ifdef FEAT_JOB_CHANNEL
721 {"job_getchannel", 1, 1, f_job_getchannel},
Bram Moolenaare1fc5152018-04-21 19:49:08 +0200722 {"job_info", 0, 1, f_job_info},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200723 {"job_setoptions", 2, 2, f_job_setoptions},
724 {"job_start", 1, 2, f_job_start},
725 {"job_status", 1, 1, f_job_status},
726 {"job_stop", 1, 2, f_job_stop},
727#endif
728 {"join", 1, 2, f_join},
729 {"js_decode", 1, 1, f_js_decode},
730 {"js_encode", 1, 1, f_js_encode},
731 {"json_decode", 1, 1, f_json_decode},
732 {"json_encode", 1, 1, f_json_encode},
733 {"keys", 1, 1, f_keys},
734 {"last_buffer_nr", 0, 0, f_last_buffer_nr},/* obsolete */
735 {"len", 1, 1, f_len},
736 {"libcall", 3, 3, f_libcall},
737 {"libcallnr", 3, 3, f_libcallnr},
738 {"line", 1, 1, f_line},
739 {"line2byte", 1, 1, f_line2byte},
740 {"lispindent", 1, 1, f_lispindent},
741 {"localtime", 0, 0, f_localtime},
742#ifdef FEAT_FLOAT
743 {"log", 1, 1, f_log},
744 {"log10", 1, 1, f_log10},
745#endif
746#ifdef FEAT_LUA
747 {"luaeval", 1, 2, f_luaeval},
748#endif
749 {"map", 2, 2, f_map},
750 {"maparg", 1, 4, f_maparg},
751 {"mapcheck", 1, 3, f_mapcheck},
752 {"match", 2, 4, f_match},
753 {"matchadd", 2, 5, f_matchadd},
754 {"matchaddpos", 2, 5, f_matchaddpos},
755 {"matcharg", 1, 1, f_matcharg},
756 {"matchdelete", 1, 1, f_matchdelete},
757 {"matchend", 2, 4, f_matchend},
758 {"matchlist", 2, 4, f_matchlist},
759 {"matchstr", 2, 4, f_matchstr},
760 {"matchstrpos", 2, 4, f_matchstrpos},
761 {"max", 1, 1, f_max},
762 {"min", 1, 1, f_min},
763#ifdef vim_mkdir
764 {"mkdir", 1, 3, f_mkdir},
765#endif
766 {"mode", 0, 1, f_mode},
767#ifdef FEAT_MZSCHEME
768 {"mzeval", 1, 1, f_mzeval},
769#endif
770 {"nextnonblank", 1, 1, f_nextnonblank},
771 {"nr2char", 1, 2, f_nr2char},
772 {"or", 2, 2, f_or},
773 {"pathshorten", 1, 1, f_pathshorten},
774#ifdef FEAT_PERL
775 {"perleval", 1, 1, f_perleval},
776#endif
777#ifdef FEAT_FLOAT
778 {"pow", 2, 2, f_pow},
779#endif
780 {"prevnonblank", 1, 1, f_prevnonblank},
Bram Moolenaarc71807d2018-03-03 15:06:52 +0100781 {"printf", 1, 19, f_printf},
Bram Moolenaarf2732452018-06-03 14:47:35 +0200782#ifdef FEAT_JOB_CHANNEL
783 {"prompt_setcallback", 2, 2, f_prompt_setcallback},
Bram Moolenaar0e5979a2018-06-17 19:36:33 +0200784 {"prompt_setinterrupt", 2, 2, f_prompt_setinterrupt},
Bram Moolenaarf2732452018-06-03 14:47:35 +0200785 {"prompt_setprompt", 2, 2, f_prompt_setprompt},
786#endif
Bram Moolenaar98aefe72018-12-13 22:20:09 +0100787#ifdef FEAT_TEXT_PROP
788 {"prop_add", 3, 3, f_prop_add},
789 {"prop_clear", 1, 3, f_prop_clear},
790 {"prop_list", 1, 2, f_prop_list},
Bram Moolenaar0a2f5782019-03-22 13:20:43 +0100791 {"prop_remove", 1, 3, f_prop_remove},
Bram Moolenaar98aefe72018-12-13 22:20:09 +0100792 {"prop_type_add", 2, 2, f_prop_type_add},
793 {"prop_type_change", 2, 2, f_prop_type_change},
794 {"prop_type_delete", 1, 2, f_prop_type_delete},
795 {"prop_type_get", 1, 2, f_prop_type_get},
796 {"prop_type_list", 0, 1, f_prop_type_list},
797#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200798 {"pumvisible", 0, 0, f_pumvisible},
799#ifdef FEAT_PYTHON3
800 {"py3eval", 1, 1, f_py3eval},
801#endif
802#ifdef FEAT_PYTHON
803 {"pyeval", 1, 1, f_pyeval},
804#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100805#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
806 {"pyxeval", 1, 1, f_pyxeval},
807#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200808 {"range", 1, 3, f_range},
809 {"readfile", 1, 3, f_readfile},
Bram Moolenaar0b6d9112018-05-22 20:35:17 +0200810 {"reg_executing", 0, 0, f_reg_executing},
811 {"reg_recording", 0, 0, f_reg_recording},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200812 {"reltime", 0, 2, f_reltime},
813#ifdef FEAT_FLOAT
814 {"reltimefloat", 1, 1, f_reltimefloat},
815#endif
816 {"reltimestr", 1, 1, f_reltimestr},
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +0100817 {"remote_expr", 2, 4, f_remote_expr},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200818 {"remote_foreground", 1, 1, f_remote_foreground},
819 {"remote_peek", 1, 2, f_remote_peek},
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +0100820 {"remote_read", 1, 2, f_remote_read},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200821 {"remote_send", 2, 3, f_remote_send},
Bram Moolenaar7416f3e2017-03-18 18:10:13 +0100822 {"remote_startserver", 1, 1, f_remote_startserver},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200823 {"remove", 2, 3, f_remove},
824 {"rename", 2, 2, f_rename},
825 {"repeat", 2, 2, f_repeat},
826 {"resolve", 1, 1, f_resolve},
827 {"reverse", 1, 1, f_reverse},
828#ifdef FEAT_FLOAT
829 {"round", 1, 1, f_round},
830#endif
831 {"screenattr", 2, 2, f_screenattr},
832 {"screenchar", 2, 2, f_screenchar},
833 {"screencol", 0, 0, f_screencol},
834 {"screenrow", 0, 0, f_screenrow},
835 {"search", 1, 4, f_search},
836 {"searchdecl", 1, 3, f_searchdecl},
837 {"searchpair", 3, 7, f_searchpair},
838 {"searchpairpos", 3, 7, f_searchpairpos},
839 {"searchpos", 1, 4, f_searchpos},
840 {"server2client", 2, 2, f_server2client},
841 {"serverlist", 0, 0, f_serverlist},
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +0200842 {"setbufline", 3, 3, f_setbufline},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200843 {"setbufvar", 3, 3, f_setbufvar},
844 {"setcharsearch", 1, 1, f_setcharsearch},
845 {"setcmdpos", 1, 1, f_setcmdpos},
846 {"setfperm", 2, 2, f_setfperm},
847 {"setline", 2, 2, f_setline},
Bram Moolenaard823fa92016-08-12 16:29:27 +0200848 {"setloclist", 2, 4, f_setloclist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200849 {"setmatches", 1, 1, f_setmatches},
850 {"setpos", 2, 2, f_setpos},
Bram Moolenaard823fa92016-08-12 16:29:27 +0200851 {"setqflist", 1, 3, f_setqflist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200852 {"setreg", 2, 3, f_setreg},
853 {"settabvar", 3, 3, f_settabvar},
854 {"settabwinvar", 4, 4, f_settabwinvar},
Bram Moolenaarf49cc602018-11-11 15:21:05 +0100855 {"settagstack", 2, 3, f_settagstack},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200856 {"setwinvar", 3, 3, f_setwinvar},
857#ifdef FEAT_CRYPT
858 {"sha256", 1, 1, f_sha256},
859#endif
860 {"shellescape", 1, 2, f_shellescape},
Bram Moolenaarf9514162018-11-22 03:08:29 +0100861 {"shiftwidth", 0, 1, f_shiftwidth},
Bram Moolenaar162b7142018-12-21 15:17:36 +0100862#ifdef FEAT_SIGNS
863 {"sign_define", 1, 2, f_sign_define},
864 {"sign_getdefined", 0, 1, f_sign_getdefined},
865 {"sign_getplaced", 0, 2, f_sign_getplaced},
Bram Moolenaar6b7b7192019-01-11 13:42:41 +0100866 {"sign_jump", 3, 3, f_sign_jump},
Bram Moolenaar162b7142018-12-21 15:17:36 +0100867 {"sign_place", 4, 5, f_sign_place},
868 {"sign_undefine", 0, 1, f_sign_undefine},
869 {"sign_unplace", 1, 2, f_sign_unplace},
870#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200871 {"simplify", 1, 1, f_simplify},
872#ifdef FEAT_FLOAT
873 {"sin", 1, 1, f_sin},
874 {"sinh", 1, 1, f_sinh},
875#endif
876 {"sort", 1, 3, f_sort},
877 {"soundfold", 1, 1, f_soundfold},
878 {"spellbadword", 0, 1, f_spellbadword},
879 {"spellsuggest", 1, 3, f_spellsuggest},
880 {"split", 1, 3, f_split},
881#ifdef FEAT_FLOAT
882 {"sqrt", 1, 1, f_sqrt},
883 {"str2float", 1, 1, f_str2float},
884#endif
885 {"str2nr", 1, 2, f_str2nr},
886 {"strcharpart", 2, 3, f_strcharpart},
887 {"strchars", 1, 2, f_strchars},
888 {"strdisplaywidth", 1, 2, f_strdisplaywidth},
889#ifdef HAVE_STRFTIME
890 {"strftime", 1, 2, f_strftime},
891#endif
892 {"strgetchar", 2, 2, f_strgetchar},
893 {"stridx", 2, 3, f_stridx},
894 {"string", 1, 1, f_string},
895 {"strlen", 1, 1, f_strlen},
896 {"strpart", 2, 3, f_strpart},
897 {"strridx", 2, 3, f_strridx},
898 {"strtrans", 1, 1, f_strtrans},
899 {"strwidth", 1, 1, f_strwidth},
900 {"submatch", 1, 2, f_submatch},
901 {"substitute", 4, 4, f_substitute},
Bram Moolenaar00f123a2018-08-21 20:28:54 +0200902 {"swapinfo", 1, 1, f_swapinfo},
Bram Moolenaar110bd602018-09-16 18:46:59 +0200903 {"swapname", 1, 1, f_swapname},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200904 {"synID", 3, 3, f_synID},
905 {"synIDattr", 2, 3, f_synIDattr},
906 {"synIDtrans", 1, 1, f_synIDtrans},
907 {"synconcealed", 2, 2, f_synconcealed},
908 {"synstack", 2, 2, f_synstack},
909 {"system", 1, 2, f_system},
910 {"systemlist", 1, 2, f_systemlist},
911 {"tabpagebuflist", 0, 1, f_tabpagebuflist},
912 {"tabpagenr", 0, 1, f_tabpagenr},
913 {"tabpagewinnr", 1, 2, f_tabpagewinnr},
914 {"tagfiles", 0, 0, f_tagfiles},
Bram Moolenaarc6aafba2017-03-21 17:09:10 +0100915 {"taglist", 1, 2, f_taglist},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200916#ifdef FEAT_FLOAT
917 {"tan", 1, 1, f_tan},
918 {"tanh", 1, 1, f_tanh},
919#endif
920 {"tempname", 0, 0, f_tempname},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200921#ifdef FEAT_TERMINAL
Bram Moolenaard96ff162018-02-18 22:13:29 +0100922 {"term_dumpdiff", 2, 3, f_term_dumpdiff},
923 {"term_dumpload", 1, 2, f_term_dumpload},
Bram Moolenaarcafafb32018-02-22 21:07:09 +0100924 {"term_dumpwrite", 2, 3, f_term_dumpwrite},
Bram Moolenaare41e3b42017-08-11 16:24:50 +0200925 {"term_getaltscreen", 1, 1, f_term_getaltscreen},
Bram Moolenaarf59c6e82018-04-10 15:59:11 +0200926# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
927 {"term_getansicolors", 1, 1, f_term_getansicolors},
928# endif
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200929 {"term_getattr", 2, 2, f_term_getattr},
Bram Moolenaar97870002017-07-30 18:28:38 +0200930 {"term_getcursor", 1, 1, f_term_getcursor},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200931 {"term_getjob", 1, 1, f_term_getjob},
Bram Moolenaar45356542017-08-06 17:53:31 +0200932 {"term_getline", 2, 2, f_term_getline},
Bram Moolenaar82b9ca02017-08-08 23:06:46 +0200933 {"term_getscrolled", 1, 1, f_term_getscrolled},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200934 {"term_getsize", 1, 1, f_term_getsize},
Bram Moolenaarb000e322017-07-30 19:38:21 +0200935 {"term_getstatus", 1, 1, f_term_getstatus},
936 {"term_gettitle", 1, 1, f_term_gettitle},
Bram Moolenaar2dc9d262017-09-08 14:39:30 +0200937 {"term_gettty", 1, 2, f_term_gettty},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200938 {"term_list", 0, 0, f_term_list},
Bram Moolenaar45356542017-08-06 17:53:31 +0200939 {"term_scrape", 2, 2, f_term_scrape},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200940 {"term_sendkeys", 2, 2, f_term_sendkeys},
Bram Moolenaarf59c6e82018-04-10 15:59:11 +0200941# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
942 {"term_setansicolors", 2, 2, f_term_setansicolors},
943# endif
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +0100944 {"term_setkill", 2, 2, f_term_setkill},
Bram Moolenaar4d8bac82018-03-09 21:33:34 +0100945 {"term_setrestore", 2, 2, f_term_setrestore},
Bram Moolenaara42d3632018-04-14 17:05:38 +0200946 {"term_setsize", 3, 3, f_term_setsize},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200947 {"term_start", 1, 2, f_term_start},
Bram Moolenaarf3402b12017-08-06 19:07:08 +0200948 {"term_wait", 1, 2, f_term_wait},
Bram Moolenaarc6df10e2017-07-29 20:15:08 +0200949#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200950 {"test_alloc_fail", 3, 3, f_test_alloc_fail},
951 {"test_autochdir", 0, 0, f_test_autochdir},
Bram Moolenaar5e80de32017-09-03 15:48:12 +0200952 {"test_feedinput", 1, 1, f_test_feedinput},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200953 {"test_garbagecollect_now", 0, 0, f_test_garbagecollect_now},
Bram Moolenaare0c31f62017-03-01 15:07:05 +0100954 {"test_ignore_error", 1, 1, f_test_ignore_error},
Bram Moolenaarc0f5a782019-01-13 15:16:13 +0100955 {"test_null_blob", 0, 0, f_test_null_blob},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200956#ifdef FEAT_JOB_CHANNEL
957 {"test_null_channel", 0, 0, f_test_null_channel},
958#endif
959 {"test_null_dict", 0, 0, f_test_null_dict},
960#ifdef FEAT_JOB_CHANNEL
961 {"test_null_job", 0, 0, f_test_null_job},
962#endif
963 {"test_null_list", 0, 0, f_test_null_list},
964 {"test_null_partial", 0, 0, f_test_null_partial},
965 {"test_null_string", 0, 0, f_test_null_string},
Bram Moolenaarfe8ef982018-09-13 20:31:54 +0200966 {"test_option_not_set", 1, 1, f_test_option_not_set},
Bram Moolenaareb992cb2017-03-09 18:20:16 +0100967 {"test_override", 2, 2, f_test_override},
Bram Moolenaarab186732018-09-14 21:27:06 +0200968#ifdef FEAT_GUI
969 {"test_scrollbar", 3, 3, f_test_scrollbar},
970#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200971 {"test_settime", 1, 1, f_test_settime},
972#ifdef FEAT_TIMERS
Bram Moolenaar8e97bd72016-08-06 22:05:07 +0200973 {"timer_info", 0, 1, f_timer_info},
Bram Moolenaarb73598e2016-08-07 18:22:53 +0200974 {"timer_pause", 2, 2, f_timer_pause},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200975 {"timer_start", 2, 3, f_timer_start},
976 {"timer_stop", 1, 1, f_timer_stop},
Bram Moolenaarb73598e2016-08-07 18:22:53 +0200977 {"timer_stopall", 0, 0, f_timer_stopall},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200978#endif
979 {"tolower", 1, 1, f_tolower},
980 {"toupper", 1, 1, f_toupper},
981 {"tr", 3, 3, f_tr},
Bram Moolenaar295ac5a2018-03-22 23:04:02 +0100982 {"trim", 1, 2, f_trim},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200983#ifdef FEAT_FLOAT
984 {"trunc", 1, 1, f_trunc},
985#endif
986 {"type", 1, 1, f_type},
987 {"undofile", 1, 1, f_undofile},
988 {"undotree", 0, 0, f_undotree},
989 {"uniq", 1, 3, f_uniq},
990 {"values", 1, 1, f_values},
991 {"virtcol", 1, 1, f_virtcol},
992 {"visualmode", 0, 1, f_visualmode},
993 {"wildmenumode", 0, 0, f_wildmenumode},
994 {"win_findbuf", 1, 1, f_win_findbuf},
995 {"win_getid", 0, 2, f_win_getid},
996 {"win_gotoid", 1, 1, f_win_gotoid},
997 {"win_id2tabwin", 1, 1, f_win_id2tabwin},
998 {"win_id2win", 1, 1, f_win_id2win},
Bram Moolenaar22044dc2017-12-02 15:43:37 +0100999 {"win_screenpos", 1, 1, f_win_screenpos},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001000 {"winbufnr", 1, 1, f_winbufnr},
1001 {"wincol", 0, 0, f_wincol},
1002 {"winheight", 1, 1, f_winheight},
Bram Moolenaar0f6b4f02018-08-21 16:56:34 +02001003 {"winlayout", 0, 1, f_winlayout},
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001004 {"winline", 0, 0, f_winline},
1005 {"winnr", 0, 1, f_winnr},
1006 {"winrestcmd", 0, 0, f_winrestcmd},
1007 {"winrestview", 1, 1, f_winrestview},
1008 {"winsaveview", 0, 0, f_winsaveview},
1009 {"winwidth", 1, 1, f_winwidth},
1010 {"wordcount", 0, 0, f_wordcount},
1011 {"writefile", 2, 3, f_writefile},
1012 {"xor", 2, 2, f_xor},
1013};
1014
1015#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
1016
1017/*
1018 * Function given to ExpandGeneric() to obtain the list of internal
1019 * or user defined function names.
1020 */
1021 char_u *
1022get_function_name(expand_T *xp, int idx)
1023{
1024 static int intidx = -1;
1025 char_u *name;
1026
1027 if (idx == 0)
1028 intidx = -1;
1029 if (intidx < 0)
1030 {
1031 name = get_user_func_name(xp, idx);
1032 if (name != NULL)
1033 return name;
1034 }
1035 if (++intidx < (int)(sizeof(functions) / sizeof(struct fst)))
1036 {
1037 STRCPY(IObuff, functions[intidx].f_name);
1038 STRCAT(IObuff, "(");
1039 if (functions[intidx].f_max_argc == 0)
1040 STRCAT(IObuff, ")");
1041 return IObuff;
1042 }
1043
1044 return NULL;
1045}
1046
1047/*
1048 * Function given to ExpandGeneric() to obtain the list of internal or
1049 * user defined variable or function names.
1050 */
1051 char_u *
1052get_expr_name(expand_T *xp, int idx)
1053{
1054 static int intidx = -1;
1055 char_u *name;
1056
1057 if (idx == 0)
1058 intidx = -1;
1059 if (intidx < 0)
1060 {
1061 name = get_function_name(xp, idx);
1062 if (name != NULL)
1063 return name;
1064 }
1065 return get_user_var_name(xp, ++intidx);
1066}
1067
1068#endif /* FEAT_CMDL_COMPL */
1069
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001070/*
1071 * Find internal function in table above.
1072 * Return index, or -1 if not found
1073 */
1074 int
1075find_internal_func(
1076 char_u *name) /* name of the function */
1077{
1078 int first = 0;
1079 int last = (int)(sizeof(functions) / sizeof(struct fst)) - 1;
1080 int cmp;
1081 int x;
1082
1083 /*
1084 * Find the function name in the table. Binary search.
1085 */
1086 while (first <= last)
1087 {
1088 x = first + ((unsigned)(last - first) >> 1);
1089 cmp = STRCMP(name, functions[x].f_name);
1090 if (cmp < 0)
1091 last = x - 1;
1092 else if (cmp > 0)
1093 first = x + 1;
1094 else
1095 return x;
1096 }
1097 return -1;
1098}
1099
1100 int
1101call_internal_func(
1102 char_u *name,
1103 int argcount,
1104 typval_T *argvars,
1105 typval_T *rettv)
1106{
1107 int i;
1108
1109 i = find_internal_func(name);
1110 if (i < 0)
1111 return ERROR_UNKNOWN;
1112 if (argcount < functions[i].f_min_argc)
1113 return ERROR_TOOFEW;
1114 if (argcount > functions[i].f_max_argc)
1115 return ERROR_TOOMANY;
1116 argvars[argcount].v_type = VAR_UNKNOWN;
1117 functions[i].f_func(argvars, rettv);
1118 return ERROR_NONE;
1119}
1120
1121/*
1122 * Return TRUE for a non-zero Number and a non-empty String.
1123 */
1124 static int
1125non_zero_arg(typval_T *argvars)
1126{
1127 return ((argvars[0].v_type == VAR_NUMBER
1128 && argvars[0].vval.v_number != 0)
1129 || (argvars[0].v_type == VAR_SPECIAL
1130 && argvars[0].vval.v_number == VVAL_TRUE)
1131 || (argvars[0].v_type == VAR_STRING
1132 && argvars[0].vval.v_string != NULL
1133 && *argvars[0].vval.v_string != NUL));
1134}
1135
1136/*
1137 * Get the lnum from the first argument.
1138 * Also accepts ".", "$", etc., but that only works for the current buffer.
1139 * Returns -1 on error.
1140 */
1141 static linenr_T
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001142tv_get_lnum(typval_T *argvars)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001143{
1144 typval_T rettv;
1145 linenr_T lnum;
1146
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001147 lnum = (linenr_T)tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001148 if (lnum == 0) /* no valid number, try using line() */
1149 {
1150 rettv.v_type = VAR_NUMBER;
1151 f_line(argvars, &rettv);
1152 lnum = (linenr_T)rettv.vval.v_number;
1153 clear_tv(&rettv);
1154 }
1155 return lnum;
1156}
1157
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001158/*
1159 * Get the lnum from the first argument.
1160 * Also accepts "$", then "buf" is used.
1161 * Returns 0 on error.
1162 */
1163 static linenr_T
1164tv_get_lnum_buf(typval_T *argvars, buf_T *buf)
1165{
1166 if (argvars[0].v_type == VAR_STRING
1167 && argvars[0].vval.v_string != NULL
1168 && argvars[0].vval.v_string[0] == '$'
1169 && buf != NULL)
1170 return buf->b_ml.ml_line_count;
1171 return (linenr_T)tv_get_number_chk(&argvars[0], NULL);
1172}
1173
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001174#ifdef FEAT_FLOAT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001175/*
1176 * Get the float value of "argvars[0]" into "f".
1177 * Returns FAIL when the argument is not a Number or Float.
1178 */
1179 static int
1180get_float_arg(typval_T *argvars, float_T *f)
1181{
1182 if (argvars[0].v_type == VAR_FLOAT)
1183 {
1184 *f = argvars[0].vval.v_float;
1185 return OK;
1186 }
1187 if (argvars[0].v_type == VAR_NUMBER)
1188 {
1189 *f = (float_T)argvars[0].vval.v_number;
1190 return OK;
1191 }
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001192 emsg(_("E808: Number or Float required"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001193 return FAIL;
1194}
1195
1196/*
1197 * "abs(expr)" function
1198 */
1199 static void
1200f_abs(typval_T *argvars, typval_T *rettv)
1201{
1202 if (argvars[0].v_type == VAR_FLOAT)
1203 {
1204 rettv->v_type = VAR_FLOAT;
1205 rettv->vval.v_float = fabs(argvars[0].vval.v_float);
1206 }
1207 else
1208 {
1209 varnumber_T n;
1210 int error = FALSE;
1211
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001212 n = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001213 if (error)
1214 rettv->vval.v_number = -1;
1215 else if (n > 0)
1216 rettv->vval.v_number = n;
1217 else
1218 rettv->vval.v_number = -n;
1219 }
1220}
1221
1222/*
1223 * "acos()" function
1224 */
1225 static void
1226f_acos(typval_T *argvars, typval_T *rettv)
1227{
1228 float_T f = 0.0;
1229
1230 rettv->v_type = VAR_FLOAT;
1231 if (get_float_arg(argvars, &f) == OK)
1232 rettv->vval.v_float = acos(f);
1233 else
1234 rettv->vval.v_float = 0.0;
1235}
1236#endif
1237
1238/*
1239 * "add(list, item)" function
1240 */
1241 static void
1242f_add(typval_T *argvars, typval_T *rettv)
1243{
1244 list_T *l;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001245 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001246
1247 rettv->vval.v_number = 1; /* Default: Failed */
1248 if (argvars[0].v_type == VAR_LIST)
1249 {
1250 if ((l = argvars[0].vval.v_list) != NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +01001251 && !var_check_lock(l->lv_lock,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001252 (char_u *)N_("add() argument"), TRUE)
1253 && list_append_tv(l, &argvars[1]) == OK)
1254 copy_tv(&argvars[0], rettv);
1255 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001256 else if (argvars[0].v_type == VAR_BLOB)
1257 {
1258 if ((b = argvars[0].vval.v_blob) != NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +01001259 && !var_check_lock(b->bv_lock,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001260 (char_u *)N_("add() argument"), TRUE))
1261 {
Bram Moolenaar05500ec2019-01-13 19:10:33 +01001262 int error = FALSE;
1263 varnumber_T n = tv_get_number_chk(&argvars[1], &error);
1264
1265 if (!error)
1266 {
1267 ga_append(&b->bv_ga, (int)n);
1268 copy_tv(&argvars[0], rettv);
1269 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001270 }
1271 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001272 else
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01001273 emsg(_(e_listblobreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001274}
1275
1276/*
1277 * "and(expr, expr)" function
1278 */
1279 static void
1280f_and(typval_T *argvars, typval_T *rettv)
1281{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001282 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
1283 & tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaarca851592018-06-06 21:04:07 +02001284}
1285
1286/*
Bram Moolenaard79a2622018-06-07 18:17:46 +02001287 * If there is a window for "curbuf", make it the current window.
1288 */
1289 static void
1290find_win_for_curbuf(void)
1291{
1292 wininfo_T *wip;
1293
1294 for (wip = curbuf->b_wininfo; wip != NULL; wip = wip->wi_next)
1295 {
1296 if (wip->wi_win != NULL)
1297 {
1298 curwin = wip->wi_win;
1299 break;
1300 }
1301 }
1302}
1303
1304/*
Bram Moolenaarca851592018-06-06 21:04:07 +02001305 * Set line or list of lines in buffer "buf".
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001306 */
1307 static void
Bram Moolenaarca851592018-06-06 21:04:07 +02001308set_buffer_lines(
1309 buf_T *buf,
1310 linenr_T lnum_arg,
1311 int append,
1312 typval_T *lines,
1313 typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001314{
Bram Moolenaarca851592018-06-06 21:04:07 +02001315 linenr_T lnum = lnum_arg + (append ? 1 : 0);
1316 char_u *line = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001317 list_T *l = NULL;
1318 listitem_T *li = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001319 long added = 0;
Bram Moolenaarca851592018-06-06 21:04:07 +02001320 linenr_T append_lnum;
1321 buf_T *curbuf_save = NULL;
1322 win_T *curwin_save = NULL;
1323 int is_curbuf = buf == curbuf;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001324
Bram Moolenaarca851592018-06-06 21:04:07 +02001325 /* When using the current buffer ml_mfp will be set if needed. Useful when
1326 * setline() is used on startup. For other buffers the buffer must be
1327 * loaded. */
1328 if (buf == NULL || (!is_curbuf && buf->b_ml.ml_mfp == NULL) || lnum < 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001329 {
Bram Moolenaarca851592018-06-06 21:04:07 +02001330 rettv->vval.v_number = 1; /* FAIL */
1331 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001332 }
1333
Bram Moolenaarca851592018-06-06 21:04:07 +02001334 if (!is_curbuf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001335 {
Bram Moolenaarca851592018-06-06 21:04:07 +02001336 curbuf_save = curbuf;
1337 curwin_save = curwin;
1338 curbuf = buf;
Bram Moolenaard79a2622018-06-07 18:17:46 +02001339 find_win_for_curbuf();
Bram Moolenaarca851592018-06-06 21:04:07 +02001340 }
1341
1342 if (append)
1343 // appendbufline() uses the line number below which we insert
1344 append_lnum = lnum - 1;
1345 else
1346 // setbufline() uses the line number above which we insert, we only
1347 // append if it's below the last line
1348 append_lnum = curbuf->b_ml.ml_line_count;
1349
1350 if (lines->v_type == VAR_LIST)
1351 {
1352 l = lines->vval.v_list;
1353 li = l->lv_first;
1354 }
1355 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001356 line = tv_get_string_chk(lines);
Bram Moolenaarca851592018-06-06 21:04:07 +02001357
1358 /* default result is zero == OK */
1359 for (;;)
1360 {
1361 if (l != NULL)
1362 {
1363 /* list argument, get next string */
1364 if (li == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001365 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001366 line = tv_get_string_chk(&li->li_tv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001367 li = li->li_next;
1368 }
1369
Bram Moolenaarca851592018-06-06 21:04:07 +02001370 rettv->vval.v_number = 1; /* FAIL */
1371 if (line == NULL || lnum > curbuf->b_ml.ml_line_count + 1)
1372 break;
1373
1374 /* When coming here from Insert mode, sync undo, so that this can be
1375 * undone separately from what was previously inserted. */
1376 if (u_sync_once == 2)
1377 {
1378 u_sync_once = 1; /* notify that u_sync() was called */
1379 u_sync(TRUE);
1380 }
1381
1382 if (!append && lnum <= curbuf->b_ml.ml_line_count)
1383 {
Bram Moolenaar21b50382019-01-04 18:07:24 +01001384 // Existing line, replace it.
1385 // Removes any existing text properties.
1386 if (u_savesub(lnum) == OK && ml_replace_len(
1387 lnum, line, (colnr_T)STRLEN(line) + 1, TRUE, TRUE) == OK)
Bram Moolenaarca851592018-06-06 21:04:07 +02001388 {
1389 changed_bytes(lnum, 0);
1390 if (is_curbuf && lnum == curwin->w_cursor.lnum)
1391 check_cursor_col();
1392 rettv->vval.v_number = 0; /* OK */
1393 }
1394 }
1395 else if (added > 0 || u_save(lnum - 1, lnum) == OK)
1396 {
1397 /* append the line */
1398 ++added;
1399 if (ml_append(lnum - 1, line, (colnr_T)0, FALSE) == OK)
1400 rettv->vval.v_number = 0; /* OK */
1401 }
1402
1403 if (l == NULL) /* only one string argument */
1404 break;
1405 ++lnum;
1406 }
1407
1408 if (added > 0)
1409 {
1410 win_T *wp;
1411 tabpage_T *tp;
1412
1413 appended_lines_mark(append_lnum, added);
1414 FOR_ALL_TAB_WINDOWS(tp, wp)
1415 if (wp->w_buffer == buf && wp->w_cursor.lnum > append_lnum)
1416 wp->w_cursor.lnum += added;
1417 check_cursor_col();
1418
Bram Moolenaarf2732452018-06-03 14:47:35 +02001419#ifdef FEAT_JOB_CHANNEL
1420 if (bt_prompt(curbuf) && (State & INSERT))
1421 // show the line with the prompt
1422 update_topline();
1423#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001424 }
Bram Moolenaarca851592018-06-06 21:04:07 +02001425
1426 if (!is_curbuf)
1427 {
1428 curbuf = curbuf_save;
1429 curwin = curwin_save;
1430 }
1431}
1432
1433/*
1434 * "append(lnum, string/list)" function
1435 */
1436 static void
1437f_append(typval_T *argvars, typval_T *rettv)
1438{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001439 linenr_T lnum = tv_get_lnum(&argvars[0]);
Bram Moolenaarca851592018-06-06 21:04:07 +02001440
1441 set_buffer_lines(curbuf, lnum, TRUE, &argvars[1], rettv);
1442}
1443
1444/*
1445 * "appendbufline(buf, lnum, string/list)" function
1446 */
1447 static void
1448f_appendbufline(typval_T *argvars, typval_T *rettv)
1449{
1450 linenr_T lnum;
1451 buf_T *buf;
1452
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01001453 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaarca851592018-06-06 21:04:07 +02001454 if (buf == NULL)
1455 rettv->vval.v_number = 1; /* FAIL */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001456 else
Bram Moolenaarca851592018-06-06 21:04:07 +02001457 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001458 lnum = tv_get_lnum_buf(&argvars[1], buf);
Bram Moolenaarca851592018-06-06 21:04:07 +02001459 set_buffer_lines(buf, lnum, TRUE, &argvars[2], rettv);
1460 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001461}
1462
1463/*
Bram Moolenaare6e39892018-10-25 12:32:11 +02001464 * "argc([window id])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001465 */
1466 static void
Bram Moolenaare6e39892018-10-25 12:32:11 +02001467f_argc(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001468{
Bram Moolenaare6e39892018-10-25 12:32:11 +02001469 win_T *wp;
1470
1471 if (argvars[0].v_type == VAR_UNKNOWN)
1472 // use the current window
1473 rettv->vval.v_number = ARGCOUNT;
1474 else if (argvars[0].v_type == VAR_NUMBER
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001475 && tv_get_number(&argvars[0]) == -1)
Bram Moolenaare6e39892018-10-25 12:32:11 +02001476 // use the global argument list
1477 rettv->vval.v_number = GARGCOUNT;
1478 else
1479 {
1480 // use the argument list of the specified window
1481 wp = find_win_by_nr_or_id(&argvars[0]);
1482 if (wp != NULL)
1483 rettv->vval.v_number = WARGCOUNT(wp);
1484 else
1485 rettv->vval.v_number = -1;
1486 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001487}
1488
1489/*
1490 * "argidx()" function
1491 */
1492 static void
1493f_argidx(typval_T *argvars UNUSED, typval_T *rettv)
1494{
1495 rettv->vval.v_number = curwin->w_arg_idx;
1496}
1497
1498/*
1499 * "arglistid()" function
1500 */
1501 static void
1502f_arglistid(typval_T *argvars, typval_T *rettv)
1503{
1504 win_T *wp;
1505
1506 rettv->vval.v_number = -1;
1507 wp = find_tabwin(&argvars[0], &argvars[1]);
1508 if (wp != NULL)
1509 rettv->vval.v_number = wp->w_alist->id;
1510}
1511
1512/*
Bram Moolenaare6e39892018-10-25 12:32:11 +02001513 * Get the argument list for a given window
1514 */
1515 static void
1516get_arglist_as_rettv(aentry_T *arglist, int argcount, typval_T *rettv)
1517{
1518 int idx;
1519
1520 if (rettv_list_alloc(rettv) == OK && arglist != NULL)
1521 for (idx = 0; idx < argcount; ++idx)
1522 list_append_string(rettv->vval.v_list,
1523 alist_name(&arglist[idx]), -1);
1524}
1525
1526/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001527 * "argv(nr)" function
1528 */
1529 static void
1530f_argv(typval_T *argvars, typval_T *rettv)
1531{
1532 int idx;
Bram Moolenaare6e39892018-10-25 12:32:11 +02001533 aentry_T *arglist = NULL;
1534 int argcount = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001535
1536 if (argvars[0].v_type != VAR_UNKNOWN)
1537 {
Bram Moolenaare6e39892018-10-25 12:32:11 +02001538 if (argvars[1].v_type == VAR_UNKNOWN)
1539 {
1540 arglist = ARGLIST;
1541 argcount = ARGCOUNT;
1542 }
1543 else if (argvars[1].v_type == VAR_NUMBER
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001544 && tv_get_number(&argvars[1]) == -1)
Bram Moolenaare6e39892018-10-25 12:32:11 +02001545 {
1546 arglist = GARGLIST;
1547 argcount = GARGCOUNT;
1548 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001549 else
Bram Moolenaare6e39892018-10-25 12:32:11 +02001550 {
1551 win_T *wp = find_win_by_nr_or_id(&argvars[1]);
1552
1553 if (wp != NULL)
1554 {
1555 /* Use the argument list of the specified window */
1556 arglist = WARGLIST(wp);
1557 argcount = WARGCOUNT(wp);
1558 }
1559 }
1560
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001561 rettv->v_type = VAR_STRING;
Bram Moolenaare6e39892018-10-25 12:32:11 +02001562 rettv->vval.v_string = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001563 idx = tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaare6e39892018-10-25 12:32:11 +02001564 if (arglist != NULL && idx >= 0 && idx < argcount)
1565 rettv->vval.v_string = vim_strsave(alist_name(&arglist[idx]));
1566 else if (idx == -1)
1567 get_arglist_as_rettv(arglist, argcount, rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001568 }
Bram Moolenaare6e39892018-10-25 12:32:11 +02001569 else
1570 get_arglist_as_rettv(ARGLIST, ARGCOUNT, rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001571}
1572
1573/*
Bram Moolenaarb48e96f2018-02-13 12:26:14 +01001574 * "assert_beeps(cmd [, error])" function
1575 */
1576 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001577f_assert_beeps(typval_T *argvars, typval_T *rettv)
Bram Moolenaarb48e96f2018-02-13 12:26:14 +01001578{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001579 rettv->vval.v_number = assert_beeps(argvars);
Bram Moolenaarb48e96f2018-02-13 12:26:14 +01001580}
1581
1582/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001583 * "assert_equal(expected, actual[, msg])" function
1584 */
1585 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001586f_assert_equal(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001587{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001588 rettv->vval.v_number = assert_equal_common(argvars, ASSERT_EQUAL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001589}
1590
1591/*
Bram Moolenaard96ff162018-02-18 22:13:29 +01001592 * "assert_equalfile(fname-one, fname-two)" function
1593 */
1594 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001595f_assert_equalfile(typval_T *argvars, typval_T *rettv)
Bram Moolenaard96ff162018-02-18 22:13:29 +01001596{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001597 rettv->vval.v_number = assert_equalfile(argvars);
Bram Moolenaard96ff162018-02-18 22:13:29 +01001598}
1599
1600/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001601 * "assert_notequal(expected, actual[, msg])" function
1602 */
1603 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001604f_assert_notequal(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001605{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001606 rettv->vval.v_number = assert_equal_common(argvars, ASSERT_NOTEQUAL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001607}
1608
1609/*
1610 * "assert_exception(string[, msg])" function
1611 */
1612 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001613f_assert_exception(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001614{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001615 rettv->vval.v_number = assert_exception(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001616}
1617
1618/*
Bram Moolenaar1307d1c2018-10-07 20:16:49 +02001619 * "assert_fails(cmd [, error[, msg]])" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001620 */
1621 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001622f_assert_fails(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001623{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001624 rettv->vval.v_number = assert_fails(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001625}
1626
1627/*
1628 * "assert_false(actual[, msg])" function
1629 */
1630 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001631f_assert_false(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001632{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001633 rettv->vval.v_number = assert_bool(argvars, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001634}
1635
1636/*
Bram Moolenaar61c04492016-07-23 15:35:35 +02001637 * "assert_inrange(lower, upper[, msg])" function
1638 */
1639 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001640f_assert_inrange(typval_T *argvars, typval_T *rettv)
Bram Moolenaar61c04492016-07-23 15:35:35 +02001641{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001642 rettv->vval.v_number = assert_inrange(argvars);
Bram Moolenaar61c04492016-07-23 15:35:35 +02001643}
1644
1645/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001646 * "assert_match(pattern, actual[, msg])" function
1647 */
1648 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001649f_assert_match(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001650{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001651 rettv->vval.v_number = assert_match_common(argvars, ASSERT_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001652}
1653
1654/*
1655 * "assert_notmatch(pattern, actual[, msg])" function
1656 */
1657 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001658f_assert_notmatch(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001659{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001660 rettv->vval.v_number = assert_match_common(argvars, ASSERT_NOTMATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001661}
1662
1663/*
Bram Moolenaar42205552017-03-18 19:42:22 +01001664 * "assert_report(msg)" function
1665 */
1666 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001667f_assert_report(typval_T *argvars, typval_T *rettv)
Bram Moolenaar42205552017-03-18 19:42:22 +01001668{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001669 rettv->vval.v_number = assert_report(argvars);
Bram Moolenaar42205552017-03-18 19:42:22 +01001670}
1671
1672/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001673 * "assert_true(actual[, msg])" function
1674 */
1675 static void
Bram Moolenaar65a54642018-04-28 16:56:53 +02001676f_assert_true(typval_T *argvars, typval_T *rettv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001677{
Bram Moolenaar65a54642018-04-28 16:56:53 +02001678 rettv->vval.v_number = assert_bool(argvars, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001679}
1680
1681#ifdef FEAT_FLOAT
1682/*
1683 * "asin()" function
1684 */
1685 static void
1686f_asin(typval_T *argvars, typval_T *rettv)
1687{
1688 float_T f = 0.0;
1689
1690 rettv->v_type = VAR_FLOAT;
1691 if (get_float_arg(argvars, &f) == OK)
1692 rettv->vval.v_float = asin(f);
1693 else
1694 rettv->vval.v_float = 0.0;
1695}
1696
1697/*
1698 * "atan()" function
1699 */
1700 static void
1701f_atan(typval_T *argvars, typval_T *rettv)
1702{
1703 float_T f = 0.0;
1704
1705 rettv->v_type = VAR_FLOAT;
1706 if (get_float_arg(argvars, &f) == OK)
1707 rettv->vval.v_float = atan(f);
1708 else
1709 rettv->vval.v_float = 0.0;
1710}
1711
1712/*
1713 * "atan2()" function
1714 */
1715 static void
1716f_atan2(typval_T *argvars, typval_T *rettv)
1717{
1718 float_T fx = 0.0, fy = 0.0;
1719
1720 rettv->v_type = VAR_FLOAT;
1721 if (get_float_arg(argvars, &fx) == OK
1722 && get_float_arg(&argvars[1], &fy) == OK)
1723 rettv->vval.v_float = atan2(fx, fy);
1724 else
1725 rettv->vval.v_float = 0.0;
1726}
1727#endif
1728
1729/*
Bram Moolenaar59716a22017-03-01 20:32:44 +01001730 * "balloon_show()" function
1731 */
1732#ifdef FEAT_BEVAL
1733 static void
1734f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED)
1735{
Bram Moolenaarcaf64342017-03-02 22:11:33 +01001736 if (balloonEval != NULL)
Bram Moolenaar246fe032017-11-19 19:56:27 +01001737 {
1738 if (argvars[0].v_type == VAR_LIST
1739# ifdef FEAT_GUI
1740 && !gui.in_use
1741# endif
1742 )
1743 post_balloon(balloonEval, NULL, argvars[0].vval.v_list);
1744 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001745 post_balloon(balloonEval, tv_get_string_chk(&argvars[0]), NULL);
Bram Moolenaar246fe032017-11-19 19:56:27 +01001746 }
1747}
1748
Bram Moolenaar669a8282017-11-19 20:13:05 +01001749# if defined(FEAT_BEVAL_TERM)
Bram Moolenaar246fe032017-11-19 19:56:27 +01001750 static void
1751f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED)
1752{
1753 if (rettv_list_alloc(rettv) == OK)
1754 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001755 char_u *msg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar246fe032017-11-19 19:56:27 +01001756
1757 if (msg != NULL)
1758 {
1759 pumitem_T *array;
1760 int size = split_message(msg, &array);
1761 int i;
1762
1763 /* Skip the first and last item, they are always empty. */
1764 for (i = 1; i < size - 1; ++i)
1765 list_append_string(rettv->vval.v_list, array[i].pum_text, -1);
Bram Moolenaarb301f6b2018-02-10 15:38:35 +01001766 while (size > 0)
1767 vim_free(array[--size].pum_text);
Bram Moolenaar246fe032017-11-19 19:56:27 +01001768 vim_free(array);
1769 }
1770 }
Bram Moolenaar59716a22017-03-01 20:32:44 +01001771}
Bram Moolenaar669a8282017-11-19 20:13:05 +01001772# endif
Bram Moolenaar59716a22017-03-01 20:32:44 +01001773#endif
1774
1775/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001776 * "browse(save, title, initdir, default)" function
1777 */
1778 static void
1779f_browse(typval_T *argvars UNUSED, typval_T *rettv)
1780{
1781#ifdef FEAT_BROWSE
1782 int save;
1783 char_u *title;
1784 char_u *initdir;
1785 char_u *defname;
1786 char_u buf[NUMBUFLEN];
1787 char_u buf2[NUMBUFLEN];
1788 int error = FALSE;
1789
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001790 save = (int)tv_get_number_chk(&argvars[0], &error);
1791 title = tv_get_string_chk(&argvars[1]);
1792 initdir = tv_get_string_buf_chk(&argvars[2], buf);
1793 defname = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001794
1795 if (error || title == NULL || initdir == NULL || defname == NULL)
1796 rettv->vval.v_string = NULL;
1797 else
1798 rettv->vval.v_string =
1799 do_browse(save ? BROWSE_SAVE : 0,
1800 title, defname, NULL, initdir, NULL, curbuf);
1801#else
1802 rettv->vval.v_string = NULL;
1803#endif
1804 rettv->v_type = VAR_STRING;
1805}
1806
1807/*
1808 * "browsedir(title, initdir)" function
1809 */
1810 static void
1811f_browsedir(typval_T *argvars UNUSED, typval_T *rettv)
1812{
1813#ifdef FEAT_BROWSE
1814 char_u *title;
1815 char_u *initdir;
1816 char_u buf[NUMBUFLEN];
1817
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001818 title = tv_get_string_chk(&argvars[0]);
1819 initdir = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001820
1821 if (title == NULL || initdir == NULL)
1822 rettv->vval.v_string = NULL;
1823 else
1824 rettv->vval.v_string = do_browse(BROWSE_DIR,
1825 title, NULL, NULL, initdir, NULL, curbuf);
1826#else
1827 rettv->vval.v_string = NULL;
1828#endif
1829 rettv->v_type = VAR_STRING;
1830}
1831
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001832/*
1833 * Find a buffer by number or exact name.
1834 */
1835 static buf_T *
1836find_buffer(typval_T *avar)
1837{
1838 buf_T *buf = NULL;
1839
1840 if (avar->v_type == VAR_NUMBER)
1841 buf = buflist_findnr((int)avar->vval.v_number);
1842 else if (avar->v_type == VAR_STRING && avar->vval.v_string != NULL)
1843 {
1844 buf = buflist_findname_exp(avar->vval.v_string);
1845 if (buf == NULL)
1846 {
1847 /* No full path name match, try a match with a URL or a "nofile"
1848 * buffer, these don't use the full path. */
Bram Moolenaar29323592016-07-24 22:04:11 +02001849 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001850 if (buf->b_fname != NULL
1851 && (path_with_url(buf->b_fname)
1852#ifdef FEAT_QUICKFIX
1853 || bt_nofile(buf)
1854#endif
1855 )
1856 && STRCMP(buf->b_fname, avar->vval.v_string) == 0)
1857 break;
1858 }
1859 }
1860 return buf;
1861}
1862
1863/*
1864 * "bufexists(expr)" function
1865 */
1866 static void
1867f_bufexists(typval_T *argvars, typval_T *rettv)
1868{
1869 rettv->vval.v_number = (find_buffer(&argvars[0]) != NULL);
1870}
1871
1872/*
1873 * "buflisted(expr)" function
1874 */
1875 static void
1876f_buflisted(typval_T *argvars, typval_T *rettv)
1877{
1878 buf_T *buf;
1879
1880 buf = find_buffer(&argvars[0]);
1881 rettv->vval.v_number = (buf != NULL && buf->b_p_bl);
1882}
1883
1884/*
1885 * "bufloaded(expr)" function
1886 */
1887 static void
1888f_bufloaded(typval_T *argvars, typval_T *rettv)
1889{
1890 buf_T *buf;
1891
1892 buf = find_buffer(&argvars[0]);
1893 rettv->vval.v_number = (buf != NULL && buf->b_ml.ml_mfp != NULL);
1894}
1895
1896 buf_T *
1897buflist_find_by_name(char_u *name, int curtab_only)
1898{
1899 int save_magic;
1900 char_u *save_cpo;
1901 buf_T *buf;
1902
1903 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
1904 save_magic = p_magic;
1905 p_magic = TRUE;
1906 save_cpo = p_cpo;
1907 p_cpo = (char_u *)"";
1908
1909 buf = buflist_findnr(buflist_findpat(name, name + STRLEN(name),
1910 TRUE, FALSE, curtab_only));
1911
1912 p_magic = save_magic;
1913 p_cpo = save_cpo;
1914 return buf;
1915}
1916
1917/*
1918 * Get buffer by number or pattern.
1919 */
Bram Moolenaarc6df10e2017-07-29 20:15:08 +02001920 buf_T *
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01001921tv_get_buf(typval_T *tv, int curtab_only)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001922{
1923 char_u *name = tv->vval.v_string;
1924 buf_T *buf;
1925
1926 if (tv->v_type == VAR_NUMBER)
1927 return buflist_findnr((int)tv->vval.v_number);
1928 if (tv->v_type != VAR_STRING)
1929 return NULL;
1930 if (name == NULL || *name == NUL)
1931 return curbuf;
1932 if (name[0] == '$' && name[1] == NUL)
1933 return lastbuf;
1934
1935 buf = buflist_find_by_name(name, curtab_only);
1936
1937 /* If not found, try expanding the name, like done for bufexists(). */
1938 if (buf == NULL)
1939 buf = find_buffer(tv);
1940
1941 return buf;
1942}
1943
Bram Moolenaarec9d3002019-01-12 13:50:31 +01001944#ifdef FEAT_SIGNS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001945/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01001946 * Get the buffer from "arg" and give an error and return NULL if it is not
1947 * valid.
1948 */
1949 static buf_T *
1950get_buf_arg(typval_T *arg)
1951{
1952 buf_T *buf;
1953
1954 ++emsg_off;
1955 buf = tv_get_buf(arg, FALSE);
1956 --emsg_off;
1957 if (buf == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001958 semsg(_("E158: Invalid buffer name: %s"), tv_get_string(arg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01001959 return buf;
1960}
Bram Moolenaarec9d3002019-01-12 13:50:31 +01001961#endif
Bram Moolenaar6b7b7192019-01-11 13:42:41 +01001962
1963/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001964 * "bufname(expr)" function
1965 */
1966 static void
1967f_bufname(typval_T *argvars, typval_T *rettv)
1968{
1969 buf_T *buf;
1970
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001971 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001972 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01001973 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001974 rettv->v_type = VAR_STRING;
1975 if (buf != NULL && buf->b_fname != NULL)
1976 rettv->vval.v_string = vim_strsave(buf->b_fname);
1977 else
1978 rettv->vval.v_string = NULL;
1979 --emsg_off;
1980}
1981
1982/*
1983 * "bufnr(expr)" function
1984 */
1985 static void
1986f_bufnr(typval_T *argvars, typval_T *rettv)
1987{
1988 buf_T *buf;
1989 int error = FALSE;
1990 char_u *name;
1991
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001992 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001993 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01001994 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02001995 --emsg_off;
1996
1997 /* If the buffer isn't found and the second argument is not zero create a
1998 * new buffer. */
1999 if (buf == NULL
2000 && argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002001 && tv_get_number_chk(&argvars[1], &error) != 0
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002002 && !error
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002003 && (name = tv_get_string_chk(&argvars[0])) != NULL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002004 && !error)
2005 buf = buflist_new(name, NULL, (linenr_T)1, 0);
2006
2007 if (buf != NULL)
2008 rettv->vval.v_number = buf->b_fnum;
2009 else
2010 rettv->vval.v_number = -1;
2011}
2012
2013 static void
2014buf_win_common(typval_T *argvars, typval_T *rettv, int get_nr)
2015{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002016 win_T *wp;
2017 int winnr = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002018 buf_T *buf;
2019
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002020 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002021 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01002022 buf = tv_get_buf(&argvars[0], TRUE);
Bram Moolenaar29323592016-07-24 22:04:11 +02002023 FOR_ALL_WINDOWS(wp)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002024 {
2025 ++winnr;
2026 if (wp->w_buffer == buf)
2027 break;
2028 }
2029 rettv->vval.v_number = (wp != NULL ? (get_nr ? winnr : wp->w_id) : -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002030 --emsg_off;
2031}
2032
2033/*
2034 * "bufwinid(nr)" function
2035 */
2036 static void
2037f_bufwinid(typval_T *argvars, typval_T *rettv)
2038{
2039 buf_win_common(argvars, rettv, FALSE);
2040}
2041
2042/*
2043 * "bufwinnr(nr)" function
2044 */
2045 static void
2046f_bufwinnr(typval_T *argvars, typval_T *rettv)
2047{
2048 buf_win_common(argvars, rettv, TRUE);
2049}
2050
2051/*
2052 * "byte2line(byte)" function
2053 */
2054 static void
2055f_byte2line(typval_T *argvars UNUSED, typval_T *rettv)
2056{
2057#ifndef FEAT_BYTEOFF
2058 rettv->vval.v_number = -1;
2059#else
2060 long boff = 0;
2061
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002062 boff = tv_get_number(&argvars[0]) - 1; /* boff gets -1 on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002063 if (boff < 0)
2064 rettv->vval.v_number = -1;
2065 else
2066 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
2067 (linenr_T)0, &boff);
2068#endif
2069}
2070
2071 static void
2072byteidx(typval_T *argvars, typval_T *rettv, int comp UNUSED)
2073{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002074 char_u *t;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002075 char_u *str;
2076 varnumber_T idx;
2077
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002078 str = tv_get_string_chk(&argvars[0]);
2079 idx = tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002080 rettv->vval.v_number = -1;
2081 if (str == NULL || idx < 0)
2082 return;
2083
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002084 t = str;
2085 for ( ; idx > 0; idx--)
2086 {
2087 if (*t == NUL) /* EOL reached */
2088 return;
2089 if (enc_utf8 && comp)
2090 t += utf_ptr2len(t);
2091 else
2092 t += (*mb_ptr2len)(t);
2093 }
2094 rettv->vval.v_number = (varnumber_T)(t - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002095}
2096
2097/*
2098 * "byteidx()" function
2099 */
2100 static void
2101f_byteidx(typval_T *argvars, typval_T *rettv)
2102{
2103 byteidx(argvars, rettv, FALSE);
2104}
2105
2106/*
2107 * "byteidxcomp()" function
2108 */
2109 static void
2110f_byteidxcomp(typval_T *argvars, typval_T *rettv)
2111{
2112 byteidx(argvars, rettv, TRUE);
2113}
2114
2115/*
2116 * "call(func, arglist [, dict])" function
2117 */
2118 static void
2119f_call(typval_T *argvars, typval_T *rettv)
2120{
2121 char_u *func;
2122 partial_T *partial = NULL;
2123 dict_T *selfdict = NULL;
2124
2125 if (argvars[1].v_type != VAR_LIST)
2126 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002127 emsg(_(e_listreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002128 return;
2129 }
2130 if (argvars[1].vval.v_list == NULL)
2131 return;
2132
2133 if (argvars[0].v_type == VAR_FUNC)
2134 func = argvars[0].vval.v_string;
2135 else if (argvars[0].v_type == VAR_PARTIAL)
2136 {
2137 partial = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02002138 func = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002139 }
2140 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002141 func = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002142 if (*func == NUL)
2143 return; /* type error or empty name */
2144
2145 if (argvars[2].v_type != VAR_UNKNOWN)
2146 {
2147 if (argvars[2].v_type != VAR_DICT)
2148 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002149 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002150 return;
2151 }
2152 selfdict = argvars[2].vval.v_dict;
2153 }
2154
2155 (void)func_call(func, &argvars[1], partial, selfdict, rettv);
2156}
2157
2158#ifdef FEAT_FLOAT
2159/*
2160 * "ceil({float})" function
2161 */
2162 static void
2163f_ceil(typval_T *argvars, typval_T *rettv)
2164{
2165 float_T f = 0.0;
2166
2167 rettv->v_type = VAR_FLOAT;
2168 if (get_float_arg(argvars, &f) == OK)
2169 rettv->vval.v_float = ceil(f);
2170 else
2171 rettv->vval.v_float = 0.0;
2172}
2173#endif
2174
2175#ifdef FEAT_JOB_CHANNEL
2176/*
Bram Moolenaar4b785f62016-11-29 21:54:44 +01002177 * "ch_canread()" function
2178 */
2179 static void
2180f_ch_canread(typval_T *argvars, typval_T *rettv)
2181{
Bram Moolenaar958dc692016-12-01 15:34:12 +01002182 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
Bram Moolenaar4b785f62016-11-29 21:54:44 +01002183
2184 rettv->vval.v_number = 0;
2185 if (channel != NULL)
2186 rettv->vval.v_number = channel_has_readahead(channel, PART_SOCK)
2187 || channel_has_readahead(channel, PART_OUT)
2188 || channel_has_readahead(channel, PART_ERR);
2189}
2190
2191/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002192 * "ch_close()" function
2193 */
2194 static void
2195f_ch_close(typval_T *argvars, typval_T *rettv UNUSED)
2196{
2197 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
2198
2199 if (channel != NULL)
2200 {
2201 channel_close(channel, FALSE);
2202 channel_clear(channel);
2203 }
2204}
2205
2206/*
Bram Moolenaar0874a832016-09-01 15:11:51 +02002207 * "ch_close()" function
2208 */
2209 static void
2210f_ch_close_in(typval_T *argvars, typval_T *rettv UNUSED)
2211{
2212 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
2213
2214 if (channel != NULL)
2215 channel_close_in(channel);
2216}
2217
2218/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002219 * "ch_getbufnr()" function
2220 */
2221 static void
2222f_ch_getbufnr(typval_T *argvars, typval_T *rettv)
2223{
2224 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
2225
2226 rettv->vval.v_number = -1;
2227 if (channel != NULL)
2228 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002229 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002230 int part;
2231
2232 if (STRCMP(what, "err") == 0)
2233 part = PART_ERR;
2234 else if (STRCMP(what, "out") == 0)
2235 part = PART_OUT;
2236 else if (STRCMP(what, "in") == 0)
2237 part = PART_IN;
2238 else
2239 part = PART_SOCK;
2240 if (channel->ch_part[part].ch_bufref.br_buf != NULL)
2241 rettv->vval.v_number =
2242 channel->ch_part[part].ch_bufref.br_buf->b_fnum;
2243 }
2244}
2245
2246/*
2247 * "ch_getjob()" function
2248 */
2249 static void
2250f_ch_getjob(typval_T *argvars, typval_T *rettv)
2251{
2252 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
2253
2254 if (channel != NULL)
2255 {
2256 rettv->v_type = VAR_JOB;
2257 rettv->vval.v_job = channel->ch_job;
2258 if (channel->ch_job != NULL)
2259 ++channel->ch_job->jv_refcount;
2260 }
2261}
2262
2263/*
2264 * "ch_info()" function
2265 */
2266 static void
2267f_ch_info(typval_T *argvars, typval_T *rettv UNUSED)
2268{
2269 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
2270
2271 if (channel != NULL && rettv_dict_alloc(rettv) != FAIL)
2272 channel_info(channel, rettv->vval.v_dict);
2273}
2274
2275/*
2276 * "ch_log()" function
2277 */
2278 static void
2279f_ch_log(typval_T *argvars, typval_T *rettv UNUSED)
2280{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002281 char_u *msg = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002282 channel_T *channel = NULL;
2283
2284 if (argvars[1].v_type != VAR_UNKNOWN)
2285 channel = get_channel_arg(&argvars[1], FALSE, FALSE, 0);
2286
Bram Moolenaard5359b22018-04-05 22:44:39 +02002287 ch_log(channel, "%s", msg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002288}
2289
2290/*
2291 * "ch_logfile()" function
2292 */
2293 static void
2294f_ch_logfile(typval_T *argvars, typval_T *rettv UNUSED)
2295{
2296 char_u *fname;
2297 char_u *opt = (char_u *)"";
2298 char_u buf[NUMBUFLEN];
2299
Bram Moolenaar6d87e9e2017-08-07 20:51:51 +02002300 /* Don't open a file in restricted mode. */
2301 if (check_restricted() || check_secure())
2302 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002303 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002304 if (argvars[1].v_type == VAR_STRING)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002305 opt = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002306 ch_logfile(fname, opt);
2307}
2308
2309/*
2310 * "ch_open()" function
2311 */
2312 static void
2313f_ch_open(typval_T *argvars, typval_T *rettv)
2314{
2315 rettv->v_type = VAR_CHANNEL;
2316 if (check_restricted() || check_secure())
2317 return;
2318 rettv->vval.v_channel = channel_open_func(argvars);
2319}
2320
2321/*
2322 * "ch_read()" function
2323 */
2324 static void
2325f_ch_read(typval_T *argvars, typval_T *rettv)
2326{
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002327 common_channel_read(argvars, rettv, FALSE, FALSE);
2328}
2329
2330/*
2331 * "ch_readblob()" function
2332 */
2333 static void
2334f_ch_readblob(typval_T *argvars, typval_T *rettv)
2335{
2336 common_channel_read(argvars, rettv, TRUE, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002337}
2338
2339/*
2340 * "ch_readraw()" function
2341 */
2342 static void
2343f_ch_readraw(typval_T *argvars, typval_T *rettv)
2344{
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002345 common_channel_read(argvars, rettv, TRUE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002346}
2347
2348/*
2349 * "ch_evalexpr()" function
2350 */
2351 static void
2352f_ch_evalexpr(typval_T *argvars, typval_T *rettv)
2353{
2354 ch_expr_common(argvars, rettv, TRUE);
2355}
2356
2357/*
2358 * "ch_sendexpr()" function
2359 */
2360 static void
2361f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
2362{
2363 ch_expr_common(argvars, rettv, FALSE);
2364}
2365
2366/*
2367 * "ch_evalraw()" function
2368 */
2369 static void
2370f_ch_evalraw(typval_T *argvars, typval_T *rettv)
2371{
2372 ch_raw_common(argvars, rettv, TRUE);
2373}
2374
2375/*
2376 * "ch_sendraw()" function
2377 */
2378 static void
2379f_ch_sendraw(typval_T *argvars, typval_T *rettv)
2380{
2381 ch_raw_common(argvars, rettv, FALSE);
2382}
2383
2384/*
2385 * "ch_setoptions()" function
2386 */
2387 static void
2388f_ch_setoptions(typval_T *argvars, typval_T *rettv UNUSED)
2389{
2390 channel_T *channel;
2391 jobopt_T opt;
2392
2393 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
2394 if (channel == NULL)
2395 return;
2396 clear_job_options(&opt);
2397 if (get_job_options(&argvars[1], &opt,
Bram Moolenaar08d384f2017-08-11 21:51:23 +02002398 JO_CB_ALL + JO_TIMEOUT_ALL + JO_MODE_ALL, 0) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002399 channel_set_options(channel, &opt);
2400 free_job_options(&opt);
2401}
2402
2403/*
2404 * "ch_status()" function
2405 */
2406 static void
2407f_ch_status(typval_T *argvars, typval_T *rettv)
2408{
2409 channel_T *channel;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02002410 jobopt_T opt;
2411 int part = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002412
2413 /* return an empty string by default */
2414 rettv->v_type = VAR_STRING;
2415 rettv->vval.v_string = NULL;
2416
2417 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
Bram Moolenaar7ef38102016-09-26 22:36:58 +02002418
2419 if (argvars[1].v_type != VAR_UNKNOWN)
2420 {
2421 clear_job_options(&opt);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02002422 if (get_job_options(&argvars[1], &opt, JO_PART, 0) == OK
Bram Moolenaar7ef38102016-09-26 22:36:58 +02002423 && (opt.jo_set & JO_PART))
2424 part = opt.jo_part;
2425 }
2426
2427 rettv->vval.v_string = vim_strsave((char_u *)channel_status(channel, part));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002428}
2429#endif
2430
2431/*
2432 * "changenr()" function
2433 */
2434 static void
2435f_changenr(typval_T *argvars UNUSED, typval_T *rettv)
2436{
2437 rettv->vval.v_number = curbuf->b_u_seq_cur;
2438}
2439
2440/*
2441 * "char2nr(string)" function
2442 */
2443 static void
2444f_char2nr(typval_T *argvars, typval_T *rettv)
2445{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002446 if (has_mbyte)
2447 {
2448 int utf8 = 0;
2449
2450 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002451 utf8 = (int)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002452
2453 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01002454 rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002455 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002456 rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002457 }
2458 else
Bram Moolenaar13505972019-01-24 15:04:48 +01002459 rettv->vval.v_number = tv_get_string(&argvars[0])[0];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002460}
2461
2462/*
2463 * "cindent(lnum)" function
2464 */
2465 static void
2466f_cindent(typval_T *argvars UNUSED, typval_T *rettv)
2467{
2468#ifdef FEAT_CINDENT
2469 pos_T pos;
2470 linenr_T lnum;
2471
2472 pos = curwin->w_cursor;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002473 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002474 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
2475 {
2476 curwin->w_cursor.lnum = lnum;
2477 rettv->vval.v_number = get_c_indent();
2478 curwin->w_cursor = pos;
2479 }
2480 else
2481#endif
2482 rettv->vval.v_number = -1;
2483}
2484
2485/*
2486 * "clearmatches()" function
2487 */
2488 static void
2489f_clearmatches(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2490{
2491#ifdef FEAT_SEARCH_EXTRA
2492 clear_matches(curwin);
2493#endif
2494}
2495
2496/*
2497 * "col(string)" function
2498 */
2499 static void
2500f_col(typval_T *argvars, typval_T *rettv)
2501{
2502 colnr_T col = 0;
2503 pos_T *fp;
2504 int fnum = curbuf->b_fnum;
2505
2506 fp = var2fpos(&argvars[0], FALSE, &fnum);
2507 if (fp != NULL && fnum == curbuf->b_fnum)
2508 {
2509 if (fp->col == MAXCOL)
2510 {
2511 /* '> can be MAXCOL, get the length of the line then */
2512 if (fp->lnum <= curbuf->b_ml.ml_line_count)
2513 col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1;
2514 else
2515 col = MAXCOL;
2516 }
2517 else
2518 {
2519 col = fp->col + 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002520 /* col(".") when the cursor is on the NUL at the end of the line
2521 * because of "coladd" can be seen as an extra column. */
2522 if (virtual_active() && fp == &curwin->w_cursor)
2523 {
2524 char_u *p = ml_get_cursor();
2525
2526 if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p,
2527 curwin->w_virtcol - curwin->w_cursor.coladd))
2528 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002529 int l;
2530
2531 if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL)
2532 col += l;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002533 }
2534 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002535 }
2536 }
2537 rettv->vval.v_number = col;
2538}
2539
2540#if defined(FEAT_INS_EXPAND)
2541/*
2542 * "complete()" function
2543 */
2544 static void
2545f_complete(typval_T *argvars, typval_T *rettv UNUSED)
2546{
2547 int startcol;
2548
2549 if ((State & INSERT) == 0)
2550 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002551 emsg(_("E785: complete() can only be used in Insert mode"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002552 return;
2553 }
2554
2555 /* Check for undo allowed here, because if something was already inserted
2556 * the line was already saved for undo and this check isn't done. */
2557 if (!undo_allowed())
2558 return;
2559
2560 if (argvars[1].v_type != VAR_LIST || argvars[1].vval.v_list == NULL)
2561 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002562 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002563 return;
2564 }
2565
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002566 startcol = (int)tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002567 if (startcol <= 0)
2568 return;
2569
2570 set_completion(startcol - 1, argvars[1].vval.v_list);
2571}
2572
2573/*
2574 * "complete_add()" function
2575 */
2576 static void
2577f_complete_add(typval_T *argvars, typval_T *rettv)
2578{
2579 rettv->vval.v_number = ins_compl_add_tv(&argvars[0], 0);
2580}
2581
2582/*
2583 * "complete_check()" function
2584 */
2585 static void
2586f_complete_check(typval_T *argvars UNUSED, typval_T *rettv)
2587{
2588 int saved = RedrawingDisabled;
2589
2590 RedrawingDisabled = 0;
Bram Moolenaar472e8592016-10-15 17:06:47 +02002591 ins_compl_check_keys(0, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002592 rettv->vval.v_number = compl_interrupted;
2593 RedrawingDisabled = saved;
2594}
2595#endif
2596
2597/*
2598 * "confirm(message, buttons[, default [, type]])" function
2599 */
2600 static void
2601f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2602{
2603#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2604 char_u *message;
2605 char_u *buttons = NULL;
2606 char_u buf[NUMBUFLEN];
2607 char_u buf2[NUMBUFLEN];
2608 int def = 1;
2609 int type = VIM_GENERIC;
2610 char_u *typestr;
2611 int error = FALSE;
2612
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002613 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002614 if (message == NULL)
2615 error = TRUE;
2616 if (argvars[1].v_type != VAR_UNKNOWN)
2617 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002618 buttons = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002619 if (buttons == NULL)
2620 error = TRUE;
2621 if (argvars[2].v_type != VAR_UNKNOWN)
2622 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002623 def = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002624 if (argvars[3].v_type != VAR_UNKNOWN)
2625 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002626 typestr = tv_get_string_buf_chk(&argvars[3], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002627 if (typestr == NULL)
2628 error = TRUE;
2629 else
2630 {
2631 switch (TOUPPER_ASC(*typestr))
2632 {
2633 case 'E': type = VIM_ERROR; break;
2634 case 'Q': type = VIM_QUESTION; break;
2635 case 'I': type = VIM_INFO; break;
2636 case 'W': type = VIM_WARNING; break;
2637 case 'G': type = VIM_GENERIC; break;
2638 }
2639 }
2640 }
2641 }
2642 }
2643
2644 if (buttons == NULL || *buttons == NUL)
2645 buttons = (char_u *)_("&Ok");
2646
2647 if (!error)
2648 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
2649 def, NULL, FALSE);
2650#endif
2651}
2652
2653/*
2654 * "copy()" function
2655 */
2656 static void
2657f_copy(typval_T *argvars, typval_T *rettv)
2658{
2659 item_copy(&argvars[0], rettv, FALSE, 0);
2660}
2661
2662#ifdef FEAT_FLOAT
2663/*
2664 * "cos()" function
2665 */
2666 static void
2667f_cos(typval_T *argvars, typval_T *rettv)
2668{
2669 float_T f = 0.0;
2670
2671 rettv->v_type = VAR_FLOAT;
2672 if (get_float_arg(argvars, &f) == OK)
2673 rettv->vval.v_float = cos(f);
2674 else
2675 rettv->vval.v_float = 0.0;
2676}
2677
2678/*
2679 * "cosh()" function
2680 */
2681 static void
2682f_cosh(typval_T *argvars, typval_T *rettv)
2683{
2684 float_T f = 0.0;
2685
2686 rettv->v_type = VAR_FLOAT;
2687 if (get_float_arg(argvars, &f) == OK)
2688 rettv->vval.v_float = cosh(f);
2689 else
2690 rettv->vval.v_float = 0.0;
2691}
2692#endif
2693
2694/*
2695 * "count()" function
2696 */
2697 static void
2698f_count(typval_T *argvars, typval_T *rettv)
2699{
2700 long n = 0;
2701 int ic = FALSE;
Bram Moolenaar9966b212017-07-28 16:46:57 +02002702 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002703
Bram Moolenaar9966b212017-07-28 16:46:57 +02002704 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002705 ic = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar9966b212017-07-28 16:46:57 +02002706
2707 if (argvars[0].v_type == VAR_STRING)
2708 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002709 char_u *expr = tv_get_string_chk(&argvars[1]);
Bram Moolenaar9966b212017-07-28 16:46:57 +02002710 char_u *p = argvars[0].vval.v_string;
2711 char_u *next;
2712
Bram Moolenaar338e47f2017-12-19 11:55:26 +01002713 if (!error && expr != NULL && *expr != NUL && p != NULL)
Bram Moolenaar9966b212017-07-28 16:46:57 +02002714 {
2715 if (ic)
2716 {
2717 size_t len = STRLEN(expr);
2718
2719 while (*p != NUL)
2720 {
2721 if (MB_STRNICMP(p, expr, len) == 0)
2722 {
2723 ++n;
2724 p += len;
2725 }
2726 else
2727 MB_PTR_ADV(p);
2728 }
2729 }
2730 else
2731 while ((next = (char_u *)strstr((char *)p, (char *)expr))
2732 != NULL)
2733 {
2734 ++n;
2735 p = next + STRLEN(expr);
2736 }
2737 }
2738
2739 }
2740 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002741 {
2742 listitem_T *li;
2743 list_T *l;
2744 long idx;
2745
2746 if ((l = argvars[0].vval.v_list) != NULL)
2747 {
2748 li = l->lv_first;
2749 if (argvars[2].v_type != VAR_UNKNOWN)
2750 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002751 if (argvars[3].v_type != VAR_UNKNOWN)
2752 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002753 idx = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002754 if (!error)
2755 {
2756 li = list_find(l, idx);
2757 if (li == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002758 semsg(_(e_listidx), idx);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002759 }
2760 }
2761 if (error)
2762 li = NULL;
2763 }
2764
2765 for ( ; li != NULL; li = li->li_next)
2766 if (tv_equal(&li->li_tv, &argvars[1], ic, FALSE))
2767 ++n;
2768 }
2769 }
2770 else if (argvars[0].v_type == VAR_DICT)
2771 {
2772 int todo;
2773 dict_T *d;
2774 hashitem_T *hi;
2775
2776 if ((d = argvars[0].vval.v_dict) != NULL)
2777 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002778 if (argvars[2].v_type != VAR_UNKNOWN)
2779 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002780 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002781 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002782 }
2783
2784 todo = error ? 0 : (int)d->dv_hashtab.ht_used;
2785 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
2786 {
2787 if (!HASHITEM_EMPTY(hi))
2788 {
2789 --todo;
2790 if (tv_equal(&HI2DI(hi)->di_tv, &argvars[1], ic, FALSE))
2791 ++n;
2792 }
2793 }
2794 }
2795 }
2796 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002797 semsg(_(e_listdictarg), "count()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002798 rettv->vval.v_number = n;
2799}
2800
2801/*
2802 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
2803 *
2804 * Checks the existence of a cscope connection.
2805 */
2806 static void
2807f_cscope_connection(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2808{
2809#ifdef FEAT_CSCOPE
2810 int num = 0;
2811 char_u *dbpath = NULL;
2812 char_u *prepend = NULL;
2813 char_u buf[NUMBUFLEN];
2814
2815 if (argvars[0].v_type != VAR_UNKNOWN
2816 && argvars[1].v_type != VAR_UNKNOWN)
2817 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002818 num = (int)tv_get_number(&argvars[0]);
2819 dbpath = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002820 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002821 prepend = tv_get_string_buf(&argvars[2], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002822 }
2823
2824 rettv->vval.v_number = cs_connection(num, dbpath, prepend);
2825#endif
2826}
2827
2828/*
2829 * "cursor(lnum, col)" function, or
2830 * "cursor(list)"
2831 *
2832 * Moves the cursor to the specified line and column.
2833 * Returns 0 when the position could be set, -1 otherwise.
2834 */
2835 static void
2836f_cursor(typval_T *argvars, typval_T *rettv)
2837{
2838 long line, col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002839 long coladd = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002840 int set_curswant = TRUE;
2841
2842 rettv->vval.v_number = -1;
2843 if (argvars[1].v_type == VAR_UNKNOWN)
2844 {
2845 pos_T pos;
2846 colnr_T curswant = -1;
2847
2848 if (list2fpos(argvars, &pos, NULL, &curswant) == FAIL)
2849 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002850 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002851 return;
2852 }
2853 line = pos.lnum;
2854 col = pos.col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002855 coladd = pos.coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002856 if (curswant >= 0)
2857 {
2858 curwin->w_curswant = curswant - 1;
2859 set_curswant = FALSE;
2860 }
2861 }
2862 else
2863 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002864 line = tv_get_lnum(argvars);
2865 col = (long)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002866 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002867 coladd = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002868 }
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01002869 if (line < 0 || col < 0 || coladd < 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002870 return; /* type error; errmsg already given */
2871 if (line > 0)
2872 curwin->w_cursor.lnum = line;
2873 if (col > 0)
2874 curwin->w_cursor.col = col - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002875 curwin->w_cursor.coladd = coladd;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002876
2877 /* Make sure the cursor is in a valid position. */
2878 check_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002879 /* Correct cursor for multi-byte character. */
2880 if (has_mbyte)
2881 mb_adjust_cursor();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002882
2883 curwin->w_set_curswant = set_curswant;
2884 rettv->vval.v_number = 0;
2885}
2886
Bram Moolenaar4f974752019-02-17 17:44:42 +01002887#ifdef MSWIN
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002888/*
2889 * "debugbreak()" function
2890 */
2891 static void
2892f_debugbreak(typval_T *argvars, typval_T *rettv)
2893{
2894 int pid;
2895
2896 rettv->vval.v_number = FAIL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002897 pid = (int)tv_get_number(&argvars[0]);
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002898 if (pid == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002899 emsg(_(e_invarg));
Bram Moolenaar4551c0a2018-06-20 22:38:21 +02002900 else
2901 {
2902 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
2903
2904 if (hProcess != NULL)
2905 {
2906 DebugBreakProcess(hProcess);
2907 CloseHandle(hProcess);
2908 rettv->vval.v_number = OK;
2909 }
2910 }
2911}
2912#endif
2913
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002914/*
2915 * "deepcopy()" function
2916 */
2917 static void
2918f_deepcopy(typval_T *argvars, typval_T *rettv)
2919{
2920 int noref = 0;
2921 int copyID;
2922
2923 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002924 noref = (int)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002925 if (noref < 0 || noref > 1)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002926 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002927 else
2928 {
2929 copyID = get_copyID();
2930 item_copy(&argvars[0], rettv, TRUE, noref == 0 ? copyID : 0);
2931 }
2932}
2933
2934/*
2935 * "delete()" function
2936 */
2937 static void
2938f_delete(typval_T *argvars, typval_T *rettv)
2939{
2940 char_u nbuf[NUMBUFLEN];
2941 char_u *name;
2942 char_u *flags;
2943
2944 rettv->vval.v_number = -1;
2945 if (check_restricted() || check_secure())
2946 return;
2947
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002948 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002949 if (name == NULL || *name == NUL)
2950 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002951 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002952 return;
2953 }
2954
2955 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002956 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002957 else
2958 flags = (char_u *)"";
2959
2960 if (*flags == NUL)
2961 /* delete a file */
2962 rettv->vval.v_number = mch_remove(name) == 0 ? 0 : -1;
2963 else if (STRCMP(flags, "d") == 0)
2964 /* delete an empty directory */
2965 rettv->vval.v_number = mch_rmdir(name) == 0 ? 0 : -1;
2966 else if (STRCMP(flags, "rf") == 0)
2967 /* delete a directory recursively */
2968 rettv->vval.v_number = delete_recursive(name);
2969 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002970 semsg(_(e_invexpr2), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02002971}
2972
2973/*
Bram Moolenaard79a2622018-06-07 18:17:46 +02002974 * "deletebufline()" function
2975 */
2976 static void
Bram Moolenaar6f8d2ac2018-07-25 19:49:45 +02002977f_deletebufline(typval_T *argvars, typval_T *rettv)
Bram Moolenaard79a2622018-06-07 18:17:46 +02002978{
2979 buf_T *buf;
2980 linenr_T first, last;
2981 linenr_T lnum;
2982 long count;
2983 int is_curbuf;
2984 buf_T *curbuf_save = NULL;
2985 win_T *curwin_save = NULL;
2986 tabpage_T *tp;
2987 win_T *wp;
2988
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01002989 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaard79a2622018-06-07 18:17:46 +02002990 if (buf == NULL)
2991 {
2992 rettv->vval.v_number = 1; /* FAIL */
2993 return;
2994 }
2995 is_curbuf = buf == curbuf;
2996
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002997 first = tv_get_lnum_buf(&argvars[1], buf);
Bram Moolenaard79a2622018-06-07 18:17:46 +02002998 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002999 last = tv_get_lnum_buf(&argvars[2], buf);
Bram Moolenaard79a2622018-06-07 18:17:46 +02003000 else
3001 last = first;
3002
3003 if (buf->b_ml.ml_mfp == NULL || first < 1
3004 || first > buf->b_ml.ml_line_count || last < first)
3005 {
3006 rettv->vval.v_number = 1; /* FAIL */
3007 return;
3008 }
3009
3010 if (!is_curbuf)
3011 {
3012 curbuf_save = curbuf;
3013 curwin_save = curwin;
3014 curbuf = buf;
3015 find_win_for_curbuf();
3016 }
3017 if (last > curbuf->b_ml.ml_line_count)
3018 last = curbuf->b_ml.ml_line_count;
3019 count = last - first + 1;
3020
3021 // When coming here from Insert mode, sync undo, so that this can be
3022 // undone separately from what was previously inserted.
3023 if (u_sync_once == 2)
3024 {
3025 u_sync_once = 1; // notify that u_sync() was called
3026 u_sync(TRUE);
3027 }
3028
3029 if (u_save(first - 1, last + 1) == FAIL)
3030 {
3031 rettv->vval.v_number = 1; /* FAIL */
3032 return;
3033 }
3034
3035 for (lnum = first; lnum <= last; ++lnum)
3036 ml_delete(first, TRUE);
3037
3038 FOR_ALL_TAB_WINDOWS(tp, wp)
3039 if (wp->w_buffer == buf)
3040 {
3041 if (wp->w_cursor.lnum > last)
3042 wp->w_cursor.lnum -= count;
3043 else if (wp->w_cursor.lnum> first)
3044 wp->w_cursor.lnum = first;
3045 if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count)
3046 wp->w_cursor.lnum = wp->w_buffer->b_ml.ml_line_count;
3047 }
3048 check_cursor_col();
3049 deleted_lines_mark(first, count);
3050
3051 if (!is_curbuf)
3052 {
3053 curbuf = curbuf_save;
3054 curwin = curwin_save;
3055 }
3056}
3057
3058/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003059 * "did_filetype()" function
3060 */
3061 static void
3062f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3063{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003064 rettv->vval.v_number = did_filetype;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003065}
3066
3067/*
3068 * "diff_filler()" function
3069 */
3070 static void
3071f_diff_filler(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3072{
3073#ifdef FEAT_DIFF
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003074 rettv->vval.v_number = diff_check_fill(curwin, tv_get_lnum(argvars));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003075#endif
3076}
3077
3078/*
3079 * "diff_hlID()" function
3080 */
3081 static void
3082f_diff_hlID(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
3083{
3084#ifdef FEAT_DIFF
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003085 linenr_T lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003086 static linenr_T prev_lnum = 0;
Bram Moolenaar79518e22017-02-17 16:31:35 +01003087 static varnumber_T changedtick = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003088 static int fnum = 0;
3089 static int change_start = 0;
3090 static int change_end = 0;
3091 static hlf_T hlID = (hlf_T)0;
3092 int filler_lines;
3093 int col;
3094
3095 if (lnum < 0) /* ignore type error in {lnum} arg */
3096 lnum = 0;
3097 if (lnum != prev_lnum
Bram Moolenaar95c526e2017-02-25 14:59:34 +01003098 || changedtick != CHANGEDTICK(curbuf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003099 || fnum != curbuf->b_fnum)
3100 {
3101 /* New line, buffer, change: need to get the values. */
3102 filler_lines = diff_check(curwin, lnum);
3103 if (filler_lines < 0)
3104 {
3105 if (filler_lines == -1)
3106 {
3107 change_start = MAXCOL;
3108 change_end = -1;
3109 if (diff_find_change(curwin, lnum, &change_start, &change_end))
3110 hlID = HLF_ADD; /* added line */
3111 else
3112 hlID = HLF_CHD; /* changed line */
3113 }
3114 else
3115 hlID = HLF_ADD; /* added line */
3116 }
3117 else
3118 hlID = (hlf_T)0;
3119 prev_lnum = lnum;
Bram Moolenaar95c526e2017-02-25 14:59:34 +01003120 changedtick = CHANGEDTICK(curbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003121 fnum = curbuf->b_fnum;
3122 }
3123
3124 if (hlID == HLF_CHD || hlID == HLF_TXD)
3125 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003126 col = tv_get_number(&argvars[1]) - 1; /* ignore type error in {col} */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003127 if (col >= change_start && col <= change_end)
3128 hlID = HLF_TXD; /* changed text */
3129 else
3130 hlID = HLF_CHD; /* changed line */
3131 }
3132 rettv->vval.v_number = hlID == (hlf_T)0 ? 0 : (int)hlID;
3133#endif
3134}
3135
3136/*
3137 * "empty({expr})" function
3138 */
3139 static void
3140f_empty(typval_T *argvars, typval_T *rettv)
3141{
3142 int n = FALSE;
3143
3144 switch (argvars[0].v_type)
3145 {
3146 case VAR_STRING:
3147 case VAR_FUNC:
3148 n = argvars[0].vval.v_string == NULL
3149 || *argvars[0].vval.v_string == NUL;
3150 break;
3151 case VAR_PARTIAL:
3152 n = FALSE;
3153 break;
3154 case VAR_NUMBER:
3155 n = argvars[0].vval.v_number == 0;
3156 break;
3157 case VAR_FLOAT:
3158#ifdef FEAT_FLOAT
3159 n = argvars[0].vval.v_float == 0.0;
3160 break;
3161#endif
3162 case VAR_LIST:
3163 n = argvars[0].vval.v_list == NULL
3164 || argvars[0].vval.v_list->lv_first == NULL;
3165 break;
3166 case VAR_DICT:
3167 n = argvars[0].vval.v_dict == NULL
3168 || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0;
3169 break;
3170 case VAR_SPECIAL:
3171 n = argvars[0].vval.v_number != VVAL_TRUE;
3172 break;
3173
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003174 case VAR_BLOB:
3175 n = argvars[0].vval.v_blob == NULL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003176 || argvars[0].vval.v_blob->bv_ga.ga_len == 0;
3177 break;
3178
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003179 case VAR_JOB:
3180#ifdef FEAT_JOB_CHANNEL
3181 n = argvars[0].vval.v_job == NULL
3182 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
3183 break;
3184#endif
3185 case VAR_CHANNEL:
3186#ifdef FEAT_JOB_CHANNEL
3187 n = argvars[0].vval.v_channel == NULL
3188 || !channel_is_open(argvars[0].vval.v_channel);
3189 break;
3190#endif
3191 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +01003192 internal_error("f_empty(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003193 n = TRUE;
3194 break;
3195 }
3196
3197 rettv->vval.v_number = n;
3198}
3199
3200/*
3201 * "escape({string}, {chars})" function
3202 */
3203 static void
3204f_escape(typval_T *argvars, typval_T *rettv)
3205{
3206 char_u buf[NUMBUFLEN];
3207
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003208 rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]),
3209 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003210 rettv->v_type = VAR_STRING;
3211}
3212
3213/*
3214 * "eval()" function
3215 */
3216 static void
3217f_eval(typval_T *argvars, typval_T *rettv)
3218{
3219 char_u *s, *p;
3220
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003221 s = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003222 if (s != NULL)
3223 s = skipwhite(s);
3224
3225 p = s;
3226 if (s == NULL || eval1(&s, rettv, TRUE) == FAIL)
3227 {
3228 if (p != NULL && !aborting())
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003229 semsg(_(e_invexpr2), p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003230 need_clr_eos = FALSE;
3231 rettv->v_type = VAR_NUMBER;
3232 rettv->vval.v_number = 0;
3233 }
3234 else if (*s != NUL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003235 emsg(_(e_trailing));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003236}
3237
3238/*
3239 * "eventhandler()" function
3240 */
3241 static void
3242f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv)
3243{
3244 rettv->vval.v_number = vgetc_busy;
3245}
3246
3247/*
3248 * "executable()" function
3249 */
3250 static void
3251f_executable(typval_T *argvars, typval_T *rettv)
3252{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003253 char_u *name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003254
3255 /* Check in $PATH and also check directly if there is a directory name. */
3256 rettv->vval.v_number = mch_can_exe(name, NULL, TRUE)
3257 || (gettail(name) != name && mch_can_exe(name, NULL, FALSE));
3258}
3259
3260static garray_T redir_execute_ga;
3261
3262/*
3263 * Append "value[value_len]" to the execute() output.
3264 */
3265 void
3266execute_redir_str(char_u *value, int value_len)
3267{
3268 int len;
3269
3270 if (value_len == -1)
3271 len = (int)STRLEN(value); /* Append the entire string */
3272 else
3273 len = value_len; /* Append only "value_len" characters */
3274 if (ga_grow(&redir_execute_ga, len) == OK)
3275 {
3276 mch_memmove((char *)redir_execute_ga.ga_data
3277 + redir_execute_ga.ga_len, value, len);
3278 redir_execute_ga.ga_len += len;
3279 }
3280}
3281
3282/*
3283 * Get next line from a list.
3284 * Called by do_cmdline() to get the next line.
3285 * Returns allocated string, or NULL for end of function.
3286 */
3287
3288 static char_u *
3289get_list_line(
3290 int c UNUSED,
3291 void *cookie,
3292 int indent UNUSED)
3293{
3294 listitem_T **p = (listitem_T **)cookie;
3295 listitem_T *item = *p;
3296 char_u buf[NUMBUFLEN];
3297 char_u *s;
3298
3299 if (item == NULL)
3300 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003301 s = tv_get_string_buf_chk(&item->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003302 *p = item->li_next;
3303 return s == NULL ? NULL : vim_strsave(s);
3304}
3305
3306/*
3307 * "execute()" function
3308 */
3309 static void
3310f_execute(typval_T *argvars, typval_T *rettv)
3311{
3312 char_u *cmd = NULL;
3313 list_T *list = NULL;
3314 int save_msg_silent = msg_silent;
3315 int save_emsg_silent = emsg_silent;
3316 int save_emsg_noredir = emsg_noredir;
3317 int save_redir_execute = redir_execute;
Bram Moolenaar20951482017-12-25 13:44:43 +01003318 int save_redir_off = redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003319 garray_T save_ga;
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003320 int save_msg_col = msg_col;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003321 int echo_output = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003322
3323 rettv->vval.v_string = NULL;
3324 rettv->v_type = VAR_STRING;
3325
3326 if (argvars[0].v_type == VAR_LIST)
3327 {
3328 list = argvars[0].vval.v_list;
3329 if (list == NULL || list->lv_first == NULL)
3330 /* empty list, no commands, empty output */
3331 return;
3332 ++list->lv_refcount;
3333 }
3334 else
3335 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003336 cmd = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003337 if (cmd == NULL)
3338 return;
3339 }
3340
3341 if (argvars[1].v_type != VAR_UNKNOWN)
3342 {
3343 char_u buf[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003344 char_u *s = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003345
3346 if (s == NULL)
3347 return;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003348 if (*s == NUL)
3349 echo_output = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003350 if (STRNCMP(s, "silent", 6) == 0)
3351 ++msg_silent;
3352 if (STRCMP(s, "silent!") == 0)
3353 {
3354 emsg_silent = TRUE;
3355 emsg_noredir = TRUE;
3356 }
3357 }
3358 else
3359 ++msg_silent;
3360
3361 if (redir_execute)
3362 save_ga = redir_execute_ga;
3363 ga_init2(&redir_execute_ga, (int)sizeof(char), 500);
3364 redir_execute = TRUE;
Bram Moolenaar20951482017-12-25 13:44:43 +01003365 redir_off = FALSE;
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003366 if (!echo_output)
3367 msg_col = 0; // prevent leading spaces
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003368
3369 if (cmd != NULL)
3370 do_cmdline_cmd(cmd);
3371 else
3372 {
3373 listitem_T *item = list->lv_first;
3374
3375 do_cmdline(NULL, get_list_line, (void *)&item,
3376 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
3377 --list->lv_refcount;
3378 }
3379
Bram Moolenaard297f352017-01-29 20:31:21 +01003380 /* Need to append a NUL to the result. */
3381 if (ga_grow(&redir_execute_ga, 1) == OK)
3382 {
3383 ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL;
3384 rettv->vval.v_string = redir_execute_ga.ga_data;
3385 }
3386 else
3387 {
3388 ga_clear(&redir_execute_ga);
3389 rettv->vval.v_string = NULL;
3390 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003391 msg_silent = save_msg_silent;
3392 emsg_silent = save_emsg_silent;
3393 emsg_noredir = save_emsg_noredir;
3394
3395 redir_execute = save_redir_execute;
3396 if (redir_execute)
3397 redir_execute_ga = save_ga;
Bram Moolenaar20951482017-12-25 13:44:43 +01003398 redir_off = save_redir_off;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003399
Bram Moolenaar10ccaa12018-12-07 16:38:23 +01003400 // "silent reg" or "silent echo x" leaves msg_col somewhere in the line.
Bram Moolenaar446e7a32018-12-08 13:57:42 +01003401 if (echo_output)
3402 // When not working silently: put it in column zero. A following
3403 // "echon" will overwrite the message, unavoidably.
3404 msg_col = 0;
3405 else
3406 // When working silently: Put it back where it was, since nothing
3407 // should have been written.
3408 msg_col = save_msg_col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003409}
3410
3411/*
3412 * "exepath()" function
3413 */
3414 static void
3415f_exepath(typval_T *argvars, typval_T *rettv)
3416{
3417 char_u *p = NULL;
3418
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003419 (void)mch_can_exe(tv_get_string(&argvars[0]), &p, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003420 rettv->v_type = VAR_STRING;
3421 rettv->vval.v_string = p;
3422}
3423
3424/*
3425 * "exists()" function
3426 */
3427 static void
3428f_exists(typval_T *argvars, typval_T *rettv)
3429{
3430 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003431 int n = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003432
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003433 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003434 if (*p == '$') /* environment variable */
3435 {
3436 /* first try "normal" environment variables (fast) */
3437 if (mch_getenv(p + 1) != NULL)
3438 n = TRUE;
3439 else
3440 {
3441 /* try expanding things like $VIM and ${HOME} */
3442 p = expand_env_save(p);
3443 if (p != NULL && *p != '$')
3444 n = TRUE;
3445 vim_free(p);
3446 }
3447 }
3448 else if (*p == '&' || *p == '+') /* option */
3449 {
3450 n = (get_option_tv(&p, NULL, TRUE) == OK);
3451 if (*skipwhite(p) != NUL)
3452 n = FALSE; /* trailing garbage */
3453 }
3454 else if (*p == '*') /* internal or user defined function */
3455 {
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02003456 n = function_exists(p + 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003457 }
3458 else if (*p == ':')
3459 {
3460 n = cmd_exists(p + 1);
3461 }
3462 else if (*p == '#')
3463 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003464 if (p[1] == '#')
3465 n = autocmd_supported(p + 2);
3466 else
3467 n = au_exists(p + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003468 }
3469 else /* internal variable */
3470 {
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01003471 n = var_exists(p);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003472 }
3473
3474 rettv->vval.v_number = n;
3475}
3476
3477#ifdef FEAT_FLOAT
3478/*
3479 * "exp()" function
3480 */
3481 static void
3482f_exp(typval_T *argvars, typval_T *rettv)
3483{
3484 float_T f = 0.0;
3485
3486 rettv->v_type = VAR_FLOAT;
3487 if (get_float_arg(argvars, &f) == OK)
3488 rettv->vval.v_float = exp(f);
3489 else
3490 rettv->vval.v_float = 0.0;
3491}
3492#endif
3493
3494/*
3495 * "expand()" function
3496 */
3497 static void
3498f_expand(typval_T *argvars, typval_T *rettv)
3499{
3500 char_u *s;
3501 int len;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003502 char *errormsg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003503 int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
3504 expand_T xpc;
3505 int error = FALSE;
3506 char_u *result;
3507
3508 rettv->v_type = VAR_STRING;
3509 if (argvars[1].v_type != VAR_UNKNOWN
3510 && argvars[2].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003511 && tv_get_number_chk(&argvars[2], &error)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003512 && !error)
3513 {
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02003514 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003515 }
3516
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003517 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003518 if (*s == '%' || *s == '#' || *s == '<')
3519 {
3520 ++emsg_off;
3521 result = eval_vars(s, s, &len, NULL, &errormsg, NULL);
3522 --emsg_off;
3523 if (rettv->v_type == VAR_LIST)
3524 {
3525 if (rettv_list_alloc(rettv) != FAIL && result != NULL)
3526 list_append_string(rettv->vval.v_list, result, -1);
3527 else
3528 vim_free(result);
3529 }
3530 else
3531 rettv->vval.v_string = result;
3532 }
3533 else
3534 {
3535 /* When the optional second argument is non-zero, don't remove matches
3536 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
3537 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003538 && tv_get_number_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003539 options |= WILD_KEEP_ALL;
3540 if (!error)
3541 {
3542 ExpandInit(&xpc);
3543 xpc.xp_context = EXPAND_FILES;
3544 if (p_wic)
3545 options += WILD_ICASE;
3546 if (rettv->v_type == VAR_STRING)
3547 rettv->vval.v_string = ExpandOne(&xpc, s, NULL,
3548 options, WILD_ALL);
3549 else if (rettv_list_alloc(rettv) != FAIL)
3550 {
3551 int i;
3552
3553 ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
3554 for (i = 0; i < xpc.xp_numfiles; i++)
3555 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
3556 ExpandCleanup(&xpc);
3557 }
3558 }
3559 else
3560 rettv->vval.v_string = NULL;
3561 }
3562}
3563
3564/*
3565 * "extend(list, list [, idx])" function
3566 * "extend(dict, dict [, action])" function
3567 */
3568 static void
3569f_extend(typval_T *argvars, typval_T *rettv)
3570{
3571 char_u *arg_errmsg = (char_u *)N_("extend() argument");
3572
3573 if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)
3574 {
3575 list_T *l1, *l2;
3576 listitem_T *item;
3577 long before;
3578 int error = FALSE;
3579
3580 l1 = argvars[0].vval.v_list;
3581 l2 = argvars[1].vval.v_list;
Bram Moolenaar05c00c02019-02-11 22:00:11 +01003582 if (l1 != NULL && !var_check_lock(l1->lv_lock, arg_errmsg, TRUE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003583 && l2 != NULL)
3584 {
3585 if (argvars[2].v_type != VAR_UNKNOWN)
3586 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003587 before = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003588 if (error)
3589 return; /* type error; errmsg already given */
3590
3591 if (before == l1->lv_len)
3592 item = NULL;
3593 else
3594 {
3595 item = list_find(l1, before);
3596 if (item == NULL)
3597 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003598 semsg(_(e_listidx), before);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003599 return;
3600 }
3601 }
3602 }
3603 else
3604 item = NULL;
3605 list_extend(l1, l2, item);
3606
3607 copy_tv(&argvars[0], rettv);
3608 }
3609 }
3610 else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)
3611 {
3612 dict_T *d1, *d2;
3613 char_u *action;
3614 int i;
3615
3616 d1 = argvars[0].vval.v_dict;
3617 d2 = argvars[1].vval.v_dict;
Bram Moolenaar05c00c02019-02-11 22:00:11 +01003618 if (d1 != NULL && !var_check_lock(d1->dv_lock, arg_errmsg, TRUE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003619 && d2 != NULL)
3620 {
3621 /* Check the third argument. */
3622 if (argvars[2].v_type != VAR_UNKNOWN)
3623 {
3624 static char *(av[]) = {"keep", "force", "error"};
3625
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003626 action = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003627 if (action == NULL)
3628 return; /* type error; errmsg already given */
3629 for (i = 0; i < 3; ++i)
3630 if (STRCMP(action, av[i]) == 0)
3631 break;
3632 if (i == 3)
3633 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003634 semsg(_(e_invarg2), action);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003635 return;
3636 }
3637 }
3638 else
3639 action = (char_u *)"force";
3640
3641 dict_extend(d1, d2, action);
3642
3643 copy_tv(&argvars[0], rettv);
3644 }
3645 }
3646 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003647 semsg(_(e_listdictarg), "extend()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003648}
3649
3650/*
3651 * "feedkeys()" function
3652 */
3653 static void
3654f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED)
3655{
3656 int remap = TRUE;
3657 int insert = FALSE;
3658 char_u *keys, *flags;
3659 char_u nbuf[NUMBUFLEN];
3660 int typed = FALSE;
3661 int execute = FALSE;
3662 int dangerous = FALSE;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003663 int lowlevel = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003664 char_u *keys_esc;
3665
3666 /* This is not allowed in the sandbox. If the commands would still be
3667 * executed in the sandbox it would be OK, but it probably happens later,
3668 * when "sandbox" is no longer set. */
3669 if (check_secure())
3670 return;
3671
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003672 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003673
3674 if (argvars[1].v_type != VAR_UNKNOWN)
3675 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003676 flags = tv_get_string_buf(&argvars[1], nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003677 for ( ; *flags != NUL; ++flags)
3678 {
3679 switch (*flags)
3680 {
3681 case 'n': remap = FALSE; break;
3682 case 'm': remap = TRUE; break;
3683 case 't': typed = TRUE; break;
3684 case 'i': insert = TRUE; break;
3685 case 'x': execute = TRUE; break;
3686 case '!': dangerous = TRUE; break;
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003687 case 'L': lowlevel = TRUE; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003688 }
3689 }
3690 }
3691
3692 if (*keys != NUL || execute)
3693 {
3694 /* Need to escape K_SPECIAL and CSI before putting the string in the
3695 * typeahead buffer. */
3696 keys_esc = vim_strsave_escape_csi(keys);
3697 if (keys_esc != NULL)
3698 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003699 if (lowlevel)
3700 {
3701#ifdef USE_INPUT_BUF
3702 add_to_input_buf(keys, (int)STRLEN(keys));
3703#else
3704 emsg(_("E980: lowlevel input not supported"));
3705#endif
3706 }
3707 else
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003708 {
Bram Moolenaar5e66b422019-01-24 21:58:10 +01003709 ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003710 insert ? 0 : typebuf.tb_len, !typed, FALSE);
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003711 if (vgetc_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02003712#ifdef FEAT_TIMERS
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003713 || timer_busy
Bram Moolenaar5d7be4f2017-06-25 13:40:17 +02003714#endif
Bram Moolenaar8d4ce562019-01-30 22:01:40 +01003715 )
3716 typebuf_was_filled = TRUE;
3717 }
3718 vim_free(keys_esc);
3719
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003720 if (execute)
3721 {
3722 int save_msg_scroll = msg_scroll;
3723
3724 /* Avoid a 1 second delay when the keys start Insert mode. */
3725 msg_scroll = FALSE;
3726
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003727 if (!dangerous)
3728 ++ex_normal_busy;
Bram Moolenaar586c70c2018-10-02 16:23:58 +02003729 exec_normal(TRUE, FALSE, TRUE);
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02003730 if (!dangerous)
3731 --ex_normal_busy;
3732
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003733 msg_scroll |= save_msg_scroll;
3734 }
3735 }
3736 }
3737}
3738
3739/*
3740 * "filereadable()" function
3741 */
3742 static void
3743f_filereadable(typval_T *argvars, typval_T *rettv)
3744{
3745 int fd;
3746 char_u *p;
3747 int n;
3748
3749#ifndef O_NONBLOCK
3750# define O_NONBLOCK 0
3751#endif
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003752 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003753 if (*p && !mch_isdir(p) && (fd = mch_open((char *)p,
3754 O_RDONLY | O_NONBLOCK, 0)) >= 0)
3755 {
3756 n = TRUE;
3757 close(fd);
3758 }
3759 else
3760 n = FALSE;
3761
3762 rettv->vval.v_number = n;
3763}
3764
3765/*
3766 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
3767 * rights to write into.
3768 */
3769 static void
3770f_filewritable(typval_T *argvars, typval_T *rettv)
3771{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003772 rettv->vval.v_number = filewritable(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003773}
3774
3775 static void
3776findfilendir(
3777 typval_T *argvars UNUSED,
3778 typval_T *rettv,
3779 int find_what UNUSED)
3780{
3781#ifdef FEAT_SEARCHPATH
3782 char_u *fname;
3783 char_u *fresult = NULL;
3784 char_u *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
3785 char_u *p;
3786 char_u pathbuf[NUMBUFLEN];
3787 int count = 1;
3788 int first = TRUE;
3789 int error = FALSE;
3790#endif
3791
3792 rettv->vval.v_string = NULL;
3793 rettv->v_type = VAR_STRING;
3794
3795#ifdef FEAT_SEARCHPATH
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003796 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003797
3798 if (argvars[1].v_type != VAR_UNKNOWN)
3799 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003800 p = tv_get_string_buf_chk(&argvars[1], pathbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003801 if (p == NULL)
3802 error = TRUE;
3803 else
3804 {
3805 if (*p != NUL)
3806 path = p;
3807
3808 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003809 count = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003810 }
3811 }
3812
3813 if (count < 0 && rettv_list_alloc(rettv) == FAIL)
3814 error = TRUE;
3815
3816 if (*fname != NUL && !error)
3817 {
3818 do
3819 {
3820 if (rettv->v_type == VAR_STRING || rettv->v_type == VAR_LIST)
3821 vim_free(fresult);
3822 fresult = find_file_in_path_option(first ? fname : NULL,
3823 first ? (int)STRLEN(fname) : 0,
3824 0, first, path,
3825 find_what,
3826 curbuf->b_ffname,
3827 find_what == FINDFILE_DIR
3828 ? (char_u *)"" : curbuf->b_p_sua);
3829 first = FALSE;
3830
3831 if (fresult != NULL && rettv->v_type == VAR_LIST)
3832 list_append_string(rettv->vval.v_list, fresult, -1);
3833
3834 } while ((rettv->v_type == VAR_LIST || --count > 0) && fresult != NULL);
3835 }
3836
3837 if (rettv->v_type == VAR_STRING)
3838 rettv->vval.v_string = fresult;
3839#endif
3840}
3841
3842/*
3843 * "filter()" function
3844 */
3845 static void
3846f_filter(typval_T *argvars, typval_T *rettv)
3847{
3848 filter_map(argvars, rettv, FALSE);
3849}
3850
3851/*
3852 * "finddir({fname}[, {path}[, {count}]])" function
3853 */
3854 static void
3855f_finddir(typval_T *argvars, typval_T *rettv)
3856{
3857 findfilendir(argvars, rettv, FINDFILE_DIR);
3858}
3859
3860/*
3861 * "findfile({fname}[, {path}[, {count}]])" function
3862 */
3863 static void
3864f_findfile(typval_T *argvars, typval_T *rettv)
3865{
3866 findfilendir(argvars, rettv, FINDFILE_FILE);
3867}
3868
3869#ifdef FEAT_FLOAT
3870/*
3871 * "float2nr({float})" function
3872 */
3873 static void
3874f_float2nr(typval_T *argvars, typval_T *rettv)
3875{
3876 float_T f = 0.0;
3877
3878 if (get_float_arg(argvars, &f) == OK)
3879 {
Bram Moolenaar863e80b2017-06-04 20:30:00 +02003880 if (f <= -VARNUM_MAX + DBL_EPSILON)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01003881 rettv->vval.v_number = -VARNUM_MAX;
Bram Moolenaar863e80b2017-06-04 20:30:00 +02003882 else if (f >= VARNUM_MAX - DBL_EPSILON)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01003883 rettv->vval.v_number = VARNUM_MAX;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003884 else
3885 rettv->vval.v_number = (varnumber_T)f;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003886 }
3887}
3888
3889/*
3890 * "floor({float})" function
3891 */
3892 static void
3893f_floor(typval_T *argvars, typval_T *rettv)
3894{
3895 float_T f = 0.0;
3896
3897 rettv->v_type = VAR_FLOAT;
3898 if (get_float_arg(argvars, &f) == OK)
3899 rettv->vval.v_float = floor(f);
3900 else
3901 rettv->vval.v_float = 0.0;
3902}
3903
3904/*
3905 * "fmod()" function
3906 */
3907 static void
3908f_fmod(typval_T *argvars, typval_T *rettv)
3909{
3910 float_T fx = 0.0, fy = 0.0;
3911
3912 rettv->v_type = VAR_FLOAT;
3913 if (get_float_arg(argvars, &fx) == OK
3914 && get_float_arg(&argvars[1], &fy) == OK)
3915 rettv->vval.v_float = fmod(fx, fy);
3916 else
3917 rettv->vval.v_float = 0.0;
3918}
3919#endif
3920
3921/*
3922 * "fnameescape({string})" function
3923 */
3924 static void
3925f_fnameescape(typval_T *argvars, typval_T *rettv)
3926{
3927 rettv->vval.v_string = vim_strsave_fnameescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003928 tv_get_string(&argvars[0]), FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003929 rettv->v_type = VAR_STRING;
3930}
3931
3932/*
3933 * "fnamemodify({fname}, {mods})" function
3934 */
3935 static void
3936f_fnamemodify(typval_T *argvars, typval_T *rettv)
3937{
3938 char_u *fname;
3939 char_u *mods;
3940 int usedlen = 0;
3941 int len;
3942 char_u *fbuf = NULL;
3943 char_u buf[NUMBUFLEN];
3944
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003945 fname = tv_get_string_chk(&argvars[0]);
3946 mods = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003947 if (fname == NULL || mods == NULL)
3948 fname = NULL;
3949 else
3950 {
3951 len = (int)STRLEN(fname);
Bram Moolenaar00136dc2018-07-25 21:19:13 +02003952 (void)modify_fname(mods, FALSE, &usedlen, &fname, &fbuf, &len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003953 }
3954
3955 rettv->v_type = VAR_STRING;
3956 if (fname == NULL)
3957 rettv->vval.v_string = NULL;
3958 else
3959 rettv->vval.v_string = vim_strnsave(fname, len);
3960 vim_free(fbuf);
3961}
3962
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003963/*
3964 * "foldclosed()" function
3965 */
3966 static void
3967foldclosed_both(
3968 typval_T *argvars UNUSED,
3969 typval_T *rettv,
3970 int end UNUSED)
3971{
3972#ifdef FEAT_FOLDING
3973 linenr_T lnum;
3974 linenr_T first, last;
3975
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003976 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02003977 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
3978 {
3979 if (hasFoldingWin(curwin, lnum, &first, &last, FALSE, NULL))
3980 {
3981 if (end)
3982 rettv->vval.v_number = (varnumber_T)last;
3983 else
3984 rettv->vval.v_number = (varnumber_T)first;
3985 return;
3986 }
3987 }
3988#endif
3989 rettv->vval.v_number = -1;
3990}
3991
3992/*
3993 * "foldclosed()" function
3994 */
3995 static void
3996f_foldclosed(typval_T *argvars, typval_T *rettv)
3997{
3998 foldclosed_both(argvars, rettv, FALSE);
3999}
4000
4001/*
4002 * "foldclosedend()" function
4003 */
4004 static void
4005f_foldclosedend(typval_T *argvars, typval_T *rettv)
4006{
4007 foldclosed_both(argvars, rettv, TRUE);
4008}
4009
4010/*
4011 * "foldlevel()" function
4012 */
4013 static void
4014f_foldlevel(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4015{
4016#ifdef FEAT_FOLDING
4017 linenr_T lnum;
4018
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004019 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004020 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4021 rettv->vval.v_number = foldLevel(lnum);
4022#endif
4023}
4024
4025/*
4026 * "foldtext()" function
4027 */
4028 static void
4029f_foldtext(typval_T *argvars UNUSED, typval_T *rettv)
4030{
4031#ifdef FEAT_FOLDING
4032 linenr_T foldstart;
4033 linenr_T foldend;
4034 char_u *dashes;
4035 linenr_T lnum;
4036 char_u *s;
4037 char_u *r;
4038 int len;
4039 char *txt;
Bram Moolenaaree695f72016-08-03 22:08:45 +02004040 long count;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004041#endif
4042
4043 rettv->v_type = VAR_STRING;
4044 rettv->vval.v_string = NULL;
4045#ifdef FEAT_FOLDING
4046 foldstart = (linenr_T)get_vim_var_nr(VV_FOLDSTART);
4047 foldend = (linenr_T)get_vim_var_nr(VV_FOLDEND);
4048 dashes = get_vim_var_str(VV_FOLDDASHES);
4049 if (foldstart > 0 && foldend <= curbuf->b_ml.ml_line_count
4050 && dashes != NULL)
4051 {
4052 /* Find first non-empty line in the fold. */
Bram Moolenaar69aa0992016-07-17 22:33:53 +02004053 for (lnum = foldstart; lnum < foldend; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004054 if (!linewhite(lnum))
4055 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004056
4057 /* Find interesting text in this line. */
4058 s = skipwhite(ml_get(lnum));
4059 /* skip C comment-start */
4060 if (s[0] == '/' && (s[1] == '*' || s[1] == '/'))
4061 {
4062 s = skipwhite(s + 2);
4063 if (*skipwhite(s) == NUL
4064 && lnum + 1 < (linenr_T)get_vim_var_nr(VV_FOLDEND))
4065 {
4066 s = skipwhite(ml_get(lnum + 1));
4067 if (*s == '*')
4068 s = skipwhite(s + 1);
4069 }
4070 }
Bram Moolenaaree695f72016-08-03 22:08:45 +02004071 count = (long)(foldend - foldstart + 1);
Bram Moolenaar1c465442017-03-12 20:10:05 +01004072 txt = NGETTEXT("+-%s%3ld line: ", "+-%s%3ld lines: ", count);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004073 r = alloc((unsigned)(STRLEN(txt)
4074 + STRLEN(dashes) /* for %s */
4075 + 20 /* for %3ld */
4076 + STRLEN(s))); /* concatenated */
4077 if (r != NULL)
4078 {
Bram Moolenaaree695f72016-08-03 22:08:45 +02004079 sprintf((char *)r, txt, dashes, count);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004080 len = (int)STRLEN(r);
4081 STRCAT(r, s);
4082 /* remove 'foldmarker' and 'commentstring' */
4083 foldtext_cleanup(r + len);
4084 rettv->vval.v_string = r;
4085 }
4086 }
4087#endif
4088}
4089
4090/*
4091 * "foldtextresult(lnum)" function
4092 */
4093 static void
4094f_foldtextresult(typval_T *argvars UNUSED, typval_T *rettv)
4095{
4096#ifdef FEAT_FOLDING
4097 linenr_T lnum;
4098 char_u *text;
Bram Moolenaaree695f72016-08-03 22:08:45 +02004099 char_u buf[FOLD_TEXT_LEN];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004100 foldinfo_T foldinfo;
4101 int fold_count;
Bram Moolenaar495b7dd2017-09-16 17:19:22 +02004102 static int entered = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004103#endif
4104
4105 rettv->v_type = VAR_STRING;
4106 rettv->vval.v_string = NULL;
4107#ifdef FEAT_FOLDING
Bram Moolenaar495b7dd2017-09-16 17:19:22 +02004108 if (entered)
4109 return; /* reject recursive use */
4110 entered = TRUE;
4111
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004112 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004113 /* treat illegal types and illegal string values for {lnum} the same */
4114 if (lnum < 0)
4115 lnum = 0;
4116 fold_count = foldedCount(curwin, lnum, &foldinfo);
4117 if (fold_count > 0)
4118 {
Bram Moolenaarc6aafba2017-03-21 17:09:10 +01004119 text = get_foldtext(curwin, lnum, lnum + fold_count - 1,
4120 &foldinfo, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004121 if (text == buf)
4122 text = vim_strsave(text);
4123 rettv->vval.v_string = text;
4124 }
Bram Moolenaar495b7dd2017-09-16 17:19:22 +02004125
4126 entered = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004127#endif
4128}
4129
4130/*
4131 * "foreground()" function
4132 */
4133 static void
4134f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
4135{
4136#ifdef FEAT_GUI
4137 if (gui.in_use)
4138 gui_mch_set_foreground();
4139#else
Bram Moolenaar4f974752019-02-17 17:44:42 +01004140# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004141 win32_set_foreground();
4142# endif
4143#endif
4144}
4145
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004146 static void
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004147common_function(typval_T *argvars, typval_T *rettv, int is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004148{
4149 char_u *s;
4150 char_u *name;
4151 int use_string = FALSE;
4152 partial_T *arg_pt = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004153 char_u *trans_name = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004154
4155 if (argvars[0].v_type == VAR_FUNC)
4156 {
4157 /* function(MyFunc, [arg], dict) */
4158 s = argvars[0].vval.v_string;
4159 }
4160 else if (argvars[0].v_type == VAR_PARTIAL
4161 && argvars[0].vval.v_partial != NULL)
4162 {
4163 /* function(dict.MyFunc, [arg]) */
4164 arg_pt = argvars[0].vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004165 s = partial_name(arg_pt);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004166 }
4167 else
4168 {
4169 /* function('MyFunc', [arg], dict) */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004170 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004171 use_string = TRUE;
4172 }
4173
Bram Moolenaar843b8842016-08-21 14:36:15 +02004174 if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004175 {
4176 name = s;
4177 trans_name = trans_function_name(&name, FALSE,
4178 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, NULL, NULL);
4179 if (*name != NUL)
4180 s = NULL;
4181 }
4182
Bram Moolenaar843b8842016-08-21 14:36:15 +02004183 if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
4184 || (is_funcref && trans_name == NULL))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004185 semsg(_(e_invarg2), use_string ? tv_get_string(&argvars[0]) : s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004186 /* Don't check an autoload name for existence here. */
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004187 else if (trans_name != NULL && (is_funcref
4188 ? find_func(trans_name) == NULL
4189 : !translated_function_exists(trans_name)))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004190 semsg(_("E700: Unknown function: %s"), s);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004191 else
4192 {
4193 int dict_idx = 0;
4194 int arg_idx = 0;
4195 list_T *list = NULL;
4196
4197 if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0)
4198 {
4199 char sid_buf[25];
4200 int off = *s == 's' ? 2 : 5;
4201
4202 /* Expand s: and <SID> into <SNR>nr_, so that the function can
4203 * also be called from another script. Using trans_function_name()
4204 * would also work, but some plugins depend on the name being
4205 * printable text. */
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02004206 sprintf(sid_buf, "<SNR>%ld_", (long)current_sctx.sc_sid);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004207 name = alloc((int)(STRLEN(sid_buf) + STRLEN(s + off) + 1));
4208 if (name != NULL)
4209 {
4210 STRCPY(name, sid_buf);
4211 STRCAT(name, s + off);
4212 }
4213 }
4214 else
4215 name = vim_strsave(s);
4216
4217 if (argvars[1].v_type != VAR_UNKNOWN)
4218 {
4219 if (argvars[2].v_type != VAR_UNKNOWN)
4220 {
4221 /* function(name, [args], dict) */
4222 arg_idx = 1;
4223 dict_idx = 2;
4224 }
4225 else if (argvars[1].v_type == VAR_DICT)
4226 /* function(name, dict) */
4227 dict_idx = 1;
4228 else
4229 /* function(name, [args]) */
4230 arg_idx = 1;
4231 if (dict_idx > 0)
4232 {
4233 if (argvars[dict_idx].v_type != VAR_DICT)
4234 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004235 emsg(_("E922: expected a dict"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004236 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004237 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004238 }
4239 if (argvars[dict_idx].vval.v_dict == NULL)
4240 dict_idx = 0;
4241 }
4242 if (arg_idx > 0)
4243 {
4244 if (argvars[arg_idx].v_type != VAR_LIST)
4245 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004246 emsg(_("E923: Second argument of function() must be a list or a dict"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004247 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004248 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004249 }
4250 list = argvars[arg_idx].vval.v_list;
4251 if (list == NULL || list->lv_len == 0)
4252 arg_idx = 0;
4253 }
4254 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004255 if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004256 {
4257 partial_T *pt = (partial_T *)alloc_clear(sizeof(partial_T));
4258
4259 /* result is a VAR_PARTIAL */
4260 if (pt == NULL)
4261 vim_free(name);
4262 else
4263 {
4264 if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
4265 {
4266 listitem_T *li;
4267 int i = 0;
4268 int arg_len = 0;
4269 int lv_len = 0;
4270
4271 if (arg_pt != NULL)
4272 arg_len = arg_pt->pt_argc;
4273 if (list != NULL)
4274 lv_len = list->lv_len;
4275 pt->pt_argc = arg_len + lv_len;
4276 pt->pt_argv = (typval_T *)alloc(
4277 sizeof(typval_T) * pt->pt_argc);
4278 if (pt->pt_argv == NULL)
4279 {
4280 vim_free(pt);
4281 vim_free(name);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004282 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004283 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004284 for (i = 0; i < arg_len; i++)
4285 copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
4286 if (lv_len > 0)
4287 for (li = list->lv_first; li != NULL;
4288 li = li->li_next)
4289 copy_tv(&li->li_tv, &pt->pt_argv[i++]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004290 }
4291
4292 /* For "function(dict.func, [], dict)" and "func" is a partial
4293 * use "dict". That is backwards compatible. */
4294 if (dict_idx > 0)
4295 {
4296 /* The dict is bound explicitly, pt_auto is FALSE. */
4297 pt->pt_dict = argvars[dict_idx].vval.v_dict;
4298 ++pt->pt_dict->dv_refcount;
4299 }
4300 else if (arg_pt != NULL)
4301 {
4302 /* If the dict was bound automatically the result is also
4303 * bound automatically. */
4304 pt->pt_dict = arg_pt->pt_dict;
4305 pt->pt_auto = arg_pt->pt_auto;
4306 if (pt->pt_dict != NULL)
4307 ++pt->pt_dict->dv_refcount;
4308 }
4309
4310 pt->pt_refcount = 1;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004311 if (arg_pt != NULL && arg_pt->pt_func != NULL)
4312 {
4313 pt->pt_func = arg_pt->pt_func;
4314 func_ptr_ref(pt->pt_func);
4315 vim_free(name);
4316 }
4317 else if (is_funcref)
4318 {
4319 pt->pt_func = find_func(trans_name);
4320 func_ptr_ref(pt->pt_func);
4321 vim_free(name);
4322 }
4323 else
4324 {
4325 pt->pt_name = name;
4326 func_ref(name);
4327 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004328 }
4329 rettv->v_type = VAR_PARTIAL;
4330 rettv->vval.v_partial = pt;
4331 }
4332 else
4333 {
4334 /* result is a VAR_FUNC */
4335 rettv->v_type = VAR_FUNC;
4336 rettv->vval.v_string = name;
4337 func_ref(name);
4338 }
4339 }
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004340theend:
4341 vim_free(trans_name);
4342}
4343
4344/*
4345 * "funcref()" function
4346 */
4347 static void
4348f_funcref(typval_T *argvars, typval_T *rettv)
4349{
4350 common_function(argvars, rettv, TRUE);
4351}
4352
4353/*
4354 * "function()" function
4355 */
4356 static void
4357f_function(typval_T *argvars, typval_T *rettv)
4358{
4359 common_function(argvars, rettv, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004360}
4361
4362/*
4363 * "garbagecollect()" function
4364 */
4365 static void
4366f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED)
4367{
4368 /* This is postponed until we are back at the toplevel, because we may be
4369 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
4370 want_garbage_collect = TRUE;
4371
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004372 if (argvars[0].v_type != VAR_UNKNOWN && tv_get_number(&argvars[0]) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004373 garbage_collect_at_exit = TRUE;
4374}
4375
4376/*
4377 * "get()" function
4378 */
4379 static void
4380f_get(typval_T *argvars, typval_T *rettv)
4381{
4382 listitem_T *li;
4383 list_T *l;
4384 dictitem_T *di;
4385 dict_T *d;
4386 typval_T *tv = NULL;
4387
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004388 if (argvars[0].v_type == VAR_BLOB)
4389 {
4390 int error = FALSE;
4391 int idx = tv_get_number_chk(&argvars[1], &error);
4392
4393 if (!error)
4394 {
4395 rettv->v_type = VAR_NUMBER;
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004396 if (idx < 0)
4397 idx = blob_len(argvars[0].vval.v_blob) + idx;
4398 if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob))
4399 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004400 else
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004401 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004402 rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx);
Bram Moolenaar2ea773b2019-01-15 22:16:42 +01004403 tv = rettv;
4404 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004405 }
4406 }
4407 else if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004408 {
4409 if ((l = argvars[0].vval.v_list) != NULL)
4410 {
4411 int error = FALSE;
4412
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004413 li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004414 if (!error && li != NULL)
4415 tv = &li->li_tv;
4416 }
4417 }
4418 else if (argvars[0].v_type == VAR_DICT)
4419 {
4420 if ((d = argvars[0].vval.v_dict) != NULL)
4421 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004422 di = dict_find(d, tv_get_string(&argvars[1]), -1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004423 if (di != NULL)
4424 tv = &di->di_tv;
4425 }
4426 }
4427 else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC)
4428 {
4429 partial_T *pt;
4430 partial_T fref_pt;
4431
4432 if (argvars[0].v_type == VAR_PARTIAL)
4433 pt = argvars[0].vval.v_partial;
4434 else
4435 {
4436 vim_memset(&fref_pt, 0, sizeof(fref_pt));
4437 fref_pt.pt_name = argvars[0].vval.v_string;
4438 pt = &fref_pt;
4439 }
4440
4441 if (pt != NULL)
4442 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004443 char_u *what = tv_get_string(&argvars[1]);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004444 char_u *n;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004445
4446 if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0)
4447 {
4448 rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004449 n = partial_name(pt);
4450 if (n == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004451 rettv->vval.v_string = NULL;
4452 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004453 {
4454 rettv->vval.v_string = vim_strsave(n);
4455 if (rettv->v_type == VAR_FUNC)
4456 func_ref(rettv->vval.v_string);
4457 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004458 }
4459 else if (STRCMP(what, "dict") == 0)
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004460 rettv_dict_set(rettv, pt->pt_dict);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004461 else if (STRCMP(what, "args") == 0)
4462 {
4463 rettv->v_type = VAR_LIST;
4464 if (rettv_list_alloc(rettv) == OK)
4465 {
4466 int i;
4467
4468 for (i = 0; i < pt->pt_argc; ++i)
4469 list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]);
4470 }
4471 }
4472 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004473 semsg(_(e_invarg2), what);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004474 return;
4475 }
4476 }
4477 else
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01004478 semsg(_(e_listdictblobarg), "get()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004479
4480 if (tv == NULL)
4481 {
4482 if (argvars[2].v_type != VAR_UNKNOWN)
4483 copy_tv(&argvars[2], rettv);
4484 }
4485 else
4486 copy_tv(tv, rettv);
4487}
4488
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004489/*
4490 * Returns buffer options, variables and other attributes in a dictionary.
4491 */
4492 static dict_T *
4493get_buffer_info(buf_T *buf)
4494{
4495 dict_T *dict;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004496 tabpage_T *tp;
4497 win_T *wp;
4498 list_T *windows;
4499
4500 dict = dict_alloc();
4501 if (dict == NULL)
4502 return NULL;
4503
Bram Moolenaare0be1672018-07-08 16:50:37 +02004504 dict_add_number(dict, "bufnr", buf->b_fnum);
4505 dict_add_string(dict, "name", buf->b_ffname);
4506 dict_add_number(dict, "lnum", buf == curbuf ? curwin->w_cursor.lnum
4507 : buflist_findlnum(buf));
4508 dict_add_number(dict, "loaded", buf->b_ml.ml_mfp != NULL);
4509 dict_add_number(dict, "listed", buf->b_p_bl);
4510 dict_add_number(dict, "changed", bufIsChanged(buf));
4511 dict_add_number(dict, "changedtick", CHANGEDTICK(buf));
4512 dict_add_number(dict, "hidden",
4513 buf->b_ml.ml_mfp != NULL && buf->b_nwindows == 0);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004514
Bram Moolenaar9f8187c2016-08-27 20:34:01 +02004515 /* Get a reference to buffer variables */
4516 dict_add_dict(dict, "variables", buf->b_vars);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004517
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004518 /* List of windows displaying this buffer */
4519 windows = list_alloc();
4520 if (windows != NULL)
4521 {
4522 FOR_ALL_TAB_WINDOWS(tp, wp)
4523 if (wp->w_buffer == buf)
4524 list_append_number(windows, (varnumber_T)wp->w_id);
4525 dict_add_list(dict, "windows", windows);
4526 }
4527
4528#ifdef FEAT_SIGNS
4529 if (buf->b_signlist != NULL)
4530 {
4531 /* List of signs placed in this buffer */
4532 list_T *signs = list_alloc();
4533 if (signs != NULL)
4534 {
4535 get_buffer_signs(buf, signs);
4536 dict_add_list(dict, "signs", signs);
4537 }
4538 }
4539#endif
4540
4541 return dict;
4542}
4543
4544/*
4545 * "getbufinfo()" function
4546 */
4547 static void
4548f_getbufinfo(typval_T *argvars, typval_T *rettv)
4549{
4550 buf_T *buf = NULL;
4551 buf_T *argbuf = NULL;
4552 dict_T *d;
4553 int filtered = FALSE;
4554 int sel_buflisted = FALSE;
4555 int sel_bufloaded = FALSE;
Bram Moolenaar8e6a31d2017-12-10 21:06:22 +01004556 int sel_bufmodified = FALSE;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004557
4558 if (rettv_list_alloc(rettv) != OK)
4559 return;
4560
4561 /* List of all the buffers or selected buffers */
4562 if (argvars[0].v_type == VAR_DICT)
4563 {
4564 dict_T *sel_d = argvars[0].vval.v_dict;
4565
4566 if (sel_d != NULL)
4567 {
4568 dictitem_T *di;
4569
4570 filtered = TRUE;
4571
4572 di = dict_find(sel_d, (char_u *)"buflisted", -1);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004573 if (di != NULL && tv_get_number(&di->di_tv))
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004574 sel_buflisted = TRUE;
4575
4576 di = dict_find(sel_d, (char_u *)"bufloaded", -1);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004577 if (di != NULL && tv_get_number(&di->di_tv))
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004578 sel_bufloaded = TRUE;
Bram Moolenaar8e6a31d2017-12-10 21:06:22 +01004579
4580 di = dict_find(sel_d, (char_u *)"bufmodified", -1);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004581 if (di != NULL && tv_get_number(&di->di_tv))
Bram Moolenaar8e6a31d2017-12-10 21:06:22 +01004582 sel_bufmodified = TRUE;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004583 }
4584 }
4585 else if (argvars[0].v_type != VAR_UNKNOWN)
4586 {
4587 /* Information about one buffer. Argument specifies the buffer */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004588 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004589 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01004590 argbuf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004591 --emsg_off;
4592 if (argbuf == NULL)
4593 return;
4594 }
4595
4596 /* Return information about all the buffers or a specified buffer */
Bram Moolenaar386600f2016-08-15 22:16:25 +02004597 FOR_ALL_BUFFERS(buf)
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004598 {
4599 if (argbuf != NULL && argbuf != buf)
4600 continue;
4601 if (filtered && ((sel_bufloaded && buf->b_ml.ml_mfp == NULL)
Bram Moolenaar8e6a31d2017-12-10 21:06:22 +01004602 || (sel_buflisted && !buf->b_p_bl)
4603 || (sel_bufmodified && !buf->b_changed)))
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02004604 continue;
4605
4606 d = get_buffer_info(buf);
4607 if (d != NULL)
4608 list_append_dict(rettv->vval.v_list, d);
4609 if (argbuf != NULL)
4610 return;
4611 }
4612}
4613
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004614/*
4615 * Get line or list of lines from buffer "buf" into "rettv".
4616 * Return a range (from start to end) of lines in rettv from the specified
4617 * buffer.
4618 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
4619 */
4620 static void
4621get_buffer_lines(
4622 buf_T *buf,
4623 linenr_T start,
4624 linenr_T end,
4625 int retlist,
4626 typval_T *rettv)
4627{
4628 char_u *p;
4629
4630 rettv->v_type = VAR_STRING;
4631 rettv->vval.v_string = NULL;
4632 if (retlist && rettv_list_alloc(rettv) == FAIL)
4633 return;
4634
4635 if (buf == NULL || buf->b_ml.ml_mfp == NULL || start < 0)
4636 return;
4637
4638 if (!retlist)
4639 {
4640 if (start >= 1 && start <= buf->b_ml.ml_line_count)
4641 p = ml_get_buf(buf, start, FALSE);
4642 else
4643 p = (char_u *)"";
4644 rettv->vval.v_string = vim_strsave(p);
4645 }
4646 else
4647 {
4648 if (end < start)
4649 return;
4650
4651 if (start < 1)
4652 start = 1;
4653 if (end > buf->b_ml.ml_line_count)
4654 end = buf->b_ml.ml_line_count;
4655 while (start <= end)
4656 if (list_append_string(rettv->vval.v_list,
4657 ml_get_buf(buf, start++, FALSE), -1) == FAIL)
4658 break;
4659 }
4660}
4661
4662/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004663 * "getbufline()" function
4664 */
4665 static void
4666f_getbufline(typval_T *argvars, typval_T *rettv)
4667{
4668 linenr_T lnum;
4669 linenr_T end;
4670 buf_T *buf;
4671
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004672 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004673 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01004674 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004675 --emsg_off;
4676
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004677 lnum = tv_get_lnum_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004678 if (argvars[2].v_type == VAR_UNKNOWN)
4679 end = lnum;
4680 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004681 end = tv_get_lnum_buf(&argvars[2], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004682
4683 get_buffer_lines(buf, lnum, end, TRUE, rettv);
4684}
4685
4686/*
4687 * "getbufvar()" function
4688 */
4689 static void
4690f_getbufvar(typval_T *argvars, typval_T *rettv)
4691{
4692 buf_T *buf;
4693 buf_T *save_curbuf;
4694 char_u *varname;
4695 dictitem_T *v;
4696 int done = FALSE;
4697
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004698 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
4699 varname = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004700 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01004701 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004702
4703 rettv->v_type = VAR_STRING;
4704 rettv->vval.v_string = NULL;
4705
4706 if (buf != NULL && varname != NULL)
4707 {
4708 /* set curbuf to be our buf, temporarily */
4709 save_curbuf = curbuf;
4710 curbuf = buf;
4711
Bram Moolenaar30567352016-08-27 21:25:44 +02004712 if (*varname == '&')
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004713 {
Bram Moolenaar30567352016-08-27 21:25:44 +02004714 if (varname[1] == NUL)
4715 {
4716 /* get all buffer-local options in a dict */
4717 dict_T *opts = get_winbuf_options(TRUE);
4718
4719 if (opts != NULL)
4720 {
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004721 rettv_dict_set(rettv, opts);
Bram Moolenaar30567352016-08-27 21:25:44 +02004722 done = TRUE;
4723 }
4724 }
4725 else if (get_option_tv(&varname, rettv, TRUE) == OK)
4726 /* buffer-local-option */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004727 done = TRUE;
4728 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004729 else
4730 {
4731 /* Look up the variable. */
4732 /* Let getbufvar({nr}, "") return the "b:" dictionary. */
4733 v = find_var_in_ht(&curbuf->b_vars->dv_hashtab,
4734 'b', varname, FALSE);
4735 if (v != NULL)
4736 {
4737 copy_tv(&v->di_tv, rettv);
4738 done = TRUE;
4739 }
4740 }
4741
4742 /* restore previous notion of curbuf */
4743 curbuf = save_curbuf;
4744 }
4745
4746 if (!done && argvars[2].v_type != VAR_UNKNOWN)
4747 /* use the default value */
4748 copy_tv(&argvars[2], rettv);
4749
4750 --emsg_off;
4751}
4752
4753/*
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004754 * "getchangelist()" function
4755 */
4756 static void
4757f_getchangelist(typval_T *argvars, typval_T *rettv)
4758{
4759#ifdef FEAT_JUMPLIST
4760 buf_T *buf;
4761 int i;
4762 list_T *l;
4763 dict_T *d;
4764#endif
4765
4766 if (rettv_list_alloc(rettv) != OK)
4767 return;
4768
4769#ifdef FEAT_JUMPLIST
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004770 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
Bram Moolenaar341a64c2018-02-13 19:21:17 +01004771 ++emsg_off;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01004772 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar341a64c2018-02-13 19:21:17 +01004773 --emsg_off;
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004774 if (buf == NULL)
4775 return;
4776
4777 l = list_alloc();
4778 if (l == NULL)
4779 return;
4780
4781 if (list_append_list(rettv->vval.v_list, l) == FAIL)
4782 return;
4783 /*
4784 * The current window change list index tracks only the position in the
4785 * current buffer change list. For other buffers, use the change list
4786 * length as the current index.
4787 */
4788 list_append_number(rettv->vval.v_list,
4789 (varnumber_T)((buf == curwin->w_buffer)
4790 ? curwin->w_changelistidx : buf->b_changelistlen));
4791
4792 for (i = 0; i < buf->b_changelistlen; ++i)
4793 {
4794 if (buf->b_changelist[i].lnum == 0)
4795 continue;
4796 if ((d = dict_alloc()) == NULL)
4797 return;
4798 if (list_append_dict(l, d) == FAIL)
4799 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02004800 dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum);
4801 dict_add_number(d, "col", (long)buf->b_changelist[i].col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02004802 dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd);
Bram Moolenaar07ad8162018-02-13 13:59:59 +01004803 }
4804#endif
4805}
4806/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004807 * "getchar()" function
4808 */
4809 static void
4810f_getchar(typval_T *argvars, typval_T *rettv)
4811{
4812 varnumber_T n;
4813 int error = FALSE;
Bram Moolenaarf0fab302019-03-05 12:24:10 +01004814 int save_reg_executing = reg_executing;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004815
Bram Moolenaar84d93902018-09-11 20:10:20 +02004816#ifdef MESSAGE_QUEUE
4817 // vpeekc() used to check for messages, but that caused problems, invoking
4818 // a callback where it was not expected. Some plugins use getchar(1) in a
4819 // loop to await a message, therefore make sure we check for messages here.
4820 parse_queued_messages();
4821#endif
4822
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004823 /* Position the cursor. Needed after a message that ends in a space. */
4824 windgoto(msg_row, msg_col);
4825
4826 ++no_mapping;
4827 ++allow_keys;
4828 for (;;)
4829 {
4830 if (argvars[0].v_type == VAR_UNKNOWN)
4831 /* getchar(): blocking wait. */
Bram Moolenaarec2da362017-01-21 20:04:22 +01004832 n = plain_vgetc();
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004833 else if (tv_get_number_chk(&argvars[0], &error) == 1)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004834 /* getchar(1): only check if char avail */
4835 n = vpeekc_any();
4836 else if (error || vpeekc_any() == NUL)
4837 /* illegal argument or getchar(0) and no char avail: return zero */
4838 n = 0;
4839 else
4840 /* getchar(0) and char avail: return char */
Bram Moolenaarec2da362017-01-21 20:04:22 +01004841 n = plain_vgetc();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004842
4843 if (n == K_IGNORE)
4844 continue;
4845 break;
4846 }
4847 --no_mapping;
4848 --allow_keys;
Bram Moolenaarf0fab302019-03-05 12:24:10 +01004849 reg_executing = save_reg_executing;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004850
4851 set_vim_var_nr(VV_MOUSE_WIN, 0);
4852 set_vim_var_nr(VV_MOUSE_WINID, 0);
4853 set_vim_var_nr(VV_MOUSE_LNUM, 0);
4854 set_vim_var_nr(VV_MOUSE_COL, 0);
4855
4856 rettv->vval.v_number = n;
4857 if (IS_SPECIAL(n) || mod_mask != 0)
4858 {
4859 char_u temp[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */
4860 int i = 0;
4861
4862 /* Turn a special key into three bytes, plus modifier. */
4863 if (mod_mask != 0)
4864 {
4865 temp[i++] = K_SPECIAL;
4866 temp[i++] = KS_MODIFIER;
4867 temp[i++] = mod_mask;
4868 }
4869 if (IS_SPECIAL(n))
4870 {
4871 temp[i++] = K_SPECIAL;
4872 temp[i++] = K_SECOND(n);
4873 temp[i++] = K_THIRD(n);
4874 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004875 else if (has_mbyte)
4876 i += (*mb_char2bytes)(n, temp + i);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004877 else
4878 temp[i++] = n;
4879 temp[i++] = NUL;
4880 rettv->v_type = VAR_STRING;
4881 rettv->vval.v_string = vim_strsave(temp);
4882
4883#ifdef FEAT_MOUSE
4884 if (is_mouse_key(n))
4885 {
4886 int row = mouse_row;
4887 int col = mouse_col;
4888 win_T *win;
4889 linenr_T lnum;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004890 win_T *wp;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004891 int winnr = 1;
4892
4893 if (row >= 0 && col >= 0)
4894 {
4895 /* Find the window at the mouse coordinates and compute the
4896 * text position. */
4897 win = mouse_find_win(&row, &col);
Bram Moolenaar989a70c2017-08-16 22:46:01 +02004898 if (win == NULL)
4899 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004900 (void)mouse_comp_pos(win, &row, &col, &lnum);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004901 for (wp = firstwin; wp != win; wp = wp->w_next)
4902 ++winnr;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004903 set_vim_var_nr(VV_MOUSE_WIN, winnr);
4904 set_vim_var_nr(VV_MOUSE_WINID, win->w_id);
4905 set_vim_var_nr(VV_MOUSE_LNUM, lnum);
4906 set_vim_var_nr(VV_MOUSE_COL, col + 1);
4907 }
4908 }
4909#endif
4910 }
4911}
4912
4913/*
4914 * "getcharmod()" function
4915 */
4916 static void
4917f_getcharmod(typval_T *argvars UNUSED, typval_T *rettv)
4918{
4919 rettv->vval.v_number = mod_mask;
4920}
4921
4922/*
4923 * "getcharsearch()" function
4924 */
4925 static void
4926f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv)
4927{
4928 if (rettv_dict_alloc(rettv) != FAIL)
4929 {
4930 dict_T *dict = rettv->vval.v_dict;
4931
Bram Moolenaare0be1672018-07-08 16:50:37 +02004932 dict_add_string(dict, "char", last_csearch());
4933 dict_add_number(dict, "forward", last_csearch_forward());
4934 dict_add_number(dict, "until", last_csearch_until());
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004935 }
4936}
4937
4938/*
4939 * "getcmdline()" function
4940 */
4941 static void
4942f_getcmdline(typval_T *argvars UNUSED, typval_T *rettv)
4943{
4944 rettv->v_type = VAR_STRING;
4945 rettv->vval.v_string = get_cmdline_str();
4946}
4947
4948/*
4949 * "getcmdpos()" function
4950 */
4951 static void
4952f_getcmdpos(typval_T *argvars UNUSED, typval_T *rettv)
4953{
4954 rettv->vval.v_number = get_cmdline_pos() + 1;
4955}
4956
4957/*
4958 * "getcmdtype()" function
4959 */
4960 static void
4961f_getcmdtype(typval_T *argvars UNUSED, typval_T *rettv)
4962{
4963 rettv->v_type = VAR_STRING;
4964 rettv->vval.v_string = alloc(2);
4965 if (rettv->vval.v_string != NULL)
4966 {
4967 rettv->vval.v_string[0] = get_cmdline_type();
4968 rettv->vval.v_string[1] = NUL;
4969 }
4970}
4971
4972/*
4973 * "getcmdwintype()" function
4974 */
4975 static void
4976f_getcmdwintype(typval_T *argvars UNUSED, typval_T *rettv)
4977{
4978 rettv->v_type = VAR_STRING;
4979 rettv->vval.v_string = NULL;
4980#ifdef FEAT_CMDWIN
4981 rettv->vval.v_string = alloc(2);
4982 if (rettv->vval.v_string != NULL)
4983 {
4984 rettv->vval.v_string[0] = cmdwin_type;
4985 rettv->vval.v_string[1] = NUL;
4986 }
4987#endif
4988}
4989
4990#if defined(FEAT_CMDL_COMPL)
4991/*
4992 * "getcompletion()" function
4993 */
4994 static void
4995f_getcompletion(typval_T *argvars, typval_T *rettv)
4996{
4997 char_u *pat;
4998 expand_T xpc;
Bram Moolenaare9d58a62016-08-13 15:07:41 +02004999 int filtered = FALSE;
Bram Moolenaarb56195e2016-07-28 22:53:37 +02005000 int options = WILD_SILENT | WILD_USE_NL | WILD_ADD_SLASH
5001 | WILD_NO_BEEP;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005002
Bram Moolenaare9d58a62016-08-13 15:07:41 +02005003 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005004 filtered = tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaare9d58a62016-08-13 15:07:41 +02005005
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005006 if (p_wic)
5007 options |= WILD_ICASE;
5008
Bram Moolenaare9d58a62016-08-13 15:07:41 +02005009 /* For filtered results, 'wildignore' is used */
5010 if (!filtered)
5011 options |= WILD_KEEP_ALL;
5012
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005013 ExpandInit(&xpc);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005014 xpc.xp_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005015 xpc.xp_pattern_len = (int)STRLEN(xpc.xp_pattern);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005016 xpc.xp_context = cmdcomplete_str_to_type(tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005017 if (xpc.xp_context == EXPAND_NOTHING)
5018 {
5019 if (argvars[1].v_type == VAR_STRING)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005020 semsg(_(e_invarg2), argvars[1].vval.v_string);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005021 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005022 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005023 return;
5024 }
5025
5026# if defined(FEAT_MENU)
5027 if (xpc.xp_context == EXPAND_MENUS)
5028 {
5029 set_context_in_menu_cmd(&xpc, (char_u *)"menu", xpc.xp_pattern, FALSE);
5030 xpc.xp_pattern_len = (int)STRLEN(xpc.xp_pattern);
5031 }
5032# endif
Bram Moolenaarb650b982016-08-05 20:35:13 +02005033#ifdef FEAT_CSCOPE
5034 if (xpc.xp_context == EXPAND_CSCOPE)
5035 {
5036 set_context_in_cscope_cmd(&xpc, xpc.xp_pattern, CMD_cscope);
5037 xpc.xp_pattern_len = (int)STRLEN(xpc.xp_pattern);
5038 }
5039#endif
Bram Moolenaar7522f692016-08-06 14:12:50 +02005040#ifdef FEAT_SIGNS
5041 if (xpc.xp_context == EXPAND_SIGN)
5042 {
5043 set_context_in_sign_cmd(&xpc, xpc.xp_pattern);
5044 xpc.xp_pattern_len = (int)STRLEN(xpc.xp_pattern);
5045 }
5046#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005047
5048 pat = addstar(xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
5049 if ((rettv_list_alloc(rettv) != FAIL) && (pat != NULL))
5050 {
Bram Moolenaarb56195e2016-07-28 22:53:37 +02005051 int i;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005052
5053 ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
5054
5055 for (i = 0; i < xpc.xp_numfiles; i++)
5056 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
5057 }
5058 vim_free(pat);
5059 ExpandCleanup(&xpc);
5060}
5061#endif
5062
5063/*
5064 * "getcwd()" function
5065 */
5066 static void
5067f_getcwd(typval_T *argvars, typval_T *rettv)
5068{
5069 win_T *wp = NULL;
5070 char_u *cwd;
Bram Moolenaar54591292018-02-09 20:53:59 +01005071 int global = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005072
5073 rettv->v_type = VAR_STRING;
5074 rettv->vval.v_string = NULL;
5075
Bram Moolenaar54591292018-02-09 20:53:59 +01005076 if (argvars[0].v_type == VAR_NUMBER && argvars[0].vval.v_number == -1)
5077 global = TRUE;
5078 else
5079 wp = find_tabwin(&argvars[0], &argvars[1]);
5080
5081 if (wp != NULL && wp->w_localdir != NULL)
5082 rettv->vval.v_string = vim_strsave(wp->w_localdir);
5083 else if (wp != NULL || global)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005084 {
Bram Moolenaar54591292018-02-09 20:53:59 +01005085 if (globaldir != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005086 rettv->vval.v_string = vim_strsave(globaldir);
5087 else
5088 {
5089 cwd = alloc(MAXPATHL);
5090 if (cwd != NULL)
5091 {
5092 if (mch_dirname(cwd, MAXPATHL) != FAIL)
5093 rettv->vval.v_string = vim_strsave(cwd);
5094 vim_free(cwd);
5095 }
5096 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005097 }
Bram Moolenaar3c5b8cd2018-09-02 14:25:05 +02005098#ifdef BACKSLASH_IN_FILENAME
5099 if (rettv->vval.v_string != NULL)
5100 slash_adjust(rettv->vval.v_string);
5101#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005102}
5103
5104/*
5105 * "getfontname()" function
5106 */
5107 static void
5108f_getfontname(typval_T *argvars UNUSED, typval_T *rettv)
5109{
5110 rettv->v_type = VAR_STRING;
5111 rettv->vval.v_string = NULL;
5112#ifdef FEAT_GUI
5113 if (gui.in_use)
5114 {
5115 GuiFont font;
5116 char_u *name = NULL;
5117
5118 if (argvars[0].v_type == VAR_UNKNOWN)
5119 {
5120 /* Get the "Normal" font. Either the name saved by
5121 * hl_set_font_name() or from the font ID. */
5122 font = gui.norm_font;
5123 name = hl_get_font_name();
5124 }
5125 else
5126 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005127 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005128 if (STRCMP(name, "*") == 0) /* don't use font dialog */
5129 return;
5130 font = gui_mch_get_font(name, FALSE);
5131 if (font == NOFONT)
5132 return; /* Invalid font name, return empty string. */
5133 }
5134 rettv->vval.v_string = gui_mch_get_fontname(font, name);
5135 if (argvars[0].v_type != VAR_UNKNOWN)
5136 gui_mch_free_font(font);
5137 }
5138#endif
5139}
5140
5141/*
5142 * "getfperm({fname})" function
5143 */
5144 static void
5145f_getfperm(typval_T *argvars, typval_T *rettv)
5146{
5147 char_u *fname;
5148 stat_T st;
5149 char_u *perm = NULL;
5150 char_u flags[] = "rwx";
5151 int i;
5152
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005153 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005154
5155 rettv->v_type = VAR_STRING;
5156 if (mch_stat((char *)fname, &st) >= 0)
5157 {
5158 perm = vim_strsave((char_u *)"---------");
5159 if (perm != NULL)
5160 {
5161 for (i = 0; i < 9; i++)
5162 {
5163 if (st.st_mode & (1 << (8 - i)))
5164 perm[i] = flags[i % 3];
5165 }
5166 }
5167 }
5168 rettv->vval.v_string = perm;
5169}
5170
5171/*
5172 * "getfsize({fname})" function
5173 */
5174 static void
5175f_getfsize(typval_T *argvars, typval_T *rettv)
5176{
5177 char_u *fname;
5178 stat_T st;
5179
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005180 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005181
5182 rettv->v_type = VAR_NUMBER;
5183
5184 if (mch_stat((char *)fname, &st) >= 0)
5185 {
5186 if (mch_isdir(fname))
5187 rettv->vval.v_number = 0;
5188 else
5189 {
5190 rettv->vval.v_number = (varnumber_T)st.st_size;
5191
5192 /* non-perfect check for overflow */
5193 if ((off_T)rettv->vval.v_number != (off_T)st.st_size)
5194 rettv->vval.v_number = -2;
5195 }
5196 }
5197 else
5198 rettv->vval.v_number = -1;
5199}
5200
5201/*
5202 * "getftime({fname})" function
5203 */
5204 static void
5205f_getftime(typval_T *argvars, typval_T *rettv)
5206{
5207 char_u *fname;
5208 stat_T st;
5209
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005210 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005211
5212 if (mch_stat((char *)fname, &st) >= 0)
5213 rettv->vval.v_number = (varnumber_T)st.st_mtime;
5214 else
5215 rettv->vval.v_number = -1;
5216}
5217
5218/*
5219 * "getftype({fname})" function
5220 */
5221 static void
5222f_getftype(typval_T *argvars, typval_T *rettv)
5223{
5224 char_u *fname;
5225 stat_T st;
5226 char_u *type = NULL;
5227 char *t;
5228
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005229 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005230
5231 rettv->v_type = VAR_STRING;
5232 if (mch_lstat((char *)fname, &st) >= 0)
5233 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005234 if (S_ISREG(st.st_mode))
5235 t = "file";
5236 else if (S_ISDIR(st.st_mode))
5237 t = "dir";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005238 else if (S_ISLNK(st.st_mode))
5239 t = "link";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005240 else if (S_ISBLK(st.st_mode))
5241 t = "bdev";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005242 else if (S_ISCHR(st.st_mode))
5243 t = "cdev";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005244 else if (S_ISFIFO(st.st_mode))
5245 t = "fifo";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005246 else if (S_ISSOCK(st.st_mode))
Bram Moolenaar1598f992018-08-09 22:08:57 +02005247 t = "socket";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005248 else
5249 t = "other";
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005250 type = vim_strsave((char_u *)t);
5251 }
5252 rettv->vval.v_string = type;
5253}
5254
5255/*
Bram Moolenaar4f505882018-02-10 21:06:32 +01005256 * "getjumplist()" function
5257 */
5258 static void
5259f_getjumplist(typval_T *argvars, typval_T *rettv)
5260{
5261#ifdef FEAT_JUMPLIST
5262 win_T *wp;
5263 int i;
5264 list_T *l;
5265 dict_T *d;
5266#endif
5267
5268 if (rettv_list_alloc(rettv) != OK)
5269 return;
5270
5271#ifdef FEAT_JUMPLIST
5272 wp = find_tabwin(&argvars[0], &argvars[1]);
5273 if (wp == NULL)
5274 return;
5275
Bram Moolenaar57ee2b62019-02-12 22:15:06 +01005276 cleanup_jumplist(wp, TRUE);
5277
Bram Moolenaar4f505882018-02-10 21:06:32 +01005278 l = list_alloc();
5279 if (l == NULL)
5280 return;
5281
5282 if (list_append_list(rettv->vval.v_list, l) == FAIL)
5283 return;
5284 list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx);
5285
5286 for (i = 0; i < wp->w_jumplistlen; ++i)
5287 {
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005288 if (wp->w_jumplist[i].fmark.mark.lnum == 0)
5289 continue;
Bram Moolenaar4f505882018-02-10 21:06:32 +01005290 if ((d = dict_alloc()) == NULL)
5291 return;
5292 if (list_append_dict(l, d) == FAIL)
5293 return;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005294 dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum);
5295 dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005296 dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005297 dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum);
Bram Moolenaara7e18d22018-02-11 14:29:49 +01005298 if (wp->w_jumplist[i].fname != NULL)
Bram Moolenaare0be1672018-07-08 16:50:37 +02005299 dict_add_string(d, "filename", wp->w_jumplist[i].fname);
Bram Moolenaar4f505882018-02-10 21:06:32 +01005300 }
5301#endif
5302}
5303
5304/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005305 * "getline(lnum, [end])" function
5306 */
5307 static void
5308f_getline(typval_T *argvars, typval_T *rettv)
5309{
5310 linenr_T lnum;
5311 linenr_T end;
5312 int retlist;
5313
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005314 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005315 if (argvars[1].v_type == VAR_UNKNOWN)
5316 {
5317 end = 0;
5318 retlist = FALSE;
5319 }
5320 else
5321 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005322 end = tv_get_lnum(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005323 retlist = TRUE;
5324 }
5325
5326 get_buffer_lines(curbuf, lnum, end, retlist, rettv);
5327}
5328
Bram Moolenaar4ae20952016-08-13 15:29:14 +02005329#ifdef FEAT_QUICKFIX
Bram Moolenaard823fa92016-08-12 16:29:27 +02005330 static void
5331get_qf_loc_list(int is_qf, win_T *wp, typval_T *what_arg, typval_T *rettv)
5332{
Bram Moolenaard823fa92016-08-12 16:29:27 +02005333 if (what_arg->v_type == VAR_UNKNOWN)
5334 {
5335 if (rettv_list_alloc(rettv) == OK)
5336 if (is_qf || wp != NULL)
Bram Moolenaar7adf06f2017-08-27 15:23:41 +02005337 (void)get_errorlist(NULL, wp, -1, rettv->vval.v_list);
Bram Moolenaard823fa92016-08-12 16:29:27 +02005338 }
5339 else
5340 {
5341 if (rettv_dict_alloc(rettv) == OK)
5342 if (is_qf || (wp != NULL))
5343 {
5344 if (what_arg->v_type == VAR_DICT)
5345 {
5346 dict_T *d = what_arg->vval.v_dict;
5347
5348 if (d != NULL)
Bram Moolenaarb4d5fba2017-09-11 19:31:28 +02005349 qf_get_properties(wp, d, rettv->vval.v_dict);
Bram Moolenaard823fa92016-08-12 16:29:27 +02005350 }
5351 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005352 emsg(_(e_dictreq));
Bram Moolenaard823fa92016-08-12 16:29:27 +02005353 }
5354 }
Bram Moolenaard823fa92016-08-12 16:29:27 +02005355}
Bram Moolenaar4ae20952016-08-13 15:29:14 +02005356#endif
Bram Moolenaard823fa92016-08-12 16:29:27 +02005357
5358/*
5359 * "getloclist()" function
5360 */
5361 static void
5362f_getloclist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
5363{
5364#ifdef FEAT_QUICKFIX
5365 win_T *wp;
5366
Bram Moolenaarbabfcf52018-10-25 13:11:16 +02005367 wp = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaard823fa92016-08-12 16:29:27 +02005368 get_qf_loc_list(FALSE, wp, &argvars[1], rettv);
5369#endif
5370}
5371
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005372/*
5373 * "getmatches()" function
5374 */
5375 static void
5376f_getmatches(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
5377{
5378#ifdef FEAT_SEARCH_EXTRA
5379 dict_T *dict;
5380 matchitem_T *cur = curwin->w_match_head;
5381 int i;
5382
5383 if (rettv_list_alloc(rettv) == OK)
5384 {
5385 while (cur != NULL)
5386 {
5387 dict = dict_alloc();
5388 if (dict == NULL)
5389 return;
5390 if (cur->match.regprog == NULL)
5391 {
5392 /* match added with matchaddpos() */
5393 for (i = 0; i < MAXPOSMATCH; ++i)
5394 {
5395 llpos_T *llpos;
5396 char buf[6];
5397 list_T *l;
5398
5399 llpos = &cur->pos.pos[i];
5400 if (llpos->lnum == 0)
5401 break;
5402 l = list_alloc();
5403 if (l == NULL)
5404 break;
5405 list_append_number(l, (varnumber_T)llpos->lnum);
5406 if (llpos->col > 0)
5407 {
5408 list_append_number(l, (varnumber_T)llpos->col);
5409 list_append_number(l, (varnumber_T)llpos->len);
5410 }
5411 sprintf(buf, "pos%d", i + 1);
5412 dict_add_list(dict, buf, l);
5413 }
5414 }
5415 else
5416 {
Bram Moolenaare0be1672018-07-08 16:50:37 +02005417 dict_add_string(dict, "pattern", cur->pattern);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005418 }
Bram Moolenaare0be1672018-07-08 16:50:37 +02005419 dict_add_string(dict, "group", syn_id2name(cur->hlg_id));
5420 dict_add_number(dict, "priority", (long)cur->priority);
5421 dict_add_number(dict, "id", (long)cur->id);
Bram Moolenaar13505972019-01-24 15:04:48 +01005422# if defined(FEAT_CONCEAL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005423 if (cur->conceal_char)
5424 {
5425 char_u buf[MB_MAXBYTES + 1];
5426
5427 buf[(*mb_char2bytes)((int)cur->conceal_char, buf)] = NUL;
Bram Moolenaare0be1672018-07-08 16:50:37 +02005428 dict_add_string(dict, "conceal", (char_u *)&buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005429 }
5430# endif
5431 list_append_dict(rettv->vval.v_list, dict);
5432 cur = cur->next;
5433 }
5434 }
5435#endif
5436}
5437
5438/*
5439 * "getpid()" function
5440 */
5441 static void
5442f_getpid(typval_T *argvars UNUSED, typval_T *rettv)
5443{
5444 rettv->vval.v_number = mch_get_pid();
5445}
5446
5447 static void
5448getpos_both(
5449 typval_T *argvars,
5450 typval_T *rettv,
5451 int getcurpos)
5452{
5453 pos_T *fp;
5454 list_T *l;
5455 int fnum = -1;
5456
5457 if (rettv_list_alloc(rettv) == OK)
5458 {
5459 l = rettv->vval.v_list;
5460 if (getcurpos)
5461 fp = &curwin->w_cursor;
5462 else
5463 fp = var2fpos(&argvars[0], TRUE, &fnum);
5464 if (fnum != -1)
5465 list_append_number(l, (varnumber_T)fnum);
5466 else
5467 list_append_number(l, (varnumber_T)0);
5468 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum
5469 : (varnumber_T)0);
5470 list_append_number(l, (fp != NULL)
5471 ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1)
5472 : (varnumber_T)0);
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01005473 list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd :
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005474 (varnumber_T)0);
5475 if (getcurpos)
5476 {
Bram Moolenaar19a66852019-03-07 11:25:32 +01005477 int save_set_curswant = curwin->w_set_curswant;
5478 colnr_T save_curswant = curwin->w_curswant;
5479 colnr_T save_virtcol = curwin->w_virtcol;
5480
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005481 update_curswant();
5482 list_append_number(l, curwin->w_curswant == MAXCOL ?
5483 (varnumber_T)MAXCOL : (varnumber_T)curwin->w_curswant + 1);
Bram Moolenaar19a66852019-03-07 11:25:32 +01005484
5485 // Do not change "curswant", as it is unexpected that a get
5486 // function has a side effect.
5487 if (save_set_curswant)
5488 {
5489 curwin->w_set_curswant = save_set_curswant;
5490 curwin->w_curswant = save_curswant;
5491 curwin->w_virtcol = save_virtcol;
5492 curwin->w_valid &= ~VALID_VIRTCOL;
5493 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005494 }
5495 }
5496 else
5497 rettv->vval.v_number = FALSE;
5498}
5499
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005500/*
5501 * "getcurpos()" function
5502 */
5503 static void
5504f_getcurpos(typval_T *argvars, typval_T *rettv)
5505{
5506 getpos_both(argvars, rettv, TRUE);
5507}
5508
5509/*
5510 * "getpos(string)" function
5511 */
5512 static void
5513f_getpos(typval_T *argvars, typval_T *rettv)
5514{
5515 getpos_both(argvars, rettv, FALSE);
5516}
5517
5518/*
Bram Moolenaard823fa92016-08-12 16:29:27 +02005519 * "getqflist()" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005520 */
5521 static void
5522f_getqflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
5523{
5524#ifdef FEAT_QUICKFIX
Bram Moolenaard823fa92016-08-12 16:29:27 +02005525 get_qf_loc_list(TRUE, NULL, &argvars[0], rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005526#endif
5527}
5528
5529/*
5530 * "getreg()" function
5531 */
5532 static void
5533f_getreg(typval_T *argvars, typval_T *rettv)
5534{
5535 char_u *strregname;
5536 int regname;
5537 int arg2 = FALSE;
5538 int return_list = FALSE;
5539 int error = FALSE;
5540
5541 if (argvars[0].v_type != VAR_UNKNOWN)
5542 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005543 strregname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005544 error = strregname == NULL;
5545 if (argvars[1].v_type != VAR_UNKNOWN)
5546 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005547 arg2 = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005548 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005549 return_list = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005550 }
5551 }
5552 else
5553 strregname = get_vim_var_str(VV_REG);
5554
5555 if (error)
5556 return;
5557
5558 regname = (strregname == NULL ? '"' : *strregname);
5559 if (regname == 0)
5560 regname = '"';
5561
5562 if (return_list)
5563 {
5564 rettv->v_type = VAR_LIST;
5565 rettv->vval.v_list = (list_T *)get_reg_contents(regname,
5566 (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST);
5567 if (rettv->vval.v_list == NULL)
5568 (void)rettv_list_alloc(rettv);
5569 else
5570 ++rettv->vval.v_list->lv_refcount;
5571 }
5572 else
5573 {
5574 rettv->v_type = VAR_STRING;
5575 rettv->vval.v_string = get_reg_contents(regname,
5576 arg2 ? GREG_EXPR_SRC : 0);
5577 }
5578}
5579
5580/*
5581 * "getregtype()" function
5582 */
5583 static void
5584f_getregtype(typval_T *argvars, typval_T *rettv)
5585{
5586 char_u *strregname;
5587 int regname;
5588 char_u buf[NUMBUFLEN + 2];
5589 long reglen = 0;
5590
5591 if (argvars[0].v_type != VAR_UNKNOWN)
5592 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005593 strregname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005594 if (strregname == NULL) /* type error; errmsg already given */
5595 {
5596 rettv->v_type = VAR_STRING;
5597 rettv->vval.v_string = NULL;
5598 return;
5599 }
5600 }
5601 else
5602 /* Default to v:register */
5603 strregname = get_vim_var_str(VV_REG);
5604
5605 regname = (strregname == NULL ? '"' : *strregname);
5606 if (regname == 0)
5607 regname = '"';
5608
5609 buf[0] = NUL;
5610 buf[1] = NUL;
5611 switch (get_reg_type(regname, &reglen))
5612 {
5613 case MLINE: buf[0] = 'V'; break;
5614 case MCHAR: buf[0] = 'v'; break;
5615 case MBLOCK:
5616 buf[0] = Ctrl_V;
5617 sprintf((char *)buf + 1, "%ld", reglen + 1);
5618 break;
5619 }
5620 rettv->v_type = VAR_STRING;
5621 rettv->vval.v_string = vim_strsave(buf);
5622}
5623
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005624/*
5625 * Returns information (variables, options, etc.) about a tab page
5626 * as a dictionary.
5627 */
5628 static dict_T *
5629get_tabpage_info(tabpage_T *tp, int tp_idx)
5630{
5631 win_T *wp;
5632 dict_T *dict;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005633 list_T *l;
5634
5635 dict = dict_alloc();
5636 if (dict == NULL)
5637 return NULL;
5638
Bram Moolenaare0be1672018-07-08 16:50:37 +02005639 dict_add_number(dict, "tabnr", tp_idx);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005640
5641 l = list_alloc();
5642 if (l != NULL)
5643 {
5644 for (wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
5645 wp; wp = wp->w_next)
5646 list_append_number(l, (varnumber_T)wp->w_id);
5647 dict_add_list(dict, "windows", l);
5648 }
5649
Bram Moolenaar9f8187c2016-08-27 20:34:01 +02005650 /* Make a reference to tabpage variables */
5651 dict_add_dict(dict, "variables", tp->tp_vars);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005652
5653 return dict;
5654}
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005655
5656/*
5657 * "gettabinfo()" function
5658 */
5659 static void
5660f_gettabinfo(typval_T *argvars, typval_T *rettv)
5661{
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005662 tabpage_T *tp, *tparg = NULL;
5663 dict_T *d;
Bram Moolenaar386600f2016-08-15 22:16:25 +02005664 int tpnr = 0;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005665
5666 if (rettv_list_alloc(rettv) != OK)
5667 return;
5668
5669 if (argvars[0].v_type != VAR_UNKNOWN)
5670 {
5671 /* Information about one tab page */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005672 tparg = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005673 if (tparg == NULL)
5674 return;
5675 }
5676
5677 /* Get information about a specific tab page or all tab pages */
Bram Moolenaar386600f2016-08-15 22:16:25 +02005678 FOR_ALL_TABPAGES(tp)
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005679 {
Bram Moolenaar386600f2016-08-15 22:16:25 +02005680 tpnr++;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005681 if (tparg != NULL && tp != tparg)
5682 continue;
5683 d = get_tabpage_info(tp, tpnr);
5684 if (d != NULL)
5685 list_append_dict(rettv->vval.v_list, d);
5686 if (tparg != NULL)
5687 return;
5688 }
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005689}
5690
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005691/*
5692 * "gettabvar()" function
5693 */
5694 static void
5695f_gettabvar(typval_T *argvars, typval_T *rettv)
5696{
5697 win_T *oldcurwin;
5698 tabpage_T *tp, *oldtabpage;
5699 dictitem_T *v;
5700 char_u *varname;
5701 int done = FALSE;
5702
5703 rettv->v_type = VAR_STRING;
5704 rettv->vval.v_string = NULL;
5705
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005706 varname = tv_get_string_chk(&argvars[1]);
5707 tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005708 if (tp != NULL && varname != NULL)
5709 {
5710 /* Set tp to be our tabpage, temporarily. Also set the window to the
5711 * first window in the tabpage, otherwise the window is not valid. */
5712 if (switch_win(&oldcurwin, &oldtabpage,
Bram Moolenaar816968d2017-09-29 21:29:18 +02005713 tp == curtab || tp->tp_firstwin == NULL ? firstwin
5714 : tp->tp_firstwin, tp, TRUE) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005715 {
5716 /* look up the variable */
5717 /* Let gettabvar({nr}, "") return the "t:" dictionary. */
5718 v = find_var_in_ht(&tp->tp_vars->dv_hashtab, 't', varname, FALSE);
5719 if (v != NULL)
5720 {
5721 copy_tv(&v->di_tv, rettv);
5722 done = TRUE;
5723 }
5724 }
5725
5726 /* restore previous notion of curwin */
5727 restore_win(oldcurwin, oldtabpage, TRUE);
5728 }
5729
5730 if (!done && argvars[2].v_type != VAR_UNKNOWN)
5731 copy_tv(&argvars[2], rettv);
5732}
5733
5734/*
5735 * "gettabwinvar()" function
5736 */
5737 static void
5738f_gettabwinvar(typval_T *argvars, typval_T *rettv)
5739{
5740 getwinvar(argvars, rettv, 1);
5741}
5742
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005743/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +01005744 * "gettagstack()" function
5745 */
5746 static void
5747f_gettagstack(typval_T *argvars, typval_T *rettv)
5748{
5749 win_T *wp = curwin; // default is current window
5750
5751 if (rettv_dict_alloc(rettv) != OK)
5752 return;
5753
5754 if (argvars[0].v_type != VAR_UNKNOWN)
5755 {
5756 wp = find_win_by_nr_or_id(&argvars[0]);
5757 if (wp == NULL)
5758 return;
5759 }
5760
5761 get_tagstack(wp, rettv->vval.v_dict);
5762}
5763
5764/*
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005765 * Returns information about a window as a dictionary.
5766 */
5767 static dict_T *
5768get_win_info(win_T *wp, short tpnr, short winnr)
5769{
5770 dict_T *dict;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005771
5772 dict = dict_alloc();
5773 if (dict == NULL)
5774 return NULL;
5775
Bram Moolenaare0be1672018-07-08 16:50:37 +02005776 dict_add_number(dict, "tabnr", tpnr);
5777 dict_add_number(dict, "winnr", winnr);
5778 dict_add_number(dict, "winid", wp->w_id);
5779 dict_add_number(dict, "height", wp->w_height);
Bram Moolenaar7132ddc2018-07-15 17:01:11 +02005780 dict_add_number(dict, "winrow", wp->w_winrow + 1);
Bram Moolenaar8fcb60f2019-03-04 13:18:30 +01005781 dict_add_number(dict, "topline", wp->w_topline);
5782 dict_add_number(dict, "botline", wp->w_botline - 1);
Bram Moolenaar1b9645d2017-09-17 23:03:31 +02005783#ifdef FEAT_MENU
Bram Moolenaare0be1672018-07-08 16:50:37 +02005784 dict_add_number(dict, "winbar", wp->w_winbar_height);
Bram Moolenaar1b9645d2017-09-17 23:03:31 +02005785#endif
Bram Moolenaare0be1672018-07-08 16:50:37 +02005786 dict_add_number(dict, "width", wp->w_width);
Bram Moolenaar7132ddc2018-07-15 17:01:11 +02005787 dict_add_number(dict, "wincol", wp->w_wincol + 1);
Bram Moolenaare0be1672018-07-08 16:50:37 +02005788 dict_add_number(dict, "bufnr", wp->w_buffer->b_fnum);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005789
Bram Moolenaar69905d12017-08-13 18:14:47 +02005790#ifdef FEAT_TERMINAL
Bram Moolenaare0be1672018-07-08 16:50:37 +02005791 dict_add_number(dict, "terminal", bt_terminal(wp->w_buffer));
Bram Moolenaar69905d12017-08-13 18:14:47 +02005792#endif
Bram Moolenaar386600f2016-08-15 22:16:25 +02005793#ifdef FEAT_QUICKFIX
Bram Moolenaare0be1672018-07-08 16:50:37 +02005794 dict_add_number(dict, "quickfix", bt_quickfix(wp->w_buffer));
5795 dict_add_number(dict, "loclist",
5796 (bt_quickfix(wp->w_buffer) && wp->w_llist_ref != NULL));
Bram Moolenaar386600f2016-08-15 22:16:25 +02005797#endif
5798
Bram Moolenaar30567352016-08-27 21:25:44 +02005799 /* Add a reference to window variables */
Bram Moolenaar9f8187c2016-08-27 20:34:01 +02005800 dict_add_dict(dict, "variables", wp->w_vars);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005801
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005802 return dict;
5803}
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005804
5805/*
5806 * "getwininfo()" function
5807 */
5808 static void
5809f_getwininfo(typval_T *argvars, typval_T *rettv)
5810{
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005811 tabpage_T *tp;
5812 win_T *wp = NULL, *wparg = NULL;
5813 dict_T *d;
Bram Moolenaar386600f2016-08-15 22:16:25 +02005814 short tabnr = 0, winnr;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005815
5816 if (rettv_list_alloc(rettv) != OK)
5817 return;
5818
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005819 if (argvars[0].v_type != VAR_UNKNOWN)
5820 {
Bram Moolenaareeb1b9c2019-02-10 22:59:04 +01005821 wparg = win_id2wp(tv_get_number(&argvars[0]));
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005822 if (wparg == NULL)
5823 return;
5824 }
5825
5826 /* Collect information about either all the windows across all the tab
5827 * pages or one particular window.
5828 */
Bram Moolenaar386600f2016-08-15 22:16:25 +02005829 FOR_ALL_TABPAGES(tp)
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005830 {
Bram Moolenaar386600f2016-08-15 22:16:25 +02005831 tabnr++;
5832 winnr = 0;
5833 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005834 {
Bram Moolenaar386600f2016-08-15 22:16:25 +02005835 winnr++;
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005836 if (wparg != NULL && wp != wparg)
5837 continue;
5838 d = get_win_info(wp, tabnr, winnr);
5839 if (d != NULL)
5840 list_append_dict(rettv->vval.v_list, d);
5841 if (wparg != NULL)
5842 /* found information about a specific window */
5843 return;
5844 }
5845 }
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02005846}
5847
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005848/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005849 * "win_findbuf()" function
5850 */
5851 static void
5852f_win_findbuf(typval_T *argvars, typval_T *rettv)
5853{
5854 if (rettv_list_alloc(rettv) != FAIL)
5855 win_findbuf(argvars, rettv->vval.v_list);
5856}
5857
5858/*
5859 * "win_getid()" function
5860 */
5861 static void
5862f_win_getid(typval_T *argvars, typval_T *rettv)
5863{
5864 rettv->vval.v_number = win_getid(argvars);
5865}
5866
5867/*
5868 * "win_gotoid()" function
5869 */
5870 static void
5871f_win_gotoid(typval_T *argvars, typval_T *rettv)
5872{
5873 rettv->vval.v_number = win_gotoid(argvars);
5874}
5875
5876/*
5877 * "win_id2tabwin()" function
5878 */
5879 static void
5880f_win_id2tabwin(typval_T *argvars, typval_T *rettv)
5881{
5882 if (rettv_list_alloc(rettv) != FAIL)
5883 win_id2tabwin(argvars, rettv->vval.v_list);
5884}
5885
5886/*
5887 * "win_id2win()" function
5888 */
5889 static void
5890f_win_id2win(typval_T *argvars, typval_T *rettv)
5891{
5892 rettv->vval.v_number = win_id2win(argvars);
5893}
5894
5895/*
Bram Moolenaar22044dc2017-12-02 15:43:37 +01005896 * "win_screenpos()" function
5897 */
5898 static void
5899f_win_screenpos(typval_T *argvars, typval_T *rettv)
5900{
5901 win_T *wp;
5902
5903 if (rettv_list_alloc(rettv) == FAIL)
5904 return;
5905
Bram Moolenaarbabfcf52018-10-25 13:11:16 +02005906 wp = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaar22044dc2017-12-02 15:43:37 +01005907 list_append_number(rettv->vval.v_list, wp == NULL ? 0 : wp->w_winrow + 1);
5908 list_append_number(rettv->vval.v_list, wp == NULL ? 0 : wp->w_wincol + 1);
5909}
5910
5911/*
Bram Moolenaar3f54fd32018-03-03 21:29:55 +01005912 * "getwinpos({timeout})" function
5913 */
5914 static void
5915f_getwinpos(typval_T *argvars UNUSED, typval_T *rettv)
5916{
5917 int x = -1;
5918 int y = -1;
5919
5920 if (rettv_list_alloc(rettv) == FAIL)
5921 return;
5922#ifdef FEAT_GUI
5923 if (gui.in_use)
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01005924 (void)gui_mch_get_winpos(&x, &y);
Bram Moolenaar3f54fd32018-03-03 21:29:55 +01005925# if defined(HAVE_TGETENT) && defined(FEAT_TERMRESPONSE)
5926 else
5927# endif
5928#endif
5929#if defined(HAVE_TGETENT) && defined(FEAT_TERMRESPONSE)
5930 {
5931 varnumber_T timeout = 100;
5932
5933 if (argvars[0].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005934 timeout = tv_get_number(&argvars[0]);
Bram Moolenaar3f54fd32018-03-03 21:29:55 +01005935 term_get_winpos(&x, &y, timeout);
5936 }
5937#endif
5938 list_append_number(rettv->vval.v_list, (varnumber_T)x);
5939 list_append_number(rettv->vval.v_list, (varnumber_T)y);
5940}
5941
5942
5943/*
Bram Moolenaarba6ec182017-04-04 22:41:10 +02005944 * "getwinposx()" function
5945 */
5946 static void
5947f_getwinposx(typval_T *argvars UNUSED, typval_T *rettv)
5948{
5949 rettv->vval.v_number = -1;
5950#ifdef FEAT_GUI
5951 if (gui.in_use)
5952 {
5953 int x, y;
5954
5955 if (gui_mch_get_winpos(&x, &y) == OK)
5956 rettv->vval.v_number = x;
Bram Moolenaar7860bac2017-04-09 15:03:15 +02005957 return;
Bram Moolenaarba6ec182017-04-04 22:41:10 +02005958 }
5959#endif
5960#if defined(HAVE_TGETENT) && defined(FEAT_TERMRESPONSE)
5961 {
5962 int x, y;
5963
Bram Moolenaar3f54fd32018-03-03 21:29:55 +01005964 if (term_get_winpos(&x, &y, (varnumber_T)100) == OK)
Bram Moolenaarba6ec182017-04-04 22:41:10 +02005965 rettv->vval.v_number = x;
5966 }
5967#endif
5968}
5969
5970/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005971 * "getwinposy()" function
5972 */
5973 static void
5974f_getwinposy(typval_T *argvars UNUSED, typval_T *rettv)
5975{
5976 rettv->vval.v_number = -1;
5977#ifdef FEAT_GUI
5978 if (gui.in_use)
5979 {
5980 int x, y;
5981
5982 if (gui_mch_get_winpos(&x, &y) == OK)
5983 rettv->vval.v_number = y;
Bram Moolenaar7860bac2017-04-09 15:03:15 +02005984 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005985 }
5986#endif
Bram Moolenaarba6ec182017-04-04 22:41:10 +02005987#if defined(HAVE_TGETENT) && defined(FEAT_TERMRESPONSE)
5988 {
5989 int x, y;
5990
Bram Moolenaar3f54fd32018-03-03 21:29:55 +01005991 if (term_get_winpos(&x, &y, (varnumber_T)100) == OK)
Bram Moolenaarba6ec182017-04-04 22:41:10 +02005992 rettv->vval.v_number = y;
5993 }
5994#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02005995}
5996
5997/*
5998 * "getwinvar()" function
5999 */
6000 static void
6001f_getwinvar(typval_T *argvars, typval_T *rettv)
6002{
6003 getwinvar(argvars, rettv, 0);
6004}
6005
6006/*
6007 * "glob()" function
6008 */
6009 static void
6010f_glob(typval_T *argvars, typval_T *rettv)
6011{
6012 int options = WILD_SILENT|WILD_USE_NL;
6013 expand_T xpc;
6014 int error = FALSE;
6015
6016 /* When the optional second argument is non-zero, don't remove matches
6017 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
6018 rettv->v_type = VAR_STRING;
6019 if (argvars[1].v_type != VAR_UNKNOWN)
6020 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006021 if (tv_get_number_chk(&argvars[1], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006022 options |= WILD_KEEP_ALL;
6023 if (argvars[2].v_type != VAR_UNKNOWN)
6024 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006025 if (tv_get_number_chk(&argvars[2], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006026 {
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02006027 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006028 }
6029 if (argvars[3].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006030 && tv_get_number_chk(&argvars[3], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006031 options |= WILD_ALLLINKS;
6032 }
6033 }
6034 if (!error)
6035 {
6036 ExpandInit(&xpc);
6037 xpc.xp_context = EXPAND_FILES;
6038 if (p_wic)
6039 options += WILD_ICASE;
6040 if (rettv->v_type == VAR_STRING)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006041 rettv->vval.v_string = ExpandOne(&xpc, tv_get_string(&argvars[0]),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006042 NULL, options, WILD_ALL);
6043 else if (rettv_list_alloc(rettv) != FAIL)
6044 {
6045 int i;
6046
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006047 ExpandOne(&xpc, tv_get_string(&argvars[0]),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006048 NULL, options, WILD_ALL_KEEP);
6049 for (i = 0; i < xpc.xp_numfiles; i++)
6050 list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1);
6051
6052 ExpandCleanup(&xpc);
6053 }
6054 }
6055 else
6056 rettv->vval.v_string = NULL;
6057}
6058
6059/*
6060 * "globpath()" function
6061 */
6062 static void
6063f_globpath(typval_T *argvars, typval_T *rettv)
6064{
6065 int flags = 0;
6066 char_u buf1[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006067 char_u *file = tv_get_string_buf_chk(&argvars[1], buf1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006068 int error = FALSE;
6069 garray_T ga;
6070 int i;
6071
6072 /* When the optional second argument is non-zero, don't remove matches
6073 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
6074 rettv->v_type = VAR_STRING;
6075 if (argvars[2].v_type != VAR_UNKNOWN)
6076 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006077 if (tv_get_number_chk(&argvars[2], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006078 flags |= WILD_KEEP_ALL;
6079 if (argvars[3].v_type != VAR_UNKNOWN)
6080 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006081 if (tv_get_number_chk(&argvars[3], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006082 {
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02006083 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006084 }
6085 if (argvars[4].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006086 && tv_get_number_chk(&argvars[4], &error))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006087 flags |= WILD_ALLLINKS;
6088 }
6089 }
6090 if (file != NULL && !error)
6091 {
6092 ga_init2(&ga, (int)sizeof(char_u *), 10);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006093 globpath(tv_get_string(&argvars[0]), file, &ga, flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006094 if (rettv->v_type == VAR_STRING)
6095 rettv->vval.v_string = ga_concat_strings(&ga, "\n");
6096 else if (rettv_list_alloc(rettv) != FAIL)
6097 for (i = 0; i < ga.ga_len; ++i)
6098 list_append_string(rettv->vval.v_list,
6099 ((char_u **)(ga.ga_data))[i], -1);
6100 ga_clear_strings(&ga);
6101 }
6102 else
6103 rettv->vval.v_string = NULL;
6104}
6105
6106/*
6107 * "glob2regpat()" function
6108 */
6109 static void
6110f_glob2regpat(typval_T *argvars, typval_T *rettv)
6111{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006112 char_u *pat = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006113
6114 rettv->v_type = VAR_STRING;
6115 rettv->vval.v_string = (pat == NULL)
6116 ? NULL : file_pat_to_reg_pat(pat, NULL, NULL, FALSE);
6117}
6118
6119/* for VIM_VERSION_ defines */
6120#include "version.h"
6121
6122/*
6123 * "has()" function
6124 */
6125 static void
6126f_has(typval_T *argvars, typval_T *rettv)
6127{
6128 int i;
6129 char_u *name;
6130 int n = FALSE;
6131 static char *(has_list[]) =
6132 {
6133#ifdef AMIGA
6134 "amiga",
6135# ifdef FEAT_ARP
6136 "arp",
6137# endif
6138#endif
6139#ifdef __BEOS__
6140 "beos",
6141#endif
Bram Moolenaar39536dd2019-01-29 22:58:21 +01006142#if defined(BSD) && !defined(MACOS_X)
6143 "bsd",
6144#endif
6145#ifdef hpux
6146 "hpux",
6147#endif
6148#ifdef __linux__
6149 "linux",
6150#endif
Bram Moolenaard0573012017-10-28 21:11:06 +02006151#ifdef MACOS_X
Bram Moolenaar4f505882018-02-10 21:06:32 +01006152 "mac", /* Mac OS X (and, once, Mac OS Classic) */
6153 "osx", /* Mac OS X */
Bram Moolenaard0573012017-10-28 21:11:06 +02006154# ifdef MACOS_X_DARWIN
Bram Moolenaar4f505882018-02-10 21:06:32 +01006155 "macunix", /* Mac OS X, with the darwin feature */
6156 "osxdarwin", /* synonym for macunix */
Bram Moolenaard0573012017-10-28 21:11:06 +02006157# endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006158#endif
6159#ifdef __QNX__
6160 "qnx",
6161#endif
Bram Moolenaar39536dd2019-01-29 22:58:21 +01006162#ifdef SUN_SYSTEM
6163 "sun",
6164#else
6165 "moon",
6166#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006167#ifdef UNIX
6168 "unix",
6169#endif
6170#ifdef VMS
6171 "vms",
6172#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006173#ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006174 "win32",
6175#endif
Bram Moolenaar1eed5322019-02-26 17:03:54 +01006176#if defined(UNIX) && defined(__CYGWIN__)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006177 "win32unix",
6178#endif
Bram Moolenaar44b443c2019-02-18 22:14:18 +01006179#ifdef _WIN64
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006180 "win64",
6181#endif
6182#ifdef EBCDIC
6183 "ebcdic",
6184#endif
6185#ifndef CASE_INSENSITIVE_FILENAME
6186 "fname_case",
6187#endif
6188#ifdef HAVE_ACL
6189 "acl",
6190#endif
6191#ifdef FEAT_ARABIC
6192 "arabic",
6193#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006194 "autocmd",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02006195#ifdef FEAT_AUTOCHDIR
Bram Moolenaar39536dd2019-01-29 22:58:21 +01006196 "autochdir",
Bram Moolenaar83ec2a72018-07-27 22:08:59 +02006197#endif
Bram Moolenaare42a6d22017-11-12 19:21:51 +01006198#ifdef FEAT_AUTOSERVERNAME
6199 "autoservername",
6200#endif
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01006201#ifdef FEAT_BEVAL_GUI
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006202 "balloon_eval",
Bram Moolenaar4f974752019-02-17 17:44:42 +01006203# ifndef FEAT_GUI_MSWIN /* other GUIs always have multiline balloons */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006204 "balloon_multiline",
6205# endif
6206#endif
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01006207#ifdef FEAT_BEVAL_TERM
Bram Moolenaar51b0f372017-11-18 18:52:04 +01006208 "balloon_eval_term",
6209#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006210#if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
6211 "builtin_terms",
6212# ifdef ALL_BUILTIN_TCAPS
6213 "all_builtin_terms",
6214# endif
6215#endif
6216#if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \
Bram Moolenaar4f974752019-02-17 17:44:42 +01006217 || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006218 || defined(FEAT_GUI_MOTIF))
6219 "browsefilter",
6220#endif
6221#ifdef FEAT_BYTEOFF
6222 "byte_offset",
6223#endif
6224#ifdef FEAT_JOB_CHANNEL
6225 "channel",
6226#endif
6227#ifdef FEAT_CINDENT
6228 "cindent",
6229#endif
6230#ifdef FEAT_CLIENTSERVER
6231 "clientserver",
6232#endif
6233#ifdef FEAT_CLIPBOARD
6234 "clipboard",
6235#endif
6236#ifdef FEAT_CMDL_COMPL
6237 "cmdline_compl",
6238#endif
6239#ifdef FEAT_CMDHIST
6240 "cmdline_hist",
6241#endif
6242#ifdef FEAT_COMMENTS
6243 "comments",
6244#endif
6245#ifdef FEAT_CONCEAL
6246 "conceal",
6247#endif
6248#ifdef FEAT_CRYPT
6249 "cryptv",
6250 "crypt-blowfish",
6251 "crypt-blowfish2",
6252#endif
6253#ifdef FEAT_CSCOPE
6254 "cscope",
6255#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006256 "cursorbind",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006257#ifdef CURSOR_SHAPE
6258 "cursorshape",
6259#endif
6260#ifdef DEBUG
6261 "debug",
6262#endif
6263#ifdef FEAT_CON_DIALOG
6264 "dialog_con",
6265#endif
6266#ifdef FEAT_GUI_DIALOG
6267 "dialog_gui",
6268#endif
6269#ifdef FEAT_DIFF
6270 "diff",
6271#endif
6272#ifdef FEAT_DIGRAPHS
6273 "digraphs",
6274#endif
6275#ifdef FEAT_DIRECTX
6276 "directx",
6277#endif
6278#ifdef FEAT_DND
6279 "dnd",
6280#endif
6281#ifdef FEAT_EMACS_TAGS
6282 "emacs_tags",
6283#endif
6284 "eval", /* always present, of course! */
6285 "ex_extra", /* graduated feature */
6286#ifdef FEAT_SEARCH_EXTRA
6287 "extra_search",
6288#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006289#ifdef FEAT_SEARCHPATH
6290 "file_in_path",
6291#endif
6292#ifdef FEAT_FILTERPIPE
6293 "filterpipe",
6294#endif
6295#ifdef FEAT_FIND_ID
6296 "find_in_path",
6297#endif
6298#ifdef FEAT_FLOAT
6299 "float",
6300#endif
6301#ifdef FEAT_FOLDING
6302 "folding",
6303#endif
6304#ifdef FEAT_FOOTER
6305 "footer",
6306#endif
6307#if !defined(USE_SYSTEM) && defined(UNIX)
6308 "fork",
6309#endif
6310#ifdef FEAT_GETTEXT
6311 "gettext",
6312#endif
6313#ifdef FEAT_GUI
6314 "gui",
6315#endif
6316#ifdef FEAT_GUI_ATHENA
6317# ifdef FEAT_GUI_NEXTAW
6318 "gui_neXtaw",
6319# else
6320 "gui_athena",
6321# endif
6322#endif
6323#ifdef FEAT_GUI_GTK
6324 "gui_gtk",
6325# ifdef USE_GTK3
6326 "gui_gtk3",
6327# else
6328 "gui_gtk2",
6329# endif
6330#endif
6331#ifdef FEAT_GUI_GNOME
6332 "gui_gnome",
6333#endif
6334#ifdef FEAT_GUI_MAC
6335 "gui_mac",
6336#endif
6337#ifdef FEAT_GUI_MOTIF
6338 "gui_motif",
6339#endif
6340#ifdef FEAT_GUI_PHOTON
6341 "gui_photon",
6342#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006343#ifdef FEAT_GUI_MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006344 "gui_win32",
6345#endif
6346#ifdef FEAT_HANGULIN
6347 "hangul_input",
6348#endif
6349#if defined(HAVE_ICONV_H) && defined(USE_ICONV)
6350 "iconv",
6351#endif
6352#ifdef FEAT_INS_EXPAND
6353 "insert_expand",
6354#endif
6355#ifdef FEAT_JOB_CHANNEL
6356 "job",
6357#endif
6358#ifdef FEAT_JUMPLIST
6359 "jumplist",
6360#endif
6361#ifdef FEAT_KEYMAP
6362 "keymap",
6363#endif
Bram Moolenaar9532fe72016-07-29 22:50:35 +02006364 "lambda", /* always with FEAT_EVAL, since 7.4.2120 with closure */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006365#ifdef FEAT_LANGMAP
6366 "langmap",
6367#endif
6368#ifdef FEAT_LIBCALL
6369 "libcall",
6370#endif
6371#ifdef FEAT_LINEBREAK
6372 "linebreak",
6373#endif
6374#ifdef FEAT_LISP
6375 "lispindent",
6376#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006377 "listcmds",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006378#ifdef FEAT_LOCALMAP
6379 "localmap",
6380#endif
6381#ifdef FEAT_LUA
6382# ifndef DYNAMIC_LUA
6383 "lua",
6384# endif
6385#endif
6386#ifdef FEAT_MENU
6387 "menu",
6388#endif
6389#ifdef FEAT_SESSION
6390 "mksession",
6391#endif
6392#ifdef FEAT_MODIFY_FNAME
6393 "modify_fname",
6394#endif
6395#ifdef FEAT_MOUSE
6396 "mouse",
6397#endif
6398#ifdef FEAT_MOUSESHAPE
6399 "mouseshape",
6400#endif
6401#if defined(UNIX) || defined(VMS)
6402# ifdef FEAT_MOUSE_DEC
6403 "mouse_dec",
6404# endif
6405# ifdef FEAT_MOUSE_GPM
6406 "mouse_gpm",
6407# endif
6408# ifdef FEAT_MOUSE_JSB
6409 "mouse_jsbterm",
6410# endif
6411# ifdef FEAT_MOUSE_NET
6412 "mouse_netterm",
6413# endif
6414# ifdef FEAT_MOUSE_PTERM
6415 "mouse_pterm",
6416# endif
Bram Moolenaar2ace1bd2019-03-22 12:03:30 +01006417# ifdef FEAT_MOUSE_XTERM
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006418 "mouse_sgr",
6419# endif
6420# ifdef FEAT_SYSMOUSE
6421 "mouse_sysmouse",
6422# endif
6423# ifdef FEAT_MOUSE_URXVT
6424 "mouse_urxvt",
6425# endif
6426# ifdef FEAT_MOUSE_XTERM
6427 "mouse_xterm",
6428# endif
6429#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006430 "multi_byte",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006431#ifdef FEAT_MBYTE_IME
6432 "multi_byte_ime",
6433#endif
6434#ifdef FEAT_MULTI_LANG
6435 "multi_lang",
6436#endif
6437#ifdef FEAT_MZSCHEME
6438#ifndef DYNAMIC_MZSCHEME
6439 "mzscheme",
6440#endif
6441#endif
6442#ifdef FEAT_NUM64
6443 "num64",
6444#endif
6445#ifdef FEAT_OLE
6446 "ole",
6447#endif
Bram Moolenaar6183ccb2018-07-22 05:08:11 +02006448#ifdef FEAT_EVAL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006449 "packages",
Bram Moolenaar6183ccb2018-07-22 05:08:11 +02006450#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006451#ifdef FEAT_PATH_EXTRA
6452 "path_extra",
6453#endif
6454#ifdef FEAT_PERL
6455#ifndef DYNAMIC_PERL
6456 "perl",
6457#endif
6458#endif
6459#ifdef FEAT_PERSISTENT_UNDO
6460 "persistent_undo",
6461#endif
Bram Moolenaar84b242c2018-01-28 17:45:49 +01006462#if defined(FEAT_PYTHON)
6463 "python_compiled",
6464# if defined(DYNAMIC_PYTHON)
6465 "python_dynamic",
6466# else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006467 "python",
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006468 "pythonx",
Bram Moolenaar84b242c2018-01-28 17:45:49 +01006469# endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006470#endif
Bram Moolenaar84b242c2018-01-28 17:45:49 +01006471#if defined(FEAT_PYTHON3)
6472 "python3_compiled",
6473# if defined(DYNAMIC_PYTHON3)
6474 "python3_dynamic",
6475# else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006476 "python3",
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006477 "pythonx",
Bram Moolenaar84b242c2018-01-28 17:45:49 +01006478# endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006479#endif
6480#ifdef FEAT_POSTSCRIPT
6481 "postscript",
6482#endif
6483#ifdef FEAT_PRINTER
6484 "printer",
6485#endif
6486#ifdef FEAT_PROFILE
6487 "profile",
6488#endif
6489#ifdef FEAT_RELTIME
6490 "reltime",
6491#endif
6492#ifdef FEAT_QUICKFIX
6493 "quickfix",
6494#endif
6495#ifdef FEAT_RIGHTLEFT
6496 "rightleft",
6497#endif
6498#if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
6499 "ruby",
6500#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006501 "scrollbind",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006502#ifdef FEAT_CMDL_INFO
6503 "showcmd",
6504 "cmdline_info",
6505#endif
6506#ifdef FEAT_SIGNS
6507 "signs",
6508#endif
6509#ifdef FEAT_SMARTINDENT
6510 "smartindent",
6511#endif
6512#ifdef STARTUPTIME
6513 "startuptime",
6514#endif
6515#ifdef FEAT_STL_OPT
6516 "statusline",
6517#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006518#ifdef FEAT_NETBEANS_INTG
6519 "netbeans_intg",
6520#endif
6521#ifdef FEAT_SPELL
6522 "spell",
6523#endif
6524#ifdef FEAT_SYN_HL
6525 "syntax",
6526#endif
6527#if defined(USE_SYSTEM) || !defined(UNIX)
6528 "system",
6529#endif
6530#ifdef FEAT_TAG_BINS
6531 "tag_binary",
6532#endif
6533#ifdef FEAT_TAG_OLDSTATIC
6534 "tag_old_static",
6535#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006536#ifdef FEAT_TCL
6537# ifndef DYNAMIC_TCL
6538 "tcl",
6539# endif
6540#endif
6541#ifdef FEAT_TERMGUICOLORS
6542 "termguicolors",
6543#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006544#if defined(FEAT_TERMINAL) && !defined(MSWIN)
Bram Moolenaare4f25e42017-07-07 11:54:15 +02006545 "terminal",
6546#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006547#ifdef TERMINFO
6548 "terminfo",
6549#endif
6550#ifdef FEAT_TERMRESPONSE
6551 "termresponse",
6552#endif
6553#ifdef FEAT_TEXTOBJ
6554 "textobjects",
6555#endif
Bram Moolenaar98aefe72018-12-13 22:20:09 +01006556#ifdef FEAT_TEXT_PROP
6557 "textprop",
6558#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006559#ifdef HAVE_TGETENT
6560 "tgetent",
6561#endif
6562#ifdef FEAT_TIMERS
6563 "timers",
6564#endif
6565#ifdef FEAT_TITLE
6566 "title",
6567#endif
6568#ifdef FEAT_TOOLBAR
6569 "toolbar",
6570#endif
6571#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
6572 "unnamedplus",
6573#endif
6574#ifdef FEAT_USR_CMDS
6575 "user-commands", /* was accidentally included in 5.4 */
6576 "user_commands",
6577#endif
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006578#ifdef FEAT_VARTABS
6579 "vartabs",
6580#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006581#ifdef FEAT_VIMINFO
6582 "viminfo",
6583#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006584 "vertsplit",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006585 "virtualedit",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006586 "visual",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006587 "visualextra",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006588 "vreplace",
Bram Moolenaarff1e8792018-03-12 22:16:37 +01006589#ifdef FEAT_VTP
6590 "vtp",
6591#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006592#ifdef FEAT_WILDIGN
6593 "wildignore",
6594#endif
6595#ifdef FEAT_WILDMENU
6596 "wildmenu",
6597#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006598 "windows",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006599#ifdef FEAT_WAK
6600 "winaltkeys",
6601#endif
6602#ifdef FEAT_WRITEBACKUP
6603 "writebackup",
6604#endif
6605#ifdef FEAT_XIM
6606 "xim",
6607#endif
6608#ifdef FEAT_XFONTSET
6609 "xfontset",
6610#endif
6611#ifdef FEAT_XPM_W32
6612 "xpm",
6613 "xpm_w32", /* for backward compatibility */
6614#else
6615# if defined(HAVE_XPM)
6616 "xpm",
6617# endif
6618#endif
6619#ifdef USE_XSMP
6620 "xsmp",
6621#endif
6622#ifdef USE_XSMP_INTERACT
6623 "xsmp_interact",
6624#endif
6625#ifdef FEAT_XCLIPBOARD
6626 "xterm_clipboard",
6627#endif
6628#ifdef FEAT_XTERM_SAVE
6629 "xterm_save",
6630#endif
6631#if defined(UNIX) && defined(FEAT_X11)
6632 "X11",
6633#endif
6634 NULL
6635 };
6636
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006637 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006638 for (i = 0; has_list[i] != NULL; ++i)
6639 if (STRICMP(name, has_list[i]) == 0)
6640 {
6641 n = TRUE;
6642 break;
6643 }
6644
6645 if (n == FALSE)
6646 {
6647 if (STRNICMP(name, "patch", 5) == 0)
6648 {
6649 if (name[5] == '-'
6650 && STRLEN(name) >= 11
6651 && vim_isdigit(name[6])
6652 && vim_isdigit(name[8])
6653 && vim_isdigit(name[10]))
6654 {
6655 int major = atoi((char *)name + 6);
6656 int minor = atoi((char *)name + 8);
6657
6658 /* Expect "patch-9.9.01234". */
6659 n = (major < VIM_VERSION_MAJOR
6660 || (major == VIM_VERSION_MAJOR
6661 && (minor < VIM_VERSION_MINOR
6662 || (minor == VIM_VERSION_MINOR
6663 && has_patch(atoi((char *)name + 10))))));
6664 }
6665 else
6666 n = has_patch(atoi((char *)name + 5));
6667 }
6668 else if (STRICMP(name, "vim_starting") == 0)
6669 n = (starting != 0);
Bram Moolenaar2cab0e12016-11-24 15:09:07 +01006670 else if (STRICMP(name, "ttyin") == 0)
6671 n = mch_input_isatty();
6672 else if (STRICMP(name, "ttyout") == 0)
6673 n = stdout_isatty;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006674 else if (STRICMP(name, "multi_byte_encoding") == 0)
6675 n = has_mbyte;
Bram Moolenaar4f974752019-02-17 17:44:42 +01006676#if defined(FEAT_BEVAL) && defined(FEAT_GUI_MSWIN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006677 else if (STRICMP(name, "balloon_multiline") == 0)
6678 n = multiline_balloon_available();
6679#endif
6680#ifdef DYNAMIC_TCL
6681 else if (STRICMP(name, "tcl") == 0)
6682 n = tcl_enabled(FALSE);
6683#endif
6684#if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
6685 else if (STRICMP(name, "iconv") == 0)
6686 n = iconv_enabled(FALSE);
6687#endif
6688#ifdef DYNAMIC_LUA
6689 else if (STRICMP(name, "lua") == 0)
6690 n = lua_enabled(FALSE);
6691#endif
6692#ifdef DYNAMIC_MZSCHEME
6693 else if (STRICMP(name, "mzscheme") == 0)
6694 n = mzscheme_enabled(FALSE);
6695#endif
6696#ifdef DYNAMIC_RUBY
6697 else if (STRICMP(name, "ruby") == 0)
6698 n = ruby_enabled(FALSE);
6699#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006700#ifdef DYNAMIC_PYTHON
6701 else if (STRICMP(name, "python") == 0)
6702 n = python_enabled(FALSE);
6703#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006704#ifdef DYNAMIC_PYTHON3
6705 else if (STRICMP(name, "python3") == 0)
6706 n = python3_enabled(FALSE);
6707#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01006708#if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3)
6709 else if (STRICMP(name, "pythonx") == 0)
6710 {
6711# if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3)
6712 if (p_pyx == 0)
6713 n = python3_enabled(FALSE) || python_enabled(FALSE);
6714 else if (p_pyx == 3)
6715 n = python3_enabled(FALSE);
6716 else if (p_pyx == 2)
6717 n = python_enabled(FALSE);
6718# elif defined(DYNAMIC_PYTHON)
6719 n = python_enabled(FALSE);
6720# elif defined(DYNAMIC_PYTHON3)
6721 n = python3_enabled(FALSE);
6722# endif
6723 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006724#endif
6725#ifdef DYNAMIC_PERL
6726 else if (STRICMP(name, "perl") == 0)
6727 n = perl_enabled(FALSE);
6728#endif
6729#ifdef FEAT_GUI
6730 else if (STRICMP(name, "gui_running") == 0)
6731 n = (gui.in_use || gui.starting);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006732# ifdef FEAT_BROWSE
6733 else if (STRICMP(name, "browse") == 0)
6734 n = gui.in_use; /* gui_mch_browse() works when GUI is running */
6735# endif
6736#endif
6737#ifdef FEAT_SYN_HL
6738 else if (STRICMP(name, "syntax_items") == 0)
6739 n = syntax_present(curwin);
6740#endif
Bram Moolenaarcafafb32018-02-22 21:07:09 +01006741#ifdef FEAT_VTP
6742 else if (STRICMP(name, "vcon") == 0)
Bram Moolenaard8b37a52018-06-28 15:50:28 +02006743 n = is_term_win32() && has_vtp_working();
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006744#endif
6745#ifdef FEAT_NETBEANS_INTG
6746 else if (STRICMP(name, "netbeans_enabled") == 0)
6747 n = netbeans_active();
6748#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006749#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaara83e3962017-08-17 14:39:07 +02006750 else if (STRICMP(name, "terminal") == 0)
6751 n = terminal_enabled();
6752#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01006753#if defined(FEAT_TERMINAL) && defined(MSWIN)
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01006754 else if (STRICMP(name, "conpty") == 0)
6755 n = use_conpty();
6756#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006757 }
6758
6759 rettv->vval.v_number = n;
6760}
6761
6762/*
6763 * "has_key()" function
6764 */
6765 static void
6766f_has_key(typval_T *argvars, typval_T *rettv)
6767{
6768 if (argvars[0].v_type != VAR_DICT)
6769 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006770 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006771 return;
6772 }
6773 if (argvars[0].vval.v_dict == NULL)
6774 return;
6775
6776 rettv->vval.v_number = dict_find(argvars[0].vval.v_dict,
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006777 tv_get_string(&argvars[1]), -1) != NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006778}
6779
6780/*
6781 * "haslocaldir()" function
6782 */
6783 static void
6784f_haslocaldir(typval_T *argvars, typval_T *rettv)
6785{
6786 win_T *wp = NULL;
6787
6788 wp = find_tabwin(&argvars[0], &argvars[1]);
6789 rettv->vval.v_number = (wp != NULL && wp->w_localdir != NULL);
6790}
6791
6792/*
6793 * "hasmapto()" function
6794 */
6795 static void
6796f_hasmapto(typval_T *argvars, typval_T *rettv)
6797{
6798 char_u *name;
6799 char_u *mode;
6800 char_u buf[NUMBUFLEN];
6801 int abbr = FALSE;
6802
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006803 name = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006804 if (argvars[1].v_type == VAR_UNKNOWN)
6805 mode = (char_u *)"nvo";
6806 else
6807 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006808 mode = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006809 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006810 abbr = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006811 }
6812
6813 if (map_to_exists(name, mode, abbr))
6814 rettv->vval.v_number = TRUE;
6815 else
6816 rettv->vval.v_number = FALSE;
6817}
6818
6819/*
6820 * "histadd()" function
6821 */
6822 static void
6823f_histadd(typval_T *argvars UNUSED, typval_T *rettv)
6824{
6825#ifdef FEAT_CMDHIST
6826 int histype;
6827 char_u *str;
6828 char_u buf[NUMBUFLEN];
6829#endif
6830
6831 rettv->vval.v_number = FALSE;
Bram Moolenaar8c62a082019-02-08 14:34:10 +01006832 if (check_secure())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006833 return;
6834#ifdef FEAT_CMDHIST
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006835 str = tv_get_string_chk(&argvars[0]); /* NULL on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006836 histype = str != NULL ? get_histtype(str) : -1;
6837 if (histype >= 0)
6838 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006839 str = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006840 if (*str != NUL)
6841 {
6842 init_history();
6843 add_to_history(histype, str, FALSE, NUL);
6844 rettv->vval.v_number = TRUE;
6845 return;
6846 }
6847 }
6848#endif
6849}
6850
6851/*
6852 * "histdel()" function
6853 */
6854 static void
6855f_histdel(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
6856{
6857#ifdef FEAT_CMDHIST
6858 int n;
6859 char_u buf[NUMBUFLEN];
6860 char_u *str;
6861
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006862 str = tv_get_string_chk(&argvars[0]); /* NULL on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006863 if (str == NULL)
6864 n = 0;
6865 else if (argvars[1].v_type == VAR_UNKNOWN)
6866 /* only one argument: clear entire history */
6867 n = clr_history(get_histtype(str));
6868 else if (argvars[1].v_type == VAR_NUMBER)
6869 /* index given: remove that entry */
6870 n = del_history_idx(get_histtype(str),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006871 (int)tv_get_number(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006872 else
6873 /* string given: remove all matching entries */
6874 n = del_history_entry(get_histtype(str),
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006875 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006876 rettv->vval.v_number = n;
6877#endif
6878}
6879
6880/*
6881 * "histget()" function
6882 */
6883 static void
6884f_histget(typval_T *argvars UNUSED, typval_T *rettv)
6885{
6886#ifdef FEAT_CMDHIST
6887 int type;
6888 int idx;
6889 char_u *str;
6890
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006891 str = tv_get_string_chk(&argvars[0]); /* NULL on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006892 if (str == NULL)
6893 rettv->vval.v_string = NULL;
6894 else
6895 {
6896 type = get_histtype(str);
6897 if (argvars[1].v_type == VAR_UNKNOWN)
6898 idx = get_history_idx(type);
6899 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006900 idx = (int)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006901 /* -1 on type error */
6902 rettv->vval.v_string = vim_strsave(get_history_entry(type, idx));
6903 }
6904#else
6905 rettv->vval.v_string = NULL;
6906#endif
6907 rettv->v_type = VAR_STRING;
6908}
6909
6910/*
6911 * "histnr()" function
6912 */
6913 static void
6914f_histnr(typval_T *argvars UNUSED, typval_T *rettv)
6915{
6916 int i;
6917
6918#ifdef FEAT_CMDHIST
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006919 char_u *history = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006920
6921 i = history == NULL ? HIST_CMD - 1 : get_histtype(history);
6922 if (i >= HIST_CMD && i < HIST_COUNT)
6923 i = get_history_idx(i);
6924 else
6925#endif
6926 i = -1;
6927 rettv->vval.v_number = i;
6928}
6929
6930/*
6931 * "highlightID(name)" function
6932 */
6933 static void
6934f_hlID(typval_T *argvars, typval_T *rettv)
6935{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006936 rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006937}
6938
6939/*
6940 * "highlight_exists()" function
6941 */
6942 static void
6943f_hlexists(typval_T *argvars, typval_T *rettv)
6944{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006945 rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006946}
6947
6948/*
6949 * "hostname()" function
6950 */
6951 static void
6952f_hostname(typval_T *argvars UNUSED, typval_T *rettv)
6953{
6954 char_u hostname[256];
6955
6956 mch_get_host_name(hostname, 256);
6957 rettv->v_type = VAR_STRING;
6958 rettv->vval.v_string = vim_strsave(hostname);
6959}
6960
6961/*
6962 * iconv() function
6963 */
6964 static void
6965f_iconv(typval_T *argvars UNUSED, typval_T *rettv)
6966{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006967 char_u buf1[NUMBUFLEN];
6968 char_u buf2[NUMBUFLEN];
6969 char_u *from, *to, *str;
6970 vimconv_T vimconv;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006971
6972 rettv->v_type = VAR_STRING;
6973 rettv->vval.v_string = NULL;
6974
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006975 str = tv_get_string(&argvars[0]);
6976 from = enc_canonize(enc_skip(tv_get_string_buf(&argvars[1], buf1)));
6977 to = enc_canonize(enc_skip(tv_get_string_buf(&argvars[2], buf2)));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006978 vimconv.vc_type = CONV_NONE;
6979 convert_setup(&vimconv, from, to);
6980
6981 /* If the encodings are equal, no conversion needed. */
6982 if (vimconv.vc_type == CONV_NONE)
6983 rettv->vval.v_string = vim_strsave(str);
6984 else
6985 rettv->vval.v_string = string_convert(&vimconv, str, NULL);
6986
6987 convert_setup(&vimconv, NULL, NULL);
6988 vim_free(from);
6989 vim_free(to);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006990}
6991
6992/*
6993 * "indent()" function
6994 */
6995 static void
6996f_indent(typval_T *argvars, typval_T *rettv)
6997{
6998 linenr_T lnum;
6999
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007000 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007001 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
7002 rettv->vval.v_number = get_indent_lnum(lnum);
7003 else
7004 rettv->vval.v_number = -1;
7005}
7006
7007/*
7008 * "index()" function
7009 */
7010 static void
7011f_index(typval_T *argvars, typval_T *rettv)
7012{
7013 list_T *l;
7014 listitem_T *item;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007015 blob_T *b;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007016 long idx = 0;
7017 int ic = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007018 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007019
7020 rettv->vval.v_number = -1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007021 if (argvars[0].v_type == VAR_BLOB)
7022 {
7023 typval_T tv;
7024 int start = 0;
7025
7026 if (argvars[2].v_type != VAR_UNKNOWN)
7027 {
7028 start = tv_get_number_chk(&argvars[2], &error);
7029 if (error)
7030 return;
7031 }
7032 b = argvars[0].vval.v_blob;
7033 if (b == NULL)
7034 return;
Bram Moolenaar05500ec2019-01-13 19:10:33 +01007035 if (start < 0)
7036 {
7037 start = blob_len(b) + start;
7038 if (start < 0)
7039 start = 0;
7040 }
7041
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007042 for (idx = start; idx < blob_len(b); ++idx)
7043 {
7044 tv.v_type = VAR_NUMBER;
7045 tv.vval.v_number = blob_get(b, idx);
7046 if (tv_equal(&tv, &argvars[1], ic, FALSE))
7047 {
7048 rettv->vval.v_number = idx;
7049 return;
7050 }
7051 }
7052 return;
7053 }
7054 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007055 {
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01007056 emsg(_(e_listblobreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007057 return;
7058 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007059
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007060 l = argvars[0].vval.v_list;
7061 if (l != NULL)
7062 {
7063 item = l->lv_first;
7064 if (argvars[2].v_type != VAR_UNKNOWN)
7065 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007066 /* Start at specified item. Use the cached index that list_find()
7067 * sets, so that a negative number also works. */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007068 item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007069 idx = l->lv_idx;
7070 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007071 ic = (int)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007072 if (error)
7073 item = NULL;
7074 }
7075
7076 for ( ; item != NULL; item = item->li_next, ++idx)
7077 if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
7078 {
7079 rettv->vval.v_number = idx;
7080 break;
7081 }
7082 }
7083}
7084
7085static int inputsecret_flag = 0;
7086
7087/*
7088 * "input()" function
7089 * Also handles inputsecret() when inputsecret is set.
7090 */
7091 static void
7092f_input(typval_T *argvars, typval_T *rettv)
7093{
7094 get_user_input(argvars, rettv, FALSE, inputsecret_flag);
7095}
7096
7097/*
7098 * "inputdialog()" function
7099 */
7100 static void
7101f_inputdialog(typval_T *argvars, typval_T *rettv)
7102{
7103#if defined(FEAT_GUI_TEXTDIALOG)
7104 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
7105 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
7106 {
7107 char_u *message;
7108 char_u buf[NUMBUFLEN];
7109 char_u *defstr = (char_u *)"";
7110
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007111 message = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007112 if (argvars[1].v_type != VAR_UNKNOWN
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007113 && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007114 vim_strncpy(IObuff, defstr, IOSIZE - 1);
7115 else
7116 IObuff[0] = NUL;
7117 if (message != NULL && defstr != NULL
7118 && do_dialog(VIM_QUESTION, NULL, message,
7119 (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1)
7120 rettv->vval.v_string = vim_strsave(IObuff);
7121 else
7122 {
7123 if (message != NULL && defstr != NULL
7124 && argvars[1].v_type != VAR_UNKNOWN
7125 && argvars[2].v_type != VAR_UNKNOWN)
7126 rettv->vval.v_string = vim_strsave(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007127 tv_get_string_buf(&argvars[2], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007128 else
7129 rettv->vval.v_string = NULL;
7130 }
7131 rettv->v_type = VAR_STRING;
7132 }
7133 else
7134#endif
7135 get_user_input(argvars, rettv, TRUE, inputsecret_flag);
7136}
7137
7138/*
7139 * "inputlist()" function
7140 */
7141 static void
7142f_inputlist(typval_T *argvars, typval_T *rettv)
7143{
7144 listitem_T *li;
7145 int selected;
7146 int mouse_used;
7147
7148#ifdef NO_CONSOLE_INPUT
Bram Moolenaar91d348a2017-07-29 20:16:03 +02007149 /* While starting up, there is no place to enter text. When running tests
7150 * with --not-a-term we assume feedkeys() will be used. */
7151 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007152 return;
7153#endif
7154 if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
7155 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007156 semsg(_(e_listarg), "inputlist()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007157 return;
7158 }
7159
7160 msg_start();
7161 msg_row = Rows - 1; /* for when 'cmdheight' > 1 */
7162 lines_left = Rows; /* avoid more prompt */
7163 msg_scroll = TRUE;
7164 msg_clr_eos();
7165
7166 for (li = argvars[0].vval.v_list->lv_first; li != NULL; li = li->li_next)
7167 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007168 msg_puts((char *)tv_get_string(&li->li_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007169 msg_putchar('\n');
7170 }
7171
7172 /* Ask for choice. */
7173 selected = prompt_for_number(&mouse_used);
7174 if (mouse_used)
7175 selected -= lines_left;
7176
7177 rettv->vval.v_number = selected;
7178}
7179
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007180static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
7181
7182/*
7183 * "inputrestore()" function
7184 */
7185 static void
7186f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
7187{
7188 if (ga_userinput.ga_len > 0)
7189 {
7190 --ga_userinput.ga_len;
7191 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
7192 + ga_userinput.ga_len);
7193 /* default return is zero == OK */
7194 }
7195 else if (p_verbose > 1)
7196 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01007197 verb_msg(_("called inputrestore() more often than inputsave()"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007198 rettv->vval.v_number = 1; /* Failed */
7199 }
7200}
7201
7202/*
7203 * "inputsave()" function
7204 */
7205 static void
7206f_inputsave(typval_T *argvars UNUSED, typval_T *rettv)
7207{
7208 /* Add an entry to the stack of typeahead storage. */
7209 if (ga_grow(&ga_userinput, 1) == OK)
7210 {
7211 save_typeahead((tasave_T *)(ga_userinput.ga_data)
7212 + ga_userinput.ga_len);
7213 ++ga_userinput.ga_len;
7214 /* default return is zero == OK */
7215 }
7216 else
7217 rettv->vval.v_number = 1; /* Failed */
7218}
7219
7220/*
7221 * "inputsecret()" function
7222 */
7223 static void
7224f_inputsecret(typval_T *argvars, typval_T *rettv)
7225{
7226 ++cmdline_star;
7227 ++inputsecret_flag;
7228 f_input(argvars, rettv);
7229 --cmdline_star;
7230 --inputsecret_flag;
7231}
7232
7233/*
7234 * "insert()" function
7235 */
7236 static void
7237f_insert(typval_T *argvars, typval_T *rettv)
7238{
7239 long before = 0;
7240 listitem_T *item;
7241 list_T *l;
7242 int error = FALSE;
7243
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007244 if (argvars[0].v_type == VAR_BLOB)
7245 {
7246 int val, len;
7247 char_u *p;
7248
7249 len = blob_len(argvars[0].vval.v_blob);
7250 if (argvars[2].v_type != VAR_UNKNOWN)
7251 {
7252 before = (long)tv_get_number_chk(&argvars[2], &error);
7253 if (error)
7254 return; // type error; errmsg already given
7255 if (before < 0 || before > len)
7256 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007257 semsg(_(e_invarg2), tv_get_string(&argvars[2]));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007258 return;
7259 }
7260 }
7261 val = tv_get_number_chk(&argvars[1], &error);
7262 if (error)
7263 return;
7264 if (val < 0 || val > 255)
7265 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007266 semsg(_(e_invarg2), tv_get_string(&argvars[1]));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007267 return;
7268 }
7269
7270 if (ga_grow(&argvars[0].vval.v_blob->bv_ga, 1) == FAIL)
7271 return;
7272 p = (char_u *)argvars[0].vval.v_blob->bv_ga.ga_data;
7273 mch_memmove(p + before + 1, p + before, (size_t)len - before);
7274 *(p + before) = val;
7275 ++argvars[0].vval.v_blob->bv_ga.ga_len;
7276
7277 copy_tv(&argvars[0], rettv);
7278 }
7279 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01007280 semsg(_(e_listblobarg), "insert()");
Bram Moolenaar05c00c02019-02-11 22:00:11 +01007281 else if ((l = argvars[0].vval.v_list) != NULL
7282 && !var_check_lock(l->lv_lock,
7283 (char_u *)N_("insert() argument"), TRUE))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007284 {
7285 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007286 before = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007287 if (error)
7288 return; /* type error; errmsg already given */
7289
7290 if (before == l->lv_len)
7291 item = NULL;
7292 else
7293 {
7294 item = list_find(l, before);
7295 if (item == NULL)
7296 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007297 semsg(_(e_listidx), before);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007298 l = NULL;
7299 }
7300 }
7301 if (l != NULL)
7302 {
7303 list_insert_tv(l, &argvars[1], item);
7304 copy_tv(&argvars[0], rettv);
7305 }
7306 }
7307}
7308
7309/*
7310 * "invert(expr)" function
7311 */
7312 static void
7313f_invert(typval_T *argvars, typval_T *rettv)
7314{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007315 rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007316}
7317
7318/*
7319 * "isdirectory()" function
7320 */
7321 static void
7322f_isdirectory(typval_T *argvars, typval_T *rettv)
7323{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007324 rettv->vval.v_number = mch_isdir(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007325}
7326
7327/*
7328 * Return TRUE if typeval "tv" is locked: Either that value is locked itself
7329 * or it refers to a List or Dictionary that is locked.
7330 */
7331 static int
7332tv_islocked(typval_T *tv)
7333{
7334 return (tv->v_lock & VAR_LOCKED)
7335 || (tv->v_type == VAR_LIST
7336 && tv->vval.v_list != NULL
7337 && (tv->vval.v_list->lv_lock & VAR_LOCKED))
7338 || (tv->v_type == VAR_DICT
7339 && tv->vval.v_dict != NULL
7340 && (tv->vval.v_dict->dv_lock & VAR_LOCKED));
7341}
7342
7343/*
7344 * "islocked()" function
7345 */
7346 static void
7347f_islocked(typval_T *argvars, typval_T *rettv)
7348{
7349 lval_T lv;
7350 char_u *end;
7351 dictitem_T *di;
7352
7353 rettv->vval.v_number = -1;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007354 end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
Bram Moolenaar3a257732017-02-21 20:47:13 +01007355 GLV_NO_AUTOLOAD | GLV_READ_ONLY, FNE_CHECK_START);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007356 if (end != NULL && lv.ll_name != NULL)
7357 {
7358 if (*end != NUL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007359 emsg(_(e_trailing));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007360 else
7361 {
7362 if (lv.ll_tv == NULL)
7363 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01007364 di = find_var(lv.ll_name, NULL, TRUE);
7365 if (di != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007366 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01007367 /* Consider a variable locked when:
7368 * 1. the variable itself is locked
7369 * 2. the value of the variable is locked.
7370 * 3. the List or Dict value is locked.
7371 */
7372 rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
7373 || tv_islocked(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007374 }
7375 }
7376 else if (lv.ll_range)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007377 emsg(_("E786: Range not allowed"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007378 else if (lv.ll_newkey != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007379 semsg(_(e_dictkey), lv.ll_newkey);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007380 else if (lv.ll_list != NULL)
7381 /* List item. */
7382 rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
7383 else
7384 /* Dictionary item. */
7385 rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
7386 }
7387 }
7388
7389 clear_lval(&lv);
7390}
7391
7392#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
7393/*
7394 * "isnan()" function
7395 */
7396 static void
7397f_isnan(typval_T *argvars, typval_T *rettv)
7398{
7399 rettv->vval.v_number = argvars[0].v_type == VAR_FLOAT
7400 && isnan(argvars[0].vval.v_float);
7401}
7402#endif
7403
7404/*
7405 * "items(dict)" function
7406 */
7407 static void
7408f_items(typval_T *argvars, typval_T *rettv)
7409{
7410 dict_list(argvars, rettv, 2);
7411}
7412
7413#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
7414/*
7415 * Get the job from the argument.
7416 * Returns NULL if the job is invalid.
7417 */
7418 static job_T *
7419get_job_arg(typval_T *tv)
7420{
7421 job_T *job;
7422
7423 if (tv->v_type != VAR_JOB)
7424 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007425 semsg(_(e_invarg2), tv_get_string(tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007426 return NULL;
7427 }
7428 job = tv->vval.v_job;
7429
7430 if (job == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007431 emsg(_("E916: not a valid job"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007432 return job;
7433}
7434
7435/*
7436 * "job_getchannel()" function
7437 */
7438 static void
7439f_job_getchannel(typval_T *argvars, typval_T *rettv)
7440{
7441 job_T *job = get_job_arg(&argvars[0]);
7442
7443 if (job != NULL)
7444 {
7445 rettv->v_type = VAR_CHANNEL;
7446 rettv->vval.v_channel = job->jv_channel;
7447 if (job->jv_channel != NULL)
7448 ++job->jv_channel->ch_refcount;
7449 }
7450}
7451
7452/*
7453 * "job_info()" function
7454 */
7455 static void
7456f_job_info(typval_T *argvars, typval_T *rettv)
7457{
Bram Moolenaare1fc5152018-04-21 19:49:08 +02007458 if (argvars[0].v_type != VAR_UNKNOWN)
7459 {
7460 job_T *job = get_job_arg(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007461
Bram Moolenaare1fc5152018-04-21 19:49:08 +02007462 if (job != NULL && rettv_dict_alloc(rettv) != FAIL)
7463 job_info(job, rettv->vval.v_dict);
7464 }
7465 else if (rettv_list_alloc(rettv) == OK)
7466 job_info_all(rettv->vval.v_list);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007467}
7468
7469/*
7470 * "job_setoptions()" function
7471 */
7472 static void
7473f_job_setoptions(typval_T *argvars, typval_T *rettv UNUSED)
7474{
7475 job_T *job = get_job_arg(&argvars[0]);
7476 jobopt_T opt;
7477
7478 if (job == NULL)
7479 return;
7480 clear_job_options(&opt);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02007481 if (get_job_options(&argvars[1], &opt, JO_STOPONEXIT + JO_EXIT_CB, 0) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007482 job_set_options(job, &opt);
7483 free_job_options(&opt);
7484}
7485
7486/*
7487 * "job_start()" function
7488 */
7489 static void
7490f_job_start(typval_T *argvars, typval_T *rettv)
7491{
7492 rettv->v_type = VAR_JOB;
7493 if (check_restricted() || check_secure())
7494 return;
Bram Moolenaar493359e2018-06-12 20:25:52 +02007495 rettv->vval.v_job = job_start(argvars, NULL, NULL, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007496}
7497
7498/*
7499 * "job_status()" function
7500 */
7501 static void
7502f_job_status(typval_T *argvars, typval_T *rettv)
7503{
7504 job_T *job = get_job_arg(&argvars[0]);
7505
7506 if (job != NULL)
7507 {
7508 rettv->v_type = VAR_STRING;
7509 rettv->vval.v_string = vim_strsave((char_u *)job_status(job));
7510 }
7511}
7512
7513/*
7514 * "job_stop()" function
7515 */
7516 static void
7517f_job_stop(typval_T *argvars, typval_T *rettv)
7518{
7519 job_T *job = get_job_arg(&argvars[0]);
7520
7521 if (job != NULL)
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02007522 rettv->vval.v_number = job_stop(job, argvars, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007523}
7524#endif
7525
7526/*
7527 * "join()" function
7528 */
7529 static void
7530f_join(typval_T *argvars, typval_T *rettv)
7531{
7532 garray_T ga;
7533 char_u *sep;
7534
7535 if (argvars[0].v_type != VAR_LIST)
7536 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007537 emsg(_(e_listreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007538 return;
7539 }
7540 if (argvars[0].vval.v_list == NULL)
7541 return;
7542 if (argvars[1].v_type == VAR_UNKNOWN)
7543 sep = (char_u *)" ";
7544 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007545 sep = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007546
7547 rettv->v_type = VAR_STRING;
7548
7549 if (sep != NULL)
7550 {
7551 ga_init2(&ga, (int)sizeof(char), 80);
7552 list_join(&ga, argvars[0].vval.v_list, sep, TRUE, FALSE, 0);
7553 ga_append(&ga, NUL);
7554 rettv->vval.v_string = (char_u *)ga.ga_data;
7555 }
7556 else
7557 rettv->vval.v_string = NULL;
7558}
7559
7560/*
7561 * "js_decode()" function
7562 */
7563 static void
7564f_js_decode(typval_T *argvars, typval_T *rettv)
7565{
7566 js_read_T reader;
7567
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007568 reader.js_buf = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007569 reader.js_fill = NULL;
7570 reader.js_used = 0;
7571 if (json_decode_all(&reader, rettv, JSON_JS) != OK)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007572 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007573}
7574
7575/*
7576 * "js_encode()" function
7577 */
7578 static void
7579f_js_encode(typval_T *argvars, typval_T *rettv)
7580{
7581 rettv->v_type = VAR_STRING;
7582 rettv->vval.v_string = json_encode(&argvars[0], JSON_JS);
7583}
7584
7585/*
7586 * "json_decode()" function
7587 */
7588 static void
7589f_json_decode(typval_T *argvars, typval_T *rettv)
7590{
7591 js_read_T reader;
7592
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007593 reader.js_buf = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007594 reader.js_fill = NULL;
7595 reader.js_used = 0;
Bram Moolenaar03c60c12017-01-10 15:15:37 +01007596 json_decode_all(&reader, rettv, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007597}
7598
7599/*
7600 * "json_encode()" function
7601 */
7602 static void
7603f_json_encode(typval_T *argvars, typval_T *rettv)
7604{
7605 rettv->v_type = VAR_STRING;
7606 rettv->vval.v_string = json_encode(&argvars[0], 0);
7607}
7608
7609/*
7610 * "keys()" function
7611 */
7612 static void
7613f_keys(typval_T *argvars, typval_T *rettv)
7614{
7615 dict_list(argvars, rettv, 0);
7616}
7617
7618/*
7619 * "last_buffer_nr()" function.
7620 */
7621 static void
7622f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv)
7623{
7624 int n = 0;
7625 buf_T *buf;
7626
Bram Moolenaar29323592016-07-24 22:04:11 +02007627 FOR_ALL_BUFFERS(buf)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007628 if (n < buf->b_fnum)
7629 n = buf->b_fnum;
7630
7631 rettv->vval.v_number = n;
7632}
7633
7634/*
7635 * "len()" function
7636 */
7637 static void
7638f_len(typval_T *argvars, typval_T *rettv)
7639{
7640 switch (argvars[0].v_type)
7641 {
7642 case VAR_STRING:
7643 case VAR_NUMBER:
7644 rettv->vval.v_number = (varnumber_T)STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007645 tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007646 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01007647 case VAR_BLOB:
7648 rettv->vval.v_number = blob_len(argvars[0].vval.v_blob);
7649 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007650 case VAR_LIST:
7651 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
7652 break;
7653 case VAR_DICT:
7654 rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
7655 break;
7656 case VAR_UNKNOWN:
7657 case VAR_SPECIAL:
7658 case VAR_FLOAT:
7659 case VAR_FUNC:
7660 case VAR_PARTIAL:
7661 case VAR_JOB:
7662 case VAR_CHANNEL:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007663 emsg(_("E701: Invalid type for len()"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007664 break;
7665 }
7666}
7667
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007668 static void
Bram Moolenaar6d721c72017-01-17 16:56:28 +01007669libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007670{
7671#ifdef FEAT_LIBCALL
7672 char_u *string_in;
7673 char_u **string_result;
7674 int nr_result;
7675#endif
7676
7677 rettv->v_type = type;
7678 if (type != VAR_NUMBER)
7679 rettv->vval.v_string = NULL;
7680
7681 if (check_restricted() || check_secure())
7682 return;
7683
7684#ifdef FEAT_LIBCALL
Bram Moolenaar9af41842016-09-25 21:45:05 +02007685 /* The first two args must be strings, otherwise it's meaningless */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007686 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
7687 {
7688 string_in = NULL;
7689 if (argvars[2].v_type == VAR_STRING)
7690 string_in = argvars[2].vval.v_string;
7691 if (type == VAR_NUMBER)
7692 string_result = NULL;
7693 else
7694 string_result = &rettv->vval.v_string;
7695 if (mch_libcall(argvars[0].vval.v_string,
7696 argvars[1].vval.v_string,
7697 string_in,
7698 argvars[2].vval.v_number,
7699 string_result,
7700 &nr_result) == OK
7701 && type == VAR_NUMBER)
7702 rettv->vval.v_number = nr_result;
7703 }
7704#endif
7705}
7706
7707/*
7708 * "libcall()" function
7709 */
7710 static void
7711f_libcall(typval_T *argvars, typval_T *rettv)
7712{
7713 libcall_common(argvars, rettv, VAR_STRING);
7714}
7715
7716/*
7717 * "libcallnr()" function
7718 */
7719 static void
7720f_libcallnr(typval_T *argvars, typval_T *rettv)
7721{
7722 libcall_common(argvars, rettv, VAR_NUMBER);
7723}
7724
7725/*
7726 * "line(string)" function
7727 */
7728 static void
7729f_line(typval_T *argvars, typval_T *rettv)
7730{
7731 linenr_T lnum = 0;
7732 pos_T *fp;
7733 int fnum;
7734
7735 fp = var2fpos(&argvars[0], TRUE, &fnum);
7736 if (fp != NULL)
7737 lnum = fp->lnum;
7738 rettv->vval.v_number = lnum;
7739}
7740
7741/*
7742 * "line2byte(lnum)" function
7743 */
7744 static void
7745f_line2byte(typval_T *argvars UNUSED, typval_T *rettv)
7746{
7747#ifndef FEAT_BYTEOFF
7748 rettv->vval.v_number = -1;
7749#else
7750 linenr_T lnum;
7751
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007752 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007753 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
7754 rettv->vval.v_number = -1;
7755 else
7756 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
7757 if (rettv->vval.v_number >= 0)
7758 ++rettv->vval.v_number;
7759#endif
7760}
7761
7762/*
7763 * "lispindent(lnum)" function
7764 */
7765 static void
7766f_lispindent(typval_T *argvars UNUSED, typval_T *rettv)
7767{
7768#ifdef FEAT_LISP
7769 pos_T pos;
7770 linenr_T lnum;
7771
7772 pos = curwin->w_cursor;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007773 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007774 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
7775 {
7776 curwin->w_cursor.lnum = lnum;
7777 rettv->vval.v_number = get_lisp_indent();
7778 curwin->w_cursor = pos;
7779 }
7780 else
7781#endif
7782 rettv->vval.v_number = -1;
7783}
7784
7785/*
7786 * "localtime()" function
7787 */
7788 static void
7789f_localtime(typval_T *argvars UNUSED, typval_T *rettv)
7790{
7791 rettv->vval.v_number = (varnumber_T)time(NULL);
7792}
7793
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007794 static void
7795get_maparg(typval_T *argvars, typval_T *rettv, int exact)
7796{
7797 char_u *keys;
7798 char_u *which;
7799 char_u buf[NUMBUFLEN];
7800 char_u *keys_buf = NULL;
7801 char_u *rhs;
7802 int mode;
7803 int abbr = FALSE;
7804 int get_dict = FALSE;
7805 mapblock_T *mp;
7806 int buffer_local;
7807
7808 /* return empty string for failure */
7809 rettv->v_type = VAR_STRING;
7810 rettv->vval.v_string = NULL;
7811
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007812 keys = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007813 if (*keys == NUL)
7814 return;
7815
7816 if (argvars[1].v_type != VAR_UNKNOWN)
7817 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007818 which = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007819 if (argvars[2].v_type != VAR_UNKNOWN)
7820 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007821 abbr = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007822 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007823 get_dict = (int)tv_get_number(&argvars[3]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007824 }
7825 }
7826 else
7827 which = (char_u *)"";
7828 if (which == NULL)
7829 return;
7830
7831 mode = get_map_mode(&which, 0);
7832
7833 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE, FALSE);
7834 rhs = check_map(keys, mode, exact, FALSE, abbr, &mp, &buffer_local);
7835 vim_free(keys_buf);
7836
7837 if (!get_dict)
7838 {
7839 /* Return a string. */
7840 if (rhs != NULL)
Bram Moolenaarf88a5bc2018-05-21 13:28:44 +02007841 {
7842 if (*rhs == NUL)
7843 rettv->vval.v_string = vim_strsave((char_u *)"<Nop>");
7844 else
7845 rettv->vval.v_string = str2special_save(rhs, FALSE);
7846 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007847
7848 }
7849 else if (rettv_dict_alloc(rettv) != FAIL && rhs != NULL)
7850 {
7851 /* Return a dictionary. */
7852 char_u *lhs = str2special_save(mp->m_keys, TRUE);
7853 char_u *mapmode = map_mode_to_chars(mp->m_mode);
7854 dict_T *dict = rettv->vval.v_dict;
7855
Bram Moolenaare0be1672018-07-08 16:50:37 +02007856 dict_add_string(dict, "lhs", lhs);
7857 dict_add_string(dict, "rhs", mp->m_orig_str);
7858 dict_add_number(dict, "noremap", mp->m_noremap ? 1L : 0L);
7859 dict_add_number(dict, "expr", mp->m_expr ? 1L : 0L);
7860 dict_add_number(dict, "silent", mp->m_silent ? 1L : 0L);
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02007861 dict_add_number(dict, "sid", (long)mp->m_script_ctx.sc_sid);
7862 dict_add_number(dict, "lnum", (long)mp->m_script_ctx.sc_lnum);
Bram Moolenaare0be1672018-07-08 16:50:37 +02007863 dict_add_number(dict, "buffer", (long)buffer_local);
7864 dict_add_number(dict, "nowait", mp->m_nowait ? 1L : 0L);
7865 dict_add_string(dict, "mode", mapmode);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007866
7867 vim_free(lhs);
7868 vim_free(mapmode);
7869 }
7870}
7871
7872#ifdef FEAT_FLOAT
7873/*
7874 * "log()" function
7875 */
7876 static void
7877f_log(typval_T *argvars, typval_T *rettv)
7878{
7879 float_T f = 0.0;
7880
7881 rettv->v_type = VAR_FLOAT;
7882 if (get_float_arg(argvars, &f) == OK)
7883 rettv->vval.v_float = log(f);
7884 else
7885 rettv->vval.v_float = 0.0;
7886}
7887
7888/*
7889 * "log10()" function
7890 */
7891 static void
7892f_log10(typval_T *argvars, typval_T *rettv)
7893{
7894 float_T f = 0.0;
7895
7896 rettv->v_type = VAR_FLOAT;
7897 if (get_float_arg(argvars, &f) == OK)
7898 rettv->vval.v_float = log10(f);
7899 else
7900 rettv->vval.v_float = 0.0;
7901}
7902#endif
7903
7904#ifdef FEAT_LUA
7905/*
7906 * "luaeval()" function
7907 */
7908 static void
7909f_luaeval(typval_T *argvars, typval_T *rettv)
7910{
7911 char_u *str;
7912 char_u buf[NUMBUFLEN];
7913
Bram Moolenaar8c62a082019-02-08 14:34:10 +01007914 if (check_restricted() || check_secure())
7915 return;
7916
Bram Moolenaard155d7a2018-12-21 16:04:21 +01007917 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007918 do_luaeval(str, argvars + 1, rettv);
7919}
7920#endif
7921
7922/*
7923 * "map()" function
7924 */
7925 static void
7926f_map(typval_T *argvars, typval_T *rettv)
7927{
7928 filter_map(argvars, rettv, TRUE);
7929}
7930
7931/*
7932 * "maparg()" function
7933 */
7934 static void
7935f_maparg(typval_T *argvars, typval_T *rettv)
7936{
7937 get_maparg(argvars, rettv, TRUE);
7938}
7939
7940/*
7941 * "mapcheck()" function
7942 */
7943 static void
7944f_mapcheck(typval_T *argvars, typval_T *rettv)
7945{
7946 get_maparg(argvars, rettv, FALSE);
7947}
7948
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007949typedef enum
7950{
7951 MATCH_END, /* matchend() */
7952 MATCH_MATCH, /* match() */
7953 MATCH_STR, /* matchstr() */
7954 MATCH_LIST, /* matchlist() */
7955 MATCH_POS /* matchstrpos() */
7956} matchtype_T;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007957
7958 static void
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007959find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007960{
7961 char_u *str = NULL;
7962 long len = 0;
7963 char_u *expr = NULL;
7964 char_u *pat;
7965 regmatch_T regmatch;
7966 char_u patbuf[NUMBUFLEN];
7967 char_u strbuf[NUMBUFLEN];
7968 char_u *save_cpo;
7969 long start = 0;
7970 long nth = 1;
7971 colnr_T startcol = 0;
7972 int match = 0;
7973 list_T *l = NULL;
7974 listitem_T *li = NULL;
7975 long idx = 0;
7976 char_u *tofree = NULL;
7977
7978 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
7979 save_cpo = p_cpo;
7980 p_cpo = (char_u *)"";
7981
7982 rettv->vval.v_number = -1;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007983 if (type == MATCH_LIST || type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007984 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007985 /* type MATCH_LIST: return empty list when there are no matches.
7986 * type MATCH_POS: return ["", -1, -1, -1] */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007987 if (rettv_list_alloc(rettv) == FAIL)
7988 goto theend;
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02007989 if (type == MATCH_POS
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007990 && (list_append_string(rettv->vval.v_list,
7991 (char_u *)"", 0) == FAIL
7992 || list_append_number(rettv->vval.v_list,
7993 (varnumber_T)-1) == FAIL
7994 || list_append_number(rettv->vval.v_list,
7995 (varnumber_T)-1) == FAIL
7996 || list_append_number(rettv->vval.v_list,
7997 (varnumber_T)-1) == FAIL))
7998 {
7999 list_free(rettv->vval.v_list);
8000 rettv->vval.v_list = NULL;
8001 goto theend;
8002 }
8003 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008004 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008005 {
8006 rettv->v_type = VAR_STRING;
8007 rettv->vval.v_string = NULL;
8008 }
8009
8010 if (argvars[0].v_type == VAR_LIST)
8011 {
8012 if ((l = argvars[0].vval.v_list) == NULL)
8013 goto theend;
8014 li = l->lv_first;
8015 }
8016 else
8017 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008018 expr = str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008019 len = (long)STRLEN(str);
8020 }
8021
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008022 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008023 if (pat == NULL)
8024 goto theend;
8025
8026 if (argvars[2].v_type != VAR_UNKNOWN)
8027 {
8028 int error = FALSE;
8029
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008030 start = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008031 if (error)
8032 goto theend;
8033 if (l != NULL)
8034 {
8035 li = list_find(l, start);
8036 if (li == NULL)
8037 goto theend;
8038 idx = l->lv_idx; /* use the cached index */
8039 }
8040 else
8041 {
8042 if (start < 0)
8043 start = 0;
8044 if (start > len)
8045 goto theend;
8046 /* When "count" argument is there ignore matches before "start",
8047 * otherwise skip part of the string. Differs when pattern is "^"
8048 * or "\<". */
8049 if (argvars[3].v_type != VAR_UNKNOWN)
8050 startcol = start;
8051 else
8052 {
8053 str += start;
8054 len -= start;
8055 }
8056 }
8057
8058 if (argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008059 nth = (long)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008060 if (error)
8061 goto theend;
8062 }
8063
8064 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
8065 if (regmatch.regprog != NULL)
8066 {
8067 regmatch.rm_ic = p_ic;
8068
8069 for (;;)
8070 {
8071 if (l != NULL)
8072 {
8073 if (li == NULL)
8074 {
8075 match = FALSE;
8076 break;
8077 }
8078 vim_free(tofree);
8079 expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0);
8080 if (str == NULL)
8081 break;
8082 }
8083
8084 match = vim_regexec_nl(&regmatch, str, (colnr_T)startcol);
8085
8086 if (match && --nth <= 0)
8087 break;
8088 if (l == NULL && !match)
8089 break;
8090
8091 /* Advance to just after the match. */
8092 if (l != NULL)
8093 {
8094 li = li->li_next;
8095 ++idx;
8096 }
8097 else
8098 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008099 startcol = (colnr_T)(regmatch.startp[0]
8100 + (*mb_ptr2len)(regmatch.startp[0]) - str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008101 if (startcol > (colnr_T)len
8102 || str + startcol <= regmatch.startp[0])
8103 {
8104 match = FALSE;
8105 break;
8106 }
8107 }
8108 }
8109
8110 if (match)
8111 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008112 if (type == MATCH_POS)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008113 {
8114 listitem_T *li1 = rettv->vval.v_list->lv_first;
8115 listitem_T *li2 = li1->li_next;
8116 listitem_T *li3 = li2->li_next;
8117 listitem_T *li4 = li3->li_next;
8118
8119 vim_free(li1->li_tv.vval.v_string);
8120 li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0],
8121 (int)(regmatch.endp[0] - regmatch.startp[0]));
8122 li3->li_tv.vval.v_number =
8123 (varnumber_T)(regmatch.startp[0] - expr);
8124 li4->li_tv.vval.v_number =
8125 (varnumber_T)(regmatch.endp[0] - expr);
8126 if (l != NULL)
8127 li2->li_tv.vval.v_number = (varnumber_T)idx;
8128 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008129 else if (type == MATCH_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008130 {
8131 int i;
8132
8133 /* return list with matched string and submatches */
8134 for (i = 0; i < NSUBEXP; ++i)
8135 {
8136 if (regmatch.endp[i] == NULL)
8137 {
8138 if (list_append_string(rettv->vval.v_list,
8139 (char_u *)"", 0) == FAIL)
8140 break;
8141 }
8142 else if (list_append_string(rettv->vval.v_list,
8143 regmatch.startp[i],
8144 (int)(regmatch.endp[i] - regmatch.startp[i]))
8145 == FAIL)
8146 break;
8147 }
8148 }
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008149 else if (type == MATCH_STR)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008150 {
8151 /* return matched string */
8152 if (l != NULL)
8153 copy_tv(&li->li_tv, rettv);
8154 else
8155 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
8156 (int)(regmatch.endp[0] - regmatch.startp[0]));
8157 }
8158 else if (l != NULL)
8159 rettv->vval.v_number = idx;
8160 else
8161 {
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008162 if (type != MATCH_END)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008163 rettv->vval.v_number =
8164 (varnumber_T)(regmatch.startp[0] - str);
8165 else
8166 rettv->vval.v_number =
8167 (varnumber_T)(regmatch.endp[0] - str);
8168 rettv->vval.v_number += (varnumber_T)(str - expr);
8169 }
8170 }
8171 vim_regfree(regmatch.regprog);
8172 }
8173
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008174theend:
8175 if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008176 /* matchstrpos() without a list: drop the second item. */
8177 listitem_remove(rettv->vval.v_list,
8178 rettv->vval.v_list->lv_first->li_next);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008179 vim_free(tofree);
8180 p_cpo = save_cpo;
8181}
8182
8183/*
8184 * "match()" function
8185 */
8186 static void
8187f_match(typval_T *argvars, typval_T *rettv)
8188{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008189 find_some_match(argvars, rettv, MATCH_MATCH);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008190}
8191
Bram Moolenaar95e51472018-07-28 16:55:56 +02008192#ifdef FEAT_SEARCH_EXTRA
8193 static int
8194matchadd_dict_arg(typval_T *tv, char_u **conceal_char, win_T **win)
8195{
8196 dictitem_T *di;
8197
8198 if (tv->v_type != VAR_DICT)
8199 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008200 emsg(_(e_dictreq));
Bram Moolenaar95e51472018-07-28 16:55:56 +02008201 return FAIL;
8202 }
8203
8204 if (dict_find(tv->vval.v_dict, (char_u *)"conceal", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +01008205 *conceal_char = dict_get_string(tv->vval.v_dict,
Bram Moolenaar95e51472018-07-28 16:55:56 +02008206 (char_u *)"conceal", FALSE);
8207
8208 if ((di = dict_find(tv->vval.v_dict, (char_u *)"window", -1)) != NULL)
8209 {
Bram Moolenaarbabfcf52018-10-25 13:11:16 +02008210 *win = find_win_by_nr_or_id(&di->di_tv);
Bram Moolenaar95e51472018-07-28 16:55:56 +02008211 if (*win == NULL)
8212 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008213 emsg(_("E957: Invalid window number"));
Bram Moolenaar95e51472018-07-28 16:55:56 +02008214 return FAIL;
8215 }
8216 }
8217
8218 return OK;
8219}
8220#endif
8221
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008222/*
8223 * "matchadd()" function
8224 */
8225 static void
8226f_matchadd(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8227{
8228#ifdef FEAT_SEARCH_EXTRA
8229 char_u buf[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008230 char_u *grp = tv_get_string_buf_chk(&argvars[0], buf); /* group */
8231 char_u *pat = tv_get_string_buf_chk(&argvars[1], buf); /* pattern */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008232 int prio = 10; /* default priority */
8233 int id = -1;
8234 int error = FALSE;
8235 char_u *conceal_char = NULL;
Bram Moolenaar95e51472018-07-28 16:55:56 +02008236 win_T *win = curwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008237
8238 rettv->vval.v_number = -1;
8239
8240 if (grp == NULL || pat == NULL)
8241 return;
8242 if (argvars[2].v_type != VAR_UNKNOWN)
8243 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008244 prio = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008245 if (argvars[3].v_type != VAR_UNKNOWN)
8246 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008247 id = (int)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar95e51472018-07-28 16:55:56 +02008248 if (argvars[4].v_type != VAR_UNKNOWN
8249 && matchadd_dict_arg(&argvars[4], &conceal_char, &win) == FAIL)
8250 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008251 }
8252 }
8253 if (error == TRUE)
8254 return;
8255 if (id >= 1 && id <= 3)
8256 {
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01008257 semsg(_("E798: ID is reserved for \":match\": %d"), id);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008258 return;
8259 }
8260
Bram Moolenaar95e51472018-07-28 16:55:56 +02008261 rettv->vval.v_number = match_add(win, grp, pat, prio, id, NULL,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008262 conceal_char);
8263#endif
8264}
8265
8266/*
8267 * "matchaddpos()" function
8268 */
8269 static void
8270f_matchaddpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8271{
8272#ifdef FEAT_SEARCH_EXTRA
8273 char_u buf[NUMBUFLEN];
8274 char_u *group;
8275 int prio = 10;
8276 int id = -1;
8277 int error = FALSE;
8278 list_T *l;
8279 char_u *conceal_char = NULL;
Bram Moolenaar95e51472018-07-28 16:55:56 +02008280 win_T *win = curwin;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008281
8282 rettv->vval.v_number = -1;
8283
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008284 group = tv_get_string_buf_chk(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008285 if (group == NULL)
8286 return;
8287
8288 if (argvars[1].v_type != VAR_LIST)
8289 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008290 semsg(_(e_listarg), "matchaddpos()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008291 return;
8292 }
8293 l = argvars[1].vval.v_list;
8294 if (l == NULL)
8295 return;
8296
8297 if (argvars[2].v_type != VAR_UNKNOWN)
8298 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008299 prio = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008300 if (argvars[3].v_type != VAR_UNKNOWN)
8301 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008302 id = (int)tv_get_number_chk(&argvars[3], &error);
Bram Moolenaar95e51472018-07-28 16:55:56 +02008303
8304 if (argvars[4].v_type != VAR_UNKNOWN
8305 && matchadd_dict_arg(&argvars[4], &conceal_char, &win) == FAIL)
8306 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008307 }
8308 }
8309 if (error == TRUE)
8310 return;
8311
8312 /* id == 3 is ok because matchaddpos() is supposed to substitute :3match */
8313 if (id == 1 || id == 2)
8314 {
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01008315 semsg(_("E798: ID is reserved for \":match\": %d"), id);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008316 return;
8317 }
8318
Bram Moolenaar95e51472018-07-28 16:55:56 +02008319 rettv->vval.v_number = match_add(win, group, NULL, prio, id, l,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008320 conceal_char);
8321#endif
8322}
8323
8324/*
8325 * "matcharg()" function
8326 */
8327 static void
8328f_matcharg(typval_T *argvars UNUSED, typval_T *rettv)
8329{
8330 if (rettv_list_alloc(rettv) == OK)
8331 {
8332#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008333 int id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008334 matchitem_T *m;
8335
8336 if (id >= 1 && id <= 3)
8337 {
8338 if ((m = (matchitem_T *)get_match(curwin, id)) != NULL)
8339 {
8340 list_append_string(rettv->vval.v_list,
8341 syn_id2name(m->hlg_id), -1);
8342 list_append_string(rettv->vval.v_list, m->pattern, -1);
8343 }
8344 else
8345 {
8346 list_append_string(rettv->vval.v_list, NULL, -1);
8347 list_append_string(rettv->vval.v_list, NULL, -1);
8348 }
8349 }
8350#endif
8351 }
8352}
8353
8354/*
8355 * "matchdelete()" function
8356 */
8357 static void
8358f_matchdelete(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8359{
8360#ifdef FEAT_SEARCH_EXTRA
8361 rettv->vval.v_number = match_delete(curwin,
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008362 (int)tv_get_number(&argvars[0]), TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008363#endif
8364}
8365
8366/*
8367 * "matchend()" function
8368 */
8369 static void
8370f_matchend(typval_T *argvars, typval_T *rettv)
8371{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008372 find_some_match(argvars, rettv, MATCH_END);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008373}
8374
8375/*
8376 * "matchlist()" function
8377 */
8378 static void
8379f_matchlist(typval_T *argvars, typval_T *rettv)
8380{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008381 find_some_match(argvars, rettv, MATCH_LIST);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008382}
8383
8384/*
8385 * "matchstr()" function
8386 */
8387 static void
8388f_matchstr(typval_T *argvars, typval_T *rettv)
8389{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008390 find_some_match(argvars, rettv, MATCH_STR);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008391}
8392
8393/*
8394 * "matchstrpos()" function
8395 */
8396 static void
8397f_matchstrpos(typval_T *argvars, typval_T *rettv)
8398{
Bram Moolenaar8d9f0ef2017-08-27 13:51:01 +02008399 find_some_match(argvars, rettv, MATCH_POS);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008400}
8401
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008402 static void
8403max_min(typval_T *argvars, typval_T *rettv, int domax)
8404{
8405 varnumber_T n = 0;
8406 varnumber_T i;
8407 int error = FALSE;
8408
8409 if (argvars[0].v_type == VAR_LIST)
8410 {
8411 list_T *l;
8412 listitem_T *li;
8413
8414 l = argvars[0].vval.v_list;
8415 if (l != NULL)
8416 {
8417 li = l->lv_first;
8418 if (li != NULL)
8419 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008420 n = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008421 for (;;)
8422 {
8423 li = li->li_next;
8424 if (li == NULL)
8425 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008426 i = tv_get_number_chk(&li->li_tv, &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008427 if (domax ? i > n : i < n)
8428 n = i;
8429 }
8430 }
8431 }
8432 }
8433 else if (argvars[0].v_type == VAR_DICT)
8434 {
8435 dict_T *d;
8436 int first = TRUE;
8437 hashitem_T *hi;
8438 int todo;
8439
8440 d = argvars[0].vval.v_dict;
8441 if (d != NULL)
8442 {
8443 todo = (int)d->dv_hashtab.ht_used;
8444 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
8445 {
8446 if (!HASHITEM_EMPTY(hi))
8447 {
8448 --todo;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008449 i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008450 if (first)
8451 {
8452 n = i;
8453 first = FALSE;
8454 }
8455 else if (domax ? i > n : i < n)
8456 n = i;
8457 }
8458 }
8459 }
8460 }
8461 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008462 semsg(_(e_listdictarg), domax ? "max()" : "min()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008463 rettv->vval.v_number = error ? 0 : n;
8464}
8465
8466/*
8467 * "max()" function
8468 */
8469 static void
8470f_max(typval_T *argvars, typval_T *rettv)
8471{
8472 max_min(argvars, rettv, TRUE);
8473}
8474
8475/*
8476 * "min()" function
8477 */
8478 static void
8479f_min(typval_T *argvars, typval_T *rettv)
8480{
8481 max_min(argvars, rettv, FALSE);
8482}
8483
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008484/*
8485 * Create the directory in which "dir" is located, and higher levels when
8486 * needed.
Bram Moolenaar7860bac2017-04-09 15:03:15 +02008487 * Return OK or FAIL.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008488 */
8489 static int
8490mkdir_recurse(char_u *dir, int prot)
8491{
8492 char_u *p;
8493 char_u *updir;
8494 int r = FAIL;
8495
8496 /* Get end of directory name in "dir".
8497 * We're done when it's "/" or "c:/". */
8498 p = gettail_sep(dir);
8499 if (p <= get_past_head(dir))
8500 return OK;
8501
8502 /* If the directory exists we're done. Otherwise: create it.*/
8503 updir = vim_strnsave(dir, (int)(p - dir));
8504 if (updir == NULL)
8505 return FAIL;
8506 if (mch_isdir(updir))
8507 r = OK;
8508 else if (mkdir_recurse(updir, prot) == OK)
8509 r = vim_mkdir_emsg(updir, prot);
8510 vim_free(updir);
8511 return r;
8512}
8513
8514#ifdef vim_mkdir
8515/*
8516 * "mkdir()" function
8517 */
8518 static void
8519f_mkdir(typval_T *argvars, typval_T *rettv)
8520{
8521 char_u *dir;
8522 char_u buf[NUMBUFLEN];
8523 int prot = 0755;
8524
8525 rettv->vval.v_number = FAIL;
8526 if (check_restricted() || check_secure())
8527 return;
8528
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008529 dir = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008530 if (*dir == NUL)
Bram Moolenaar78a16b02018-04-14 13:51:55 +02008531 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008532
Bram Moolenaar78a16b02018-04-14 13:51:55 +02008533 if (*gettail(dir) == NUL)
8534 /* remove trailing slashes */
8535 *gettail_sep(dir) = NUL;
8536
8537 if (argvars[1].v_type != VAR_UNKNOWN)
8538 {
8539 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008540 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008541 prot = (int)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar78a16b02018-04-14 13:51:55 +02008542 if (prot == -1)
8543 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008544 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008545 if (STRCMP(tv_get_string(&argvars[1]), "p") == 0)
Bram Moolenaar78a16b02018-04-14 13:51:55 +02008546 {
8547 if (mch_isdir(dir))
8548 {
8549 /* With the "p" flag it's OK if the dir already exists. */
8550 rettv->vval.v_number = OK;
8551 return;
8552 }
8553 mkdir_recurse(dir, prot);
8554 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008555 }
Bram Moolenaar78a16b02018-04-14 13:51:55 +02008556 rettv->vval.v_number = vim_mkdir_emsg(dir, prot);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008557}
8558#endif
8559
8560/*
8561 * "mode()" function
8562 */
8563 static void
8564f_mode(typval_T *argvars, typval_T *rettv)
8565{
Bram Moolenaar612cc382018-07-29 15:34:26 +02008566 char_u buf[4];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008567
Bram Moolenaar612cc382018-07-29 15:34:26 +02008568 vim_memset(buf, 0, sizeof(buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008569
8570 if (time_for_testing == 93784)
8571 {
8572 /* Testing the two-character code. */
8573 buf[0] = 'x';
8574 buf[1] = '!';
8575 }
Bram Moolenaar2bb7b6b2017-08-13 20:58:33 +02008576#ifdef FEAT_TERMINAL
8577 else if (term_use_loop())
8578 buf[0] = 't';
8579#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008580 else if (VIsual_active)
8581 {
8582 if (VIsual_select)
8583 buf[0] = VIsual_mode + 's' - 'v';
8584 else
8585 buf[0] = VIsual_mode;
8586 }
8587 else if (State == HITRETURN || State == ASKMORE || State == SETWSIZE
8588 || State == CONFIRM)
8589 {
8590 buf[0] = 'r';
8591 if (State == ASKMORE)
8592 buf[1] = 'm';
8593 else if (State == CONFIRM)
8594 buf[1] = '?';
8595 }
8596 else if (State == EXTERNCMD)
8597 buf[0] = '!';
8598 else if (State & INSERT)
8599 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008600 if (State & VREPLACE_FLAG)
8601 {
8602 buf[0] = 'R';
8603 buf[1] = 'v';
8604 }
8605 else
Bram Moolenaare90858d2017-02-01 17:24:34 +01008606 {
8607 if (State & REPLACE_FLAG)
8608 buf[0] = 'R';
8609 else
8610 buf[0] = 'i';
8611#ifdef FEAT_INS_EXPAND
8612 if (ins_compl_active())
8613 buf[1] = 'c';
Bram Moolenaar05625322018-02-09 12:28:00 +01008614 else if (ctrl_x_mode_not_defined_yet())
Bram Moolenaare90858d2017-02-01 17:24:34 +01008615 buf[1] = 'x';
8616#endif
8617 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008618 }
Bram Moolenaare90858d2017-02-01 17:24:34 +01008619 else if ((State & CMDLINE) || exmode_active)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008620 {
8621 buf[0] = 'c';
Bram Moolenaare90858d2017-02-01 17:24:34 +01008622 if (exmode_active == EXMODE_VIM)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008623 buf[1] = 'v';
Bram Moolenaare90858d2017-02-01 17:24:34 +01008624 else if (exmode_active == EXMODE_NORMAL)
8625 buf[1] = 'e';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008626 }
8627 else
8628 {
8629 buf[0] = 'n';
8630 if (finish_op)
Bram Moolenaar5976f8f2018-12-27 23:44:44 +01008631 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008632 buf[1] = 'o';
Bram Moolenaar5976f8f2018-12-27 23:44:44 +01008633 // to be able to detect force-linewise/blockwise/characterwise operations
8634 buf[2] = motion_force;
8635 }
Bram Moolenaar612cc382018-07-29 15:34:26 +02008636 else if (restart_edit == 'I' || restart_edit == 'R'
8637 || restart_edit == 'V')
8638 {
8639 buf[1] = 'i';
8640 buf[2] = restart_edit;
8641 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008642 }
8643
8644 /* Clear out the minor mode when the argument is not a non-zero number or
8645 * non-empty string. */
8646 if (!non_zero_arg(&argvars[0]))
8647 buf[1] = NUL;
8648
8649 rettv->vval.v_string = vim_strsave(buf);
8650 rettv->v_type = VAR_STRING;
8651}
8652
8653#if defined(FEAT_MZSCHEME) || defined(PROTO)
8654/*
8655 * "mzeval()" function
8656 */
8657 static void
8658f_mzeval(typval_T *argvars, typval_T *rettv)
8659{
8660 char_u *str;
8661 char_u buf[NUMBUFLEN];
8662
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008663 if (check_restricted() || check_secure())
8664 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008665 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008666 do_mzeval(str, rettv);
8667}
8668
8669 void
8670mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv)
8671{
8672 typval_T argvars[3];
8673
8674 argvars[0].v_type = VAR_STRING;
8675 argvars[0].vval.v_string = name;
8676 copy_tv(args, &argvars[1]);
8677 argvars[2].v_type = VAR_UNKNOWN;
8678 f_call(argvars, rettv);
8679 clear_tv(&argvars[1]);
8680}
8681#endif
8682
8683/*
8684 * "nextnonblank()" function
8685 */
8686 static void
8687f_nextnonblank(typval_T *argvars, typval_T *rettv)
8688{
8689 linenr_T lnum;
8690
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008691 for (lnum = tv_get_lnum(argvars); ; ++lnum)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008692 {
8693 if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count)
8694 {
8695 lnum = 0;
8696 break;
8697 }
8698 if (*skipwhite(ml_get(lnum)) != NUL)
8699 break;
8700 }
8701 rettv->vval.v_number = lnum;
8702}
8703
8704/*
8705 * "nr2char()" function
8706 */
8707 static void
8708f_nr2char(typval_T *argvars, typval_T *rettv)
8709{
8710 char_u buf[NUMBUFLEN];
8711
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008712 if (has_mbyte)
8713 {
8714 int utf8 = 0;
8715
8716 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008717 utf8 = (int)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008718 if (utf8)
Bram Moolenaarbdace832019-03-02 10:13:42 +01008719 buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008720 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008721 buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008722 }
8723 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008724 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008725 buf[0] = (char_u)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008726 buf[1] = NUL;
8727 }
8728 rettv->v_type = VAR_STRING;
8729 rettv->vval.v_string = vim_strsave(buf);
8730}
8731
8732/*
8733 * "or(expr, expr)" function
8734 */
8735 static void
8736f_or(typval_T *argvars, typval_T *rettv)
8737{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008738 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
8739 | tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008740}
8741
8742/*
8743 * "pathshorten()" function
8744 */
8745 static void
8746f_pathshorten(typval_T *argvars, typval_T *rettv)
8747{
8748 char_u *p;
8749
8750 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008751 p = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008752 if (p == NULL)
8753 rettv->vval.v_string = NULL;
8754 else
8755 {
8756 p = vim_strsave(p);
8757 rettv->vval.v_string = p;
8758 if (p != NULL)
8759 shorten_dir(p);
8760 }
8761}
8762
8763#ifdef FEAT_PERL
8764/*
8765 * "perleval()" function
8766 */
8767 static void
8768f_perleval(typval_T *argvars, typval_T *rettv)
8769{
8770 char_u *str;
8771 char_u buf[NUMBUFLEN];
8772
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008773 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008774 do_perleval(str, rettv);
8775}
8776#endif
8777
8778#ifdef FEAT_FLOAT
8779/*
8780 * "pow()" function
8781 */
8782 static void
8783f_pow(typval_T *argvars, typval_T *rettv)
8784{
8785 float_T fx = 0.0, fy = 0.0;
8786
8787 rettv->v_type = VAR_FLOAT;
8788 if (get_float_arg(argvars, &fx) == OK
8789 && get_float_arg(&argvars[1], &fy) == OK)
8790 rettv->vval.v_float = pow(fx, fy);
8791 else
8792 rettv->vval.v_float = 0.0;
8793}
8794#endif
8795
8796/*
8797 * "prevnonblank()" function
8798 */
8799 static void
8800f_prevnonblank(typval_T *argvars, typval_T *rettv)
8801{
8802 linenr_T lnum;
8803
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008804 lnum = tv_get_lnum(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008805 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
8806 lnum = 0;
8807 else
8808 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
8809 --lnum;
8810 rettv->vval.v_number = lnum;
8811}
8812
8813/* This dummy va_list is here because:
8814 * - passing a NULL pointer doesn't work when va_list isn't a pointer
8815 * - locally in the function results in a "used before set" warning
8816 * - using va_start() to initialize it gives "function with fixed args" error */
8817static va_list ap;
8818
8819/*
8820 * "printf()" function
8821 */
8822 static void
8823f_printf(typval_T *argvars, typval_T *rettv)
8824{
8825 char_u buf[NUMBUFLEN];
8826 int len;
8827 char_u *s;
8828 int saved_did_emsg = did_emsg;
8829 char *fmt;
8830
8831 rettv->v_type = VAR_STRING;
8832 rettv->vval.v_string = NULL;
8833
8834 /* Get the required length, allocate the buffer and do it for real. */
8835 did_emsg = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008836 fmt = (char *)tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008837 len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008838 if (!did_emsg)
8839 {
8840 s = alloc(len + 1);
8841 if (s != NULL)
8842 {
8843 rettv->vval.v_string = s;
Bram Moolenaar8327d1d2017-07-11 22:34:51 +02008844 (void)vim_vsnprintf_typval((char *)s, len + 1, fmt,
8845 ap, argvars + 1);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008846 }
8847 }
8848 did_emsg |= saved_did_emsg;
8849}
8850
Bram Moolenaarf2732452018-06-03 14:47:35 +02008851#ifdef FEAT_JOB_CHANNEL
8852/*
8853 * "prompt_setcallback({buffer}, {callback})" function
8854 */
8855 static void
8856f_prompt_setcallback(typval_T *argvars, typval_T *rettv UNUSED)
8857{
8858 buf_T *buf;
8859 char_u *callback;
8860 partial_T *partial;
8861
8862 if (check_secure())
8863 return;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01008864 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaarf2732452018-06-03 14:47:35 +02008865 if (buf == NULL)
8866 return;
8867
8868 callback = get_callback(&argvars[1], &partial);
8869 if (callback == NULL)
8870 return;
8871
8872 free_callback(buf->b_prompt_callback, buf->b_prompt_partial);
8873 if (partial == NULL)
8874 buf->b_prompt_callback = vim_strsave(callback);
8875 else
8876 /* pointer into the partial */
8877 buf->b_prompt_callback = callback;
8878 buf->b_prompt_partial = partial;
8879}
8880
8881/*
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02008882 * "prompt_setinterrupt({buffer}, {callback})" function
8883 */
8884 static void
8885f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv UNUSED)
8886{
8887 buf_T *buf;
8888 char_u *callback;
8889 partial_T *partial;
8890
8891 if (check_secure())
8892 return;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01008893 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02008894 if (buf == NULL)
8895 return;
8896
8897 callback = get_callback(&argvars[1], &partial);
8898 if (callback == NULL)
8899 return;
8900
8901 free_callback(buf->b_prompt_interrupt, buf->b_prompt_int_partial);
8902 if (partial == NULL)
8903 buf->b_prompt_interrupt = vim_strsave(callback);
8904 else
8905 /* pointer into the partial */
8906 buf->b_prompt_interrupt = callback;
8907 buf->b_prompt_int_partial = partial;
8908}
8909
8910/*
Bram Moolenaarf2732452018-06-03 14:47:35 +02008911 * "prompt_setprompt({buffer}, {text})" function
8912 */
8913 static void
8914f_prompt_setprompt(typval_T *argvars, typval_T *rettv UNUSED)
8915{
8916 buf_T *buf;
8917 char_u *text;
8918
8919 if (check_secure())
8920 return;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +01008921 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaarf2732452018-06-03 14:47:35 +02008922 if (buf == NULL)
8923 return;
8924
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008925 text = tv_get_string(&argvars[1]);
Bram Moolenaarf2732452018-06-03 14:47:35 +02008926 vim_free(buf->b_prompt_text);
8927 buf->b_prompt_text = vim_strsave(text);
8928}
8929#endif
8930
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008931/*
8932 * "pumvisible()" function
8933 */
8934 static void
8935f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
8936{
8937#ifdef FEAT_INS_EXPAND
8938 if (pum_visible())
8939 rettv->vval.v_number = 1;
8940#endif
8941}
8942
8943#ifdef FEAT_PYTHON3
8944/*
8945 * "py3eval()" function
8946 */
8947 static void
8948f_py3eval(typval_T *argvars, typval_T *rettv)
8949{
8950 char_u *str;
8951 char_u buf[NUMBUFLEN];
8952
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008953 if (check_restricted() || check_secure())
8954 return;
8955
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008956 if (p_pyx == 0)
8957 p_pyx = 3;
8958
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008959 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008960 do_py3eval(str, rettv);
8961}
8962#endif
8963
8964#ifdef FEAT_PYTHON
8965/*
8966 * "pyeval()" function
8967 */
8968 static void
8969f_pyeval(typval_T *argvars, typval_T *rettv)
8970{
8971 char_u *str;
8972 char_u buf[NUMBUFLEN];
8973
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008974 if (check_restricted() || check_secure())
8975 return;
8976
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008977 if (p_pyx == 0)
8978 p_pyx = 2;
8979
Bram Moolenaard155d7a2018-12-21 16:04:21 +01008980 str = tv_get_string_buf(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008981 do_pyeval(str, rettv);
8982}
8983#endif
8984
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008985#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
8986/*
8987 * "pyxeval()" function
8988 */
8989 static void
8990f_pyxeval(typval_T *argvars, typval_T *rettv)
8991{
Bram Moolenaar8c62a082019-02-08 14:34:10 +01008992 if (check_restricted() || check_secure())
8993 return;
8994
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01008995# if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
8996 init_pyxversion();
8997 if (p_pyx == 2)
8998 f_pyeval(argvars, rettv);
8999 else
9000 f_py3eval(argvars, rettv);
9001# elif defined(FEAT_PYTHON)
9002 f_pyeval(argvars, rettv);
9003# elif defined(FEAT_PYTHON3)
9004 f_py3eval(argvars, rettv);
9005# endif
9006}
9007#endif
9008
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009009/*
9010 * "range()" function
9011 */
9012 static void
9013f_range(typval_T *argvars, typval_T *rettv)
9014{
9015 varnumber_T start;
9016 varnumber_T end;
9017 varnumber_T stride = 1;
9018 varnumber_T i;
9019 int error = FALSE;
9020
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009021 start = tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009022 if (argvars[1].v_type == VAR_UNKNOWN)
9023 {
9024 end = start - 1;
9025 start = 0;
9026 }
9027 else
9028 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009029 end = tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009030 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009031 stride = tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009032 }
9033
9034 if (error)
9035 return; /* type error; errmsg already given */
9036 if (stride == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009037 emsg(_("E726: Stride is zero"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009038 else if (stride > 0 ? end + 1 < start : end - 1 > start)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009039 emsg(_("E727: Start past end"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009040 else
9041 {
9042 if (rettv_list_alloc(rettv) == OK)
9043 for (i = start; stride > 0 ? i <= end : i >= end; i += stride)
9044 if (list_append_number(rettv->vval.v_list,
9045 (varnumber_T)i) == FAIL)
9046 break;
9047 }
9048}
9049
9050/*
9051 * "readfile()" function
9052 */
9053 static void
9054f_readfile(typval_T *argvars, typval_T *rettv)
9055{
9056 int binary = FALSE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009057 int blob = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009058 int failed = FALSE;
9059 char_u *fname;
9060 FILE *fd;
9061 char_u buf[(IOSIZE/256)*256]; /* rounded to avoid odd + 1 */
9062 int io_size = sizeof(buf);
9063 int readlen; /* size of last fread() */
9064 char_u *prev = NULL; /* previously read bytes, if any */
9065 long prevlen = 0; /* length of data in prev */
9066 long prevsize = 0; /* size of prev buffer */
9067 long maxline = MAXLNUM;
9068 long cnt = 0;
9069 char_u *p; /* position in buf */
9070 char_u *start; /* start of current line */
9071
9072 if (argvars[1].v_type != VAR_UNKNOWN)
9073 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009074 if (STRCMP(tv_get_string(&argvars[1]), "b") == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009075 binary = TRUE;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009076 if (STRCMP(tv_get_string(&argvars[1]), "B") == 0)
9077 blob = TRUE;
9078
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009079 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009080 maxline = (long)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009081 }
9082
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009083 if (blob)
9084 {
9085 if (rettv_blob_alloc(rettv) == FAIL)
9086 return;
9087 }
9088 else
9089 {
9090 if (rettv_list_alloc(rettv) == FAIL)
9091 return;
9092 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009093
9094 /* Always open the file in binary mode, library functions have a mind of
9095 * their own about CR-LF conversion. */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009096 fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009097 if (*fname == NUL || (fd = mch_fopen((char *)fname, READBIN)) == NULL)
9098 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009099 semsg(_(e_notopen), *fname == NUL ? (char_u *)_("<empty>") : fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009100 return;
9101 }
9102
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009103 if (blob)
9104 {
9105 if (read_blob(fd, rettv->vval.v_blob) == FAIL)
9106 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009107 emsg("cannot read file");
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009108 blob_free(rettv->vval.v_blob);
9109 }
9110 fclose(fd);
9111 return;
9112 }
9113
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009114 while (cnt < maxline || maxline < 0)
9115 {
9116 readlen = (int)fread(buf, 1, io_size, fd);
9117
9118 /* This for loop processes what was read, but is also entered at end
9119 * of file so that either:
9120 * - an incomplete line gets written
9121 * - a "binary" file gets an empty line at the end if it ends in a
9122 * newline. */
9123 for (p = buf, start = buf;
9124 p < buf + readlen || (readlen <= 0 && (prevlen > 0 || binary));
9125 ++p)
9126 {
9127 if (*p == '\n' || readlen <= 0)
9128 {
9129 listitem_T *li;
9130 char_u *s = NULL;
9131 long_u len = p - start;
9132
9133 /* Finished a line. Remove CRs before NL. */
9134 if (readlen > 0 && !binary)
9135 {
9136 while (len > 0 && start[len - 1] == '\r')
9137 --len;
9138 /* removal may cross back to the "prev" string */
9139 if (len == 0)
9140 while (prevlen > 0 && prev[prevlen - 1] == '\r')
9141 --prevlen;
9142 }
9143 if (prevlen == 0)
9144 s = vim_strnsave(start, (int)len);
9145 else
9146 {
9147 /* Change "prev" buffer to be the right size. This way
9148 * the bytes are only copied once, and very long lines are
9149 * allocated only once. */
9150 if ((s = vim_realloc(prev, prevlen + len + 1)) != NULL)
9151 {
9152 mch_memmove(s + prevlen, start, len);
9153 s[prevlen + len] = NUL;
9154 prev = NULL; /* the list will own the string */
9155 prevlen = prevsize = 0;
9156 }
9157 }
9158 if (s == NULL)
9159 {
9160 do_outofmem_msg((long_u) prevlen + len + 1);
9161 failed = TRUE;
9162 break;
9163 }
9164
9165 if ((li = listitem_alloc()) == NULL)
9166 {
9167 vim_free(s);
9168 failed = TRUE;
9169 break;
9170 }
9171 li->li_tv.v_type = VAR_STRING;
9172 li->li_tv.v_lock = 0;
9173 li->li_tv.vval.v_string = s;
9174 list_append(rettv->vval.v_list, li);
9175
9176 start = p + 1; /* step over newline */
9177 if ((++cnt >= maxline && maxline >= 0) || readlen <= 0)
9178 break;
9179 }
9180 else if (*p == NUL)
9181 *p = '\n';
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009182 /* Check for utf8 "bom"; U+FEFF is encoded as EF BB BF. Do this
9183 * when finding the BF and check the previous two bytes. */
9184 else if (*p == 0xbf && enc_utf8 && !binary)
9185 {
9186 /* Find the two bytes before the 0xbf. If p is at buf, or buf
9187 * + 1, these may be in the "prev" string. */
9188 char_u back1 = p >= buf + 1 ? p[-1]
9189 : prevlen >= 1 ? prev[prevlen - 1] : NUL;
9190 char_u back2 = p >= buf + 2 ? p[-2]
9191 : p == buf + 1 && prevlen >= 1 ? prev[prevlen - 1]
9192 : prevlen >= 2 ? prev[prevlen - 2] : NUL;
9193
9194 if (back2 == 0xef && back1 == 0xbb)
9195 {
9196 char_u *dest = p - 2;
9197
9198 /* Usually a BOM is at the beginning of a file, and so at
9199 * the beginning of a line; then we can just step over it.
9200 */
9201 if (start == dest)
9202 start = p + 1;
9203 else
9204 {
9205 /* have to shuffle buf to close gap */
9206 int adjust_prevlen = 0;
9207
9208 if (dest < buf)
9209 {
9210 adjust_prevlen = (int)(buf - dest); /* must be 1 or 2 */
9211 dest = buf;
9212 }
9213 if (readlen > p - buf + 1)
9214 mch_memmove(dest, p + 1, readlen - (p - buf) - 1);
9215 readlen -= 3 - adjust_prevlen;
9216 prevlen -= adjust_prevlen;
9217 p = dest - 1;
9218 }
9219 }
9220 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009221 } /* for */
9222
9223 if (failed || (cnt >= maxline && maxline >= 0) || readlen <= 0)
9224 break;
9225 if (start < p)
9226 {
9227 /* There's part of a line in buf, store it in "prev". */
9228 if (p - start + prevlen >= prevsize)
9229 {
9230 /* need bigger "prev" buffer */
9231 char_u *newprev;
9232
9233 /* A common use case is ordinary text files and "prev" gets a
9234 * fragment of a line, so the first allocation is made
9235 * small, to avoid repeatedly 'allocing' large and
9236 * 'reallocing' small. */
9237 if (prevsize == 0)
9238 prevsize = (long)(p - start);
9239 else
9240 {
9241 long grow50pc = (prevsize * 3) / 2;
9242 long growmin = (long)((p - start) * 2 + prevlen);
9243 prevsize = grow50pc > growmin ? grow50pc : growmin;
9244 }
9245 newprev = prev == NULL ? alloc(prevsize)
9246 : vim_realloc(prev, prevsize);
9247 if (newprev == NULL)
9248 {
9249 do_outofmem_msg((long_u)prevsize);
9250 failed = TRUE;
9251 break;
9252 }
9253 prev = newprev;
9254 }
9255 /* Add the line part to end of "prev". */
9256 mch_memmove(prev + prevlen, start, p - start);
9257 prevlen += (long)(p - start);
9258 }
9259 } /* while */
9260
9261 /*
9262 * For a negative line count use only the lines at the end of the file,
9263 * free the rest.
9264 */
9265 if (!failed && maxline < 0)
9266 while (cnt > -maxline)
9267 {
9268 listitem_remove(rettv->vval.v_list, rettv->vval.v_list->lv_first);
9269 --cnt;
9270 }
9271
9272 if (failed)
9273 {
9274 list_free(rettv->vval.v_list);
9275 /* readfile doc says an empty list is returned on error */
9276 rettv->vval.v_list = list_alloc();
9277 }
9278
9279 vim_free(prev);
9280 fclose(fd);
9281}
9282
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02009283 static void
9284return_register(int regname, typval_T *rettv)
9285{
9286 char_u buf[2] = {0, 0};
9287
9288 buf[0] = (char_u)regname;
9289 rettv->v_type = VAR_STRING;
9290 rettv->vval.v_string = vim_strsave(buf);
9291}
9292
9293/*
9294 * "reg_executing()" function
9295 */
9296 static void
9297f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv)
9298{
9299 return_register(reg_executing, rettv);
9300}
9301
9302/*
9303 * "reg_recording()" function
9304 */
9305 static void
9306f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv)
9307{
9308 return_register(reg_recording, rettv);
9309}
9310
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009311#if defined(FEAT_RELTIME)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009312/*
9313 * Convert a List to proftime_T.
9314 * Return FAIL when there is something wrong.
9315 */
9316 static int
9317list2proftime(typval_T *arg, proftime_T *tm)
9318{
9319 long n1, n2;
9320 int error = FALSE;
9321
9322 if (arg->v_type != VAR_LIST || arg->vval.v_list == NULL
9323 || arg->vval.v_list->lv_len != 2)
9324 return FAIL;
9325 n1 = list_find_nr(arg->vval.v_list, 0L, &error);
9326 n2 = list_find_nr(arg->vval.v_list, 1L, &error);
Bram Moolenaar4f974752019-02-17 17:44:42 +01009327# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009328 tm->HighPart = n1;
9329 tm->LowPart = n2;
9330# else
9331 tm->tv_sec = n1;
9332 tm->tv_usec = n2;
9333# endif
9334 return error ? FAIL : OK;
9335}
9336#endif /* FEAT_RELTIME */
9337
9338/*
9339 * "reltime()" function
9340 */
9341 static void
9342f_reltime(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9343{
9344#ifdef FEAT_RELTIME
9345 proftime_T res;
9346 proftime_T start;
9347
9348 if (argvars[0].v_type == VAR_UNKNOWN)
9349 {
9350 /* No arguments: get current time. */
9351 profile_start(&res);
9352 }
9353 else if (argvars[1].v_type == VAR_UNKNOWN)
9354 {
9355 if (list2proftime(&argvars[0], &res) == FAIL)
9356 return;
9357 profile_end(&res);
9358 }
9359 else
9360 {
9361 /* Two arguments: compute the difference. */
9362 if (list2proftime(&argvars[0], &start) == FAIL
9363 || list2proftime(&argvars[1], &res) == FAIL)
9364 return;
9365 profile_sub(&res, &start);
9366 }
9367
9368 if (rettv_list_alloc(rettv) == OK)
9369 {
9370 long n1, n2;
9371
Bram Moolenaar4f974752019-02-17 17:44:42 +01009372# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009373 n1 = res.HighPart;
9374 n2 = res.LowPart;
9375# else
9376 n1 = res.tv_sec;
9377 n2 = res.tv_usec;
9378# endif
9379 list_append_number(rettv->vval.v_list, (varnumber_T)n1);
9380 list_append_number(rettv->vval.v_list, (varnumber_T)n2);
9381 }
9382#endif
9383}
9384
9385#ifdef FEAT_FLOAT
9386/*
9387 * "reltimefloat()" function
9388 */
9389 static void
9390f_reltimefloat(typval_T *argvars UNUSED, typval_T *rettv)
9391{
9392# ifdef FEAT_RELTIME
9393 proftime_T tm;
9394# endif
9395
9396 rettv->v_type = VAR_FLOAT;
9397 rettv->vval.v_float = 0;
9398# ifdef FEAT_RELTIME
9399 if (list2proftime(&argvars[0], &tm) == OK)
9400 rettv->vval.v_float = profile_float(&tm);
9401# endif
9402}
9403#endif
9404
9405/*
9406 * "reltimestr()" function
9407 */
9408 static void
9409f_reltimestr(typval_T *argvars UNUSED, typval_T *rettv)
9410{
9411#ifdef FEAT_RELTIME
9412 proftime_T tm;
9413#endif
9414
9415 rettv->v_type = VAR_STRING;
9416 rettv->vval.v_string = NULL;
9417#ifdef FEAT_RELTIME
9418 if (list2proftime(&argvars[0], &tm) == OK)
9419 rettv->vval.v_string = vim_strsave((char_u *)profile_msg(&tm));
9420#endif
9421}
9422
9423#if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009424 static void
9425make_connection(void)
9426{
9427 if (X_DISPLAY == NULL
9428# ifdef FEAT_GUI
9429 && !gui.in_use
9430# endif
9431 )
9432 {
9433 x_force_connect = TRUE;
9434 setup_term_clip();
9435 x_force_connect = FALSE;
9436 }
9437}
9438
9439 static int
9440check_connection(void)
9441{
9442 make_connection();
9443 if (X_DISPLAY == NULL)
9444 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009445 emsg(_("E240: No connection to the X server"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009446 return FAIL;
9447 }
9448 return OK;
9449}
9450#endif
9451
9452#ifdef FEAT_CLIENTSERVER
9453 static void
9454remote_common(typval_T *argvars, typval_T *rettv, int expr)
9455{
9456 char_u *server_name;
9457 char_u *keys;
9458 char_u *r = NULL;
9459 char_u buf[NUMBUFLEN];
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009460 int timeout = 0;
Bram Moolenaar4f974752019-02-17 17:44:42 +01009461# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009462 HWND w;
9463# else
9464 Window w;
9465# endif
9466
9467 if (check_restricted() || check_secure())
9468 return;
9469
9470# ifdef FEAT_X11
9471 if (check_connection() == FAIL)
9472 return;
9473# endif
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009474 if (argvars[2].v_type != VAR_UNKNOWN
9475 && argvars[3].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009476 timeout = tv_get_number(&argvars[3]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009477
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009478 server_name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009479 if (server_name == NULL)
9480 return; /* type error; errmsg already given */
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009481 keys = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaar4f974752019-02-17 17:44:42 +01009482# ifdef MSWIN
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009483 if (serverSendToVim(server_name, keys, &r, &w, expr, timeout, TRUE) < 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009484# else
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009485 if (serverSendToVim(X_DISPLAY, server_name, keys, &r, &w, expr, timeout,
9486 0, TRUE) < 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009487# endif
9488 {
9489 if (r != NULL)
Bram Moolenaar09d6c382017-09-09 16:25:54 +02009490 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009491 emsg((char *)r); // sending worked but evaluation failed
Bram Moolenaar09d6c382017-09-09 16:25:54 +02009492 vim_free(r);
9493 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009494 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009495 semsg(_("E241: Unable to send to %s"), server_name);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009496 return;
9497 }
9498
9499 rettv->vval.v_string = r;
9500
9501 if (argvars[2].v_type != VAR_UNKNOWN)
9502 {
9503 dictitem_T v;
9504 char_u str[30];
9505 char_u *idvar;
9506
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009507 idvar = tv_get_string_chk(&argvars[2]);
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009508 if (idvar != NULL && *idvar != NUL)
9509 {
9510 sprintf((char *)str, PRINTF_HEX_LONG_U, (long_u)w);
9511 v.di_tv.v_type = VAR_STRING;
9512 v.di_tv.vval.v_string = vim_strsave(str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009513 set_var(idvar, &v.di_tv, FALSE);
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009514 vim_free(v.di_tv.vval.v_string);
9515 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009516 }
9517}
9518#endif
9519
9520/*
9521 * "remote_expr()" function
9522 */
9523 static void
9524f_remote_expr(typval_T *argvars UNUSED, typval_T *rettv)
9525{
9526 rettv->v_type = VAR_STRING;
9527 rettv->vval.v_string = NULL;
9528#ifdef FEAT_CLIENTSERVER
9529 remote_common(argvars, rettv, TRUE);
9530#endif
9531}
9532
9533/*
9534 * "remote_foreground()" function
9535 */
9536 static void
9537f_remote_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9538{
9539#ifdef FEAT_CLIENTSERVER
Bram Moolenaar4f974752019-02-17 17:44:42 +01009540# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009541 /* On Win32 it's done in this application. */
9542 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009543 char_u *server_name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009544
9545 if (server_name != NULL)
9546 serverForeground(server_name);
9547 }
9548# else
9549 /* Send a foreground() expression to the server. */
9550 argvars[1].v_type = VAR_STRING;
9551 argvars[1].vval.v_string = vim_strsave((char_u *)"foreground()");
9552 argvars[2].v_type = VAR_UNKNOWN;
Bram Moolenaar09d6c382017-09-09 16:25:54 +02009553 rettv->v_type = VAR_STRING;
9554 rettv->vval.v_string = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009555 remote_common(argvars, rettv, TRUE);
9556 vim_free(argvars[1].vval.v_string);
9557# endif
9558#endif
9559}
9560
9561 static void
9562f_remote_peek(typval_T *argvars UNUSED, typval_T *rettv)
9563{
9564#ifdef FEAT_CLIENTSERVER
9565 dictitem_T v;
9566 char_u *s = NULL;
Bram Moolenaar4f974752019-02-17 17:44:42 +01009567# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009568 long_u n = 0;
9569# endif
9570 char_u *serverid;
9571
9572 if (check_restricted() || check_secure())
9573 {
9574 rettv->vval.v_number = -1;
9575 return;
9576 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009577 serverid = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009578 if (serverid == NULL)
9579 {
9580 rettv->vval.v_number = -1;
9581 return; /* type error; errmsg already given */
9582 }
Bram Moolenaar4f974752019-02-17 17:44:42 +01009583# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009584 sscanf((const char *)serverid, SCANF_HEX_LONG_U, &n);
9585 if (n == 0)
9586 rettv->vval.v_number = -1;
9587 else
9588 {
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009589 s = serverGetReply((HWND)n, FALSE, FALSE, FALSE, 0);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009590 rettv->vval.v_number = (s != NULL);
9591 }
9592# else
9593 if (check_connection() == FAIL)
9594 return;
9595
9596 rettv->vval.v_number = serverPeekReply(X_DISPLAY,
9597 serverStrToWin(serverid), &s);
9598# endif
9599
9600 if (argvars[1].v_type != VAR_UNKNOWN && rettv->vval.v_number > 0)
9601 {
9602 char_u *retvar;
9603
9604 v.di_tv.v_type = VAR_STRING;
9605 v.di_tv.vval.v_string = vim_strsave(s);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009606 retvar = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009607 if (retvar != NULL)
9608 set_var(retvar, &v.di_tv, FALSE);
9609 vim_free(v.di_tv.vval.v_string);
9610 }
9611#else
9612 rettv->vval.v_number = -1;
9613#endif
9614}
9615
9616 static void
9617f_remote_read(typval_T *argvars UNUSED, typval_T *rettv)
9618{
9619 char_u *r = NULL;
9620
9621#ifdef FEAT_CLIENTSERVER
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009622 char_u *serverid = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009623
9624 if (serverid != NULL && !check_restricted() && !check_secure())
9625 {
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009626 int timeout = 0;
Bram Moolenaar4f974752019-02-17 17:44:42 +01009627# ifdef MSWIN
Bram Moolenaar1662ce12017-03-19 21:47:50 +01009628 /* The server's HWND is encoded in the 'id' parameter */
9629 long_u n = 0;
9630# endif
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009631
9632 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009633 timeout = tv_get_number(&argvars[1]);
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009634
Bram Moolenaar4f974752019-02-17 17:44:42 +01009635# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009636 sscanf((char *)serverid, SCANF_HEX_LONG_U, &n);
9637 if (n != 0)
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009638 r = serverGetReply((HWND)n, FALSE, TRUE, TRUE, timeout);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009639 if (r == NULL)
9640# else
Bram Moolenaar81b9d0b2017-03-19 21:20:53 +01009641 if (check_connection() == FAIL
9642 || serverReadReply(X_DISPLAY, serverStrToWin(serverid),
9643 &r, FALSE, timeout) < 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009644# endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009645 emsg(_("E277: Unable to read a server reply"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009646 }
9647#endif
9648 rettv->v_type = VAR_STRING;
9649 rettv->vval.v_string = r;
9650}
9651
9652/*
9653 * "remote_send()" function
9654 */
9655 static void
9656f_remote_send(typval_T *argvars UNUSED, typval_T *rettv)
9657{
9658 rettv->v_type = VAR_STRING;
9659 rettv->vval.v_string = NULL;
9660#ifdef FEAT_CLIENTSERVER
9661 remote_common(argvars, rettv, FALSE);
9662#endif
9663}
9664
9665/*
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01009666 * "remote_startserver()" function
9667 */
9668 static void
9669f_remote_startserver(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9670{
9671#ifdef FEAT_CLIENTSERVER
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009672 char_u *server = tv_get_string_chk(&argvars[0]);
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01009673
9674 if (server == NULL)
9675 return; /* type error; errmsg already given */
9676 if (serverName != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009677 emsg(_("E941: already started a server"));
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01009678 else
9679 {
9680# ifdef FEAT_X11
9681 if (check_connection() == OK)
9682 serverRegisterName(X_DISPLAY, server);
9683# else
9684 serverSetName(server);
9685# endif
9686 }
9687#else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009688 emsg(_("E942: +clientserver feature not available"));
Bram Moolenaar7416f3e2017-03-18 18:10:13 +01009689#endif
9690}
9691
9692/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009693 * "remove()" function
9694 */
9695 static void
9696f_remove(typval_T *argvars, typval_T *rettv)
9697{
9698 list_T *l;
9699 listitem_T *item, *item2;
9700 listitem_T *li;
9701 long idx;
9702 long end;
9703 char_u *key;
9704 dict_T *d;
9705 dictitem_T *di;
9706 char_u *arg_errmsg = (char_u *)N_("remove() argument");
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009707 int error = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009708
9709 if (argvars[0].v_type == VAR_DICT)
9710 {
9711 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009712 semsg(_(e_toomanyarg), "remove()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009713 else if ((d = argvars[0].vval.v_dict) != NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +01009714 && !var_check_lock(d->dv_lock, arg_errmsg, TRUE))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009715 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009716 key = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009717 if (key != NULL)
9718 {
9719 di = dict_find(d, key, -1);
9720 if (di == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009721 semsg(_(e_dictkey), key);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009722 else if (!var_check_fixed(di->di_flags, arg_errmsg, TRUE)
9723 && !var_check_ro(di->di_flags, arg_errmsg, TRUE))
9724 {
9725 *rettv = di->di_tv;
9726 init_tv(&di->di_tv);
9727 dictitem_remove(d, di);
9728 }
9729 }
9730 }
9731 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009732 else if (argvars[0].v_type == VAR_BLOB)
9733 {
9734 idx = (long)tv_get_number_chk(&argvars[1], &error);
9735 if (!error)
9736 {
9737 blob_T *b = argvars[0].vval.v_blob;
9738 int len = blob_len(b);
9739 char_u *p;
9740
9741 if (idx < 0)
9742 // count from the end
9743 idx = len + idx;
9744 if (idx < 0 || idx >= len)
9745 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009746 semsg(_(e_blobidx), idx);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009747 return;
9748 }
9749 if (argvars[2].v_type == VAR_UNKNOWN)
9750 {
9751 // Remove one item, return its value.
9752 p = (char_u *)b->bv_ga.ga_data;
9753 rettv->vval.v_number = (varnumber_T) *(p + idx);
9754 mch_memmove(p + idx, p + idx + 1, (size_t)len - idx - 1);
9755 --b->bv_ga.ga_len;
9756 }
9757 else
9758 {
9759 blob_T *blob;
9760
9761 // Remove range of items, return list with values.
9762 end = (long)tv_get_number_chk(&argvars[2], &error);
9763 if (error)
9764 return;
9765 if (end < 0)
9766 // count from the end
9767 end = len + end;
9768 if (end >= len || idx > end)
9769 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009770 semsg(_(e_blobidx), end);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009771 return;
9772 }
9773 blob = blob_alloc();
9774 if (blob == NULL)
9775 return;
9776 blob->bv_ga.ga_len = end - idx + 1;
9777 if (ga_grow(&blob->bv_ga, end - idx + 1) == FAIL)
9778 {
9779 vim_free(blob);
9780 return;
9781 }
9782 p = (char_u *)b->bv_ga.ga_data;
9783 mch_memmove((char_u *)blob->bv_ga.ga_data, p + idx,
9784 (size_t)(end - idx + 1));
9785 ++blob->bv_refcount;
9786 rettv->v_type = VAR_BLOB;
9787 rettv->vval.v_blob = blob;
9788
9789 mch_memmove(p + idx, p + end + 1, (size_t)(len - end));
9790 b->bv_ga.ga_len -= end - idx + 1;
9791 }
9792 }
9793 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009794 else if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +01009795 semsg(_(e_listdictblobarg), "remove()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009796 else if ((l = argvars[0].vval.v_list) != NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +01009797 && !var_check_lock(l->lv_lock, arg_errmsg, TRUE))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009798 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009799 idx = (long)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009800 if (error)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009801 ; // type error: do nothing, errmsg already given
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009802 else if ((item = list_find(l, idx)) == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009803 semsg(_(e_listidx), idx);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009804 else
9805 {
9806 if (argvars[2].v_type == VAR_UNKNOWN)
9807 {
9808 /* Remove one item, return its value. */
9809 vimlist_remove(l, item, item);
9810 *rettv = item->li_tv;
9811 vim_free(item);
9812 }
9813 else
9814 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009815 // Remove range of items, return list with values.
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009816 end = (long)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009817 if (error)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01009818 ; // type error: do nothing
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009819 else if ((item2 = list_find(l, end)) == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009820 semsg(_(e_listidx), end);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009821 else
9822 {
9823 int cnt = 0;
9824
9825 for (li = item; li != NULL; li = li->li_next)
9826 {
9827 ++cnt;
9828 if (li == item2)
9829 break;
9830 }
9831 if (li == NULL) /* didn't find "item2" after "item" */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009832 emsg(_(e_invrange));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009833 else
9834 {
9835 vimlist_remove(l, item, item2);
9836 if (rettv_list_alloc(rettv) == OK)
9837 {
9838 l = rettv->vval.v_list;
9839 l->lv_first = item;
9840 l->lv_last = item2;
9841 item->li_prev = NULL;
9842 item2->li_next = NULL;
9843 l->lv_len = cnt;
9844 }
9845 }
9846 }
9847 }
9848 }
9849 }
9850}
9851
9852/*
9853 * "rename({from}, {to})" function
9854 */
9855 static void
9856f_rename(typval_T *argvars, typval_T *rettv)
9857{
9858 char_u buf[NUMBUFLEN];
9859
9860 if (check_restricted() || check_secure())
9861 rettv->vval.v_number = -1;
9862 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009863 rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
9864 tv_get_string_buf(&argvars[1], buf));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009865}
9866
9867/*
9868 * "repeat()" function
9869 */
9870 static void
9871f_repeat(typval_T *argvars, typval_T *rettv)
9872{
9873 char_u *p;
9874 int n;
9875 int slen;
9876 int len;
9877 char_u *r;
9878 int i;
9879
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009880 n = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009881 if (argvars[0].v_type == VAR_LIST)
9882 {
9883 if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL)
9884 while (n-- > 0)
9885 if (list_extend(rettv->vval.v_list,
9886 argvars[0].vval.v_list, NULL) == FAIL)
9887 break;
9888 }
9889 else
9890 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009891 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009892 rettv->v_type = VAR_STRING;
9893 rettv->vval.v_string = NULL;
9894
9895 slen = (int)STRLEN(p);
9896 len = slen * n;
9897 if (len <= 0)
9898 return;
9899
9900 r = alloc(len + 1);
9901 if (r != NULL)
9902 {
9903 for (i = 0; i < n; i++)
9904 mch_memmove(r + i * slen, p, (size_t)slen);
9905 r[len] = NUL;
9906 }
9907
9908 rettv->vval.v_string = r;
9909 }
9910}
9911
9912/*
9913 * "resolve()" function
9914 */
9915 static void
9916f_resolve(typval_T *argvars, typval_T *rettv)
9917{
9918 char_u *p;
9919#ifdef HAVE_READLINK
9920 char_u *buf = NULL;
9921#endif
9922
Bram Moolenaard155d7a2018-12-21 16:04:21 +01009923 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009924#ifdef FEAT_SHORTCUT
9925 {
9926 char_u *v = NULL;
9927
Bram Moolenaardce1e892019-02-10 23:18:53 +01009928 v = mch_resolve_path(p, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009929 if (v != NULL)
9930 rettv->vval.v_string = v;
9931 else
9932 rettv->vval.v_string = vim_strsave(p);
9933 }
9934#else
9935# ifdef HAVE_READLINK
9936 {
9937 char_u *cpy;
9938 int len;
9939 char_u *remain = NULL;
9940 char_u *q;
9941 int is_relative_to_current = FALSE;
9942 int has_trailing_pathsep = FALSE;
9943 int limit = 100;
9944
9945 p = vim_strsave(p);
9946
9947 if (p[0] == '.' && (vim_ispathsep(p[1])
9948 || (p[1] == '.' && (vim_ispathsep(p[2])))))
9949 is_relative_to_current = TRUE;
9950
9951 len = STRLEN(p);
9952 if (len > 0 && after_pathsep(p, p + len))
9953 {
9954 has_trailing_pathsep = TRUE;
9955 p[len - 1] = NUL; /* the trailing slash breaks readlink() */
9956 }
9957
9958 q = getnextcomp(p);
9959 if (*q != NUL)
9960 {
9961 /* Separate the first path component in "p", and keep the
9962 * remainder (beginning with the path separator). */
9963 remain = vim_strsave(q - 1);
9964 q[-1] = NUL;
9965 }
9966
9967 buf = alloc(MAXPATHL + 1);
9968 if (buf == NULL)
9969 goto fail;
9970
9971 for (;;)
9972 {
9973 for (;;)
9974 {
9975 len = readlink((char *)p, (char *)buf, MAXPATHL);
9976 if (len <= 0)
9977 break;
9978 buf[len] = NUL;
9979
9980 if (limit-- == 0)
9981 {
9982 vim_free(p);
9983 vim_free(remain);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009984 emsg(_("E655: Too many symbolic links (cycle?)"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009985 rettv->vval.v_string = NULL;
9986 goto fail;
9987 }
9988
9989 /* Ensure that the result will have a trailing path separator
9990 * if the argument has one. */
9991 if (remain == NULL && has_trailing_pathsep)
9992 add_pathsep(buf);
9993
9994 /* Separate the first path component in the link value and
9995 * concatenate the remainders. */
9996 q = getnextcomp(vim_ispathsep(*buf) ? buf + 1 : buf);
9997 if (*q != NUL)
9998 {
9999 if (remain == NULL)
10000 remain = vim_strsave(q - 1);
10001 else
10002 {
10003 cpy = concat_str(q - 1, remain);
10004 if (cpy != NULL)
10005 {
10006 vim_free(remain);
10007 remain = cpy;
10008 }
10009 }
10010 q[-1] = NUL;
10011 }
10012
10013 q = gettail(p);
10014 if (q > p && *q == NUL)
10015 {
10016 /* Ignore trailing path separator. */
10017 q[-1] = NUL;
10018 q = gettail(p);
10019 }
10020 if (q > p && !mch_isFullName(buf))
10021 {
10022 /* symlink is relative to directory of argument */
10023 cpy = alloc((unsigned)(STRLEN(p) + STRLEN(buf) + 1));
10024 if (cpy != NULL)
10025 {
10026 STRCPY(cpy, p);
10027 STRCPY(gettail(cpy), buf);
10028 vim_free(p);
10029 p = cpy;
10030 }
10031 }
10032 else
10033 {
10034 vim_free(p);
10035 p = vim_strsave(buf);
10036 }
10037 }
10038
10039 if (remain == NULL)
10040 break;
10041
10042 /* Append the first path component of "remain" to "p". */
10043 q = getnextcomp(remain + 1);
10044 len = q - remain - (*q != NUL);
10045 cpy = vim_strnsave(p, STRLEN(p) + len);
10046 if (cpy != NULL)
10047 {
10048 STRNCAT(cpy, remain, len);
10049 vim_free(p);
10050 p = cpy;
10051 }
10052 /* Shorten "remain". */
10053 if (*q != NUL)
10054 STRMOVE(remain, q - 1);
10055 else
Bram Moolenaard23a8232018-02-10 18:45:26 +010010056 VIM_CLEAR(remain);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010057 }
10058
10059 /* If the result is a relative path name, make it explicitly relative to
10060 * the current directory if and only if the argument had this form. */
10061 if (!vim_ispathsep(*p))
10062 {
10063 if (is_relative_to_current
10064 && *p != NUL
10065 && !(p[0] == '.'
10066 && (p[1] == NUL
10067 || vim_ispathsep(p[1])
10068 || (p[1] == '.'
10069 && (p[2] == NUL
10070 || vim_ispathsep(p[2]))))))
10071 {
10072 /* Prepend "./". */
10073 cpy = concat_str((char_u *)"./", p);
10074 if (cpy != NULL)
10075 {
10076 vim_free(p);
10077 p = cpy;
10078 }
10079 }
10080 else if (!is_relative_to_current)
10081 {
10082 /* Strip leading "./". */
10083 q = p;
10084 while (q[0] == '.' && vim_ispathsep(q[1]))
10085 q += 2;
10086 if (q > p)
10087 STRMOVE(p, p + 2);
10088 }
10089 }
10090
10091 /* Ensure that the result will have no trailing path separator
10092 * if the argument had none. But keep "/" or "//". */
10093 if (!has_trailing_pathsep)
10094 {
10095 q = p + STRLEN(p);
10096 if (after_pathsep(p, q))
10097 *gettail_sep(p) = NUL;
10098 }
10099
10100 rettv->vval.v_string = p;
10101 }
10102# else
10103 rettv->vval.v_string = vim_strsave(p);
10104# endif
10105#endif
10106
10107 simplify_filename(rettv->vval.v_string);
10108
10109#ifdef HAVE_READLINK
10110fail:
10111 vim_free(buf);
10112#endif
10113 rettv->v_type = VAR_STRING;
10114}
10115
10116/*
10117 * "reverse({list})" function
10118 */
10119 static void
10120f_reverse(typval_T *argvars, typval_T *rettv)
10121{
10122 list_T *l;
10123 listitem_T *li, *ni;
10124
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010010125 if (argvars[0].v_type == VAR_BLOB)
10126 {
10127 blob_T *b = argvars[0].vval.v_blob;
10128 int i, len = blob_len(b);
10129
10130 for (i = 0; i < len / 2; i++)
10131 {
10132 int tmp = blob_get(b, i);
10133
10134 blob_set(b, i, blob_get(b, len - i - 1));
10135 blob_set(b, len - i - 1, tmp);
10136 }
10137 rettv_blob_set(rettv, b);
10138 return;
10139 }
10140
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010141 if (argvars[0].v_type != VAR_LIST)
Bram Moolenaar0d17f0d2019-01-22 22:20:38 +010010142 semsg(_(e_listblobarg), "reverse()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010143 else if ((l = argvars[0].vval.v_list) != NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +010010144 && !var_check_lock(l->lv_lock,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010145 (char_u *)N_("reverse() argument"), TRUE))
10146 {
10147 li = l->lv_last;
10148 l->lv_first = l->lv_last = NULL;
10149 l->lv_len = 0;
10150 while (li != NULL)
10151 {
10152 ni = li->li_prev;
10153 list_append(l, li);
10154 li = ni;
10155 }
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020010156 rettv_list_set(rettv, l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010157 l->lv_idx = l->lv_len - l->lv_idx - 1;
10158 }
10159}
10160
10161#define SP_NOMOVE 0x01 /* don't move cursor */
10162#define SP_REPEAT 0x02 /* repeat to find outer pair */
10163#define SP_RETCOUNT 0x04 /* return matchcount */
10164#define SP_SETPCMARK 0x08 /* set previous context mark */
10165#define SP_START 0x10 /* accept match at start position */
10166#define SP_SUBPAT 0x20 /* return nr of matching sub-pattern */
10167#define SP_END 0x40 /* leave cursor at end of match */
10168#define SP_COLUMN 0x80 /* start at cursor column */
10169
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010170/*
10171 * Get flags for a search function.
10172 * Possibly sets "p_ws".
10173 * Returns BACKWARD, FORWARD or zero (for an error).
10174 */
10175 static int
10176get_search_arg(typval_T *varp, int *flagsp)
10177{
10178 int dir = FORWARD;
10179 char_u *flags;
10180 char_u nbuf[NUMBUFLEN];
10181 int mask;
10182
10183 if (varp->v_type != VAR_UNKNOWN)
10184 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010185 flags = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010186 if (flags == NULL)
10187 return 0; /* type error; errmsg already given */
10188 while (*flags != NUL)
10189 {
10190 switch (*flags)
10191 {
10192 case 'b': dir = BACKWARD; break;
10193 case 'w': p_ws = TRUE; break;
10194 case 'W': p_ws = FALSE; break;
10195 default: mask = 0;
10196 if (flagsp != NULL)
10197 switch (*flags)
10198 {
10199 case 'c': mask = SP_START; break;
10200 case 'e': mask = SP_END; break;
10201 case 'm': mask = SP_RETCOUNT; break;
10202 case 'n': mask = SP_NOMOVE; break;
10203 case 'p': mask = SP_SUBPAT; break;
10204 case 'r': mask = SP_REPEAT; break;
10205 case 's': mask = SP_SETPCMARK; break;
10206 case 'z': mask = SP_COLUMN; break;
10207 }
10208 if (mask == 0)
10209 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010210 semsg(_(e_invarg2), flags);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010211 dir = 0;
10212 }
10213 else
10214 *flagsp |= mask;
10215 }
10216 if (dir == 0)
10217 break;
10218 ++flags;
10219 }
10220 }
10221 return dir;
10222}
10223
10224/*
10225 * Shared by search() and searchpos() functions.
10226 */
10227 static int
10228search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
10229{
10230 int flags;
10231 char_u *pat;
10232 pos_T pos;
10233 pos_T save_cursor;
10234 int save_p_ws = p_ws;
10235 int dir;
10236 int retval = 0; /* default: FAIL */
10237 long lnum_stop = 0;
10238 proftime_T tm;
10239#ifdef FEAT_RELTIME
10240 long time_limit = 0;
10241#endif
10242 int options = SEARCH_KEEP;
10243 int subpatnum;
10244
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010245 pat = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010246 dir = get_search_arg(&argvars[1], flagsp); /* may set p_ws */
10247 if (dir == 0)
10248 goto theend;
10249 flags = *flagsp;
10250 if (flags & SP_START)
10251 options |= SEARCH_START;
10252 if (flags & SP_END)
10253 options |= SEARCH_END;
10254 if (flags & SP_COLUMN)
10255 options |= SEARCH_COL;
10256
10257 /* Optional arguments: line number to stop searching and timeout. */
10258 if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN)
10259 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010260 lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010261 if (lnum_stop < 0)
10262 goto theend;
10263#ifdef FEAT_RELTIME
10264 if (argvars[3].v_type != VAR_UNKNOWN)
10265 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010266 time_limit = (long)tv_get_number_chk(&argvars[3], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010267 if (time_limit < 0)
10268 goto theend;
10269 }
10270#endif
10271 }
10272
10273#ifdef FEAT_RELTIME
10274 /* Set the time limit, if there is one. */
10275 profile_setlimit(time_limit, &tm);
10276#endif
10277
10278 /*
10279 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
10280 * Check to make sure only those flags are set.
10281 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
10282 * flags cannot be set. Check for that condition also.
10283 */
10284 if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
10285 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
10286 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010287 semsg(_(e_invarg2), tv_get_string(&argvars[1]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010288 goto theend;
10289 }
10290
10291 pos = save_cursor = curwin->w_cursor;
Bram Moolenaar5d24a222018-12-23 19:10:09 +010010292 subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaarfbd0b0a2017-06-17 18:44:21 +020010293 options, RE_SEARCH, (linenr_T)lnum_stop, &tm, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010294 if (subpatnum != FAIL)
10295 {
10296 if (flags & SP_SUBPAT)
10297 retval = subpatnum;
10298 else
10299 retval = pos.lnum;
10300 if (flags & SP_SETPCMARK)
10301 setpcmark();
10302 curwin->w_cursor = pos;
10303 if (match_pos != NULL)
10304 {
10305 /* Store the match cursor position */
10306 match_pos->lnum = pos.lnum;
10307 match_pos->col = pos.col + 1;
10308 }
10309 /* "/$" will put the cursor after the end of the line, may need to
10310 * correct that here */
10311 check_cursor();
10312 }
10313
10314 /* If 'n' flag is used: restore cursor position. */
10315 if (flags & SP_NOMOVE)
10316 curwin->w_cursor = save_cursor;
10317 else
10318 curwin->w_set_curswant = TRUE;
10319theend:
10320 p_ws = save_p_ws;
10321
10322 return retval;
10323}
10324
10325#ifdef FEAT_FLOAT
10326
10327/*
10328 * round() is not in C90, use ceil() or floor() instead.
10329 */
10330 float_T
10331vim_round(float_T f)
10332{
10333 return f > 0 ? floor(f + 0.5) : ceil(f - 0.5);
10334}
10335
10336/*
10337 * "round({float})" function
10338 */
10339 static void
10340f_round(typval_T *argvars, typval_T *rettv)
10341{
10342 float_T f = 0.0;
10343
10344 rettv->v_type = VAR_FLOAT;
10345 if (get_float_arg(argvars, &f) == OK)
10346 rettv->vval.v_float = vim_round(f);
10347 else
10348 rettv->vval.v_float = 0.0;
10349}
10350#endif
10351
10352/*
10353 * "screenattr()" function
10354 */
10355 static void
10356f_screenattr(typval_T *argvars, typval_T *rettv)
10357{
10358 int row;
10359 int col;
10360 int c;
10361
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010362 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
10363 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010364 if (row < 0 || row >= screen_Rows
10365 || col < 0 || col >= screen_Columns)
10366 c = -1;
10367 else
10368 c = ScreenAttrs[LineOffset[row] + col];
10369 rettv->vval.v_number = c;
10370}
10371
10372/*
10373 * "screenchar()" function
10374 */
10375 static void
10376f_screenchar(typval_T *argvars, typval_T *rettv)
10377{
10378 int row;
10379 int col;
10380 int off;
10381 int c;
10382
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010383 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
10384 col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010385 if (row < 0 || row >= screen_Rows
10386 || col < 0 || col >= screen_Columns)
10387 c = -1;
10388 else
10389 {
10390 off = LineOffset[row] + col;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010391 if (enc_utf8 && ScreenLinesUC[off] != 0)
10392 c = ScreenLinesUC[off];
10393 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010394 c = ScreenLines[off];
10395 }
10396 rettv->vval.v_number = c;
10397}
10398
10399/*
10400 * "screencol()" function
10401 *
10402 * First column is 1 to be consistent with virtcol().
10403 */
10404 static void
10405f_screencol(typval_T *argvars UNUSED, typval_T *rettv)
10406{
10407 rettv->vval.v_number = screen_screencol() + 1;
10408}
10409
10410/*
10411 * "screenrow()" function
10412 */
10413 static void
10414f_screenrow(typval_T *argvars UNUSED, typval_T *rettv)
10415{
10416 rettv->vval.v_number = screen_screenrow() + 1;
10417}
10418
10419/*
10420 * "search()" function
10421 */
10422 static void
10423f_search(typval_T *argvars, typval_T *rettv)
10424{
10425 int flags = 0;
10426
10427 rettv->vval.v_number = search_cmn(argvars, NULL, &flags);
10428}
10429
10430/*
10431 * "searchdecl()" function
10432 */
10433 static void
10434f_searchdecl(typval_T *argvars, typval_T *rettv)
10435{
10436 int locally = 1;
10437 int thisblock = 0;
10438 int error = FALSE;
10439 char_u *name;
10440
10441 rettv->vval.v_number = 1; /* default: FAIL */
10442
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010443 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010444 if (argvars[1].v_type != VAR_UNKNOWN)
10445 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010446 locally = (int)tv_get_number_chk(&argvars[1], &error) == 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010447 if (!error && argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010448 thisblock = (int)tv_get_number_chk(&argvars[2], &error) != 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010449 }
10450 if (!error && name != NULL)
10451 rettv->vval.v_number = find_decl(name, (int)STRLEN(name),
10452 locally, thisblock, SEARCH_KEEP) == FAIL;
10453}
10454
10455/*
10456 * Used by searchpair() and searchpairpos()
10457 */
10458 static int
10459searchpair_cmn(typval_T *argvars, pos_T *match_pos)
10460{
10461 char_u *spat, *mpat, *epat;
Bram Moolenaar48570482017-10-30 21:48:41 +010010462 typval_T *skip;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010463 int save_p_ws = p_ws;
10464 int dir;
10465 int flags = 0;
10466 char_u nbuf1[NUMBUFLEN];
10467 char_u nbuf2[NUMBUFLEN];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010468 int retval = 0; /* default: FAIL */
10469 long lnum_stop = 0;
10470 long time_limit = 0;
10471
Bram Moolenaar3dddb092018-06-24 19:01:59 +020010472 /* Get the three pattern arguments: start, middle, end. Will result in an
10473 * error if not a valid argument. */
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010474 spat = tv_get_string_chk(&argvars[0]);
10475 mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
10476 epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010477 if (spat == NULL || mpat == NULL || epat == NULL)
10478 goto theend; /* type error */
10479
10480 /* Handle the optional fourth argument: flags */
10481 dir = get_search_arg(&argvars[3], &flags); /* may set p_ws */
10482 if (dir == 0)
10483 goto theend;
10484
10485 /* Don't accept SP_END or SP_SUBPAT.
10486 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
10487 */
10488 if ((flags & (SP_END | SP_SUBPAT)) != 0
10489 || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
10490 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010491 semsg(_(e_invarg2), tv_get_string(&argvars[3]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010492 goto theend;
10493 }
10494
10495 /* Using 'r' implies 'W', otherwise it doesn't work. */
10496 if (flags & SP_REPEAT)
10497 p_ws = FALSE;
10498
10499 /* Optional fifth argument: skip expression */
10500 if (argvars[3].v_type == VAR_UNKNOWN
10501 || argvars[4].v_type == VAR_UNKNOWN)
Bram Moolenaar48570482017-10-30 21:48:41 +010010502 skip = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010503 else
10504 {
Bram Moolenaar48570482017-10-30 21:48:41 +010010505 skip = &argvars[4];
10506 if (skip->v_type != VAR_FUNC && skip->v_type != VAR_PARTIAL
10507 && skip->v_type != VAR_STRING)
10508 {
10509 /* Type error */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010510 semsg(_(e_invarg2), tv_get_string(&argvars[4]));
Bram Moolenaar48570482017-10-30 21:48:41 +010010511 goto theend;
10512 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010513 if (argvars[5].v_type != VAR_UNKNOWN)
10514 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010515 lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010516 if (lnum_stop < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +020010517 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010518 semsg(_(e_invarg2), tv_get_string(&argvars[5]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010519 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +020010520 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010521#ifdef FEAT_RELTIME
10522 if (argvars[6].v_type != VAR_UNKNOWN)
10523 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010524 time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010525 if (time_limit < 0)
Bram Moolenaar3dddb092018-06-24 19:01:59 +020010526 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010527 semsg(_(e_invarg2), tv_get_string(&argvars[6]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010528 goto theend;
Bram Moolenaar3dddb092018-06-24 19:01:59 +020010529 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010530 }
10531#endif
10532 }
10533 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010534
10535 retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
10536 match_pos, lnum_stop, time_limit);
10537
10538theend:
10539 p_ws = save_p_ws;
10540
10541 return retval;
10542}
10543
10544/*
10545 * "searchpair()" function
10546 */
10547 static void
10548f_searchpair(typval_T *argvars, typval_T *rettv)
10549{
10550 rettv->vval.v_number = searchpair_cmn(argvars, NULL);
10551}
10552
10553/*
10554 * "searchpairpos()" function
10555 */
10556 static void
10557f_searchpairpos(typval_T *argvars, typval_T *rettv)
10558{
10559 pos_T match_pos;
10560 int lnum = 0;
10561 int col = 0;
10562
10563 if (rettv_list_alloc(rettv) == FAIL)
10564 return;
10565
10566 if (searchpair_cmn(argvars, &match_pos) > 0)
10567 {
10568 lnum = match_pos.lnum;
10569 col = match_pos.col;
10570 }
10571
10572 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
10573 list_append_number(rettv->vval.v_list, (varnumber_T)col);
10574}
10575
10576/*
10577 * Search for a start/middle/end thing.
10578 * Used by searchpair(), see its documentation for the details.
10579 * Returns 0 or -1 for no match,
10580 */
10581 long
10582do_searchpair(
10583 char_u *spat, /* start pattern */
10584 char_u *mpat, /* middle pattern */
10585 char_u *epat, /* end pattern */
10586 int dir, /* BACKWARD or FORWARD */
Bram Moolenaar48570482017-10-30 21:48:41 +010010587 typval_T *skip, /* skip expression */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010588 int flags, /* SP_SETPCMARK and other SP_ values */
10589 pos_T *match_pos,
10590 linenr_T lnum_stop, /* stop at this line if not zero */
10591 long time_limit UNUSED) /* stop after this many msec */
10592{
10593 char_u *save_cpo;
10594 char_u *pat, *pat2 = NULL, *pat3 = NULL;
10595 long retval = 0;
10596 pos_T pos;
10597 pos_T firstpos;
10598 pos_T foundpos;
10599 pos_T save_cursor;
10600 pos_T save_pos;
10601 int n;
10602 int r;
10603 int nest = 1;
Bram Moolenaar48570482017-10-30 21:48:41 +010010604 int use_skip = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010605 int err;
10606 int options = SEARCH_KEEP;
10607 proftime_T tm;
10608
10609 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
10610 save_cpo = p_cpo;
10611 p_cpo = empty_option;
10612
10613#ifdef FEAT_RELTIME
10614 /* Set the time limit, if there is one. */
10615 profile_setlimit(time_limit, &tm);
10616#endif
10617
10618 /* Make two search patterns: start/end (pat2, for in nested pairs) and
10619 * start/middle/end (pat3, for the top pair). */
Bram Moolenaar6e450a52017-01-06 20:03:58 +010010620 pat2 = alloc((unsigned)(STRLEN(spat) + STRLEN(epat) + 17));
10621 pat3 = alloc((unsigned)(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010622 if (pat2 == NULL || pat3 == NULL)
10623 goto theend;
Bram Moolenaar6e450a52017-01-06 20:03:58 +010010624 sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010625 if (*mpat == NUL)
10626 STRCPY(pat3, pat2);
10627 else
Bram Moolenaar6e450a52017-01-06 20:03:58 +010010628 sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010629 spat, epat, mpat);
10630 if (flags & SP_START)
10631 options |= SEARCH_START;
10632
Bram Moolenaar48570482017-10-30 21:48:41 +010010633 if (skip != NULL)
10634 {
10635 /* Empty string means to not use the skip expression. */
10636 if (skip->v_type == VAR_STRING || skip->v_type == VAR_FUNC)
10637 use_skip = skip->vval.v_string != NULL
10638 && *skip->vval.v_string != NUL;
10639 }
10640
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010641 save_cursor = curwin->w_cursor;
10642 pos = curwin->w_cursor;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010643 CLEAR_POS(&firstpos);
10644 CLEAR_POS(&foundpos);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010645 pat = pat3;
10646 for (;;)
10647 {
Bram Moolenaar5d24a222018-12-23 19:10:09 +010010648 n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
Bram Moolenaarfbd0b0a2017-06-17 18:44:21 +020010649 options, RE_SEARCH, lnum_stop, &tm, NULL);
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010650 if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010651 /* didn't find it or found the first match again: FAIL */
10652 break;
10653
10654 if (firstpos.lnum == 0)
10655 firstpos = pos;
Bram Moolenaarb5aedf32017-03-12 18:23:53 +010010656 if (EQUAL_POS(pos, foundpos))
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010657 {
10658 /* Found the same position again. Can happen with a pattern that
10659 * has "\zs" at the end and searching backwards. Advance one
10660 * character and try again. */
10661 if (dir == BACKWARD)
10662 decl(&pos);
10663 else
10664 incl(&pos);
10665 }
10666 foundpos = pos;
10667
10668 /* clear the start flag to avoid getting stuck here */
10669 options &= ~SEARCH_START;
10670
10671 /* If the skip pattern matches, ignore this match. */
Bram Moolenaar48570482017-10-30 21:48:41 +010010672 if (use_skip)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010673 {
10674 save_pos = curwin->w_cursor;
10675 curwin->w_cursor = pos;
Bram Moolenaar48570482017-10-30 21:48:41 +010010676 err = FALSE;
10677 r = eval_expr_to_bool(skip, &err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010678 curwin->w_cursor = save_pos;
10679 if (err)
10680 {
10681 /* Evaluating {skip} caused an error, break here. */
10682 curwin->w_cursor = save_cursor;
10683 retval = -1;
10684 break;
10685 }
10686 if (r)
10687 continue;
10688 }
10689
10690 if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2))
10691 {
10692 /* Found end when searching backwards or start when searching
10693 * forward: nested pair. */
10694 ++nest;
10695 pat = pat2; /* nested, don't search for middle */
10696 }
10697 else
10698 {
10699 /* Found end when searching forward or start when searching
10700 * backward: end of (nested) pair; or found middle in outer pair. */
10701 if (--nest == 1)
10702 pat = pat3; /* outer level, search for middle */
10703 }
10704
10705 if (nest == 0)
10706 {
10707 /* Found the match: return matchcount or line number. */
10708 if (flags & SP_RETCOUNT)
10709 ++retval;
10710 else
10711 retval = pos.lnum;
10712 if (flags & SP_SETPCMARK)
10713 setpcmark();
10714 curwin->w_cursor = pos;
10715 if (!(flags & SP_REPEAT))
10716 break;
10717 nest = 1; /* search for next unmatched */
10718 }
10719 }
10720
10721 if (match_pos != NULL)
10722 {
10723 /* Store the match cursor position */
10724 match_pos->lnum = curwin->w_cursor.lnum;
10725 match_pos->col = curwin->w_cursor.col + 1;
10726 }
10727
10728 /* If 'n' flag is used or search failed: restore cursor position. */
10729 if ((flags & SP_NOMOVE) || retval == 0)
10730 curwin->w_cursor = save_cursor;
10731
10732theend:
10733 vim_free(pat2);
10734 vim_free(pat3);
10735 if (p_cpo == empty_option)
10736 p_cpo = save_cpo;
10737 else
10738 /* Darn, evaluating the {skip} expression changed the value. */
10739 free_string_option(save_cpo);
10740
10741 return retval;
10742}
10743
10744/*
10745 * "searchpos()" function
10746 */
10747 static void
10748f_searchpos(typval_T *argvars, typval_T *rettv)
10749{
10750 pos_T match_pos;
10751 int lnum = 0;
10752 int col = 0;
10753 int n;
10754 int flags = 0;
10755
10756 if (rettv_list_alloc(rettv) == FAIL)
10757 return;
10758
10759 n = search_cmn(argvars, &match_pos, &flags);
10760 if (n > 0)
10761 {
10762 lnum = match_pos.lnum;
10763 col = match_pos.col;
10764 }
10765
10766 list_append_number(rettv->vval.v_list, (varnumber_T)lnum);
10767 list_append_number(rettv->vval.v_list, (varnumber_T)col);
10768 if (flags & SP_SUBPAT)
10769 list_append_number(rettv->vval.v_list, (varnumber_T)n);
10770}
10771
10772 static void
10773f_server2client(typval_T *argvars UNUSED, typval_T *rettv)
10774{
10775#ifdef FEAT_CLIENTSERVER
10776 char_u buf[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010777 char_u *server = tv_get_string_chk(&argvars[0]);
10778 char_u *reply = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010779
10780 rettv->vval.v_number = -1;
10781 if (server == NULL || reply == NULL)
10782 return;
10783 if (check_restricted() || check_secure())
10784 return;
10785# ifdef FEAT_X11
10786 if (check_connection() == FAIL)
10787 return;
10788# endif
10789
10790 if (serverSendReply(server, reply) < 0)
10791 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010792 emsg(_("E258: Unable to send to client"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010793 return;
10794 }
10795 rettv->vval.v_number = 0;
10796#else
10797 rettv->vval.v_number = -1;
10798#endif
10799}
10800
10801 static void
10802f_serverlist(typval_T *argvars UNUSED, typval_T *rettv)
10803{
10804 char_u *r = NULL;
10805
10806#ifdef FEAT_CLIENTSERVER
Bram Moolenaar4f974752019-02-17 17:44:42 +010010807# ifdef MSWIN
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010808 r = serverGetVimNames();
10809# else
10810 make_connection();
10811 if (X_DISPLAY != NULL)
10812 r = serverGetVimNames(X_DISPLAY);
10813# endif
10814#endif
10815 rettv->v_type = VAR_STRING;
10816 rettv->vval.v_string = r;
10817}
10818
10819/*
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +020010820 * "setbufline()" function
10821 */
10822 static void
Bram Moolenaar6f8d2ac2018-07-25 19:49:45 +020010823f_setbufline(typval_T *argvars, typval_T *rettv)
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +020010824{
10825 linenr_T lnum;
10826 buf_T *buf;
10827
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010010828 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +020010829 if (buf == NULL)
10830 rettv->vval.v_number = 1; /* FAIL */
10831 else
10832 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010833 lnum = tv_get_lnum_buf(&argvars[1], buf);
Bram Moolenaarca851592018-06-06 21:04:07 +020010834 set_buffer_lines(buf, lnum, FALSE, &argvars[2], rettv);
Bram Moolenaarb31cf2b2017-09-02 19:45:19 +020010835 }
10836}
10837
10838/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010839 * "setbufvar()" function
10840 */
10841 static void
10842f_setbufvar(typval_T *argvars, typval_T *rettv UNUSED)
10843{
10844 buf_T *buf;
10845 char_u *varname, *bufvarname;
10846 typval_T *varp;
10847 char_u nbuf[NUMBUFLEN];
10848
Bram Moolenaar8c62a082019-02-08 14:34:10 +010010849 if (check_secure())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010850 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010851 (void)tv_get_number(&argvars[0]); /* issue errmsg if type error */
10852 varname = tv_get_string_chk(&argvars[1]);
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010010853 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010854 varp = &argvars[2];
10855
10856 if (buf != NULL && varname != NULL && varp != NULL)
10857 {
10858 if (*varname == '&')
10859 {
10860 long numval;
10861 char_u *strval;
10862 int error = FALSE;
10863 aco_save_T aco;
10864
10865 /* set curbuf to be our buf, temporarily */
10866 aucmd_prepbuf(&aco, buf);
10867
10868 ++varname;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010869 numval = (long)tv_get_number_chk(varp, &error);
10870 strval = tv_get_string_buf_chk(varp, nbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010871 if (!error && strval != NULL)
10872 set_option_value(varname, numval, strval, OPT_LOCAL);
10873
10874 /* reset notion of buffer */
10875 aucmd_restbuf(&aco);
10876 }
10877 else
10878 {
10879 buf_T *save_curbuf = curbuf;
10880
10881 bufvarname = alloc((unsigned)STRLEN(varname) + 3);
10882 if (bufvarname != NULL)
10883 {
10884 curbuf = buf;
10885 STRCPY(bufvarname, "b:");
10886 STRCPY(bufvarname + 2, varname);
10887 set_var(bufvarname, varp, TRUE);
10888 vim_free(bufvarname);
10889 curbuf = save_curbuf;
10890 }
10891 }
10892 }
10893}
10894
10895 static void
10896f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED)
10897{
10898 dict_T *d;
10899 dictitem_T *di;
10900 char_u *csearch;
10901
10902 if (argvars[0].v_type != VAR_DICT)
10903 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010904 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010905 return;
10906 }
10907
10908 if ((d = argvars[0].vval.v_dict) != NULL)
10909 {
Bram Moolenaar8f667172018-12-14 15:38:31 +010010910 csearch = dict_get_string(d, (char_u *)"char", FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010911 if (csearch != NULL)
10912 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010913 if (enc_utf8)
10914 {
10915 int pcc[MAX_MCO];
10916 int c = utfc_ptr2char(csearch, pcc);
10917
10918 set_last_csearch(c, csearch, utfc_ptr2len(csearch));
10919 }
10920 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010921 set_last_csearch(PTR2CHAR(csearch),
10922 csearch, MB_PTR2LEN(csearch));
10923 }
10924
10925 di = dict_find(d, (char_u *)"forward", -1);
10926 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010927 set_csearch_direction((int)tv_get_number(&di->di_tv)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010928 ? FORWARD : BACKWARD);
10929
10930 di = dict_find(d, (char_u *)"until", -1);
10931 if (di != NULL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010932 set_csearch_until(!!tv_get_number(&di->di_tv));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010933 }
10934}
10935
10936/*
10937 * "setcmdpos()" function
10938 */
10939 static void
10940f_setcmdpos(typval_T *argvars, typval_T *rettv)
10941{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010942 int pos = (int)tv_get_number(&argvars[0]) - 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010943
10944 if (pos >= 0)
10945 rettv->vval.v_number = set_cmdline_pos(pos);
10946}
10947
10948/*
10949 * "setfperm({fname}, {mode})" function
10950 */
10951 static void
10952f_setfperm(typval_T *argvars, typval_T *rettv)
10953{
10954 char_u *fname;
10955 char_u modebuf[NUMBUFLEN];
10956 char_u *mode_str;
10957 int i;
10958 int mask;
10959 int mode = 0;
10960
10961 rettv->vval.v_number = 0;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010962 fname = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010963 if (fname == NULL)
10964 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010965 mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010966 if (mode_str == NULL)
10967 return;
10968 if (STRLEN(mode_str) != 9)
10969 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010010970 semsg(_(e_invarg2), mode_str);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010971 return;
10972 }
10973
10974 mask = 1;
10975 for (i = 8; i >= 0; --i)
10976 {
10977 if (mode_str[i] != '-')
10978 mode |= mask;
10979 mask = mask << 1;
10980 }
10981 rettv->vval.v_number = mch_setperm(fname, mode) == OK;
10982}
10983
10984/*
10985 * "setline()" function
10986 */
10987 static void
10988f_setline(typval_T *argvars, typval_T *rettv)
10989{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010010990 linenr_T lnum = tv_get_lnum(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010991
Bram Moolenaarca851592018-06-06 21:04:07 +020010992 set_buffer_lines(curbuf, lnum, FALSE, &argvars[1], rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010993}
10994
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010995/*
10996 * Used by "setqflist()" and "setloclist()" functions
10997 */
10998 static void
10999set_qf_ll_list(
11000 win_T *wp UNUSED,
11001 typval_T *list_arg UNUSED,
11002 typval_T *action_arg UNUSED,
Bram Moolenaard823fa92016-08-12 16:29:27 +020011003 typval_T *what_arg UNUSED,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011004 typval_T *rettv)
11005{
11006#ifdef FEAT_QUICKFIX
11007 static char *e_invact = N_("E927: Invalid action: '%s'");
11008 char_u *act;
11009 int action = 0;
Bram Moolenaar2f82ca72018-06-17 19:22:52 +020011010 static int recursive = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011011#endif
11012
11013 rettv->vval.v_number = -1;
11014
11015#ifdef FEAT_QUICKFIX
11016 if (list_arg->v_type != VAR_LIST)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011017 emsg(_(e_listreq));
Bram Moolenaar2f82ca72018-06-17 19:22:52 +020011018 else if (recursive != 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011019 emsg(_(e_au_recursive));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011020 else
11021 {
11022 list_T *l = list_arg->vval.v_list;
Bram Moolenaard823fa92016-08-12 16:29:27 +020011023 dict_T *d = NULL;
11024 int valid_dict = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011025
11026 if (action_arg->v_type == VAR_STRING)
11027 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011028 act = tv_get_string_chk(action_arg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011029 if (act == NULL)
11030 return; /* type error; errmsg already given */
Bram Moolenaarb6fa30c2017-03-29 14:19:25 +020011031 if ((*act == 'a' || *act == 'r' || *act == ' ' || *act == 'f') &&
11032 act[1] == NUL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011033 action = *act;
11034 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011035 semsg(_(e_invact), act);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011036 }
11037 else if (action_arg->v_type == VAR_UNKNOWN)
11038 action = ' ';
11039 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011040 emsg(_(e_stringreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011041
Bram Moolenaard823fa92016-08-12 16:29:27 +020011042 if (action_arg->v_type != VAR_UNKNOWN
11043 && what_arg->v_type != VAR_UNKNOWN)
11044 {
11045 if (what_arg->v_type == VAR_DICT)
11046 d = what_arg->vval.v_dict;
11047 else
11048 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011049 emsg(_(e_dictreq));
Bram Moolenaard823fa92016-08-12 16:29:27 +020011050 valid_dict = FALSE;
11051 }
11052 }
11053
Bram Moolenaar2f82ca72018-06-17 19:22:52 +020011054 ++recursive;
Bram Moolenaard823fa92016-08-12 16:29:27 +020011055 if (l != NULL && action && valid_dict && set_errorlist(wp, l, action,
Bram Moolenaar2f82ca72018-06-17 19:22:52 +020011056 (char_u *)(wp == NULL ? ":setqflist()" : ":setloclist()"),
11057 d) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011058 rettv->vval.v_number = 0;
Bram Moolenaar2f82ca72018-06-17 19:22:52 +020011059 --recursive;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011060 }
11061#endif
11062}
11063
11064/*
11065 * "setloclist()" function
11066 */
11067 static void
11068f_setloclist(typval_T *argvars, typval_T *rettv)
11069{
11070 win_T *win;
11071
11072 rettv->vval.v_number = -1;
11073
Bram Moolenaarbabfcf52018-10-25 13:11:16 +020011074 win = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011075 if (win != NULL)
Bram Moolenaard823fa92016-08-12 16:29:27 +020011076 set_qf_ll_list(win, &argvars[1], &argvars[2], &argvars[3], rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011077}
11078
11079/*
11080 * "setmatches()" function
11081 */
11082 static void
11083f_setmatches(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
11084{
11085#ifdef FEAT_SEARCH_EXTRA
11086 list_T *l;
11087 listitem_T *li;
11088 dict_T *d;
11089 list_T *s = NULL;
11090
11091 rettv->vval.v_number = -1;
11092 if (argvars[0].v_type != VAR_LIST)
11093 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011094 emsg(_(e_listreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011095 return;
11096 }
11097 if ((l = argvars[0].vval.v_list) != NULL)
11098 {
11099
11100 /* To some extent make sure that we are dealing with a list from
11101 * "getmatches()". */
11102 li = l->lv_first;
11103 while (li != NULL)
11104 {
11105 if (li->li_tv.v_type != VAR_DICT
11106 || (d = li->li_tv.vval.v_dict) == NULL)
11107 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011108 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011109 return;
11110 }
11111 if (!(dict_find(d, (char_u *)"group", -1) != NULL
11112 && (dict_find(d, (char_u *)"pattern", -1) != NULL
11113 || dict_find(d, (char_u *)"pos1", -1) != NULL)
11114 && dict_find(d, (char_u *)"priority", -1) != NULL
11115 && dict_find(d, (char_u *)"id", -1) != NULL))
11116 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011117 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011118 return;
11119 }
11120 li = li->li_next;
11121 }
11122
11123 clear_matches(curwin);
11124 li = l->lv_first;
11125 while (li != NULL)
11126 {
11127 int i = 0;
11128 char_u buf[5];
11129 dictitem_T *di;
11130 char_u *group;
11131 int priority;
11132 int id;
11133 char_u *conceal;
11134
11135 d = li->li_tv.vval.v_dict;
11136 if (dict_find(d, (char_u *)"pattern", -1) == NULL)
11137 {
11138 if (s == NULL)
11139 {
11140 s = list_alloc();
11141 if (s == NULL)
11142 return;
11143 }
11144
11145 /* match from matchaddpos() */
11146 for (i = 1; i < 9; i++)
11147 {
11148 sprintf((char *)buf, (char *)"pos%d", i);
11149 if ((di = dict_find(d, (char_u *)buf, -1)) != NULL)
11150 {
11151 if (di->di_tv.v_type != VAR_LIST)
11152 return;
11153
11154 list_append_tv(s, &di->di_tv);
11155 s->lv_refcount++;
11156 }
11157 else
11158 break;
11159 }
11160 }
11161
Bram Moolenaar8f667172018-12-14 15:38:31 +010011162 group = dict_get_string(d, (char_u *)"group", TRUE);
11163 priority = (int)dict_get_number(d, (char_u *)"priority");
11164 id = (int)dict_get_number(d, (char_u *)"id");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011165 conceal = dict_find(d, (char_u *)"conceal", -1) != NULL
Bram Moolenaar8f667172018-12-14 15:38:31 +010011166 ? dict_get_string(d, (char_u *)"conceal", TRUE)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011167 : NULL;
11168 if (i == 0)
11169 {
11170 match_add(curwin, group,
Bram Moolenaar8f667172018-12-14 15:38:31 +010011171 dict_get_string(d, (char_u *)"pattern", FALSE),
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011172 priority, id, NULL, conceal);
11173 }
11174 else
11175 {
11176 match_add(curwin, group, NULL, priority, id, s, conceal);
11177 list_unref(s);
11178 s = NULL;
11179 }
Bram Moolenaar7dc5e2e2016-08-05 22:22:06 +020011180 vim_free(group);
11181 vim_free(conceal);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011182
11183 li = li->li_next;
11184 }
11185 rettv->vval.v_number = 0;
11186 }
11187#endif
11188}
11189
11190/*
11191 * "setpos()" function
11192 */
11193 static void
11194f_setpos(typval_T *argvars, typval_T *rettv)
11195{
11196 pos_T pos;
11197 int fnum;
11198 char_u *name;
11199 colnr_T curswant = -1;
11200
11201 rettv->vval.v_number = -1;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011202 name = tv_get_string_chk(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011203 if (name != NULL)
11204 {
11205 if (list2fpos(&argvars[1], &pos, &fnum, &curswant) == OK)
11206 {
11207 if (--pos.col < 0)
11208 pos.col = 0;
11209 if (name[0] == '.' && name[1] == NUL)
11210 {
Bram Moolenaar3a29abc2017-01-28 18:31:41 +010011211 /* set cursor; "fnum" is ignored */
11212 curwin->w_cursor = pos;
11213 if (curswant >= 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011214 {
Bram Moolenaar3a29abc2017-01-28 18:31:41 +010011215 curwin->w_curswant = curswant - 1;
11216 curwin->w_set_curswant = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011217 }
Bram Moolenaar3a29abc2017-01-28 18:31:41 +010011218 check_cursor();
11219 rettv->vval.v_number = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011220 }
11221 else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)
11222 {
11223 /* set mark */
11224 if (setmark_pos(name[1], &pos, fnum) == OK)
11225 rettv->vval.v_number = 0;
11226 }
11227 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011228 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011229 }
11230 }
11231}
11232
11233/*
11234 * "setqflist()" function
11235 */
11236 static void
11237f_setqflist(typval_T *argvars, typval_T *rettv)
11238{
Bram Moolenaard823fa92016-08-12 16:29:27 +020011239 set_qf_ll_list(NULL, &argvars[0], &argvars[1], &argvars[2], rettv);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011240}
11241
11242/*
11243 * "setreg()" function
11244 */
11245 static void
11246f_setreg(typval_T *argvars, typval_T *rettv)
11247{
11248 int regname;
11249 char_u *strregname;
11250 char_u *stropt;
11251 char_u *strval;
11252 int append;
11253 char_u yank_type;
11254 long block_len;
11255
11256 block_len = -1;
11257 yank_type = MAUTO;
11258 append = FALSE;
11259
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011260 strregname = tv_get_string_chk(argvars);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011261 rettv->vval.v_number = 1; /* FAIL is default */
11262
11263 if (strregname == NULL)
11264 return; /* type error; errmsg already given */
11265 regname = *strregname;
11266 if (regname == 0 || regname == '@')
11267 regname = '"';
11268
11269 if (argvars[2].v_type != VAR_UNKNOWN)
11270 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011271 stropt = tv_get_string_chk(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011272 if (stropt == NULL)
11273 return; /* type error */
11274 for (; *stropt != NUL; ++stropt)
11275 switch (*stropt)
11276 {
11277 case 'a': case 'A': /* append */
11278 append = TRUE;
11279 break;
11280 case 'v': case 'c': /* character-wise selection */
11281 yank_type = MCHAR;
11282 break;
11283 case 'V': case 'l': /* line-wise selection */
11284 yank_type = MLINE;
11285 break;
11286 case 'b': case Ctrl_V: /* block-wise selection */
11287 yank_type = MBLOCK;
11288 if (VIM_ISDIGIT(stropt[1]))
11289 {
11290 ++stropt;
11291 block_len = getdigits(&stropt) - 1;
11292 --stropt;
11293 }
11294 break;
11295 }
11296 }
11297
11298 if (argvars[1].v_type == VAR_LIST)
11299 {
11300 char_u **lstval;
11301 char_u **allocval;
11302 char_u buf[NUMBUFLEN];
11303 char_u **curval;
11304 char_u **curallocval;
11305 list_T *ll = argvars[1].vval.v_list;
11306 listitem_T *li;
11307 int len;
11308
11309 /* If the list is NULL handle like an empty list. */
11310 len = ll == NULL ? 0 : ll->lv_len;
11311
11312 /* First half: use for pointers to result lines; second half: use for
11313 * pointers to allocated copies. */
11314 lstval = (char_u **)alloc(sizeof(char_u *) * ((len + 1) * 2));
11315 if (lstval == NULL)
11316 return;
11317 curval = lstval;
11318 allocval = lstval + len + 2;
11319 curallocval = allocval;
11320
11321 for (li = ll == NULL ? NULL : ll->lv_first; li != NULL;
11322 li = li->li_next)
11323 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011324 strval = tv_get_string_buf_chk(&li->li_tv, buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011325 if (strval == NULL)
11326 goto free_lstval;
11327 if (strval == buf)
11328 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011329 /* Need to make a copy, next tv_get_string_buf_chk() will
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011330 * overwrite the string. */
11331 strval = vim_strsave(buf);
11332 if (strval == NULL)
11333 goto free_lstval;
11334 *curallocval++ = strval;
11335 }
11336 *curval++ = strval;
11337 }
11338 *curval++ = NULL;
11339
11340 write_reg_contents_lst(regname, lstval, -1,
11341 append, yank_type, block_len);
11342free_lstval:
11343 while (curallocval > allocval)
11344 vim_free(*--curallocval);
11345 vim_free(lstval);
11346 }
11347 else
11348 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011349 strval = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011350 if (strval == NULL)
11351 return;
11352 write_reg_contents_ex(regname, strval, -1,
11353 append, yank_type, block_len);
11354 }
11355 rettv->vval.v_number = 0;
11356}
11357
11358/*
11359 * "settabvar()" function
11360 */
11361 static void
11362f_settabvar(typval_T *argvars, typval_T *rettv)
11363{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011364 tabpage_T *save_curtab;
11365 tabpage_T *tp;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011366 char_u *varname, *tabvarname;
11367 typval_T *varp;
11368
11369 rettv->vval.v_number = 0;
11370
Bram Moolenaar8c62a082019-02-08 14:34:10 +010011371 if (check_secure())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011372 return;
11373
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011374 tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
11375 varname = tv_get_string_chk(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011376 varp = &argvars[2];
11377
Bram Moolenaar4033c552017-09-16 20:54:51 +020011378 if (varname != NULL && varp != NULL && tp != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011379 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011380 save_curtab = curtab;
11381 goto_tabpage_tp(tp, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011382
11383 tabvarname = alloc((unsigned)STRLEN(varname) + 3);
11384 if (tabvarname != NULL)
11385 {
11386 STRCPY(tabvarname, "t:");
11387 STRCPY(tabvarname + 2, varname);
11388 set_var(tabvarname, varp, TRUE);
11389 vim_free(tabvarname);
11390 }
11391
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011392 /* Restore current tabpage */
11393 if (valid_tabpage(save_curtab))
11394 goto_tabpage_tp(save_curtab, FALSE, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011395 }
11396}
11397
11398/*
11399 * "settabwinvar()" function
11400 */
11401 static void
11402f_settabwinvar(typval_T *argvars, typval_T *rettv)
11403{
11404 setwinvar(argvars, rettv, 1);
11405}
11406
11407/*
Bram Moolenaarf49cc602018-11-11 15:21:05 +010011408 * "settagstack()" function
11409 */
11410 static void
11411f_settagstack(typval_T *argvars, typval_T *rettv)
11412{
11413 static char *e_invact2 = N_("E962: Invalid action: '%s'");
11414 win_T *wp;
11415 dict_T *d;
11416 int action = 'r';
11417
11418 rettv->vval.v_number = -1;
11419
11420 // first argument: window number or id
11421 wp = find_win_by_nr_or_id(&argvars[0]);
11422 if (wp == NULL)
11423 return;
11424
11425 // second argument: dict with items to set in the tag stack
11426 if (argvars[1].v_type != VAR_DICT)
11427 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011428 emsg(_(e_dictreq));
Bram Moolenaarf49cc602018-11-11 15:21:05 +010011429 return;
11430 }
11431 d = argvars[1].vval.v_dict;
11432 if (d == NULL)
11433 return;
11434
11435 // third argument: action - 'a' for append and 'r' for replace.
11436 // default is to replace the stack.
11437 if (argvars[2].v_type == VAR_UNKNOWN)
11438 action = 'r';
11439 else if (argvars[2].v_type == VAR_STRING)
11440 {
11441 char_u *actstr;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011442 actstr = tv_get_string_chk(&argvars[2]);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010011443 if (actstr == NULL)
11444 return;
11445 if ((*actstr == 'r' || *actstr == 'a') && actstr[1] == NUL)
11446 action = *actstr;
11447 else
11448 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011449 semsg(_(e_invact2), actstr);
Bram Moolenaarf49cc602018-11-11 15:21:05 +010011450 return;
11451 }
11452 }
11453 else
11454 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011455 emsg(_(e_stringreq));
Bram Moolenaarf49cc602018-11-11 15:21:05 +010011456 return;
11457 }
11458
11459 if (set_tagstack(wp, d, action) == OK)
11460 rettv->vval.v_number = 0;
11461}
11462
11463/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011464 * "setwinvar()" function
11465 */
11466 static void
11467f_setwinvar(typval_T *argvars, typval_T *rettv)
11468{
11469 setwinvar(argvars, rettv, 0);
11470}
11471
11472#ifdef FEAT_CRYPT
11473/*
11474 * "sha256({string})" function
11475 */
11476 static void
11477f_sha256(typval_T *argvars, typval_T *rettv)
11478{
11479 char_u *p;
11480
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011481 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011482 rettv->vval.v_string = vim_strsave(
11483 sha256_bytes(p, (int)STRLEN(p), NULL, 0));
11484 rettv->v_type = VAR_STRING;
11485}
11486#endif /* FEAT_CRYPT */
11487
11488/*
11489 * "shellescape({string})" function
11490 */
11491 static void
11492f_shellescape(typval_T *argvars, typval_T *rettv)
11493{
Bram Moolenaar20615522017-06-05 18:46:26 +020011494 int do_special = non_zero_arg(&argvars[1]);
11495
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011496 rettv->vval.v_string = vim_strsave_shellescape(
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011497 tv_get_string(&argvars[0]), do_special, do_special);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011498 rettv->v_type = VAR_STRING;
11499}
11500
11501/*
11502 * shiftwidth() function
11503 */
11504 static void
11505f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv)
11506{
Bram Moolenaarf9514162018-11-22 03:08:29 +010011507 rettv->vval.v_number = 0;
11508
11509 if (argvars[0].v_type != VAR_UNKNOWN)
11510 {
11511 long col;
11512
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011513 col = (long)tv_get_number_chk(argvars, NULL);
Bram Moolenaarf9514162018-11-22 03:08:29 +010011514 if (col < 0)
11515 return; // type error; errmsg already given
11516#ifdef FEAT_VARTABS
11517 rettv->vval.v_number = get_sw_value_col(curbuf, col);
11518 return;
11519#endif
11520 }
11521
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011522 rettv->vval.v_number = get_sw_value(curbuf);
11523}
11524
Bram Moolenaar162b7142018-12-21 15:17:36 +010011525#ifdef FEAT_SIGNS
11526/*
11527 * "sign_define()" function
11528 */
11529 static void
11530f_sign_define(typval_T *argvars, typval_T *rettv)
11531{
11532 char_u *name;
11533 dict_T *dict;
11534 char_u *icon = NULL;
11535 char_u *linehl = NULL;
11536 char_u *text = NULL;
11537 char_u *texthl = NULL;
11538
11539 rettv->vval.v_number = -1;
11540
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011541 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011542 if (name == NULL)
11543 return;
11544
11545 if (argvars[1].v_type != VAR_UNKNOWN)
11546 {
11547 if (argvars[1].v_type != VAR_DICT)
11548 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011549 emsg(_(e_dictreq));
Bram Moolenaar162b7142018-12-21 15:17:36 +010011550 return;
11551 }
11552
11553 // sign attributes
11554 dict = argvars[1].vval.v_dict;
11555 if (dict_find(dict, (char_u *)"icon", -1) != NULL)
11556 icon = dict_get_string(dict, (char_u *)"icon", TRUE);
11557 if (dict_find(dict, (char_u *)"linehl", -1) != NULL)
11558 linehl = dict_get_string(dict, (char_u *)"linehl", TRUE);
11559 if (dict_find(dict, (char_u *)"text", -1) != NULL)
11560 text = dict_get_string(dict, (char_u *)"text", TRUE);
11561 if (dict_find(dict, (char_u *)"texthl", -1) != NULL)
11562 texthl = dict_get_string(dict, (char_u *)"texthl", TRUE);
11563 }
11564
11565 if (sign_define_by_name(name, icon, linehl, text, texthl) == OK)
11566 rettv->vval.v_number = 0;
11567
11568 vim_free(icon);
11569 vim_free(linehl);
11570 vim_free(text);
11571 vim_free(texthl);
11572}
11573
11574/*
11575 * "sign_getdefined()" function
11576 */
11577 static void
11578f_sign_getdefined(typval_T *argvars, typval_T *rettv)
11579{
11580 char_u *name = NULL;
11581
11582 if (rettv_list_alloc_id(rettv, aid_sign_getdefined) != OK)
11583 return;
11584
11585 if (argvars[0].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011586 name = tv_get_string(&argvars[0]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011587
11588 sign_getlist(name, rettv->vval.v_list);
11589}
11590
11591/*
11592 * "sign_getplaced()" function
11593 */
11594 static void
11595f_sign_getplaced(typval_T *argvars, typval_T *rettv)
11596{
11597 buf_T *buf = NULL;
11598 dict_T *dict;
11599 dictitem_T *di;
11600 linenr_T lnum = 0;
11601 int sign_id = 0;
11602 char_u *group = NULL;
11603 int notanum = FALSE;
11604
11605 if (rettv_list_alloc_id(rettv, aid_sign_getplaced) != OK)
11606 return;
11607
11608 if (argvars[0].v_type != VAR_UNKNOWN)
11609 {
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011610 // get signs placed in the specified buffer
11611 buf = get_buf_arg(&argvars[0]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011612 if (buf == NULL)
Bram Moolenaar162b7142018-12-21 15:17:36 +010011613 return;
Bram Moolenaar162b7142018-12-21 15:17:36 +010011614
11615 if (argvars[1].v_type != VAR_UNKNOWN)
11616 {
11617 if (argvars[1].v_type != VAR_DICT ||
11618 ((dict = argvars[1].vval.v_dict) == NULL))
11619 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011620 emsg(_(e_dictreq));
Bram Moolenaar162b7142018-12-21 15:17:36 +010011621 return;
11622 }
11623 if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
11624 {
11625 // get signs placed at this line
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011626 (void)tv_get_number_chk(&di->di_tv, &notanum);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011627 if (notanum)
11628 return;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011629 lnum = tv_get_lnum(&di->di_tv);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011630 }
11631 if ((di = dict_find(dict, (char_u *)"id", -1)) != NULL)
11632 {
11633 // get sign placed with this identifier
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011634 sign_id = (int)tv_get_number_chk(&di->di_tv, &notanum);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011635 if (notanum)
11636 return;
11637 }
11638 if ((di = dict_find(dict, (char_u *)"group", -1)) != NULL)
11639 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011640 group = tv_get_string_chk(&di->di_tv);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011641 if (group == NULL)
11642 return;
Bram Moolenaar6436cd82018-12-27 00:28:33 +010011643 if (*group == '\0') // empty string means global group
11644 group = NULL;
Bram Moolenaar162b7142018-12-21 15:17:36 +010011645 }
11646 }
11647 }
11648
11649 sign_get_placed(buf, lnum, sign_id, group, rettv->vval.v_list);
11650}
11651
11652/*
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011653 * "sign_jump()" function
11654 */
11655 static void
11656f_sign_jump(typval_T *argvars, typval_T *rettv)
11657{
11658 int sign_id;
11659 char_u *sign_group = NULL;
11660 buf_T *buf;
11661 int notanum = FALSE;
11662
11663 rettv->vval.v_number = -1;
11664
Bram Moolenaarbdace832019-03-02 10:13:42 +010011665 // Sign identifier
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011666 sign_id = (int)tv_get_number_chk(&argvars[0], &notanum);
11667 if (notanum)
11668 return;
11669 if (sign_id <= 0)
11670 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011671 emsg(_(e_invarg));
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011672 return;
11673 }
11674
11675 // Sign group
11676 sign_group = tv_get_string_chk(&argvars[1]);
11677 if (sign_group == NULL)
11678 return;
11679 if (sign_group[0] == '\0')
11680 sign_group = NULL; // global sign group
11681 else
11682 {
11683 sign_group = vim_strsave(sign_group);
11684 if (sign_group == NULL)
11685 return;
11686 }
11687
11688 // Buffer to place the sign
11689 buf = get_buf_arg(&argvars[2]);
11690 if (buf == NULL)
11691 goto cleanup;
11692
11693 rettv->vval.v_number = sign_jump(sign_id, sign_group, buf);
11694
11695cleanup:
11696 vim_free(sign_group);
11697}
11698
11699/*
Bram Moolenaar162b7142018-12-21 15:17:36 +010011700 * "sign_place()" function
11701 */
11702 static void
11703f_sign_place(typval_T *argvars, typval_T *rettv)
11704{
11705 int sign_id;
11706 char_u *group = NULL;
11707 char_u *sign_name;
11708 buf_T *buf;
11709 dict_T *dict;
11710 dictitem_T *di;
11711 linenr_T lnum = 0;
11712 int prio = SIGN_DEF_PRIO;
11713 int notanum = FALSE;
11714
11715 rettv->vval.v_number = -1;
11716
Bram Moolenaarbdace832019-03-02 10:13:42 +010011717 // Sign identifier
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011718 sign_id = (int)tv_get_number_chk(&argvars[0], &notanum);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011719 if (notanum)
11720 return;
11721 if (sign_id < 0)
11722 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011723 emsg(_(e_invarg));
Bram Moolenaar162b7142018-12-21 15:17:36 +010011724 return;
11725 }
11726
11727 // Sign group
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011728 group = tv_get_string_chk(&argvars[1]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011729 if (group == NULL)
11730 return;
11731 if (group[0] == '\0')
11732 group = NULL; // global sign group
11733 else
11734 {
11735 group = vim_strsave(group);
11736 if (group == NULL)
11737 return;
11738 }
11739
11740 // Sign name
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011741 sign_name = tv_get_string_chk(&argvars[2]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011742 if (sign_name == NULL)
11743 goto cleanup;
11744
11745 // Buffer to place the sign
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011746 buf = get_buf_arg(&argvars[3]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011747 if (buf == NULL)
Bram Moolenaar162b7142018-12-21 15:17:36 +010011748 goto cleanup;
Bram Moolenaar162b7142018-12-21 15:17:36 +010011749
11750 if (argvars[4].v_type != VAR_UNKNOWN)
11751 {
11752 if (argvars[4].v_type != VAR_DICT ||
11753 ((dict = argvars[4].vval.v_dict) == NULL))
11754 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011755 emsg(_(e_dictreq));
Bram Moolenaar162b7142018-12-21 15:17:36 +010011756 goto cleanup;
11757 }
11758
11759 // Line number where the sign is to be placed
11760 if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
11761 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011762 (void)tv_get_number_chk(&di->di_tv, &notanum);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011763 if (notanum)
11764 goto cleanup;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011765 lnum = tv_get_lnum(&di->di_tv);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011766 }
11767 if ((di = dict_find(dict, (char_u *)"priority", -1)) != NULL)
11768 {
11769 // Sign priority
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011770 prio = (int)tv_get_number_chk(&di->di_tv, &notanum);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011771 if (notanum)
11772 goto cleanup;
11773 }
11774 }
11775
11776 if (sign_place(&sign_id, group, sign_name, buf, lnum, prio) == OK)
11777 rettv->vval.v_number = sign_id;
11778
11779cleanup:
11780 vim_free(group);
11781}
11782
11783/*
11784 * "sign_undefine()" function
11785 */
11786 static void
11787f_sign_undefine(typval_T *argvars, typval_T *rettv)
11788{
11789 char_u *name;
11790
11791 rettv->vval.v_number = -1;
11792
11793 if (argvars[0].v_type == VAR_UNKNOWN)
11794 {
11795 // Free all the signs
11796 free_signs();
11797 rettv->vval.v_number = 0;
11798 }
11799 else
11800 {
11801 // Free only the specified sign
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011802 name = tv_get_string_chk(&argvars[0]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011803 if (name == NULL)
11804 return;
11805
11806 if (sign_undefine_by_name(name) == OK)
11807 rettv->vval.v_number = 0;
11808 }
11809}
11810
11811/*
11812 * "sign_unplace()" function
11813 */
11814 static void
11815f_sign_unplace(typval_T *argvars, typval_T *rettv)
11816{
11817 dict_T *dict;
11818 dictitem_T *di;
11819 int sign_id = 0;
11820 buf_T *buf = NULL;
11821 char_u *group = NULL;
11822
11823 rettv->vval.v_number = -1;
11824
11825 if (argvars[0].v_type != VAR_STRING)
11826 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011827 emsg(_(e_invarg));
Bram Moolenaar162b7142018-12-21 15:17:36 +010011828 return;
11829 }
11830
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011831 group = tv_get_string(&argvars[0]);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011832 if (group[0] == '\0')
11833 group = NULL; // global sign group
11834 else
11835 {
11836 group = vim_strsave(group);
11837 if (group == NULL)
11838 return;
11839 }
11840
11841 if (argvars[1].v_type != VAR_UNKNOWN)
11842 {
11843 if (argvars[1].v_type != VAR_DICT)
11844 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011845 emsg(_(e_dictreq));
Bram Moolenaar1ea88a32018-12-29 21:00:27 +010011846 goto cleanup;
Bram Moolenaar162b7142018-12-21 15:17:36 +010011847 }
11848 dict = argvars[1].vval.v_dict;
11849
11850 if ((di = dict_find(dict, (char_u *)"buffer", -1)) != NULL)
11851 {
Bram Moolenaar6b7b7192019-01-11 13:42:41 +010011852 buf = get_buf_arg(&di->di_tv);
Bram Moolenaar162b7142018-12-21 15:17:36 +010011853 if (buf == NULL)
Bram Moolenaar1ea88a32018-12-29 21:00:27 +010011854 goto cleanup;
Bram Moolenaar162b7142018-12-21 15:17:36 +010011855 }
11856 if (dict_find(dict, (char_u *)"id", -1) != NULL)
11857 sign_id = dict_get_number(dict, (char_u *)"id");
11858 }
11859
11860 if (buf == NULL)
11861 {
11862 // Delete the sign in all the buffers
11863 FOR_ALL_BUFFERS(buf)
Bram Moolenaar7d83bf42018-12-29 18:53:55 +010011864 if (sign_unplace(sign_id, group, buf, 0) == OK)
Bram Moolenaar162b7142018-12-21 15:17:36 +010011865 rettv->vval.v_number = 0;
11866 }
11867 else
11868 {
Bram Moolenaar7d83bf42018-12-29 18:53:55 +010011869 if (sign_unplace(sign_id, group, buf, 0) == OK)
Bram Moolenaar162b7142018-12-21 15:17:36 +010011870 rettv->vval.v_number = 0;
11871 }
Bram Moolenaar1ea88a32018-12-29 21:00:27 +010011872
11873cleanup:
Bram Moolenaar162b7142018-12-21 15:17:36 +010011874 vim_free(group);
11875}
11876#endif
11877
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011878/*
11879 * "simplify()" function
11880 */
11881 static void
11882f_simplify(typval_T *argvars, typval_T *rettv)
11883{
11884 char_u *p;
11885
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011886 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011887 rettv->vval.v_string = vim_strsave(p);
11888 simplify_filename(rettv->vval.v_string); /* simplify in place */
11889 rettv->v_type = VAR_STRING;
11890}
11891
11892#ifdef FEAT_FLOAT
11893/*
11894 * "sin()" function
11895 */
11896 static void
11897f_sin(typval_T *argvars, typval_T *rettv)
11898{
11899 float_T f = 0.0;
11900
11901 rettv->v_type = VAR_FLOAT;
11902 if (get_float_arg(argvars, &f) == OK)
11903 rettv->vval.v_float = sin(f);
11904 else
11905 rettv->vval.v_float = 0.0;
11906}
11907
11908/*
11909 * "sinh()" function
11910 */
11911 static void
11912f_sinh(typval_T *argvars, typval_T *rettv)
11913{
11914 float_T f = 0.0;
11915
11916 rettv->v_type = VAR_FLOAT;
11917 if (get_float_arg(argvars, &f) == OK)
11918 rettv->vval.v_float = sinh(f);
11919 else
11920 rettv->vval.v_float = 0.0;
11921}
11922#endif
11923
11924static int
11925#ifdef __BORLANDC__
11926 _RTLENTRYF
11927#endif
11928 item_compare(const void *s1, const void *s2);
11929static int
11930#ifdef __BORLANDC__
11931 _RTLENTRYF
11932#endif
11933 item_compare2(const void *s1, const void *s2);
11934
11935/* struct used in the array that's given to qsort() */
11936typedef struct
11937{
11938 listitem_T *item;
11939 int idx;
11940} sortItem_T;
11941
11942/* struct storing information about current sort */
11943typedef struct
11944{
11945 int item_compare_ic;
11946 int item_compare_numeric;
11947 int item_compare_numbers;
11948#ifdef FEAT_FLOAT
11949 int item_compare_float;
11950#endif
11951 char_u *item_compare_func;
11952 partial_T *item_compare_partial;
11953 dict_T *item_compare_selfdict;
11954 int item_compare_func_err;
11955 int item_compare_keep_zero;
11956} sortinfo_T;
11957static sortinfo_T *sortinfo = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011958#define ITEM_COMPARE_FAIL 999
11959
11960/*
11961 * Compare functions for f_sort() and f_uniq() below.
11962 */
11963 static int
11964#ifdef __BORLANDC__
11965_RTLENTRYF
11966#endif
11967item_compare(const void *s1, const void *s2)
11968{
11969 sortItem_T *si1, *si2;
11970 typval_T *tv1, *tv2;
11971 char_u *p1, *p2;
11972 char_u *tofree1 = NULL, *tofree2 = NULL;
11973 int res;
11974 char_u numbuf1[NUMBUFLEN];
11975 char_u numbuf2[NUMBUFLEN];
11976
11977 si1 = (sortItem_T *)s1;
11978 si2 = (sortItem_T *)s2;
11979 tv1 = &si1->item->li_tv;
11980 tv2 = &si2->item->li_tv;
11981
11982 if (sortinfo->item_compare_numbers)
11983 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011984 varnumber_T v1 = tv_get_number(tv1);
11985 varnumber_T v2 = tv_get_number(tv2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011986
11987 return v1 == v2 ? 0 : v1 > v2 ? 1 : -1;
11988 }
11989
11990#ifdef FEAT_FLOAT
11991 if (sortinfo->item_compare_float)
11992 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010011993 float_T v1 = tv_get_float(tv1);
11994 float_T v2 = tv_get_float(tv2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020011995
11996 return v1 == v2 ? 0 : v1 > v2 ? 1 : -1;
11997 }
11998#endif
11999
12000 /* tv2string() puts quotes around a string and allocates memory. Don't do
12001 * that for string variables. Use a single quote when comparing with a
12002 * non-string to do what the docs promise. */
12003 if (tv1->v_type == VAR_STRING)
12004 {
12005 if (tv2->v_type != VAR_STRING || sortinfo->item_compare_numeric)
12006 p1 = (char_u *)"'";
12007 else
12008 p1 = tv1->vval.v_string;
12009 }
12010 else
12011 p1 = tv2string(tv1, &tofree1, numbuf1, 0);
12012 if (tv2->v_type == VAR_STRING)
12013 {
12014 if (tv1->v_type != VAR_STRING || sortinfo->item_compare_numeric)
12015 p2 = (char_u *)"'";
12016 else
12017 p2 = tv2->vval.v_string;
12018 }
12019 else
12020 p2 = tv2string(tv2, &tofree2, numbuf2, 0);
12021 if (p1 == NULL)
12022 p1 = (char_u *)"";
12023 if (p2 == NULL)
12024 p2 = (char_u *)"";
12025 if (!sortinfo->item_compare_numeric)
12026 {
12027 if (sortinfo->item_compare_ic)
12028 res = STRICMP(p1, p2);
12029 else
12030 res = STRCMP(p1, p2);
12031 }
12032 else
12033 {
12034 double n1, n2;
12035 n1 = strtod((char *)p1, (char **)&p1);
12036 n2 = strtod((char *)p2, (char **)&p2);
12037 res = n1 == n2 ? 0 : n1 > n2 ? 1 : -1;
12038 }
12039
12040 /* When the result would be zero, compare the item indexes. Makes the
12041 * sort stable. */
12042 if (res == 0 && !sortinfo->item_compare_keep_zero)
12043 res = si1->idx > si2->idx ? 1 : -1;
12044
12045 vim_free(tofree1);
12046 vim_free(tofree2);
12047 return res;
12048}
12049
12050 static int
12051#ifdef __BORLANDC__
12052_RTLENTRYF
12053#endif
12054item_compare2(const void *s1, const void *s2)
12055{
12056 sortItem_T *si1, *si2;
12057 int res;
12058 typval_T rettv;
12059 typval_T argv[3];
12060 int dummy;
12061 char_u *func_name;
12062 partial_T *partial = sortinfo->item_compare_partial;
12063
12064 /* shortcut after failure in previous call; compare all items equal */
12065 if (sortinfo->item_compare_func_err)
12066 return 0;
12067
12068 si1 = (sortItem_T *)s1;
12069 si2 = (sortItem_T *)s2;
12070
12071 if (partial == NULL)
12072 func_name = sortinfo->item_compare_func;
12073 else
Bram Moolenaar437bafe2016-08-01 15:40:54 +020012074 func_name = partial_name(partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012075
12076 /* Copy the values. This is needed to be able to set v_lock to VAR_FIXED
12077 * in the copy without changing the original list items. */
12078 copy_tv(&si1->item->li_tv, &argv[0]);
12079 copy_tv(&si2->item->li_tv, &argv[1]);
12080
12081 rettv.v_type = VAR_UNKNOWN; /* clear_tv() uses this */
12082 res = call_func(func_name, (int)STRLEN(func_name),
Bram Moolenaardf48fb42016-07-22 21:50:18 +020012083 &rettv, 2, argv, NULL, 0L, 0L, &dummy, TRUE,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012084 partial, sortinfo->item_compare_selfdict);
12085 clear_tv(&argv[0]);
12086 clear_tv(&argv[1]);
12087
12088 if (res == FAIL)
12089 res = ITEM_COMPARE_FAIL;
12090 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012091 res = (int)tv_get_number_chk(&rettv, &sortinfo->item_compare_func_err);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012092 if (sortinfo->item_compare_func_err)
12093 res = ITEM_COMPARE_FAIL; /* return value has wrong type */
12094 clear_tv(&rettv);
12095
12096 /* When the result would be zero, compare the pointers themselves. Makes
12097 * the sort stable. */
12098 if (res == 0 && !sortinfo->item_compare_keep_zero)
12099 res = si1->idx > si2->idx ? 1 : -1;
12100
12101 return res;
12102}
12103
12104/*
12105 * "sort({list})" function
12106 */
12107 static void
12108do_sort_uniq(typval_T *argvars, typval_T *rettv, int sort)
12109{
12110 list_T *l;
12111 listitem_T *li;
12112 sortItem_T *ptrs;
12113 sortinfo_T *old_sortinfo;
12114 sortinfo_T info;
12115 long len;
12116 long i;
12117
12118 /* Pointer to current info struct used in compare function. Save and
12119 * restore the current one for nested calls. */
12120 old_sortinfo = sortinfo;
12121 sortinfo = &info;
12122
12123 if (argvars[0].v_type != VAR_LIST)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012124 semsg(_(e_listarg), sort ? "sort()" : "uniq()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012125 else
12126 {
12127 l = argvars[0].vval.v_list;
Bram Moolenaar05c00c02019-02-11 22:00:11 +010012128 if (l == NULL || var_check_lock(l->lv_lock,
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012129 (char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),
12130 TRUE))
12131 goto theend;
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020012132 rettv_list_set(rettv, l);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012133
12134 len = list_len(l);
12135 if (len <= 1)
12136 goto theend; /* short list sorts pretty quickly */
12137
12138 info.item_compare_ic = FALSE;
12139 info.item_compare_numeric = FALSE;
12140 info.item_compare_numbers = FALSE;
12141#ifdef FEAT_FLOAT
12142 info.item_compare_float = FALSE;
12143#endif
12144 info.item_compare_func = NULL;
12145 info.item_compare_partial = NULL;
12146 info.item_compare_selfdict = NULL;
12147 if (argvars[1].v_type != VAR_UNKNOWN)
12148 {
12149 /* optional second argument: {func} */
12150 if (argvars[1].v_type == VAR_FUNC)
12151 info.item_compare_func = argvars[1].vval.v_string;
12152 else if (argvars[1].v_type == VAR_PARTIAL)
12153 info.item_compare_partial = argvars[1].vval.v_partial;
12154 else
12155 {
12156 int error = FALSE;
12157
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012158 i = (long)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012159 if (error)
12160 goto theend; /* type error; errmsg already given */
12161 if (i == 1)
12162 info.item_compare_ic = TRUE;
12163 else if (argvars[1].v_type != VAR_NUMBER)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012164 info.item_compare_func = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012165 else if (i != 0)
12166 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012167 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012168 goto theend;
12169 }
12170 if (info.item_compare_func != NULL)
12171 {
12172 if (*info.item_compare_func == NUL)
12173 {
12174 /* empty string means default sort */
12175 info.item_compare_func = NULL;
12176 }
12177 else if (STRCMP(info.item_compare_func, "n") == 0)
12178 {
12179 info.item_compare_func = NULL;
12180 info.item_compare_numeric = TRUE;
12181 }
12182 else if (STRCMP(info.item_compare_func, "N") == 0)
12183 {
12184 info.item_compare_func = NULL;
12185 info.item_compare_numbers = TRUE;
12186 }
12187#ifdef FEAT_FLOAT
12188 else if (STRCMP(info.item_compare_func, "f") == 0)
12189 {
12190 info.item_compare_func = NULL;
12191 info.item_compare_float = TRUE;
12192 }
12193#endif
12194 else if (STRCMP(info.item_compare_func, "i") == 0)
12195 {
12196 info.item_compare_func = NULL;
12197 info.item_compare_ic = TRUE;
12198 }
12199 }
12200 }
12201
12202 if (argvars[2].v_type != VAR_UNKNOWN)
12203 {
12204 /* optional third argument: {dict} */
12205 if (argvars[2].v_type != VAR_DICT)
12206 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012207 emsg(_(e_dictreq));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012208 goto theend;
12209 }
12210 info.item_compare_selfdict = argvars[2].vval.v_dict;
12211 }
12212 }
12213
12214 /* Make an array with each entry pointing to an item in the List. */
12215 ptrs = (sortItem_T *)alloc((int)(len * sizeof(sortItem_T)));
12216 if (ptrs == NULL)
12217 goto theend;
12218
12219 i = 0;
12220 if (sort)
12221 {
12222 /* sort(): ptrs will be the list to sort */
12223 for (li = l->lv_first; li != NULL; li = li->li_next)
12224 {
12225 ptrs[i].item = li;
12226 ptrs[i].idx = i;
12227 ++i;
12228 }
12229
12230 info.item_compare_func_err = FALSE;
12231 info.item_compare_keep_zero = FALSE;
12232 /* test the compare function */
12233 if ((info.item_compare_func != NULL
12234 || info.item_compare_partial != NULL)
12235 && item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
12236 == ITEM_COMPARE_FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012237 emsg(_("E702: Sort compare function failed"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012238 else
12239 {
12240 /* Sort the array with item pointers. */
12241 qsort((void *)ptrs, (size_t)len, sizeof(sortItem_T),
12242 info.item_compare_func == NULL
12243 && info.item_compare_partial == NULL
12244 ? item_compare : item_compare2);
12245
12246 if (!info.item_compare_func_err)
12247 {
12248 /* Clear the List and append the items in sorted order. */
12249 l->lv_first = l->lv_last = l->lv_idx_item = NULL;
12250 l->lv_len = 0;
12251 for (i = 0; i < len; ++i)
12252 list_append(l, ptrs[i].item);
12253 }
12254 }
12255 }
12256 else
12257 {
12258 int (*item_compare_func_ptr)(const void *, const void *);
12259
12260 /* f_uniq(): ptrs will be a stack of items to remove */
12261 info.item_compare_func_err = FALSE;
12262 info.item_compare_keep_zero = TRUE;
12263 item_compare_func_ptr = info.item_compare_func != NULL
12264 || info.item_compare_partial != NULL
12265 ? item_compare2 : item_compare;
12266
12267 for (li = l->lv_first; li != NULL && li->li_next != NULL;
12268 li = li->li_next)
12269 {
12270 if (item_compare_func_ptr((void *)&li, (void *)&li->li_next)
12271 == 0)
12272 ptrs[i++].item = li;
12273 if (info.item_compare_func_err)
12274 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012275 emsg(_("E882: Uniq compare function failed"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012276 break;
12277 }
12278 }
12279
12280 if (!info.item_compare_func_err)
12281 {
12282 while (--i >= 0)
12283 {
12284 li = ptrs[i].item->li_next;
12285 ptrs[i].item->li_next = li->li_next;
12286 if (li->li_next != NULL)
12287 li->li_next->li_prev = ptrs[i].item;
12288 else
12289 l->lv_last = ptrs[i].item;
12290 list_fix_watch(l, li);
12291 listitem_free(li);
12292 l->lv_len--;
12293 }
12294 }
12295 }
12296
12297 vim_free(ptrs);
12298 }
12299theend:
12300 sortinfo = old_sortinfo;
12301}
12302
12303/*
12304 * "sort({list})" function
12305 */
12306 static void
12307f_sort(typval_T *argvars, typval_T *rettv)
12308{
12309 do_sort_uniq(argvars, rettv, TRUE);
12310}
12311
12312/*
12313 * "uniq({list})" function
12314 */
12315 static void
12316f_uniq(typval_T *argvars, typval_T *rettv)
12317{
12318 do_sort_uniq(argvars, rettv, FALSE);
12319}
12320
12321/*
12322 * "soundfold({word})" function
12323 */
12324 static void
12325f_soundfold(typval_T *argvars, typval_T *rettv)
12326{
12327 char_u *s;
12328
12329 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012330 s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012331#ifdef FEAT_SPELL
12332 rettv->vval.v_string = eval_soundfold(s);
12333#else
12334 rettv->vval.v_string = vim_strsave(s);
12335#endif
12336}
12337
12338/*
12339 * "spellbadword()" function
12340 */
12341 static void
12342f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv)
12343{
12344 char_u *word = (char_u *)"";
12345 hlf_T attr = HLF_COUNT;
12346 int len = 0;
12347
12348 if (rettv_list_alloc(rettv) == FAIL)
12349 return;
12350
12351#ifdef FEAT_SPELL
12352 if (argvars[0].v_type == VAR_UNKNOWN)
12353 {
12354 /* Find the start and length of the badly spelled word. */
12355 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
12356 if (len != 0)
Bram Moolenaarb73fa622017-12-21 20:27:47 +010012357 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012358 word = ml_get_cursor();
Bram Moolenaarb73fa622017-12-21 20:27:47 +010012359 curwin->w_set_curswant = TRUE;
12360 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012361 }
12362 else if (curwin->w_p_spell && *curbuf->b_s.b_p_spl != NUL)
12363 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012364 char_u *str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012365 int capcol = -1;
12366
12367 if (str != NULL)
12368 {
12369 /* Check the argument for spelling. */
12370 while (*str != NUL)
12371 {
12372 len = spell_check(curwin, str, &attr, &capcol, FALSE);
12373 if (attr != HLF_COUNT)
12374 {
12375 word = str;
12376 break;
12377 }
12378 str += len;
Bram Moolenaar66ab9162018-07-20 20:28:48 +020012379 capcol -= len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012380 }
12381 }
12382 }
12383#endif
12384
12385 list_append_string(rettv->vval.v_list, word, len);
12386 list_append_string(rettv->vval.v_list, (char_u *)(
12387 attr == HLF_SPB ? "bad" :
12388 attr == HLF_SPR ? "rare" :
12389 attr == HLF_SPL ? "local" :
12390 attr == HLF_SPC ? "caps" :
12391 ""), -1);
12392}
12393
12394/*
12395 * "spellsuggest()" function
12396 */
12397 static void
12398f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv)
12399{
12400#ifdef FEAT_SPELL
12401 char_u *str;
12402 int typeerr = FALSE;
12403 int maxcount;
12404 garray_T ga;
12405 int i;
12406 listitem_T *li;
12407 int need_capital = FALSE;
12408#endif
12409
12410 if (rettv_list_alloc(rettv) == FAIL)
12411 return;
12412
12413#ifdef FEAT_SPELL
12414 if (curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL)
12415 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012416 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012417 if (argvars[1].v_type != VAR_UNKNOWN)
12418 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012419 maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012420 if (maxcount <= 0)
12421 return;
12422 if (argvars[2].v_type != VAR_UNKNOWN)
12423 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012424 need_capital = (int)tv_get_number_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012425 if (typeerr)
12426 return;
12427 }
12428 }
12429 else
12430 maxcount = 25;
12431
12432 spell_suggest_list(&ga, str, maxcount, need_capital, FALSE);
12433
12434 for (i = 0; i < ga.ga_len; ++i)
12435 {
12436 str = ((char_u **)ga.ga_data)[i];
12437
12438 li = listitem_alloc();
12439 if (li == NULL)
12440 vim_free(str);
12441 else
12442 {
12443 li->li_tv.v_type = VAR_STRING;
12444 li->li_tv.v_lock = 0;
12445 li->li_tv.vval.v_string = str;
12446 list_append(rettv->vval.v_list, li);
12447 }
12448 }
12449 ga_clear(&ga);
12450 }
12451#endif
12452}
12453
12454 static void
12455f_split(typval_T *argvars, typval_T *rettv)
12456{
12457 char_u *str;
12458 char_u *end;
12459 char_u *pat = NULL;
12460 regmatch_T regmatch;
12461 char_u patbuf[NUMBUFLEN];
12462 char_u *save_cpo;
12463 int match;
12464 colnr_T col = 0;
12465 int keepempty = FALSE;
12466 int typeerr = FALSE;
12467
12468 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12469 save_cpo = p_cpo;
12470 p_cpo = (char_u *)"";
12471
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012472 str = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012473 if (argvars[1].v_type != VAR_UNKNOWN)
12474 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012475 pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012476 if (pat == NULL)
12477 typeerr = TRUE;
12478 if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012479 keepempty = (int)tv_get_number_chk(&argvars[2], &typeerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012480 }
12481 if (pat == NULL || *pat == NUL)
12482 pat = (char_u *)"[\\x01- ]\\+";
12483
12484 if (rettv_list_alloc(rettv) == FAIL)
12485 return;
12486 if (typeerr)
12487 return;
12488
12489 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
12490 if (regmatch.regprog != NULL)
12491 {
12492 regmatch.rm_ic = FALSE;
12493 while (*str != NUL || keepempty)
12494 {
12495 if (*str == NUL)
12496 match = FALSE; /* empty item at the end */
12497 else
12498 match = vim_regexec_nl(&regmatch, str, col);
12499 if (match)
12500 end = regmatch.startp[0];
12501 else
12502 end = str + STRLEN(str);
12503 if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0
12504 && *str != NUL && match && end < regmatch.endp[0]))
12505 {
12506 if (list_append_string(rettv->vval.v_list, str,
12507 (int)(end - str)) == FAIL)
12508 break;
12509 }
12510 if (!match)
12511 break;
Bram Moolenaar13505972019-01-24 15:04:48 +010012512 // Advance to just after the match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012513 if (regmatch.endp[0] > str)
12514 col = 0;
12515 else
Bram Moolenaar13505972019-01-24 15:04:48 +010012516 // Don't get stuck at the same match.
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012517 col = (*mb_ptr2len)(regmatch.endp[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012518 str = regmatch.endp[0];
12519 }
12520
12521 vim_regfree(regmatch.regprog);
12522 }
12523
12524 p_cpo = save_cpo;
12525}
12526
12527#ifdef FEAT_FLOAT
12528/*
12529 * "sqrt()" function
12530 */
12531 static void
12532f_sqrt(typval_T *argvars, typval_T *rettv)
12533{
12534 float_T f = 0.0;
12535
12536 rettv->v_type = VAR_FLOAT;
12537 if (get_float_arg(argvars, &f) == OK)
12538 rettv->vval.v_float = sqrt(f);
12539 else
12540 rettv->vval.v_float = 0.0;
12541}
12542
12543/*
12544 * "str2float()" function
12545 */
12546 static void
12547f_str2float(typval_T *argvars, typval_T *rettv)
12548{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012549 char_u *p = skipwhite(tv_get_string(&argvars[0]));
Bram Moolenaar08243d22017-01-10 16:12:29 +010012550 int isneg = (*p == '-');
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012551
Bram Moolenaar08243d22017-01-10 16:12:29 +010012552 if (*p == '+' || *p == '-')
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012553 p = skipwhite(p + 1);
12554 (void)string2float(p, &rettv->vval.v_float);
Bram Moolenaar08243d22017-01-10 16:12:29 +010012555 if (isneg)
12556 rettv->vval.v_float *= -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012557 rettv->v_type = VAR_FLOAT;
12558}
12559#endif
12560
12561/*
12562 * "str2nr()" function
12563 */
12564 static void
12565f_str2nr(typval_T *argvars, typval_T *rettv)
12566{
12567 int base = 10;
12568 char_u *p;
12569 varnumber_T n;
12570 int what;
Bram Moolenaar08243d22017-01-10 16:12:29 +010012571 int isneg;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012572
12573 if (argvars[1].v_type != VAR_UNKNOWN)
12574 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012575 base = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012576 if (base != 2 && base != 8 && base != 10 && base != 16)
12577 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012578 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012579 return;
12580 }
12581 }
12582
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012583 p = skipwhite(tv_get_string(&argvars[0]));
Bram Moolenaar08243d22017-01-10 16:12:29 +010012584 isneg = (*p == '-');
12585 if (*p == '+' || *p == '-')
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012586 p = skipwhite(p + 1);
12587 switch (base)
12588 {
12589 case 2: what = STR2NR_BIN + STR2NR_FORCE; break;
12590 case 8: what = STR2NR_OCT + STR2NR_FORCE; break;
12591 case 16: what = STR2NR_HEX + STR2NR_FORCE; break;
12592 default: what = 0;
12593 }
12594 vim_str2nr(p, NULL, NULL, what, &n, NULL, 0);
Bram Moolenaar08243d22017-01-10 16:12:29 +010012595 if (isneg)
12596 rettv->vval.v_number = -n;
12597 else
12598 rettv->vval.v_number = n;
12599
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012600}
12601
12602#ifdef HAVE_STRFTIME
12603/*
12604 * "strftime({format}[, {time}])" function
12605 */
12606 static void
12607f_strftime(typval_T *argvars, typval_T *rettv)
12608{
12609 char_u result_buf[256];
12610 struct tm *curtime;
12611 time_t seconds;
12612 char_u *p;
12613
12614 rettv->v_type = VAR_STRING;
12615
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012616 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012617 if (argvars[1].v_type == VAR_UNKNOWN)
12618 seconds = time(NULL);
12619 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012620 seconds = (time_t)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012621 curtime = localtime(&seconds);
12622 /* MSVC returns NULL for an invalid value of seconds. */
12623 if (curtime == NULL)
12624 rettv->vval.v_string = vim_strsave((char_u *)_("(Invalid)"));
12625 else
12626 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012627 vimconv_T conv;
12628 char_u *enc;
12629
12630 conv.vc_type = CONV_NONE;
12631 enc = enc_locale();
12632 convert_setup(&conv, p_enc, enc);
12633 if (conv.vc_type != CONV_NONE)
12634 p = string_convert(&conv, p, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012635 if (p != NULL)
12636 (void)strftime((char *)result_buf, sizeof(result_buf),
12637 (char *)p, curtime);
12638 else
12639 result_buf[0] = NUL;
12640
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012641 if (conv.vc_type != CONV_NONE)
12642 vim_free(p);
12643 convert_setup(&conv, enc, p_enc);
12644 if (conv.vc_type != CONV_NONE)
12645 rettv->vval.v_string = string_convert(&conv, result_buf, NULL);
12646 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012647 rettv->vval.v_string = vim_strsave(result_buf);
12648
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012649 /* Release conversion descriptors */
12650 convert_setup(&conv, NULL, NULL);
12651 vim_free(enc);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012652 }
12653}
12654#endif
12655
12656/*
12657 * "strgetchar()" function
12658 */
12659 static void
12660f_strgetchar(typval_T *argvars, typval_T *rettv)
12661{
12662 char_u *str;
12663 int len;
12664 int error = FALSE;
12665 int charidx;
Bram Moolenaar13505972019-01-24 15:04:48 +010012666 int byteidx = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012667
12668 rettv->vval.v_number = -1;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012669 str = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012670 if (str == NULL)
12671 return;
12672 len = (int)STRLEN(str);
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012673 charidx = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012674 if (error)
12675 return;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012676
Bram Moolenaar13505972019-01-24 15:04:48 +010012677 while (charidx >= 0 && byteidx < len)
12678 {
12679 if (charidx == 0)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012680 {
Bram Moolenaar13505972019-01-24 15:04:48 +010012681 rettv->vval.v_number = mb_ptr2char(str + byteidx);
12682 break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012683 }
Bram Moolenaar13505972019-01-24 15:04:48 +010012684 --charidx;
12685 byteidx += MB_CPTR2LEN(str + byteidx);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012686 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012687}
12688
12689/*
12690 * "stridx()" function
12691 */
12692 static void
12693f_stridx(typval_T *argvars, typval_T *rettv)
12694{
12695 char_u buf[NUMBUFLEN];
12696 char_u *needle;
12697 char_u *haystack;
12698 char_u *save_haystack;
12699 char_u *pos;
12700 int start_idx;
12701
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012702 needle = tv_get_string_chk(&argvars[1]);
12703 save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012704 rettv->vval.v_number = -1;
12705 if (needle == NULL || haystack == NULL)
12706 return; /* type error; errmsg already given */
12707
12708 if (argvars[2].v_type != VAR_UNKNOWN)
12709 {
12710 int error = FALSE;
12711
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012712 start_idx = (int)tv_get_number_chk(&argvars[2], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012713 if (error || start_idx >= (int)STRLEN(haystack))
12714 return;
12715 if (start_idx >= 0)
12716 haystack += start_idx;
12717 }
12718
12719 pos = (char_u *)strstr((char *)haystack, (char *)needle);
12720 if (pos != NULL)
12721 rettv->vval.v_number = (varnumber_T)(pos - save_haystack);
12722}
12723
12724/*
12725 * "string()" function
12726 */
Bram Moolenaar461a7fc2018-12-22 13:28:07 +010012727 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012728f_string(typval_T *argvars, typval_T *rettv)
12729{
12730 char_u *tofree;
12731 char_u numbuf[NUMBUFLEN];
12732
12733 rettv->v_type = VAR_STRING;
12734 rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf,
12735 get_copyID());
12736 /* Make a copy if we have a value but it's not in allocated memory. */
12737 if (rettv->vval.v_string != NULL && tofree == NULL)
12738 rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
12739}
12740
12741/*
12742 * "strlen()" function
12743 */
12744 static void
12745f_strlen(typval_T *argvars, typval_T *rettv)
12746{
12747 rettv->vval.v_number = (varnumber_T)(STRLEN(
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012748 tv_get_string(&argvars[0])));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012749}
12750
12751/*
12752 * "strchars()" function
12753 */
12754 static void
12755f_strchars(typval_T *argvars, typval_T *rettv)
12756{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012757 char_u *s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012758 int skipcc = 0;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012759 varnumber_T len = 0;
12760 int (*func_mb_ptr2char_adv)(char_u **pp);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012761
12762 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012763 skipcc = (int)tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012764 if (skipcc < 0 || skipcc > 1)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012765 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012766 else
12767 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012768 func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;
12769 while (*s != NUL)
12770 {
12771 func_mb_ptr2char_adv(&s);
12772 ++len;
12773 }
12774 rettv->vval.v_number = len;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012775 }
12776}
12777
12778/*
12779 * "strdisplaywidth()" function
12780 */
12781 static void
12782f_strdisplaywidth(typval_T *argvars, typval_T *rettv)
12783{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012784 char_u *s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012785 int col = 0;
12786
12787 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012788 col = (int)tv_get_number(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012789
12790 rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col);
12791}
12792
12793/*
12794 * "strwidth()" function
12795 */
12796 static void
12797f_strwidth(typval_T *argvars, typval_T *rettv)
12798{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012799 char_u *s = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012800
Bram Moolenaar13505972019-01-24 15:04:48 +010012801 rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012802}
12803
12804/*
12805 * "strcharpart()" function
12806 */
12807 static void
12808f_strcharpart(typval_T *argvars, typval_T *rettv)
12809{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012810 char_u *p;
12811 int nchar;
12812 int nbyte = 0;
12813 int charlen;
12814 int len = 0;
12815 int slen;
12816 int error = FALSE;
12817
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012818 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012819 slen = (int)STRLEN(p);
12820
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012821 nchar = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012822 if (!error)
12823 {
12824 if (nchar > 0)
12825 while (nchar > 0 && nbyte < slen)
12826 {
Bram Moolenaard3c907b2016-08-17 21:32:09 +020012827 nbyte += MB_CPTR2LEN(p + nbyte);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012828 --nchar;
12829 }
12830 else
12831 nbyte = nchar;
12832 if (argvars[2].v_type != VAR_UNKNOWN)
12833 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012834 charlen = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012835 while (charlen > 0 && nbyte + len < slen)
12836 {
12837 int off = nbyte + len;
12838
12839 if (off < 0)
12840 len += 1;
12841 else
Bram Moolenaard3c907b2016-08-17 21:32:09 +020012842 len += MB_CPTR2LEN(p + off);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012843 --charlen;
12844 }
12845 }
12846 else
12847 len = slen - nbyte; /* default: all bytes that are available. */
12848 }
12849
12850 /*
12851 * Only return the overlap between the specified part and the actual
12852 * string.
12853 */
12854 if (nbyte < 0)
12855 {
12856 len += nbyte;
12857 nbyte = 0;
12858 }
12859 else if (nbyte > slen)
12860 nbyte = slen;
12861 if (len < 0)
12862 len = 0;
12863 else if (nbyte + len > slen)
12864 len = slen - nbyte;
12865
12866 rettv->v_type = VAR_STRING;
12867 rettv->vval.v_string = vim_strnsave(p + nbyte, len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012868}
12869
12870/*
12871 * "strpart()" function
12872 */
12873 static void
12874f_strpart(typval_T *argvars, typval_T *rettv)
12875{
12876 char_u *p;
12877 int n;
12878 int len;
12879 int slen;
12880 int error = FALSE;
12881
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012882 p = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012883 slen = (int)STRLEN(p);
12884
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012885 n = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012886 if (error)
12887 len = 0;
12888 else if (argvars[2].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012889 len = (int)tv_get_number(&argvars[2]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012890 else
12891 len = slen - n; /* default len: all bytes that are available. */
12892
12893 /*
12894 * Only return the overlap between the specified part and the actual
12895 * string.
12896 */
12897 if (n < 0)
12898 {
12899 len += n;
12900 n = 0;
12901 }
12902 else if (n > slen)
12903 n = slen;
12904 if (len < 0)
12905 len = 0;
12906 else if (n + len > slen)
12907 len = slen - n;
12908
12909 rettv->v_type = VAR_STRING;
12910 rettv->vval.v_string = vim_strnsave(p + n, len);
12911}
12912
12913/*
12914 * "strridx()" function
12915 */
12916 static void
12917f_strridx(typval_T *argvars, typval_T *rettv)
12918{
12919 char_u buf[NUMBUFLEN];
12920 char_u *needle;
12921 char_u *haystack;
12922 char_u *rest;
12923 char_u *lastmatch = NULL;
12924 int haystack_len, end_idx;
12925
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012926 needle = tv_get_string_chk(&argvars[1]);
12927 haystack = tv_get_string_buf_chk(&argvars[0], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012928
12929 rettv->vval.v_number = -1;
12930 if (needle == NULL || haystack == NULL)
12931 return; /* type error; errmsg already given */
12932
12933 haystack_len = (int)STRLEN(haystack);
12934 if (argvars[2].v_type != VAR_UNKNOWN)
12935 {
12936 /* Third argument: upper limit for index */
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012937 end_idx = (int)tv_get_number_chk(&argvars[2], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012938 if (end_idx < 0)
12939 return; /* can never find a match */
12940 }
12941 else
12942 end_idx = haystack_len;
12943
12944 if (*needle == NUL)
12945 {
12946 /* Empty string matches past the end. */
12947 lastmatch = haystack + end_idx;
12948 }
12949 else
12950 {
12951 for (rest = haystack; *rest != '\0'; ++rest)
12952 {
12953 rest = (char_u *)strstr((char *)rest, (char *)needle);
12954 if (rest == NULL || rest > haystack + end_idx)
12955 break;
12956 lastmatch = rest;
12957 }
12958 }
12959
12960 if (lastmatch == NULL)
12961 rettv->vval.v_number = -1;
12962 else
12963 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
12964}
12965
12966/*
12967 * "strtrans()" function
12968 */
12969 static void
12970f_strtrans(typval_T *argvars, typval_T *rettv)
12971{
12972 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012973 rettv->vval.v_string = transstr(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012974}
12975
12976/*
12977 * "submatch()" function
12978 */
12979 static void
12980f_submatch(typval_T *argvars, typval_T *rettv)
12981{
12982 int error = FALSE;
12983 int no;
12984 int retList = 0;
12985
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012986 no = (int)tv_get_number_chk(&argvars[0], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012987 if (error)
12988 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020012989 if (no < 0 || no >= NSUBEXP)
12990 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010012991 semsg(_("E935: invalid submatch number: %d"), no);
Bram Moolenaar79518e22017-02-17 16:31:35 +010012992 return;
Bram Moolenaar989f5922016-08-21 15:26:54 +020012993 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012994 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010012995 retList = (int)tv_get_number_chk(&argvars[1], &error);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020012996 if (error)
12997 return;
12998
12999 if (retList == 0)
13000 {
13001 rettv->v_type = VAR_STRING;
13002 rettv->vval.v_string = reg_submatch(no);
13003 }
13004 else
13005 {
13006 rettv->v_type = VAR_LIST;
13007 rettv->vval.v_list = reg_submatch_list(no);
13008 }
13009}
13010
13011/*
13012 * "substitute()" function
13013 */
13014 static void
13015f_substitute(typval_T *argvars, typval_T *rettv)
13016{
13017 char_u patbuf[NUMBUFLEN];
13018 char_u subbuf[NUMBUFLEN];
13019 char_u flagsbuf[NUMBUFLEN];
13020
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013021 char_u *str = tv_get_string_chk(&argvars[0]);
13022 char_u *pat = tv_get_string_buf_chk(&argvars[1], patbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +020013023 char_u *sub = NULL;
13024 typval_T *expr = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013025 char_u *flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013026
Bram Moolenaar72ab7292016-07-19 19:10:51 +020013027 if (argvars[2].v_type == VAR_FUNC || argvars[2].v_type == VAR_PARTIAL)
13028 expr = &argvars[2];
13029 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013030 sub = tv_get_string_buf_chk(&argvars[2], subbuf);
Bram Moolenaar72ab7292016-07-19 19:10:51 +020013031
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013032 rettv->v_type = VAR_STRING;
Bram Moolenaar72ab7292016-07-19 19:10:51 +020013033 if (str == NULL || pat == NULL || (sub == NULL && expr == NULL)
13034 || flg == NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013035 rettv->vval.v_string = NULL;
13036 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +020013037 rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013038}
13039
13040/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +020013041 * "swapinfo(swap_filename)" function
13042 */
13043 static void
13044f_swapinfo(typval_T *argvars, typval_T *rettv)
13045{
13046 if (rettv_dict_alloc(rettv) == OK)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013047 get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
Bram Moolenaar00f123a2018-08-21 20:28:54 +020013048}
13049
13050/*
Bram Moolenaar110bd602018-09-16 18:46:59 +020013051 * "swapname(expr)" function
13052 */
13053 static void
13054f_swapname(typval_T *argvars, typval_T *rettv)
13055{
13056 buf_T *buf;
13057
13058 rettv->v_type = VAR_STRING;
Bram Moolenaarf2d79fa2019-01-03 22:19:27 +010013059 buf = tv_get_buf(&argvars[0], FALSE);
Bram Moolenaar110bd602018-09-16 18:46:59 +020013060 if (buf == NULL || buf->b_ml.ml_mfp == NULL
13061 || buf->b_ml.ml_mfp->mf_fname == NULL)
13062 rettv->vval.v_string = NULL;
13063 else
13064 rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname);
13065}
13066
13067/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013068 * "synID(lnum, col, trans)" function
13069 */
13070 static void
13071f_synID(typval_T *argvars UNUSED, typval_T *rettv)
13072{
13073 int id = 0;
13074#ifdef FEAT_SYN_HL
13075 linenr_T lnum;
13076 colnr_T col;
13077 int trans;
13078 int transerr = FALSE;
13079
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013080 lnum = tv_get_lnum(argvars); /* -1 on type error */
13081 col = (linenr_T)tv_get_number(&argvars[1]) - 1; /* -1 on type error */
13082 trans = (int)tv_get_number_chk(&argvars[2], &transerr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013083
13084 if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
13085 && col >= 0 && col < (long)STRLEN(ml_get(lnum)))
13086 id = syn_get_id(curwin, lnum, (colnr_T)col, trans, NULL, FALSE);
13087#endif
13088
13089 rettv->vval.v_number = id;
13090}
13091
13092/*
13093 * "synIDattr(id, what [, mode])" function
13094 */
13095 static void
13096f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv)
13097{
13098 char_u *p = NULL;
13099#ifdef FEAT_SYN_HL
13100 int id;
13101 char_u *what;
13102 char_u *mode;
13103 char_u modebuf[NUMBUFLEN];
13104 int modec;
13105
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013106 id = (int)tv_get_number(&argvars[0]);
13107 what = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013108 if (argvars[2].v_type != VAR_UNKNOWN)
13109 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013110 mode = tv_get_string_buf(&argvars[2], modebuf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013111 modec = TOLOWER_ASC(mode[0]);
13112 if (modec != 't' && modec != 'c' && modec != 'g')
13113 modec = 0; /* replace invalid with current */
13114 }
13115 else
13116 {
13117#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
13118 if (USE_24BIT)
13119 modec = 'g';
13120 else
13121#endif
13122 if (t_colors > 1)
13123 modec = 'c';
13124 else
13125 modec = 't';
13126 }
13127
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013128 switch (TOLOWER_ASC(what[0]))
13129 {
13130 case 'b':
13131 if (TOLOWER_ASC(what[1]) == 'g') /* bg[#] */
13132 p = highlight_color(id, what, modec);
13133 else /* bold */
13134 p = highlight_has_attr(id, HL_BOLD, modec);
13135 break;
13136
13137 case 'f': /* fg[#] or font */
13138 p = highlight_color(id, what, modec);
13139 break;
13140
13141 case 'i':
13142 if (TOLOWER_ASC(what[1]) == 'n') /* inverse */
13143 p = highlight_has_attr(id, HL_INVERSE, modec);
13144 else /* italic */
13145 p = highlight_has_attr(id, HL_ITALIC, modec);
13146 break;
13147
13148 case 'n': /* name */
Bram Moolenaarc96272e2017-03-26 13:50:09 +020013149 p = get_highlight_name_ext(NULL, id - 1, FALSE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013150 break;
13151
13152 case 'r': /* reverse */
13153 p = highlight_has_attr(id, HL_INVERSE, modec);
13154 break;
13155
13156 case 's':
13157 if (TOLOWER_ASC(what[1]) == 'p') /* sp[#] */
13158 p = highlight_color(id, what, modec);
Bram Moolenaarcf4b00c2017-09-02 18:33:56 +020013159 /* strikeout */
13160 else if (TOLOWER_ASC(what[1]) == 't' &&
13161 TOLOWER_ASC(what[2]) == 'r')
13162 p = highlight_has_attr(id, HL_STRIKETHROUGH, modec);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013163 else /* standout */
13164 p = highlight_has_attr(id, HL_STANDOUT, modec);
13165 break;
13166
13167 case 'u':
13168 if (STRLEN(what) <= 5 || TOLOWER_ASC(what[5]) != 'c')
13169 /* underline */
13170 p = highlight_has_attr(id, HL_UNDERLINE, modec);
13171 else
13172 /* undercurl */
13173 p = highlight_has_attr(id, HL_UNDERCURL, modec);
13174 break;
13175 }
13176
13177 if (p != NULL)
13178 p = vim_strsave(p);
13179#endif
13180 rettv->v_type = VAR_STRING;
13181 rettv->vval.v_string = p;
13182}
13183
13184/*
13185 * "synIDtrans(id)" function
13186 */
13187 static void
13188f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv)
13189{
13190 int id;
13191
13192#ifdef FEAT_SYN_HL
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013193 id = (int)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013194
13195 if (id > 0)
13196 id = syn_get_final_id(id);
13197 else
13198#endif
13199 id = 0;
13200
13201 rettv->vval.v_number = id;
13202}
13203
13204/*
13205 * "synconcealed(lnum, col)" function
13206 */
13207 static void
13208f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
13209{
13210#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
13211 linenr_T lnum;
13212 colnr_T col;
13213 int syntax_flags = 0;
13214 int cchar;
13215 int matchid = 0;
13216 char_u str[NUMBUFLEN];
13217#endif
13218
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020013219 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013220
13221#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013222 lnum = tv_get_lnum(argvars); /* -1 on type error */
13223 col = (colnr_T)tv_get_number(&argvars[1]) - 1; /* -1 on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013224
13225 vim_memset(str, NUL, sizeof(str));
13226
13227 if (rettv_list_alloc(rettv) != FAIL)
13228 {
13229 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
13230 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
13231 && curwin->w_p_cole > 0)
13232 {
13233 (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE);
13234 syntax_flags = get_syntax_info(&matchid);
13235
13236 /* get the conceal character */
13237 if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3)
13238 {
13239 cchar = syn_get_sub_char();
Bram Moolenaar4d785892017-06-22 22:00:50 +020013240 if (cchar == NUL && curwin->w_p_cole == 1)
13241 cchar = (lcs_conceal == NUL) ? ' ' : lcs_conceal;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013242 if (cchar != NUL)
13243 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013244 if (has_mbyte)
13245 (*mb_char2bytes)(cchar, str);
13246 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013247 str[0] = cchar;
13248 }
13249 }
13250 }
13251
13252 list_append_number(rettv->vval.v_list,
13253 (syntax_flags & HL_CONCEAL) != 0);
13254 /* -1 to auto-determine strlen */
13255 list_append_string(rettv->vval.v_list, str, -1);
13256 list_append_number(rettv->vval.v_list, matchid);
13257 }
13258#endif
13259}
13260
13261/*
13262 * "synstack(lnum, col)" function
13263 */
13264 static void
13265f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
13266{
13267#ifdef FEAT_SYN_HL
13268 linenr_T lnum;
13269 colnr_T col;
13270 int i;
13271 int id;
13272#endif
13273
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020013274 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013275
13276#ifdef FEAT_SYN_HL
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013277 lnum = tv_get_lnum(argvars); /* -1 on type error */
13278 col = (colnr_T)tv_get_number(&argvars[1]) - 1; /* -1 on type error */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013279
13280 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count
13281 && col >= 0 && col <= (long)STRLEN(ml_get(lnum))
13282 && rettv_list_alloc(rettv) != FAIL)
13283 {
13284 (void)syn_get_id(curwin, lnum, (colnr_T)col, FALSE, NULL, TRUE);
13285 for (i = 0; ; ++i)
13286 {
13287 id = syn_get_stack_item(i);
13288 if (id < 0)
13289 break;
13290 if (list_append_number(rettv->vval.v_list, id) == FAIL)
13291 break;
13292 }
13293 }
13294#endif
13295}
13296
13297 static void
13298get_cmd_output_as_rettv(
13299 typval_T *argvars,
13300 typval_T *rettv,
13301 int retlist)
13302{
13303 char_u *res = NULL;
13304 char_u *p;
13305 char_u *infile = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013306 int err = FALSE;
13307 FILE *fd;
13308 list_T *list = NULL;
13309 int flags = SHELL_SILENT;
13310
13311 rettv->v_type = VAR_STRING;
13312 rettv->vval.v_string = NULL;
13313 if (check_restricted() || check_secure())
13314 goto errret;
13315
13316 if (argvars[1].v_type != VAR_UNKNOWN)
13317 {
13318 /*
Bram Moolenaar12c44922017-01-08 13:26:03 +010013319 * Write the text to a temp file, to be used for input of the shell
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013320 * command.
13321 */
13322 if ((infile = vim_tempname('i', TRUE)) == NULL)
13323 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013324 emsg(_(e_notmp));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013325 goto errret;
13326 }
13327
13328 fd = mch_fopen((char *)infile, WRITEBIN);
13329 if (fd == NULL)
13330 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013331 semsg(_(e_notopen), infile);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013332 goto errret;
13333 }
Bram Moolenaar12c44922017-01-08 13:26:03 +010013334 if (argvars[1].v_type == VAR_NUMBER)
13335 {
13336 linenr_T lnum;
13337 buf_T *buf;
13338
13339 buf = buflist_findnr(argvars[1].vval.v_number);
13340 if (buf == NULL)
13341 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013342 semsg(_(e_nobufnr), argvars[1].vval.v_number);
Bram Moolenaar23c9e8b2017-01-20 19:59:54 +010013343 fclose(fd);
Bram Moolenaar12c44922017-01-08 13:26:03 +010013344 goto errret;
13345 }
13346
13347 for (lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++)
13348 {
13349 for (p = ml_get_buf(buf, lnum, FALSE); *p != NUL; ++p)
13350 if (putc(*p == '\n' ? NUL : *p, fd) == EOF)
13351 {
13352 err = TRUE;
13353 break;
13354 }
13355 if (putc(NL, fd) == EOF)
13356 {
13357 err = TRUE;
13358 break;
13359 }
13360 }
13361 }
13362 else if (argvars[1].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013363 {
13364 if (write_list(fd, argvars[1].vval.v_list, TRUE) == FAIL)
13365 err = TRUE;
13366 }
13367 else
13368 {
Bram Moolenaar12c44922017-01-08 13:26:03 +010013369 size_t len;
13370 char_u buf[NUMBUFLEN];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013371
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013372 p = tv_get_string_buf_chk(&argvars[1], buf);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013373 if (p == NULL)
13374 {
13375 fclose(fd);
13376 goto errret; /* type error; errmsg already given */
13377 }
13378 len = STRLEN(p);
13379 if (len > 0 && fwrite(p, len, 1, fd) != 1)
13380 err = TRUE;
13381 }
13382 if (fclose(fd) != 0)
13383 err = TRUE;
13384 if (err)
13385 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013386 emsg(_("E677: Error writing temp file"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013387 goto errret;
13388 }
13389 }
13390
13391 /* Omit SHELL_COOKED when invoked with ":silent". Avoids that the shell
13392 * echoes typeahead, that messes up the display. */
13393 if (!msg_silent)
13394 flags += SHELL_COOKED;
13395
13396 if (retlist)
13397 {
13398 int len;
13399 listitem_T *li;
13400 char_u *s = NULL;
13401 char_u *start;
13402 char_u *end;
13403 int i;
13404
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013405 res = get_cmd_output(tv_get_string(&argvars[0]), infile, flags, &len);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013406 if (res == NULL)
13407 goto errret;
13408
13409 list = list_alloc();
13410 if (list == NULL)
13411 goto errret;
13412
13413 for (i = 0; i < len; ++i)
13414 {
13415 start = res + i;
13416 while (i < len && res[i] != NL)
13417 ++i;
13418 end = res + i;
13419
13420 s = alloc((unsigned)(end - start + 1));
13421 if (s == NULL)
13422 goto errret;
13423
13424 for (p = s; start < end; ++p, ++start)
13425 *p = *start == NUL ? NL : *start;
13426 *p = NUL;
13427
13428 li = listitem_alloc();
13429 if (li == NULL)
13430 {
13431 vim_free(s);
13432 goto errret;
13433 }
13434 li->li_tv.v_type = VAR_STRING;
13435 li->li_tv.v_lock = 0;
13436 li->li_tv.vval.v_string = s;
13437 list_append(list, li);
13438 }
13439
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020013440 rettv_list_set(rettv, list);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013441 list = NULL;
13442 }
13443 else
13444 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013445 res = get_cmd_output(tv_get_string(&argvars[0]), infile, flags, NULL);
Bram Moolenaar00590742019-02-15 21:06:09 +010013446#ifdef USE_CRNL
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013447 /* translate <CR><NL> into <NL> */
13448 if (res != NULL)
13449 {
13450 char_u *s, *d;
13451
13452 d = res;
13453 for (s = res; *s; ++s)
13454 {
13455 if (s[0] == CAR && s[1] == NL)
13456 ++s;
13457 *d++ = *s;
13458 }
13459 *d = NUL;
13460 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013461#endif
13462 rettv->vval.v_string = res;
13463 res = NULL;
13464 }
13465
13466errret:
13467 if (infile != NULL)
13468 {
13469 mch_remove(infile);
13470 vim_free(infile);
13471 }
13472 if (res != NULL)
13473 vim_free(res);
13474 if (list != NULL)
13475 list_free(list);
13476}
13477
13478/*
13479 * "system()" function
13480 */
13481 static void
13482f_system(typval_T *argvars, typval_T *rettv)
13483{
13484 get_cmd_output_as_rettv(argvars, rettv, FALSE);
13485}
13486
13487/*
13488 * "systemlist()" function
13489 */
13490 static void
13491f_systemlist(typval_T *argvars, typval_T *rettv)
13492{
13493 get_cmd_output_as_rettv(argvars, rettv, TRUE);
13494}
13495
13496/*
13497 * "tabpagebuflist()" function
13498 */
13499 static void
13500f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
13501{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013502 tabpage_T *tp;
13503 win_T *wp = NULL;
13504
13505 if (argvars[0].v_type == VAR_UNKNOWN)
13506 wp = firstwin;
13507 else
13508 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013509 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013510 if (tp != NULL)
13511 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
13512 }
13513 if (wp != NULL && rettv_list_alloc(rettv) != FAIL)
13514 {
13515 for (; wp != NULL; wp = wp->w_next)
13516 if (list_append_number(rettv->vval.v_list,
13517 wp->w_buffer->b_fnum) == FAIL)
13518 break;
13519 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013520}
13521
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013522/*
13523 * "tabpagenr()" function
13524 */
13525 static void
13526f_tabpagenr(typval_T *argvars UNUSED, typval_T *rettv)
13527{
13528 int nr = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013529 char_u *arg;
13530
13531 if (argvars[0].v_type != VAR_UNKNOWN)
13532 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013533 arg = tv_get_string_chk(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013534 nr = 0;
13535 if (arg != NULL)
13536 {
13537 if (STRCMP(arg, "$") == 0)
13538 nr = tabpage_index(NULL) - 1;
13539 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013540 semsg(_(e_invexpr2), arg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013541 }
13542 }
13543 else
13544 nr = tabpage_index(curtab);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013545 rettv->vval.v_number = nr;
13546}
13547
13548
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013549/*
13550 * Common code for tabpagewinnr() and winnr().
13551 */
13552 static int
13553get_winnr(tabpage_T *tp, typval_T *argvar)
13554{
13555 win_T *twin;
13556 int nr = 1;
13557 win_T *wp;
13558 char_u *arg;
13559
13560 twin = (tp == curtab) ? curwin : tp->tp_curwin;
13561 if (argvar->v_type != VAR_UNKNOWN)
13562 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013563 arg = tv_get_string_chk(argvar);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013564 if (arg == NULL)
13565 nr = 0; /* type error; errmsg already given */
13566 else if (STRCMP(arg, "$") == 0)
13567 twin = (tp == curtab) ? lastwin : tp->tp_lastwin;
13568 else if (STRCMP(arg, "#") == 0)
13569 {
13570 twin = (tp == curtab) ? prevwin : tp->tp_prevwin;
13571 if (twin == NULL)
13572 nr = 0;
13573 }
13574 else
13575 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013576 semsg(_(e_invexpr2), arg);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013577 nr = 0;
13578 }
13579 }
13580
13581 if (nr > 0)
13582 for (wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
13583 wp != twin; wp = wp->w_next)
13584 {
13585 if (wp == NULL)
13586 {
13587 /* didn't find it in this tabpage */
13588 nr = 0;
13589 break;
13590 }
13591 ++nr;
13592 }
13593 return nr;
13594}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013595
13596/*
13597 * "tabpagewinnr()" function
13598 */
13599 static void
13600f_tabpagewinnr(typval_T *argvars UNUSED, typval_T *rettv)
13601{
13602 int nr = 1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013603 tabpage_T *tp;
13604
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013605 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013606 if (tp == NULL)
13607 nr = 0;
13608 else
13609 nr = get_winnr(tp, &argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013610 rettv->vval.v_number = nr;
13611}
13612
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013613/*
13614 * "tagfiles()" function
13615 */
13616 static void
13617f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv)
13618{
13619 char_u *fname;
13620 tagname_T tn;
13621 int first;
13622
13623 if (rettv_list_alloc(rettv) == FAIL)
13624 return;
13625 fname = alloc(MAXPATHL);
13626 if (fname == NULL)
13627 return;
13628
13629 for (first = TRUE; ; first = FALSE)
13630 if (get_tagfname(&tn, first, fname) == FAIL
13631 || list_append_string(rettv->vval.v_list, fname, -1) == FAIL)
13632 break;
13633 tagname_free(&tn);
13634 vim_free(fname);
13635}
13636
13637/*
13638 * "taglist()" function
13639 */
13640 static void
13641f_taglist(typval_T *argvars, typval_T *rettv)
13642{
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010013643 char_u *fname = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013644 char_u *tag_pattern;
13645
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013646 tag_pattern = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013647
13648 rettv->vval.v_number = FALSE;
13649 if (*tag_pattern == NUL)
13650 return;
13651
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010013652 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013653 fname = tv_get_string(&argvars[1]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013654 if (rettv_list_alloc(rettv) == OK)
Bram Moolenaarc6aafba2017-03-21 17:09:10 +010013655 (void)get_tags(rettv->vval.v_list, tag_pattern, fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013656}
13657
13658/*
13659 * "tempname()" function
13660 */
13661 static void
13662f_tempname(typval_T *argvars UNUSED, typval_T *rettv)
13663{
13664 static int x = 'A';
13665
13666 rettv->v_type = VAR_STRING;
13667 rettv->vval.v_string = vim_tempname(x, FALSE);
13668
13669 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
13670 * names. Skip 'I' and 'O', they are used for shell redirection. */
13671 do
13672 {
13673 if (x == 'Z')
13674 x = '0';
13675 else if (x == '9')
13676 x = 'A';
13677 else
13678 {
13679#ifdef EBCDIC
13680 if (x == 'I')
13681 x = 'J';
13682 else if (x == 'R')
13683 x = 'S';
13684 else
13685#endif
13686 ++x;
13687 }
13688 } while (x == 'I' || x == 'O');
13689}
13690
13691#ifdef FEAT_FLOAT
13692/*
13693 * "tan()" function
13694 */
13695 static void
13696f_tan(typval_T *argvars, typval_T *rettv)
13697{
13698 float_T f = 0.0;
13699
13700 rettv->v_type = VAR_FLOAT;
13701 if (get_float_arg(argvars, &f) == OK)
13702 rettv->vval.v_float = tan(f);
13703 else
13704 rettv->vval.v_float = 0.0;
13705}
13706
13707/*
13708 * "tanh()" function
13709 */
13710 static void
13711f_tanh(typval_T *argvars, typval_T *rettv)
13712{
13713 float_T f = 0.0;
13714
13715 rettv->v_type = VAR_FLOAT;
13716 if (get_float_arg(argvars, &f) == OK)
13717 rettv->vval.v_float = tanh(f);
13718 else
13719 rettv->vval.v_float = 0.0;
13720}
13721#endif
13722
13723/*
13724 * "test_alloc_fail(id, countdown, repeat)" function
13725 */
13726 static void
13727f_test_alloc_fail(typval_T *argvars, typval_T *rettv UNUSED)
13728{
13729 if (argvars[0].v_type != VAR_NUMBER
13730 || argvars[0].vval.v_number <= 0
13731 || argvars[1].v_type != VAR_NUMBER
13732 || argvars[1].vval.v_number < 0
13733 || argvars[2].v_type != VAR_NUMBER)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013734 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013735 else
13736 {
13737 alloc_fail_id = argvars[0].vval.v_number;
13738 if (alloc_fail_id >= aid_last)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013739 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013740 alloc_fail_countdown = argvars[1].vval.v_number;
13741 alloc_fail_repeat = argvars[2].vval.v_number;
13742 did_outofmem_msg = FALSE;
13743 }
13744}
13745
13746/*
13747 * "test_autochdir()"
13748 */
13749 static void
13750f_test_autochdir(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
13751{
13752#if defined(FEAT_AUTOCHDIR)
13753 test_autochdir = TRUE;
13754#endif
13755}
13756
13757/*
Bram Moolenaar5e80de32017-09-03 15:48:12 +020013758 * "test_feedinput()"
13759 */
13760 static void
13761f_test_feedinput(typval_T *argvars, typval_T *rettv UNUSED)
13762{
13763#ifdef USE_INPUT_BUF
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013764 char_u *val = tv_get_string_chk(&argvars[0]);
Bram Moolenaar5e80de32017-09-03 15:48:12 +020013765
13766 if (val != NULL)
13767 {
13768 trash_input_buf();
13769 add_to_input_buf_csi(val, (int)STRLEN(val));
13770 }
13771#endif
13772}
13773
13774/*
Bram Moolenaarfe8ef982018-09-13 20:31:54 +020013775 * "test_option_not_set({name})" function
13776 */
13777 static void
13778f_test_option_not_set(typval_T *argvars, typval_T *rettv UNUSED)
13779{
13780 char_u *name = (char_u *)"";
13781
13782 if (argvars[0].v_type != VAR_STRING)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013783 emsg(_(e_invarg));
Bram Moolenaarfe8ef982018-09-13 20:31:54 +020013784 else
13785 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013786 name = tv_get_string(&argvars[0]);
Bram Moolenaarfe8ef982018-09-13 20:31:54 +020013787 if (reset_option_was_set(name) == FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013788 semsg(_(e_invarg2), name);
Bram Moolenaarfe8ef982018-09-13 20:31:54 +020013789 }
13790}
13791
13792/*
13793 * "test_override({name}, {val})" function
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013794 */
13795 static void
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013796f_test_override(typval_T *argvars, typval_T *rettv UNUSED)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013797{
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013798 char_u *name = (char_u *)"";
13799 int val;
Bram Moolenaar182a17b2017-06-25 20:57:18 +020013800 static int save_starting = -1;
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013801
13802 if (argvars[0].v_type != VAR_STRING
13803 || (argvars[1].v_type) != VAR_NUMBER)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013804 emsg(_(e_invarg));
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013805 else
13806 {
Bram Moolenaare38197d2018-12-24 23:35:13 +010013807 name = tv_get_string(&argvars[0]);
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013808 val = (int)tv_get_number(&argvars[1]);
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013809
13810 if (STRCMP(name, (char_u *)"redraw") == 0)
13811 disable_redraw_for_testing = val;
Bram Moolenaared5a9d62018-09-06 13:14:43 +020013812 else if (STRCMP(name, (char_u *)"redraw_flag") == 0)
13813 ignore_redraw_flag_for_testing = val;
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013814 else if (STRCMP(name, (char_u *)"char_avail") == 0)
13815 disable_char_avail_for_testing = val;
Bram Moolenaar182a17b2017-06-25 20:57:18 +020013816 else if (STRCMP(name, (char_u *)"starting") == 0)
13817 {
13818 if (val)
13819 {
13820 if (save_starting < 0)
13821 save_starting = starting;
13822 starting = 0;
13823 }
13824 else
13825 {
13826 starting = save_starting;
13827 save_starting = -1;
13828 }
13829 }
Bram Moolenaarbcf94422018-06-23 14:21:42 +020013830 else if (STRCMP(name, (char_u *)"nfa_fail") == 0)
13831 nfa_fail_for_testing = val;
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013832 else if (STRCMP(name, (char_u *)"ALL") == 0)
13833 {
13834 disable_char_avail_for_testing = FALSE;
13835 disable_redraw_for_testing = FALSE;
Bram Moolenaared5a9d62018-09-06 13:14:43 +020013836 ignore_redraw_flag_for_testing = FALSE;
Bram Moolenaarbcf94422018-06-23 14:21:42 +020013837 nfa_fail_for_testing = FALSE;
Bram Moolenaar182a17b2017-06-25 20:57:18 +020013838 if (save_starting >= 0)
13839 {
13840 starting = save_starting;
13841 save_starting = -1;
13842 }
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013843 }
13844 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013845 semsg(_(e_invarg2), name);
Bram Moolenaareb992cb2017-03-09 18:20:16 +010013846 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013847}
13848
13849/*
13850 * "test_garbagecollect_now()" function
13851 */
13852 static void
13853f_test_garbagecollect_now(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
13854{
13855 /* This is dangerous, any Lists and Dicts used internally may be freed
13856 * while still in use. */
13857 garbage_collect(TRUE);
13858}
13859
Bram Moolenaare0c31f62017-03-01 15:07:05 +010013860/*
13861 * "test_ignore_error()" function
13862 */
13863 static void
13864f_test_ignore_error(typval_T *argvars, typval_T *rettv UNUSED)
13865{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013866 ignore_error_for_testing(tv_get_string(&argvars[0]));
Bram Moolenaare0c31f62017-03-01 15:07:05 +010013867}
13868
Bram Moolenaarc0f5a782019-01-13 15:16:13 +010013869 static void
13870f_test_null_blob(typval_T *argvars UNUSED, typval_T *rettv)
13871{
13872 rettv->v_type = VAR_BLOB;
13873 rettv->vval.v_blob = NULL;
13874}
13875
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013876#ifdef FEAT_JOB_CHANNEL
13877 static void
13878f_test_null_channel(typval_T *argvars UNUSED, typval_T *rettv)
13879{
13880 rettv->v_type = VAR_CHANNEL;
13881 rettv->vval.v_channel = NULL;
13882}
13883#endif
13884
13885 static void
13886f_test_null_dict(typval_T *argvars UNUSED, typval_T *rettv)
13887{
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020013888 rettv_dict_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013889}
13890
13891#ifdef FEAT_JOB_CHANNEL
13892 static void
13893f_test_null_job(typval_T *argvars UNUSED, typval_T *rettv)
13894{
13895 rettv->v_type = VAR_JOB;
13896 rettv->vval.v_job = NULL;
13897}
13898#endif
13899
13900 static void
13901f_test_null_list(typval_T *argvars UNUSED, typval_T *rettv)
13902{
Bram Moolenaar45cf6e92017-04-30 20:25:19 +020013903 rettv_list_set(rettv, NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013904}
13905
13906 static void
13907f_test_null_partial(typval_T *argvars UNUSED, typval_T *rettv)
13908{
13909 rettv->v_type = VAR_PARTIAL;
13910 rettv->vval.v_partial = NULL;
13911}
13912
13913 static void
13914f_test_null_string(typval_T *argvars UNUSED, typval_T *rettv)
13915{
13916 rettv->v_type = VAR_STRING;
13917 rettv->vval.v_string = NULL;
13918}
13919
Bram Moolenaarab186732018-09-14 21:27:06 +020013920#ifdef FEAT_GUI
13921 static void
13922f_test_scrollbar(typval_T *argvars, typval_T *rettv UNUSED)
13923{
13924 char_u *which;
13925 long value;
13926 int dragging;
13927 scrollbar_T *sb = NULL;
13928
13929 if (argvars[0].v_type != VAR_STRING
13930 || (argvars[1].v_type) != VAR_NUMBER
13931 || (argvars[2].v_type) != VAR_NUMBER)
13932 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013933 emsg(_(e_invarg));
Bram Moolenaarab186732018-09-14 21:27:06 +020013934 return;
13935 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013936 which = tv_get_string(&argvars[0]);
13937 value = tv_get_number(&argvars[1]);
13938 dragging = tv_get_number(&argvars[2]);
Bram Moolenaarab186732018-09-14 21:27:06 +020013939
13940 if (STRCMP(which, "left") == 0)
13941 sb = &curwin->w_scrollbars[SBAR_LEFT];
13942 else if (STRCMP(which, "right") == 0)
13943 sb = &curwin->w_scrollbars[SBAR_RIGHT];
13944 else if (STRCMP(which, "hor") == 0)
13945 sb = &gui.bottom_sbar;
13946 if (sb == NULL)
13947 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013948 semsg(_(e_invarg2), which);
Bram Moolenaarab186732018-09-14 21:27:06 +020013949 return;
13950 }
13951 gui_drag_scrollbar(sb, value, dragging);
Bram Moolenaar586c70c2018-10-02 16:23:58 +020013952# ifndef USE_ON_FLY_SCROLL
13953 // need to loop through normal_cmd() to handle the scroll events
13954 exec_normal(FALSE, TRUE, FALSE);
13955# endif
Bram Moolenaarab186732018-09-14 21:27:06 +020013956}
13957#endif
13958
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013959 static void
13960f_test_settime(typval_T *argvars, typval_T *rettv UNUSED)
13961{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010013962 time_for_testing = (time_t)tv_get_number(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013963}
13964
13965#if defined(FEAT_JOB_CHANNEL) || defined(FEAT_TIMERS) || defined(PROTO)
13966/*
13967 * Get a callback from "arg". It can be a Funcref or a function name.
13968 * When "arg" is zero return an empty string.
13969 * Return NULL for an invalid argument.
13970 */
13971 char_u *
13972get_callback(typval_T *arg, partial_T **pp)
13973{
13974 if (arg->v_type == VAR_PARTIAL && arg->vval.v_partial != NULL)
13975 {
13976 *pp = arg->vval.v_partial;
13977 ++(*pp)->pt_refcount;
Bram Moolenaar437bafe2016-08-01 15:40:54 +020013978 return partial_name(*pp);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013979 }
13980 *pp = NULL;
Bram Moolenaar437bafe2016-08-01 15:40:54 +020013981 if (arg->v_type == VAR_FUNC || arg->v_type == VAR_STRING)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013982 {
13983 func_ref(arg->vval.v_string);
13984 return arg->vval.v_string;
13985 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013986 if (arg->v_type == VAR_NUMBER && arg->vval.v_number == 0)
13987 return (char_u *)"";
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010013988 emsg(_("E921: Invalid callback argument"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013989 return NULL;
13990}
13991
13992/*
Bram Moolenaard5359b22018-04-05 22:44:39 +020013993 * Unref/free "callback" and "partial" returned by get_callback().
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020013994 */
13995 void
13996free_callback(char_u *callback, partial_T *partial)
13997{
13998 if (partial != NULL)
13999 partial_unref(partial);
14000 else if (callback != NULL)
14001 {
14002 func_unref(callback);
14003 vim_free(callback);
14004 }
14005}
14006#endif
14007
14008#ifdef FEAT_TIMERS
14009/*
Bram Moolenaar8e97bd72016-08-06 22:05:07 +020014010 * "timer_info([timer])" function
14011 */
14012 static void
14013f_timer_info(typval_T *argvars, typval_T *rettv)
14014{
14015 timer_T *timer = NULL;
14016
14017 if (rettv_list_alloc(rettv) != OK)
14018 return;
14019 if (argvars[0].v_type != VAR_UNKNOWN)
14020 {
14021 if (argvars[0].v_type != VAR_NUMBER)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014022 emsg(_(e_number_exp));
Bram Moolenaar8e97bd72016-08-06 22:05:07 +020014023 else
14024 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014025 timer = find_timer((int)tv_get_number(&argvars[0]));
Bram Moolenaar8e97bd72016-08-06 22:05:07 +020014026 if (timer != NULL)
14027 add_timer_info(rettv, timer);
14028 }
14029 }
14030 else
14031 add_timer_info_all(rettv);
14032}
14033
14034/*
Bram Moolenaarb73598e2016-08-07 18:22:53 +020014035 * "timer_pause(timer, paused)" function
14036 */
14037 static void
14038f_timer_pause(typval_T *argvars, typval_T *rettv UNUSED)
14039{
14040 timer_T *timer = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014041 int paused = (int)tv_get_number(&argvars[1]);
Bram Moolenaarb73598e2016-08-07 18:22:53 +020014042
14043 if (argvars[0].v_type != VAR_NUMBER)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014044 emsg(_(e_number_exp));
Bram Moolenaarb73598e2016-08-07 18:22:53 +020014045 else
14046 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014047 timer = find_timer((int)tv_get_number(&argvars[0]));
Bram Moolenaarb73598e2016-08-07 18:22:53 +020014048 if (timer != NULL)
14049 timer->tr_paused = paused;
14050 }
14051}
14052
14053/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014054 * "timer_start(time, callback [, options])" function
14055 */
14056 static void
14057f_timer_start(typval_T *argvars, typval_T *rettv)
14058{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014059 long msec = (long)tv_get_number(&argvars[0]);
Bram Moolenaar75537a92016-09-05 22:45:28 +020014060 timer_T *timer;
14061 int repeat = 0;
14062 char_u *callback;
14063 dict_T *dict;
14064 partial_T *partial;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014065
Bram Moolenaar75537a92016-09-05 22:45:28 +020014066 rettv->vval.v_number = -1;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014067 if (check_secure())
14068 return;
14069 if (argvars[2].v_type != VAR_UNKNOWN)
14070 {
14071 if (argvars[2].v_type != VAR_DICT
14072 || (dict = argvars[2].vval.v_dict) == NULL)
14073 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014074 semsg(_(e_invarg2), tv_get_string(&argvars[2]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014075 return;
14076 }
14077 if (dict_find(dict, (char_u *)"repeat", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014078 repeat = dict_get_number(dict, (char_u *)"repeat");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014079 }
14080
Bram Moolenaar75537a92016-09-05 22:45:28 +020014081 callback = get_callback(&argvars[1], &partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014082 if (callback == NULL)
Bram Moolenaar75537a92016-09-05 22:45:28 +020014083 return;
14084
14085 timer = create_timer(msec, repeat);
14086 if (timer == NULL)
14087 free_callback(callback, partial);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014088 else
14089 {
Bram Moolenaar26fe0d52016-09-10 14:27:30 +020014090 if (partial == NULL)
Bram Moolenaar3ab14352016-07-30 22:32:11 +020014091 timer->tr_callback = vim_strsave(callback);
14092 else
14093 /* pointer into the partial */
14094 timer->tr_callback = callback;
Bram Moolenaar75537a92016-09-05 22:45:28 +020014095 timer->tr_partial = partial;
14096 rettv->vval.v_number = (varnumber_T)timer->tr_id;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014097 }
14098}
14099
14100/*
14101 * "timer_stop(timer)" function
14102 */
14103 static void
14104f_timer_stop(typval_T *argvars, typval_T *rettv UNUSED)
14105{
14106 timer_T *timer;
14107
14108 if (argvars[0].v_type != VAR_NUMBER)
14109 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014110 emsg(_(e_number_exp));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014111 return;
14112 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014113 timer = find_timer((int)tv_get_number(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014114 if (timer != NULL)
14115 stop_timer(timer);
14116}
Bram Moolenaarb73598e2016-08-07 18:22:53 +020014117
14118/*
14119 * "timer_stopall()" function
14120 */
14121 static void
14122f_timer_stopall(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
14123{
14124 stop_all_timers();
14125}
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014126#endif
14127
14128/*
14129 * "tolower(string)" function
14130 */
14131 static void
14132f_tolower(typval_T *argvars, typval_T *rettv)
14133{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014134 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014135 rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014136}
14137
14138/*
14139 * "toupper(string)" function
14140 */
14141 static void
14142f_toupper(typval_T *argvars, typval_T *rettv)
14143{
14144 rettv->v_type = VAR_STRING;
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014145 rettv->vval.v_string = strup_save(tv_get_string(&argvars[0]));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014146}
14147
14148/*
14149 * "tr(string, fromstr, tostr)" function
14150 */
14151 static void
14152f_tr(typval_T *argvars, typval_T *rettv)
14153{
14154 char_u *in_str;
14155 char_u *fromstr;
14156 char_u *tostr;
14157 char_u *p;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014158 int inlen;
14159 int fromlen;
14160 int tolen;
14161 int idx;
14162 char_u *cpstr;
14163 int cplen;
14164 int first = TRUE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014165 char_u buf[NUMBUFLEN];
14166 char_u buf2[NUMBUFLEN];
14167 garray_T ga;
14168
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014169 in_str = tv_get_string(&argvars[0]);
14170 fromstr = tv_get_string_buf_chk(&argvars[1], buf);
14171 tostr = tv_get_string_buf_chk(&argvars[2], buf2);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014172
14173 /* Default return value: empty string. */
14174 rettv->v_type = VAR_STRING;
14175 rettv->vval.v_string = NULL;
14176 if (fromstr == NULL || tostr == NULL)
14177 return; /* type error; errmsg already given */
14178 ga_init2(&ga, (int)sizeof(char), 80);
14179
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014180 if (!has_mbyte)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014181 /* not multi-byte: fromstr and tostr must be the same length */
14182 if (STRLEN(fromstr) != STRLEN(tostr))
14183 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014184error:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014185 semsg(_(e_invarg2), fromstr);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014186 ga_clear(&ga);
14187 return;
14188 }
14189
14190 /* fromstr and tostr have to contain the same number of chars */
14191 while (*in_str != NUL)
14192 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014193 if (has_mbyte)
14194 {
14195 inlen = (*mb_ptr2len)(in_str);
14196 cpstr = in_str;
14197 cplen = inlen;
14198 idx = 0;
14199 for (p = fromstr; *p != NUL; p += fromlen)
14200 {
14201 fromlen = (*mb_ptr2len)(p);
14202 if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0)
14203 {
14204 for (p = tostr; *p != NUL; p += tolen)
14205 {
14206 tolen = (*mb_ptr2len)(p);
14207 if (idx-- == 0)
14208 {
14209 cplen = tolen;
14210 cpstr = p;
14211 break;
14212 }
14213 }
14214 if (*p == NUL) /* tostr is shorter than fromstr */
14215 goto error;
14216 break;
14217 }
14218 ++idx;
14219 }
14220
14221 if (first && cpstr == in_str)
14222 {
14223 /* Check that fromstr and tostr have the same number of
14224 * (multi-byte) characters. Done only once when a character
14225 * of in_str doesn't appear in fromstr. */
14226 first = FALSE;
14227 for (p = tostr; *p != NUL; p += tolen)
14228 {
14229 tolen = (*mb_ptr2len)(p);
14230 --idx;
14231 }
14232 if (idx != 0)
14233 goto error;
14234 }
14235
14236 (void)ga_grow(&ga, cplen);
14237 mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen);
14238 ga.ga_len += cplen;
14239
14240 in_str += inlen;
14241 }
14242 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014243 {
14244 /* When not using multi-byte chars we can do it faster. */
14245 p = vim_strchr(fromstr, *in_str);
14246 if (p != NULL)
14247 ga_append(&ga, tostr[p - fromstr]);
14248 else
14249 ga_append(&ga, *in_str);
14250 ++in_str;
14251 }
14252 }
14253
14254 /* add a terminating NUL */
14255 (void)ga_grow(&ga, 1);
14256 ga_append(&ga, NUL);
14257
14258 rettv->vval.v_string = ga.ga_data;
14259}
14260
Bram Moolenaar295ac5a2018-03-22 23:04:02 +010014261/*
14262 * "trim({expr})" function
14263 */
14264 static void
14265f_trim(typval_T *argvars, typval_T *rettv)
14266{
14267 char_u buf1[NUMBUFLEN];
14268 char_u buf2[NUMBUFLEN];
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014269 char_u *head = tv_get_string_buf_chk(&argvars[0], buf1);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +010014270 char_u *mask = NULL;
14271 char_u *tail;
14272 char_u *prev;
14273 char_u *p;
14274 int c1;
14275
14276 rettv->v_type = VAR_STRING;
14277 if (head == NULL)
14278 {
14279 rettv->vval.v_string = NULL;
14280 return;
14281 }
14282
14283 if (argvars[1].v_type == VAR_STRING)
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014284 mask = tv_get_string_buf_chk(&argvars[1], buf2);
Bram Moolenaar295ac5a2018-03-22 23:04:02 +010014285
14286 while (*head != NUL)
14287 {
14288 c1 = PTR2CHAR(head);
14289 if (mask == NULL)
14290 {
14291 if (c1 > ' ' && c1 != 0xa0)
14292 break;
14293 }
14294 else
14295 {
14296 for (p = mask; *p != NUL; MB_PTR_ADV(p))
14297 if (c1 == PTR2CHAR(p))
14298 break;
14299 if (*p == NUL)
14300 break;
14301 }
14302 MB_PTR_ADV(head);
14303 }
14304
14305 for (tail = head + STRLEN(head); tail > head; tail = prev)
14306 {
14307 prev = tail;
14308 MB_PTR_BACK(head, prev);
14309 c1 = PTR2CHAR(prev);
14310 if (mask == NULL)
14311 {
14312 if (c1 > ' ' && c1 != 0xa0)
14313 break;
14314 }
14315 else
14316 {
14317 for (p = mask; *p != NUL; MB_PTR_ADV(p))
14318 if (c1 == PTR2CHAR(p))
14319 break;
14320 if (*p == NUL)
14321 break;
14322 }
14323 }
14324 rettv->vval.v_string = vim_strnsave(head, (int)(tail - head));
14325}
14326
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014327#ifdef FEAT_FLOAT
14328/*
14329 * "trunc({float})" function
14330 */
14331 static void
14332f_trunc(typval_T *argvars, typval_T *rettv)
14333{
14334 float_T f = 0.0;
14335
14336 rettv->v_type = VAR_FLOAT;
14337 if (get_float_arg(argvars, &f) == OK)
14338 /* trunc() is not in C90, use floor() or ceil() instead. */
14339 rettv->vval.v_float = f > 0 ? floor(f) : ceil(f);
14340 else
14341 rettv->vval.v_float = 0.0;
14342}
14343#endif
14344
14345/*
14346 * "type(expr)" function
14347 */
14348 static void
14349f_type(typval_T *argvars, typval_T *rettv)
14350{
14351 int n = -1;
14352
14353 switch (argvars[0].v_type)
14354 {
Bram Moolenaarf562e722016-07-19 17:25:25 +020014355 case VAR_NUMBER: n = VAR_TYPE_NUMBER; break;
14356 case VAR_STRING: n = VAR_TYPE_STRING; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014357 case VAR_PARTIAL:
Bram Moolenaarf562e722016-07-19 17:25:25 +020014358 case VAR_FUNC: n = VAR_TYPE_FUNC; break;
14359 case VAR_LIST: n = VAR_TYPE_LIST; break;
14360 case VAR_DICT: n = VAR_TYPE_DICT; break;
14361 case VAR_FLOAT: n = VAR_TYPE_FLOAT; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014362 case VAR_SPECIAL:
14363 if (argvars[0].vval.v_number == VVAL_FALSE
14364 || argvars[0].vval.v_number == VVAL_TRUE)
Bram Moolenaarf562e722016-07-19 17:25:25 +020014365 n = VAR_TYPE_BOOL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014366 else
Bram Moolenaarf562e722016-07-19 17:25:25 +020014367 n = VAR_TYPE_NONE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014368 break;
Bram Moolenaarf562e722016-07-19 17:25:25 +020014369 case VAR_JOB: n = VAR_TYPE_JOB; break;
14370 case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014371 case VAR_BLOB: n = VAR_TYPE_BLOB; break;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014372 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +010014373 internal_error("f_type(UNKNOWN)");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014374 n = -1;
14375 break;
14376 }
14377 rettv->vval.v_number = n;
14378}
14379
14380/*
14381 * "undofile(name)" function
14382 */
14383 static void
14384f_undofile(typval_T *argvars UNUSED, typval_T *rettv)
14385{
14386 rettv->v_type = VAR_STRING;
14387#ifdef FEAT_PERSISTENT_UNDO
14388 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014389 char_u *fname = tv_get_string(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014390
14391 if (*fname == NUL)
14392 {
14393 /* If there is no file name there will be no undo file. */
14394 rettv->vval.v_string = NULL;
14395 }
14396 else
14397 {
14398 char_u *ffname = FullName_save(fname, FALSE);
14399
14400 if (ffname != NULL)
14401 rettv->vval.v_string = u_get_undo_file_name(ffname, FALSE);
14402 vim_free(ffname);
14403 }
14404 }
14405#else
14406 rettv->vval.v_string = NULL;
14407#endif
14408}
14409
14410/*
14411 * "undotree()" function
14412 */
14413 static void
14414f_undotree(typval_T *argvars UNUSED, typval_T *rettv)
14415{
14416 if (rettv_dict_alloc(rettv) == OK)
14417 {
14418 dict_T *dict = rettv->vval.v_dict;
14419 list_T *list;
14420
Bram Moolenaare0be1672018-07-08 16:50:37 +020014421 dict_add_number(dict, "synced", (long)curbuf->b_u_synced);
14422 dict_add_number(dict, "seq_last", curbuf->b_u_seq_last);
14423 dict_add_number(dict, "save_last", (long)curbuf->b_u_save_nr_last);
14424 dict_add_number(dict, "seq_cur", curbuf->b_u_seq_cur);
14425 dict_add_number(dict, "time_cur", (long)curbuf->b_u_time_cur);
14426 dict_add_number(dict, "save_cur", (long)curbuf->b_u_save_nr_cur);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014427
14428 list = list_alloc();
14429 if (list != NULL)
14430 {
14431 u_eval_tree(curbuf->b_u_oldhead, list);
14432 dict_add_list(dict, "entries", list);
14433 }
14434 }
14435}
14436
14437/*
14438 * "values(dict)" function
14439 */
14440 static void
14441f_values(typval_T *argvars, typval_T *rettv)
14442{
14443 dict_list(argvars, rettv, 1);
14444}
14445
14446/*
14447 * "virtcol(string)" function
14448 */
14449 static void
14450f_virtcol(typval_T *argvars, typval_T *rettv)
14451{
14452 colnr_T vcol = 0;
14453 pos_T *fp;
14454 int fnum = curbuf->b_fnum;
14455
14456 fp = var2fpos(&argvars[0], FALSE, &fnum);
14457 if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count
14458 && fnum == curbuf->b_fnum)
14459 {
14460 getvvcol(curwin, fp, NULL, NULL, &vcol);
14461 ++vcol;
14462 }
14463
14464 rettv->vval.v_number = vcol;
14465}
14466
14467/*
14468 * "visualmode()" function
14469 */
14470 static void
14471f_visualmode(typval_T *argvars, typval_T *rettv)
14472{
14473 char_u str[2];
14474
14475 rettv->v_type = VAR_STRING;
14476 str[0] = curbuf->b_visual_mode_eval;
14477 str[1] = NUL;
14478 rettv->vval.v_string = vim_strsave(str);
14479
14480 /* A non-zero number or non-empty string argument: reset mode. */
14481 if (non_zero_arg(&argvars[0]))
14482 curbuf->b_visual_mode_eval = NUL;
14483}
14484
14485/*
14486 * "wildmenumode()" function
14487 */
14488 static void
14489f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
14490{
14491#ifdef FEAT_WILDMENU
14492 if (wild_menu_showing)
14493 rettv->vval.v_number = 1;
14494#endif
14495}
14496
14497/*
14498 * "winbufnr(nr)" function
14499 */
14500 static void
14501f_winbufnr(typval_T *argvars, typval_T *rettv)
14502{
14503 win_T *wp;
14504
Bram Moolenaarbabfcf52018-10-25 13:11:16 +020014505 wp = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014506 if (wp == NULL)
14507 rettv->vval.v_number = -1;
14508 else
14509 rettv->vval.v_number = wp->w_buffer->b_fnum;
14510}
14511
14512/*
14513 * "wincol()" function
14514 */
14515 static void
14516f_wincol(typval_T *argvars UNUSED, typval_T *rettv)
14517{
14518 validate_cursor();
14519 rettv->vval.v_number = curwin->w_wcol + 1;
14520}
14521
14522/*
14523 * "winheight(nr)" function
14524 */
14525 static void
14526f_winheight(typval_T *argvars, typval_T *rettv)
14527{
14528 win_T *wp;
14529
Bram Moolenaarbabfcf52018-10-25 13:11:16 +020014530 wp = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014531 if (wp == NULL)
14532 rettv->vval.v_number = -1;
14533 else
14534 rettv->vval.v_number = wp->w_height;
14535}
14536
14537/*
Bram Moolenaar0f6b4f02018-08-21 16:56:34 +020014538 * "winlayout()" function
14539 */
14540 static void
14541f_winlayout(typval_T *argvars, typval_T *rettv)
14542{
14543 tabpage_T *tp;
14544
14545 if (rettv_list_alloc(rettv) != OK)
14546 return;
14547
14548 if (argvars[0].v_type == VAR_UNKNOWN)
14549 tp = curtab;
14550 else
14551 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014552 tp = find_tabpage((int)tv_get_number(&argvars[0]));
Bram Moolenaar0f6b4f02018-08-21 16:56:34 +020014553 if (tp == NULL)
14554 return;
14555 }
14556
14557 get_framelayout(tp->tp_topframe, rettv->vval.v_list, TRUE);
14558}
14559
14560/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014561 * "winline()" function
14562 */
14563 static void
14564f_winline(typval_T *argvars UNUSED, typval_T *rettv)
14565{
14566 validate_cursor();
14567 rettv->vval.v_number = curwin->w_wrow + 1;
14568}
14569
14570/*
14571 * "winnr()" function
14572 */
14573 static void
14574f_winnr(typval_T *argvars UNUSED, typval_T *rettv)
14575{
14576 int nr = 1;
14577
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014578 nr = get_winnr(curtab, &argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014579 rettv->vval.v_number = nr;
14580}
14581
14582/*
14583 * "winrestcmd()" function
14584 */
14585 static void
14586f_winrestcmd(typval_T *argvars UNUSED, typval_T *rettv)
14587{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014588 win_T *wp;
14589 int winnr = 1;
14590 garray_T ga;
14591 char_u buf[50];
14592
14593 ga_init2(&ga, (int)sizeof(char), 70);
Bram Moolenaar29323592016-07-24 22:04:11 +020014594 FOR_ALL_WINDOWS(wp)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014595 {
14596 sprintf((char *)buf, "%dresize %d|", winnr, wp->w_height);
14597 ga_concat(&ga, buf);
14598 sprintf((char *)buf, "vert %dresize %d|", winnr, wp->w_width);
14599 ga_concat(&ga, buf);
14600 ++winnr;
14601 }
14602 ga_append(&ga, NUL);
14603
14604 rettv->vval.v_string = ga.ga_data;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014605 rettv->v_type = VAR_STRING;
14606}
14607
14608/*
14609 * "winrestview()" function
14610 */
14611 static void
14612f_winrestview(typval_T *argvars, typval_T *rettv UNUSED)
14613{
14614 dict_T *dict;
14615
14616 if (argvars[0].v_type != VAR_DICT
14617 || (dict = argvars[0].vval.v_dict) == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014618 emsg(_(e_invarg));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014619 else
14620 {
14621 if (dict_find(dict, (char_u *)"lnum", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014622 curwin->w_cursor.lnum = (linenr_T)dict_get_number(dict, (char_u *)"lnum");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014623 if (dict_find(dict, (char_u *)"col", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014624 curwin->w_cursor.col = (colnr_T)dict_get_number(dict, (char_u *)"col");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014625 if (dict_find(dict, (char_u *)"coladd", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014626 curwin->w_cursor.coladd = (colnr_T)dict_get_number(dict, (char_u *)"coladd");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014627 if (dict_find(dict, (char_u *)"curswant", -1) != NULL)
14628 {
Bram Moolenaar8f667172018-12-14 15:38:31 +010014629 curwin->w_curswant = (colnr_T)dict_get_number(dict, (char_u *)"curswant");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014630 curwin->w_set_curswant = FALSE;
14631 }
14632
14633 if (dict_find(dict, (char_u *)"topline", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014634 set_topline(curwin, (linenr_T)dict_get_number(dict, (char_u *)"topline"));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014635#ifdef FEAT_DIFF
14636 if (dict_find(dict, (char_u *)"topfill", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014637 curwin->w_topfill = (int)dict_get_number(dict, (char_u *)"topfill");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014638#endif
14639 if (dict_find(dict, (char_u *)"leftcol", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014640 curwin->w_leftcol = (colnr_T)dict_get_number(dict, (char_u *)"leftcol");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014641 if (dict_find(dict, (char_u *)"skipcol", -1) != NULL)
Bram Moolenaar8f667172018-12-14 15:38:31 +010014642 curwin->w_skipcol = (colnr_T)dict_get_number(dict, (char_u *)"skipcol");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014643
14644 check_cursor();
14645 win_new_height(curwin, curwin->w_height);
Bram Moolenaar02631462017-09-22 15:20:32 +020014646 win_new_width(curwin, curwin->w_width);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014647 changed_window_setting();
14648
14649 if (curwin->w_topline <= 0)
14650 curwin->w_topline = 1;
14651 if (curwin->w_topline > curbuf->b_ml.ml_line_count)
14652 curwin->w_topline = curbuf->b_ml.ml_line_count;
14653#ifdef FEAT_DIFF
14654 check_topfill(curwin, TRUE);
14655#endif
14656 }
14657}
14658
14659/*
14660 * "winsaveview()" function
14661 */
14662 static void
14663f_winsaveview(typval_T *argvars UNUSED, typval_T *rettv)
14664{
14665 dict_T *dict;
14666
14667 if (rettv_dict_alloc(rettv) == FAIL)
14668 return;
14669 dict = rettv->vval.v_dict;
14670
Bram Moolenaare0be1672018-07-08 16:50:37 +020014671 dict_add_number(dict, "lnum", (long)curwin->w_cursor.lnum);
14672 dict_add_number(dict, "col", (long)curwin->w_cursor.col);
Bram Moolenaare0be1672018-07-08 16:50:37 +020014673 dict_add_number(dict, "coladd", (long)curwin->w_cursor.coladd);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014674 update_curswant();
Bram Moolenaare0be1672018-07-08 16:50:37 +020014675 dict_add_number(dict, "curswant", (long)curwin->w_curswant);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014676
Bram Moolenaare0be1672018-07-08 16:50:37 +020014677 dict_add_number(dict, "topline", (long)curwin->w_topline);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014678#ifdef FEAT_DIFF
Bram Moolenaare0be1672018-07-08 16:50:37 +020014679 dict_add_number(dict, "topfill", (long)curwin->w_topfill);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014680#endif
Bram Moolenaare0be1672018-07-08 16:50:37 +020014681 dict_add_number(dict, "leftcol", (long)curwin->w_leftcol);
14682 dict_add_number(dict, "skipcol", (long)curwin->w_skipcol);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014683}
14684
14685/*
14686 * "winwidth(nr)" function
14687 */
14688 static void
14689f_winwidth(typval_T *argvars, typval_T *rettv)
14690{
14691 win_T *wp;
14692
Bram Moolenaarbabfcf52018-10-25 13:11:16 +020014693 wp = find_win_by_nr_or_id(&argvars[0]);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014694 if (wp == NULL)
14695 rettv->vval.v_number = -1;
14696 else
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014697 rettv->vval.v_number = wp->w_width;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014698}
14699
14700/*
14701 * "wordcount()" function
14702 */
14703 static void
14704f_wordcount(typval_T *argvars UNUSED, typval_T *rettv)
14705{
14706 if (rettv_dict_alloc(rettv) == FAIL)
14707 return;
14708 cursor_pos_info(rettv->vval.v_dict);
14709}
14710
14711/*
14712 * "writefile()" function
14713 */
14714 static void
14715f_writefile(typval_T *argvars, typval_T *rettv)
14716{
14717 int binary = FALSE;
14718 int append = FALSE;
Bram Moolenaar7567d0b2017-11-16 23:04:15 +010014719#ifdef HAVE_FSYNC
14720 int do_fsync = p_fs;
14721#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014722 char_u *fname;
14723 FILE *fd;
14724 int ret = 0;
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014725 listitem_T *li;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014726 list_T *list = NULL;
14727 blob_T *blob = NULL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014728
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014729 rettv->vval.v_number = -1;
Bram Moolenaar8c62a082019-02-08 14:34:10 +010014730 if (check_secure())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014731 return;
14732
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014733 if (argvars[0].v_type == VAR_LIST)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014734 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014735 list = argvars[0].vval.v_list;
14736 if (list == NULL)
14737 return;
14738 for (li = list->lv_first; li != NULL; li = li->li_next)
14739 if (tv_get_string_chk(&li->li_tv) == NULL)
14740 return;
14741 }
14742 else if (argvars[0].v_type == VAR_BLOB)
14743 {
14744 blob = argvars[0].vval.v_blob;
14745 if (blob == NULL)
14746 return;
14747 }
14748 else
14749 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014750 semsg(_(e_invarg2), "writefile()");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014751 return;
14752 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014753
14754 if (argvars[2].v_type != VAR_UNKNOWN)
14755 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014756 char_u *arg2 = tv_get_string_chk(&argvars[2]);
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014757
14758 if (arg2 == NULL)
14759 return;
14760 if (vim_strchr(arg2, 'b') != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014761 binary = TRUE;
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014762 if (vim_strchr(arg2, 'a') != NULL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014763 append = TRUE;
Bram Moolenaar7567d0b2017-11-16 23:04:15 +010014764#ifdef HAVE_FSYNC
14765 if (vim_strchr(arg2, 's') != NULL)
14766 do_fsync = TRUE;
14767 else if (vim_strchr(arg2, 'S') != NULL)
14768 do_fsync = FALSE;
14769#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014770 }
14771
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014772 fname = tv_get_string_chk(&argvars[1]);
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014773 if (fname == NULL)
14774 return;
14775
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014776 /* Always open the file in binary mode, library functions have a mind of
14777 * their own about CR-LF conversion. */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014778 if (*fname == NUL || (fd = mch_fopen((char *)fname,
14779 append ? APPENDBIN : WRITEBIN)) == NULL)
14780 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010014781 semsg(_(e_notcreate), *fname == NUL ? (char_u *)_("<empty>") : fname);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014782 ret = -1;
14783 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014784 else if (blob)
14785 {
14786 if (write_blob(fd, blob) == FAIL)
14787 ret = -1;
14788#ifdef HAVE_FSYNC
14789 else if (do_fsync)
14790 // Ignore the error, the user wouldn't know what to do about it.
14791 // May happen for a device.
Bram Moolenaara7870192019-02-14 12:56:36 +010014792 vim_ignored = vim_fsync(fileno(fd));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +010014793#endif
14794 fclose(fd);
14795 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014796 else
14797 {
Bram Moolenaar8cf91282017-06-13 19:38:37 +020014798 if (write_list(fd, list, binary) == FAIL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014799 ret = -1;
Bram Moolenaar7567d0b2017-11-16 23:04:15 +010014800#ifdef HAVE_FSYNC
Bram Moolenaar291a9d12017-11-25 14:37:11 +010014801 else if (do_fsync)
14802 /* Ignore the error, the user wouldn't know what to do about it.
14803 * May happen for a device. */
Bram Moolenaara7870192019-02-14 12:56:36 +010014804 vim_ignored = vim_fsync(fileno(fd));
Bram Moolenaar7567d0b2017-11-16 23:04:15 +010014805#endif
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014806 fclose(fd);
14807 }
14808
14809 rettv->vval.v_number = ret;
14810}
14811
14812/*
14813 * "xor(expr, expr)" function
14814 */
14815 static void
14816f_xor(typval_T *argvars, typval_T *rettv)
14817{
Bram Moolenaard155d7a2018-12-21 16:04:21 +010014818 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
14819 ^ tv_get_number_chk(&argvars[1], NULL);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014820}
14821
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020014822#endif /* FEAT_EVAL */