blob: 23994342c775b6b7e8f136498744bc7211c239bf [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001/* vi:set ts=8 sts=4 sw=4 noet:
2 *
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 * vim9compile.c: :def and dealing with instructions
12 */
13
14#define USING_FLOAT_STUFF
15#include "vim.h"
16
17#if defined(FEAT_EVAL) || defined(PROTO)
18
19#ifdef VMS
20# include <float.h>
21#endif
22
23#define DEFINE_VIM9_GLOBALS
24#include "vim9.h"
25
Bram Moolenaarefd88552020-06-18 20:50:10 +020026// values for ctx_skip
27typedef enum {
28 SKIP_NOT, // condition is a constant, produce code
29 SKIP_YES, // condition is a constant, do NOT produce code
Bram Moolenaar280b0dc2020-06-20 13:29:03 +020030 SKIP_UNKNOWN // condition is not a constant, produce code
Bram Moolenaarefd88552020-06-18 20:50:10 +020031} skip_T;
32
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010033/*
34 * Chain of jump instructions where the end label needs to be set.
35 */
36typedef struct endlabel_S endlabel_T;
37struct endlabel_S {
38 endlabel_T *el_next; // chain end_label locations
39 int el_end_label; // instruction idx where to set end
40};
41
42/*
43 * info specific for the scope of :if / elseif / else
44 */
45typedef struct {
Bram Moolenaarefd88552020-06-18 20:50:10 +020046 int is_seen_else;
Bram Moolenaarced68a02021-01-24 17:53:47 +010047 int is_seen_skip_not; // a block was unconditionally executed
Bram Moolenaarefd88552020-06-18 20:50:10 +020048 int is_had_return; // every block ends in :return
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010049 int is_if_label; // instruction idx at IF or ELSEIF
50 endlabel_T *is_end_label; // instructions to set end label
51} ifscope_T;
52
53/*
54 * info specific for the scope of :while
55 */
56typedef struct {
57 int ws_top_label; // instruction idx at WHILE
58 endlabel_T *ws_end_label; // instructions to set end
59} whilescope_T;
60
61/*
62 * info specific for the scope of :for
63 */
64typedef struct {
65 int fs_top_label; // instruction idx at FOR
66 endlabel_T *fs_end_label; // break instructions
67} forscope_T;
68
69/*
70 * info specific for the scope of :try
71 */
72typedef struct {
73 int ts_try_label; // instruction idx at TRY
74 endlabel_T *ts_end_label; // jump to :finally or :endtry
75 int ts_catch_label; // instruction idx of last CATCH
76 int ts_caught_all; // "catch" without argument encountered
77} tryscope_T;
78
79typedef enum {
80 NO_SCOPE,
81 IF_SCOPE,
82 WHILE_SCOPE,
83 FOR_SCOPE,
84 TRY_SCOPE,
85 BLOCK_SCOPE
86} scopetype_T;
87
88/*
89 * Info for one scope, pointed to by "ctx_scope".
90 */
91typedef struct scope_S scope_T;
92struct scope_S {
93 scope_T *se_outer; // scope containing this one
94 scopetype_T se_type;
95 int se_local_count; // ctx_locals.ga_len before scope
Bram Moolenaarefd88552020-06-18 20:50:10 +020096 skip_T se_skip_save; // ctx_skip before the block
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010097 union {
98 ifscope_T se_if;
99 whilescope_T se_while;
100 forscope_T se_for;
101 tryscope_T se_try;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +0100102 } se_u;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100103};
104
105/*
106 * Entry for "ctx_locals". Used for arguments and local variables.
107 */
108typedef struct {
109 char_u *lv_name;
110 type_T *lv_type;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200111 int lv_idx; // index of the variable on the stack
Bram Moolenaarab360522021-01-10 14:02:28 +0100112 int lv_from_outer; // nesting level, using ctx_outer scope
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200113 int lv_const; // when TRUE cannot be assigned to
114 int lv_arg; // when TRUE this is an argument
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100115} lvar_T;
116
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +0200117// Destination for an assignment or ":unlet" with an index.
118typedef enum {
119 dest_local,
120 dest_option,
121 dest_env,
122 dest_global,
123 dest_buffer,
124 dest_window,
125 dest_tab,
126 dest_vimvar,
127 dest_script,
128 dest_reg,
129 dest_expr,
130} assign_dest_T;
131
132// Used by compile_lhs() to store information about the LHS of an assignment
133// and one argument of ":unlet" with an index.
134typedef struct {
135 assign_dest_T lhs_dest; // type of destination
136
Bram Moolenaar753bcf82021-04-21 14:24:24 +0200137 char_u *lhs_name; // allocated name excluding the last
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +0200138 // "[expr]" or ".name".
139 size_t lhs_varlen; // length of the variable without
140 // "[expr]" or ".name"
Bram Moolenaar753bcf82021-04-21 14:24:24 +0200141 char_u *lhs_whole; // allocated name including the last
142 // "[expr]" or ".name" for :redir
143 size_t lhs_varlen_total; // length of the variable including
144 // any "[expr]" or ".name"
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +0200145 char_u *lhs_dest_end; // end of the destination, including
146 // "[expr]" or ".name".
147
148 int lhs_has_index; // has "[expr]" or ".name"
149
150 int lhs_new_local; // create new local variable
151 int lhs_opt_flags; // for when destination is an option
152 int lhs_vimvaridx; // for when destination is a v:var
153
154 lvar_T lhs_local_lvar; // used for existing local destination
155 lvar_T lhs_arg_lvar; // used for argument destination
156 lvar_T *lhs_lvar; // points to destination lvar
157 int lhs_scriptvar_sid;
158 int lhs_scriptvar_idx;
159
160 int lhs_has_type; // type was specified
161 type_T *lhs_type;
162 type_T *lhs_member_type;
163
164 int lhs_append; // used by ISN_REDIREND
165} lhs_T;
166
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100167/*
168 * Context for compiling lines of Vim script.
169 * Stores info about the local variables and condition stack.
170 */
171struct cctx_S {
172 ufunc_T *ctx_ufunc; // current function
173 int ctx_lnum; // line number in current function
Bram Moolenaar7a092242020-04-16 22:10:49 +0200174 char_u *ctx_line_start; // start of current line or NULL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100175 garray_T ctx_instr; // generated instructions
176
Bram Moolenaar8cec9272021-06-23 20:20:53 +0200177 int ctx_prev_lnum; // line number below previous command, for
178 // debugging
179
Bram Moolenaare99d4222021-06-13 14:01:26 +0200180 compiletype_T ctx_compile_type;
Bram Moolenaarb2049902021-01-24 12:53:53 +0100181
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100182 garray_T ctx_locals; // currently visible local variables
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100183
Bram Moolenaar148ce7a2020-09-23 21:57:23 +0200184 int ctx_has_closure; // set to one if a closures was created in
185 // the function
Bram Moolenaarbf67ea12020-05-02 17:52:42 +0200186
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100187 garray_T ctx_imports; // imported items
188
Bram Moolenaar9b68c822020-06-18 19:31:08 +0200189 skip_T ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100190 scope_T *ctx_scope; // current scope, NULL at toplevel
Bram Moolenaarefd88552020-06-18 20:50:10 +0200191 int ctx_had_return; // last seen statement was "return"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100192
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200193 cctx_T *ctx_outer; // outer scope for lambda or nested
194 // function
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200195 int ctx_outer_used; // var in ctx_outer was used
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200196
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100197 garray_T ctx_type_stack; // type of each item on the stack
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200198 garray_T *ctx_type_list; // list of pointers to allocated types
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +0200199
Bram Moolenaar02194d22020-10-24 23:08:38 +0200200 int ctx_has_cmdmod; // ISN_CMDMOD was generated
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +0200201
202 lhs_T ctx_redir_lhs; // LHS for ":redir => var", valid when
203 // lhs_name is not NULL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100204};
205
Bram Moolenaarcdc40c42020-12-26 17:43:08 +0100206static void delete_def_function_contents(dfunc_T *dfunc, int mark_deleted);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100207
208/*
Bram Moolenaar709664c2020-12-12 14:33:41 +0100209 * Lookup variable "name" in the local scope and return it in "lvar".
Bram Moolenaarab360522021-01-10 14:02:28 +0100210 * "lvar->lv_from_outer" is incremented accordingly.
Bram Moolenaar709664c2020-12-12 14:33:41 +0100211 * If "lvar" is NULL only check if the variable can be found.
212 * Return FAIL if not found.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100213 */
Bram Moolenaar709664c2020-12-12 14:33:41 +0100214 static int
215lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100216{
217 int idx;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100218 lvar_T *lvp;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100219
Bram Moolenaarae8d2de2020-02-13 21:42:24 +0100220 if (len == 0)
Bram Moolenaar709664c2020-12-12 14:33:41 +0100221 return FAIL;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200222
223 // Find local in current function scope.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100224 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
225 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100226 lvp = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
227 if (STRNCMP(name, lvp->lv_name, len) == 0
228 && STRLEN(lvp->lv_name) == len)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200229 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100230 if (lvar != NULL)
231 {
232 *lvar = *lvp;
Bram Moolenaarab360522021-01-10 14:02:28 +0100233 lvar->lv_from_outer = 0;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100234 }
235 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200236 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100237 }
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200238
239 // Find local in outer function scope.
240 if (cctx->ctx_outer != NULL)
241 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100242 if (lookup_local(name, len, lvar, cctx->ctx_outer) == OK)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200243 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100244 if (lvar != NULL)
245 {
246 cctx->ctx_outer_used = TRUE;
Bram Moolenaarab360522021-01-10 14:02:28 +0100247 ++lvar->lv_from_outer;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100248 }
249 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200250 }
251 }
252
Bram Moolenaar709664c2020-12-12 14:33:41 +0100253 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100254}
255
256/*
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200257 * Lookup an argument in the current function and an enclosing function.
258 * Returns the argument index in "idxp"
259 * Returns the argument type in "type"
260 * Sets "gen_load_outer" to TRUE if found in outer scope.
261 * Returns OK when found, FAIL otherwise.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100262 */
263 static int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200264arg_exists(
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200265 char_u *name,
266 size_t len,
267 int *idxp,
268 type_T **type,
269 int *gen_load_outer,
270 cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100271{
272 int idx;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200273 char_u *va_name;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100274
Bram Moolenaarae8d2de2020-02-13 21:42:24 +0100275 if (len == 0)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200276 return FAIL;
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200277 for (idx = 0; idx < cctx->ctx_ufunc->uf_args_visible; ++idx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100278 {
279 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx);
280
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200281 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL)
282 {
283 if (idxp != NULL)
284 {
285 // Arguments are located above the frame pointer. One further
286 // if there is a vararg argument
287 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len
288 + STACK_FRAME_SIZE)
289 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0);
290
291 if (cctx->ctx_ufunc->uf_arg_types != NULL)
292 *type = cctx->ctx_ufunc->uf_arg_types[idx];
293 else
294 *type = &t_any;
295 }
296 return OK;
297 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100298 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100299
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200300 va_name = cctx->ctx_ufunc->uf_va_name;
301 if (va_name != NULL
302 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL)
303 {
304 if (idxp != NULL)
305 {
306 // varargs is always the last argument
307 *idxp = -STACK_FRAME_SIZE - 1;
308 *type = cctx->ctx_ufunc->uf_va_type;
309 }
310 return OK;
311 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100312
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200313 if (cctx->ctx_outer != NULL)
314 {
315 // Lookup the name for an argument of the outer function.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200316 if (arg_exists(name, len, idxp, type, gen_load_outer, cctx->ctx_outer)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200317 == OK)
318 {
Bram Moolenaar44ec21c2021-02-12 21:50:57 +0100319 if (gen_load_outer != NULL)
320 ++*gen_load_outer;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200321 return OK;
322 }
323 }
324
325 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100326}
327
328/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200329 * Lookup a script-local variable in the current script, possibly defined in a
330 * block that contains the function "cctx->ctx_ufunc".
331 * "cctx" is NULL at the script level.
Bram Moolenaar18062fc2021-03-05 21:35:47 +0100332 * If "len" is <= 0 "name" must be NUL terminated.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200333 * Return NULL when not found.
334 */
335 static sallvar_T *
336find_script_var(char_u *name, size_t len, cctx_T *cctx)
337{
338 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
339 hashitem_T *hi;
340 int cc;
341 sallvar_T *sav;
342 ufunc_T *ufunc;
343
344 // Find the list of all script variables with the right name.
345 if (len > 0)
346 {
347 cc = name[len];
348 name[len] = NUL;
349 }
350 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
351 if (len > 0)
352 name[len] = cc;
353 if (HASHITEM_EMPTY(hi))
354 return NULL;
355
356 sav = HI2SAV(hi);
357 if (sav->sav_block_id == 0 || cctx == NULL)
358 // variable defined in the script scope or not in a function.
359 return sav;
360
361 // Go over the variables with this name and find one that was visible
362 // from the function.
363 ufunc = cctx->ctx_ufunc;
364 while (sav != NULL)
365 {
366 int idx;
367
368 // Go over the blocks that this function was defined in. If the
369 // variable block ID matches it was visible to the function.
370 for (idx = 0; idx < ufunc->uf_block_depth; ++idx)
371 if (ufunc->uf_block_ids[idx] == sav->sav_block_id)
372 return sav;
373 sav = sav->sav_next;
374 }
375
376 return NULL;
377}
378
379/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +0100380 * Return TRUE if the script context is Vim9 script.
Bram Moolenaar84367732020-08-23 15:21:55 +0200381 */
382 static int
383script_is_vim9()
384{
385 return SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9;
386}
387
388/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200389 * Lookup a variable (without s: prefix) in the current script.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200390 * "cctx" is NULL at the script level.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100391 * Returns OK or FAIL.
392 */
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200393 static int
394script_var_exists(char_u *name, size_t len, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100395{
Bram Moolenaar9c4f5522020-09-25 21:47:28 +0200396 if (current_sctx.sc_sid <= 0)
397 return FAIL;
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200398 if (script_is_vim9())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200399 {
400 // Check script variables that were visible where the function was
401 // defined.
402 if (find_script_var(name, len, cctx) != NULL)
403 return OK;
404 }
405 else
406 {
407 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
408 dictitem_T *di;
409 int cc;
410
411 // Check script variables that are currently visible
412 cc = name[len];
413 name[len] = NUL;
414 di = find_var_in_ht(ht, 0, name, TRUE);
415 name[len] = cc;
416 if (di != NULL)
417 return OK;
418 }
419
420 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100421}
422
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100423/*
Bram Moolenaare0890d62021-02-17 14:52:14 +0100424 * Return TRUE if "name" is a local variable, argument, script variable or
425 * imported.
426 */
427 static int
428variable_exists(char_u *name, size_t len, cctx_T *cctx)
429{
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100430 return (cctx != NULL
431 && (lookup_local(name, len, NULL, cctx) == OK
432 || arg_exists(name, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200433 || script_var_exists(name, len, cctx) == OK
Bram Moolenaare0890d62021-02-17 14:52:14 +0100434 || find_imported(name, len, cctx) != NULL;
435}
436
437/*
Bram Moolenaar6914e872021-03-06 21:01:09 +0100438 * Return TRUE if "name" is a local variable, argument, script variable,
439 * imported or function.
440 */
441 static int
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100442item_exists(char_u *name, size_t len, int cmd UNUSED, cctx_T *cctx)
Bram Moolenaar6914e872021-03-06 21:01:09 +0100443{
444 int is_global;
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100445 char_u *p;
Bram Moolenaar6914e872021-03-06 21:01:09 +0100446
447 if (variable_exists(name, len, cctx))
448 return TRUE;
449
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100450 // This is similar to what is in lookup_scriptitem():
451 // Find a function, so that a following "->" works.
452 // Require "(" or "->" to follow, "Cmd" is a user command while "Cmd()" is
453 // a function call.
454 p = skipwhite(name + len);
455
456 if (name[len] == '(' || (p[0] == '-' && p[1] == '>'))
457 {
458 // Do not check for an internal function, since it might also be a
Yegappan Lakshmanan2d6d7182021-06-13 21:52:48 +0200459 // valid command, such as ":split" versus "split()".
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100460 // Skip "g:" before a function name.
461 is_global = (name[0] == 'g' && name[1] == ':');
462 return find_func(is_global ? name + 2 : name, is_global, cctx) != NULL;
463 }
464 return FALSE;
Bram Moolenaar6914e872021-03-06 21:01:09 +0100465}
466
467/*
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100468 * Check if "p[len]" is already defined, either in script "import_sid" or in
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200469 * compilation context "cctx". "cctx" is NULL at the script level.
Bram Moolenaar0f769812020-09-12 18:32:34 +0200470 * Does not check the global namespace.
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100471 * If "is_arg" is TRUE the error message is for an argument name.
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100472 * Return FAIL and give an error if it defined.
473 */
474 int
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100475check_defined(char_u *p, size_t len, cctx_T *cctx, int is_arg)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100476{
Bram Moolenaar0f769812020-09-12 18:32:34 +0200477 int c = p[len];
478 ufunc_T *ufunc = NULL;
Bram Moolenaarad486a02020-08-01 23:22:18 +0200479
Bram Moolenaarda479c72021-04-10 21:01:38 +0200480 // underscore argument is OK
481 if (len == 1 && *p == '_')
482 return OK;
483
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200484 if (script_var_exists(p, len, cctx) == OK)
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100485 {
486 if (is_arg)
487 semsg(_(e_argument_already_declared_in_script_str), p);
488 else
489 semsg(_(e_variable_already_declared_in_script_str), p);
490 return FAIL;
491 }
492
Bram Moolenaarad486a02020-08-01 23:22:18 +0200493 p[len] = NUL;
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100494 if ((cctx != NULL
Bram Moolenaar709664c2020-12-12 14:33:41 +0100495 && (lookup_local(p, len, NULL, cctx) == OK
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200496 || arg_exists(p, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaarad486a02020-08-01 23:22:18 +0200497 || find_imported(p, len, cctx) != NULL
Bram Moolenaar0f769812020-09-12 18:32:34 +0200498 || (ufunc = find_func_even_dead(p, FALSE, cctx)) != NULL)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100499 {
Bram Moolenaar0f769812020-09-12 18:32:34 +0200500 // A local or script-local function can shadow a global function.
Bram Moolenaar577dc932021-06-27 15:35:40 +0200501 if (ufunc == NULL || ((ufunc->uf_flags & FC_DEAD) == 0
502 && (!func_is_global(ufunc)
503 || (p[0] == 'g' && p[1] == ':'))))
Bram Moolenaar0f769812020-09-12 18:32:34 +0200504 {
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100505 if (is_arg)
506 semsg(_(e_argument_name_shadows_existing_variable_str), p);
507 else
508 semsg(_(e_name_already_defined_str), p);
Bram Moolenaar0f769812020-09-12 18:32:34 +0200509 p[len] = c;
Bram Moolenaar0f769812020-09-12 18:32:34 +0200510 return FAIL;
511 }
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100512 }
Bram Moolenaarad486a02020-08-01 23:22:18 +0200513 p[len] = c;
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100514 return OK;
515}
516
Bram Moolenaar65b95452020-07-19 14:03:09 +0200517
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100518/////////////////////////////////////////////////////////////////////
519// Following generate_ functions expect the caller to call ga_grow().
520
Bram Moolenaar9b68c822020-06-18 19:31:08 +0200521#define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return NULL
522#define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return OK
Bram Moolenaar080457c2020-03-03 21:53:32 +0100523
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100524/*
525 * Generate an instruction without arguments.
526 * Returns a pointer to the new instruction, NULL if failed.
527 */
528 static isn_T *
529generate_instr(cctx_T *cctx, isntype_T isn_type)
530{
531 garray_T *instr = &cctx->ctx_instr;
532 isn_T *isn;
533
Bram Moolenaar080457c2020-03-03 21:53:32 +0100534 RETURN_NULL_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100535 if (ga_grow(instr, 1) == FAIL)
536 return NULL;
537 isn = ((isn_T *)instr->ga_data) + instr->ga_len;
538 isn->isn_type = isn_type;
539 isn->isn_lnum = cctx->ctx_lnum + 1;
540 ++instr->ga_len;
541
542 return isn;
543}
544
545/*
546 * Generate an instruction without arguments.
547 * "drop" will be removed from the stack.
548 * Returns a pointer to the new instruction, NULL if failed.
549 */
550 static isn_T *
551generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop)
552{
553 garray_T *stack = &cctx->ctx_type_stack;
554
Bram Moolenaar080457c2020-03-03 21:53:32 +0100555 RETURN_NULL_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100556 stack->ga_len -= drop;
557 return generate_instr(cctx, isn_type);
558}
559
560/*
561 * Generate instruction "isn_type" and put "type" on the type stack.
562 */
563 static isn_T *
564generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type)
565{
566 isn_T *isn;
567 garray_T *stack = &cctx->ctx_type_stack;
568
569 if ((isn = generate_instr(cctx, isn_type)) == NULL)
570 return NULL;
571
572 if (ga_grow(stack, 1) == FAIL)
573 return NULL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200574 ((type_T **)stack->ga_data)[stack->ga_len] = type == NULL ? &t_any : type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100575 ++stack->ga_len;
576
577 return isn;
578}
579
580/*
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200581 * Generate an ISN_DEBUG instruction.
582 */
583 static isn_T *
584generate_instr_debug(cctx_T *cctx)
585{
586 isn_T *isn;
587 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
588 + cctx->ctx_ufunc->uf_dfunc_idx;
589
590 if ((isn = generate_instr(cctx, ISN_DEBUG)) == NULL)
591 return NULL;
Bram Moolenaar8cec9272021-06-23 20:20:53 +0200592 isn->isn_arg.debug.dbg_var_names_len = dfunc->df_var_names.ga_len;
593 isn->isn_arg.debug.dbg_break_lnum = cctx->ctx_prev_lnum;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200594 return isn;
595}
596
597/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100598 * If type at "offset" isn't already VAR_STRING then generate ISN_2STRING.
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200599 * But only for simple types.
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200600 * When "tolerant" is TRUE convert most types to string, e.g. a List.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100601 */
602 static int
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200603may_generate_2STRING(int offset, int tolerant, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100604{
605 isn_T *isn;
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200606 isntype_T isntype = ISN_2STRING;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100607 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100608 type_T **type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100609
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100610 RETURN_OK_IF_SKIP(cctx);
611 type = ((type_T **)stack->ga_data) + stack->ga_len + offset;
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200612 switch ((*type)->tt_type)
613 {
614 // nothing to be done
615 case VAR_STRING: return OK;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100616
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200617 // conversion possible
618 case VAR_SPECIAL:
619 case VAR_BOOL:
620 case VAR_NUMBER:
621 case VAR_FLOAT:
622 break;
623
624 // conversion possible (with runtime check)
625 case VAR_ANY:
626 case VAR_UNKNOWN:
627 isntype = ISN_2STRING_ANY;
628 break;
629
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200630 // conversion possible when tolerant
631 case VAR_LIST:
632 if (tolerant)
633 {
634 isntype = ISN_2STRING_ANY;
635 break;
636 }
637 // FALLTHROUGH
638
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200639 // conversion not possible
640 case VAR_VOID:
641 case VAR_BLOB:
642 case VAR_FUNC:
643 case VAR_PARTIAL:
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200644 case VAR_DICT:
645 case VAR_JOB:
646 case VAR_CHANNEL:
Bram Moolenaarf18332f2021-05-07 17:55:55 +0200647 case VAR_INSTR:
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200648 to_string_error((*type)->tt_type);
649 return FAIL;
650 }
651
652 *type = &t_string;
653 if ((isn = generate_instr(cctx, isntype)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100654 return FAIL;
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200655 isn->isn_arg.tostring.offset = offset;
656 isn->isn_arg.tostring.tolerant = tolerant;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100657
658 return OK;
659}
660
661 static int
662check_number_or_float(vartype_T type1, vartype_T type2, char_u *op)
663{
Bram Moolenaar4c683752020-04-05 21:38:23 +0200664 if (!((type1 == VAR_NUMBER || type1 == VAR_FLOAT || type1 == VAR_ANY)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100665 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT
Bram Moolenaar4c683752020-04-05 21:38:23 +0200666 || type2 == VAR_ANY)))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100667 {
668 if (*op == '+')
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200669 emsg(_(e_wrong_argument_type_for_plus));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100670 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200671 semsg(_(e_char_requires_number_or_float_arguments), *op);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100672 return FAIL;
673 }
674 return OK;
675}
676
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200677 static int
678generate_add_instr(
679 cctx_T *cctx,
680 vartype_T vartype,
681 type_T *type1,
682 type_T *type2)
683{
Bram Moolenaar399ea812020-12-15 21:28:57 +0100684 garray_T *stack = &cctx->ctx_type_stack;
685 isn_T *isn = generate_instr_drop(cctx,
686 vartype == VAR_NUMBER ? ISN_OPNR
687 : vartype == VAR_LIST ? ISN_ADDLIST
688 : vartype == VAR_BLOB ? ISN_ADDBLOB
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200689#ifdef FEAT_FLOAT
Bram Moolenaar399ea812020-12-15 21:28:57 +0100690 : vartype == VAR_FLOAT ? ISN_OPFLOAT
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200691#endif
Bram Moolenaar399ea812020-12-15 21:28:57 +0100692 : ISN_OPANY, 1);
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200693
694 if (vartype != VAR_LIST && vartype != VAR_BLOB
695 && type1->tt_type != VAR_ANY
696 && type2->tt_type != VAR_ANY
697 && check_number_or_float(
698 type1->tt_type, type2->tt_type, (char_u *)"+") == FAIL)
699 return FAIL;
700
701 if (isn != NULL)
702 isn->isn_arg.op.op_type = EXPR_ADD;
Bram Moolenaar399ea812020-12-15 21:28:57 +0100703
704 // When concatenating two lists with different member types the member type
705 // becomes "any".
706 if (vartype == VAR_LIST
707 && type1->tt_type == VAR_LIST && type2->tt_type == VAR_LIST
708 && type1->tt_member != type2->tt_member)
709 (((type_T **)stack->ga_data)[stack->ga_len - 1]) = &t_list_any;
710
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200711 return isn == NULL ? FAIL : OK;
712}
713
714/*
715 * Get the type to use for an instruction for an operation on "type1" and
716 * "type2". If they are matching use a type-specific instruction. Otherwise
717 * fall back to runtime type checking.
718 */
719 static vartype_T
720operator_type(type_T *type1, type_T *type2)
721{
722 if (type1->tt_type == type2->tt_type
723 && (type1->tt_type == VAR_NUMBER
724 || type1->tt_type == VAR_LIST
725#ifdef FEAT_FLOAT
726 || type1->tt_type == VAR_FLOAT
727#endif
728 || type1->tt_type == VAR_BLOB))
729 return type1->tt_type;
730 return VAR_ANY;
731}
732
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100733/*
734 * Generate an instruction with two arguments. The instruction depends on the
735 * type of the arguments.
736 */
737 static int
738generate_two_op(cctx_T *cctx, char_u *op)
739{
740 garray_T *stack = &cctx->ctx_type_stack;
741 type_T *type1;
742 type_T *type2;
743 vartype_T vartype;
744 isn_T *isn;
745
Bram Moolenaar080457c2020-03-03 21:53:32 +0100746 RETURN_OK_IF_SKIP(cctx);
747
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200748 // Get the known type of the two items on the stack.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100749 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2];
750 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200751 vartype = operator_type(type1, type2);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100752
753 switch (*op)
754 {
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200755 case '+':
756 if (generate_add_instr(cctx, vartype, type1, type2) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100757 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100758 break;
759
760 case '-':
761 case '*':
762 case '/': if (check_number_or_float(type1->tt_type, type2->tt_type,
763 op) == FAIL)
764 return FAIL;
765 if (vartype == VAR_NUMBER)
766 isn = generate_instr_drop(cctx, ISN_OPNR, 1);
767#ifdef FEAT_FLOAT
768 else if (vartype == VAR_FLOAT)
769 isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1);
770#endif
771 else
772 isn = generate_instr_drop(cctx, ISN_OPANY, 1);
773 if (isn != NULL)
774 isn->isn_arg.op.op_type = *op == '*'
775 ? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB;
776 break;
777
Bram Moolenaar4c683752020-04-05 21:38:23 +0200778 case '%': if ((type1->tt_type != VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100779 && type1->tt_type != VAR_NUMBER)
Bram Moolenaar4c683752020-04-05 21:38:23 +0200780 || (type2->tt_type != VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100781 && type2->tt_type != VAR_NUMBER))
782 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200783 emsg(_(e_percent_requires_number_arguments));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100784 return FAIL;
785 }
786 isn = generate_instr_drop(cctx,
787 vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1);
788 if (isn != NULL)
789 isn->isn_arg.op.op_type = EXPR_REM;
790 break;
791 }
792
793 // correct type of result
Bram Moolenaar4c683752020-04-05 21:38:23 +0200794 if (vartype == VAR_ANY)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100795 {
796 type_T *type = &t_any;
797
798#ifdef FEAT_FLOAT
799 // float+number and number+float results in float
800 if ((type1->tt_type == VAR_NUMBER || type1->tt_type == VAR_FLOAT)
801 && (type2->tt_type == VAR_NUMBER || type2->tt_type == VAR_FLOAT))
802 type = &t_float;
803#endif
804 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type;
805 }
806
807 return OK;
808}
809
810/*
Bram Moolenaara5565e42020-05-09 15:44:01 +0200811 * Get the instruction to use for comparing "type1" with "type2"
812 * Return ISN_DROP when failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100813 */
Bram Moolenaara5565e42020-05-09 15:44:01 +0200814 static isntype_T
Bram Moolenaar657137c2021-01-09 15:45:23 +0100815get_compare_isn(exprtype_T exprtype, vartype_T type1, vartype_T type2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100816{
817 isntype_T isntype = ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100818
Bram Moolenaar4c683752020-04-05 21:38:23 +0200819 if (type1 == VAR_UNKNOWN)
820 type1 = VAR_ANY;
821 if (type2 == VAR_UNKNOWN)
822 type2 = VAR_ANY;
823
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100824 if (type1 == type2)
825 {
826 switch (type1)
827 {
828 case VAR_BOOL: isntype = ISN_COMPAREBOOL; break;
829 case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break;
830 case VAR_NUMBER: isntype = ISN_COMPARENR; break;
831 case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break;
832 case VAR_STRING: isntype = ISN_COMPARESTRING; break;
833 case VAR_BLOB: isntype = ISN_COMPAREBLOB; break;
834 case VAR_LIST: isntype = ISN_COMPARELIST; break;
835 case VAR_DICT: isntype = ISN_COMPAREDICT; break;
836 case VAR_FUNC: isntype = ISN_COMPAREFUNC; break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100837 default: isntype = ISN_COMPAREANY; break;
838 }
839 }
Bram Moolenaar4c683752020-04-05 21:38:23 +0200840 else if (type1 == VAR_ANY || type2 == VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100841 || ((type1 == VAR_NUMBER || type1 == VAR_FLOAT)
Bram Moolenaar6914e872021-03-06 21:01:09 +0100842 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT)))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100843 isntype = ISN_COMPAREANY;
844
Bram Moolenaar657137c2021-01-09 15:45:23 +0100845 if ((exprtype == EXPR_IS || exprtype == EXPR_ISNOT)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100846 && (isntype == ISN_COMPAREBOOL
847 || isntype == ISN_COMPARESPECIAL
848 || isntype == ISN_COMPARENR
849 || isntype == ISN_COMPAREFLOAT))
850 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200851 semsg(_(e_cannot_use_str_with_str),
Bram Moolenaar657137c2021-01-09 15:45:23 +0100852 exprtype == EXPR_IS ? "is" : "isnot" , vartype_name(type1));
Bram Moolenaara5565e42020-05-09 15:44:01 +0200853 return ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100854 }
855 if (isntype == ISN_DROP
Bram Moolenaar657137c2021-01-09 15:45:23 +0100856 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100857 && (type1 == VAR_BOOL || type1 == VAR_SPECIAL
858 || type2 == VAR_BOOL || type2 == VAR_SPECIAL)))
Bram Moolenaar657137c2021-01-09 15:45:23 +0100859 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL
860 && exprtype != EXPR_IS && exprtype != EXPR_ISNOT
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100861 && (type1 == VAR_BLOB || type2 == VAR_BLOB
862 || type1 == VAR_LIST || type2 == VAR_LIST))))
863 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200864 semsg(_(e_cannot_compare_str_with_str),
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100865 vartype_name(type1), vartype_name(type2));
Bram Moolenaara5565e42020-05-09 15:44:01 +0200866 return ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100867 }
Bram Moolenaara5565e42020-05-09 15:44:01 +0200868 return isntype;
869}
870
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200871 int
Bram Moolenaar657137c2021-01-09 15:45:23 +0100872check_compare_types(exprtype_T type, typval_T *tv1, typval_T *tv2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200873{
874 if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP)
875 return FAIL;
876 return OK;
877}
878
Bram Moolenaara5565e42020-05-09 15:44:01 +0200879/*
880 * Generate an ISN_COMPARE* instruction with a boolean result.
881 */
882 static int
Bram Moolenaar657137c2021-01-09 15:45:23 +0100883generate_COMPARE(cctx_T *cctx, exprtype_T exprtype, int ic)
Bram Moolenaara5565e42020-05-09 15:44:01 +0200884{
885 isntype_T isntype;
886 isn_T *isn;
887 garray_T *stack = &cctx->ctx_type_stack;
888 vartype_T type1;
889 vartype_T type2;
890
891 RETURN_OK_IF_SKIP(cctx);
892
893 // Get the known type of the two items on the stack. If they are matching
894 // use a type-specific instruction. Otherwise fall back to runtime type
895 // checking.
896 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type;
897 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type;
Bram Moolenaar657137c2021-01-09 15:45:23 +0100898 isntype = get_compare_isn(exprtype, type1, type2);
Bram Moolenaara5565e42020-05-09 15:44:01 +0200899 if (isntype == ISN_DROP)
900 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100901
902 if ((isn = generate_instr(cctx, isntype)) == NULL)
903 return FAIL;
Bram Moolenaar657137c2021-01-09 15:45:23 +0100904 isn->isn_arg.op.op_type = exprtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100905 isn->isn_arg.op.op_ic = ic;
906
907 // takes two arguments, puts one bool back
908 if (stack->ga_len >= 2)
909 {
910 --stack->ga_len;
911 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
912 }
913
914 return OK;
915}
916
917/*
918 * Generate an ISN_2BOOL instruction.
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200919 * "offset" is the offset in the type stack.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100920 */
921 static int
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200922generate_2BOOL(cctx_T *cctx, int invert, int offset)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100923{
924 isn_T *isn;
925 garray_T *stack = &cctx->ctx_type_stack;
926
Bram Moolenaar080457c2020-03-03 21:53:32 +0100927 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100928 if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL)
929 return FAIL;
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200930 isn->isn_arg.tobool.invert = invert;
931 isn->isn_arg.tobool.offset = offset;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100932
933 // type becomes bool
Bram Moolenaar5fa9b242021-06-04 21:00:32 +0200934 ((type_T **)stack->ga_data)[stack->ga_len + offset] = &t_bool;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100935
936 return OK;
937}
938
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200939/*
940 * Generate an ISN_COND2BOOL instruction.
941 */
942 static int
943generate_COND2BOOL(cctx_T *cctx)
944{
945 isn_T *isn;
946 garray_T *stack = &cctx->ctx_type_stack;
947
948 RETURN_OK_IF_SKIP(cctx);
949 if ((isn = generate_instr(cctx, ISN_COND2BOOL)) == NULL)
950 return FAIL;
951
952 // type becomes bool
953 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
954
955 return OK;
956}
957
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100958 static int
Bram Moolenaar5e654232020-09-16 15:22:00 +0200959generate_TYPECHECK(
960 cctx_T *cctx,
961 type_T *expected,
Bram Moolenaare32e5162021-01-21 20:21:29 +0100962 int offset,
963 int argidx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100964{
965 isn_T *isn;
966 garray_T *stack = &cctx->ctx_type_stack;
967
Bram Moolenaar080457c2020-03-03 21:53:32 +0100968 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100969 if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL)
970 return FAIL;
Bram Moolenaar5e654232020-09-16 15:22:00 +0200971 isn->isn_arg.type.ct_type = alloc_type(expected);
Bram Moolenaarb3005ce2021-01-22 17:51:06 +0100972 isn->isn_arg.type.ct_off = (int8_T)offset;
973 isn->isn_arg.type.ct_arg_idx = (int8_T)argidx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100974
Bram Moolenaar5e654232020-09-16 15:22:00 +0200975 // type becomes expected
976 ((type_T **)stack->ga_data)[stack->ga_len + offset] = expected;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100977
978 return OK;
979}
980
Bram Moolenaaraa210a32021-01-02 15:41:03 +0100981 static int
982generate_SETTYPE(
983 cctx_T *cctx,
984 type_T *expected)
985{
986 isn_T *isn;
987
988 RETURN_OK_IF_SKIP(cctx);
989 if ((isn = generate_instr(cctx, ISN_SETTYPE)) == NULL)
990 return FAIL;
991 isn->isn_arg.type.ct_type = alloc_type(expected);
992 return OK;
993}
994
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100995/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200996 * Return TRUE if "actual" could be "expected" and a runtime typecheck is to be
997 * used. Return FALSE if the types will never match.
998 */
Bram Moolenaar193f6202020-11-16 20:08:35 +0100999 int
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001000use_typecheck(type_T *actual, type_T *expected)
1001{
1002 if (actual->tt_type == VAR_ANY
1003 || actual->tt_type == VAR_UNKNOWN
1004 || (actual->tt_type == VAR_FUNC
1005 && (expected->tt_type == VAR_FUNC
1006 || expected->tt_type == VAR_PARTIAL)
Bram Moolenaar328eac22021-01-07 19:23:08 +01001007 && (actual->tt_member == &t_any || actual->tt_argcount < 0)
1008 && ((actual->tt_member == &t_void)
1009 == (expected->tt_member == &t_void))))
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001010 return TRUE;
1011 if ((actual->tt_type == VAR_LIST || actual->tt_type == VAR_DICT)
1012 && actual->tt_type == expected->tt_type)
1013 // This takes care of a nested list or dict.
1014 return use_typecheck(actual->tt_member, expected->tt_member);
1015 return FALSE;
1016}
1017
1018/*
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001019 * Check that
Bram Moolenaar5e654232020-09-16 15:22:00 +02001020 * - "actual" matches "expected" type or
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001021 * - "actual" is a type that can be "expected" type: add a runtime check; or
1022 * - return FAIL.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001023 * If "actual_is_const" is TRUE then the type won't change at runtime, do not
1024 * generate a TYPECHECK.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001025 */
Bram Moolenaar351ead02021-01-16 16:07:01 +01001026 int
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001027need_type(
1028 type_T *actual,
1029 type_T *expected,
1030 int offset,
Bram Moolenaar351ead02021-01-16 16:07:01 +01001031 int arg_idx,
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001032 cctx_T *cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001033 int silent,
1034 int actual_is_const)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001035{
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02001036 where_T where = WHERE_INIT;
Bram Moolenaarf785aa12021-02-11 21:19:34 +01001037
Bram Moolenaar4ed124c2020-09-09 20:03:46 +02001038 if (expected == &t_bool && actual != &t_bool
1039 && (actual->tt_flags & TTFLAG_BOOL_OK))
1040 {
1041 // Using "0", "1" or the result of an expression with "&&" or "||" as a
1042 // boolean is OK but requires a conversion.
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02001043 generate_2BOOL(cctx, FALSE, offset);
Bram Moolenaar4ed124c2020-09-09 20:03:46 +02001044 return OK;
1045 }
1046
Bram Moolenaarf785aa12021-02-11 21:19:34 +01001047 where.wt_index = arg_idx;
Bram Moolenaarf785aa12021-02-11 21:19:34 +01001048 if (check_type(expected, actual, FALSE, where) == OK)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001049 return OK;
Bram Moolenaar5e654232020-09-16 15:22:00 +02001050
1051 // If the actual type can be the expected type add a runtime check.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001052 // If it's a constant a runtime check makes no sense.
Bram Moolenaar378697a2021-07-15 19:23:18 +02001053 if ((!actual_is_const || actual == &t_any)
1054 && use_typecheck(actual, expected))
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001055 {
Bram Moolenaare32e5162021-01-21 20:21:29 +01001056 generate_TYPECHECK(cctx, expected, offset, arg_idx);
Bram Moolenaar5e654232020-09-16 15:22:00 +02001057 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001058 }
Bram Moolenaar5e654232020-09-16 15:22:00 +02001059
1060 if (!silent)
Bram Moolenaar351ead02021-01-16 16:07:01 +01001061 arg_type_mismatch(expected, actual, arg_idx);
Bram Moolenaar5e654232020-09-16 15:22:00 +02001062 return FAIL;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001063}
1064
1065/*
Bram Moolenaarea2d4072020-11-12 12:08:51 +01001066 * Check that the top of the type stack has a type that can be used as a
1067 * condition. Give an error and return FAIL if not.
1068 */
1069 static int
1070bool_on_stack(cctx_T *cctx)
1071{
1072 garray_T *stack = &cctx->ctx_type_stack;
1073 type_T *type;
1074
1075 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
1076 if (type == &t_bool)
1077 return OK;
1078
Bram Moolenaaraf8ea0d2021-04-11 18:24:46 +02001079 if (type == &t_any || type == &t_number || type == &t_number_bool)
Bram Moolenaarea2d4072020-11-12 12:08:51 +01001080 // Number 0 and 1 are OK to use as a bool. "any" could also be a bool.
1081 // This requires a runtime type check.
1082 return generate_COND2BOOL(cctx);
1083
Bram Moolenaar351ead02021-01-16 16:07:01 +01001084 return need_type(type, &t_bool, -1, 0, cctx, FALSE, FALSE);
Bram Moolenaarea2d4072020-11-12 12:08:51 +01001085}
1086
1087/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001088 * Generate an ISN_PUSHNR instruction.
1089 */
1090 static int
1091generate_PUSHNR(cctx_T *cctx, varnumber_T number)
1092{
1093 isn_T *isn;
Bram Moolenaar29a86ff2020-09-09 14:55:31 +02001094 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001095
Bram Moolenaar080457c2020-03-03 21:53:32 +01001096 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001097 if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL)
1098 return FAIL;
1099 isn->isn_arg.number = number;
1100
Bram Moolenaar29a86ff2020-09-09 14:55:31 +02001101 if (number == 0 || number == 1)
Bram Moolenaar29a86ff2020-09-09 14:55:31 +02001102 // A 0 or 1 number can also be used as a bool.
Bram Moolenaar3868f592020-12-25 13:20:41 +01001103 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_number_bool;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001104 return OK;
1105}
1106
1107/*
1108 * Generate an ISN_PUSHBOOL instruction.
1109 */
1110 static int
1111generate_PUSHBOOL(cctx_T *cctx, varnumber_T number)
1112{
1113 isn_T *isn;
1114
Bram Moolenaar080457c2020-03-03 21:53:32 +01001115 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001116 if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL)
1117 return FAIL;
1118 isn->isn_arg.number = number;
1119
1120 return OK;
1121}
1122
1123/*
1124 * Generate an ISN_PUSHSPEC instruction.
1125 */
1126 static int
1127generate_PUSHSPEC(cctx_T *cctx, varnumber_T number)
1128{
1129 isn_T *isn;
1130
Bram Moolenaar080457c2020-03-03 21:53:32 +01001131 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001132 if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL)
1133 return FAIL;
1134 isn->isn_arg.number = number;
1135
1136 return OK;
1137}
1138
1139#ifdef FEAT_FLOAT
1140/*
1141 * Generate an ISN_PUSHF instruction.
1142 */
1143 static int
1144generate_PUSHF(cctx_T *cctx, float_T fnumber)
1145{
1146 isn_T *isn;
1147
Bram Moolenaar080457c2020-03-03 21:53:32 +01001148 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001149 if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL)
1150 return FAIL;
1151 isn->isn_arg.fnumber = fnumber;
1152
1153 return OK;
1154}
1155#endif
1156
1157/*
1158 * Generate an ISN_PUSHS instruction.
1159 * Consumes "str".
1160 */
1161 static int
1162generate_PUSHS(cctx_T *cctx, char_u *str)
1163{
1164 isn_T *isn;
1165
Bram Moolenaar508b5612021-01-02 18:17:26 +01001166 if (cctx->ctx_skip == SKIP_YES)
1167 {
1168 vim_free(str);
1169 return OK;
1170 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001171 if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL)
1172 return FAIL;
1173 isn->isn_arg.string = str;
1174
1175 return OK;
1176}
1177
1178/*
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001179 * Generate an ISN_PUSHCHANNEL instruction.
1180 * Consumes "channel".
1181 */
1182 static int
1183generate_PUSHCHANNEL(cctx_T *cctx, channel_T *channel)
1184{
1185 isn_T *isn;
1186
Bram Moolenaar080457c2020-03-03 21:53:32 +01001187 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001188 if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL)
1189 return FAIL;
1190 isn->isn_arg.channel = channel;
1191
1192 return OK;
1193}
1194
1195/*
1196 * Generate an ISN_PUSHJOB instruction.
1197 * Consumes "job".
1198 */
1199 static int
1200generate_PUSHJOB(cctx_T *cctx, job_T *job)
1201{
1202 isn_T *isn;
1203
Bram Moolenaar080457c2020-03-03 21:53:32 +01001204 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +01001205 if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001206 return FAIL;
1207 isn->isn_arg.job = job;
1208
1209 return OK;
1210}
1211
1212/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001213 * Generate an ISN_PUSHBLOB instruction.
1214 * Consumes "blob".
1215 */
1216 static int
1217generate_PUSHBLOB(cctx_T *cctx, blob_T *blob)
1218{
1219 isn_T *isn;
1220
Bram Moolenaar080457c2020-03-03 21:53:32 +01001221 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001222 if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL)
1223 return FAIL;
1224 isn->isn_arg.blob = blob;
1225
1226 return OK;
1227}
1228
1229/*
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001230 * Generate an ISN_PUSHFUNC instruction with name "name".
1231 * Consumes "name".
1232 */
1233 static int
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001234generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001235{
1236 isn_T *isn;
1237
Bram Moolenaar080457c2020-03-03 21:53:32 +01001238 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001239 if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001240 return FAIL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001241 isn->isn_arg.string = name == NULL ? NULL : vim_strsave(name);
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001242
1243 return OK;
1244}
1245
1246/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001247 * Generate an ISN_GETITEM instruction with "index".
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02001248 * "with_op" is TRUE for "+=" and other operators, the stack has the current
1249 * value below the list with values.
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001250 */
1251 static int
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02001252generate_GETITEM(cctx_T *cctx, int index, int with_op)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001253{
1254 isn_T *isn;
1255 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02001256 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len
1257 - (with_op ? 2 : 1)];
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001258 type_T *item_type = &t_any;
1259
1260 RETURN_OK_IF_SKIP(cctx);
1261
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001262 if (type->tt_type != VAR_LIST)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001263 {
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001264 // cannot happen, caller has checked the type
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001265 emsg(_(e_listreq));
1266 return FAIL;
1267 }
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001268 item_type = type->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001269 if ((isn = generate_instr(cctx, ISN_GETITEM)) == NULL)
1270 return FAIL;
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02001271 isn->isn_arg.getitem.gi_index = index;
1272 isn->isn_arg.getitem.gi_with_op = with_op;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001273
1274 // add the item type to the type stack
1275 if (ga_grow(stack, 1) == FAIL)
1276 return FAIL;
1277 ((type_T **)stack->ga_data)[stack->ga_len] = item_type;
1278 ++stack->ga_len;
1279 return OK;
1280}
1281
1282/*
Bram Moolenaar9af78762020-06-16 11:34:42 +02001283 * Generate an ISN_SLICE instruction with "count".
1284 */
1285 static int
1286generate_SLICE(cctx_T *cctx, int count)
1287{
1288 isn_T *isn;
1289
1290 RETURN_OK_IF_SKIP(cctx);
1291 if ((isn = generate_instr(cctx, ISN_SLICE)) == NULL)
1292 return FAIL;
1293 isn->isn_arg.number = count;
1294 return OK;
1295}
1296
1297/*
1298 * Generate an ISN_CHECKLEN instruction with "min_len".
1299 */
1300 static int
1301generate_CHECKLEN(cctx_T *cctx, int min_len, int more_OK)
1302{
1303 isn_T *isn;
1304
1305 RETURN_OK_IF_SKIP(cctx);
1306
1307 if ((isn = generate_instr(cctx, ISN_CHECKLEN)) == NULL)
1308 return FAIL;
1309 isn->isn_arg.checklen.cl_min_len = min_len;
1310 isn->isn_arg.checklen.cl_more_OK = more_OK;
1311
1312 return OK;
1313}
1314
1315/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001316 * Generate an ISN_STORE instruction.
1317 */
1318 static int
1319generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name)
1320{
1321 isn_T *isn;
1322
Bram Moolenaar080457c2020-03-03 21:53:32 +01001323 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001324 if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL)
1325 return FAIL;
1326 if (name != NULL)
1327 isn->isn_arg.string = vim_strsave(name);
1328 else
1329 isn->isn_arg.number = idx;
1330
1331 return OK;
1332}
1333
1334/*
Bram Moolenaarab360522021-01-10 14:02:28 +01001335 * Generate an ISN_STOREOUTER instruction.
1336 */
1337 static int
1338generate_STOREOUTER(cctx_T *cctx, int idx, int level)
1339{
1340 isn_T *isn;
1341
1342 RETURN_OK_IF_SKIP(cctx);
1343 if ((isn = generate_instr_drop(cctx, ISN_STOREOUTER, 1)) == NULL)
1344 return FAIL;
1345 isn->isn_arg.outer.outer_idx = idx;
1346 isn->isn_arg.outer.outer_depth = level;
1347
1348 return OK;
1349}
1350
1351/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001352 * Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE)
1353 */
1354 static int
1355generate_STORENR(cctx_T *cctx, int idx, varnumber_T value)
1356{
1357 isn_T *isn;
1358
Bram Moolenaar080457c2020-03-03 21:53:32 +01001359 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001360 if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL)
1361 return FAIL;
Bram Moolenaara471eea2020-03-04 22:20:26 +01001362 isn->isn_arg.storenr.stnr_idx = idx;
1363 isn->isn_arg.storenr.stnr_val = value;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001364
1365 return OK;
1366}
1367
1368/*
1369 * Generate an ISN_STOREOPT instruction
1370 */
1371 static int
1372generate_STOREOPT(cctx_T *cctx, char_u *name, int opt_flags)
1373{
1374 isn_T *isn;
1375
Bram Moolenaar080457c2020-03-03 21:53:32 +01001376 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1c199f92020-08-07 21:28:34 +02001377 if ((isn = generate_instr_drop(cctx, ISN_STOREOPT, 1)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001378 return FAIL;
1379 isn->isn_arg.storeopt.so_name = vim_strsave(name);
1380 isn->isn_arg.storeopt.so_flags = opt_flags;
1381
1382 return OK;
1383}
1384
1385/*
1386 * Generate an ISN_LOAD or similar instruction.
1387 */
1388 static int
1389generate_LOAD(
1390 cctx_T *cctx,
1391 isntype_T isn_type,
1392 int idx,
1393 char_u *name,
1394 type_T *type)
1395{
1396 isn_T *isn;
1397
Bram Moolenaar080457c2020-03-03 21:53:32 +01001398 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001399 if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL)
1400 return FAIL;
1401 if (name != NULL)
1402 isn->isn_arg.string = vim_strsave(name);
1403 else
1404 isn->isn_arg.number = idx;
1405
1406 return OK;
1407}
1408
1409/*
Bram Moolenaarab360522021-01-10 14:02:28 +01001410 * Generate an ISN_LOADOUTER instruction
1411 */
1412 static int
1413generate_LOADOUTER(
1414 cctx_T *cctx,
1415 int idx,
1416 int nesting,
1417 type_T *type)
1418{
1419 isn_T *isn;
1420
1421 RETURN_OK_IF_SKIP(cctx);
1422 if ((isn = generate_instr_type(cctx, ISN_LOADOUTER, type)) == NULL)
1423 return FAIL;
1424 isn->isn_arg.outer.outer_idx = idx;
1425 isn->isn_arg.outer.outer_depth = nesting;
1426
1427 return OK;
1428}
1429
1430/*
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001431 * Generate an ISN_LOADV instruction for v:var.
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001432 */
1433 static int
1434generate_LOADV(
1435 cctx_T *cctx,
1436 char_u *name,
1437 int error)
1438{
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001439 int di_flags;
1440 int vidx = find_vim_var(name, &di_flags);
1441 type_T *type;
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001442
Bram Moolenaar080457c2020-03-03 21:53:32 +01001443 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001444 if (vidx < 0)
1445 {
1446 if (error)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001447 semsg(_(e_variable_not_found_str), name);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001448 return FAIL;
1449 }
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +02001450 type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001451
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001452 return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001453}
1454
1455/*
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001456 * Generate an ISN_UNLET instruction.
1457 */
1458 static int
Bram Moolenaar7bdaea62020-04-19 18:27:26 +02001459generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001460{
1461 isn_T *isn;
1462
1463 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar7bdaea62020-04-19 18:27:26 +02001464 if ((isn = generate_instr(cctx, isn_type)) == NULL)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001465 return FAIL;
1466 isn->isn_arg.unlet.ul_name = vim_strsave(name);
1467 isn->isn_arg.unlet.ul_forceit = forceit;
1468
1469 return OK;
1470}
1471
1472/*
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02001473 * Generate an ISN_LOCKCONST instruction.
1474 */
1475 static int
1476generate_LOCKCONST(cctx_T *cctx)
1477{
1478 isn_T *isn;
1479
1480 RETURN_OK_IF_SKIP(cctx);
1481 if ((isn = generate_instr(cctx, ISN_LOCKCONST)) == NULL)
1482 return FAIL;
1483 return OK;
1484}
1485
1486/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001487 * Generate an ISN_LOADS instruction.
1488 */
1489 static int
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001490generate_OLDSCRIPT(
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001491 cctx_T *cctx,
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001492 isntype_T isn_type,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001493 char_u *name,
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001494 int sid,
1495 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001496{
1497 isn_T *isn;
1498
Bram Moolenaar080457c2020-03-03 21:53:32 +01001499 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001500 if (isn_type == ISN_LOADS)
1501 isn = generate_instr_type(cctx, isn_type, type);
1502 else
1503 isn = generate_instr_drop(cctx, isn_type, 1);
1504 if (isn == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001505 return FAIL;
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001506 isn->isn_arg.loadstore.ls_name = vim_strsave(name);
1507 isn->isn_arg.loadstore.ls_sid = sid;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001508
1509 return OK;
1510}
1511
1512/*
1513 * Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction.
1514 */
1515 static int
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001516generate_VIM9SCRIPT(
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001517 cctx_T *cctx,
1518 isntype_T isn_type,
1519 int sid,
1520 int idx,
1521 type_T *type)
1522{
1523 isn_T *isn;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01001524 scriptref_T *sref;
1525 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001526
Bram Moolenaar080457c2020-03-03 21:53:32 +01001527 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001528 if (isn_type == ISN_LOADSCRIPT)
1529 isn = generate_instr_type(cctx, isn_type, type);
1530 else
1531 isn = generate_instr_drop(cctx, isn_type, 1);
1532 if (isn == NULL)
1533 return FAIL;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01001534
1535 // This requires three arguments, which doesn't fit in an instruction, thus
1536 // we need to allocate a struct for this.
1537 sref = ALLOC_ONE(scriptref_T);
1538 if (sref == NULL)
1539 return FAIL;
1540 isn->isn_arg.script.scriptref = sref;
1541 sref->sref_sid = sid;
1542 sref->sref_idx = idx;
1543 sref->sref_seq = si->sn_script_seq;
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001544 sref->sref_type = type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001545 return OK;
1546}
1547
1548/*
1549 * Generate an ISN_NEWLIST instruction.
1550 */
1551 static int
1552generate_NEWLIST(cctx_T *cctx, int count)
1553{
1554 isn_T *isn;
1555 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001556 type_T *type;
1557 type_T *member;
1558
Bram Moolenaar080457c2020-03-03 21:53:32 +01001559 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001560 if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL)
1561 return FAIL;
1562 isn->isn_arg.number = count;
1563
Bram Moolenaar127542b2020-08-09 17:22:04 +02001564 // get the member type from all the items on the stack.
Bram Moolenaar9c2b0662020-09-01 19:56:15 +02001565 if (count == 0)
1566 member = &t_void;
1567 else
1568 member = get_member_type_from_stack(
Bram Moolenaar127542b2020-08-09 17:22:04 +02001569 ((type_T **)stack->ga_data) + stack->ga_len, count, 1,
1570 cctx->ctx_type_list);
1571 type = get_list_type(member, cctx->ctx_type_list);
1572
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001573 // drop the value types
1574 stack->ga_len -= count;
1575
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001576 // add the list type to the type stack
1577 if (ga_grow(stack, 1) == FAIL)
1578 return FAIL;
1579 ((type_T **)stack->ga_data)[stack->ga_len] = type;
1580 ++stack->ga_len;
1581
1582 return OK;
1583}
1584
1585/*
1586 * Generate an ISN_NEWDICT instruction.
1587 */
1588 static int
1589generate_NEWDICT(cctx_T *cctx, int count)
1590{
1591 isn_T *isn;
1592 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001593 type_T *type;
1594 type_T *member;
1595
Bram Moolenaar080457c2020-03-03 21:53:32 +01001596 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001597 if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL)
1598 return FAIL;
1599 isn->isn_arg.number = count;
1600
Bram Moolenaar9c2b0662020-09-01 19:56:15 +02001601 if (count == 0)
1602 member = &t_void;
1603 else
1604 member = get_member_type_from_stack(
Bram Moolenaar127542b2020-08-09 17:22:04 +02001605 ((type_T **)stack->ga_data) + stack->ga_len, count, 2,
1606 cctx->ctx_type_list);
1607 type = get_dict_type(member, cctx->ctx_type_list);
1608
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001609 // drop the key and value types
1610 stack->ga_len -= 2 * count;
1611
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001612 // add the dict type to the type stack
1613 if (ga_grow(stack, 1) == FAIL)
1614 return FAIL;
1615 ((type_T **)stack->ga_data)[stack->ga_len] = type;
1616 ++stack->ga_len;
1617
1618 return OK;
1619}
1620
1621/*
1622 * Generate an ISN_FUNCREF instruction.
1623 */
1624 static int
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001625generate_FUNCREF(cctx_T *cctx, ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001626{
1627 isn_T *isn;
1628 garray_T *stack = &cctx->ctx_type_stack;
1629
Bram Moolenaar080457c2020-03-03 21:53:32 +01001630 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001631 if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL)
1632 return FAIL;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001633 isn->isn_arg.funcref.fr_func = ufunc->uf_dfunc_idx;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02001634 cctx->ctx_has_closure = 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001635
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01001636 // If the referenced function is a closure, it may use items further up in
Bram Moolenaarab360522021-01-10 14:02:28 +01001637 // the nested context, including this one.
1638 if (ufunc->uf_flags & FC_CLOSURE)
1639 cctx->ctx_ufunc->uf_flags |= FC_CLOSURE;
1640
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001641 if (ga_grow(stack, 1) == FAIL)
1642 return FAIL;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001643 ((type_T **)stack->ga_data)[stack->ga_len] =
1644 ufunc->uf_func_type == NULL ? &t_func_any : ufunc->uf_func_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001645 ++stack->ga_len;
1646
1647 return OK;
1648}
1649
1650/*
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001651 * Generate an ISN_NEWFUNC instruction.
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001652 * "lambda_name" and "func_name" must be in allocated memory and will be
1653 * consumed.
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001654 */
1655 static int
1656generate_NEWFUNC(cctx_T *cctx, char_u *lambda_name, char_u *func_name)
1657{
1658 isn_T *isn;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001659
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001660 if (cctx->ctx_skip == SKIP_YES)
1661 {
1662 vim_free(lambda_name);
1663 vim_free(func_name);
1664 return OK;
1665 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001666 if ((isn = generate_instr(cctx, ISN_NEWFUNC)) == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001667 {
1668 vim_free(lambda_name);
1669 vim_free(func_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001670 return FAIL;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001671 }
1672 isn->isn_arg.newfunc.nf_lambda = lambda_name;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001673 isn->isn_arg.newfunc.nf_global = func_name;
1674
1675 return OK;
1676}
1677
1678/*
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001679 * Generate an ISN_DEF instruction: list functions
1680 */
1681 static int
1682generate_DEF(cctx_T *cctx, char_u *name, size_t len)
1683{
1684 isn_T *isn;
1685
1686 RETURN_OK_IF_SKIP(cctx);
1687 if ((isn = generate_instr(cctx, ISN_DEF)) == NULL)
1688 return FAIL;
1689 if (len > 0)
1690 {
1691 isn->isn_arg.string = vim_strnsave(name, len);
1692 if (isn->isn_arg.string == NULL)
1693 return FAIL;
1694 }
1695 return OK;
1696}
1697
1698/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001699 * Generate an ISN_JUMP instruction.
1700 */
1701 static int
1702generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where)
1703{
1704 isn_T *isn;
1705 garray_T *stack = &cctx->ctx_type_stack;
1706
Bram Moolenaar080457c2020-03-03 21:53:32 +01001707 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001708 if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL)
1709 return FAIL;
1710 isn->isn_arg.jump.jump_when = when;
1711 isn->isn_arg.jump.jump_where = where;
1712
1713 if (when != JUMP_ALWAYS && stack->ga_len > 0)
1714 --stack->ga_len;
1715
1716 return OK;
1717}
1718
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02001719/*
1720 * Generate an ISN_JUMP_IF_ARG_SET instruction.
1721 */
1722 static int
1723generate_JUMP_IF_ARG_SET(cctx_T *cctx, int arg_off)
1724{
1725 isn_T *isn;
1726
1727 RETURN_OK_IF_SKIP(cctx);
1728 if ((isn = generate_instr(cctx, ISN_JUMP_IF_ARG_SET)) == NULL)
1729 return FAIL;
1730 isn->isn_arg.jumparg.jump_arg_off = arg_off;
1731 // jump_where is set later
1732 return OK;
1733}
1734
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001735 static int
1736generate_FOR(cctx_T *cctx, int loop_idx)
1737{
1738 isn_T *isn;
1739 garray_T *stack = &cctx->ctx_type_stack;
1740
Bram Moolenaar080457c2020-03-03 21:53:32 +01001741 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001742 if ((isn = generate_instr(cctx, ISN_FOR)) == NULL)
1743 return FAIL;
1744 isn->isn_arg.forloop.for_idx = loop_idx;
1745
1746 if (ga_grow(stack, 1) == FAIL)
1747 return FAIL;
1748 // type doesn't matter, will be stored next
1749 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
1750 ++stack->ga_len;
1751
1752 return OK;
1753}
Bram Moolenaarc150c092021-02-13 15:02:46 +01001754/*
1755 * Generate an ISN_TRYCONT instruction.
1756 */
1757 static int
1758generate_TRYCONT(cctx_T *cctx, int levels, int where)
1759{
1760 isn_T *isn;
1761
1762 RETURN_OK_IF_SKIP(cctx);
1763 if ((isn = generate_instr(cctx, ISN_TRYCONT)) == NULL)
1764 return FAIL;
1765 isn->isn_arg.trycont.tct_levels = levels;
1766 isn->isn_arg.trycont.tct_where = where;
1767
1768 return OK;
1769}
1770
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001771
1772/*
1773 * Generate an ISN_BCALL instruction.
Bram Moolenaar389df252020-07-09 21:20:47 +02001774 * "method_call" is TRUE for "value->method()"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001775 * Return FAIL if the number of arguments is wrong.
1776 */
1777 static int
Bram Moolenaar389df252020-07-09 21:20:47 +02001778generate_BCALL(cctx_T *cctx, int func_idx, int argcount, int method_call)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001779{
1780 isn_T *isn;
1781 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar389df252020-07-09 21:20:47 +02001782 int argoff;
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001783 type_T **argtypes = NULL;
Bram Moolenaar52312242021-07-11 18:23:19 +02001784 type_T *shuffled_argtypes[MAX_FUNC_ARGS];
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001785 type_T *maptype = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001786
Bram Moolenaar080457c2020-03-03 21:53:32 +01001787 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar389df252020-07-09 21:20:47 +02001788 argoff = check_internal_func(func_idx, argcount);
1789 if (argoff < 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001790 return FAIL;
1791
Bram Moolenaar389df252020-07-09 21:20:47 +02001792 if (method_call && argoff > 1)
1793 {
1794 if ((isn = generate_instr(cctx, ISN_SHUFFLE)) == NULL)
1795 return FAIL;
1796 isn->isn_arg.shuffle.shfl_item = argcount;
1797 isn->isn_arg.shuffle.shfl_up = argoff - 1;
1798 }
1799
Bram Moolenaaraf7a9062020-10-21 16:49:17 +02001800 if (argcount > 0)
1801 {
1802 // Check the types of the arguments.
1803 argtypes = ((type_T **)stack->ga_data) + stack->ga_len - argcount;
Bram Moolenaar52312242021-07-11 18:23:19 +02001804 if (method_call && argoff > 1)
1805 {
1806 int i;
1807
1808 for (i = 0; i < argcount; ++i)
1809 shuffled_argtypes[i] = (i < argoff - 1)
1810 ? argtypes[i + 1]
1811 : (i == argoff - 1) ? argtypes[0] : argtypes[i];
1812 argtypes = shuffled_argtypes;
1813 }
Bram Moolenaar351ead02021-01-16 16:07:01 +01001814 if (internal_func_check_arg_types(argtypes, func_idx, argcount,
1815 cctx) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02001816 return FAIL;
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001817 if (internal_func_is_map(func_idx))
1818 maptype = *argtypes;
Bram Moolenaaraf7a9062020-10-21 16:49:17 +02001819 }
Bram Moolenaar94738d82020-10-21 14:25:07 +02001820
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001821 if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL)
1822 return FAIL;
1823 isn->isn_arg.bfunc.cbf_idx = func_idx;
1824 isn->isn_arg.bfunc.cbf_argcount = argcount;
1825
Bram Moolenaar94738d82020-10-21 14:25:07 +02001826 // Drop the argument types and push the return type.
1827 stack->ga_len -= argcount;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001828 if (ga_grow(stack, 1) == FAIL)
1829 return FAIL;
1830 ((type_T **)stack->ga_data)[stack->ga_len] =
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001831 internal_func_ret_type(func_idx, argcount, argtypes);
Bram Moolenaar94738d82020-10-21 14:25:07 +02001832 ++stack->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001833
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001834 if (maptype != NULL && maptype->tt_member != NULL
1835 && maptype->tt_member != &t_any)
1836 // Check that map() didn't change the item types.
Bram Moolenaare32e5162021-01-21 20:21:29 +01001837 generate_TYPECHECK(cctx, maptype, -1, 1);
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001838
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001839 return OK;
1840}
1841
1842/*
Bram Moolenaar1dcae592020-10-19 19:02:42 +02001843 * Generate an ISN_LISTAPPEND instruction. Works like add().
1844 * Argument count is already checked.
1845 */
1846 static int
1847generate_LISTAPPEND(cctx_T *cctx)
1848{
1849 garray_T *stack = &cctx->ctx_type_stack;
1850 type_T *list_type;
1851 type_T *item_type;
1852 type_T *expected;
1853
1854 // Caller already checked that list_type is a list.
1855 list_type = ((type_T **)stack->ga_data)[stack->ga_len - 2];
1856 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
1857 expected = list_type->tt_member;
Bram Moolenaar351ead02021-01-16 16:07:01 +01001858 if (need_type(item_type, expected, -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar1dcae592020-10-19 19:02:42 +02001859 return FAIL;
1860
1861 if (generate_instr(cctx, ISN_LISTAPPEND) == NULL)
1862 return FAIL;
1863
1864 --stack->ga_len; // drop the argument
1865 return OK;
1866}
1867
1868/*
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02001869 * Generate an ISN_BLOBAPPEND instruction. Works like add().
1870 * Argument count is already checked.
1871 */
1872 static int
1873generate_BLOBAPPEND(cctx_T *cctx)
1874{
1875 garray_T *stack = &cctx->ctx_type_stack;
1876 type_T *item_type;
1877
1878 // Caller already checked that blob_type is a blob.
1879 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar351ead02021-01-16 16:07:01 +01001880 if (need_type(item_type, &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02001881 return FAIL;
1882
1883 if (generate_instr(cctx, ISN_BLOBAPPEND) == NULL)
1884 return FAIL;
1885
1886 --stack->ga_len; // drop the argument
1887 return OK;
1888}
1889
1890/*
Bram Moolenaarb2049902021-01-24 12:53:53 +01001891 * Return TRUE if "ufunc" should be compiled, taking into account whether
1892 * "profile" indicates profiling is to be done.
1893 */
1894 int
Bram Moolenaare99d4222021-06-13 14:01:26 +02001895func_needs_compiling(ufunc_T *ufunc, compiletype_T compile_type)
Bram Moolenaarb2049902021-01-24 12:53:53 +01001896{
1897 switch (ufunc->uf_def_status)
1898 {
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02001899 case UF_TO_BE_COMPILED:
1900 return TRUE;
1901
Bram Moolenaarb2049902021-01-24 12:53:53 +01001902 case UF_COMPILED:
1903 {
1904 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
1905 + ufunc->uf_dfunc_idx;
1906
Bram Moolenaare99d4222021-06-13 14:01:26 +02001907 switch (compile_type)
1908 {
Bram Moolenaard9f31c12021-06-13 14:15:29 +02001909 case CT_PROFILE:
1910#ifdef FEAT_PROFILE
1911 return dfunc->df_instr_prof == NULL;
1912#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02001913 case CT_NONE:
1914 return dfunc->df_instr == NULL;
Bram Moolenaare99d4222021-06-13 14:01:26 +02001915 case CT_DEBUG:
1916 return dfunc->df_instr_debug == NULL;
1917 }
Bram Moolenaarb2049902021-01-24 12:53:53 +01001918 }
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02001919
1920 case UF_NOT_COMPILED:
1921 case UF_COMPILE_ERROR:
1922 case UF_COMPILING:
1923 break;
Bram Moolenaarb2049902021-01-24 12:53:53 +01001924 }
Bram Moolenaarf002a412021-01-24 13:34:18 +01001925 return FALSE;
Bram Moolenaarb2049902021-01-24 12:53:53 +01001926}
1927
1928/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001929 * Generate an ISN_DCALL or ISN_UCALL instruction.
1930 * Return FAIL if the number of arguments is wrong.
1931 */
1932 static int
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01001933generate_CALL(cctx_T *cctx, ufunc_T *ufunc, int pushed_argcount)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001934{
1935 isn_T *isn;
1936 garray_T *stack = &cctx->ctx_type_stack;
1937 int regular_args = ufunc->uf_args.ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01001938 int argcount = pushed_argcount;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001939
Bram Moolenaar080457c2020-03-03 21:53:32 +01001940 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001941 if (argcount > regular_args && !has_varargs(ufunc))
1942 {
Bram Moolenaarb185a402020-09-18 22:42:00 +02001943 semsg(_(e_toomanyarg), printable_func_name(ufunc));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001944 return FAIL;
1945 }
1946 if (argcount < regular_args - ufunc->uf_def_args.ga_len)
1947 {
Bram Moolenaarb185a402020-09-18 22:42:00 +02001948 semsg(_(e_toofewarg), printable_func_name(ufunc));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001949 return FAIL;
1950 }
1951
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02001952 if (ufunc->uf_def_status != UF_NOT_COMPILED
1953 && ufunc->uf_def_status != UF_COMPILE_ERROR)
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001954 {
1955 int i;
1956
1957 for (i = 0; i < argcount; ++i)
1958 {
1959 type_T *expected;
1960 type_T *actual;
1961
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02001962 actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
1963 if (actual == &t_special
1964 && i >= regular_args - ufunc->uf_def_args.ga_len)
1965 {
1966 // assume v:none used for default argument value
1967 continue;
1968 }
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001969 if (i < regular_args)
1970 {
1971 if (ufunc->uf_arg_types == NULL)
1972 continue;
1973 expected = ufunc->uf_arg_types[i];
1974 }
Bram Moolenaar2a389082021-04-09 20:24:31 +02001975 else if (ufunc->uf_va_type == NULL
1976 || ufunc->uf_va_type == &t_list_any)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001977 // possibly a lambda or "...: any"
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001978 expected = &t_any;
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001979 else
1980 expected = ufunc->uf_va_type->tt_member;
Bram Moolenaare32e5162021-01-21 20:21:29 +01001981 if (need_type(actual, expected, -argcount + i, i + 1, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001982 TRUE, FALSE) == FAIL)
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001983 {
1984 arg_type_mismatch(expected, actual, i + 1);
1985 return FAIL;
1986 }
1987 }
Bram Moolenaare99d4222021-06-13 14:01:26 +02001988 if (func_needs_compiling(ufunc, COMPILE_TYPE(ufunc))
Bram Moolenaarb2049902021-01-24 12:53:53 +01001989 && compile_def_function(ufunc, ufunc->uf_ret_type == NULL,
Bram Moolenaare99d4222021-06-13 14:01:26 +02001990 COMPILE_TYPE(ufunc), NULL) == FAIL)
Bram Moolenaarb2049902021-01-24 12:53:53 +01001991 return FAIL;
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001992 }
Bram Moolenaarb55d6182021-06-08 22:01:53 +02001993 if (ufunc->uf_def_status == UF_COMPILE_ERROR)
1994 {
1995 emsg_funcname(_(e_call_to_function_that_failed_to_compile_str),
1996 ufunc->uf_name);
1997 return FAIL;
1998 }
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001999
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002000 if ((isn = generate_instr(cctx,
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002001 ufunc->uf_def_status != UF_NOT_COMPILED ? ISN_DCALL
Bram Moolenaar822ba242020-05-24 23:00:18 +02002002 : ISN_UCALL)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002003 return FAIL;
Bram Moolenaara05e5242020-09-19 18:19:19 +02002004 if (isn->isn_type == ISN_DCALL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002005 {
2006 isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx;
2007 isn->isn_arg.dfunc.cdf_argcount = argcount;
2008 }
2009 else
2010 {
2011 // A user function may be deleted and redefined later, can't use the
2012 // ufunc pointer, need to look it up again at runtime.
2013 isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name);
2014 isn->isn_arg.ufunc.cuf_argcount = argcount;
2015 }
2016
2017 stack->ga_len -= argcount; // drop the arguments
2018 if (ga_grow(stack, 1) == FAIL)
2019 return FAIL;
2020 // add return value
2021 ((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type;
2022 ++stack->ga_len;
2023
2024 return OK;
2025}
2026
2027/*
2028 * Generate an ISN_UCALL instruction when the function isn't defined yet.
2029 */
2030 static int
2031generate_UCALL(cctx_T *cctx, char_u *name, int argcount)
2032{
2033 isn_T *isn;
2034 garray_T *stack = &cctx->ctx_type_stack;
2035
Bram Moolenaar080457c2020-03-03 21:53:32 +01002036 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002037 if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL)
2038 return FAIL;
2039 isn->isn_arg.ufunc.cuf_name = vim_strsave(name);
2040 isn->isn_arg.ufunc.cuf_argcount = argcount;
2041
2042 stack->ga_len -= argcount; // drop the arguments
Bram Moolenaar26e117e2020-02-04 21:24:15 +01002043 if (ga_grow(stack, 1) == FAIL)
2044 return FAIL;
2045 // add return value
2046 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
2047 ++stack->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002048
2049 return OK;
2050}
2051
2052/*
2053 * Generate an ISN_PCALL instruction.
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002054 * "type" is the type of the FuncRef.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002055 */
2056 static int
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002057generate_PCALL(
2058 cctx_T *cctx,
2059 int argcount,
2060 char_u *name,
2061 type_T *type,
2062 int at_top)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002063{
2064 isn_T *isn;
2065 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002066 type_T *ret_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002067
Bram Moolenaar080457c2020-03-03 21:53:32 +01002068 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02002069
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002070 if (type->tt_type == VAR_ANY)
2071 ret_type = &t_any;
2072 else if (type->tt_type == VAR_FUNC || type->tt_type == VAR_PARTIAL)
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02002073 {
2074 if (type->tt_argcount != -1)
2075 {
2076 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
2077
2078 if (argcount < type->tt_min_argcount - varargs)
2079 {
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01002080 semsg(_(e_toofewarg), name);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02002081 return FAIL;
2082 }
2083 if (!varargs && argcount > type->tt_argcount)
2084 {
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01002085 semsg(_(e_toomanyarg), name);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02002086 return FAIL;
2087 }
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01002088 if (type->tt_args != NULL)
2089 {
2090 int i;
2091
2092 for (i = 0; i < argcount; ++i)
2093 {
Bram Moolenaar1088b692021-04-09 22:12:44 +02002094 int offset = -argcount + i - (at_top ? 0 : 1);
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01002095 type_T *actual = ((type_T **)stack->ga_data)[
2096 stack->ga_len + offset];
2097 type_T *expected;
2098
Bram Moolenaar32b3f822021-01-06 21:59:39 +01002099 if (varargs && i >= type->tt_argcount - 1)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01002100 expected = type->tt_args[
Bram Moolenaar32b3f822021-01-06 21:59:39 +01002101 type->tt_argcount - 1]->tt_member;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02002102 else if (i >= type->tt_min_argcount
2103 && actual == &t_special)
2104 expected = &t_any;
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01002105 else
2106 expected = type->tt_args[i];
Bram Moolenaare32e5162021-01-21 20:21:29 +01002107 if (need_type(actual, expected, offset, i + 1,
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01002108 cctx, TRUE, FALSE) == FAIL)
2109 {
2110 arg_type_mismatch(expected, actual, i + 1);
2111 return FAIL;
2112 }
2113 }
2114 }
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02002115 }
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002116 ret_type = type->tt_member;
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02002117 }
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002118 else
2119 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002120 semsg(_(e_not_callable_type_str), name);
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002121 return FAIL;
2122 }
2123
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002124 if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL)
2125 return FAIL;
2126 isn->isn_arg.pfunc.cpf_top = at_top;
2127 isn->isn_arg.pfunc.cpf_argcount = argcount;
2128
2129 stack->ga_len -= argcount; // drop the arguments
2130
2131 // drop the funcref/partial, get back the return value
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002132 ((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002133
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002134 // If partial is above the arguments it must be cleared and replaced with
2135 // the return value.
2136 if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL)
2137 return FAIL;
2138
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002139 return OK;
2140}
2141
2142/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002143 * Generate an ISN_STRINGMEMBER instruction.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002144 */
2145 static int
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002146generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002147{
2148 isn_T *isn;
2149 garray_T *stack = &cctx->ctx_type_stack;
2150 type_T *type;
2151
Bram Moolenaar080457c2020-03-03 21:53:32 +01002152 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002153 if ((isn = generate_instr(cctx, ISN_STRINGMEMBER)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002154 return FAIL;
Bram Moolenaar71ccd032020-06-12 22:59:11 +02002155 isn->isn_arg.string = vim_strnsave(name, len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002156
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002157 // check for dict type
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002158 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002159 if (type->tt_type != VAR_DICT && type != &t_any)
2160 {
2161 emsg(_(e_dictreq));
2162 return FAIL;
2163 }
2164 // change dict type to dict member type
2165 if (type->tt_type == VAR_DICT)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01002166 {
2167 ((type_T **)stack->ga_data)[stack->ga_len - 1] =
2168 type->tt_member == &t_unknown ? &t_any : type->tt_member;
2169 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002170
2171 return OK;
2172}
2173
2174/*
2175 * Generate an ISN_ECHO instruction.
2176 */
2177 static int
2178generate_ECHO(cctx_T *cctx, int with_white, int count)
2179{
2180 isn_T *isn;
2181
Bram Moolenaar080457c2020-03-03 21:53:32 +01002182 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002183 if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL)
2184 return FAIL;
2185 isn->isn_arg.echo.echo_with_white = with_white;
2186 isn->isn_arg.echo.echo_count = count;
2187
2188 return OK;
2189}
2190
Bram Moolenaarad39c092020-02-26 18:23:43 +01002191/*
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002192 * Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction.
Bram Moolenaarad39c092020-02-26 18:23:43 +01002193 */
2194 static int
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002195generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count)
Bram Moolenaarad39c092020-02-26 18:23:43 +01002196{
2197 isn_T *isn;
2198
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002199 if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL)
Bram Moolenaarad39c092020-02-26 18:23:43 +01002200 return FAIL;
2201 isn->isn_arg.number = count;
2202
2203 return OK;
2204}
2205
Bram Moolenaarc3516f72020-09-08 22:45:35 +02002206/*
2207 * Generate an ISN_PUT instruction.
2208 */
2209 static int
2210generate_PUT(cctx_T *cctx, int regname, linenr_T lnum)
2211{
2212 isn_T *isn;
2213
2214 RETURN_OK_IF_SKIP(cctx);
2215 if ((isn = generate_instr(cctx, ISN_PUT)) == NULL)
2216 return FAIL;
2217 isn->isn_arg.put.put_regname = regname;
2218 isn->isn_arg.put.put_lnum = lnum;
2219 return OK;
2220}
2221
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002222 static int
2223generate_EXEC(cctx_T *cctx, char_u *line)
2224{
2225 isn_T *isn;
2226
Bram Moolenaar080457c2020-03-03 21:53:32 +01002227 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002228 if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL)
2229 return FAIL;
2230 isn->isn_arg.string = vim_strsave(line);
2231 return OK;
2232}
2233
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02002234 static int
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002235generate_LEGACY_EVAL(cctx_T *cctx, char_u *line)
2236{
2237 isn_T *isn;
2238 garray_T *stack = &cctx->ctx_type_stack;
2239
2240 RETURN_OK_IF_SKIP(cctx);
2241 if ((isn = generate_instr(cctx, ISN_LEGACY_EVAL)) == NULL)
2242 return FAIL;
2243 isn->isn_arg.string = vim_strsave(line);
2244
2245 if (ga_grow(stack, 1) == FAIL)
2246 return FAIL;
2247 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
2248 ++stack->ga_len;
2249
2250 return OK;
2251}
2252
2253 static int
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02002254generate_EXECCONCAT(cctx_T *cctx, int count)
2255{
2256 isn_T *isn;
2257
2258 if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL)
2259 return FAIL;
2260 isn->isn_arg.number = count;
2261 return OK;
2262}
2263
Bram Moolenaar08597872020-12-10 19:43:40 +01002264/*
2265 * Generate ISN_RANGE. Consumes "range". Return OK/FAIL.
2266 */
2267 static int
2268generate_RANGE(cctx_T *cctx, char_u *range)
2269{
2270 isn_T *isn;
2271 garray_T *stack = &cctx->ctx_type_stack;
2272
2273 if ((isn = generate_instr(cctx, ISN_RANGE)) == NULL)
2274 return FAIL;
2275 isn->isn_arg.string = range;
2276
2277 if (ga_grow(stack, 1) == FAIL)
2278 return FAIL;
2279 ((type_T **)stack->ga_data)[stack->ga_len] = &t_number;
2280 ++stack->ga_len;
2281 return OK;
2282}
2283
Bram Moolenaar792f7862020-11-23 08:31:18 +01002284 static int
2285generate_UNPACK(cctx_T *cctx, int var_count, int semicolon)
2286{
2287 isn_T *isn;
2288
2289 RETURN_OK_IF_SKIP(cctx);
2290 if ((isn = generate_instr(cctx, ISN_UNPACK)) == NULL)
2291 return FAIL;
2292 isn->isn_arg.unpack.unp_count = var_count;
2293 isn->isn_arg.unpack.unp_semicolon = semicolon;
2294 return OK;
2295}
2296
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002297/*
Bram Moolenaar02194d22020-10-24 23:08:38 +02002298 * Generate an instruction for any command modifiers.
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002299 */
2300 static int
Bram Moolenaare1004402020-10-24 20:49:43 +02002301generate_cmdmods(cctx_T *cctx, cmdmod_T *cmod)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002302{
2303 isn_T *isn;
2304
Bram Moolenaarfa984412021-03-25 22:15:28 +01002305 if (has_cmdmod(cmod))
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002306 {
Bram Moolenaar02194d22020-10-24 23:08:38 +02002307 cctx->ctx_has_cmdmod = TRUE;
2308
2309 if ((isn = generate_instr(cctx, ISN_CMDMOD)) == NULL)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002310 return FAIL;
Bram Moolenaar02194d22020-10-24 23:08:38 +02002311 isn->isn_arg.cmdmod.cf_cmdmod = ALLOC_ONE(cmdmod_T);
2312 if (isn->isn_arg.cmdmod.cf_cmdmod == NULL)
2313 return FAIL;
2314 mch_memmove(isn->isn_arg.cmdmod.cf_cmdmod, cmod, sizeof(cmdmod_T));
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01002315 // filter program now belongs to the instruction
Bram Moolenaar02194d22020-10-24 23:08:38 +02002316 cmod->cmod_filter_regmatch.regprog = NULL;
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002317 }
Bram Moolenaar02194d22020-10-24 23:08:38 +02002318
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002319 return OK;
2320}
2321
2322 static int
Bram Moolenaar02194d22020-10-24 23:08:38 +02002323generate_undo_cmdmods(cctx_T *cctx)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002324{
Bram Moolenaarf665e972020-12-05 19:17:16 +01002325 if (cctx->ctx_has_cmdmod && generate_instr(cctx, ISN_CMDMOD_REV) == NULL)
2326 return FAIL;
Bram Moolenaar7cd24222021-01-12 18:58:39 +01002327 cctx->ctx_has_cmdmod = FALSE;
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002328 return OK;
2329}
2330
Bram Moolenaarfa984412021-03-25 22:15:28 +01002331 static int
2332misplaced_cmdmod(cctx_T *cctx)
Bram Moolenaara91a7132021-03-25 21:12:15 +01002333{
2334 garray_T *instr = &cctx->ctx_instr;
2335
Bram Moolenaara91a7132021-03-25 21:12:15 +01002336 if (cctx->ctx_has_cmdmod
2337 && ((isn_T *)instr->ga_data)[instr->ga_len - 1].isn_type
2338 == ISN_CMDMOD)
2339 {
Bram Moolenaarfa984412021-03-25 22:15:28 +01002340 emsg(_(e_misplaced_command_modifier));
2341 return TRUE;
Bram Moolenaara91a7132021-03-25 21:12:15 +01002342 }
Bram Moolenaarfa984412021-03-25 22:15:28 +01002343 return FALSE;
Bram Moolenaara91a7132021-03-25 21:12:15 +01002344}
2345
2346/*
2347 * Get the index of the current instruction.
2348 * This compenstates for a preceding ISN_CMDMOD and ISN_PROF_START.
2349 */
2350 static int
2351current_instr_idx(cctx_T *cctx)
2352{
2353 garray_T *instr = &cctx->ctx_instr;
2354 int idx = instr->ga_len;
2355
Bram Moolenaare99d4222021-06-13 14:01:26 +02002356 while (idx > 0)
2357 {
2358 if (cctx->ctx_has_cmdmod && ((isn_T *)instr->ga_data)[idx - 1]
Bram Moolenaara91a7132021-03-25 21:12:15 +01002359 .isn_type == ISN_CMDMOD)
Bram Moolenaare99d4222021-06-13 14:01:26 +02002360 {
2361 --idx;
2362 continue;
2363 }
Bram Moolenaara91a7132021-03-25 21:12:15 +01002364#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02002365 if (((isn_T *)instr->ga_data)[idx - 1].isn_type == ISN_PROF_START)
2366 {
2367 --idx;
2368 continue;
2369 }
Bram Moolenaara91a7132021-03-25 21:12:15 +01002370#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02002371 if (((isn_T *)instr->ga_data)[idx - 1].isn_type == ISN_DEBUG)
2372 {
2373 --idx;
2374 continue;
2375 }
2376 break;
2377 }
Bram Moolenaara91a7132021-03-25 21:12:15 +01002378 return idx;
2379}
2380
Bram Moolenaarf002a412021-01-24 13:34:18 +01002381#ifdef FEAT_PROFILE
Bram Moolenaarb2049902021-01-24 12:53:53 +01002382 static void
2383may_generate_prof_end(cctx_T *cctx, int prof_lnum)
2384{
Bram Moolenaare99d4222021-06-13 14:01:26 +02002385 if (cctx->ctx_compile_type == CT_PROFILE && prof_lnum >= 0)
Bram Moolenaarb2049902021-01-24 12:53:53 +01002386 generate_instr(cctx, ISN_PROF_END);
Bram Moolenaarb2049902021-01-24 12:53:53 +01002387}
Bram Moolenaarf002a412021-01-24 13:34:18 +01002388#endif
Bram Moolenaarb2049902021-01-24 12:53:53 +01002389
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002390/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002391 * Reserve space for a local variable.
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002392 * Return the variable or NULL if it failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002393 */
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002394 static lvar_T *
Bram Moolenaare8211a32020-10-09 22:04:29 +02002395reserve_local(
2396 cctx_T *cctx,
2397 char_u *name,
2398 size_t len,
2399 int isConst,
2400 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002401{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002402 lvar_T *lvar;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002403 dfunc_T *dfunc;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002404
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002405 if (arg_exists(name, len, NULL, NULL, NULL, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002406 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002407 emsg_namelen(_(e_str_is_used_as_argument), name, (int)len);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002408 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002409 }
2410
2411 if (ga_grow(&cctx->ctx_locals, 1) == FAIL)
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002412 return NULL;
2413 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
Bram Moolenaare8211a32020-10-09 22:04:29 +02002414 CLEAR_POINTER(lvar);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002415
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002416 // Every local variable uses the next entry on the stack. We could re-use
2417 // the last ones when leaving a scope, but then variables used in a closure
2418 // might get overwritten. To keep things simple do not re-use stack
2419 // entries. This is less efficient, but memory is cheap these days.
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002420 dfunc = ((dfunc_T *)def_functions.ga_data) + cctx->ctx_ufunc->uf_dfunc_idx;
2421 lvar->lv_idx = dfunc->df_var_names.ga_len;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002422
Bram Moolenaar71ccd032020-06-12 22:59:11 +02002423 lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002424 lvar->lv_const = isConst;
2425 lvar->lv_type = type;
2426
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002427 // Remember the name for debugging.
2428 if (ga_grow(&dfunc->df_var_names, 1) == FAIL)
2429 return NULL;
2430 ((char_u **)dfunc->df_var_names.ga_data)[lvar->lv_idx] =
2431 vim_strsave(lvar->lv_name);
2432 ++dfunc->df_var_names.ga_len;
2433
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002434 return lvar;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002435}
2436
2437/*
Bram Moolenaar20431c92020-03-20 18:39:46 +01002438 * Remove local variables above "new_top".
2439 */
2440 static void
2441unwind_locals(cctx_T *cctx, int new_top)
2442{
2443 if (cctx->ctx_locals.ga_len > new_top)
2444 {
2445 int idx;
2446 lvar_T *lvar;
2447
2448 for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx)
2449 {
2450 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
2451 vim_free(lvar->lv_name);
2452 }
2453 }
2454 cctx->ctx_locals.ga_len = new_top;
2455}
2456
2457/*
2458 * Free all local variables.
2459 */
2460 static void
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002461free_locals(cctx_T *cctx)
Bram Moolenaar20431c92020-03-20 18:39:46 +01002462{
2463 unwind_locals(cctx, 0);
2464 ga_clear(&cctx->ctx_locals);
2465}
2466
2467/*
Bram Moolenaar08251752021-01-11 21:20:18 +01002468 * If "check_writable" is ASSIGN_CONST give an error if the variable was
2469 * defined with :final or :const, if "check_writable" is ASSIGN_FINAL give an
2470 * error if the variable was defined with :const.
2471 */
2472 static int
2473check_item_writable(svar_T *sv, int check_writable, char_u *name)
2474{
2475 if ((check_writable == ASSIGN_CONST && sv->sv_const != 0)
2476 || (check_writable == ASSIGN_FINAL
2477 && sv->sv_const == ASSIGN_CONST))
2478 {
Bram Moolenaard8e44472021-07-21 22:20:33 +02002479 semsg(_(e_cannot_change_readonly_variable_str), name);
Bram Moolenaar08251752021-01-11 21:20:18 +01002480 return FAIL;
2481 }
2482 return OK;
2483}
2484
2485/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002486 * Find "name" in script-local items of script "sid".
Bram Moolenaar08251752021-01-11 21:20:18 +01002487 * Pass "check_writable" to check_item_writable().
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002488 * Returns the index in "sn_var_vals" if found.
2489 * If found but not in "sn_var_vals" returns -1.
Bram Moolenaar08251752021-01-11 21:20:18 +01002490 * If not found or the variable is not writable returns -2.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002491 */
2492 int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002493get_script_item_idx(int sid, char_u *name, int check_writable, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002494{
2495 hashtab_T *ht;
2496 dictitem_T *di;
Bram Moolenaar21b9e972020-01-26 19:26:46 +01002497 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002498 svar_T *sv;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002499 int idx;
2500
Bram Moolenaare3d46852020-08-29 13:39:17 +02002501 if (!SCRIPT_ID_VALID(sid))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002502 return -1;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002503 if (sid == current_sctx.sc_sid)
2504 {
Bram Moolenaar209f0202020-10-15 13:57:56 +02002505 sallvar_T *sav = find_script_var(name, 0, cctx);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002506
2507 if (sav == NULL)
2508 return -2;
2509 idx = sav->sav_var_vals_idx;
2510 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar08251752021-01-11 21:20:18 +01002511 if (check_item_writable(sv, check_writable, name) == FAIL)
2512 return -2;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002513 return idx;
2514 }
2515
2516 // First look the name up in the hashtable.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002517 ht = &SCRIPT_VARS(sid);
2518 di = find_var_in_ht(ht, 0, name, TRUE);
2519 if (di == NULL)
2520 return -2;
2521
2522 // Now find the svar_T index in sn_var_vals.
2523 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
2524 {
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002525 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002526 if (sv->sv_tv == &di->di_tv)
2527 {
Bram Moolenaar08251752021-01-11 21:20:18 +01002528 if (check_item_writable(sv, check_writable, name) == FAIL)
2529 return -2;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002530 return idx;
2531 }
2532 }
2533 return -1;
2534}
2535
2536/*
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002537 * Find "name" in imported items of the current script or in "cctx" if not
2538 * NULL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002539 */
2540 imported_T *
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002541find_imported(char_u *name, size_t len, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002542{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002543 int idx;
2544
Bram Moolenaare3d46852020-08-29 13:39:17 +02002545 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
Bram Moolenaar8e6cbb72020-07-01 14:38:12 +02002546 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002547 if (cctx != NULL)
2548 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
2549 {
2550 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data)
2551 + idx;
2552
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002553 if (len == 0 ? STRCMP(name, import->imp_name) == 0
2554 : STRLEN(import->imp_name) == len
2555 && STRNCMP(name, import->imp_name, len) == 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002556 return import;
2557 }
2558
Bram Moolenaarefa94442020-08-08 22:16:00 +02002559 return find_imported_in_script(name, len, current_sctx.sc_sid);
2560}
2561
2562 imported_T *
2563find_imported_in_script(char_u *name, size_t len, int sid)
2564{
Bram Moolenaare3d46852020-08-29 13:39:17 +02002565 scriptitem_T *si;
Bram Moolenaarefa94442020-08-08 22:16:00 +02002566 int idx;
2567
Bram Moolenaare3d46852020-08-29 13:39:17 +02002568 if (!SCRIPT_ID_VALID(sid))
2569 return NULL;
2570 si = SCRIPT_ITEM(sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002571 for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
2572 {
2573 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx;
2574
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002575 if (len == 0 ? STRCMP(name, import->imp_name) == 0
2576 : STRLEN(import->imp_name) == len
2577 && STRNCMP(name, import->imp_name, len) == 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002578 return import;
2579 }
2580 return NULL;
2581}
2582
2583/*
Bram Moolenaar20431c92020-03-20 18:39:46 +01002584 * Free all imported variables.
2585 */
2586 static void
2587free_imported(cctx_T *cctx)
2588{
2589 int idx;
2590
2591 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
2592 {
2593 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) + idx;
2594
2595 vim_free(import->imp_name);
2596 }
2597 ga_clear(&cctx->ctx_imports);
2598}
2599
2600/*
Bram Moolenaar23c55272020-06-21 16:58:13 +02002601 * Return a pointer to the next line that isn't empty or only contains a
2602 * comment. Skips over white space.
2603 * Returns NULL if there is none.
2604 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002605 char_u *
2606peek_next_line_from_context(cctx_T *cctx)
Bram Moolenaar23c55272020-06-21 16:58:13 +02002607{
2608 int lnum = cctx->ctx_lnum;
2609
2610 while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len)
2611 {
2612 char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum];
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002613 char_u *p;
Bram Moolenaar23c55272020-06-21 16:58:13 +02002614
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002615 // ignore NULLs inserted for continuation lines
2616 if (line != NULL)
2617 {
2618 p = skipwhite(line);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01002619 if (vim9_bad_comment(p))
2620 return NULL;
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002621 if (*p != NUL && !vim9_comment_start(p))
2622 return p;
2623 }
Bram Moolenaar23c55272020-06-21 16:58:13 +02002624 }
2625 return NULL;
2626}
2627
2628/*
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002629 * Called when checking for a following operator at "arg". When the rest of
2630 * the line is empty or only a comment, peek the next line. If there is a next
2631 * line return a pointer to it and set "nextp".
2632 * Otherwise skip over white space.
2633 */
2634 static char_u *
2635may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp)
2636{
2637 char_u *p = skipwhite(arg);
2638
2639 *nextp = NULL;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002640 if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p)))
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002641 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002642 *nextp = peek_next_line_from_context(cctx);
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002643 if (*nextp != NULL)
2644 return *nextp;
2645 }
2646 return p;
2647}
2648
2649/*
Bram Moolenaare6085c52020-04-12 20:19:16 +02002650 * Get the next line of the function from "cctx".
Bram Moolenaar23c55272020-06-21 16:58:13 +02002651 * Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE.
Bram Moolenaare6085c52020-04-12 20:19:16 +02002652 * Returns NULL when at the end.
2653 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002654 char_u *
Bram Moolenaar23c55272020-06-21 16:58:13 +02002655next_line_from_context(cctx_T *cctx, int skip_comment)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002656{
Bram Moolenaar7a092242020-04-16 22:10:49 +02002657 char_u *line;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002658
2659 do
2660 {
2661 ++cctx->ctx_lnum;
2662 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
Bram Moolenaar7a092242020-04-16 22:10:49 +02002663 {
2664 line = NULL;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002665 break;
Bram Moolenaar7a092242020-04-16 22:10:49 +02002666 }
Bram Moolenaare6085c52020-04-12 20:19:16 +02002667 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
Bram Moolenaar7a092242020-04-16 22:10:49 +02002668 cctx->ctx_line_start = line;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002669 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar23c55272020-06-21 16:58:13 +02002670 } while (line == NULL || *skipwhite(line) == NUL
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002671 || (skip_comment && vim9_comment_start(skipwhite(line))));
Bram Moolenaare6085c52020-04-12 20:19:16 +02002672 return line;
2673}
2674
2675/*
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002676 * Skip over white space at "whitep" and assign to "*arg".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002677 * If "*arg" is at the end of the line, advance to the next line.
Bram Moolenaar2c330432020-04-13 14:41:35 +02002678 * Also when "whitep" points to white space and "*arg" is on a "#".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002679 * Return FAIL if beyond the last line, "*arg" is unmodified then.
2680 */
2681 static int
Bram Moolenaar2c330432020-04-13 14:41:35 +02002682may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002683{
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002684 *arg = skipwhite(whitep);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01002685 if (vim9_bad_comment(*arg))
2686 return FAIL;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002687 if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg)))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002688 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002689 char_u *next = next_line_from_context(cctx, TRUE);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002690
2691 if (next == NULL)
2692 return FAIL;
2693 *arg = skipwhite(next);
2694 }
2695 return OK;
2696}
2697
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002698/*
2699 * Idem, and give an error when failed.
2700 */
2701 static int
2702may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx)
2703{
2704 if (may_get_next_line(whitep, arg, cctx) == FAIL)
2705 {
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002706 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002707 emsg(_(e_line_incomplete));
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002708 return FAIL;
2709 }
2710 return OK;
2711}
2712
2713
Bram Moolenaara5565e42020-05-09 15:44:01 +02002714// Structure passed between the compile_expr* functions to keep track of
2715// constants that have been parsed but for which no code was produced yet. If
2716// possible expressions on these constants are applied at compile time. If
2717// that is not possible, the code to push the constants needs to be generated
2718// before other instructions.
Bram Moolenaar1c747212020-05-09 18:28:34 +02002719// Using 50 should be more than enough of 5 levels of ().
2720#define PPSIZE 50
Bram Moolenaara5565e42020-05-09 15:44:01 +02002721typedef struct {
Bram Moolenaar1c747212020-05-09 18:28:34 +02002722 typval_T pp_tv[PPSIZE]; // stack of ppconst constants
Bram Moolenaara5565e42020-05-09 15:44:01 +02002723 int pp_used; // active entries in pp_tv[]
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002724 int pp_is_const; // all generated code was constants, used for a
2725 // list or dict with constant members
Bram Moolenaara5565e42020-05-09 15:44:01 +02002726} ppconst_T;
2727
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002728static int compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const);
Bram Moolenaar1c747212020-05-09 18:28:34 +02002729static int compile_expr0(char_u **arg, cctx_T *cctx);
2730static int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
2731
Bram Moolenaara5565e42020-05-09 15:44:01 +02002732/*
2733 * Generate a PUSH instruction for "tv".
2734 * "tv" will be consumed or cleared.
2735 * Nothing happens if "tv" is NULL or of type VAR_UNKNOWN;
2736 */
2737 static int
2738generate_tv_PUSH(cctx_T *cctx, typval_T *tv)
2739{
2740 if (tv != NULL)
2741 {
2742 switch (tv->v_type)
2743 {
2744 case VAR_UNKNOWN:
2745 break;
2746 case VAR_BOOL:
2747 generate_PUSHBOOL(cctx, tv->vval.v_number);
2748 break;
2749 case VAR_SPECIAL:
2750 generate_PUSHSPEC(cctx, tv->vval.v_number);
2751 break;
2752 case VAR_NUMBER:
2753 generate_PUSHNR(cctx, tv->vval.v_number);
2754 break;
2755#ifdef FEAT_FLOAT
2756 case VAR_FLOAT:
2757 generate_PUSHF(cctx, tv->vval.v_float);
2758 break;
2759#endif
2760 case VAR_BLOB:
2761 generate_PUSHBLOB(cctx, tv->vval.v_blob);
2762 tv->vval.v_blob = NULL;
2763 break;
2764 case VAR_STRING:
2765 generate_PUSHS(cctx, tv->vval.v_string);
2766 tv->vval.v_string = NULL;
2767 break;
2768 default:
2769 iemsg("constant type not supported");
2770 clear_tv(tv);
2771 return FAIL;
2772 }
2773 tv->v_type = VAR_UNKNOWN;
2774 }
2775 return OK;
2776}
2777
2778/*
2779 * Generate code for any ppconst entries.
2780 */
2781 static int
2782generate_ppconst(cctx_T *cctx, ppconst_T *ppconst)
2783{
2784 int i;
2785 int ret = OK;
Bram Moolenaar497f76b2020-05-09 16:44:22 +02002786 int save_skip = cctx->ctx_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002787
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002788 cctx->ctx_skip = SKIP_NOT;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002789 for (i = 0; i < ppconst->pp_used; ++i)
2790 if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL)
2791 ret = FAIL;
2792 ppconst->pp_used = 0;
Bram Moolenaar497f76b2020-05-09 16:44:22 +02002793 cctx->ctx_skip = save_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002794 return ret;
2795}
2796
2797/*
Bram Moolenaar05bd9782021-07-21 21:37:28 +02002798 * Check that the last item of "ppconst" is a bool.
2799 */
2800 static int
2801check_ppconst_bool(ppconst_T *ppconst)
2802{
2803 if (ppconst->pp_used > 0)
2804 {
2805 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used - 1];
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02002806 where_T where = WHERE_INIT;
Bram Moolenaar05bd9782021-07-21 21:37:28 +02002807
Bram Moolenaar05bd9782021-07-21 21:37:28 +02002808 return check_typval_type(&t_bool, tv, where);
2809 }
2810 return OK;
2811}
2812
2813/*
Bram Moolenaara5565e42020-05-09 15:44:01 +02002814 * Clear ppconst constants. Used when failing.
2815 */
2816 static void
2817clear_ppconst(ppconst_T *ppconst)
2818{
2819 int i;
2820
2821 for (i = 0; i < ppconst->pp_used; ++i)
2822 clear_tv(&ppconst->pp_tv[i]);
2823 ppconst->pp_used = 0;
2824}
2825
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002826/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02002827 * Compile getting a member from a list/dict/string/blob. Stack has the
Bram Moolenaar261417b2021-05-06 21:04:55 +02002828 * indexable value and the index or the two indexes of a slice.
Bram Moolenaare42939a2021-04-05 17:11:17 +02002829 */
2830 static int
2831compile_member(int is_slice, cctx_T *cctx)
2832{
2833 type_T **typep;
2834 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar261417b2021-05-06 21:04:55 +02002835 vartype_T vartype;
2836 type_T *idxtype;
Bram Moolenaare42939a2021-04-05 17:11:17 +02002837
Bram Moolenaar261417b2021-05-06 21:04:55 +02002838 // We can index a list, dict and blob. If we don't know the type
2839 // we can use the index value type. If we still don't know use an "ANY"
2840 // instruction.
Bram Moolenaare42939a2021-04-05 17:11:17 +02002841 typep = ((type_T **)stack->ga_data) + stack->ga_len
2842 - (is_slice ? 3 : 2);
Bram Moolenaar261417b2021-05-06 21:04:55 +02002843 vartype = (*typep)->tt_type;
2844 idxtype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaare42939a2021-04-05 17:11:17 +02002845 // If the index is a string, the variable must be a Dict.
Bram Moolenaar261417b2021-05-06 21:04:55 +02002846 if (*typep == &t_any && idxtype == &t_string)
2847 vartype = VAR_DICT;
2848 if (vartype == VAR_STRING || vartype == VAR_LIST || vartype == VAR_BLOB)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002849 {
Bram Moolenaar261417b2021-05-06 21:04:55 +02002850 if (need_type(idxtype, &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002851 return FAIL;
2852 if (is_slice)
2853 {
Bram Moolenaar261417b2021-05-06 21:04:55 +02002854 idxtype = ((type_T **)stack->ga_data)[stack->ga_len - 2];
2855 if (need_type(idxtype, &t_number, -2, 0, cctx,
Bram Moolenaare42939a2021-04-05 17:11:17 +02002856 FALSE, FALSE) == FAIL)
2857 return FAIL;
2858 }
2859 }
2860
Bram Moolenaar261417b2021-05-06 21:04:55 +02002861 if (vartype == VAR_DICT)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002862 {
2863 if (is_slice)
2864 {
2865 emsg(_(e_cannot_slice_dictionary));
2866 return FAIL;
2867 }
2868 if ((*typep)->tt_type == VAR_DICT)
2869 {
2870 *typep = (*typep)->tt_member;
2871 if (*typep == &t_unknown)
2872 // empty dict was used
2873 *typep = &t_any;
2874 }
2875 else
2876 {
2877 if (need_type(*typep, &t_dict_any, -2, 0, cctx,
2878 FALSE, FALSE) == FAIL)
2879 return FAIL;
2880 *typep = &t_any;
2881 }
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002882 if (may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002883 return FAIL;
2884 if (generate_instr_drop(cctx, ISN_MEMBER, 1) == FAIL)
2885 return FAIL;
2886 }
Bram Moolenaar261417b2021-05-06 21:04:55 +02002887 else if (vartype == VAR_STRING)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002888 {
2889 *typep = &t_string;
2890 if ((is_slice
2891 ? generate_instr_drop(cctx, ISN_STRSLICE, 2)
2892 : generate_instr_drop(cctx, ISN_STRINDEX, 1)) == FAIL)
2893 return FAIL;
2894 }
Bram Moolenaar261417b2021-05-06 21:04:55 +02002895 else if (vartype == VAR_BLOB)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002896 {
Bram Moolenaarcfc30232021-04-11 20:26:34 +02002897 if (is_slice)
2898 {
2899 *typep = &t_blob;
2900 if (generate_instr_drop(cctx, ISN_BLOBSLICE, 2) == FAIL)
2901 return FAIL;
2902 }
2903 else
2904 {
2905 *typep = &t_number;
2906 if (generate_instr_drop(cctx, ISN_BLOBINDEX, 1) == FAIL)
2907 return FAIL;
2908 }
Bram Moolenaare42939a2021-04-05 17:11:17 +02002909 }
Bram Moolenaar261417b2021-05-06 21:04:55 +02002910 else if (vartype == VAR_LIST || *typep == &t_any)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002911 {
2912 if (is_slice)
2913 {
2914 if (generate_instr_drop(cctx,
Bram Moolenaar261417b2021-05-06 21:04:55 +02002915 vartype == VAR_LIST ? ISN_LISTSLICE : ISN_ANYSLICE,
Bram Moolenaare42939a2021-04-05 17:11:17 +02002916 2) == FAIL)
2917 return FAIL;
2918 }
2919 else
2920 {
2921 if ((*typep)->tt_type == VAR_LIST)
2922 {
2923 *typep = (*typep)->tt_member;
2924 if (*typep == &t_unknown)
2925 // empty list was used
2926 *typep = &t_any;
2927 }
2928 if (generate_instr_drop(cctx,
Bram Moolenaar261417b2021-05-06 21:04:55 +02002929 vartype == VAR_LIST ? ISN_LISTINDEX : ISN_ANYINDEX, 1)
2930 == FAIL)
Bram Moolenaare42939a2021-04-05 17:11:17 +02002931 return FAIL;
2932 }
2933 }
2934 else
2935 {
2936 emsg(_(e_string_list_dict_or_blob_required));
2937 return FAIL;
2938 }
2939 return OK;
2940}
2941
2942/*
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002943 * Generate an instruction to load script-local variable "name", without the
2944 * leading "s:".
2945 * Also finds imported variables.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002946 */
2947 static int
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002948compile_load_scriptvar(
2949 cctx_T *cctx,
2950 char_u *name, // variable NUL terminated
2951 char_u *start, // start of variable
Bram Moolenaarb35efa52020-02-26 20:15:18 +01002952 char_u **end, // end of variable
2953 int error) // when TRUE may give error
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002954{
Bram Moolenaare3d46852020-08-29 13:39:17 +02002955 scriptitem_T *si;
2956 int idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002957 imported_T *import;
2958
Bram Moolenaare3d46852020-08-29 13:39:17 +02002959 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
2960 return FAIL;
2961 si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar08251752021-01-11 21:20:18 +01002962 idx = get_script_item_idx(current_sctx.sc_sid, name, 0, cctx);
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002963 if (idx == -1 || si->sn_version != SCRIPT_VERSION_VIM9)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002964 {
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002965 // variable is not in sn_var_vals: old style script.
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01002966 return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid,
2967 &t_any);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002968 }
2969 if (idx >= 0)
2970 {
2971 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
2972
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01002973 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002974 current_sctx.sc_sid, idx, sv->sv_type);
2975 return OK;
2976 }
2977
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002978 import = find_imported(name, 0, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002979 if (import != NULL)
2980 {
Bram Moolenaara6294952020-12-27 13:39:50 +01002981 if (import->imp_flags & IMP_FLAGS_STAR)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002982 {
2983 char_u *p = skipwhite(*end);
Bram Moolenaar1c991142020-07-04 13:15:31 +02002984 char_u *exp_name;
2985 int cc;
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002986 ufunc_T *ufunc;
2987 type_T *type;
2988
2989 // Used "import * as Name", need to lookup the member.
2990 if (*p != '.')
2991 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002992 semsg(_(e_expected_dot_after_name_str), start);
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002993 return FAIL;
2994 }
2995 ++p;
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002996 if (VIM_ISWHITE(*p))
2997 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002998 emsg(_(e_no_white_space_allowed_after_dot));
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002999 return FAIL;
3000 }
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003001
Bram Moolenaar1c991142020-07-04 13:15:31 +02003002 // isolate one name
3003 exp_name = p;
3004 while (eval_isnamec(*p))
3005 ++p;
3006 cc = *p;
3007 *p = NUL;
3008
Bram Moolenaaredba7072021-03-13 21:14:18 +01003009 idx = find_exported(import->imp_sid, exp_name, &ufunc, &type,
3010 cctx, TRUE);
Bram Moolenaar1c991142020-07-04 13:15:31 +02003011 *p = cc;
3012 p = skipwhite(p);
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003013 *end = p;
3014
Bram Moolenaar529fb5a2021-04-01 12:57:57 +02003015 if (idx < 0)
3016 {
3017 if (*p == '(' && ufunc != NULL)
3018 {
3019 generate_PUSHFUNC(cctx, ufunc->uf_name, import->imp_type);
3020 return OK;
3021 }
3022 return FAIL;
3023 }
3024
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003025 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
3026 import->imp_sid,
3027 idx,
3028 type);
3029 }
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02003030 else if (import->imp_funcname != NULL)
3031 generate_PUSHFUNC(cctx, import->imp_funcname, import->imp_type);
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003032 else
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003033 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
3034 import->imp_sid,
3035 import->imp_var_vals_idx,
3036 import->imp_type);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003037 return OK;
3038 }
3039
Bram Moolenaarb35efa52020-02-26 20:15:18 +01003040 if (error)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003041 semsg(_(e_item_not_found_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003042 return FAIL;
3043}
3044
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003045 static int
3046generate_funcref(cctx_T *cctx, char_u *name)
3047{
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003048 ufunc_T *ufunc = find_func(name, FALSE, cctx);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003049
3050 if (ufunc == NULL)
3051 return FAIL;
3052
Bram Moolenaarb8070e32020-07-23 20:56:04 +02003053 // Need to compile any default values to get the argument types.
Bram Moolenaare99d4222021-06-13 14:01:26 +02003054 if (func_needs_compiling(ufunc, COMPILE_TYPE(ufunc))
3055 && compile_def_function(ufunc, TRUE, COMPILE_TYPE(ufunc), NULL)
Bram Moolenaarb2049902021-01-24 12:53:53 +01003056 == FAIL)
3057 return FAIL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02003058 return generate_PUSHFUNC(cctx, ufunc->uf_name, ufunc->uf_func_type);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003059}
3060
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003061/*
3062 * Compile a variable name into a load instruction.
3063 * "end" points to just after the name.
Bram Moolenaar0f769812020-09-12 18:32:34 +02003064 * "is_expr" is TRUE when evaluating an expression, might be a funcref.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003065 * When "error" is FALSE do not give an error when not found.
3066 */
3067 static int
Bram Moolenaar0f769812020-09-12 18:32:34 +02003068compile_load(
3069 char_u **arg,
3070 char_u *end_arg,
3071 cctx_T *cctx,
3072 int is_expr,
3073 int error)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003074{
3075 type_T *type;
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003076 char_u *name = NULL;
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01003077 char_u *end = end_arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003078 int res = FAIL;
Bram Moolenaar599c89c2020-03-28 14:53:20 +01003079 int prev_called_emsg = called_emsg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003080
3081 if (*(*arg + 1) == ':')
3082 {
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003083 if (end <= *arg + 2)
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003084 {
3085 isntype_T isn_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003086
Bram Moolenaarfa596382021-04-07 21:58:16 +02003087 // load dictionary of namespace
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003088 switch (**arg)
3089 {
3090 case 'g': isn_type = ISN_LOADGDICT; break;
3091 case 'w': isn_type = ISN_LOADWDICT; break;
3092 case 't': isn_type = ISN_LOADTDICT; break;
3093 case 'b': isn_type = ISN_LOADBDICT; break;
3094 default:
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003095 semsg(_(e_namespace_not_supported_str), *arg);
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003096 goto theend;
3097 }
3098 if (generate_instr_type(cctx, isn_type, &t_dict_any) == NULL)
3099 goto theend;
3100 res = OK;
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003101 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003102 else
3103 {
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003104 isntype_T isn_type = ISN_DROP;
3105
Bram Moolenaarfa596382021-04-07 21:58:16 +02003106 // load namespaced variable
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003107 name = vim_strnsave(*arg + 2, end - (*arg + 2));
3108 if (name == NULL)
3109 return FAIL;
3110
3111 switch (**arg)
3112 {
3113 case 'v': res = generate_LOADV(cctx, name, error);
3114 break;
Bram Moolenaarfa596382021-04-07 21:58:16 +02003115 case 's': if (is_expr && ASCII_ISUPPER(*name)
3116 && find_func(name, FALSE, cctx) != NULL)
3117 res = generate_funcref(cctx, name);
3118 else
3119 res = compile_load_scriptvar(cctx, name,
Bram Moolenaarca51cc02021-04-01 21:38:53 +02003120 NULL, &end, error);
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003121 break;
Bram Moolenaar03290b82020-12-19 16:30:44 +01003122 case 'g': if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
Bram Moolenaarfa596382021-04-07 21:58:16 +02003123 {
3124 if (is_expr && ASCII_ISUPPER(*name)
3125 && find_func(name, FALSE, cctx) != NULL)
3126 res = generate_funcref(cctx, name);
3127 else
3128 isn_type = ISN_LOADG;
3129 }
Bram Moolenaar03290b82020-12-19 16:30:44 +01003130 else
3131 {
3132 isn_type = ISN_LOADAUTO;
3133 vim_free(name);
3134 name = vim_strnsave(*arg, end - *arg);
3135 if (name == NULL)
3136 return FAIL;
3137 }
3138 break;
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003139 case 'w': isn_type = ISN_LOADW; break;
3140 case 't': isn_type = ISN_LOADT; break;
3141 case 'b': isn_type = ISN_LOADB; break;
Bram Moolenaar918a4242020-12-06 14:37:08 +01003142 default: // cannot happen, just in case
3143 semsg(_(e_namespace_not_supported_str), *arg);
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003144 goto theend;
3145 }
3146 if (isn_type != ISN_DROP)
3147 {
3148 // Global, Buffer-local, Window-local and Tabpage-local
3149 // variables can be defined later, thus we don't check if it
Bram Moolenaarfa596382021-04-07 21:58:16 +02003150 // exists, give an error at runtime.
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003151 res = generate_LOAD(cctx, isn_type, 0, name, &t_any);
3152 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003153 }
3154 }
3155 else
3156 {
3157 size_t len = end - *arg;
3158 int idx;
3159 int gen_load = FALSE;
Bram Moolenaarab360522021-01-10 14:02:28 +01003160 int gen_load_outer = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003161
3162 name = vim_strnsave(*arg, end - *arg);
3163 if (name == NULL)
3164 return FAIL;
3165
Bram Moolenaarf0a40692021-06-11 22:05:47 +02003166 if (vim_strchr(name, AUTOLOAD_CHAR) != NULL)
3167 {
3168 script_autoload(name, FALSE);
3169 res = generate_LOAD(cctx, ISN_LOADAUTO, 0, name, &t_any);
3170 }
3171 else if (arg_exists(*arg, len, &idx, &type, &gen_load_outer, cctx)
3172 == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003173 {
Bram Moolenaarab360522021-01-10 14:02:28 +01003174 if (gen_load_outer == 0)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02003175 gen_load = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003176 }
3177 else
3178 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01003179 lvar_T lvar;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02003180
Bram Moolenaar709664c2020-12-12 14:33:41 +01003181 if (lookup_local(*arg, len, &lvar, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003182 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01003183 type = lvar.lv_type;
3184 idx = lvar.lv_idx;
Bram Moolenaarab360522021-01-10 14:02:28 +01003185 if (lvar.lv_from_outer != 0)
3186 gen_load_outer = lvar.lv_from_outer;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02003187 else
3188 gen_load = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003189 }
3190 else
3191 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02003192 // "var" can be script-local even without using "s:" if it
Bram Moolenaar53900992020-08-22 19:02:02 +02003193 // already exists in a Vim9 script or when it's imported.
Bram Moolenaar15e5e532021-04-07 21:21:13 +02003194 if (script_var_exists(*arg, len, cctx) == OK
Bram Moolenaar53900992020-08-22 19:02:02 +02003195 || find_imported(name, 0, cctx) != NULL)
3196 res = compile_load_scriptvar(cctx, name, *arg, &end, FALSE);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003197
Bram Moolenaar0f769812020-09-12 18:32:34 +02003198 // When evaluating an expression and the name starts with an
Bram Moolenaarfa596382021-04-07 21:58:16 +02003199 // uppercase letter it can be a user defined function.
3200 // generate_funcref() will fail if the function can't be found.
3201 if (res == FAIL && is_expr && ASCII_ISUPPER(*name))
Bram Moolenaara5565e42020-05-09 15:44:01 +02003202 res = generate_funcref(cctx, name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003203 }
3204 }
3205 if (gen_load)
3206 res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type);
Bram Moolenaarab360522021-01-10 14:02:28 +01003207 if (gen_load_outer > 0)
Bram Moolenaarfd777482020-08-12 19:42:01 +02003208 {
Bram Moolenaarab360522021-01-10 14:02:28 +01003209 res = generate_LOADOUTER(cctx, idx, gen_load_outer, type);
Bram Moolenaarfd777482020-08-12 19:42:01 +02003210 cctx->ctx_outer_used = TRUE;
3211 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003212 }
3213
3214 *arg = end;
3215
3216theend:
Bram Moolenaar599c89c2020-03-28 14:53:20 +01003217 if (res == FAIL && error && called_emsg == prev_called_emsg)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003218 semsg(_(e_variable_not_found_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003219 vim_free(name);
3220 return res;
3221}
3222
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003223 static void
3224clear_instr_ga(garray_T *gap)
3225{
3226 int idx;
3227
3228 for (idx = 0; idx < gap->ga_len; ++idx)
3229 delete_instr(((isn_T *)gap->ga_data) + idx);
3230 ga_clear(gap);
3231}
3232
3233/*
3234 * Compile a string in a ISN_PUSHS instruction into an ISN_INSTR.
3235 * Returns FAIL if compilation fails.
3236 */
3237 static int
3238compile_string(isn_T *isn, cctx_T *cctx)
3239{
3240 char_u *s = isn->isn_arg.string;
3241 garray_T save_ga = cctx->ctx_instr;
3242 int expr_res;
3243 int trailing_error;
3244 int instr_count;
3245 isn_T *instr = NULL;
3246
Bram Moolenaarcd268012021-07-22 19:11:08 +02003247 // Remove the string type from the stack.
3248 --cctx->ctx_type_stack.ga_len;
3249
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003250 // Temporarily reset the list of instructions so that the jump labels are
3251 // correct.
3252 cctx->ctx_instr.ga_len = 0;
3253 cctx->ctx_instr.ga_maxlen = 0;
3254 cctx->ctx_instr.ga_data = NULL;
3255 expr_res = compile_expr0(&s, cctx);
3256 s = skipwhite(s);
3257 trailing_error = *s != NUL;
3258
Bram Moolenaarff652882021-05-16 15:24:49 +02003259 if (expr_res == FAIL || trailing_error
3260 || ga_grow(&cctx->ctx_instr, 1) == FAIL)
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003261 {
3262 if (trailing_error)
3263 semsg(_(e_trailing_arg), s);
3264 clear_instr_ga(&cctx->ctx_instr);
3265 cctx->ctx_instr = save_ga;
3266 return FAIL;
3267 }
3268
3269 // Move the generated instructions into the ISN_INSTR instruction, then
3270 // restore the list of instructions.
3271 instr_count = cctx->ctx_instr.ga_len;
3272 instr = cctx->ctx_instr.ga_data;
3273 instr[instr_count].isn_type = ISN_FINISH;
3274
3275 cctx->ctx_instr = save_ga;
3276 vim_free(isn->isn_arg.string);
3277 isn->isn_type = ISN_INSTR;
3278 isn->isn_arg.instr = instr;
3279 return OK;
3280}
3281
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003282/*
3283 * Compile the argument expressions.
3284 * "arg" points to just after the "(" and is advanced to after the ")"
3285 */
3286 static int
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003287compile_arguments(char_u **arg, cctx_T *cctx, int *argcount, int is_searchpair)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003288{
Bram Moolenaar2c330432020-04-13 14:41:35 +02003289 char_u *p = *arg;
3290 char_u *whitep = *arg;
Bram Moolenaar10e4f122020-09-20 22:43:52 +02003291 int must_end = FALSE;
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003292 int instr_count;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003293
Bram Moolenaare6085c52020-04-12 20:19:16 +02003294 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003295 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003296 if (may_get_next_line(whitep, &p, cctx) == FAIL)
3297 goto failret;
Bram Moolenaare6085c52020-04-12 20:19:16 +02003298 if (*p == ')')
3299 {
3300 *arg = p + 1;
3301 return OK;
3302 }
Bram Moolenaar10e4f122020-09-20 22:43:52 +02003303 if (must_end)
3304 {
3305 semsg(_(e_missing_comma_before_argument_str), p);
3306 return FAIL;
3307 }
Bram Moolenaare6085c52020-04-12 20:19:16 +02003308
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003309 instr_count = cctx->ctx_instr.ga_len;
Bram Moolenaara5565e42020-05-09 15:44:01 +02003310 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003311 return FAIL;
3312 ++*argcount;
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003313
Bram Moolenaarff652882021-05-16 15:24:49 +02003314 if (is_searchpair && *argcount >= 5
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003315 && cctx->ctx_instr.ga_len == instr_count + 1)
3316 {
3317 isn_T *isn = ((isn_T *)cctx->ctx_instr.ga_data) + instr_count;
3318
3319 // {skip} argument of searchpair() can be compiled if not empty
3320 if (isn->isn_type == ISN_PUSHS && *isn->isn_arg.string != NUL)
3321 compile_string(isn, cctx);
3322 }
3323
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003324 if (*p != ',' && *skipwhite(p) == ',')
3325 {
Bram Moolenaarba98fb52021-02-07 18:06:29 +01003326 semsg(_(e_no_white_space_allowed_before_str_str), ",", p);
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003327 p = skipwhite(p);
3328 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003329 if (*p == ',')
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003330 {
3331 ++p;
Bram Moolenaare6085c52020-04-12 20:19:16 +02003332 if (*p != NUL && !VIM_ISWHITE(*p))
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01003333 semsg(_(e_white_space_required_after_str_str), ",", p - 1);
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003334 }
Bram Moolenaar10e4f122020-09-20 22:43:52 +02003335 else
3336 must_end = TRUE;
Bram Moolenaar2c330432020-04-13 14:41:35 +02003337 whitep = p;
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003338 p = skipwhite(p);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003339 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02003340failret:
Bram Moolenaare6085c52020-04-12 20:19:16 +02003341 emsg(_(e_missing_close));
3342 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003343}
3344
3345/*
3346 * Compile a function call: name(arg1, arg2)
3347 * "arg" points to "name", "arg + varlen" to the "(".
3348 * "argcount_init" is 1 for "value->method()"
3349 * Instructions:
3350 * EVAL arg1
3351 * EVAL arg2
3352 * BCALL / DCALL / UCALL
3353 */
3354 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02003355compile_call(
3356 char_u **arg,
3357 size_t varlen,
3358 cctx_T *cctx,
3359 ppconst_T *ppconst,
3360 int argcount_init)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003361{
3362 char_u *name = *arg;
Bram Moolenaar0b76ad52020-01-31 21:20:51 +01003363 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003364 int argcount = argcount_init;
3365 char_u namebuf[100];
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003366 char_u fname_buf[FLEN_FIXED + 1];
3367 char_u *tofree = NULL;
3368 int error = FCERR_NONE;
Bram Moolenaarb3a01942020-11-17 19:56:09 +01003369 ufunc_T *ufunc = NULL;
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003370 int res = FAIL;
Bram Moolenaara1773442020-08-12 15:21:22 +02003371 int is_autoload;
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003372 int is_searchpair;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003373
Bram Moolenaara5565e42020-05-09 15:44:01 +02003374 // we can evaluate "has('name')" at compile time
3375 if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0)
3376 {
3377 char_u *s = skipwhite(*arg + varlen + 1);
3378 typval_T argvars[2];
3379
3380 argvars[0].v_type = VAR_UNKNOWN;
3381 if (*s == '"')
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003382 (void)eval_string(&s, &argvars[0], TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02003383 else if (*s == '\'')
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003384 (void)eval_lit_string(&s, &argvars[0], TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02003385 s = skipwhite(s);
Bram Moolenaar8cebd432020-11-08 12:49:47 +01003386 if (*s == ')' && argvars[0].v_type == VAR_STRING
3387 && !dynamic_feature(argvars[0].vval.v_string))
Bram Moolenaara5565e42020-05-09 15:44:01 +02003388 {
3389 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used];
3390
3391 *arg = s + 1;
3392 argvars[1].v_type = VAR_UNKNOWN;
3393 tv->v_type = VAR_NUMBER;
3394 tv->vval.v_number = 0;
3395 f_has(argvars, tv);
3396 clear_tv(&argvars[0]);
3397 ++ppconst->pp_used;
3398 return OK;
3399 }
Bram Moolenaar497f76b2020-05-09 16:44:22 +02003400 clear_tv(&argvars[0]);
Bram Moolenaara5565e42020-05-09 15:44:01 +02003401 }
3402
3403 if (generate_ppconst(cctx, ppconst) == FAIL)
3404 return FAIL;
3405
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003406 if (varlen >= sizeof(namebuf))
3407 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003408 semsg(_(e_name_too_long_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003409 return FAIL;
3410 }
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003411 vim_strncpy(namebuf, *arg, varlen);
3412 name = fname_trans_sid(namebuf, fname_buf, &tofree, &error);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003413
Bram Moolenaarf06ab6b2021-05-07 19:44:21 +02003414 // We handle the "skip" argument of searchpair() and searchpairpos()
3415 // differently.
3416 is_searchpair = (varlen == 6 && STRNCMP(*arg, "search", 6) == 0)
3417 || (varlen == 9 && STRNCMP(*arg, "searchpos", 9) == 0)
3418 || (varlen == 10 && STRNCMP(*arg, "searchpair", 10) == 0)
3419 || (varlen == 13 && STRNCMP(*arg, "searchpairpos", 13) == 0);
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003420
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003421 *arg = skipwhite(*arg + varlen + 1);
Bram Moolenaarf18332f2021-05-07 17:55:55 +02003422 if (compile_arguments(arg, cctx, &argcount, is_searchpair) == FAIL)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003423 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003424
Bram Moolenaar03290b82020-12-19 16:30:44 +01003425 is_autoload = vim_strchr(name, AUTOLOAD_CHAR) != NULL;
Bram Moolenaara1773442020-08-12 15:21:22 +02003426 if (ASCII_ISLOWER(*name) && name[1] != ':' && !is_autoload)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003427 {
3428 int idx;
3429
3430 // builtin function
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003431 idx = find_internal_func(name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003432 if (idx >= 0)
Bram Moolenaar1dcae592020-10-19 19:02:42 +02003433 {
Bram Moolenaar3b690062021-02-01 20:14:51 +01003434 if (STRCMP(name, "flatten") == 0)
3435 {
3436 emsg(_(e_cannot_use_flatten_in_vim9_script));
3437 goto theend;
3438 }
3439
Bram Moolenaar1dcae592020-10-19 19:02:42 +02003440 if (STRCMP(name, "add") == 0 && argcount == 2)
3441 {
3442 garray_T *stack = &cctx->ctx_type_stack;
3443 type_T *type = ((type_T **)stack->ga_data)[
3444 stack->ga_len - 2];
3445
Bram Moolenaare88c8e82020-11-01 17:03:37 +01003446 // add() can be compiled to instructions if we know the type
Bram Moolenaar1dcae592020-10-19 19:02:42 +02003447 if (type->tt_type == VAR_LIST)
3448 {
3449 // inline "add(list, item)" so that the type can be checked
3450 res = generate_LISTAPPEND(cctx);
3451 idx = -1;
3452 }
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02003453 else if (type->tt_type == VAR_BLOB)
3454 {
3455 // inline "add(blob, nr)" so that the type can be checked
3456 res = generate_BLOBAPPEND(cctx);
3457 idx = -1;
3458 }
Bram Moolenaar1dcae592020-10-19 19:02:42 +02003459 }
3460
3461 if (idx >= 0)
3462 res = generate_BCALL(cctx, idx, argcount, argcount_init == 1);
3463 }
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003464 else
3465 semsg(_(e_unknownfunc), namebuf);
3466 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003467 }
3468
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003469 // An argument or local variable can be a function reference, this
3470 // overrules a function name.
Bram Moolenaar709664c2020-12-12 14:33:41 +01003471 if (lookup_local(namebuf, varlen, NULL, cctx) == FAIL
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003472 && arg_exists(namebuf, varlen, NULL, NULL, NULL, cctx) != OK)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003473 {
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003474 // If we can find the function by name generate the right call.
3475 // Skip global functions here, a local funcref takes precedence.
3476 ufunc = find_func(name, FALSE, cctx);
3477 if (ufunc != NULL && !func_is_global(ufunc))
3478 {
3479 res = generate_CALL(cctx, ufunc, argcount);
3480 goto theend;
3481 }
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003482 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003483
3484 // If the name is a variable, load it and use PCALL.
Bram Moolenaara26b9702020-04-18 19:53:28 +02003485 // Not for g:Func(), we don't know if it is a variable or not.
Bram Moolenaara1773442020-08-12 15:21:22 +02003486 // Not for eome#Func(), it will be loaded later.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003487 p = namebuf;
Bram Moolenaara1773442020-08-12 15:21:22 +02003488 if (STRNCMP(namebuf, "g:", 2) != 0 && !is_autoload
Bram Moolenaar0f769812020-09-12 18:32:34 +02003489 && compile_load(&p, namebuf + varlen, cctx, FALSE, FALSE) == OK)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003490 {
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003491 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar7e368202020-12-25 21:56:57 +01003492 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003493
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003494 res = generate_PCALL(cctx, argcount, namebuf, type, FALSE);
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003495 goto theend;
3496 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003497
Bram Moolenaar0f769812020-09-12 18:32:34 +02003498 // If we can find a global function by name generate the right call.
3499 if (ufunc != NULL)
3500 {
3501 res = generate_CALL(cctx, ufunc, argcount);
3502 goto theend;
3503 }
3504
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02003505 // A global function may be defined only later. Need to figure out at
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003506 // runtime. Also handles a FuncRef at runtime.
Bram Moolenaara1773442020-08-12 15:21:22 +02003507 if (STRNCMP(namebuf, "g:", 2) == 0 || is_autoload)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02003508 res = generate_UCALL(cctx, name, argcount);
3509 else
3510 semsg(_(e_unknownfunc), namebuf);
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01003511
3512theend:
3513 vim_free(tofree);
3514 return res;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003515}
3516
3517// like NAMESPACE_CHAR but with 'a' and 'l'.
3518#define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw"
3519
3520/*
3521 * Find the end of a variable or function name. Unlike find_name_end() this
3522 * does not recognize magic braces.
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01003523 * When "use_namespace" is TRUE recognize "b:", "s:", etc.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003524 * Return a pointer to just after the name. Equal to "arg" if there is no
3525 * valid name.
3526 */
Bram Moolenaar2bede172020-11-19 18:53:18 +01003527 char_u *
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01003528to_name_end(char_u *arg, int use_namespace)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003529{
3530 char_u *p;
3531
3532 // Quick check for valid starting character.
3533 if (!eval_isnamec1(*arg))
3534 return arg;
3535
3536 for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p))
3537 // Include a namespace such as "s:var" and "v:var". But "n:" is not
3538 // and can be used in slice "[n:]".
3539 if (*p == ':' && (p != arg + 1
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01003540 || !use_namespace
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003541 || vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL))
3542 break;
3543 return p;
3544}
3545
3546/*
3547 * Like to_name_end() but also skip over a list or dict constant.
Bram Moolenaar1c991142020-07-04 13:15:31 +02003548 * This intentionally does not handle line continuation.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003549 */
3550 char_u *
3551to_name_const_end(char_u *arg)
3552{
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01003553 char_u *p = to_name_end(arg, TRUE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003554 typval_T rettv;
3555
3556 if (p == arg && *arg == '[')
3557 {
3558
3559 // Can be "[1, 2, 3]->Func()".
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003560 if (eval_list(&p, &rettv, NULL, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003561 p = arg;
3562 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003563 return p;
3564}
3565
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003566/*
3567 * parse a list: [expr, expr]
3568 * "*arg" points to the '['.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003569 * ppconst->pp_is_const is set if all items are a constant.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003570 */
3571 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003572compile_list(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003573{
3574 char_u *p = skipwhite(*arg + 1);
Bram Moolenaar2c330432020-04-13 14:41:35 +02003575 char_u *whitep = *arg + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003576 int count = 0;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003577 int is_const;
3578 int is_all_const = TRUE; // reset when non-const encountered
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003579
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003580 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003581 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003582 if (may_get_next_line(whitep, &p, cctx) == FAIL)
Bram Moolenaara30590d2020-03-28 22:06:23 +01003583 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003584 semsg(_(e_list_end), *arg);
3585 return FAIL;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003586 }
Bram Moolenaardb199212020-08-12 18:01:53 +02003587 if (*p == ',')
3588 {
Bram Moolenaarba98fb52021-02-07 18:06:29 +01003589 semsg(_(e_no_white_space_allowed_before_str_str), ",", p);
Bram Moolenaardb199212020-08-12 18:01:53 +02003590 return FAIL;
3591 }
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003592 if (*p == ']')
3593 {
3594 ++p;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003595 break;
Bram Moolenaara30590d2020-03-28 22:06:23 +01003596 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003597 if (compile_expr0_ext(&p, cctx, &is_const) == FAIL)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02003598 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003599 if (!is_const)
3600 is_all_const = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003601 ++count;
3602 if (*p == ',')
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02003603 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003604 ++p;
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02003605 if (*p != ']' && !IS_WHITE_OR_NUL(*p))
3606 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01003607 semsg(_(e_white_space_required_after_str_str), ",", p - 1);
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02003608 return FAIL;
3609 }
3610 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02003611 whitep = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003612 p = skipwhite(p);
3613 }
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003614 *arg = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003615
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003616 ppconst->pp_is_const = is_all_const;
3617 return generate_NEWLIST(cctx, count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003618}
3619
3620/*
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003621 * Parse a lambda: "(arg, arg) => expr"
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01003622 * "*arg" points to the '('.
Bram Moolenaare462f522020-12-27 14:43:30 +01003623 * Returns OK/FAIL when a lambda is recognized, NOTDONE if it's not a lambda.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003624 */
3625 static int
3626compile_lambda(char_u **arg, cctx_T *cctx)
3627{
Bram Moolenaare462f522020-12-27 14:43:30 +01003628 int r;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003629 typval_T rettv;
3630 ufunc_T *ufunc;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003631 evalarg_T evalarg;
3632
3633 CLEAR_FIELD(evalarg);
3634 evalarg.eval_flags = EVAL_EVALUATE;
3635 evalarg.eval_cctx = cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003636
3637 // Get the funcref in "rettv".
Bram Moolenaare462f522020-12-27 14:43:30 +01003638 r = get_lambda_tv(arg, &rettv, TRUE, &evalarg);
3639 if (r != OK)
Bram Moolenaar2ea79ad2020-10-18 23:32:13 +02003640 {
3641 clear_evalarg(&evalarg, NULL);
Bram Moolenaare462f522020-12-27 14:43:30 +01003642 return r;
Bram Moolenaar2ea79ad2020-10-18 23:32:13 +02003643 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01003644
Bram Moolenaar65c44152020-12-24 15:14:01 +01003645 // "rettv" will now be a partial referencing the function.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003646 ufunc = rettv.vval.v_partial->pt_func;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003647 ++ufunc->uf_refcount;
3648 clear_tv(&rettv);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003649
Bram Moolenaara9931532021-06-12 15:58:16 +02003650 // Compile it here to get the return type. The return type is optional,
3651 // when it's missing use t_unknown. This is recognized in
3652 // compile_return().
3653 if (ufunc->uf_ret_type->tt_type == VAR_VOID)
3654 ufunc->uf_ret_type = &t_unknown;
Bram Moolenaar17d868b2021-06-27 16:29:53 +02003655 compile_def_function(ufunc, FALSE, cctx->ctx_compile_type, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003656
Bram Moolenaar648594e2021-07-11 17:55:01 +02003657#ifdef FEAT_PROFILE
Bram Moolenaard9162552021-07-11 15:26:13 +02003658 // When the outer function is compiled for profiling, the lambda may be
3659 // called without profiling. Compile it here in the right context.
3660 if (cctx->ctx_compile_type == CT_PROFILE)
3661 compile_def_function(ufunc, FALSE, CT_NONE, cctx);
Bram Moolenaar648594e2021-07-11 17:55:01 +02003662#endif
Bram Moolenaard9162552021-07-11 15:26:13 +02003663
Bram Moolenaar67da21a2021-03-21 22:12:34 +01003664 // evalarg.eval_tofree_cmdline may have a copy of the last line and "*arg"
3665 // points into it. Point to the original line to avoid a dangling pointer.
3666 if (evalarg.eval_tofree_cmdline != NULL)
3667 {
3668 size_t off = *arg - evalarg.eval_tofree_cmdline;
3669
3670 *arg = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum]
3671 + off;
3672 }
3673
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02003674 clear_evalarg(&evalarg, NULL);
3675
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003676 if (ufunc->uf_def_status == UF_COMPILED)
Bram Moolenaar5a849da2020-08-08 16:47:30 +02003677 {
3678 // The return type will now be known.
3679 set_function_type(ufunc);
3680
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003681 // The function reference count will be 1. When the ISN_FUNCREF
3682 // instruction is deleted the reference count is decremented and the
3683 // function is freed.
Bram Moolenaar5a849da2020-08-08 16:47:30 +02003684 return generate_FUNCREF(cctx, ufunc);
3685 }
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003686
3687 func_ptr_unref(ufunc);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003688 return FAIL;
3689}
3690
3691/*
Bram Moolenaar9bb0dad2021-07-19 22:19:29 +02003692 * Get a lambda and compile it. Uses Vim9 syntax.
3693 */
3694 int
3695get_lambda_tv_and_compile(
3696 char_u **arg,
3697 typval_T *rettv,
3698 int types_optional,
3699 evalarg_T *evalarg)
3700{
3701 int r;
3702 ufunc_T *ufunc;
3703 int save_sc_version = current_sctx.sc_version;
3704
3705 // Get the funcref in "rettv".
3706 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
3707 r = get_lambda_tv(arg, rettv, types_optional, evalarg);
3708 current_sctx.sc_version = save_sc_version;
3709 if (r != OK)
3710 return r;
3711
3712 // "rettv" will now be a partial referencing the function.
3713 ufunc = rettv->vval.v_partial->pt_func;
3714
3715 // Compile it here to get the return type. The return type is optional,
3716 // when it's missing use t_unknown. This is recognized in
3717 // compile_return().
3718 if (ufunc->uf_ret_type == NULL || ufunc->uf_ret_type->tt_type == VAR_VOID)
3719 ufunc->uf_ret_type = &t_unknown;
3720 compile_def_function(ufunc, FALSE, CT_NONE, NULL);
3721
3722 if (ufunc->uf_def_status == UF_COMPILED)
3723 {
3724 // The return type will now be known.
3725 set_function_type(ufunc);
3726 return OK;
3727 }
3728 clear_tv(rettv);
3729 return FAIL;
3730}
3731
3732/*
Bram Moolenaare0de1712020-12-02 17:36:54 +01003733 * parse a dict: {key: val, [key]: val}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003734 * "*arg" points to the '{'.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003735 * ppconst->pp_is_const is set if all item values are a constant.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003736 */
3737 static int
Bram Moolenaare0de1712020-12-02 17:36:54 +01003738compile_dict(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003739{
3740 garray_T *instr = &cctx->ctx_instr;
3741 int count = 0;
3742 dict_T *d = dict_alloc();
3743 dictitem_T *item;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003744 char_u *whitep = *arg + 1;
Bram Moolenaar2c330432020-04-13 14:41:35 +02003745 char_u *p;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003746 int is_const;
3747 int is_all_const = TRUE; // reset when non-const encountered
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003748
3749 if (d == NULL)
3750 return FAIL;
Bram Moolenaard62d87d2021-01-04 17:40:12 +01003751 if (generate_ppconst(cctx, ppconst) == FAIL)
3752 return FAIL;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003753 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003754 {
Bram Moolenaar2bede172020-11-19 18:53:18 +01003755 char_u *key = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003756
Bram Moolenaar23c55272020-06-21 16:58:13 +02003757 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003758 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003759 *arg = NULL;
3760 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003761 }
3762
3763 if (**arg == '}')
3764 break;
3765
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003766 if (**arg == '[')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003767 {
Bram Moolenaar2bede172020-11-19 18:53:18 +01003768 isn_T *isn;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003769
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003770 // {[expr]: value} uses an evaluated key.
Bram Moolenaare0de1712020-12-02 17:36:54 +01003771 *arg = skipwhite(*arg + 1);
Bram Moolenaara5565e42020-05-09 15:44:01 +02003772 if (compile_expr0(arg, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003773 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003774 isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01003775 if (isn->isn_type == ISN_PUSHNR)
3776 {
3777 char buf[NUMBUFLEN];
3778
3779 // Convert to string at compile time.
3780 vim_snprintf(buf, NUMBUFLEN, "%lld", isn->isn_arg.number);
3781 isn->isn_type = ISN_PUSHS;
3782 isn->isn_arg.string = vim_strsave((char_u *)buf);
3783 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003784 if (isn->isn_type == ISN_PUSHS)
3785 key = isn->isn_arg.string;
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02003786 else if (may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01003787 return FAIL;
Bram Moolenaare0de1712020-12-02 17:36:54 +01003788 *arg = skipwhite(*arg);
3789 if (**arg != ']')
Bram Moolenaar2bede172020-11-19 18:53:18 +01003790 {
Bram Moolenaare0de1712020-12-02 17:36:54 +01003791 emsg(_(e_missing_matching_bracket_after_dict_key));
3792 return FAIL;
Bram Moolenaar2bede172020-11-19 18:53:18 +01003793 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01003794 ++*arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003795 }
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003796 else
3797 {
3798 // {"name": value},
3799 // {'name': value},
3800 // {name: value} use "name" as a literal key
3801 key = get_literal_key(arg);
3802 if (key == NULL)
3803 return FAIL;
3804 if (generate_PUSHS(cctx, key) == FAIL)
3805 return FAIL;
3806 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003807
3808 // Check for duplicate keys, if using string keys.
3809 if (key != NULL)
3810 {
3811 item = dict_find(d, key, -1);
3812 if (item != NULL)
3813 {
3814 semsg(_(e_duplicate_key), key);
3815 goto failret;
3816 }
3817 item = dictitem_alloc(key);
3818 if (item != NULL)
3819 {
3820 item->di_tv.v_type = VAR_UNKNOWN;
3821 item->di_tv.v_lock = 0;
3822 if (dict_add(d, item) == FAIL)
3823 dictitem_free(item);
3824 }
3825 }
3826
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003827 if (**arg != ':')
3828 {
Bram Moolenaar17a836c2020-08-12 17:35:58 +02003829 if (*skipwhite(*arg) == ':')
Bram Moolenaarba98fb52021-02-07 18:06:29 +01003830 semsg(_(e_no_white_space_allowed_before_str_str), ":", *arg);
Bram Moolenaar17a836c2020-08-12 17:35:58 +02003831 else
3832 semsg(_(e_missing_dict_colon), *arg);
3833 return FAIL;
3834 }
3835 whitep = *arg + 1;
3836 if (!IS_WHITE_OR_NUL(*whitep))
3837 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01003838 semsg(_(e_white_space_required_after_str_str), ":", *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003839 return FAIL;
3840 }
3841
Bram Moolenaar23c55272020-06-21 16:58:13 +02003842 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003843 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003844 *arg = NULL;
3845 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003846 }
3847
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003848 if (compile_expr0_ext(arg, cctx, &is_const) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003849 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003850 if (!is_const)
3851 is_all_const = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003852 ++count;
3853
Bram Moolenaar2c330432020-04-13 14:41:35 +02003854 whitep = *arg;
Bram Moolenaar23c55272020-06-21 16:58:13 +02003855 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003856 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003857 *arg = NULL;
3858 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003859 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003860 if (**arg == '}')
3861 break;
3862 if (**arg != ',')
3863 {
3864 semsg(_(e_missing_dict_comma), *arg);
3865 goto failret;
3866 }
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02003867 if (IS_WHITE_OR_NUL(*whitep))
3868 {
Bram Moolenaarba98fb52021-02-07 18:06:29 +01003869 semsg(_(e_no_white_space_allowed_before_str_str), ",", whitep);
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02003870 return FAIL;
3871 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02003872 whitep = *arg + 1;
Bram Moolenaar9a13e182020-10-19 21:45:07 +02003873 if (!IS_WHITE_OR_NUL(*whitep))
3874 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01003875 semsg(_(e_white_space_required_after_str_str), ",", *arg);
Bram Moolenaar9a13e182020-10-19 21:45:07 +02003876 return FAIL;
3877 }
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01003878 *arg = skipwhite(whitep);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003879 }
3880
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003881 *arg = *arg + 1;
3882
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003883 // Allow for following comment, after at least one space.
Bram Moolenaar2c330432020-04-13 14:41:35 +02003884 p = skipwhite(*arg);
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003885 if (VIM_ISWHITE(**arg) && vim9_comment_start(p))
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003886 *arg += STRLEN(*arg);
3887
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003888 dict_unref(d);
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003889 ppconst->pp_is_const = is_all_const;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003890 return generate_NEWDICT(cctx, count);
3891
3892failret:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003893 if (*arg == NULL)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02003894 {
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003895 semsg(_(e_missing_dict_end), _("[end of lines]"));
Bram Moolenaar44aefff2020-10-05 19:23:59 +02003896 *arg = (char_u *)"";
3897 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003898 dict_unref(d);
3899 return FAIL;
3900}
3901
3902/*
3903 * Compile "&option".
3904 */
3905 static int
3906compile_get_option(char_u **arg, cctx_T *cctx)
3907{
3908 typval_T rettv;
3909 char_u *start = *arg;
3910 int ret;
3911
3912 // parse the option and get the current value to get the type.
3913 rettv.v_type = VAR_UNKNOWN;
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003914 ret = eval_option(arg, &rettv, TRUE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003915 if (ret == OK)
3916 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003917 // include the '&' in the name, eval_option() expects it.
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01003918 char_u *name = vim_strnsave(start, *arg - start);
3919 type_T *type = rettv.v_type == VAR_BOOL ? &t_bool
3920 : rettv.v_type == VAR_NUMBER ? &t_number : &t_string;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003921
3922 ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
3923 vim_free(name);
3924 }
3925 clear_tv(&rettv);
3926
3927 return ret;
3928}
3929
3930/*
3931 * Compile "$VAR".
3932 */
3933 static int
3934compile_get_env(char_u **arg, cctx_T *cctx)
3935{
3936 char_u *start = *arg;
3937 int len;
3938 int ret;
3939 char_u *name;
3940
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003941 ++*arg;
3942 len = get_env_len(arg);
3943 if (len == 0)
3944 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003945 semsg(_(e_syntax_error_at_str), start - 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003946 return FAIL;
3947 }
3948
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003949 // include the '$' in the name, eval_env_var() expects it.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003950 name = vim_strnsave(start, len + 1);
3951 ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string);
3952 vim_free(name);
3953 return ret;
3954}
3955
3956/*
3957 * Compile "@r".
3958 */
3959 static int
3960compile_get_register(char_u **arg, cctx_T *cctx)
3961{
3962 int ret;
3963
3964 ++*arg;
3965 if (**arg == NUL)
3966 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003967 semsg(_(e_syntax_error_at_str), *arg - 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003968 return FAIL;
3969 }
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02003970 if (!valid_yank_reg(**arg, FALSE))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003971 {
3972 emsg_invreg(**arg);
3973 return FAIL;
3974 }
3975 ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string);
3976 ++*arg;
3977 return ret;
3978}
3979
3980/*
3981 * Apply leading '!', '-' and '+' to constant "rettv".
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003982 * When "numeric_only" is TRUE do not apply '!'.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003983 */
3984 static int
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003985apply_leader(typval_T *rettv, int numeric_only, char_u *start, char_u **end)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003986{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003987 char_u *p = *end;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003988
3989 // this works from end to start
3990 while (p > start)
3991 {
3992 --p;
3993 if (*p == '-' || *p == '+')
3994 {
3995 // only '-' has an effect, for '+' we only check the type
3996#ifdef FEAT_FLOAT
3997 if (rettv->v_type == VAR_FLOAT)
3998 {
3999 if (*p == '-')
4000 rettv->vval.v_float = -rettv->vval.v_float;
4001 }
4002 else
4003#endif
4004 {
4005 varnumber_T val;
4006 int error = FALSE;
4007
4008 // tv_get_number_chk() accepts a string, but we don't want that
4009 // here
4010 if (check_not_string(rettv) == FAIL)
4011 return FAIL;
4012 val = tv_get_number_chk(rettv, &error);
4013 clear_tv(rettv);
4014 if (error)
4015 return FAIL;
4016 if (*p == '-')
4017 val = -val;
4018 rettv->v_type = VAR_NUMBER;
4019 rettv->vval.v_number = val;
4020 }
4021 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004022 else if (numeric_only)
4023 {
4024 ++p;
4025 break;
4026 }
Bram Moolenaar27491cd2020-10-15 21:54:56 +02004027 else if (*p == '!')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004028 {
4029 int v = tv2bool(rettv);
4030
4031 // '!' is permissive in the type.
4032 clear_tv(rettv);
4033 rettv->v_type = VAR_BOOL;
4034 rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE;
4035 }
4036 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004037 *end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004038 return OK;
4039}
4040
4041/*
4042 * Recognize v: variables that are constants and set "rettv".
4043 */
4044 static void
4045get_vim_constant(char_u **arg, typval_T *rettv)
4046{
4047 if (STRNCMP(*arg, "v:true", 6) == 0)
4048 {
4049 rettv->v_type = VAR_BOOL;
4050 rettv->vval.v_number = VVAL_TRUE;
4051 *arg += 6;
4052 }
4053 else if (STRNCMP(*arg, "v:false", 7) == 0)
4054 {
4055 rettv->v_type = VAR_BOOL;
4056 rettv->vval.v_number = VVAL_FALSE;
4057 *arg += 7;
4058 }
4059 else if (STRNCMP(*arg, "v:null", 6) == 0)
4060 {
4061 rettv->v_type = VAR_SPECIAL;
4062 rettv->vval.v_number = VVAL_NULL;
4063 *arg += 6;
4064 }
4065 else if (STRNCMP(*arg, "v:none", 6) == 0)
4066 {
4067 rettv->v_type = VAR_SPECIAL;
4068 rettv->vval.v_number = VVAL_NONE;
4069 *arg += 6;
4070 }
4071}
4072
Bram Moolenaar657137c2021-01-09 15:45:23 +01004073 exprtype_T
Bram Moolenaar61a89812020-05-07 16:58:17 +02004074get_compare_type(char_u *p, int *len, int *type_is)
4075{
Bram Moolenaar657137c2021-01-09 15:45:23 +01004076 exprtype_T type = EXPR_UNKNOWN;
Bram Moolenaar61a89812020-05-07 16:58:17 +02004077 int i;
4078
4079 switch (p[0])
4080 {
4081 case '=': if (p[1] == '=')
4082 type = EXPR_EQUAL;
4083 else if (p[1] == '~')
4084 type = EXPR_MATCH;
4085 break;
4086 case '!': if (p[1] == '=')
4087 type = EXPR_NEQUAL;
4088 else if (p[1] == '~')
4089 type = EXPR_NOMATCH;
4090 break;
4091 case '>': if (p[1] != '=')
4092 {
4093 type = EXPR_GREATER;
4094 *len = 1;
4095 }
4096 else
4097 type = EXPR_GEQUAL;
4098 break;
4099 case '<': if (p[1] != '=')
4100 {
4101 type = EXPR_SMALLER;
4102 *len = 1;
4103 }
4104 else
4105 type = EXPR_SEQUAL;
4106 break;
4107 case 'i': if (p[1] == 's')
4108 {
4109 // "is" and "isnot"; but not a prefix of a name
4110 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't')
4111 *len = 5;
4112 i = p[*len];
4113 if (!isalnum(i) && i != '_')
4114 {
4115 type = *len == 2 ? EXPR_IS : EXPR_ISNOT;
4116 *type_is = TRUE;
4117 }
4118 }
4119 break;
4120 }
4121 return type;
4122}
4123
4124/*
Bram Moolenaar7e368202020-12-25 21:56:57 +01004125 * Skip over an expression, ignoring most errors.
4126 */
4127 static void
4128skip_expr_cctx(char_u **arg, cctx_T *cctx)
4129{
4130 evalarg_T evalarg;
4131
4132 CLEAR_FIELD(evalarg);
4133 evalarg.eval_cctx = cctx;
4134 skip_expr(arg, &evalarg);
4135}
4136
4137/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004138 * Compile code to apply '-', '+' and '!'.
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004139 * When "numeric_only" is TRUE do not apply '!'.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004140 */
4141 static int
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004142compile_leader(cctx_T *cctx, int numeric_only, char_u *start, char_u **end)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004143{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004144 char_u *p = *end;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004145
4146 // this works from end to start
4147 while (p > start)
4148 {
4149 --p;
Bram Moolenaar79cdf802020-11-18 17:39:05 +01004150 while (VIM_ISWHITE(*p))
4151 --p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004152 if (*p == '-' || *p == '+')
4153 {
4154 int negate = *p == '-';
4155 isn_T *isn;
4156
4157 // TODO: check type
4158 while (p > start && (p[-1] == '-' || p[-1] == '+'))
4159 {
4160 --p;
4161 if (*p == '-')
4162 negate = !negate;
4163 }
4164 // only '-' has an effect, for '+' we only check the type
4165 if (negate)
4166 isn = generate_instr(cctx, ISN_NEGATENR);
4167 else
4168 isn = generate_instr(cctx, ISN_CHECKNR);
4169 if (isn == NULL)
4170 return FAIL;
4171 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004172 else if (numeric_only)
4173 {
4174 ++p;
4175 break;
4176 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004177 else
4178 {
Bram Moolenaar27491cd2020-10-15 21:54:56 +02004179 int invert = *p == '!';
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004180
Bram Moolenaar27491cd2020-10-15 21:54:56 +02004181 while (p > start && (p[-1] == '!' || VIM_ISWHITE(p[-1])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004182 {
Bram Moolenaar27491cd2020-10-15 21:54:56 +02004183 if (p[-1] == '!')
4184 invert = !invert;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004185 --p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004186 }
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02004187 if (generate_2BOOL(cctx, invert, -1) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004188 return FAIL;
4189 }
4190 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004191 *end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004192 return OK;
4193}
4194
4195/*
Bram Moolenaar7e368202020-12-25 21:56:57 +01004196 * Compile "(expression)": recursive!
4197 * Return FAIL/OK.
4198 */
4199 static int
4200compile_parenthesis(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
4201{
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004202 int ret;
Bram Moolenaar24156692021-01-14 20:35:49 +01004203 char_u *p = *arg + 1;
Bram Moolenaar7e368202020-12-25 21:56:57 +01004204
Bram Moolenaar24156692021-01-14 20:35:49 +01004205 if (may_get_next_line_error(p, arg, cctx) == FAIL)
4206 return FAIL;
Bram Moolenaar7e368202020-12-25 21:56:57 +01004207 if (ppconst->pp_used <= PPSIZE - 10)
4208 {
4209 ret = compile_expr1(arg, cctx, ppconst);
4210 }
4211 else
4212 {
4213 // Not enough space in ppconst, flush constants.
4214 if (generate_ppconst(cctx, ppconst) == FAIL)
4215 return FAIL;
4216 ret = compile_expr0(arg, cctx);
4217 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004218 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
4219 return FAIL;
Bram Moolenaar7e368202020-12-25 21:56:57 +01004220 if (**arg == ')')
4221 ++*arg;
4222 else if (ret == OK)
4223 {
4224 emsg(_(e_missing_close));
4225 ret = FAIL;
4226 }
4227 return ret;
4228}
4229
4230/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004231 * Compile whatever comes after "name" or "name()".
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004232 * Advances "*arg" only when something was recognized.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004233 */
4234 static int
4235compile_subscript(
4236 char_u **arg,
4237 cctx_T *cctx,
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004238 char_u *start_leader,
4239 char_u **end_leader,
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004240 ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004241{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004242 char_u *name_start = *end_leader;
4243
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004244 for (;;)
4245 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02004246 char_u *p = skipwhite(*arg);
4247
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02004248 if (*p == NUL || (VIM_ISWHITE(**arg) && vim9_comment_start(p)))
Bram Moolenaar23c55272020-06-21 16:58:13 +02004249 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004250 char_u *next = peek_next_line_from_context(cctx);
Bram Moolenaar23c55272020-06-21 16:58:13 +02004251
4252 // If a following line starts with "->{" or "->X" advance to that
4253 // line, so that a line break before "->" is allowed.
Bram Moolenaara7eedf32020-07-10 21:50:41 +02004254 // Also if a following line starts with ".x".
4255 if (next != NULL &&
4256 ((next[0] == '-' && next[1] == '>'
Bram Moolenaara7330422021-06-08 20:46:45 +02004257 && (next[2] == '{'
4258 || ASCII_ISALPHA(*skipwhite(next + 2))))
Bram Moolenaarb13ab992020-07-27 21:43:28 +02004259 || (next[0] == '.' && eval_isdictc(next[1]))))
Bram Moolenaar23c55272020-06-21 16:58:13 +02004260 {
4261 next = next_line_from_context(cctx, TRUE);
4262 if (next == NULL)
4263 return FAIL;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004264 *arg = next;
4265 p = skipwhite(*arg);
Bram Moolenaar23c55272020-06-21 16:58:13 +02004266 }
4267 }
4268
Bram Moolenaarcd268012021-07-22 19:11:08 +02004269 // Do not skip over white space to find the "(", "execute 'x' (expr)"
4270 // is not a function call.
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02004271 if (**arg == '(')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004272 {
Bram Moolenaara0a9f432020-04-28 21:29:34 +02004273 garray_T *stack = &cctx->ctx_type_stack;
4274 type_T *type;
4275 int argcount = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004276
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004277 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004278 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004279 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004280
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004281 // funcref(arg)
Bram Moolenaara0a9f432020-04-28 21:29:34 +02004282 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
4283
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004284 *arg = skipwhite(p + 1);
Bram Moolenaarf18332f2021-05-07 17:55:55 +02004285 if (compile_arguments(arg, cctx, &argcount, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004286 return FAIL;
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004287 if (generate_PCALL(cctx, argcount, name_start, type, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004288 return FAIL;
4289 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004290 else if (*p == '-' && p[1] == '>')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004291 {
Bram Moolenaar637cd7d2020-07-23 19:06:23 +02004292 char_u *pstart = p;
4293
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004294 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004295 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004296 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004297
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004298 // something->method()
4299 // Apply the '!', '-' and '+' first:
4300 // -1.0->func() works like (-1.0)->func()
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004301 if (compile_leader(cctx, TRUE, start_leader, end_leader) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004302 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004303
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004304 p += 2;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02004305 *arg = skipwhite(p);
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02004306 // No line break supported right after "->".
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01004307 if (**arg == '(')
Bram Moolenaar65c44152020-12-24 15:14:01 +01004308 {
Bram Moolenaar7e368202020-12-25 21:56:57 +01004309 int argcount = 1;
Bram Moolenaar2927c072021-04-05 19:41:21 +02004310 garray_T *stack = &cctx->ctx_type_stack;
4311 int type_idx_start = stack->ga_len;
Bram Moolenaar7e368202020-12-25 21:56:57 +01004312 type_T *type;
Bram Moolenaar2927c072021-04-05 19:41:21 +02004313 int expr_isn_start = cctx->ctx_instr.ga_len;
4314 int expr_isn_end;
4315 int arg_isn_count;
Bram Moolenaar7e368202020-12-25 21:56:57 +01004316
4317 // Funcref call: list->(Refs[2])(arg)
4318 // or lambda: list->((arg) => expr)(arg)
Bram Moolenaar2927c072021-04-05 19:41:21 +02004319 //
4320 // Fist compile the function expression.
4321 if (compile_parenthesis(arg, cctx, ppconst) == FAIL)
Bram Moolenaar7e368202020-12-25 21:56:57 +01004322 return FAIL;
Bram Moolenaar2927c072021-04-05 19:41:21 +02004323
4324 // Remember the next instruction index, where the instructions
4325 // for arguments are being written.
4326 expr_isn_end = cctx->ctx_instr.ga_len;
4327
4328 // Compile the arguments.
Bram Moolenaar7e368202020-12-25 21:56:57 +01004329 if (**arg != '(')
4330 {
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01004331 if (*skipwhite(*arg) == '(')
4332 emsg(_(e_nowhitespace));
4333 else
4334 semsg(_(e_missing_paren), *arg);
Bram Moolenaar7e368202020-12-25 21:56:57 +01004335 return FAIL;
4336 }
Bram Moolenaar7e368202020-12-25 21:56:57 +01004337 *arg = skipwhite(*arg + 1);
Bram Moolenaarf18332f2021-05-07 17:55:55 +02004338 if (compile_arguments(arg, cctx, &argcount, FALSE) == FAIL)
Bram Moolenaar7e368202020-12-25 21:56:57 +01004339 return FAIL;
4340
Bram Moolenaar2927c072021-04-05 19:41:21 +02004341 // Move the instructions for the arguments to before the
4342 // instructions of the expression and move the type of the
4343 // expression after the argument types. This is what ISN_PCALL
4344 // expects.
Bram Moolenaar7e368202020-12-25 21:56:57 +01004345 stack = &cctx->ctx_type_stack;
Bram Moolenaar2927c072021-04-05 19:41:21 +02004346 arg_isn_count = cctx->ctx_instr.ga_len - expr_isn_end;
4347 if (arg_isn_count > 0)
4348 {
4349 int expr_isn_count = expr_isn_end - expr_isn_start;
4350 isn_T *isn = ALLOC_MULT(isn_T, expr_isn_count);
4351
4352 if (isn == NULL)
4353 return FAIL;
4354 mch_memmove(isn, ((isn_T *)cctx->ctx_instr.ga_data)
4355 + expr_isn_start,
4356 sizeof(isn_T) * expr_isn_count);
4357 mch_memmove(((isn_T *)cctx->ctx_instr.ga_data)
4358 + expr_isn_start,
4359 ((isn_T *)cctx->ctx_instr.ga_data) + expr_isn_end,
4360 sizeof(isn_T) * arg_isn_count);
4361 mch_memmove(((isn_T *)cctx->ctx_instr.ga_data)
4362 + expr_isn_start + arg_isn_count,
4363 isn, sizeof(isn_T) * expr_isn_count);
4364 vim_free(isn);
4365
4366 type = ((type_T **)stack->ga_data)[type_idx_start];
4367 mch_memmove(((type_T **)stack->ga_data) + type_idx_start,
4368 ((type_T **)stack->ga_data) + type_idx_start + 1,
4369 sizeof(type_T *)
4370 * (stack->ga_len - type_idx_start - 1));
4371 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type;
4372 }
4373
Bram Moolenaar7e368202020-12-25 21:56:57 +01004374 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaarc4c56422021-07-21 20:38:46 +02004375 if (generate_PCALL(cctx, argcount, p - 2, type, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004376 return FAIL;
4377 }
4378 else
4379 {
4380 // method call: list->method()
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02004381 p = *arg;
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02004382 if (!eval_isnamec1(*p))
4383 {
Bram Moolenaar637cd7d2020-07-23 19:06:23 +02004384 semsg(_(e_trailing_arg), pstart);
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02004385 return FAIL;
4386 }
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02004387 if (ASCII_ISALPHA(*p) && p[1] == ':')
4388 p += 2;
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02004389 for ( ; eval_isnamec(*p); ++p)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004390 ;
4391 if (*p != '(')
4392 {
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02004393 semsg(_(e_missing_paren), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004394 return FAIL;
4395 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004396 if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004397 return FAIL;
4398 }
4399 }
Bram Moolenaarbadd8482020-07-31 22:38:17 +02004400 else if (**arg == '[')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004401 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004402 int is_slice = FALSE;
Bram Moolenaarb13af502020-02-17 21:12:08 +01004403
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02004404 // list index: list[123]
Bram Moolenaara6e67e42020-05-15 23:36:40 +02004405 // dict member: dict[key]
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02004406 // string index: text[123]
Bram Moolenaarcfc30232021-04-11 20:26:34 +02004407 // blob index: blob[123]
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02004408 // TODO: more arguments
4409 // TODO: recognize list or dict at runtime
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004410 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004411 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004412 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004413
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004414 ++p;
Bram Moolenaara7eedf32020-07-10 21:50:41 +02004415 if (may_get_next_line_error(p, arg, cctx) == FAIL)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02004416 return FAIL;
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004417 if (**arg == ':')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004418 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004419 // missing first index is equal to zero
4420 generate_PUSHNR(cctx, 0);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004421 }
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004422 else
4423 {
4424 if (compile_expr0(arg, cctx) == FAIL)
4425 return FAIL;
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004426 if (**arg == ':')
4427 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004428 semsg(_(e_white_space_required_before_and_after_str_at_str),
4429 ":", *arg);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004430 return FAIL;
4431 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004432 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004433 return FAIL;
4434 *arg = skipwhite(*arg);
4435 }
4436 if (**arg == ':')
4437 {
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004438 is_slice = TRUE;
4439 ++*arg;
4440 if (!IS_WHITE_OR_NUL(**arg) && **arg != ']')
4441 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004442 semsg(_(e_white_space_required_before_and_after_str_at_str),
4443 ":", *arg);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01004444 return FAIL;
4445 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004446 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004447 return FAIL;
4448 if (**arg == ']')
4449 // missing second index is equal to end of string
4450 generate_PUSHNR(cctx, -1);
4451 else
4452 {
4453 if (compile_expr0(arg, cctx) == FAIL)
Bram Moolenaar918a4242020-12-06 14:37:08 +01004454 return FAIL;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004455 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004456 return FAIL;
4457 *arg = skipwhite(*arg);
4458 }
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004459 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004460
4461 if (**arg != ']')
4462 {
4463 emsg(_(e_missbrac));
4464 return FAIL;
4465 }
Bram Moolenaarf2460a32020-02-07 22:09:54 +01004466 *arg = *arg + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004467
Bram Moolenaare42939a2021-04-05 17:11:17 +02004468 if (compile_member(is_slice, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02004469 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004470 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004471 else if (*p == '.' && p[1] != '.')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004472 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004473 // dictionary member: dict.name
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004474 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004475 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004476 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004477
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02004478 *arg = p + 1;
Bram Moolenaar90193e62021-04-04 20:49:50 +02004479 if (IS_WHITE_OR_NUL(**arg))
Bram Moolenaarc1f00662020-10-03 13:41:53 +02004480 {
4481 emsg(_(e_missing_name_after_dot));
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02004482 return FAIL;
Bram Moolenaarc1f00662020-10-03 13:41:53 +02004483 }
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02004484 p = *arg;
Bram Moolenaarb13ab992020-07-27 21:43:28 +02004485 if (eval_isdictc(*p))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004486 while (eval_isnamec(*p))
4487 MB_PTR_ADV(p);
4488 if (p == *arg)
4489 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02004490 semsg(_(e_syntax_error_at_str), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004491 return FAIL;
4492 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02004493 if (generate_STRINGMEMBER(cctx, *arg, p - *arg) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004494 return FAIL;
4495 *arg = p;
4496 }
4497 else
4498 break;
4499 }
4500
4501 // TODO - see handle_subscript():
4502 // Turn "dict.Func" into a partial for "Func" bound to "dict".
4503 // Don't do this when "Func" is already a partial that was bound
4504 // explicitly (pt_auto is FALSE).
4505
4506 return OK;
4507}
4508
4509/*
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004510 * Compile an expression at "*arg" and add instructions to "cctx->ctx_instr".
4511 * "arg" is advanced until after the expression, skipping white space.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004512 *
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004513 * If the value is a constant "ppconst->pp_used" will be non-zero.
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004514 * Before instructions are generated, any values in "ppconst" will generated.
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004515 *
4516 * This is the compiling equivalent of eval1(), eval2(), etc.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004517 */
4518
4519/*
4520 * number number constant
4521 * 0zFFFFFFFF Blob constant
4522 * "string" string constant
4523 * 'string' literal string constant
4524 * &option-name option value
4525 * @r register contents
4526 * identifier variable value
4527 * function() function call
4528 * $VAR environment variable
4529 * (expression) nested expression
4530 * [expr, expr] List
Bram Moolenaare0de1712020-12-02 17:36:54 +01004531 * {key: val, [key]: val} Dictionary
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004532 *
4533 * Also handle:
4534 * ! in front logical NOT
4535 * - in front unary minus
4536 * + in front unary plus (ignored)
4537 * trailing (arg) funcref/partial call
4538 * trailing [] subscript in String or List
4539 * trailing .name entry in Dictionary
4540 * trailing ->name() method call
4541 */
4542 static int
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004543compile_expr7(
4544 char_u **arg,
4545 cctx_T *cctx,
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004546 ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004547{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004548 char_u *start_leader, *end_leader;
4549 int ret = OK;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004550 typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used];
Bram Moolenaar1c747212020-05-09 18:28:34 +02004551 int used_before = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004552
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004553 ppconst->pp_is_const = FALSE;
4554
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004555 /*
4556 * Skip '!', '-' and '+' characters. They are handled later.
4557 */
4558 start_leader = *arg;
Bram Moolenaarb23279d2021-01-05 22:08:20 +01004559 if (eval_leader(arg, TRUE) == FAIL)
4560 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004561 end_leader = *arg;
4562
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004563 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004564 switch (**arg)
4565 {
4566 /*
4567 * Number constant.
4568 */
4569 case '0': // also for blob starting with 0z
4570 case '1':
4571 case '2':
4572 case '3':
4573 case '4':
4574 case '5':
4575 case '6':
4576 case '7':
4577 case '8':
4578 case '9':
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004579 case '.': if (eval_number(arg, rettv, TRUE, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004580 return FAIL;
Bram Moolenaar4301a722020-08-11 20:51:08 +02004581 // Apply "-" and "+" just before the number now, right to
4582 // left. Matters especially when "->" follows. Stops at
4583 // '!'.
4584 if (apply_leader(rettv, TRUE,
4585 start_leader, &end_leader) == FAIL)
4586 {
4587 clear_tv(rettv);
4588 return FAIL;
4589 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004590 break;
4591
4592 /*
4593 * String constant: "string".
4594 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004595 case '"': if (eval_string(arg, rettv, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004596 return FAIL;
4597 break;
4598
4599 /*
4600 * Literal string constant: 'str''ing'.
4601 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02004602 case '\'': if (eval_lit_string(arg, rettv, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004603 return FAIL;
4604 break;
4605
4606 /*
4607 * Constant Vim variable.
4608 */
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004609 case 'v': get_vim_constant(arg, rettv);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004610 ret = NOTDONE;
4611 break;
4612
4613 /*
Bram Moolenaara5565e42020-05-09 15:44:01 +02004614 * "true" constant
4615 */
4616 case 't': if (STRNCMP(*arg, "true", 4) == 0
4617 && !eval_isnamec((*arg)[4]))
4618 {
4619 *arg += 4;
4620 rettv->v_type = VAR_BOOL;
4621 rettv->vval.v_number = VVAL_TRUE;
4622 }
4623 else
4624 ret = NOTDONE;
4625 break;
4626
4627 /*
4628 * "false" constant
4629 */
4630 case 'f': if (STRNCMP(*arg, "false", 5) == 0
4631 && !eval_isnamec((*arg)[5]))
4632 {
4633 *arg += 5;
4634 rettv->v_type = VAR_BOOL;
4635 rettv->vval.v_number = VVAL_FALSE;
4636 }
4637 else
4638 ret = NOTDONE;
4639 break;
4640
4641 /*
Bram Moolenaar67977822021-01-03 21:53:53 +01004642 * "null" constant
4643 */
4644 case 'n': if (STRNCMP(*arg, "null", 4) == 0
Bram Moolenaarc23555d2021-03-10 19:04:07 +01004645 && !eval_isnamec((*arg)[4]))
Bram Moolenaar67977822021-01-03 21:53:53 +01004646 {
4647 *arg += 4;
4648 rettv->v_type = VAR_SPECIAL;
4649 rettv->vval.v_number = VVAL_NULL;
4650 }
4651 else
4652 ret = NOTDONE;
4653 break;
4654
4655 /*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004656 * List: [expr, expr]
4657 */
Bram Moolenaare507ff12021-01-31 21:47:42 +01004658 case '[': if (generate_ppconst(cctx, ppconst) == FAIL)
4659 return FAIL;
4660 ret = compile_list(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004661 break;
4662
4663 /*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004664 * Dictionary: {'key': val, 'key': val}
4665 */
Bram Moolenaare507ff12021-01-31 21:47:42 +01004666 case '{': if (generate_ppconst(cctx, ppconst) == FAIL)
4667 return FAIL;
4668 ret = compile_dict(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004669 break;
4670
4671 /*
4672 * Option value: &name
4673 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004674 case '&': if (generate_ppconst(cctx, ppconst) == FAIL)
4675 return FAIL;
4676 ret = compile_get_option(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004677 break;
4678
4679 /*
4680 * Environment variable: $VAR.
4681 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004682 case '$': if (generate_ppconst(cctx, ppconst) == FAIL)
4683 return FAIL;
4684 ret = compile_get_env(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004685 break;
4686
4687 /*
4688 * Register contents: @r.
4689 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004690 case '@': if (generate_ppconst(cctx, ppconst) == FAIL)
4691 return FAIL;
4692 ret = compile_get_register(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004693 break;
4694 /*
4695 * nested expression: (expression).
Bram Moolenaar65c44152020-12-24 15:14:01 +01004696 * lambda: (arg, arg) => expr
4697 * funcref: (arg, arg) => { statement }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004698 */
Bram Moolenaare462f522020-12-27 14:43:30 +01004699 case '(': // if compile_lambda returns NOTDONE then it must be (expr)
4700 ret = compile_lambda(arg, cctx);
4701 if (ret == NOTDONE)
Bram Moolenaar7e368202020-12-25 21:56:57 +01004702 ret = compile_parenthesis(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004703 break;
4704
4705 default: ret = NOTDONE;
4706 break;
4707 }
4708 if (ret == FAIL)
4709 return FAIL;
4710
Bram Moolenaar1c747212020-05-09 18:28:34 +02004711 if (rettv->v_type != VAR_UNKNOWN && used_before == ppconst->pp_used)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004712 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02004713 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004714 clear_tv(rettv);
4715 else
4716 // A constant expression can possibly be handled compile time,
4717 // return the value instead of generating code.
4718 ++ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004719 }
4720 else if (ret == NOTDONE)
4721 {
4722 char_u *p;
4723 int r;
4724
4725 if (!eval_isnamec1(**arg))
4726 {
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01004727 if (!vim9_bad_comment(*arg))
4728 {
4729 if (ends_excmd(*skipwhite(*arg)))
4730 semsg(_(e_empty_expression_str), *arg);
4731 else
4732 semsg(_(e_name_expected_str), *arg);
4733 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004734 return FAIL;
4735 }
4736
4737 // "name" or "name()"
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01004738 p = to_name_end(*arg, TRUE);
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004739 if (p - *arg == (size_t)1 && **arg == '_')
4740 {
4741 emsg(_(e_cannot_use_underscore_here));
4742 return FAIL;
4743 }
4744
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004745 if (*p == '(')
Bram Moolenaara5565e42020-05-09 15:44:01 +02004746 {
4747 r = compile_call(arg, p - *arg, cctx, ppconst, 0);
4748 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004749 else
Bram Moolenaara5565e42020-05-09 15:44:01 +02004750 {
4751 if (generate_ppconst(cctx, ppconst) == FAIL)
4752 return FAIL;
Bram Moolenaar0f769812020-09-12 18:32:34 +02004753 r = compile_load(arg, p, cctx, TRUE, TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02004754 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004755 if (r == FAIL)
4756 return FAIL;
4757 }
4758
Bram Moolenaar5c2fe642020-05-07 23:20:21 +02004759 // Handle following "[]", ".member", etc.
4760 // Then deal with prefixed '-', '+' and '!', if not done already.
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004761 if (compile_subscript(arg, cctx, start_leader, &end_leader,
Bram Moolenaara5565e42020-05-09 15:44:01 +02004762 ppconst) == FAIL)
4763 return FAIL;
4764 if (ppconst->pp_used > 0)
4765 {
4766 // apply the '!', '-' and '+' before the constant
4767 rettv = &ppconst->pp_tv[ppconst->pp_used - 1];
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004768 if (apply_leader(rettv, FALSE, start_leader, &end_leader) == FAIL)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004769 return FAIL;
4770 return OK;
4771 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004772 if (compile_leader(cctx, FALSE, start_leader, &end_leader) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004773 return FAIL;
Bram Moolenaar5c2fe642020-05-07 23:20:21 +02004774 return OK;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004775}
4776
4777/*
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004778 * Give the "white on both sides" error, taking the operator from "p[len]".
4779 */
4780 void
4781error_white_both(char_u *op, int len)
4782{
4783 char_u buf[10];
4784
4785 vim_strncpy(buf, op, len);
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004786 semsg(_(e_white_space_required_before_and_after_str_at_str), buf, op);
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004787}
4788
4789/*
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004790 * <type>expr7: runtime type check / conversion
4791 */
4792 static int
4793compile_expr7t(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
4794{
4795 type_T *want_type = NULL;
4796
4797 // Recognize <type>
4798 if (**arg == '<' && eval_isnamec1((*arg)[1]))
4799 {
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004800 ++*arg;
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004801 want_type = parse_type(arg, cctx->ctx_type_list, TRUE);
4802 if (want_type == NULL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004803 return FAIL;
4804
4805 if (**arg != '>')
4806 {
4807 if (*skipwhite(*arg) == '>')
Bram Moolenaarba98fb52021-02-07 18:06:29 +01004808 semsg(_(e_no_white_space_allowed_before_str_str), ">", *arg);
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004809 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02004810 emsg(_(e_missing_gt));
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004811 return FAIL;
4812 }
4813 ++*arg;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004814 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004815 return FAIL;
4816 }
4817
4818 if (compile_expr7(arg, cctx, ppconst) == FAIL)
4819 return FAIL;
4820
4821 if (want_type != NULL)
4822 {
4823 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaard1103582020-08-14 22:44:25 +02004824 type_T *actual;
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02004825 where_T where = WHERE_INIT;
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004826
Bram Moolenaard1103582020-08-14 22:44:25 +02004827 generate_ppconst(cctx, ppconst);
4828 actual = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaarf785aa12021-02-11 21:19:34 +01004829 if (check_type(want_type, actual, FALSE, where) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004830 {
Bram Moolenaar351ead02021-01-16 16:07:01 +01004831 if (need_type(actual, want_type, -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004832 return FAIL;
4833 }
4834 }
4835
4836 return OK;
4837}
4838
4839/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004840 * * number multiplication
4841 * / number division
4842 * % number modulo
4843 */
4844 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004845compile_expr6(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004846{
4847 char_u *op;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004848 char_u *next;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004849 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004850
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004851 // get the first expression
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004852 if (compile_expr7t(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004853 return FAIL;
4854
4855 /*
4856 * Repeat computing, until no "*", "/" or "%" is following.
4857 */
4858 for (;;)
4859 {
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004860 op = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004861 if (*op != '*' && *op != '/' && *op != '%')
4862 break;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004863 if (next != NULL)
4864 {
4865 *arg = next_line_from_context(cctx, TRUE);
4866 op = skipwhite(*arg);
4867 }
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004868
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004869 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[1]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004870 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004871 error_white_both(op, 1);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004872 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004873 }
Bram Moolenaar918a4242020-12-06 14:37:08 +01004874 if (may_get_next_line_error(op + 1, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004875 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004876
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004877 // get the second expression
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004878 if (compile_expr7t(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004879 return FAIL;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004880
4881 if (ppconst->pp_used == ppconst_used + 2
4882 && ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
4883 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004884 {
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01004885 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
4886 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
4887 varnumber_T res = 0;
4888 int failed = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004889
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004890 // both are numbers: compute the result
4891 switch (*op)
4892 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004893 case '*': res = tv1->vval.v_number * tv2->vval.v_number;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004894 break;
Bram Moolenaare64f83c2021-01-19 22:16:41 +01004895 case '/': res = num_divide(tv1->vval.v_number,
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01004896 tv2->vval.v_number, &failed);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004897 break;
Bram Moolenaare64f83c2021-01-19 22:16:41 +01004898 case '%': res = num_modulus(tv1->vval.v_number,
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01004899 tv2->vval.v_number, &failed);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004900 break;
4901 }
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01004902 if (failed)
4903 return FAIL;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004904 tv1->vval.v_number = res;
4905 --ppconst->pp_used;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004906 }
4907 else
4908 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004909 generate_ppconst(cctx, ppconst);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004910 generate_two_op(cctx, op);
4911 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004912 }
4913
4914 return OK;
4915}
4916
4917/*
Bram Moolenaard345fb92021-03-10 18:43:09 +01004918 * + number addition or list/blobl concatenation
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004919 * - number subtraction
4920 * .. string concatenation
4921 */
4922 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004923compile_expr5(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004924{
4925 char_u *op;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004926 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004927 int oplen;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004928 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004929
4930 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02004931 if (compile_expr6(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004932 return FAIL;
4933
4934 /*
4935 * Repeat computing, until no "+", "-" or ".." is following.
4936 */
4937 for (;;)
4938 {
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004939 op = may_peek_next_line(cctx, *arg, &next);
4940 if (*op != '+' && *op != '-' && !(*op == '.' && *(op + 1) == '.'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004941 break;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02004942 if (op[0] == op[1] && *op != '.' && next)
4943 // Finding "++" or "--" on the next line is a separate command.
4944 // But ".." is concatenation.
4945 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004946 oplen = (*op == '.' ? 2 : 1);
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004947 if (next != NULL)
4948 {
4949 *arg = next_line_from_context(cctx, TRUE);
4950 op = skipwhite(*arg);
4951 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004952
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004953 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[oplen]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004954 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004955 error_white_both(op, oplen);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004956 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004957 }
4958
Bram Moolenaare0de1712020-12-02 17:36:54 +01004959 if (may_get_next_line_error(op + oplen, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004960 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004961
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004962 // get the second expression
Bram Moolenaara5565e42020-05-09 15:44:01 +02004963 if (compile_expr6(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004964 return FAIL;
4965
Bram Moolenaara5565e42020-05-09 15:44:01 +02004966 if (ppconst->pp_used == ppconst_used + 2
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004967 && (*op == '.'
Bram Moolenaara5565e42020-05-09 15:44:01 +02004968 ? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING
4969 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING)
4970 : (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
4971 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004972 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02004973 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
4974 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004975
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004976 // concat/subtract/add constant numbers
4977 if (*op == '+')
4978 tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number;
4979 else if (*op == '-')
4980 tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number;
4981 else
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004982 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004983 // concatenate constant strings
4984 char_u *s1 = tv1->vval.v_string;
4985 char_u *s2 = tv2->vval.v_string;
4986 size_t len1 = STRLEN(s1);
4987
4988 tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1));
4989 if (tv1->vval.v_string == NULL)
4990 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02004991 clear_ppconst(ppconst);
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004992 return FAIL;
4993 }
4994 mch_memmove(tv1->vval.v_string, s1, len1);
4995 STRCPY(tv1->vval.v_string + len1, s2);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004996 vim_free(s1);
4997 vim_free(s2);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004998 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004999 --ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005000 }
5001 else
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02005002 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02005003 generate_ppconst(cctx, ppconst);
Bram Moolenaard345fb92021-03-10 18:43:09 +01005004 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02005005 if (*op == '.')
5006 {
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02005007 if (may_generate_2STRING(-2, FALSE, cctx) == FAIL
5008 || may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02005009 return FAIL;
5010 generate_instr_drop(cctx, ISN_CONCAT, 1);
5011 }
5012 else
5013 generate_two_op(cctx, op);
5014 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005015 }
5016
5017 return OK;
5018}
5019
5020/*
5021 * expr5a == expr5b
5022 * expr5a =~ expr5b
5023 * expr5a != expr5b
5024 * expr5a !~ expr5b
5025 * expr5a > expr5b
5026 * expr5a >= expr5b
5027 * expr5a < expr5b
5028 * expr5a <= expr5b
5029 * expr5a is expr5b
5030 * expr5a isnot expr5b
5031 *
5032 * Produces instructions:
5033 * EVAL expr5a Push result of "expr5a"
5034 * EVAL expr5b Push result of "expr5b"
5035 * COMPARE one of the compare instructions
5036 */
5037 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02005038compile_expr4(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005039{
Bram Moolenaar657137c2021-01-09 15:45:23 +01005040 exprtype_T type = EXPR_UNKNOWN;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005041 char_u *p;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005042 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005043 int len = 2;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005044 int type_is = FALSE;
Bram Moolenaara5565e42020-05-09 15:44:01 +02005045 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005046
5047 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02005048 if (compile_expr5(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005049 return FAIL;
5050
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005051 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar080457c2020-03-03 21:53:32 +01005052 type = get_compare_type(p, &len, &type_is);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005053
5054 /*
5055 * If there is a comparative operator, use it.
5056 */
5057 if (type != EXPR_UNKNOWN)
5058 {
5059 int ic = FALSE; // Default: do not ignore case
5060
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005061 if (next != NULL)
5062 {
5063 *arg = next_line_from_context(cctx, TRUE);
5064 p = skipwhite(*arg);
5065 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005066 if (type_is && (p[len] == '?' || p[len] == '#'))
5067 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02005068 semsg(_(e_invalid_expression_str), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005069 return FAIL;
5070 }
5071 // extra question mark appended: ignore case
5072 if (p[len] == '?')
5073 {
5074 ic = TRUE;
5075 ++len;
5076 }
5077 // extra '#' appended: match case (ignored)
5078 else if (p[len] == '#')
5079 ++len;
5080 // nothing appended: match case
5081
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005082 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[len]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005083 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02005084 error_white_both(p, len);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005085 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005086 }
5087
5088 // get the second variable
Bram Moolenaar918a4242020-12-06 14:37:08 +01005089 if (may_get_next_line_error(p + len, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005090 return FAIL;
5091
Bram Moolenaara5565e42020-05-09 15:44:01 +02005092 if (compile_expr5(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005093 return FAIL;
5094
Bram Moolenaara5565e42020-05-09 15:44:01 +02005095 if (ppconst->pp_used == ppconst_used + 2)
5096 {
5097 typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2];
5098 typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1];
5099 int ret;
5100
5101 // Both sides are a constant, compute the result now.
5102 // First check for a valid combination of types, this is more
5103 // strict than typval_compare().
Bram Moolenaar543e6f32020-07-10 22:45:38 +02005104 if (check_compare_types(type, tv1, tv2) == FAIL)
Bram Moolenaara5565e42020-05-09 15:44:01 +02005105 ret = FAIL;
5106 else
5107 {
5108 ret = typval_compare(tv1, tv2, type, ic);
5109 tv1->v_type = VAR_BOOL;
5110 tv1->vval.v_number = tv1->vval.v_number
5111 ? VVAL_TRUE : VVAL_FALSE;
5112 clear_tv(tv2);
5113 --ppconst->pp_used;
5114 }
5115 return ret;
5116 }
5117
5118 generate_ppconst(cctx, ppconst);
5119 return generate_COMPARE(cctx, type, ic);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005120 }
5121
5122 return OK;
5123}
5124
Bram Moolenaar7f141552020-05-09 17:35:53 +02005125static int compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
5126
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005127/*
5128 * Compile || or &&.
5129 */
5130 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02005131compile_and_or(
5132 char_u **arg,
5133 cctx_T *cctx,
5134 char *op,
5135 ppconst_T *ppconst,
5136 int ppconst_used UNUSED)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005137{
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005138 char_u *next;
5139 char_u *p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005140 int opchar = *op;
5141
5142 if (p[0] == opchar && p[1] == opchar)
5143 {
5144 garray_T *instr = &cctx->ctx_instr;
5145 garray_T end_ga;
5146
5147 /*
5148 * Repeat until there is no following "||" or "&&"
5149 */
5150 ga_init2(&end_ga, sizeof(int), 10);
5151 while (p[0] == opchar && p[1] == opchar)
5152 {
Bram Moolenaara7511c02021-04-03 21:47:07 +02005153 long start_lnum = SOURCING_LNUM;
Bram Moolenaar9e60e892021-07-15 15:40:58 +02005154 long save_sourcing_lnum;
Bram Moolenaara7511c02021-04-03 21:47:07 +02005155 int start_ctx_lnum = cctx->ctx_lnum;
5156 int save_lnum;
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005157 int status;
Bram Moolenaara7511c02021-04-03 21:47:07 +02005158
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005159 if (next != NULL)
5160 {
5161 *arg = next_line_from_context(cctx, TRUE);
5162 p = skipwhite(*arg);
5163 }
5164
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005165 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[2]))
5166 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01005167 semsg(_(e_white_space_required_before_and_after_str_at_str),
Bram Moolenaar90193e62021-04-04 20:49:50 +02005168 op, p);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005169 return FAIL;
5170 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005171
Bram Moolenaar9e60e892021-07-15 15:40:58 +02005172 save_sourcing_lnum = SOURCING_LNUM;
Bram Moolenaara7511c02021-04-03 21:47:07 +02005173 SOURCING_LNUM = start_lnum;
5174 save_lnum = cctx->ctx_lnum;
5175 cctx->ctx_lnum = start_ctx_lnum;
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005176
5177 status = check_ppconst_bool(ppconst);
5178 if (status == OK)
Bram Moolenaarea2d4072020-11-12 12:08:51 +01005179 {
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005180 // TODO: use ppconst if the value is a constant
5181 generate_ppconst(cctx, ppconst);
5182
5183 // Every part must evaluate to a bool.
5184 status = (bool_on_stack(cctx));
5185 if (status == OK)
5186 status = ga_grow(&end_ga, 1);
Bram Moolenaarea2d4072020-11-12 12:08:51 +01005187 }
Bram Moolenaara7511c02021-04-03 21:47:07 +02005188 cctx->ctx_lnum = save_lnum;
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005189 if (status == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005190 {
5191 ga_clear(&end_ga);
5192 return FAIL;
5193 }
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005194
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005195 *(((int *)end_ga.ga_data) + end_ga.ga_len) = instr->ga_len;
5196 ++end_ga.ga_len;
5197 generate_JUMP(cctx, opchar == '|'
Bram Moolenaar2bb26582020-10-03 22:52:39 +02005198 ? JUMP_IF_COND_TRUE : JUMP_IF_COND_FALSE, 0);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005199
5200 // eval the next expression
Bram Moolenaar9e60e892021-07-15 15:40:58 +02005201 SOURCING_LNUM = save_sourcing_lnum;
Bram Moolenaar918a4242020-12-06 14:37:08 +01005202 if (may_get_next_line_error(p + 2, arg, cctx) == FAIL)
Bram Moolenaar8bb0f542020-12-06 16:03:55 +01005203 {
5204 ga_clear(&end_ga);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005205 return FAIL;
Bram Moolenaar8bb0f542020-12-06 16:03:55 +01005206 }
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005207
Bram Moolenaara5565e42020-05-09 15:44:01 +02005208 if ((opchar == '|' ? compile_expr3(arg, cctx, ppconst)
5209 : compile_expr4(arg, cctx, ppconst)) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005210 {
5211 ga_clear(&end_ga);
5212 return FAIL;
5213 }
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005214
5215 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005216 }
Bram Moolenaar05bd9782021-07-21 21:37:28 +02005217
5218 if (check_ppconst_bool(ppconst) == FAIL)
5219 {
5220 ga_clear(&end_ga);
5221 return FAIL;
5222 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02005223 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005224
Bram Moolenaarea2d4072020-11-12 12:08:51 +01005225 // Every part must evaluate to a bool.
5226 if (bool_on_stack(cctx) == FAIL)
5227 {
5228 ga_clear(&end_ga);
5229 return FAIL;
5230 }
5231
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005232 // Fill in the end label in all jumps.
5233 while (end_ga.ga_len > 0)
5234 {
5235 isn_T *isn;
5236
5237 --end_ga.ga_len;
5238 isn = ((isn_T *)instr->ga_data)
5239 + *(((int *)end_ga.ga_data) + end_ga.ga_len);
5240 isn->isn_arg.jump.jump_where = instr->ga_len;
5241 }
5242 ga_clear(&end_ga);
5243 }
5244
5245 return OK;
5246}
5247
5248/*
5249 * expr4a && expr4a && expr4a logical AND
5250 *
5251 * Produces instructions:
5252 * EVAL expr4a Push result of "expr4a"
Bram Moolenaarea2d4072020-11-12 12:08:51 +01005253 * COND2BOOL convert to bool if needed
Bram Moolenaar2bb26582020-10-03 22:52:39 +02005254 * JUMP_IF_COND_FALSE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005255 * EVAL expr4b Push result of "expr4b"
Bram Moolenaar2bb26582020-10-03 22:52:39 +02005256 * JUMP_IF_COND_FALSE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005257 * EVAL expr4c Push result of "expr4c"
5258 * end:
5259 */
5260 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02005261compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005262{
Bram Moolenaara5565e42020-05-09 15:44:01 +02005263 int ppconst_used = ppconst->pp_used;
5264
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005265 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02005266 if (compile_expr4(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005267 return FAIL;
5268
5269 // || and && work almost the same
Bram Moolenaara5565e42020-05-09 15:44:01 +02005270 return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005271}
5272
5273/*
5274 * expr3a || expr3b || expr3c logical OR
5275 *
5276 * Produces instructions:
5277 * EVAL expr3a Push result of "expr3a"
Bram Moolenaarea2d4072020-11-12 12:08:51 +01005278 * COND2BOOL convert to bool if needed
Bram Moolenaar2bb26582020-10-03 22:52:39 +02005279 * JUMP_IF_COND_TRUE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005280 * EVAL expr3b Push result of "expr3b"
Bram Moolenaar2bb26582020-10-03 22:52:39 +02005281 * JUMP_IF_COND_TRUE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005282 * EVAL expr3c Push result of "expr3c"
5283 * end:
5284 */
5285 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02005286compile_expr2(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005287{
Bram Moolenaara5565e42020-05-09 15:44:01 +02005288 int ppconst_used = ppconst->pp_used;
5289
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005290 // eval the first expression
Bram Moolenaara5565e42020-05-09 15:44:01 +02005291 if (compile_expr3(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005292 return FAIL;
5293
5294 // || and && work almost the same
Bram Moolenaara5565e42020-05-09 15:44:01 +02005295 return compile_and_or(arg, cctx, "||", ppconst, ppconst_used);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005296}
5297
5298/*
5299 * Toplevel expression: expr2 ? expr1a : expr1b
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005300 * Produces instructions:
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005301 * EVAL expr2 Push result of "expr2"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005302 * JUMP_IF_FALSE alt jump if false
5303 * EVAL expr1a
5304 * JUMP_ALWAYS end
5305 * alt: EVAL expr1b
5306 * end:
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005307 *
5308 * Toplevel expression: expr2 ?? expr1
5309 * Produces instructions:
5310 * EVAL expr2 Push result of "expr2"
5311 * JUMP_AND_KEEP_IF_TRUE end jump if true
5312 * EVAL expr1
5313 * end:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005314 */
5315 static int
Bram Moolenaar7e368202020-12-25 21:56:57 +01005316compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005317{
5318 char_u *p;
Bram Moolenaara5565e42020-05-09 15:44:01 +02005319 int ppconst_used = ppconst->pp_used;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005320 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005321
Bram Moolenaar3988f642020-08-27 22:43:03 +02005322 // Ignore all kinds of errors when not producing code.
5323 if (cctx->ctx_skip == SKIP_YES)
5324 {
Bram Moolenaar7e368202020-12-25 21:56:57 +01005325 skip_expr_cctx(arg, cctx);
Bram Moolenaar3988f642020-08-27 22:43:03 +02005326 return OK;
5327 }
5328
Bram Moolenaar61a89812020-05-07 16:58:17 +02005329 // Evaluate the first expression.
Bram Moolenaara5565e42020-05-09 15:44:01 +02005330 if (compile_expr2(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005331 return FAIL;
5332
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005333 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005334 if (*p == '?')
5335 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005336 int op_falsy = p[1] == '?';
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005337 garray_T *instr = &cctx->ctx_instr;
5338 garray_T *stack = &cctx->ctx_type_stack;
5339 int alt_idx = instr->ga_len;
Bram Moolenaar38041da2020-06-21 22:17:18 +02005340 int end_idx = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005341 isn_T *isn;
Bram Moolenaar38041da2020-06-21 22:17:18 +02005342 type_T *type1 = NULL;
Bram Moolenaara5565e42020-05-09 15:44:01 +02005343 int has_const_expr = FALSE;
5344 int const_value = FALSE;
5345 int save_skip = cctx->ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005346
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005347 if (next != NULL)
5348 {
5349 *arg = next_line_from_context(cctx, TRUE);
5350 p = skipwhite(*arg);
5351 }
5352
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005353 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1 + op_falsy]))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005354 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01005355 semsg(_(e_white_space_required_before_and_after_str_at_str),
mityu4ac198c2021-05-28 17:52:40 +02005356 op_falsy ? "??" : "?", p);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005357 return FAIL;
5358 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005359
Bram Moolenaara5565e42020-05-09 15:44:01 +02005360 if (ppconst->pp_used == ppconst_used + 1)
5361 {
5362 // the condition is a constant, we know whether the ? or the :
5363 // expression is to be evaluated.
5364 has_const_expr = TRUE;
Bram Moolenaar13106602020-10-04 16:06:05 +02005365 if (op_falsy)
5366 const_value = tv2bool(&ppconst->pp_tv[ppconst_used]);
5367 else
5368 {
5369 int error = FALSE;
5370
5371 const_value = tv_get_bool_chk(&ppconst->pp_tv[ppconst_used],
5372 &error);
5373 if (error)
5374 return FAIL;
5375 }
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005376 cctx->ctx_skip = save_skip == SKIP_YES ||
5377 (op_falsy ? const_value : !const_value) ? SKIP_YES : SKIP_NOT;
5378
5379 if (op_falsy && cctx->ctx_skip == SKIP_YES)
5380 // "left ?? right" and "left" is truthy: produce "left"
5381 generate_ppconst(cctx, ppconst);
5382 else
5383 {
5384 clear_tv(&ppconst->pp_tv[ppconst_used]);
5385 --ppconst->pp_used;
5386 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02005387 }
5388 else
5389 {
5390 generate_ppconst(cctx, ppconst);
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005391 if (op_falsy)
5392 end_idx = instr->ga_len;
5393 generate_JUMP(cctx, op_falsy
5394 ? JUMP_AND_KEEP_IF_TRUE : JUMP_IF_FALSE, 0);
5395 if (op_falsy)
5396 type1 = ((type_T **)stack->ga_data)[stack->ga_len];
Bram Moolenaara5565e42020-05-09 15:44:01 +02005397 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005398
5399 // evaluate the second expression; any type is accepted
Bram Moolenaar918a4242020-12-06 14:37:08 +01005400 if (may_get_next_line_error(p + 1 + op_falsy, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02005401 return FAIL;
Bram Moolenaara5565e42020-05-09 15:44:01 +02005402 if (compile_expr1(arg, cctx, ppconst) == FAIL)
Bram Moolenaara6d53682020-01-28 23:04:06 +01005403 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005404
Bram Moolenaara5565e42020-05-09 15:44:01 +02005405 if (!has_const_expr)
5406 {
5407 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005408
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005409 if (!op_falsy)
5410 {
5411 // remember the type and drop it
5412 --stack->ga_len;
5413 type1 = ((type_T **)stack->ga_data)[stack->ga_len];
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005414
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005415 end_idx = instr->ga_len;
5416 generate_JUMP(cctx, JUMP_ALWAYS, 0);
Bram Moolenaara5565e42020-05-09 15:44:01 +02005417
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005418 // jump here from JUMP_IF_FALSE
5419 isn = ((isn_T *)instr->ga_data) + alt_idx;
5420 isn->isn_arg.jump.jump_where = instr->ga_len;
5421 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02005422 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005423
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005424 if (!op_falsy)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005425 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005426 // Check for the ":".
5427 p = may_peek_next_line(cctx, *arg, &next);
5428 if (*p != ':')
5429 {
5430 emsg(_(e_missing_colon));
5431 return FAIL;
5432 }
5433 if (next != NULL)
5434 {
5435 *arg = next_line_from_context(cctx, TRUE);
5436 p = skipwhite(*arg);
5437 }
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02005438
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005439 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1]))
5440 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01005441 semsg(_(e_white_space_required_before_and_after_str_at_str),
5442 ":", p);
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005443 return FAIL;
5444 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005445
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005446 // evaluate the third expression
5447 if (has_const_expr)
5448 cctx->ctx_skip = save_skip == SKIP_YES || const_value
Bram Moolenaar9b68c822020-06-18 19:31:08 +02005449 ? SKIP_YES : SKIP_NOT;
Bram Moolenaar918a4242020-12-06 14:37:08 +01005450 if (may_get_next_line_error(p + 1, arg, cctx) == FAIL)
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005451 return FAIL;
5452 if (compile_expr1(arg, cctx, ppconst) == FAIL)
5453 return FAIL;
5454 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005455
Bram Moolenaara5565e42020-05-09 15:44:01 +02005456 if (!has_const_expr)
5457 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005458 type_T **typep;
5459
Bram Moolenaara5565e42020-05-09 15:44:01 +02005460 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005461
Bram Moolenaara5565e42020-05-09 15:44:01 +02005462 // If the types differ, the result has a more generic type.
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005463 typep = ((type_T **)stack->ga_data) + stack->ga_len - 1;
5464 common_type(type1, *typep, typep, cctx->ctx_type_list);
Bram Moolenaara5565e42020-05-09 15:44:01 +02005465
Bram Moolenaar92f26c22020-10-03 20:17:30 +02005466 // jump here from JUMP_ALWAYS or JUMP_AND_KEEP_IF_TRUE
Bram Moolenaara5565e42020-05-09 15:44:01 +02005467 isn = ((isn_T *)instr->ga_data) + end_idx;
5468 isn->isn_arg.jump.jump_where = instr->ga_len;
5469 }
5470
5471 cctx->ctx_skip = save_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005472 }
5473 return OK;
5474}
5475
5476/*
Bram Moolenaara5565e42020-05-09 15:44:01 +02005477 * Toplevel expression.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005478 * Sets "is_const" (if not NULL) to indicate the value is a constant.
5479 * Returns OK or FAIL.
Bram Moolenaara5565e42020-05-09 15:44:01 +02005480 */
5481 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005482compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const)
Bram Moolenaara5565e42020-05-09 15:44:01 +02005483{
5484 ppconst_T ppconst;
5485
5486 CLEAR_FIELD(ppconst);
5487 if (compile_expr1(arg, cctx, &ppconst) == FAIL)
5488 {
5489 clear_ppconst(&ppconst);
5490 return FAIL;
5491 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005492 if (is_const != NULL)
5493 *is_const = ppconst.pp_used > 0 || ppconst.pp_is_const;
Bram Moolenaara5565e42020-05-09 15:44:01 +02005494 if (generate_ppconst(cctx, &ppconst) == FAIL)
5495 return FAIL;
5496 return OK;
5497}
5498
5499/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005500 * Toplevel expression.
5501 */
5502 static int
5503compile_expr0(char_u **arg, cctx_T *cctx)
5504{
5505 return compile_expr0_ext(arg, cctx, NULL);
5506}
5507
5508/*
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02005509 * Compile "return [expr]".
5510 * When "legacy" is TRUE evaluate [expr] with legacy syntax
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005511 */
5512 static char_u *
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02005513compile_return(char_u *arg, int check_return_type, int legacy, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005514{
5515 char_u *p = arg;
5516 garray_T *stack = &cctx->ctx_type_stack;
5517 type_T *stack_type;
5518
5519 if (*p != NUL && *p != '|' && *p != '\n')
5520 {
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02005521 if (legacy)
5522 {
5523 int save_flags = cmdmod.cmod_flags;
5524
5525 generate_LEGACY_EVAL(cctx, p);
5526 if (need_type(&t_any, cctx->ctx_ufunc->uf_ret_type, -1,
5527 0, cctx, FALSE, FALSE) == FAIL)
5528 return NULL;
5529 cmdmod.cmod_flags |= CMOD_LEGACY;
5530 (void)skip_expr(&p, NULL);
5531 cmdmod.cmod_flags = save_flags;
5532 }
5533 else
5534 {
5535 // compile return argument into instructions
5536 if (compile_expr0(&p, cctx) == FAIL)
5537 return NULL;
5538 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005539
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005540 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar05a55512020-07-05 15:52:19 +02005541 {
Bram Moolenaara9931532021-06-12 15:58:16 +02005542 // "check_return_type" with uf_ret_type set to &t_unknown is used
5543 // for an inline function without a specified return type. Set the
5544 // return type here.
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005545 stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaara9931532021-06-12 15:58:16 +02005546 if ((check_return_type && (cctx->ctx_ufunc->uf_ret_type == NULL
Bram Moolenaar328eac22021-01-07 19:23:08 +01005547 || cctx->ctx_ufunc->uf_ret_type == &t_unknown
5548 || cctx->ctx_ufunc->uf_ret_type == &t_any))
Bram Moolenaara9931532021-06-12 15:58:16 +02005549 || (!check_return_type
5550 && cctx->ctx_ufunc->uf_ret_type == &t_unknown))
Bram Moolenaar9e68c322020-12-25 12:38:04 +01005551 {
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005552 cctx->ctx_ufunc->uf_ret_type = stack_type;
Bram Moolenaar9e68c322020-12-25 12:38:04 +01005553 }
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005554 else
Bram Moolenaar05a55512020-07-05 15:52:19 +02005555 {
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005556 if (cctx->ctx_ufunc->uf_ret_type->tt_type == VAR_VOID
5557 && stack_type->tt_type != VAR_VOID
5558 && stack_type->tt_type != VAR_UNKNOWN)
5559 {
5560 emsg(_(e_returning_value_in_function_without_return_type));
5561 return NULL;
5562 }
5563 if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1,
Bram Moolenaar351ead02021-01-16 16:07:01 +01005564 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005565 return NULL;
5566 }
Bram Moolenaar05a55512020-07-05 15:52:19 +02005567 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005568 }
5569 else
5570 {
Bram Moolenaar9e68c322020-12-25 12:38:04 +01005571 // "check_return_type" cannot be TRUE, only used for a lambda which
Bram Moolenaar9be61bb2020-03-30 22:51:24 +02005572 // always has an argument.
Bram Moolenaar4c683752020-04-05 21:38:23 +02005573 if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID
5574 && cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005575 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005576 emsg(_(e_missing_return_value));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005577 return NULL;
5578 }
5579
5580 // No argument, return zero.
5581 generate_PUSHNR(cctx, 0);
5582 }
Bram Moolenaar7cd24222021-01-12 18:58:39 +01005583
5584 // Undo any command modifiers.
5585 generate_undo_cmdmods(cctx);
5586
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01005587 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_RETURN) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005588 return NULL;
5589
5590 // "return val | endif" is possible
5591 return skipwhite(p);
5592}
5593
5594/*
Bram Moolenaar04b12692020-05-04 23:24:44 +02005595 * Get a line from the compilation context, compatible with exarg_T getline().
5596 * Return a pointer to the line in allocated memory.
5597 * Return NULL for end-of-file or some error.
5598 */
5599 static char_u *
5600exarg_getline(
5601 int c UNUSED,
5602 void *cookie,
5603 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02005604 getline_opt_T options UNUSED)
Bram Moolenaar04b12692020-05-04 23:24:44 +02005605{
5606 cctx_T *cctx = (cctx_T *)cookie;
Bram Moolenaar66250c92020-08-20 15:02:42 +02005607 char_u *p;
Bram Moolenaar04b12692020-05-04 23:24:44 +02005608
Bram Moolenaar66250c92020-08-20 15:02:42 +02005609 for (;;)
Bram Moolenaar04b12692020-05-04 23:24:44 +02005610 {
Bram Moolenaar2914a202020-09-27 18:24:03 +02005611 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len - 1)
Bram Moolenaar66250c92020-08-20 15:02:42 +02005612 return NULL;
5613 ++cctx->ctx_lnum;
5614 p = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
5615 // Comment lines result in NULL pointers, skip them.
5616 if (p != NULL)
5617 return vim_strsave(p);
Bram Moolenaar04b12692020-05-04 23:24:44 +02005618 }
Bram Moolenaar04b12692020-05-04 23:24:44 +02005619}
5620
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01005621 void
5622fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx)
5623{
5624 eap->getline = exarg_getline;
5625 eap->cookie = cctx;
5626}
5627
Bram Moolenaar04b12692020-05-04 23:24:44 +02005628/*
5629 * Compile a nested :def command.
5630 */
5631 static char_u *
5632compile_nested_function(exarg_T *eap, cctx_T *cctx)
5633{
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005634 int is_global = *eap->arg == 'g' && eap->arg[1] == ':';
Bram Moolenaar04b12692020-05-04 23:24:44 +02005635 char_u *name_start = eap->arg;
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02005636 char_u *name_end = to_name_end(eap->arg, TRUE);
Bram Moolenaareef21022020-08-01 22:16:43 +02005637 char_u *lambda_name;
Bram Moolenaar04b12692020-05-04 23:24:44 +02005638 ufunc_T *ufunc;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005639 int r = FAIL;
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02005640 compiletype_T compile_type;
Bram Moolenaar04b12692020-05-04 23:24:44 +02005641
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02005642 if (eap->forceit)
Bram Moolenaar8b848ca2020-09-10 22:28:01 +02005643 {
5644 emsg(_(e_cannot_use_bang_with_nested_def));
5645 return NULL;
5646 }
5647
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01005648 if (*name_start == '/')
5649 {
5650 name_end = skip_regexp(name_start + 1, '/', TRUE);
5651 if (*name_end == '/')
5652 ++name_end;
5653 eap->nextcmd = check_nextcmd(name_end);
5654 }
5655 if (name_end == name_start || *skipwhite(name_end) != '(')
5656 {
5657 if (!ends_excmd2(name_start, name_end))
5658 {
5659 semsg(_(e_invalid_command_str), eap->cmd);
5660 return NULL;
5661 }
5662
5663 // "def" or "def Name": list functions
5664 if (generate_DEF(cctx, name_start, name_end - name_start) == FAIL)
5665 return NULL;
5666 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
5667 }
5668
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02005669 // Only g:Func() can use a namespace.
5670 if (name_start[1] == ':' && !is_global)
5671 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005672 semsg(_(e_namespace_not_supported_str), name_start);
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02005673 return NULL;
5674 }
Bram Moolenaar057e84a2021-02-28 16:55:11 +01005675 if (check_defined(name_start, name_end - name_start, cctx, FALSE) == FAIL)
Bram Moolenaareef21022020-08-01 22:16:43 +02005676 return NULL;
5677
Bram Moolenaar04b12692020-05-04 23:24:44 +02005678 eap->arg = name_end;
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01005679 fill_exarg_from_cctx(eap, cctx);
5680
Bram Moolenaar04b12692020-05-04 23:24:44 +02005681 eap->forceit = FALSE;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005682 lambda_name = vim_strsave(get_lambda_name());
5683 if (lambda_name == NULL)
5684 return NULL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02005685 ufunc = define_function(eap, lambda_name);
Bram Moolenaar04b12692020-05-04 23:24:44 +02005686
Bram Moolenaar822ba242020-05-24 23:00:18 +02005687 if (ufunc == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005688 {
5689 r = eap->skip ? OK : FAIL;
5690 goto theend;
5691 }
Bram Moolenaar8863bda2021-03-17 18:42:08 +01005692
5693 // copy over the block scope IDs before compiling
5694 if (!is_global && cctx->ctx_ufunc->uf_block_depth > 0)
5695 {
5696 int block_depth = cctx->ctx_ufunc->uf_block_depth;
5697
5698 ufunc->uf_block_ids = ALLOC_MULT(int, block_depth);
5699 if (ufunc->uf_block_ids != NULL)
5700 {
5701 mch_memmove(ufunc->uf_block_ids, cctx->ctx_ufunc->uf_block_ids,
5702 sizeof(int) * block_depth);
5703 ufunc->uf_block_depth = block_depth;
5704 }
5705 }
5706
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02005707 compile_type = COMPILE_TYPE(ufunc);
5708#ifdef FEAT_PROFILE
5709 // If the outer function is profiled, also compile the nested function for
5710 // profiling.
5711 if (cctx->ctx_compile_type == CT_PROFILE)
5712 compile_type = CT_PROFILE;
5713#endif
5714 if (func_needs_compiling(ufunc, compile_type)
5715 && compile_def_function(ufunc, TRUE, compile_type, cctx) == FAIL)
Bram Moolenaar4ee711f2020-09-23 18:51:11 +02005716 {
5717 func_ptr_unref(ufunc);
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005718 goto theend;
Bram Moolenaar4ee711f2020-09-23 18:51:11 +02005719 }
Bram Moolenaar04b12692020-05-04 23:24:44 +02005720
Bram Moolenaar648594e2021-07-11 17:55:01 +02005721#ifdef FEAT_PROFILE
5722 // When the outer function is compiled for profiling, the nested function
5723 // may be called without profiling. Compile it here in the right context.
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02005724 if (compile_type == CT_PROFILE && func_needs_compiling(ufunc, CT_NONE))
Bram Moolenaar648594e2021-07-11 17:55:01 +02005725 compile_def_function(ufunc, FALSE, CT_NONE, cctx);
5726#endif
5727
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005728 if (is_global)
5729 {
5730 char_u *func_name = vim_strnsave(name_start + 2,
5731 name_end - name_start - 2);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02005732
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005733 if (func_name == NULL)
5734 r = FAIL;
5735 else
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005736 {
Bram Moolenaareef21022020-08-01 22:16:43 +02005737 r = generate_NEWFUNC(cctx, lambda_name, func_name);
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005738 lambda_name = NULL;
5739 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005740 }
5741 else
5742 {
5743 // Define a local variable for the function reference.
Bram Moolenaare8211a32020-10-09 22:04:29 +02005744 lvar_T *lvar = reserve_local(cctx, name_start, name_end - name_start,
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005745 TRUE, ufunc->uf_func_type);
Bram Moolenaare8211a32020-10-09 22:04:29 +02005746
Bram Moolenaareef21022020-08-01 22:16:43 +02005747 if (lvar == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005748 goto theend;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02005749 if (generate_FUNCREF(cctx, ufunc) == FAIL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005750 goto theend;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005751 r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
5752 }
Bram Moolenaar61a89812020-05-07 16:58:17 +02005753 // TODO: warning for trailing text?
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005754
5755theend:
5756 vim_free(lambda_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005757 return r == FAIL ? NULL : (char_u *)"";
Bram Moolenaar04b12692020-05-04 23:24:44 +02005758}
5759
5760/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005761 * Return the length of an assignment operator, or zero if there isn't one.
5762 */
5763 int
5764assignment_len(char_u *p, int *heredoc)
5765{
5766 if (*p == '=')
5767 {
5768 if (p[1] == '<' && p[2] == '<')
5769 {
5770 *heredoc = TRUE;
5771 return 3;
5772 }
5773 return 1;
5774 }
5775 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=')
5776 return 2;
5777 if (STRNCMP(p, "..=", 3) == 0)
5778 return 3;
5779 return 0;
5780}
5781
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005782/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005783 * Generate the load instruction for "name".
5784 */
5785 static void
5786generate_loadvar(
5787 cctx_T *cctx,
5788 assign_dest_T dest,
5789 char_u *name,
5790 lvar_T *lvar,
5791 type_T *type)
5792{
5793 switch (dest)
5794 {
5795 case dest_option:
5796 // TODO: check the option exists
5797 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
5798 break;
5799 case dest_global:
Bram Moolenaar03290b82020-12-19 16:30:44 +01005800 if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
5801 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
5802 else
5803 generate_LOAD(cctx, ISN_LOADAUTO, 0, name, type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005804 break;
5805 case dest_buffer:
5806 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
5807 break;
5808 case dest_window:
5809 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
5810 break;
5811 case dest_tab:
5812 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
5813 break;
5814 case dest_script:
5815 compile_load_scriptvar(cctx,
5816 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
5817 break;
5818 case dest_env:
5819 // Include $ in the name here
5820 generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
5821 break;
5822 case dest_reg:
5823 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string);
5824 break;
5825 case dest_vimvar:
5826 generate_LOADV(cctx, name + 2, TRUE);
5827 break;
5828 case dest_local:
Bram Moolenaarab360522021-01-10 14:02:28 +01005829 if (lvar->lv_from_outer > 0)
5830 generate_LOADOUTER(cctx, lvar->lv_idx, lvar->lv_from_outer,
5831 type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005832 else
5833 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
5834 break;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005835 case dest_expr:
5836 // list or dict value should already be on the stack.
5837 break;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005838 }
5839}
5840
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005841/*
5842 * Skip over "[expr]" or ".member".
5843 * Does not check for any errors.
5844 */
5845 static char_u *
5846skip_index(char_u *start)
5847{
5848 char_u *p = start;
5849
5850 if (*p == '[')
5851 {
5852 p = skipwhite(p + 1);
5853 (void)skip_expr(&p, NULL);
5854 p = skipwhite(p);
5855 if (*p == ']')
5856 return p + 1;
5857 return p;
5858 }
5859 // if (*p == '.')
5860 return to_name_end(p + 1, TRUE);
5861}
5862
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005863 void
5864vim9_declare_error(char_u *name)
5865{
5866 char *scope = "";
5867
5868 switch (*name)
5869 {
Bram Moolenaar7fe87552020-06-21 20:38:28 +02005870 case 'g': scope = _("global"); break;
5871 case 'b': scope = _("buffer"); break;
5872 case 'w': scope = _("window"); break;
5873 case 't': scope = _("tab"); break;
5874 case 'v': scope = "v:"; break;
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02005875 case '$': semsg(_(e_cannot_declare_an_environment_variable), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005876 return;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005877 case '&': semsg(_(e_cannot_declare_an_option), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005878 return;
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02005879 case '@': semsg(_(e_cannot_declare_a_register_str), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005880 return;
Bram Moolenaar7fe87552020-06-21 20:38:28 +02005881 default: return;
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005882 }
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02005883 semsg(_(e_cannot_declare_a_scope_variable), scope, name);
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005884}
5885
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005886/*
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005887 * For one assignment figure out the type of destination. Return it in "dest".
5888 * When not recognized "dest" is not set.
5889 * For an option "opt_flags" is set.
5890 * For a v:var "vimvaridx" is set.
5891 * "type" is set to the destination type if known, unchanted otherwise.
5892 * Return FAIL if an error message was given.
5893 */
5894 static int
5895get_var_dest(
5896 char_u *name,
5897 assign_dest_T *dest,
5898 int cmdidx,
5899 int *opt_flags,
5900 int *vimvaridx,
5901 type_T **type,
5902 cctx_T *cctx)
5903{
5904 char_u *p;
5905
5906 if (*name == '&')
5907 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005908 int cc;
5909 long numval;
5910 getoption_T opt_type;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005911
5912 *dest = dest_option;
5913 if (cmdidx == CMD_final || cmdidx == CMD_const)
5914 {
5915 emsg(_(e_const_option));
5916 return FAIL;
5917 }
5918 p = name;
5919 p = find_option_end(&p, opt_flags);
5920 if (p == NULL)
5921 {
5922 // cannot happen?
Bram Moolenaar108010a2021-06-27 22:03:33 +02005923 emsg(_(e_unexpected_characters_in_assignment));
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005924 return FAIL;
5925 }
5926 cc = *p;
5927 *p = NUL;
5928 opt_type = get_option_value(skip_option_env_lead(name),
5929 &numval, NULL, *opt_flags);
5930 *p = cc;
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005931 switch (opt_type)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005932 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005933 case gov_unknown:
5934 semsg(_(e_unknown_option), name);
5935 return FAIL;
5936 case gov_string:
5937 case gov_hidden_string:
5938 *type = &t_string;
5939 break;
5940 case gov_bool:
5941 case gov_hidden_bool:
5942 *type = &t_bool;
5943 break;
5944 case gov_number:
5945 case gov_hidden_number:
5946 *type = &t_number;
5947 break;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005948 }
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005949 }
5950 else if (*name == '$')
5951 {
5952 *dest = dest_env;
5953 *type = &t_string;
5954 }
5955 else if (*name == '@')
5956 {
Bram Moolenaar13e45d12021-06-26 13:28:35 +02005957 if (name[1] != '@'
5958 && (!valid_yank_reg(name[1], FALSE) || name[1] == '.'))
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005959 {
5960 emsg_invreg(name[1]);
5961 return FAIL;
5962 }
5963 *dest = dest_reg;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02005964 *type = name[1] == '#' ? &t_number_or_string : &t_string;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005965 }
5966 else if (STRNCMP(name, "g:", 2) == 0)
5967 {
5968 *dest = dest_global;
5969 }
5970 else if (STRNCMP(name, "b:", 2) == 0)
5971 {
5972 *dest = dest_buffer;
5973 }
5974 else if (STRNCMP(name, "w:", 2) == 0)
5975 {
5976 *dest = dest_window;
5977 }
5978 else if (STRNCMP(name, "t:", 2) == 0)
5979 {
5980 *dest = dest_tab;
5981 }
5982 else if (STRNCMP(name, "v:", 2) == 0)
5983 {
5984 typval_T *vtv;
5985 int di_flags;
5986
5987 *vimvaridx = find_vim_var(name + 2, &di_flags);
5988 if (*vimvaridx < 0)
5989 {
5990 semsg(_(e_variable_not_found_str), name);
5991 return FAIL;
5992 }
5993 // We use the current value of "sandbox" here, is that OK?
5994 if (var_check_ro(di_flags, name, FALSE))
5995 return FAIL;
5996 *dest = dest_vimvar;
5997 vtv = get_vim_var_tv(*vimvaridx);
5998 *type = typval2type_vimvar(vtv, cctx->ctx_type_list);
5999 }
6000 return OK;
6001}
6002
6003/*
6004 * Generate a STORE instruction for "dest", not being "dest_local".
6005 * Return FAIL when out of memory.
6006 */
6007 static int
6008generate_store_var(
6009 cctx_T *cctx,
6010 assign_dest_T dest,
6011 int opt_flags,
6012 int vimvaridx,
6013 int scriptvar_idx,
6014 int scriptvar_sid,
6015 type_T *type,
6016 char_u *name)
6017{
6018 switch (dest)
6019 {
6020 case dest_option:
6021 return generate_STOREOPT(cctx, skip_option_env_lead(name),
6022 opt_flags);
6023 case dest_global:
6024 // include g: with the name, easier to execute that way
Bram Moolenaar03290b82020-12-19 16:30:44 +01006025 return generate_STORE(cctx, vim_strchr(name, AUTOLOAD_CHAR) == NULL
6026 ? ISN_STOREG : ISN_STOREAUTO, 0, name);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006027 case dest_buffer:
6028 // include b: with the name, easier to execute that way
6029 return generate_STORE(cctx, ISN_STOREB, 0, name);
6030 case dest_window:
6031 // include w: with the name, easier to execute that way
6032 return generate_STORE(cctx, ISN_STOREW, 0, name);
6033 case dest_tab:
6034 // include t: with the name, easier to execute that way
6035 return generate_STORE(cctx, ISN_STORET, 0, name);
6036 case dest_env:
6037 return generate_STORE(cctx, ISN_STOREENV, 0, name + 1);
6038 case dest_reg:
Bram Moolenaar74f4a962021-06-17 21:03:07 +02006039 return generate_STORE(cctx, ISN_STOREREG,
6040 name[1] == '@' ? '"' : name[1], NULL);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006041 case dest_vimvar:
6042 return generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL);
6043 case dest_script:
6044 if (scriptvar_idx < 0)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02006045 // "s:" may be included in the name.
6046 return generate_OLDSCRIPT(cctx, ISN_STORES, name,
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006047 scriptvar_sid, type);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006048 return generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT,
6049 scriptvar_sid, scriptvar_idx, type);
6050 case dest_local:
6051 case dest_expr:
6052 // cannot happen
6053 break;
6054 }
6055 return FAIL;
6056}
6057
Bram Moolenaar752fc692021-01-04 21:57:11 +01006058 static int
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02006059generate_store_lhs(cctx_T *cctx, lhs_T *lhs, int instr_count)
6060{
6061 if (lhs->lhs_dest != dest_local)
6062 return generate_store_var(cctx, lhs->lhs_dest,
6063 lhs->lhs_opt_flags, lhs->lhs_vimvaridx,
6064 lhs->lhs_scriptvar_idx, lhs->lhs_scriptvar_sid,
6065 lhs->lhs_type, lhs->lhs_name);
6066
6067 if (lhs->lhs_lvar != NULL)
6068 {
6069 garray_T *instr = &cctx->ctx_instr;
6070 isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
6071
6072 // optimization: turn "var = 123" from ISN_PUSHNR + ISN_STORE into
6073 // ISN_STORENR
6074 if (lhs->lhs_lvar->lv_from_outer == 0
6075 && instr->ga_len == instr_count + 1
6076 && isn->isn_type == ISN_PUSHNR)
6077 {
6078 varnumber_T val = isn->isn_arg.number;
6079 garray_T *stack = &cctx->ctx_type_stack;
6080
6081 isn->isn_type = ISN_STORENR;
6082 isn->isn_arg.storenr.stnr_idx = lhs->lhs_lvar->lv_idx;
6083 isn->isn_arg.storenr.stnr_val = val;
6084 if (stack->ga_len > 0)
6085 --stack->ga_len;
6086 }
6087 else if (lhs->lhs_lvar->lv_from_outer > 0)
6088 generate_STOREOUTER(cctx, lhs->lhs_lvar->lv_idx,
6089 lhs->lhs_lvar->lv_from_outer);
6090 else
6091 generate_STORE(cctx, ISN_STORE, lhs->lhs_lvar->lv_idx, NULL);
6092 }
6093 return OK;
6094}
6095
6096 static int
Bram Moolenaar752fc692021-01-04 21:57:11 +01006097is_decl_command(int cmdidx)
6098{
6099 return cmdidx == CMD_let || cmdidx == CMD_var
6100 || cmdidx == CMD_final || cmdidx == CMD_const;
6101}
6102
6103/*
6104 * Figure out the LHS type and other properties for an assignment or one item
6105 * of ":unlet" with an index.
6106 * Returns OK or FAIL.
6107 */
6108 static int
6109compile_lhs(
6110 char_u *var_start,
6111 lhs_T *lhs,
6112 int cmdidx,
6113 int heredoc,
6114 int oplen,
6115 cctx_T *cctx)
6116{
6117 char_u *var_end;
6118 int is_decl = is_decl_command(cmdidx);
6119
6120 CLEAR_POINTER(lhs);
6121 lhs->lhs_dest = dest_local;
6122 lhs->lhs_vimvaridx = -1;
6123 lhs->lhs_scriptvar_idx = -1;
6124
6125 // "dest_end" is the end of the destination, including "[expr]" or
6126 // ".name".
6127 // "var_end" is the end of the variable/option/etc. name.
6128 lhs->lhs_dest_end = skip_var_one(var_start, FALSE);
6129 if (*var_start == '@')
6130 var_end = var_start + 2;
6131 else
6132 {
6133 // skip over the leading "&", "&l:", "&g:" and "$"
6134 var_end = skip_option_env_lead(var_start);
6135 var_end = to_name_end(var_end, TRUE);
6136 }
6137
6138 // "a: type" is declaring variable "a" with a type, not dict "a:".
6139 if (is_decl && lhs->lhs_dest_end == var_start + 2
6140 && lhs->lhs_dest_end[-1] == ':')
6141 --lhs->lhs_dest_end;
6142 if (is_decl && var_end == var_start + 2 && var_end[-1] == ':')
6143 --var_end;
6144
6145 // compute the length of the destination without "[expr]" or ".name"
6146 lhs->lhs_varlen = var_end - var_start;
Bram Moolenaar753bcf82021-04-21 14:24:24 +02006147 lhs->lhs_varlen_total = lhs->lhs_varlen;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006148 lhs->lhs_name = vim_strnsave(var_start, lhs->lhs_varlen);
6149 if (lhs->lhs_name == NULL)
6150 return FAIL;
Bram Moolenaar08251752021-01-11 21:20:18 +01006151
6152 if (lhs->lhs_dest_end > var_start + lhs->lhs_varlen)
6153 // Something follows after the variable: "var[idx]" or "var.key".
6154 lhs->lhs_has_index = TRUE;
6155
Bram Moolenaar752fc692021-01-04 21:57:11 +01006156 if (heredoc)
6157 lhs->lhs_type = &t_list_string;
6158 else
6159 lhs->lhs_type = &t_any;
6160
6161 if (cctx->ctx_skip != SKIP_YES)
6162 {
6163 int declare_error = FALSE;
6164
6165 if (get_var_dest(lhs->lhs_name, &lhs->lhs_dest, cmdidx,
6166 &lhs->lhs_opt_flags, &lhs->lhs_vimvaridx,
6167 &lhs->lhs_type, cctx) == FAIL)
6168 return FAIL;
Bram Moolenaard877a572021-04-01 19:42:48 +02006169 if (lhs->lhs_dest != dest_local
6170 && cmdidx != CMD_const && cmdidx != CMD_final)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006171 {
6172 // Specific kind of variable recognized.
6173 declare_error = is_decl;
6174 }
6175 else
6176 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006177 // No specific kind of variable recognized, just a name.
Bram Moolenaard0edaf92021-05-28 21:06:08 +02006178 if (check_reserved_name(lhs->lhs_name) == FAIL)
6179 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006180
6181 if (lookup_local(var_start, lhs->lhs_varlen,
6182 &lhs->lhs_local_lvar, cctx) == OK)
6183 lhs->lhs_lvar = &lhs->lhs_local_lvar;
6184 else
6185 {
6186 CLEAR_FIELD(lhs->lhs_arg_lvar);
6187 if (arg_exists(var_start, lhs->lhs_varlen,
6188 &lhs->lhs_arg_lvar.lv_idx, &lhs->lhs_arg_lvar.lv_type,
6189 &lhs->lhs_arg_lvar.lv_from_outer, cctx) == OK)
6190 {
6191 if (is_decl)
6192 {
6193 semsg(_(e_str_is_used_as_argument), lhs->lhs_name);
6194 return FAIL;
6195 }
6196 lhs->lhs_lvar = &lhs->lhs_arg_lvar;
6197 }
6198 }
6199 if (lhs->lhs_lvar != NULL)
6200 {
6201 if (is_decl)
6202 {
6203 semsg(_(e_variable_already_declared), lhs->lhs_name);
6204 return FAIL;
6205 }
6206 }
6207 else
6208 {
6209 int script_namespace = lhs->lhs_varlen > 1
6210 && STRNCMP(var_start, "s:", 2) == 0;
6211 int script_var = (script_namespace
6212 ? script_var_exists(var_start + 2, lhs->lhs_varlen - 2,
Bram Moolenaar15e5e532021-04-07 21:21:13 +02006213 cctx)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006214 : script_var_exists(var_start, lhs->lhs_varlen,
Bram Moolenaar15e5e532021-04-07 21:21:13 +02006215 cctx)) == OK;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006216 imported_T *import =
6217 find_imported(var_start, lhs->lhs_varlen, cctx);
6218
6219 if (script_namespace || script_var || import != NULL)
6220 {
6221 char_u *rawname = lhs->lhs_name
6222 + (lhs->lhs_name[1] == ':' ? 2 : 0);
6223
6224 if (is_decl)
6225 {
6226 if (script_namespace)
6227 semsg(_(e_cannot_declare_script_variable_in_function),
6228 lhs->lhs_name);
6229 else
Bram Moolenaar057e84a2021-02-28 16:55:11 +01006230 semsg(_(e_variable_already_declared_in_script_str),
Bram Moolenaar752fc692021-01-04 21:57:11 +01006231 lhs->lhs_name);
6232 return FAIL;
6233 }
6234 else if (cctx->ctx_ufunc->uf_script_ctx_version
6235 == SCRIPT_VERSION_VIM9
6236 && script_namespace
6237 && !script_var && import == NULL)
6238 {
6239 semsg(_(e_unknown_variable_str), lhs->lhs_name);
6240 return FAIL;
6241 }
6242
6243 lhs->lhs_dest = dest_script;
6244
6245 // existing script-local variables should have a type
6246 lhs->lhs_scriptvar_sid = current_sctx.sc_sid;
6247 if (import != NULL)
6248 lhs->lhs_scriptvar_sid = import->imp_sid;
6249 if (SCRIPT_ID_VALID(lhs->lhs_scriptvar_sid))
6250 {
Bram Moolenaar08251752021-01-11 21:20:18 +01006251 // Check writable only when no index follows.
Bram Moolenaar752fc692021-01-04 21:57:11 +01006252 lhs->lhs_scriptvar_idx = get_script_item_idx(
Bram Moolenaar08251752021-01-11 21:20:18 +01006253 lhs->lhs_scriptvar_sid, rawname,
6254 lhs->lhs_has_index ? ASSIGN_FINAL : ASSIGN_CONST,
6255 cctx);
Bram Moolenaar752fc692021-01-04 21:57:11 +01006256 if (lhs->lhs_scriptvar_idx >= 0)
6257 {
6258 scriptitem_T *si = SCRIPT_ITEM(
6259 lhs->lhs_scriptvar_sid);
6260 svar_T *sv =
6261 ((svar_T *)si->sn_var_vals.ga_data)
6262 + lhs->lhs_scriptvar_idx;
6263 lhs->lhs_type = sv->sv_type;
6264 }
6265 }
6266 }
Bram Moolenaar057e84a2021-02-28 16:55:11 +01006267 else if (check_defined(var_start, lhs->lhs_varlen, cctx, FALSE)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006268 == FAIL)
6269 return FAIL;
6270 }
6271 }
6272
6273 if (declare_error)
6274 {
6275 vim9_declare_error(lhs->lhs_name);
6276 return FAIL;
6277 }
6278 }
6279
6280 // handle "a:name" as a name, not index "name" on "a"
6281 if (lhs->lhs_varlen > 1 || var_start[lhs->lhs_varlen] != ':')
6282 var_end = lhs->lhs_dest_end;
6283
6284 if (lhs->lhs_dest != dest_option)
6285 {
6286 if (is_decl && *var_end == ':')
6287 {
6288 char_u *p;
6289
6290 // parse optional type: "let var: type = expr"
6291 if (!VIM_ISWHITE(var_end[1]))
6292 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01006293 semsg(_(e_white_space_required_after_str_str), ":", var_end);
Bram Moolenaar752fc692021-01-04 21:57:11 +01006294 return FAIL;
6295 }
6296 p = skipwhite(var_end + 1);
6297 lhs->lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE);
6298 if (lhs->lhs_type == NULL)
6299 return FAIL;
6300 lhs->lhs_has_type = TRUE;
6301 }
6302 else if (lhs->lhs_lvar != NULL)
6303 lhs->lhs_type = lhs->lhs_lvar->lv_type;
6304 }
6305
Bram Moolenaare42939a2021-04-05 17:11:17 +02006306 if (oplen == 3 && !heredoc
6307 && lhs->lhs_dest != dest_global
6308 && !lhs->lhs_has_index
6309 && lhs->lhs_type->tt_type != VAR_STRING
6310 && lhs->lhs_type->tt_type != VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006311 {
6312 emsg(_(e_can_only_concatenate_to_string));
6313 return FAIL;
6314 }
6315
6316 if (lhs->lhs_lvar == NULL && lhs->lhs_dest == dest_local
6317 && cctx->ctx_skip != SKIP_YES)
6318 {
6319 if (oplen > 1 && !heredoc)
6320 {
6321 // +=, /=, etc. require an existing variable
6322 semsg(_(e_cannot_use_operator_on_new_variable), lhs->lhs_name);
6323 return FAIL;
6324 }
6325 if (!is_decl)
6326 {
6327 semsg(_(e_unknown_variable_str), lhs->lhs_name);
6328 return FAIL;
6329 }
6330
Bram Moolenaar3f327882021-03-17 20:56:38 +01006331 // Check the name is valid for a funcref.
Bram Moolenaar752fc692021-01-04 21:57:11 +01006332 if ((lhs->lhs_type->tt_type == VAR_FUNC
6333 || lhs->lhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01006334 && var_wrong_func_name(lhs->lhs_name, TRUE))
Bram Moolenaar752fc692021-01-04 21:57:11 +01006335 return FAIL;
Bram Moolenaar3f327882021-03-17 20:56:38 +01006336
6337 // New local variable.
Bram Moolenaar752fc692021-01-04 21:57:11 +01006338 lhs->lhs_lvar = reserve_local(cctx, var_start, lhs->lhs_varlen,
6339 cmdidx == CMD_final || cmdidx == CMD_const, lhs->lhs_type);
6340 if (lhs->lhs_lvar == NULL)
6341 return FAIL;
6342 lhs->lhs_new_local = TRUE;
6343 }
6344
6345 lhs->lhs_member_type = lhs->lhs_type;
Bram Moolenaar08251752021-01-11 21:20:18 +01006346 if (lhs->lhs_has_index)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006347 {
6348 // Something follows after the variable: "var[idx]" or "var.key".
6349 // TODO: should we also handle "->func()" here?
6350 if (is_decl)
6351 {
6352 emsg(_(e_cannot_use_index_when_declaring_variable));
6353 return FAIL;
6354 }
6355
6356 if (var_start[lhs->lhs_varlen] == '['
6357 || var_start[lhs->lhs_varlen] == '.')
6358 {
6359 char_u *after = var_start + lhs->lhs_varlen;
6360 char_u *p;
6361
6362 // Only the last index is used below, if there are others
6363 // before it generate code for the expression. Thus for
6364 // "ll[1][2]" the expression is "ll[1]" and "[2]" is the index.
6365 for (;;)
6366 {
6367 p = skip_index(after);
6368 if (*p != '[' && *p != '.')
Bram Moolenaar753bcf82021-04-21 14:24:24 +02006369 {
6370 lhs->lhs_varlen_total = p - var_start;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006371 break;
Bram Moolenaar753bcf82021-04-21 14:24:24 +02006372 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006373 after = p;
6374 }
6375 if (after > var_start + lhs->lhs_varlen)
6376 {
6377 lhs->lhs_varlen = after - var_start;
6378 lhs->lhs_dest = dest_expr;
6379 // We don't know the type before evaluating the expression,
6380 // use "any" until then.
6381 lhs->lhs_type = &t_any;
6382 }
6383
Bram Moolenaar752fc692021-01-04 21:57:11 +01006384 if (lhs->lhs_type->tt_member == NULL)
6385 lhs->lhs_member_type = &t_any;
6386 else
6387 lhs->lhs_member_type = lhs->lhs_type->tt_member;
6388 }
6389 else
6390 {
6391 semsg("Not supported yet: %s", var_start);
6392 return FAIL;
6393 }
6394 }
6395 return OK;
6396}
6397
6398/*
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02006399 * Figure out the LHS and check a few errors.
6400 */
6401 static int
6402compile_assign_lhs(
6403 char_u *var_start,
6404 lhs_T *lhs,
6405 int cmdidx,
6406 int is_decl,
6407 int heredoc,
6408 int oplen,
6409 cctx_T *cctx)
6410{
6411 if (compile_lhs(var_start, lhs, cmdidx, heredoc, oplen, cctx) == FAIL)
6412 return FAIL;
6413
6414 if (!lhs->lhs_has_index && lhs->lhs_lvar == &lhs->lhs_arg_lvar)
6415 {
6416 semsg(_(e_cannot_assign_to_argument), lhs->lhs_name);
6417 return FAIL;
6418 }
6419 if (!is_decl && lhs->lhs_lvar != NULL
6420 && lhs->lhs_lvar->lv_const && !lhs->lhs_has_index)
6421 {
6422 semsg(_(e_cannot_assign_to_constant), lhs->lhs_name);
6423 return FAIL;
6424 }
6425 return OK;
6426}
6427
6428/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02006429 * For an assignment with an index, compile the "idx" in "var[idx]" or "key" in
6430 * "var.key".
Bram Moolenaar752fc692021-01-04 21:57:11 +01006431 */
6432 static int
Bram Moolenaare42939a2021-04-05 17:11:17 +02006433compile_assign_index(
Bram Moolenaar752fc692021-01-04 21:57:11 +01006434 char_u *var_start,
6435 lhs_T *lhs,
Bram Moolenaare42939a2021-04-05 17:11:17 +02006436 int *range,
Bram Moolenaar752fc692021-01-04 21:57:11 +01006437 cctx_T *cctx)
6438{
Bram Moolenaar752fc692021-01-04 21:57:11 +01006439 size_t varlen = lhs->lhs_varlen;
Bram Moolenaare42939a2021-04-05 17:11:17 +02006440 char_u *p;
6441 int r = OK;
Bram Moolenaar68452172021-04-12 21:21:02 +02006442 int need_white_before = TRUE;
6443 int empty_second;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006444
Bram Moolenaar752fc692021-01-04 21:57:11 +01006445 p = var_start + varlen;
6446 if (*p == '[')
6447 {
6448 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02006449 if (*p == ':')
6450 {
6451 // empty first index, push zero
6452 r = generate_PUSHNR(cctx, 0);
6453 need_white_before = FALSE;
6454 }
6455 else
6456 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006457
6458 if (r == OK && *skipwhite(p) == ':')
6459 {
6460 // unlet var[idx : idx]
Bram Moolenaar68452172021-04-12 21:21:02 +02006461 // blob[idx : idx] = value
Bram Moolenaare42939a2021-04-05 17:11:17 +02006462 *range = TRUE;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006463 p = skipwhite(p);
Bram Moolenaar68452172021-04-12 21:21:02 +02006464 empty_second = *skipwhite(p + 1) == ']';
6465 if ((need_white_before && !IS_WHITE_OR_NUL(p[-1]))
6466 || (!empty_second && !IS_WHITE_OR_NUL(p[1])))
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006467 {
6468 semsg(_(e_white_space_required_before_and_after_str_at_str),
6469 ":", p);
6470 return FAIL;
6471 }
6472 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02006473 if (*p == ']')
6474 // empty second index, push "none"
6475 r = generate_PUSHSPEC(cctx, VVAL_NONE);
6476 else
6477 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006478 }
6479
Bram Moolenaar752fc692021-01-04 21:57:11 +01006480 if (r == OK && *skipwhite(p) != ']')
6481 {
6482 // this should not happen
6483 emsg(_(e_missbrac));
6484 r = FAIL;
6485 }
6486 }
6487 else // if (*p == '.')
6488 {
6489 char_u *key_end = to_name_end(p + 1, TRUE);
6490 char_u *key = vim_strnsave(p + 1, key_end - p - 1);
6491
6492 r = generate_PUSHS(cctx, key);
6493 }
Bram Moolenaare42939a2021-04-05 17:11:17 +02006494 return r;
6495}
6496
6497/*
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02006498 * For a LHS with an index, load the variable to be indexed.
6499 */
6500 static int
6501compile_load_lhs(
6502 lhs_T *lhs,
6503 char_u *var_start,
6504 type_T *rhs_type,
6505 cctx_T *cctx)
6506{
6507 if (lhs->lhs_dest == dest_expr)
6508 {
6509 size_t varlen = lhs->lhs_varlen;
6510 int c = var_start[varlen];
6511 char_u *p = var_start;
6512 garray_T *stack = &cctx->ctx_type_stack;
6513
6514 // Evaluate "ll[expr]" of "ll[expr][idx]"
6515 var_start[varlen] = NUL;
6516 if (compile_expr0(&p, cctx) == OK && p != var_start + varlen)
6517 {
6518 // this should not happen
6519 emsg(_(e_missbrac));
Bram Moolenaarc9605f02021-04-06 21:29:32 +02006520 var_start[varlen] = c;
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02006521 return FAIL;
6522 }
6523 var_start[varlen] = c;
6524
6525 lhs->lhs_type = stack->ga_len == 0 ? &t_void
6526 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
6527 // now we can properly check the type
6528 if (rhs_type != NULL && lhs->lhs_type->tt_member != NULL
6529 && rhs_type != &t_void
6530 && need_type(rhs_type, lhs->lhs_type->tt_member, -2, 0, cctx,
6531 FALSE, FALSE) == FAIL)
6532 return FAIL;
6533 }
6534 else
6535 generate_loadvar(cctx, lhs->lhs_dest, lhs->lhs_name,
6536 lhs->lhs_lvar, lhs->lhs_type);
6537 return OK;
6538}
6539
6540/*
Bram Moolenaara369c3d2021-04-21 16:00:10 +02006541 * Produce code for loading "lhs" and also take care of an index.
6542 * Return OK/FAIL.
6543 */
6544 static int
6545compile_load_lhs_with_index(lhs_T *lhs, char_u *var_start, cctx_T *cctx)
6546{
6547 compile_load_lhs(lhs, var_start, NULL, cctx);
6548
6549 if (lhs->lhs_has_index)
6550 {
6551 int range = FALSE;
6552
6553 // Get member from list or dict. First compile the
6554 // index value.
6555 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
6556 return FAIL;
6557 if (range)
6558 {
6559 semsg(_(e_cannot_use_range_with_assignment_operator_str),
6560 var_start);
6561 return FAIL;
6562 }
6563
6564 // Get the member.
6565 if (compile_member(FALSE, cctx) == FAIL)
6566 return FAIL;
6567 }
6568 return OK;
6569}
6570
6571/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02006572 * Assignment to a list or dict member, or ":unlet" for the item, using the
6573 * information in "lhs".
6574 * Returns OK or FAIL.
6575 */
6576 static int
6577compile_assign_unlet(
6578 char_u *var_start,
6579 lhs_T *lhs,
6580 int is_assign,
6581 type_T *rhs_type,
6582 cctx_T *cctx)
6583{
Bram Moolenaare42939a2021-04-05 17:11:17 +02006584 vartype_T dest_type;
Bram Moolenaare42939a2021-04-05 17:11:17 +02006585 garray_T *stack = &cctx->ctx_type_stack;
6586 int range = FALSE;
6587
Bram Moolenaar68452172021-04-12 21:21:02 +02006588 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006589 return FAIL;
Bram Moolenaar68452172021-04-12 21:21:02 +02006590 if (is_assign && range && lhs->lhs_type != &t_blob
6591 && lhs->lhs_type != &t_any)
6592 {
6593 semsg(_(e_cannot_use_range_with_assignment_str), var_start);
6594 return FAIL;
6595 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006596
6597 if (lhs->lhs_type == &t_any)
6598 {
6599 // Index on variable of unknown type: check at runtime.
6600 dest_type = VAR_ANY;
6601 }
6602 else
6603 {
6604 dest_type = lhs->lhs_type->tt_type;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006605 if (dest_type == VAR_DICT && range)
6606 {
6607 emsg(e_cannot_use_range_with_dictionary);
6608 return FAIL;
6609 }
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02006610 if (dest_type == VAR_DICT
6611 && may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006612 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02006613 if (dest_type == VAR_LIST || dest_type == VAR_BLOB)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006614 {
Bram Moolenaar51e93322021-04-17 20:44:56 +02006615 type_T *type;
6616
6617 if (range)
6618 {
6619 type = ((type_T **)stack->ga_data)[stack->ga_len - 2];
6620 if (need_type(type, &t_number,
6621 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006622 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02006623 }
6624 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar63cb6562021-07-20 22:21:59 +02006625 if ((dest_type != VAR_BLOB && type != &t_special)
Bram Moolenaar51e93322021-04-17 20:44:56 +02006626 && need_type(type, &t_number,
6627 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006628 return FAIL;
6629 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006630 }
6631
6632 // Load the dict or list. On the stack we then have:
6633 // - value (for assignment, not for :unlet)
6634 // - index
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006635 // - for [a : b] second index
Bram Moolenaar752fc692021-01-04 21:57:11 +01006636 // - variable
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02006637 if (compile_load_lhs(lhs, var_start, rhs_type, cctx) == FAIL)
6638 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006639
Bram Moolenaar68452172021-04-12 21:21:02 +02006640 if (dest_type == VAR_LIST || dest_type == VAR_DICT
6641 || dest_type == VAR_BLOB || dest_type == VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006642 {
6643 if (is_assign)
6644 {
Bram Moolenaar68452172021-04-12 21:21:02 +02006645 if (range)
6646 {
6647 if (generate_instr_drop(cctx, ISN_STORERANGE, 4) == NULL)
6648 return FAIL;
6649 }
6650 else
6651 {
6652 isn_T *isn = generate_instr_drop(cctx, ISN_STOREINDEX, 3);
Bram Moolenaar752fc692021-01-04 21:57:11 +01006653
Bram Moolenaar68452172021-04-12 21:21:02 +02006654 if (isn == NULL)
6655 return FAIL;
6656 isn->isn_arg.vartype = dest_type;
6657 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006658 }
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01006659 else if (range)
6660 {
6661 if (generate_instr_drop(cctx, ISN_UNLETRANGE, 3) == NULL)
6662 return FAIL;
6663 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006664 else
6665 {
6666 if (generate_instr_drop(cctx, ISN_UNLETINDEX, 2) == NULL)
6667 return FAIL;
6668 }
6669 }
6670 else
6671 {
6672 emsg(_(e_indexable_type_required));
6673 return FAIL;
6674 }
6675
6676 return OK;
6677}
6678
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006679/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006680 * Compile declaration and assignment:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02006681 * "let name"
6682 * "var name = expr"
6683 * "final name = expr"
6684 * "const name = expr"
6685 * "name = expr"
6686 * "arg" points to "name".
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006687 * "++arg" and "--arg"
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006688 * Return NULL for an error.
6689 * Return "arg" if it does not look like a variable list.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006690 */
6691 static char_u *
6692compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
6693{
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006694 char_u *var_start;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006695 char_u *p;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006696 char_u *end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006697 char_u *ret = NULL;
6698 int var_count = 0;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006699 int var_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006700 int semicolon = 0;
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02006701 int did_generate_slice = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006702 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006703 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006704 char_u *op;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006705 int oplen = 0;
6706 int heredoc = FALSE;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006707 int incdec = FALSE;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006708 type_T *rhs_type = &t_any;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006709 char_u *sp;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006710 int is_decl = is_decl_command(cmdidx);
6711 lhs_T lhs;
Bram Moolenaar77709b12021-04-03 21:01:01 +02006712 long start_lnum = SOURCING_LNUM;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006713
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006714 // Skip over the "var" or "[var, var]" to get to any "=".
6715 p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE);
6716 if (p == NULL)
6717 return *arg == '[' ? arg : NULL;
6718
6719 if (var_count > 0 && is_decl)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006720 {
Bram Moolenaarc7db5772020-07-21 20:55:50 +02006721 // TODO: should we allow this, and figure out type inference from list
6722 // members?
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006723 emsg(_(e_cannot_use_list_for_declaration));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006724 return NULL;
6725 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006726 lhs.lhs_name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006727
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006728 sp = p;
6729 p = skipwhite(p);
6730 op = p;
6731 oplen = assignment_len(p, &heredoc);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006732
6733 if (var_count > 0 && oplen == 0)
6734 // can be something like "[1, 2]->func()"
6735 return arg;
6736
Bram Moolenaar004d9b02020-11-30 21:40:03 +01006737 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !IS_WHITE_OR_NUL(op[oplen])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006738 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02006739 error_white_both(op, oplen);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006740 return NULL;
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02006741 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006742 if (eap->cmdidx == CMD_increment || eap->cmdidx == CMD_decrement)
6743 {
Bram Moolenaar22480d12021-06-25 21:31:09 +02006744 if (VIM_ISWHITE(eap->cmd[2]))
6745 {
6746 semsg(_(e_no_white_space_allowed_after_str_str),
6747 eap->cmdidx == CMD_increment ? "++" : "--", eap->cmd);
6748 return NULL;
6749 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006750 op = (char_u *)(eap->cmdidx == CMD_increment ? "+=" : "-=");
6751 oplen = 2;
6752 incdec = TRUE;
6753 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006754
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006755 if (heredoc)
6756 {
6757 list_T *l;
6758 listitem_T *li;
6759
6760 // [let] varname =<< [trim] {end}
Bram Moolenaar04b12692020-05-04 23:24:44 +02006761 eap->getline = exarg_getline;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006762 eap->cookie = cctx;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02006763 l = heredoc_get(eap, op + 3, FALSE);
Bram Moolenaarc0e29012020-09-27 14:22:48 +02006764 if (l == NULL)
6765 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006766
Bram Moolenaar078269b2020-09-21 20:35:55 +02006767 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006768 {
Bram Moolenaar078269b2020-09-21 20:35:55 +02006769 // Push each line and the create the list.
6770 FOR_ALL_LIST_ITEMS(l, li)
6771 {
6772 generate_PUSHS(cctx, li->li_tv.vval.v_string);
6773 li->li_tv.vval.v_string = NULL;
6774 }
6775 generate_NEWLIST(cctx, l->lv_len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006776 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006777 list_free(l);
6778 p += STRLEN(p);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006779 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006780 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006781 else if (var_count > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006782 {
Bram Moolenaar004d9b02020-11-30 21:40:03 +01006783 char_u *wp;
6784
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006785 // for "[var, var] = expr" evaluate the expression here, loop over the
6786 // list of variables below.
Bram Moolenaar004d9b02020-11-30 21:40:03 +01006787 // A line break may follow the "=".
Bram Moolenaard25ec2c2020-03-30 21:05:45 +02006788
Bram Moolenaar004d9b02020-11-30 21:40:03 +01006789 wp = op + oplen;
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01006790 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01006791 return FAIL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006792 if (compile_expr0(&p, cctx) == FAIL)
6793 return NULL;
6794 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006795
Bram Moolenaar9b68c822020-06-18 19:31:08 +02006796 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006797 {
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006798 type_T *stacktype;
6799
Bram Moolenaarec5929d2020-04-07 20:53:39 +02006800 stacktype = stack->ga_len == 0 ? &t_void
6801 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006802 if (stacktype->tt_type == VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006803 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006804 emsg(_(e_cannot_use_void_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006805 goto theend;
6806 }
Bram Moolenaar351ead02021-01-16 16:07:01 +01006807 if (need_type(stacktype, &t_list_any, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006808 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006809 goto theend;
Bram Moolenaare8593122020-07-18 15:17:02 +02006810 // TODO: check the length of a constant list here
Bram Moolenaar9af78762020-06-16 11:34:42 +02006811 generate_CHECKLEN(cctx, semicolon ? var_count - 1 : var_count,
6812 semicolon);
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006813 if (stacktype->tt_member != NULL)
6814 rhs_type = stacktype->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006815 }
6816 }
6817
6818 /*
6819 * Loop over variables in "[var, var] = expr".
6820 * For "var = expr" and "let var: type" this is done only once.
6821 */
6822 if (var_count > 0)
6823 var_start = skipwhite(arg + 1); // skip over the "["
6824 else
6825 var_start = arg;
6826 for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++)
6827 {
Bram Moolenaar6977dba2021-07-04 22:48:12 +02006828 int instr_count = -1;
6829 int save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006830
Bram Moolenaarf93bbd02021-04-10 22:35:43 +02006831 if (var_start[0] == '_' && !eval_isnamec(var_start[1]))
6832 {
6833 // Ignore underscore in "[a, _, b] = list".
6834 if (var_count > 0)
6835 {
6836 var_start = skipwhite(var_start + 2);
6837 continue;
6838 }
6839 emsg(_(e_cannot_use_underscore_here));
6840 goto theend;
6841 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006842 vim_free(lhs.lhs_name);
6843
6844 /*
6845 * Figure out the LHS type and other properties.
6846 */
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02006847 if (compile_assign_lhs(var_start, &lhs, cmdidx,
6848 is_decl, heredoc, oplen, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006849 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006850 if (!heredoc)
6851 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02006852 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006853 {
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006854 if (oplen > 0 && var_count == 0)
6855 {
6856 // skip over the "=" and the expression
6857 p = skipwhite(op + oplen);
Bram Moolenaar169502f2021-04-21 12:19:35 +02006858 (void)compile_expr0(&p, cctx);
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006859 }
6860 }
6861 else if (oplen > 0)
6862 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006863 int is_const = FALSE;
Bram Moolenaar7f764942020-12-02 15:11:18 +01006864 char_u *wp;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006865
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02006866 // for "+=", "*=", "..=" etc. first load the current value
6867 if (*op != '='
6868 && compile_load_lhs_with_index(&lhs, var_start,
6869 cctx) == FAIL)
6870 goto theend;
6871
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006872 // For "var = expr" evaluate the expression.
6873 if (var_count == 0)
6874 {
6875 int r;
6876
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006877 // Compile the expression.
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006878 instr_count = instr->ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006879 if (incdec)
Bram Moolenaar21e51222020-12-04 12:43:29 +01006880 {
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006881 r = generate_PUSHNR(cctx, 1);
6882 }
6883 else
6884 {
6885 // Temporarily hide the new local variable here, it is
6886 // not available to this expression.
6887 if (lhs.lhs_new_local)
6888 --cctx->ctx_locals.ga_len;
6889 wp = op + oplen;
6890 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
6891 {
6892 if (lhs.lhs_new_local)
6893 ++cctx->ctx_locals.ga_len;
6894 goto theend;
6895 }
6896 r = compile_expr0_ext(&p, cctx, &is_const);
Bram Moolenaar752fc692021-01-04 21:57:11 +01006897 if (lhs.lhs_new_local)
Bram Moolenaar21e51222020-12-04 12:43:29 +01006898 ++cctx->ctx_locals.ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02006899 if (r == FAIL)
6900 goto theend;
Bram Moolenaar21e51222020-12-04 12:43:29 +01006901 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006902 }
Bram Moolenaar9af78762020-06-16 11:34:42 +02006903 else if (semicolon && var_idx == var_count - 1)
6904 {
6905 // For "[var; var] = expr" get the rest of the list
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02006906 did_generate_slice = TRUE;
Bram Moolenaar9af78762020-06-16 11:34:42 +02006907 if (generate_SLICE(cctx, var_count - 1) == FAIL)
6908 goto theend;
6909 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006910 else
6911 {
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006912 // For "[var, var] = expr" get the "var_idx" item from the
6913 // list.
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02006914 if (generate_GETITEM(cctx, var_idx, *op != '=') == FAIL)
Bram Moolenaar7f764942020-12-02 15:11:18 +01006915 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006916 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006917
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006918 rhs_type = stack->ga_len == 0 ? &t_void
Bram Moolenaar6802cce2020-07-19 15:49:49 +02006919 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar752fc692021-01-04 21:57:11 +01006920 if (lhs.lhs_lvar != NULL && (is_decl || !lhs.lhs_has_type))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006921 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006922 if ((rhs_type->tt_type == VAR_FUNC
6923 || rhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01006924 && !lhs.lhs_has_index
Bram Moolenaar752fc692021-01-04 21:57:11 +01006925 && var_wrong_func_name(lhs.lhs_name, TRUE))
Bram Moolenaar0f769812020-09-12 18:32:34 +02006926 goto theend;
6927
Bram Moolenaar752fc692021-01-04 21:57:11 +01006928 if (lhs.lhs_new_local && !lhs.lhs_has_type)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006929 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006930 if (rhs_type->tt_type == VAR_VOID)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006931 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006932 emsg(_(e_cannot_use_void_value));
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006933 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006934 }
6935 else
6936 {
Bram Moolenaar04bdd572020-09-23 13:25:32 +02006937 // An empty list or dict has a &t_unknown member,
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006938 // for a variable that implies &t_any.
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006939 if (rhs_type == &t_list_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006940 lhs.lhs_lvar->lv_type = &t_list_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006941 else if (rhs_type == &t_dict_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006942 lhs.lhs_lvar->lv_type = &t_dict_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006943 else if (rhs_type == &t_unknown)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006944 lhs.lhs_lvar->lv_type = &t_any;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006945 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01006946 lhs.lhs_lvar->lv_type = rhs_type;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006947 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006948 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006949 else if (*op == '=')
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006950 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006951 type_T *use_type = lhs.lhs_lvar->lv_type;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006952
Bram Moolenaar77709b12021-04-03 21:01:01 +02006953 // Without operator check type here, otherwise below.
6954 // Use the line number of the assignment.
6955 SOURCING_LNUM = start_lnum;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006956 if (lhs.lhs_has_index)
6957 use_type = lhs.lhs_member_type;
Bram Moolenaar351ead02021-01-16 16:07:01 +01006958 if (need_type(rhs_type, use_type, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006959 FALSE, is_const) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006960 goto theend;
6961 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006962 }
Bram Moolenaar74f4a962021-06-17 21:03:07 +02006963 else
6964 {
6965 type_T *lhs_type = lhs.lhs_member_type;
6966
6967 // Special case: assigning to @# can use a number or a
6968 // string.
6969 if (lhs_type == &t_number_or_string
6970 && rhs_type->tt_type == VAR_NUMBER)
6971 lhs_type = &t_number;
6972 if (*p != '=' && need_type(rhs_type, lhs_type,
Bram Moolenaar351ead02021-01-16 16:07:01 +01006973 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006974 goto theend;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02006975 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006976 }
Bram Moolenaar30fd8202020-09-26 15:09:30 +02006977 else if (cmdidx == CMD_final)
6978 {
6979 emsg(_(e_final_requires_a_value));
6980 goto theend;
6981 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006982 else if (cmdidx == CMD_const)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006983 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02006984 emsg(_(e_const_requires_a_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006985 goto theend;
6986 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006987 else if (!lhs.lhs_has_type || lhs.lhs_dest == dest_option)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006988 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02006989 emsg(_(e_type_or_initialization_required));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006990 goto theend;
6991 }
6992 else
6993 {
6994 // variables are always initialized
6995 if (ga_grow(instr, 1) == FAIL)
6996 goto theend;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006997 switch (lhs.lhs_member_type->tt_type)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006998 {
6999 case VAR_BOOL:
7000 generate_PUSHBOOL(cctx, VVAL_FALSE);
7001 break;
7002 case VAR_FLOAT:
7003#ifdef FEAT_FLOAT
7004 generate_PUSHF(cctx, 0.0);
7005#endif
7006 break;
7007 case VAR_STRING:
7008 generate_PUSHS(cctx, NULL);
7009 break;
7010 case VAR_BLOB:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02007011 generate_PUSHBLOB(cctx, blob_alloc());
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007012 break;
7013 case VAR_FUNC:
7014 generate_PUSHFUNC(cctx, NULL, &t_func_void);
7015 break;
7016 case VAR_LIST:
7017 generate_NEWLIST(cctx, 0);
7018 break;
7019 case VAR_DICT:
7020 generate_NEWDICT(cctx, 0);
7021 break;
7022 case VAR_JOB:
7023 generate_PUSHJOB(cctx, NULL);
7024 break;
7025 case VAR_CHANNEL:
7026 generate_PUSHCHANNEL(cctx, NULL);
7027 break;
7028 case VAR_NUMBER:
7029 case VAR_UNKNOWN:
7030 case VAR_ANY:
7031 case VAR_PARTIAL:
7032 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02007033 case VAR_INSTR:
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007034 case VAR_SPECIAL: // cannot happen
7035 generate_PUSHNR(cctx, 0);
7036 break;
7037 }
7038 }
7039 if (var_count == 0)
7040 end = p;
7041 }
7042
Bram Moolenaar72abcf42020-06-18 18:26:24 +02007043 // no need to parse more when skipping
Bram Moolenaar9b68c822020-06-18 19:31:08 +02007044 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02007045 break;
7046
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007047 if (oplen > 0 && *op != '=')
7048 {
Bram Moolenaar93ad1472020-08-19 22:02:41 +02007049 type_T *expected;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007050 type_T *stacktype;
7051
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007052 if (*op == '.')
7053 expected = &t_string;
Bram Moolenaar93ad1472020-08-19 22:02:41 +02007054 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01007055 expected = lhs.lhs_member_type;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007056 stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar93ad1472020-08-19 22:02:41 +02007057 if (
7058#ifdef FEAT_FLOAT
7059 // If variable is float operation with number is OK.
7060 !(expected == &t_float && stacktype == &t_number) &&
7061#endif
Bram Moolenaar351ead02021-01-16 16:07:01 +01007062 need_type(stacktype, expected, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02007063 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007064 goto theend;
7065
7066 if (*op == '.')
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02007067 {
7068 if (generate_instr_drop(cctx, ISN_CONCAT, 1) == NULL)
7069 goto theend;
7070 }
7071 else if (*op == '+')
7072 {
7073 if (generate_add_instr(cctx,
Bram Moolenaar752fc692021-01-04 21:57:11 +01007074 operator_type(lhs.lhs_member_type, stacktype),
7075 lhs.lhs_member_type, stacktype) == FAIL)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02007076 goto theend;
7077 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02007078 else if (generate_two_op(cctx, op) == FAIL)
7079 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007080 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007081
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007082 // Use the line number of the assignment for store instruction.
7083 save_lnum = cctx->ctx_lnum;
7084 cctx->ctx_lnum = start_lnum - 1;
7085
Bram Moolenaar752fc692021-01-04 21:57:11 +01007086 if (lhs.lhs_has_index)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02007087 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01007088 // Use the info in "lhs" to store the value at the index in the
7089 // list or dict.
7090 if (compile_assign_unlet(var_start, &lhs, TRUE, rhs_type, cctx)
7091 == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007092 {
7093 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007094 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007095 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02007096 }
7097 else
7098 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01007099 if (is_decl && cmdidx == CMD_const && (lhs.lhs_dest == dest_script
Bram Moolenaard877a572021-04-01 19:42:48 +02007100 || lhs.lhs_dest == dest_global
Bram Moolenaar752fc692021-01-04 21:57:11 +01007101 || lhs.lhs_dest == dest_local))
Bram Moolenaar30fd8202020-09-26 15:09:30 +02007102 // ":const var": lock the value, but not referenced variables
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02007103 generate_LOCKCONST(cctx);
7104
Bram Moolenaaraa210a32021-01-02 15:41:03 +01007105 if (is_decl
Bram Moolenaar752fc692021-01-04 21:57:11 +01007106 && (lhs.lhs_type->tt_type == VAR_DICT
7107 || lhs.lhs_type->tt_type == VAR_LIST)
7108 && lhs.lhs_type->tt_member != NULL
7109 && lhs.lhs_type->tt_member != &t_any
7110 && lhs.lhs_type->tt_member != &t_unknown)
Bram Moolenaaraa210a32021-01-02 15:41:03 +01007111 // Set the type in the list or dict, so that it can be checked,
7112 // also in legacy script.
Bram Moolenaar752fc692021-01-04 21:57:11 +01007113 generate_SETTYPE(cctx, lhs.lhs_type);
Bram Moolenaaraa210a32021-01-02 15:41:03 +01007114
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02007115 if (generate_store_lhs(cctx, &lhs, instr_count) == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007116 {
7117 cctx->ctx_lnum = save_lnum;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02007118 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007119 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02007120 }
Bram Moolenaar6977dba2021-07-04 22:48:12 +02007121 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007122
7123 if (var_idx + 1 < var_count)
Bram Moolenaar752fc692021-01-04 21:57:11 +01007124 var_start = skipwhite(lhs.lhs_dest_end + 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007125 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007126
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02007127 // For "[var, var] = expr" drop the "expr" value.
7128 // Also for "[var, var; _] = expr".
7129 if (var_count > 0 && (!semicolon || !did_generate_slice))
Bram Moolenaar9af78762020-06-16 11:34:42 +02007130 {
Bram Moolenaarec792292020-12-13 21:26:56 +01007131 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
Bram Moolenaar9af78762020-06-16 11:34:42 +02007132 goto theend;
7133 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02007134
Bram Moolenaarb2097502020-07-19 17:17:02 +02007135 ret = skipwhite(end);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007136
7137theend:
Bram Moolenaar752fc692021-01-04 21:57:11 +01007138 vim_free(lhs.lhs_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007139 return ret;
7140}
7141
7142/*
Bram Moolenaar17126b12021-01-07 22:03:02 +01007143 * Check for an assignment at "eap->cmd", compile it if found.
7144 * Return NOTDONE if there is none, FAIL for failure, OK if done.
7145 */
7146 static int
7147may_compile_assignment(exarg_T *eap, char_u **line, cctx_T *cctx)
7148{
7149 char_u *pskip;
7150 char_u *p;
7151
7152 // Assuming the command starts with a variable or function name,
7153 // find what follows.
7154 // Skip over "var.member", "var[idx]" and the like.
7155 // Also "&opt = val", "$ENV = val" and "@r = val".
7156 pskip = (*eap->cmd == '&' || *eap->cmd == '$' || *eap->cmd == '@')
7157 ? eap->cmd + 1 : eap->cmd;
7158 p = to_name_end(pskip, TRUE);
7159 if (p > eap->cmd && *p != NUL)
7160 {
7161 char_u *var_end;
7162 int oplen;
7163 int heredoc;
7164
7165 if (eap->cmd[0] == '@')
7166 var_end = eap->cmd + 2;
7167 else
7168 var_end = find_name_end(pskip, NULL, NULL,
7169 FNE_CHECK_START | FNE_INCL_BR);
7170 oplen = assignment_len(skipwhite(var_end), &heredoc);
7171 if (oplen > 0)
7172 {
7173 size_t len = p - eap->cmd;
7174
7175 // Recognize an assignment if we recognize the variable
7176 // name:
7177 // "g:var = expr"
7178 // "local = expr" where "local" is a local var.
7179 // "script = expr" where "script" is a script-local var.
7180 // "import = expr" where "import" is an imported var
7181 // "&opt = expr"
7182 // "$ENV = expr"
7183 // "@r = expr"
7184 if (*eap->cmd == '&'
7185 || *eap->cmd == '$'
7186 || *eap->cmd == '@'
7187 || ((len) > 2 && eap->cmd[1] == ':')
Bram Moolenaare0890d62021-02-17 14:52:14 +01007188 || variable_exists(eap->cmd, len, cctx))
Bram Moolenaar17126b12021-01-07 22:03:02 +01007189 {
7190 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
7191 if (*line == NULL || *line == eap->cmd)
7192 return FAIL;
7193 return OK;
7194 }
7195 }
7196 }
7197
7198 if (*eap->cmd == '[')
7199 {
7200 // [var, var] = expr
7201 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
7202 if (*line == NULL)
7203 return FAIL;
7204 if (*line != eap->cmd)
7205 return OK;
7206 }
7207 return NOTDONE;
7208}
7209
7210/*
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007211 * Check if "name" can be "unlet".
7212 */
7213 int
7214check_vim9_unlet(char_u *name)
7215{
7216 if (name[1] != ':' || vim_strchr((char_u *)"gwtb", *name) == NULL)
7217 {
Bram Moolenaar84367732020-08-23 15:21:55 +02007218 // "unlet s:var" is allowed in legacy script.
7219 if (*name == 's' && !script_is_vim9())
7220 return OK;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02007221 semsg(_(e_cannot_unlet_str), name);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007222 return FAIL;
7223 }
7224 return OK;
7225}
7226
7227/*
7228 * Callback passed to ex_unletlock().
7229 */
7230 static int
7231compile_unlet(
7232 lval_T *lvp,
7233 char_u *name_end,
7234 exarg_T *eap,
7235 int deep UNUSED,
7236 void *coookie)
7237{
Bram Moolenaar752fc692021-01-04 21:57:11 +01007238 cctx_T *cctx = coookie;
7239 char_u *p = lvp->ll_name;
7240 int cc = *name_end;
7241 int ret = OK;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007242
Bram Moolenaar752fc692021-01-04 21:57:11 +01007243 if (cctx->ctx_skip == SKIP_YES)
7244 return OK;
7245
7246 *name_end = NUL;
7247 if (*p == '$')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007248 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01007249 // :unlet $ENV_VAR
7250 ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit);
7251 }
7252 else if (vim_strchr(p, '.') != NULL || vim_strchr(p, '[') != NULL)
7253 {
7254 lhs_T lhs;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007255
Bram Moolenaar752fc692021-01-04 21:57:11 +01007256 // This is similar to assigning: lookup the list/dict, compile the
7257 // idx/key. Then instead of storing the value unlet the item.
7258 // unlet {list}[idx]
7259 // unlet {dict}[key] dict.key
7260 //
7261 // Figure out the LHS type and other properties.
7262 //
7263 ret = compile_lhs(p, &lhs, CMD_unlet, FALSE, 0, cctx);
7264
7265 // : unlet an indexed item
7266 if (!lhs.lhs_has_index)
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01007267 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01007268 iemsg("called compile_lhs() without an index");
7269 ret = FAIL;
7270 }
7271 else
7272 {
7273 // Use the info in "lhs" to unlet the item at the index in the
7274 // list or dict.
7275 ret = compile_assign_unlet(p, &lhs, FALSE, &t_void, cctx);
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01007276 }
7277
Bram Moolenaar752fc692021-01-04 21:57:11 +01007278 vim_free(lhs.lhs_name);
7279 }
7280 else if (check_vim9_unlet(p) == FAIL)
7281 {
7282 ret = FAIL;
7283 }
7284 else
7285 {
7286 // Normal name. Only supports g:, w:, t: and b: namespaces.
7287 ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007288 }
7289
Bram Moolenaar752fc692021-01-04 21:57:11 +01007290 *name_end = cc;
7291 return ret;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007292}
7293
7294/*
Bram Moolenaarb2cb6c82021-03-28 20:38:34 +02007295 * Callback passed to ex_unletlock().
7296 */
7297 static int
7298compile_lock_unlock(
7299 lval_T *lvp,
7300 char_u *name_end,
7301 exarg_T *eap,
7302 int deep UNUSED,
7303 void *coookie)
7304{
7305 cctx_T *cctx = coookie;
7306 int cc = *name_end;
7307 char_u *p = lvp->ll_name;
7308 int ret = OK;
7309 size_t len;
7310 char_u *buf;
7311
7312 if (cctx->ctx_skip == SKIP_YES)
7313 return OK;
7314
7315 // Cannot use :lockvar and :unlockvar on local variables.
7316 if (p[1] != ':')
7317 {
7318 char_u *end = skip_var_one(p, FALSE);
7319
7320 if (lookup_local(p, end - p, NULL, cctx) == OK)
7321 {
7322 emsg(_(e_cannot_lock_unlock_local_variable));
7323 return FAIL;
7324 }
7325 }
7326
7327 // Checking is done at runtime.
7328 *name_end = NUL;
7329 len = name_end - p + 20;
7330 buf = alloc(len);
7331 if (buf == NULL)
7332 ret = FAIL;
7333 else
7334 {
7335 vim_snprintf((char *)buf, len, "%s %s",
7336 eap->cmdidx == CMD_lockvar ? "lockvar" : "unlockvar",
7337 p);
7338 ret = generate_EXEC(cctx, buf);
7339
7340 vim_free(buf);
7341 *name_end = cc;
7342 }
7343 return ret;
7344}
7345
7346/*
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007347 * compile "unlet var", "lock var" and "unlock var"
7348 * "arg" points to "var".
7349 */
7350 static char_u *
7351compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx)
7352{
Bram Moolenaarb2cb6c82021-03-28 20:38:34 +02007353 ex_unletlock(eap, arg, 0, GLV_NO_AUTOLOAD | GLV_COMPILING,
7354 eap->cmdidx == CMD_unlet ? compile_unlet : compile_lock_unlock,
7355 cctx);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02007356 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
7357}
7358
7359/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007360 * generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry".
7361 */
7362 static int
7363compile_jump_to_end(endlabel_T **el, jumpwhen_T when, cctx_T *cctx)
7364{
7365 garray_T *instr = &cctx->ctx_instr;
7366 endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T);
7367
7368 if (endlabel == NULL)
7369 return FAIL;
7370 endlabel->el_next = *el;
7371 *el = endlabel;
7372 endlabel->el_end_label = instr->ga_len;
7373
7374 generate_JUMP(cctx, when, 0);
7375 return OK;
7376}
7377
7378 static void
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01007379compile_fill_jump_to_end(endlabel_T **el, int jump_where, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007380{
7381 garray_T *instr = &cctx->ctx_instr;
7382
7383 while (*el != NULL)
7384 {
7385 endlabel_T *cur = (*el);
7386 isn_T *isn;
7387
7388 isn = ((isn_T *)instr->ga_data) + cur->el_end_label;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01007389 isn->isn_arg.jump.jump_where = jump_where;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007390 *el = cur->el_next;
7391 vim_free(cur);
7392 }
7393}
7394
Bram Moolenaar3cca2992020-04-02 22:57:36 +02007395 static void
7396compile_free_jump_to_end(endlabel_T **el)
7397{
7398 while (*el != NULL)
7399 {
7400 endlabel_T *cur = (*el);
7401
7402 *el = cur->el_next;
7403 vim_free(cur);
7404 }
7405}
7406
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007407/*
7408 * Create a new scope and set up the generic items.
7409 */
7410 static scope_T *
7411new_scope(cctx_T *cctx, scopetype_T type)
7412{
7413 scope_T *scope = ALLOC_CLEAR_ONE(scope_T);
7414
7415 if (scope == NULL)
7416 return NULL;
7417 scope->se_outer = cctx->ctx_scope;
7418 cctx->ctx_scope = scope;
7419 scope->se_type = type;
7420 scope->se_local_count = cctx->ctx_locals.ga_len;
7421 return scope;
7422}
7423
7424/*
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007425 * Free the current scope and go back to the outer scope.
7426 */
7427 static void
7428drop_scope(cctx_T *cctx)
7429{
7430 scope_T *scope = cctx->ctx_scope;
7431
7432 if (scope == NULL)
7433 {
7434 iemsg("calling drop_scope() without a scope");
7435 return;
7436 }
7437 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar3cca2992020-04-02 22:57:36 +02007438 switch (scope->se_type)
7439 {
7440 case IF_SCOPE:
7441 compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break;
7442 case FOR_SCOPE:
7443 compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break;
7444 case WHILE_SCOPE:
7445 compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break;
7446 case TRY_SCOPE:
7447 compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break;
7448 case NO_SCOPE:
7449 case BLOCK_SCOPE:
7450 break;
7451 }
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007452 vim_free(scope);
7453}
7454
7455/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007456 * compile "if expr"
7457 *
7458 * "if expr" Produces instructions:
7459 * EVAL expr Push result of "expr"
7460 * JUMP_IF_FALSE end
7461 * ... body ...
7462 * end:
7463 *
7464 * "if expr | else" Produces instructions:
7465 * EVAL expr Push result of "expr"
7466 * JUMP_IF_FALSE else
7467 * ... body ...
7468 * JUMP_ALWAYS end
7469 * else:
7470 * ... body ...
7471 * end:
7472 *
7473 * "if expr1 | elseif expr2 | else" Produces instructions:
7474 * EVAL expr Push result of "expr"
7475 * JUMP_IF_FALSE elseif
7476 * ... body ...
7477 * JUMP_ALWAYS end
7478 * elseif:
7479 * EVAL expr Push result of "expr"
7480 * JUMP_IF_FALSE else
7481 * ... body ...
7482 * JUMP_ALWAYS end
7483 * else:
7484 * ... body ...
7485 * end:
7486 */
7487 static char_u *
7488compile_if(char_u *arg, cctx_T *cctx)
7489{
7490 char_u *p = arg;
7491 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007492 int instr_count = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007493 scope_T *scope;
Bram Moolenaarefd88552020-06-18 20:50:10 +02007494 skip_T skip_save = cctx->ctx_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007495 ppconst_T ppconst;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007496
Bram Moolenaara5565e42020-05-09 15:44:01 +02007497 CLEAR_FIELD(ppconst);
7498 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007499 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02007500 clear_ppconst(&ppconst);
7501 return NULL;
7502 }
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01007503 if (!ends_excmd2(arg, skipwhite(p)))
7504 {
7505 semsg(_(e_trailing_arg), p);
7506 return NULL;
7507 }
Bram Moolenaarefd88552020-06-18 20:50:10 +02007508 if (cctx->ctx_skip == SKIP_YES)
7509 clear_ppconst(&ppconst);
7510 else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
Bram Moolenaara5565e42020-05-09 15:44:01 +02007511 {
Bram Moolenaar13106602020-10-04 16:06:05 +02007512 int error = FALSE;
7513 int v;
7514
Bram Moolenaara5565e42020-05-09 15:44:01 +02007515 // The expression results in a constant.
Bram Moolenaar13106602020-10-04 16:06:05 +02007516 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error);
Bram Moolenaardda749c2020-10-04 17:24:29 +02007517 clear_ppconst(&ppconst);
Bram Moolenaar13106602020-10-04 16:06:05 +02007518 if (error)
7519 return NULL;
7520 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007521 }
7522 else
7523 {
7524 // Not a constant, generate instructions for the expression.
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007525 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007526 if (generate_ppconst(cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007527 return NULL;
Bram Moolenaar13106602020-10-04 16:06:05 +02007528 if (bool_on_stack(cctx) == FAIL)
7529 return NULL;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007530 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007531
Bram Moolenaara91a7132021-03-25 21:12:15 +01007532 // CMDMOD_REV must come before the jump
7533 generate_undo_cmdmods(cctx);
7534
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007535 scope = new_scope(cctx, IF_SCOPE);
7536 if (scope == NULL)
7537 return NULL;
Bram Moolenaarefd88552020-06-18 20:50:10 +02007538 scope->se_skip_save = skip_save;
7539 // "is_had_return" will be reset if any block does not end in :return
7540 scope->se_u.se_if.is_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007541
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007542 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007543 {
7544 // "where" is set when ":elseif", "else" or ":endif" is found
7545 scope->se_u.se_if.is_if_label = instr->ga_len;
7546 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
7547 }
7548 else
7549 scope->se_u.se_if.is_if_label = -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007550
Bram Moolenaarced68a02021-01-24 17:53:47 +01007551#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02007552 if (cctx->ctx_compile_type == CT_PROFILE && cctx->ctx_skip == SKIP_YES
Bram Moolenaarced68a02021-01-24 17:53:47 +01007553 && skip_save != SKIP_YES)
7554 {
7555 // generated a profile start, need to generate a profile end, since it
7556 // won't be done after returning
7557 cctx->ctx_skip = SKIP_NOT;
7558 generate_instr(cctx, ISN_PROF_END);
7559 cctx->ctx_skip = SKIP_YES;
7560 }
7561#endif
7562
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007563 return p;
7564}
7565
7566 static char_u *
7567compile_elseif(char_u *arg, cctx_T *cctx)
7568{
7569 char_u *p = arg;
7570 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar7f141552020-05-09 17:35:53 +02007571 int instr_count = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007572 isn_T *isn;
7573 scope_T *scope = cctx->ctx_scope;
Bram Moolenaar7f141552020-05-09 17:35:53 +02007574 ppconst_T ppconst;
Bram Moolenaar749639e2020-08-27 23:08:47 +02007575 skip_T save_skip = cctx->ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007576
7577 if (scope == NULL || scope->se_type != IF_SCOPE)
7578 {
7579 emsg(_(e_elseif_without_if));
7580 return NULL;
7581 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01007582 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02007583 if (!cctx->ctx_had_return)
7584 scope->se_u.se_if.is_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007585
Bram Moolenaarced68a02021-01-24 17:53:47 +01007586 if (cctx->ctx_skip == SKIP_NOT)
7587 {
7588 // previous block was executed, this one and following will not
7589 cctx->ctx_skip = SKIP_YES;
7590 scope->se_u.se_if.is_seen_skip_not = TRUE;
7591 }
7592 if (scope->se_u.se_if.is_seen_skip_not)
7593 {
7594 // A previous block was executed, skip over expression and bail out.
Bram Moolenaara91a7132021-03-25 21:12:15 +01007595 // Do not count the "elseif" for profiling and cmdmod
7596 instr->ga_len = current_instr_idx(cctx);
7597
Bram Moolenaarced68a02021-01-24 17:53:47 +01007598 skip_expr_cctx(&p, cctx);
7599 return p;
7600 }
7601
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007602 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007603 {
Bram Moolenaara91a7132021-03-25 21:12:15 +01007604 int moved_cmdmod = FALSE;
7605
7606 // Move any CMDMOD instruction to after the jump
7607 if (((isn_T *)instr->ga_data)[instr->ga_len - 1].isn_type == ISN_CMDMOD)
7608 {
7609 if (ga_grow(instr, 1) == FAIL)
7610 return NULL;
7611 ((isn_T *)instr->ga_data)[instr->ga_len] =
7612 ((isn_T *)instr->ga_data)[instr->ga_len - 1];
7613 --instr->ga_len;
7614 moved_cmdmod = TRUE;
7615 }
7616
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007617 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007618 JUMP_ALWAYS, cctx) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007619 return NULL;
7620 // previous "if" or "elseif" jumps here
7621 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
7622 isn->isn_arg.jump.jump_where = instr->ga_len;
Bram Moolenaara91a7132021-03-25 21:12:15 +01007623 if (moved_cmdmod)
7624 ++instr->ga_len;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007625 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007626
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007627 // compile "expr"; if we know it evaluates to FALSE skip the block
Bram Moolenaar7f141552020-05-09 17:35:53 +02007628 CLEAR_FIELD(ppconst);
Bram Moolenaar749639e2020-08-27 23:08:47 +02007629 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaarced68a02021-01-24 17:53:47 +01007630 {
Bram Moolenaar749639e2020-08-27 23:08:47 +02007631 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaarced68a02021-01-24 17:53:47 +01007632#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02007633 if (cctx->ctx_compile_type == CT_PROFILE)
Bram Moolenaarced68a02021-01-24 17:53:47 +01007634 {
7635 // the previous block was skipped, need to profile this line
7636 generate_instr(cctx, ISN_PROF_START);
7637 instr_count = instr->ga_len;
7638 }
7639#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02007640 if (cctx->ctx_compile_type == CT_DEBUG)
7641 {
7642 // the previous block was skipped, may want to debug this line
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02007643 generate_instr_debug(cctx);
Bram Moolenaare99d4222021-06-13 14:01:26 +02007644 instr_count = instr->ga_len;
7645 }
Bram Moolenaarced68a02021-01-24 17:53:47 +01007646 }
Bram Moolenaar7f141552020-05-09 17:35:53 +02007647 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007648 {
Bram Moolenaar7f141552020-05-09 17:35:53 +02007649 clear_ppconst(&ppconst);
7650 return NULL;
7651 }
Bram Moolenaar749639e2020-08-27 23:08:47 +02007652 cctx->ctx_skip = save_skip;
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01007653 if (!ends_excmd2(arg, skipwhite(p)))
7654 {
7655 semsg(_(e_trailing_arg), p);
7656 return NULL;
7657 }
Bram Moolenaarefd88552020-06-18 20:50:10 +02007658 if (scope->se_skip_save == SKIP_YES)
7659 clear_ppconst(&ppconst);
7660 else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
Bram Moolenaar7f141552020-05-09 17:35:53 +02007661 {
Bram Moolenaar13106602020-10-04 16:06:05 +02007662 int error = FALSE;
7663 int v;
7664
Bram Moolenaar7f141552020-05-09 17:35:53 +02007665 // The expression results in a constant.
7666 // TODO: how about nesting?
Bram Moolenaar13106602020-10-04 16:06:05 +02007667 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error);
7668 if (error)
7669 return NULL;
7670 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES;
Bram Moolenaar7f141552020-05-09 17:35:53 +02007671 clear_ppconst(&ppconst);
7672 scope->se_u.se_if.is_if_label = -1;
7673 }
7674 else
7675 {
7676 // Not a constant, generate instructions for the expression.
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007677 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaar7f141552020-05-09 17:35:53 +02007678 if (generate_ppconst(cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007679 return NULL;
Bram Moolenaar13106602020-10-04 16:06:05 +02007680 if (bool_on_stack(cctx) == FAIL)
7681 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007682
Bram Moolenaara91a7132021-03-25 21:12:15 +01007683 // CMDMOD_REV must come before the jump
7684 generate_undo_cmdmods(cctx);
7685
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007686 // "where" is set when ":elseif", "else" or ":endif" is found
7687 scope->se_u.se_if.is_if_label = instr->ga_len;
7688 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
7689 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007690
7691 return p;
7692}
7693
7694 static char_u *
7695compile_else(char_u *arg, cctx_T *cctx)
7696{
7697 char_u *p = arg;
7698 garray_T *instr = &cctx->ctx_instr;
7699 isn_T *isn;
7700 scope_T *scope = cctx->ctx_scope;
7701
7702 if (scope == NULL || scope->se_type != IF_SCOPE)
7703 {
7704 emsg(_(e_else_without_if));
7705 return NULL;
7706 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01007707 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02007708 if (!cctx->ctx_had_return)
7709 scope->se_u.se_if.is_had_return = FALSE;
7710 scope->se_u.se_if.is_seen_else = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007711
Bram Moolenaarced68a02021-01-24 17:53:47 +01007712#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02007713 if (cctx->ctx_compile_type == CT_PROFILE)
Bram Moolenaarced68a02021-01-24 17:53:47 +01007714 {
7715 if (cctx->ctx_skip == SKIP_NOT
7716 && ((isn_T *)instr->ga_data)[instr->ga_len - 1]
7717 .isn_type == ISN_PROF_START)
Bram Moolenaare99d4222021-06-13 14:01:26 +02007718 // the previous block was executed, do not count "else" for
7719 // profiling
Bram Moolenaarced68a02021-01-24 17:53:47 +01007720 --instr->ga_len;
7721 if (cctx->ctx_skip == SKIP_YES && !scope->se_u.se_if.is_seen_skip_not)
7722 {
7723 // the previous block was not executed, this one will, do count the
7724 // "else" for profiling
7725 cctx->ctx_skip = SKIP_NOT;
7726 generate_instr(cctx, ISN_PROF_END);
7727 generate_instr(cctx, ISN_PROF_START);
7728 cctx->ctx_skip = SKIP_YES;
7729 }
7730 }
7731#endif
7732
7733 if (!scope->se_u.se_if.is_seen_skip_not && scope->se_skip_save != SKIP_YES)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007734 {
Bram Moolenaarefd88552020-06-18 20:50:10 +02007735 // jump from previous block to the end, unless the else block is empty
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007736 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007737 {
Bram Moolenaarefd88552020-06-18 20:50:10 +02007738 if (!cctx->ctx_had_return
7739 && compile_jump_to_end(&scope->se_u.se_if.is_end_label,
7740 JUMP_ALWAYS, cctx) == FAIL)
7741 return NULL;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007742 }
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007743
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007744 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaarefd88552020-06-18 20:50:10 +02007745 {
7746 if (scope->se_u.se_if.is_if_label >= 0)
7747 {
7748 // previous "if" or "elseif" jumps here
7749 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
7750 isn->isn_arg.jump.jump_where = instr->ga_len;
7751 scope->se_u.se_if.is_if_label = -1;
7752 }
7753 }
7754
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02007755 if (cctx->ctx_skip != SKIP_UNKNOWN)
Bram Moolenaarefd88552020-06-18 20:50:10 +02007756 cctx->ctx_skip = cctx->ctx_skip == SKIP_YES ? SKIP_NOT : SKIP_YES;
7757 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007758
7759 return p;
7760}
7761
7762 static char_u *
7763compile_endif(char_u *arg, cctx_T *cctx)
7764{
7765 scope_T *scope = cctx->ctx_scope;
7766 ifscope_T *ifscope;
7767 garray_T *instr = &cctx->ctx_instr;
7768 isn_T *isn;
7769
Bram Moolenaarfa984412021-03-25 22:15:28 +01007770 if (misplaced_cmdmod(cctx))
7771 return NULL;
7772
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007773 if (scope == NULL || scope->se_type != IF_SCOPE)
7774 {
7775 emsg(_(e_endif_without_if));
7776 return NULL;
7777 }
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007778 ifscope = &scope->se_u.se_if;
Bram Moolenaar20431c92020-03-20 18:39:46 +01007779 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02007780 if (!cctx->ctx_had_return)
7781 ifscope->is_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007782
Bram Moolenaara259d8d2020-01-31 20:10:50 +01007783 if (scope->se_u.se_if.is_if_label >= 0)
7784 {
7785 // previous "if" or "elseif" jumps here
7786 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
7787 isn->isn_arg.jump.jump_where = instr->ga_len;
7788 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007789 // Fill in the "end" label in jumps at the end of the blocks.
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01007790 compile_fill_jump_to_end(&ifscope->is_end_label, instr->ga_len, cctx);
Bram Moolenaarced68a02021-01-24 17:53:47 +01007791
7792#ifdef FEAT_PROFILE
7793 // even when skipping we count the endif as executed, unless the block it's
7794 // in is skipped
Bram Moolenaare99d4222021-06-13 14:01:26 +02007795 if (cctx->ctx_compile_type == CT_PROFILE && cctx->ctx_skip == SKIP_YES
Bram Moolenaarced68a02021-01-24 17:53:47 +01007796 && scope->se_skip_save != SKIP_YES)
7797 {
7798 cctx->ctx_skip = SKIP_NOT;
7799 generate_instr(cctx, ISN_PROF_START);
7800 }
7801#endif
Bram Moolenaarefd88552020-06-18 20:50:10 +02007802 cctx->ctx_skip = scope->se_skip_save;
7803
7804 // If all the blocks end in :return and there is an :else then the
7805 // had_return flag is set.
7806 cctx->ctx_had_return = ifscope->is_had_return && ifscope->is_seen_else;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007807
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007808 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007809 return arg;
7810}
7811
7812/*
Bram Moolenaar792f7862020-11-23 08:31:18 +01007813 * Compile "for var in expr":
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007814 *
7815 * Produces instructions:
7816 * PUSHNR -1
7817 * STORE loop-idx Set index to -1
Bram Moolenaar792f7862020-11-23 08:31:18 +01007818 * EVAL expr result of "expr" on top of stack
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007819 * top: FOR loop-idx, end Increment index, use list on bottom of stack
7820 * - if beyond end, jump to "end"
7821 * - otherwise get item from list and push it
7822 * STORE var Store item in "var"
7823 * ... body ...
7824 * JUMP top Jump back to repeat
7825 * end: DROP Drop the result of "expr"
7826 *
Bram Moolenaar792f7862020-11-23 08:31:18 +01007827 * Compile "for [var1, var2] in expr" - as above, but instead of "STORE var":
7828 * UNPACK 2 Split item in 2
7829 * STORE var1 Store item in "var1"
7830 * STORE var2 Store item in "var2"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007831 */
7832 static char_u *
Bram Moolenaar792f7862020-11-23 08:31:18 +01007833compile_for(char_u *arg_start, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007834{
Bram Moolenaar792f7862020-11-23 08:31:18 +01007835 char_u *arg;
7836 char_u *arg_end;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007837 char_u *name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007838 char_u *p;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01007839 char_u *wp;
Bram Moolenaar792f7862020-11-23 08:31:18 +01007840 int var_count = 0;
Bram Moolenaar444d8782021-06-26 12:40:56 +02007841 int var_list = FALSE;
Bram Moolenaar792f7862020-11-23 08:31:18 +01007842 int semicolon = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007843 size_t varlen;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007844 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007845 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007846 scope_T *scope;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02007847 lvar_T *loop_lvar; // loop iteration variable
7848 lvar_T *var_lvar; // variable for "var"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007849 type_T *vartype;
Bram Moolenaar792f7862020-11-23 08:31:18 +01007850 type_T *item_type = &t_any;
7851 int idx;
Bram Moolenaar6fc01612021-07-03 13:36:31 +02007852 int prev_lnum = cctx->ctx_prev_lnum;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007853
Bram Moolenaar792f7862020-11-23 08:31:18 +01007854 p = skip_var_list(arg_start, TRUE, &var_count, &semicolon, FALSE);
Bram Moolenaar036d0712021-01-17 20:23:38 +01007855 if (p == NULL)
7856 return NULL;
Bram Moolenaar792f7862020-11-23 08:31:18 +01007857 if (var_count == 0)
7858 var_count = 1;
Bram Moolenaar444d8782021-06-26 12:40:56 +02007859 else
7860 var_list = TRUE; // can also be a list of one variable
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007861
7862 // consume "in"
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01007863 wp = p;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01007864 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
7865 return NULL;
7866 if (STRNCMP(p, "in", 2) != 0 || !IS_WHITE_OR_NUL(p[2]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007867 {
Bram Moolenaar404557e2021-07-05 21:41:48 +02007868 if (*p == ':' && wp != p)
7869 semsg(_(e_no_white_space_allowed_before_colon_str), p);
7870 else
7871 emsg(_(e_missing_in));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007872 return NULL;
7873 }
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01007874 wp = p + 2;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01007875 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
7876 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007877
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007878 // Remove the already generated ISN_DEBUG, it is written below the ISN_FOR
7879 // instruction.
7880 if (cctx->ctx_compile_type == CT_DEBUG && instr->ga_len > 0
7881 && ((isn_T *)instr->ga_data)[instr->ga_len - 1]
7882 .isn_type == ISN_DEBUG)
Bram Moolenaar6fc01612021-07-03 13:36:31 +02007883 {
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007884 --instr->ga_len;
Bram Moolenaar6fc01612021-07-03 13:36:31 +02007885 prev_lnum = ((isn_T *)instr->ga_data)[instr->ga_len]
7886 .isn_arg.debug.dbg_break_lnum;
7887 }
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007888
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007889 scope = new_scope(cctx, FOR_SCOPE);
7890 if (scope == NULL)
7891 return NULL;
7892
Bram Moolenaar792f7862020-11-23 08:31:18 +01007893 // Reserve a variable to store the loop iteration counter and initialize it
7894 // to -1.
Bram Moolenaarb84a3812020-05-01 15:44:29 +02007895 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
7896 if (loop_lvar == NULL)
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007897 {
Bram Moolenaarb84a3812020-05-01 15:44:29 +02007898 // out of memory
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007899 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007900 return NULL;
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007901 }
Bram Moolenaarb84a3812020-05-01 15:44:29 +02007902 generate_STORENR(cctx, loop_lvar->lv_idx, -1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007903
7904 // compile "expr", it remains on the stack until "endfor"
7905 arg = p;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007906 if (compile_expr0(&arg, cctx) == FAIL)
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007907 {
7908 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007909 return NULL;
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007910 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01007911 arg_end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007912
Bram Moolenaard551d6c2021-04-18 13:15:58 +02007913 // If we know the type of "var" and it is a not a supported type we can
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01007914 // give an error now.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007915 vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01007916 if (vartype->tt_type != VAR_LIST && vartype->tt_type != VAR_STRING
Bram Moolenaard551d6c2021-04-18 13:15:58 +02007917 && vartype->tt_type != VAR_BLOB && vartype->tt_type != VAR_ANY)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007918 {
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01007919 semsg(_(e_for_loop_on_str_not_supported),
7920 vartype_name(vartype->tt_type));
Bram Moolenaar25b70c72020-04-01 16:34:17 +02007921 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007922 return NULL;
7923 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01007924
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02007925 if (vartype->tt_type == VAR_STRING)
7926 item_type = &t_string;
Bram Moolenaard551d6c2021-04-18 13:15:58 +02007927 else if (vartype->tt_type == VAR_BLOB)
7928 item_type = &t_number;
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02007929 else if (vartype->tt_type == VAR_LIST
7930 && vartype->tt_member->tt_type != VAR_ANY)
Bram Moolenaar792f7862020-11-23 08:31:18 +01007931 {
Bram Moolenaar444d8782021-06-26 12:40:56 +02007932 if (!var_list)
Bram Moolenaar792f7862020-11-23 08:31:18 +01007933 item_type = vartype->tt_member;
7934 else if (vartype->tt_member->tt_type == VAR_LIST
7935 && vartype->tt_member->tt_member->tt_type != VAR_ANY)
Bram Moolenaard551d6c2021-04-18 13:15:58 +02007936 // TODO: should get the type for each lhs
Bram Moolenaar792f7862020-11-23 08:31:18 +01007937 item_type = vartype->tt_member->tt_member;
7938 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007939
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007940 // CMDMOD_REV must come before the FOR instruction.
Bram Moolenaara91a7132021-03-25 21:12:15 +01007941 generate_undo_cmdmods(cctx);
7942
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007943 // "for_end" is set when ":endfor" is found
Bram Moolenaara91a7132021-03-25 21:12:15 +01007944 scope->se_u.se_for.fs_top_label = current_instr_idx(cctx);
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02007945
Bram Moolenaarb84a3812020-05-01 15:44:29 +02007946 generate_FOR(cctx, loop_lvar->lv_idx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007947
Bram Moolenaar792f7862020-11-23 08:31:18 +01007948 arg = arg_start;
Bram Moolenaar444d8782021-06-26 12:40:56 +02007949 if (var_list)
Bram Moolenaar792f7862020-11-23 08:31:18 +01007950 {
7951 generate_UNPACK(cctx, var_count, semicolon);
7952 arg = skipwhite(arg + 1); // skip white after '['
7953
7954 // the list item is replaced by a number of items
7955 if (ga_grow(stack, var_count - 1) == FAIL)
7956 {
7957 drop_scope(cctx);
7958 return NULL;
7959 }
7960 --stack->ga_len;
7961 for (idx = 0; idx < var_count; ++idx)
7962 {
7963 ((type_T **)stack->ga_data)[stack->ga_len] =
7964 (semicolon && idx == 0) ? vartype : item_type;
7965 ++stack->ga_len;
7966 }
7967 }
7968
7969 for (idx = 0; idx < var_count; ++idx)
7970 {
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007971 assign_dest_T dest = dest_local;
7972 int opt_flags = 0;
7973 int vimvaridx = -1;
7974 type_T *type = &t_any;
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02007975 type_T *lhs_type = &t_any;
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02007976 where_T where = WHERE_INIT;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007977
7978 p = skip_var_one(arg, FALSE);
Bram Moolenaar792f7862020-11-23 08:31:18 +01007979 varlen = p - arg;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007980 name = vim_strnsave(arg, varlen);
7981 if (name == NULL)
7982 goto failed;
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02007983 if (*p == ':')
7984 {
7985 p = skipwhite(p + 1);
7986 lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE);
7987 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01007988
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007989 // TODO: script var not supported?
7990 if (get_var_dest(name, &dest, CMD_for, &opt_flags,
7991 &vimvaridx, &type, cctx) == FAIL)
7992 goto failed;
7993 if (dest != dest_local)
Bram Moolenaar792f7862020-11-23 08:31:18 +01007994 {
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01007995 if (generate_store_var(cctx, dest, opt_flags, vimvaridx,
7996 0, 0, type, name) == FAIL)
7997 goto failed;
Bram Moolenaar792f7862020-11-23 08:31:18 +01007998 }
Bram Moolenaarb777da92021-05-22 21:40:39 +02007999 else if (varlen == 1 && *arg == '_')
8000 {
8001 // Assigning to "_": drop the value.
8002 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
8003 goto failed;
8004 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01008005 else
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008006 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01008007 if (lookup_local(arg, varlen, NULL, cctx) == OK)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008008 {
8009 semsg(_(e_variable_already_declared), arg);
8010 goto failed;
8011 }
8012
Bram Moolenaarea870692020-12-02 14:24:30 +01008013 if (STRNCMP(name, "s:", 2) == 0)
8014 {
8015 semsg(_(e_cannot_declare_script_variable_in_function), name);
8016 goto failed;
8017 }
8018
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008019 // Reserve a variable to store "var".
Bram Moolenaar444d8782021-06-26 12:40:56 +02008020 where.wt_index = var_list ? idx + 1 : 0;
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02008021 where.wt_variable = TRUE;
8022 if (lhs_type == &t_any)
8023 lhs_type = item_type;
8024 else if (item_type != &t_unknown
Bram Moolenaar5ede5b22021-07-07 21:55:25 +02008025 && (item_type == &t_any
Bram Moolenaarefc5db52021-07-07 21:21:30 +02008026 ? need_type(item_type, lhs_type,
8027 -1, 0, cctx, FALSE, FALSE)
8028 : check_type(lhs_type, item_type, TRUE, where))
8029 == FAIL)
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02008030 goto failed;
8031 var_lvar = reserve_local(cctx, arg, varlen, TRUE, lhs_type);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008032 if (var_lvar == NULL)
8033 // out of memory or used as an argument
8034 goto failed;
8035
8036 if (semicolon && idx == var_count - 1)
8037 var_lvar->lv_type = vartype;
8038 else
8039 var_lvar->lv_type = item_type;
8040 generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
8041 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01008042
8043 if (*p == ',' || *p == ';')
8044 ++p;
8045 arg = skipwhite(p);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008046 vim_free(name);
Bram Moolenaar792f7862020-11-23 08:31:18 +01008047 }
8048
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008049 if (cctx->ctx_compile_type == CT_DEBUG)
Bram Moolenaar6fc01612021-07-03 13:36:31 +02008050 {
8051 int save_prev_lnum = cctx->ctx_prev_lnum;
8052
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008053 // Add ISN_DEBUG here, so that the loop variables can be inspected.
Bram Moolenaar6fc01612021-07-03 13:36:31 +02008054 // Use the prev_lnum from the ISN_DEBUG instruction removed above.
8055 cctx->ctx_prev_lnum = prev_lnum;
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008056 generate_instr_debug(cctx);
Bram Moolenaar6fc01612021-07-03 13:36:31 +02008057 cctx->ctx_prev_lnum = save_prev_lnum;
8058 }
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008059
Bram Moolenaar792f7862020-11-23 08:31:18 +01008060 return arg_end;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01008061
8062failed:
8063 vim_free(name);
8064 drop_scope(cctx);
8065 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008066}
8067
8068/*
8069 * compile "endfor"
8070 */
8071 static char_u *
8072compile_endfor(char_u *arg, cctx_T *cctx)
8073{
8074 garray_T *instr = &cctx->ctx_instr;
8075 scope_T *scope = cctx->ctx_scope;
8076 forscope_T *forscope;
8077 isn_T *isn;
8078
Bram Moolenaarfa984412021-03-25 22:15:28 +01008079 if (misplaced_cmdmod(cctx))
8080 return NULL;
Bram Moolenaara91a7132021-03-25 21:12:15 +01008081
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008082 if (scope == NULL || scope->se_type != FOR_SCOPE)
8083 {
8084 emsg(_(e_for));
8085 return NULL;
8086 }
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008087 forscope = &scope->se_u.se_for;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008088 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008089 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008090
8091 // At end of ":for" scope jump back to the FOR instruction.
8092 generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label);
8093
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008094 // Fill in the "end" label in the FOR statement so it can jump here.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008095 isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label;
8096 isn->isn_arg.forloop.for_end = instr->ga_len;
8097
8098 // Fill in the "end" label any BREAK statements
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008099 compile_fill_jump_to_end(&forscope->fs_end_label, instr->ga_len, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008100
8101 // Below the ":for" scope drop the "expr" list from the stack.
8102 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
8103 return NULL;
8104
8105 vim_free(scope);
8106
8107 return arg;
8108}
8109
8110/*
8111 * compile "while expr"
8112 *
8113 * Produces instructions:
8114 * top: EVAL expr Push result of "expr"
8115 * JUMP_IF_FALSE end jump if false
8116 * ... body ...
8117 * JUMP top Jump back to repeat
8118 * end:
8119 *
8120 */
8121 static char_u *
8122compile_while(char_u *arg, cctx_T *cctx)
8123{
8124 char_u *p = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008125 scope_T *scope;
8126
8127 scope = new_scope(cctx, WHILE_SCOPE);
8128 if (scope == NULL)
8129 return NULL;
8130
Bram Moolenaara91a7132021-03-25 21:12:15 +01008131 // "endwhile" jumps back here, one before when profiling or using cmdmods
8132 scope->se_u.se_while.ws_top_label = current_instr_idx(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008133
8134 // compile "expr"
Bram Moolenaara5565e42020-05-09 15:44:01 +02008135 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008136 return NULL;
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01008137 if (!ends_excmd2(arg, skipwhite(p)))
8138 {
8139 semsg(_(e_trailing_arg), p);
8140 return NULL;
8141 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008142
Bram Moolenaar13106602020-10-04 16:06:05 +02008143 if (bool_on_stack(cctx) == FAIL)
8144 return FAIL;
8145
Bram Moolenaara91a7132021-03-25 21:12:15 +01008146 // CMDMOD_REV must come before the jump
8147 generate_undo_cmdmods(cctx);
8148
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008149 // "while_end" is set when ":endwhile" is found
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008150 if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008151 JUMP_IF_FALSE, cctx) == FAIL)
8152 return FAIL;
8153
8154 return p;
8155}
8156
8157/*
8158 * compile "endwhile"
8159 */
8160 static char_u *
8161compile_endwhile(char_u *arg, cctx_T *cctx)
8162{
8163 scope_T *scope = cctx->ctx_scope;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008164 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008165
Bram Moolenaarfa984412021-03-25 22:15:28 +01008166 if (misplaced_cmdmod(cctx))
8167 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008168 if (scope == NULL || scope->se_type != WHILE_SCOPE)
8169 {
8170 emsg(_(e_while));
8171 return NULL;
8172 }
8173 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008174 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008175
Bram Moolenaarf002a412021-01-24 13:34:18 +01008176#ifdef FEAT_PROFILE
Bram Moolenaarb2049902021-01-24 12:53:53 +01008177 // count the endwhile before jumping
8178 may_generate_prof_end(cctx, cctx->ctx_lnum);
Bram Moolenaarf002a412021-01-24 13:34:18 +01008179#endif
Bram Moolenaarb2049902021-01-24 12:53:53 +01008180
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008181 // At end of ":for" scope jump back to the FOR instruction.
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008182 generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008183
8184 // Fill in the "end" label in the WHILE statement so it can jump here.
8185 // And in any jumps for ":break"
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008186 compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label,
8187 instr->ga_len, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008188
8189 vim_free(scope);
8190
8191 return arg;
8192}
8193
8194/*
8195 * compile "continue"
8196 */
8197 static char_u *
8198compile_continue(char_u *arg, cctx_T *cctx)
8199{
8200 scope_T *scope = cctx->ctx_scope;
Bram Moolenaarc150c092021-02-13 15:02:46 +01008201 int try_scopes = 0;
8202 int loop_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008203
8204 for (;;)
8205 {
8206 if (scope == NULL)
8207 {
8208 emsg(_(e_continue));
8209 return NULL;
8210 }
Bram Moolenaarc150c092021-02-13 15:02:46 +01008211 if (scope->se_type == FOR_SCOPE)
8212 {
8213 loop_label = scope->se_u.se_for.fs_top_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008214 break;
Bram Moolenaarc150c092021-02-13 15:02:46 +01008215 }
8216 if (scope->se_type == WHILE_SCOPE)
8217 {
8218 loop_label = scope->se_u.se_while.ws_top_label;
8219 break;
8220 }
8221 if (scope->se_type == TRY_SCOPE)
8222 ++try_scopes;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008223 scope = scope->se_outer;
8224 }
8225
Bram Moolenaarc150c092021-02-13 15:02:46 +01008226 if (try_scopes > 0)
8227 // Inside one or more try/catch blocks we first need to jump to the
8228 // "finally" or "endtry" to cleanup.
8229 generate_TRYCONT(cctx, try_scopes, loop_label);
8230 else
8231 // Jump back to the FOR or WHILE instruction.
8232 generate_JUMP(cctx, JUMP_ALWAYS, loop_label);
8233
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008234 return arg;
8235}
8236
8237/*
8238 * compile "break"
8239 */
8240 static char_u *
8241compile_break(char_u *arg, cctx_T *cctx)
8242{
8243 scope_T *scope = cctx->ctx_scope;
8244 endlabel_T **el;
8245
8246 for (;;)
8247 {
8248 if (scope == NULL)
8249 {
8250 emsg(_(e_break));
8251 return NULL;
8252 }
8253 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE)
8254 break;
8255 scope = scope->se_outer;
8256 }
8257
8258 // Jump to the end of the FOR or WHILE loop.
8259 if (scope->se_type == FOR_SCOPE)
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008260 el = &scope->se_u.se_for.fs_end_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008261 else
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008262 el = &scope->se_u.se_while.ws_end_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008263 if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL)
8264 return FAIL;
8265
8266 return arg;
8267}
8268
8269/*
8270 * compile "{" start of block
8271 */
8272 static char_u *
8273compile_block(char_u *arg, cctx_T *cctx)
8274{
8275 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
8276 return NULL;
8277 return skipwhite(arg + 1);
8278}
8279
8280/*
8281 * compile end of block: drop one scope
8282 */
8283 static void
8284compile_endblock(cctx_T *cctx)
8285{
8286 scope_T *scope = cctx->ctx_scope;
8287
8288 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008289 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008290 vim_free(scope);
8291}
8292
8293/*
8294 * compile "try"
8295 * Creates a new scope for the try-endtry, pointing to the first catch and
8296 * finally.
8297 * Creates another scope for the "try" block itself.
8298 * TRY instruction sets up exception handling at runtime.
8299 *
8300 * "try"
8301 * TRY -> catch1, -> finally push trystack entry
8302 * ... try block
8303 * "throw {exception}"
8304 * EVAL {exception}
8305 * THROW create exception
8306 * ... try block
8307 * " catch {expr}"
8308 * JUMP -> finally
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01008309 * catch1: PUSH exception
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008310 * EVAL {expr}
8311 * MATCH
8312 * JUMP nomatch -> catch2
8313 * CATCH remove exception
8314 * ... catch block
8315 * " catch"
8316 * JUMP -> finally
8317 * catch2: CATCH remove exception
8318 * ... catch block
8319 * " finally"
8320 * finally:
8321 * ... finally block
8322 * " endtry"
8323 * ENDTRY pop trystack entry, may rethrow
8324 */
8325 static char_u *
8326compile_try(char_u *arg, cctx_T *cctx)
8327{
8328 garray_T *instr = &cctx->ctx_instr;
8329 scope_T *try_scope;
8330 scope_T *scope;
8331
Bram Moolenaarfa984412021-03-25 22:15:28 +01008332 if (misplaced_cmdmod(cctx))
8333 return NULL;
8334
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008335 // scope that holds the jumps that go to catch/finally/endtry
8336 try_scope = new_scope(cctx, TRY_SCOPE);
8337 if (try_scope == NULL)
8338 return NULL;
8339
Bram Moolenaar69f70502021-01-01 16:10:46 +01008340 if (cctx->ctx_skip != SKIP_YES)
8341 {
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008342 isn_T *isn;
8343
8344 // "try_catch" is set when the first ":catch" is found or when no catch
8345 // is found and ":finally" is found.
8346 // "try_finally" is set when ":finally" is found
8347 // "try_endtry" is set when ":endtry" is found
Bram Moolenaar69f70502021-01-01 16:10:46 +01008348 try_scope->se_u.se_try.ts_try_label = instr->ga_len;
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008349 if ((isn = generate_instr(cctx, ISN_TRY)) == NULL)
8350 return NULL;
8351 isn->isn_arg.try.try_ref = ALLOC_CLEAR_ONE(tryref_T);
8352 if (isn->isn_arg.try.try_ref == NULL)
Bram Moolenaar69f70502021-01-01 16:10:46 +01008353 return NULL;
8354 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008355
8356 // scope for the try block itself
8357 scope = new_scope(cctx, BLOCK_SCOPE);
8358 if (scope == NULL)
8359 return NULL;
8360
8361 return arg;
8362}
8363
8364/*
8365 * compile "catch {expr}"
8366 */
8367 static char_u *
8368compile_catch(char_u *arg, cctx_T *cctx UNUSED)
8369{
8370 scope_T *scope = cctx->ctx_scope;
8371 garray_T *instr = &cctx->ctx_instr;
8372 char_u *p;
8373 isn_T *isn;
8374
Bram Moolenaarfa984412021-03-25 22:15:28 +01008375 if (misplaced_cmdmod(cctx))
8376 return NULL;
8377
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008378 // end block scope from :try or :catch
8379 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
8380 compile_endblock(cctx);
8381 scope = cctx->ctx_scope;
8382
8383 // Error if not in a :try scope
8384 if (scope == NULL || scope->se_type != TRY_SCOPE)
8385 {
8386 emsg(_(e_catch));
8387 return NULL;
8388 }
8389
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008390 if (scope->se_u.se_try.ts_caught_all)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008391 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02008392 emsg(_(e_catch_unreachable_after_catch_all));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008393 return NULL;
8394 }
8395
Bram Moolenaar69f70502021-01-01 16:10:46 +01008396 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008397 {
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008398#ifdef FEAT_PROFILE
8399 // the profile-start should be after the jump
Bram Moolenaare99d4222021-06-13 14:01:26 +02008400 if (cctx->ctx_compile_type == CT_PROFILE
Bram Moolenaar6bc30b02021-06-16 19:19:55 +02008401 && instr->ga_len > 0
Bram Moolenaare99d4222021-06-13 14:01:26 +02008402 && ((isn_T *)instr->ga_data)[instr->ga_len - 1]
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008403 .isn_type == ISN_PROF_START)
8404 --instr->ga_len;
8405#endif
Bram Moolenaar69f70502021-01-01 16:10:46 +01008406 // Jump from end of previous block to :finally or :endtry
8407 if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label,
8408 JUMP_ALWAYS, cctx) == FAIL)
8409 return NULL;
8410
8411 // End :try or :catch scope: set value in ISN_TRY instruction
8412 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008413 if (isn->isn_arg.try.try_ref->try_catch == 0)
8414 isn->isn_arg.try.try_ref->try_catch = instr->ga_len;
Bram Moolenaar69f70502021-01-01 16:10:46 +01008415 if (scope->se_u.se_try.ts_catch_label != 0)
8416 {
8417 // Previous catch without match jumps here
8418 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
8419 isn->isn_arg.jump.jump_where = instr->ga_len;
8420 }
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008421#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02008422 if (cctx->ctx_compile_type == CT_PROFILE)
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008423 {
8424 // a "throw" that jumps here needs to be counted
8425 generate_instr(cctx, ISN_PROF_END);
8426 // the "catch" is also counted
8427 generate_instr(cctx, ISN_PROF_START);
8428 }
8429#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02008430 if (cctx->ctx_compile_type == CT_DEBUG)
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02008431 generate_instr_debug(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008432 }
8433
8434 p = skipwhite(arg);
Bram Moolenaar7a092242020-04-16 22:10:49 +02008435 if (ends_excmd2(arg, p))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008436 {
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008437 scope->se_u.se_try.ts_caught_all = TRUE;
8438 scope->se_u.se_try.ts_catch_label = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008439 }
8440 else
8441 {
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008442 char_u *end;
8443 char_u *pat;
8444 char_u *tofree = NULL;
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02008445 int dropped = 0;
Bram Moolenaar3dd64602020-02-13 20:31:28 +01008446 int len;
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008447
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008448 // Push v:exception, push {expr} and MATCH
8449 generate_instr_type(cctx, ISN_PUSHEXC, &t_string);
8450
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01008451 end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped, NULL);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008452 if (*end != *p)
8453 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02008454 semsg(_(e_separator_mismatch_str), p);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008455 vim_free(tofree);
8456 return FAIL;
8457 }
8458 if (tofree == NULL)
Bram Moolenaar3dd64602020-02-13 20:31:28 +01008459 len = (int)(end - (p + 1));
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008460 else
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02008461 len = (int)(end - tofree);
8462 pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008463 vim_free(tofree);
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02008464 p += len + 2 + dropped;
Bram Moolenaarff80cb62020-02-05 22:10:05 +01008465 if (pat == NULL)
8466 return FAIL;
8467 if (generate_PUSHS(cctx, pat) == FAIL)
8468 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008469
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008470 if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL)
8471 return NULL;
8472
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008473 scope->se_u.se_try.ts_catch_label = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008474 if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL)
8475 return NULL;
8476 }
8477
Bram Moolenaar69f70502021-01-01 16:10:46 +01008478 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_CATCH) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008479 return NULL;
8480
8481 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
8482 return NULL;
8483 return p;
8484}
8485
8486 static char_u *
8487compile_finally(char_u *arg, cctx_T *cctx)
8488{
8489 scope_T *scope = cctx->ctx_scope;
8490 garray_T *instr = &cctx->ctx_instr;
8491 isn_T *isn;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008492 int this_instr;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008493
Bram Moolenaarfa984412021-03-25 22:15:28 +01008494 if (misplaced_cmdmod(cctx))
8495 return NULL;
8496
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008497 // end block scope from :try or :catch
8498 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
8499 compile_endblock(cctx);
8500 scope = cctx->ctx_scope;
8501
8502 // Error if not in a :try scope
8503 if (scope == NULL || scope->se_type != TRY_SCOPE)
8504 {
8505 emsg(_(e_finally));
8506 return NULL;
8507 }
8508
8509 // End :catch or :finally scope: set value in ISN_TRY instruction
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008510 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008511 if (isn->isn_arg.try.try_ref->try_finally != 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008512 {
8513 emsg(_(e_finally_dup));
8514 return NULL;
8515 }
8516
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008517 this_instr = instr->ga_len;
8518#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02008519 if (cctx->ctx_compile_type == CT_PROFILE
Bram Moolenaar834193a2021-06-30 20:39:15 +02008520 && ((isn_T *)instr->ga_data)[this_instr - 1]
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008521 .isn_type == ISN_PROF_START)
Bram Moolenaar834193a2021-06-30 20:39:15 +02008522 {
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008523 // jump to the profile start of the "finally"
8524 --this_instr;
Bram Moolenaar834193a2021-06-30 20:39:15 +02008525
8526 // jump to the profile end above it
8527 if (this_instr > 0 && ((isn_T *)instr->ga_data)[this_instr - 1]
8528 .isn_type == ISN_PROF_END)
8529 --this_instr;
8530 }
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008531#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008532
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008533 // Fill in the "end" label in jumps at the end of the blocks.
8534 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label,
8535 this_instr, cctx);
8536
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008537 // If there is no :catch then an exception jumps to :finally.
8538 if (isn->isn_arg.try.try_ref->try_catch == 0)
8539 isn->isn_arg.try.try_ref->try_catch = this_instr;
8540 isn->isn_arg.try.try_ref->try_finally = this_instr;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008541 if (scope->se_u.se_try.ts_catch_label != 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008542 {
8543 // Previous catch without match jumps here
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01008544 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008545 isn->isn_arg.jump.jump_where = this_instr;
Bram Moolenaare8593122020-07-18 15:17:02 +02008546 scope->se_u.se_try.ts_catch_label = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008547 }
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008548 if (generate_instr(cctx, ISN_FINALLY) == NULL)
8549 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008550
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008551 // TODO: set index in ts_finally_label jumps
8552
8553 return arg;
8554}
8555
8556 static char_u *
8557compile_endtry(char_u *arg, cctx_T *cctx)
8558{
8559 scope_T *scope = cctx->ctx_scope;
8560 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaarc150c092021-02-13 15:02:46 +01008561 isn_T *try_isn;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008562
Bram Moolenaarfa984412021-03-25 22:15:28 +01008563 if (misplaced_cmdmod(cctx))
8564 return NULL;
8565
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008566 // end block scope from :catch or :finally
8567 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
8568 compile_endblock(cctx);
8569 scope = cctx->ctx_scope;
8570
8571 // Error if not in a :try scope
8572 if (scope == NULL || scope->se_type != TRY_SCOPE)
8573 {
8574 if (scope == NULL)
8575 emsg(_(e_no_endtry));
8576 else if (scope->se_type == WHILE_SCOPE)
8577 emsg(_(e_endwhile));
Bram Moolenaar5b18c242020-01-28 22:30:32 +01008578 else if (scope->se_type == FOR_SCOPE)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008579 emsg(_(e_endfor));
8580 else
8581 emsg(_(e_endif));
8582 return NULL;
8583 }
8584
Bram Moolenaarc150c092021-02-13 15:02:46 +01008585 try_isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
Bram Moolenaar69f70502021-01-01 16:10:46 +01008586 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008587 {
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008588 if (try_isn->isn_arg.try.try_ref->try_catch == 0
8589 && try_isn->isn_arg.try.try_ref->try_finally == 0)
Bram Moolenaar69f70502021-01-01 16:10:46 +01008590 {
8591 emsg(_(e_missing_catch_or_finally));
8592 return NULL;
8593 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008594
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008595#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02008596 if (cctx->ctx_compile_type == CT_PROFILE
8597 && ((isn_T *)instr->ga_data)[instr->ga_len - 1]
Dominique Pelle4781d6f2021-05-18 21:46:31 +02008598 .isn_type == ISN_PROF_START)
8599 // move the profile start after "endtry" so that it's not counted when
8600 // the exception is rethrown.
8601 --instr->ga_len;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008602#endif
8603
Bram Moolenaar69f70502021-01-01 16:10:46 +01008604 // Fill in the "end" label in jumps at the end of the blocks, if not
8605 // done by ":finally".
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008606 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label,
8607 instr->ga_len, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008608
Bram Moolenaar69f70502021-01-01 16:10:46 +01008609 if (scope->se_u.se_try.ts_catch_label != 0)
8610 {
8611 // Last catch without match jumps here
Bram Moolenaarc150c092021-02-13 15:02:46 +01008612 isn_T *isn = ((isn_T *)instr->ga_data)
8613 + scope->se_u.se_try.ts_catch_label;
Bram Moolenaar69f70502021-01-01 16:10:46 +01008614 isn->isn_arg.jump.jump_where = instr->ga_len;
8615 }
Bram Moolenaare8593122020-07-18 15:17:02 +02008616 }
8617
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008618 compile_endblock(cctx);
8619
Bram Moolenaar4afa7742021-02-14 16:34:59 +01008620 if (cctx->ctx_skip != SKIP_YES)
8621 {
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +01008622 // End :catch or :finally scope: set instruction index in ISN_TRY
8623 // instruction
8624 try_isn->isn_arg.try.try_ref->try_endtry = instr->ga_len;
Bram Moolenaar4afa7742021-02-14 16:34:59 +01008625 if (cctx->ctx_skip != SKIP_YES
8626 && generate_instr(cctx, ISN_ENDTRY) == NULL)
8627 return NULL;
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008628#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02008629 if (cctx->ctx_compile_type == CT_PROFILE)
Bram Moolenaar107e9ce2021-01-24 20:52:00 +01008630 generate_instr(cctx, ISN_PROF_START);
8631#endif
Bram Moolenaar4afa7742021-02-14 16:34:59 +01008632 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008633 return arg;
8634}
8635
8636/*
8637 * compile "throw {expr}"
8638 */
8639 static char_u *
8640compile_throw(char_u *arg, cctx_T *cctx UNUSED)
8641{
8642 char_u *p = skipwhite(arg);
8643
Bram Moolenaara5565e42020-05-09 15:44:01 +02008644 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008645 return NULL;
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +01008646 if (cctx->ctx_skip == SKIP_YES)
8647 return p;
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02008648 if (may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008649 return NULL;
8650 if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL)
8651 return NULL;
8652
8653 return p;
8654}
8655
Bram Moolenaarc3235272021-07-10 19:42:03 +02008656 static char_u *
8657compile_eval(char_u *arg, cctx_T *cctx)
8658{
8659 char_u *p = arg;
8660 int name_only;
8661 char_u *alias;
8662 long lnum = SOURCING_LNUM;
8663
8664 // find_ex_command() will consider a variable name an expression, assuming
8665 // that something follows on the next line. Check that something actually
8666 // follows, otherwise it's probably a misplaced command.
8667 get_name_len(&p, &alias, FALSE, FALSE);
8668 name_only = ends_excmd2(arg, skipwhite(p));
8669 vim_free(alias);
8670
8671 p = arg;
8672 if (compile_expr0(&p, cctx) == FAIL)
8673 return NULL;
8674
8675 if (name_only && lnum == SOURCING_LNUM)
8676 {
8677 semsg(_(e_expression_without_effect_str), arg);
8678 return NULL;
8679 }
8680
8681 // drop the result
8682 generate_instr_drop(cctx, ISN_DROP, 1);
8683
8684 return skipwhite(p);
8685}
8686
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008687/*
8688 * compile "echo expr"
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02008689 * compile "echomsg expr"
8690 * compile "echoerr expr"
Bram Moolenaarad39c092020-02-26 18:23:43 +01008691 * compile "execute expr"
8692 */
8693 static char_u *
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02008694compile_mult_expr(char_u *arg, int cmdidx, cctx_T *cctx)
Bram Moolenaarad39c092020-02-26 18:23:43 +01008695{
8696 char_u *p = arg;
Bram Moolenaare4984292020-12-13 14:19:25 +01008697 char_u *prev = arg;
Bram Moolenaar68db9962021-05-09 23:19:22 +02008698 char_u *expr_start;
Bram Moolenaarad39c092020-02-26 18:23:43 +01008699 int count = 0;
Bram Moolenaarc70fe462021-04-17 17:59:19 +02008700 int start_ctx_lnum = cctx->ctx_lnum;
Bram Moolenaar68db9962021-05-09 23:19:22 +02008701 garray_T *stack = &cctx->ctx_type_stack;
8702 type_T *type;
Bram Moolenaarad39c092020-02-26 18:23:43 +01008703
8704 for (;;)
8705 {
Bram Moolenaare4984292020-12-13 14:19:25 +01008706 if (ends_excmd2(prev, p))
8707 break;
Bram Moolenaar68db9962021-05-09 23:19:22 +02008708 expr_start = p;
Bram Moolenaara5565e42020-05-09 15:44:01 +02008709 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaarad39c092020-02-26 18:23:43 +01008710 return NULL;
Bram Moolenaar68db9962021-05-09 23:19:22 +02008711
8712 if (cctx->ctx_skip != SKIP_YES)
8713 {
8714 // check for non-void type
8715 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
8716 if (type->tt_type == VAR_VOID)
8717 {
8718 semsg(_(e_expression_does_not_result_in_value_str), expr_start);
8719 return NULL;
8720 }
8721 }
8722
Bram Moolenaarad39c092020-02-26 18:23:43 +01008723 ++count;
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02008724 prev = p;
Bram Moolenaarad39c092020-02-26 18:23:43 +01008725 p = skipwhite(p);
Bram Moolenaarad39c092020-02-26 18:23:43 +01008726 }
8727
Bram Moolenaare4984292020-12-13 14:19:25 +01008728 if (count > 0)
8729 {
Bram Moolenaarc70fe462021-04-17 17:59:19 +02008730 long save_lnum = cctx->ctx_lnum;
8731
8732 // Use the line number where the command started.
8733 cctx->ctx_lnum = start_ctx_lnum;
8734
Bram Moolenaare4984292020-12-13 14:19:25 +01008735 if (cmdidx == CMD_echo || cmdidx == CMD_echon)
8736 generate_ECHO(cctx, cmdidx == CMD_echo, count);
8737 else if (cmdidx == CMD_execute)
8738 generate_MULT_EXPR(cctx, ISN_EXECUTE, count);
8739 else if (cmdidx == CMD_echomsg)
8740 generate_MULT_EXPR(cctx, ISN_ECHOMSG, count);
8741 else
8742 generate_MULT_EXPR(cctx, ISN_ECHOERR, count);
Bram Moolenaarc70fe462021-04-17 17:59:19 +02008743
8744 cctx->ctx_lnum = save_lnum;
Bram Moolenaare4984292020-12-13 14:19:25 +01008745 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008746 return p;
8747}
8748
8749/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01008750 * If "eap" has a range that is not a constant generate an ISN_RANGE
Bram Moolenaar08597872020-12-10 19:43:40 +01008751 * instruction to compute it and return OK.
8752 * Otherwise return FAIL, the caller must deal with any range.
8753 */
8754 static int
8755compile_variable_range(exarg_T *eap, cctx_T *cctx)
8756{
8757 char_u *range_end = skip_range(eap->cmd, TRUE, NULL);
8758 char_u *p = skipdigits(eap->cmd);
8759
8760 if (p == range_end)
8761 return FAIL;
8762 return generate_RANGE(cctx, vim_strnsave(eap->cmd, range_end - eap->cmd));
8763}
8764
8765/*
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008766 * :put r
8767 * :put ={expr}
8768 */
8769 static char_u *
8770compile_put(char_u *arg, exarg_T *eap, cctx_T *cctx)
8771{
8772 char_u *line = arg;
8773 linenr_T lnum;
8774 char *errormsg;
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02008775 int above = eap->forceit;
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008776
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008777 eap->regname = *line;
8778
8779 if (eap->regname == '=')
8780 {
8781 char_u *p = line + 1;
8782
8783 if (compile_expr0(&p, cctx) == FAIL)
8784 return NULL;
8785 line = p;
8786 }
8787 else if (eap->regname != NUL)
8788 ++line;
8789
Bram Moolenaar08597872020-12-10 19:43:40 +01008790 if (compile_variable_range(eap, cctx) == OK)
8791 {
8792 lnum = above ? LNUM_VARIABLE_RANGE_ABOVE : LNUM_VARIABLE_RANGE;
8793 }
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008794 else
Bram Moolenaar08597872020-12-10 19:43:40 +01008795 {
8796 // Either no range or a number.
8797 // "errormsg" will not be set because the range is ADDR_LINES.
8798 if (parse_cmd_address(eap, &errormsg, FALSE) == FAIL)
Bram Moolenaar399ea812020-12-15 21:28:57 +01008799 // cannot happen
Bram Moolenaar08597872020-12-10 19:43:40 +01008800 return NULL;
8801 if (eap->addr_count == 0)
8802 lnum = -1;
8803 else
8804 lnum = eap->line2;
8805 if (above)
8806 --lnum;
8807 }
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008808
8809 generate_PUT(cctx, eap->regname, lnum);
8810 return line;
8811}
8812
8813/*
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008814 * A command that is not compiled, execute with legacy code.
8815 */
8816 static char_u *
8817compile_exec(char_u *line, exarg_T *eap, cctx_T *cctx)
8818{
Bram Moolenaare729ce22021-06-06 21:38:09 +02008819 char_u *p;
8820 int has_expr = FALSE;
8821 char_u *nextcmd = (char_u *)"";
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008822
Bram Moolenaar9b68c822020-06-18 19:31:08 +02008823 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008824 goto theend;
8825
Bram Moolenaare729ce22021-06-06 21:38:09 +02008826 // If there was a prececing command modifier, drop it and include it in the
8827 // EXEC command.
8828 if (cctx->ctx_has_cmdmod)
8829 {
8830 garray_T *instr = &cctx->ctx_instr;
8831 isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
8832
8833 if (isn->isn_type == ISN_CMDMOD)
8834 {
8835 vim_regfree(isn->isn_arg.cmdmod.cf_cmdmod
8836 ->cmod_filter_regmatch.regprog);
8837 vim_free(isn->isn_arg.cmdmod.cf_cmdmod);
8838 --instr->ga_len;
8839 cctx->ctx_has_cmdmod = FALSE;
8840 }
8841 }
8842
Bram Moolenaar7d41aa82020-04-26 14:29:56 +02008843 if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE)
Bram Moolenaare9f262b2020-07-05 14:57:51 +02008844 {
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02008845 long argt = eap->argt;
Bram Moolenaare9f262b2020-07-05 14:57:51 +02008846 int usefilter = FALSE;
8847
8848 has_expr = argt & (EX_XFILE | EX_EXPAND);
8849
8850 // If the command can be followed by a bar, find the bar and truncate
8851 // it, so that the following command can be compiled.
8852 // The '|' is overwritten with a NUL, it is put back below.
8853 if ((eap->cmdidx == CMD_write || eap->cmdidx == CMD_read)
8854 && *eap->arg == '!')
8855 // :w !filter or :r !filter or :r! filter
8856 usefilter = TRUE;
8857 if ((argt & EX_TRLBAR) && !usefilter)
8858 {
Bram Moolenaarb8a92962020-08-20 18:02:47 +02008859 eap->argt = argt;
Bram Moolenaare9f262b2020-07-05 14:57:51 +02008860 separate_nextcmd(eap);
8861 if (eap->nextcmd != NULL)
8862 nextcmd = eap->nextcmd;
8863 }
Bram Moolenaara11919f2021-01-02 19:44:56 +01008864 else if (eap->cmdidx == CMD_wincmd)
8865 {
8866 p = eap->arg;
8867 if (*p != NUL)
8868 ++p;
8869 if (*p == 'g' || *p == Ctrl_G)
8870 ++p;
8871 p = skipwhite(p);
8872 if (*p == '|')
8873 {
8874 *p = NUL;
8875 nextcmd = p + 1;
8876 }
8877 }
Bram Moolenaare9f262b2020-07-05 14:57:51 +02008878 }
8879
Bram Moolenaar6378c4f2020-04-26 13:50:41 +02008880 if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0)
8881 {
8882 // expand filename in "syntax include [@group] filename"
8883 has_expr = TRUE;
8884 eap->arg = skipwhite(eap->arg + 7);
8885 if (*eap->arg == '@')
8886 eap->arg = skiptowhite(eap->arg);
8887 }
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008888
Bram Moolenaar56ce9ea2020-12-25 18:35:29 +01008889 if ((eap->cmdidx == CMD_global || eap->cmdidx == CMD_vglobal)
8890 && STRLEN(eap->arg) > 4)
8891 {
8892 int delim = *eap->arg;
8893
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01008894 p = skip_regexp_ex(eap->arg + 1, delim, TRUE, NULL, NULL, NULL);
Bram Moolenaar56ce9ea2020-12-25 18:35:29 +01008895 if (*p == delim)
8896 {
8897 eap->arg = p + 1;
8898 has_expr = TRUE;
8899 }
8900 }
8901
Bram Moolenaarecac5912021-01-05 19:23:28 +01008902 if (eap->cmdidx == CMD_folddoopen || eap->cmdidx == CMD_folddoclosed)
8903 {
8904 // TODO: should only expand when appropriate for the command
8905 eap->arg = skiptowhite(eap->arg);
8906 has_expr = TRUE;
8907 }
8908
Bram Moolenaar6378c4f2020-04-26 13:50:41 +02008909 if (has_expr && (p = (char_u *)strstr((char *)eap->arg, "`=")) != NULL)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008910 {
8911 int count = 0;
8912 char_u *start = skipwhite(line);
8913
8914 // :cmd xxx`=expr1`yyy`=expr2`zzz
8915 // PUSHS ":cmd xxx"
8916 // eval expr1
8917 // PUSHS "yyy"
8918 // eval expr2
8919 // PUSHS "zzz"
8920 // EXECCONCAT 5
8921 for (;;)
8922 {
8923 if (p > start)
8924 {
Bram Moolenaar71ccd032020-06-12 22:59:11 +02008925 generate_PUSHS(cctx, vim_strnsave(start, p - start));
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008926 ++count;
8927 }
8928 p += 2;
Bram Moolenaara5565e42020-05-09 15:44:01 +02008929 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008930 return NULL;
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02008931 may_generate_2STRING(-1, TRUE, cctx);
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008932 ++count;
8933 p = skipwhite(p);
8934 if (*p != '`')
8935 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02008936 emsg(_(e_missing_backtick));
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008937 return NULL;
8938 }
8939 start = p + 1;
8940
8941 p = (char_u *)strstr((char *)start, "`=");
8942 if (p == NULL)
8943 {
8944 if (*skipwhite(start) != NUL)
8945 {
8946 generate_PUSHS(cctx, vim_strsave(start));
8947 ++count;
8948 }
8949 break;
8950 }
8951 }
8952 generate_EXECCONCAT(cctx, count);
8953 }
8954 else
8955 generate_EXEC(cctx, line);
8956
8957theend:
Bram Moolenaare9f262b2020-07-05 14:57:51 +02008958 if (*nextcmd != NUL)
8959 {
8960 // the parser expects a pointer to the bar, put it back
8961 --nextcmd;
8962 *nextcmd = '|';
8963 }
8964
8965 return nextcmd;
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008966}
8967
Bram Moolenaar20677332021-06-06 17:02:53 +02008968/*
8969 * A script command with heredoc, e.g.
8970 * ruby << EOF
8971 * command
8972 * EOF
8973 * Has been turned into one long line with NL characters by
8974 * get_function_body():
8975 * ruby << EOF<NL> command<NL>EOF
8976 */
8977 static char_u *
8978compile_script(char_u *line, cctx_T *cctx)
8979{
8980 if (cctx->ctx_skip != SKIP_YES)
8981 {
8982 isn_T *isn;
8983
8984 if ((isn = generate_instr(cctx, ISN_EXEC_SPLIT)) == NULL)
8985 return NULL;
8986 isn->isn_arg.string = vim_strsave(line);
8987 }
8988 return (char_u *)"";
8989}
8990
Bram Moolenaar8238f082021-04-20 21:10:48 +02008991
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008992/*
Bram Moolenaar4c137212021-04-19 16:48:48 +02008993 * :s/pat/repl/
8994 */
8995 static char_u *
8996compile_substitute(char_u *arg, exarg_T *eap, cctx_T *cctx)
8997{
8998 char_u *cmd = eap->arg;
8999 char_u *expr = (char_u *)strstr((char *)cmd, "\\=");
9000
9001 if (expr != NULL)
9002 {
9003 int delimiter = *cmd++;
9004
9005 // There is a \=expr, find it in the substitute part.
Bram Moolenaar8238f082021-04-20 21:10:48 +02009006 cmd = skip_regexp_ex(cmd, delimiter, magic_isset(), NULL, NULL, NULL);
Bram Moolenaar4c137212021-04-19 16:48:48 +02009007 if (cmd[0] == delimiter && cmd[1] == '\\' && cmd[2] == '=')
9008 {
Bram Moolenaar8238f082021-04-20 21:10:48 +02009009 garray_T save_ga = cctx->ctx_instr;
9010 char_u *end;
Bram Moolenaar169502f2021-04-21 12:19:35 +02009011 int expr_res;
Bram Moolenaar8238f082021-04-20 21:10:48 +02009012 int trailing_error;
9013 int instr_count;
Bram Moolenaarf18332f2021-05-07 17:55:55 +02009014 isn_T *instr;
Bram Moolenaar8238f082021-04-20 21:10:48 +02009015 isn_T *isn;
Bram Moolenaar4c137212021-04-19 16:48:48 +02009016
9017 cmd += 3;
9018 end = skip_substitute(cmd, delimiter);
9019
Bram Moolenaarf18332f2021-05-07 17:55:55 +02009020 // Temporarily reset the list of instructions so that the jump
Bram Moolenaar8238f082021-04-20 21:10:48 +02009021 // labels are correct.
9022 cctx->ctx_instr.ga_len = 0;
9023 cctx->ctx_instr.ga_maxlen = 0;
9024 cctx->ctx_instr.ga_data = NULL;
Bram Moolenaar169502f2021-04-21 12:19:35 +02009025 expr_res = compile_expr0(&cmd, cctx);
Bram Moolenaar4c137212021-04-19 16:48:48 +02009026 if (end[-1] == NUL)
9027 end[-1] = delimiter;
9028 cmd = skipwhite(cmd);
Bram Moolenaar8238f082021-04-20 21:10:48 +02009029 trailing_error = *cmd != delimiter && *cmd != NUL;
9030
Bram Moolenaar169502f2021-04-21 12:19:35 +02009031 if (expr_res == FAIL || trailing_error
9032 || ga_grow(&cctx->ctx_instr, 1) == FAIL)
Bram Moolenaar4c137212021-04-19 16:48:48 +02009033 {
Bram Moolenaar8238f082021-04-20 21:10:48 +02009034 if (trailing_error)
9035 semsg(_(e_trailing_arg), cmd);
9036 clear_instr_ga(&cctx->ctx_instr);
9037 cctx->ctx_instr = save_ga;
Bram Moolenaar4c137212021-04-19 16:48:48 +02009038 return NULL;
9039 }
9040
Bram Moolenaar8238f082021-04-20 21:10:48 +02009041 // Move the generated instructions into the ISN_SUBSTITUTE
9042 // instructions, then restore the list of instructions before
9043 // adding the ISN_SUBSTITUTE instruction.
Bram Moolenaar5c787fb2021-04-20 21:49:35 +02009044 instr_count = cctx->ctx_instr.ga_len;
9045 instr = cctx->ctx_instr.ga_data;
Bram Moolenaar8238f082021-04-20 21:10:48 +02009046 instr[instr_count].isn_type = ISN_FINISH;
9047
9048 cctx->ctx_instr = save_ga;
9049 if ((isn = generate_instr(cctx, ISN_SUBSTITUTE)) == NULL)
9050 {
9051 int idx;
9052
9053 for (idx = 0; idx < instr_count; ++idx)
9054 delete_instr(instr + idx);
9055 vim_free(instr);
Bram Moolenaar4c137212021-04-19 16:48:48 +02009056 return NULL;
Bram Moolenaar8238f082021-04-20 21:10:48 +02009057 }
9058 isn->isn_arg.subs.subs_cmd = vim_strsave(arg);
9059 isn->isn_arg.subs.subs_instr = instr;
Bram Moolenaar4c137212021-04-19 16:48:48 +02009060
9061 // skip over flags
9062 if (*end == '&')
9063 ++end;
9064 while (ASCII_ISALPHA(*end) || *end == '#')
9065 ++end;
9066 return end;
9067 }
9068 }
9069
9070 return compile_exec(arg, eap, cctx);
9071}
9072
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009073 static char_u *
9074compile_redir(char_u *line, exarg_T *eap, cctx_T *cctx)
9075{
9076 char_u *arg = eap->arg;
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009077 lhs_T *lhs = &cctx->ctx_redir_lhs;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009078
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009079 if (lhs->lhs_name != NULL)
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009080 {
9081 if (STRNCMP(arg, "END", 3) == 0)
9082 {
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009083 if (lhs->lhs_append)
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009084 {
Bram Moolenaara369c3d2021-04-21 16:00:10 +02009085 // First load the current variable value.
9086 if (compile_load_lhs_with_index(lhs, lhs->lhs_whole,
9087 cctx) == FAIL)
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009088 return NULL;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009089 }
9090
9091 // Gets the redirected text and put it on the stack, then store it
9092 // in the variable.
9093 generate_instr_type(cctx, ISN_REDIREND, &t_string);
9094
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009095 if (lhs->lhs_append)
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009096 generate_instr_drop(cctx, ISN_CONCAT, 1);
9097
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009098 if (lhs->lhs_has_index)
9099 {
9100 // Use the info in "lhs" to store the value at the index in the
9101 // list or dict.
9102 if (compile_assign_unlet(lhs->lhs_whole, lhs, TRUE,
9103 &t_string, cctx) == FAIL)
9104 return NULL;
9105 }
9106 else if (generate_store_lhs(cctx, lhs, -1) == FAIL)
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009107 return NULL;
9108
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009109 VIM_CLEAR(lhs->lhs_name);
9110 VIM_CLEAR(lhs->lhs_whole);
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009111 return arg + 3;
9112 }
9113 emsg(_(e_cannot_nest_redir));
9114 return NULL;
9115 }
9116
9117 if (arg[0] == '=' && arg[1] == '>')
9118 {
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009119 int append = FALSE;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009120
9121 // redirect to a variable is compiled
9122 arg += 2;
9123 if (*arg == '>')
9124 {
9125 ++arg;
9126 append = TRUE;
9127 }
9128 arg = skipwhite(arg);
9129
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009130 if (compile_assign_lhs(arg, lhs, CMD_redir,
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009131 FALSE, FALSE, 1, cctx) == FAIL)
9132 return NULL;
9133 generate_instr(cctx, ISN_REDIRSTART);
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009134 lhs->lhs_append = append;
9135 if (lhs->lhs_has_index)
9136 {
9137 lhs->lhs_whole = vim_strnsave(arg, lhs->lhs_varlen_total);
9138 if (lhs->lhs_whole == NULL)
9139 return NULL;
9140 }
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009141
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009142 return arg + lhs->lhs_varlen_total;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009143 }
9144
9145 // other redirects are handled like at script level
9146 return compile_exec(line, eap, cctx);
9147}
9148
Bram Moolenaarb7c97812021-05-05 22:51:39 +02009149#ifdef FEAT_QUICKFIX
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02009150 static char_u *
9151compile_cexpr(char_u *line, exarg_T *eap, cctx_T *cctx)
9152{
9153 isn_T *isn;
9154 char_u *p;
9155
9156 isn = generate_instr(cctx, ISN_CEXPR_AUCMD);
9157 if (isn == NULL)
9158 return NULL;
9159 isn->isn_arg.number = eap->cmdidx;
9160
9161 p = eap->arg;
9162 if (compile_expr0(&p, cctx) == FAIL)
9163 return NULL;
9164
9165 isn = generate_instr(cctx, ISN_CEXPR_CORE);
9166 if (isn == NULL)
9167 return NULL;
9168 isn->isn_arg.cexpr.cexpr_ref = ALLOC_ONE(cexprref_T);
9169 if (isn->isn_arg.cexpr.cexpr_ref == NULL)
9170 return NULL;
9171 isn->isn_arg.cexpr.cexpr_ref->cer_cmdidx = eap->cmdidx;
9172 isn->isn_arg.cexpr.cexpr_ref->cer_forceit = eap->forceit;
9173 isn->isn_arg.cexpr.cexpr_ref->cer_cmdline = vim_strsave(skipwhite(line));
9174
9175 return p;
9176}
Bram Moolenaarb7c97812021-05-05 22:51:39 +02009177#endif
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02009178
Bram Moolenaar4c137212021-04-19 16:48:48 +02009179/*
Bram Moolenaar09689a02020-05-09 22:50:08 +02009180 * Add a function to the list of :def functions.
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02009181 * This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet.
Bram Moolenaar09689a02020-05-09 22:50:08 +02009182 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02009183 static int
Bram Moolenaar09689a02020-05-09 22:50:08 +02009184add_def_function(ufunc_T *ufunc)
9185{
9186 dfunc_T *dfunc;
9187
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02009188 if (def_functions.ga_len == 0)
9189 {
9190 // The first position is not used, so that a zero uf_dfunc_idx means it
9191 // wasn't set.
9192 if (ga_grow(&def_functions, 1) == FAIL)
9193 return FAIL;
9194 ++def_functions.ga_len;
9195 }
9196
Bram Moolenaar09689a02020-05-09 22:50:08 +02009197 // Add the function to "def_functions".
9198 if (ga_grow(&def_functions, 1) == FAIL)
9199 return FAIL;
9200 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
9201 CLEAR_POINTER(dfunc);
9202 dfunc->df_idx = def_functions.ga_len;
9203 ufunc->uf_dfunc_idx = dfunc->df_idx;
9204 dfunc->df_ufunc = ufunc;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01009205 dfunc->df_name = vim_strsave(ufunc->uf_name);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02009206 ga_init2(&dfunc->df_var_names, sizeof(char_u *), 10);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01009207 ++dfunc->df_refcount;
Bram Moolenaar09689a02020-05-09 22:50:08 +02009208 ++def_functions.ga_len;
9209 return OK;
9210}
9211
9212/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009213 * After ex_function() has collected all the function lines: parse and compile
9214 * the lines into instructions.
9215 * Adds the function to "def_functions".
Bram Moolenaar9e68c322020-12-25 12:38:04 +01009216 * When "check_return_type" is set then set ufunc->uf_ret_type to the type of
9217 * the return statement (used for lambda). When uf_ret_type is already set
9218 * then check that it matches.
Bram Moolenaarb2049902021-01-24 12:53:53 +01009219 * When "profiling" is true add ISN_PROF_START instructions.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02009220 * "outer_cctx" is set for a nested function.
Bram Moolenaar05afcee2020-03-31 23:32:31 +02009221 * This can be used recursively through compile_lambda(), which may reallocate
9222 * "def_functions".
Bram Moolenaar822ba242020-05-24 23:00:18 +02009223 * Returns OK or FAIL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009224 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02009225 int
Bram Moolenaarb2049902021-01-24 12:53:53 +01009226compile_def_function(
Bram Moolenaare99d4222021-06-13 14:01:26 +02009227 ufunc_T *ufunc,
9228 int check_return_type,
9229 compiletype_T compile_type,
9230 cctx_T *outer_cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009231{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009232 char_u *line = NULL;
Bram Moolenaarf62d7392021-04-14 12:40:00 +02009233 char_u *line_to_free = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009234 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009235 char *errormsg = NULL; // error message
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009236 cctx_T cctx;
9237 garray_T *instr;
Bram Moolenaard66960b2020-10-30 20:46:26 +01009238 int did_emsg_before = did_emsg;
Bram Moolenaar599410c2021-04-10 14:03:43 +02009239 int did_emsg_silent_before = did_emsg_silent;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009240 int ret = FAIL;
9241 sctx_T save_current_sctx = current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02009242 int save_estack_compiling = estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02009243 int save_cmod_flags = cmdmod.cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009244 int do_estack_push;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02009245 int new_def_function = FALSE;
Bram Moolenaarf002a412021-01-24 13:34:18 +01009246#ifdef FEAT_PROFILE
Bram Moolenaarb2049902021-01-24 12:53:53 +01009247 int prof_lnum = -1;
Bram Moolenaarf002a412021-01-24 13:34:18 +01009248#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02009249 int debug_lnum = -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009250
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009251 // When using a function that was compiled before: Free old instructions.
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01009252 // The index is reused. Otherwise add a new entry in "def_functions".
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02009253 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009254 {
Bram Moolenaar09689a02020-05-09 22:50:08 +02009255 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
9256 + ufunc->uf_dfunc_idx;
Bram Moolenaar3b814af2021-06-15 10:22:17 +02009257 isn_T *instr_dest = NULL;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02009258
9259 switch (compile_type)
9260 {
9261 case CT_PROFILE:
9262#ifdef FEAT_PROFILE
9263 instr_dest = dfunc->df_instr_prof; break;
9264#endif
9265 case CT_NONE: instr_dest = dfunc->df_instr; break;
9266 case CT_DEBUG: instr_dest = dfunc->df_instr_debug; break;
9267 }
9268 if (instr_dest != NULL)
9269 // Was compiled in this mode before: Free old instructions.
9270 delete_def_function_contents(dfunc, FALSE);
9271 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009272 }
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02009273 else
9274 {
9275 if (add_def_function(ufunc) == FAIL)
9276 return FAIL;
9277 new_def_function = TRUE;
9278 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009279
Bram Moolenaar985116a2020-07-12 17:31:09 +02009280 ufunc->uf_def_status = UF_COMPILING;
9281
Bram Moolenaara80faa82020-04-12 19:37:17 +02009282 CLEAR_FIELD(cctx);
Bram Moolenaarb2049902021-01-24 12:53:53 +01009283
Bram Moolenaare99d4222021-06-13 14:01:26 +02009284 cctx.ctx_compile_type = compile_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009285 cctx.ctx_ufunc = ufunc;
9286 cctx.ctx_lnum = -1;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02009287 cctx.ctx_outer = outer_cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009288 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
9289 ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50);
9290 ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10);
9291 cctx.ctx_type_list = &ufunc->uf_type_list;
9292 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
9293 instr = &cctx.ctx_instr;
9294
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009295 // Set the context to the function, it may be compiled when called from
9296 // another script. Set the script version to the most modern one.
9297 // The line number will be set in next_line_from_context().
9298 current_sctx = ufunc->uf_script_ctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009299 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
9300
Bram Moolenaardc4c2302021-04-25 13:54:42 +02009301 // Don't use the flag from ":legacy" here.
9302 cmdmod.cmod_flags &= ~CMOD_LEGACY;
9303
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009304 // Make sure error messages are OK.
9305 do_estack_push = !estack_top_is_ufunc(ufunc, 1);
9306 if (do_estack_push)
9307 estack_push_ufunc(ufunc, 1);
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02009308 estack_compiling = TRUE;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009309
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009310 if (ufunc->uf_def_args.ga_len > 0)
9311 {
9312 int count = ufunc->uf_def_args.ga_len;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009313 int first_def_arg = ufunc->uf_args.ga_len - count;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009314 int i;
9315 char_u *arg;
9316 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
Bram Moolenaarb8070e32020-07-23 20:56:04 +02009317 int did_set_arg_type = FALSE;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009318
9319 // Produce instructions for the default values of optional arguments.
Bram Moolenaar12bce952021-03-11 20:04:04 +01009320 SOURCING_LNUM = 0; // line number unknown
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009321 for (i = 0; i < count; ++i)
9322 {
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009323 garray_T *stack = &cctx.ctx_type_stack;
9324 type_T *val_type;
9325 int arg_idx = first_def_arg + i;
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02009326 where_T where = WHERE_INIT;
Bram Moolenaar12bce952021-03-11 20:04:04 +01009327 int r;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02009328 int jump_instr_idx = instr->ga_len;
9329 isn_T *isn;
9330
9331 // Use a JUMP_IF_ARG_SET instruction to skip if the value was given.
9332 if (generate_JUMP_IF_ARG_SET(&cctx, i - count - off) == FAIL)
9333 goto erret;
Bram Moolenaar12bce952021-03-11 20:04:04 +01009334
9335 // Make sure later arguments are not found.
Bram Moolenaare28d9b32021-07-03 18:56:53 +02009336 ufunc->uf_args_visible = arg_idx;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009337
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009338 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
Bram Moolenaar12bce952021-03-11 20:04:04 +01009339 r = compile_expr0(&arg, &cctx);
9340
Bram Moolenaar12bce952021-03-11 20:04:04 +01009341 if (r == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009342 goto erret;
9343
9344 // If no type specified use the type of the default value.
9345 // Otherwise check that the default value type matches the
9346 // specified type.
9347 val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaarf785aa12021-02-11 21:19:34 +01009348 where.wt_index = arg_idx + 1;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009349 if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02009350 {
9351 did_set_arg_type = TRUE;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009352 ufunc->uf_arg_types[arg_idx] = val_type;
Bram Moolenaarb8070e32020-07-23 20:56:04 +02009353 }
Bram Moolenaar8b565c22020-08-30 23:24:20 +02009354 else if (check_type(ufunc->uf_arg_types[arg_idx], val_type,
Bram Moolenaarf785aa12021-02-11 21:19:34 +01009355 TRUE, where) == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009356 goto erret;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02009357
9358 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009359 goto erret;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02009360
9361 // set instruction index in JUMP_IF_ARG_SET to here
9362 isn = ((isn_T *)instr->ga_data) + jump_instr_idx;
9363 isn->isn_arg.jumparg.jump_where = instr->ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009364 }
Bram Moolenaarb8070e32020-07-23 20:56:04 +02009365
9366 if (did_set_arg_type)
9367 set_function_type(ufunc);
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009368 }
Bram Moolenaare28d9b32021-07-03 18:56:53 +02009369 ufunc->uf_args_visible = ufunc->uf_args.ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01009370
9371 /*
9372 * Loop over all the lines of the function and generate instructions.
9373 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009374 for (;;)
9375 {
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02009376 exarg_T ea;
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02009377 int starts_with_colon = FALSE;
9378 char_u *cmd;
Bram Moolenaar02194d22020-10-24 23:08:38 +02009379 cmdmod_T local_cmdmod;
Bram Moolenaar5b1c8fe2020-02-21 18:42:43 +01009380
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02009381 // Bail out on the first error to avoid a flood of errors and report
9382 // the right line number when inside try/catch.
Bram Moolenaard66960b2020-10-30 20:46:26 +01009383 if (did_emsg_before != did_emsg)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02009384 goto erret;
9385
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009386 if (line != NULL && *line == '|')
9387 // the line continues after a '|'
9388 ++line;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02009389 else if (line != NULL && *skipwhite(line) != NUL
Bram Moolenaar7a092242020-04-16 22:10:49 +02009390 && !(*line == '#' && (line == cctx.ctx_line_start
9391 || VIM_ISWHITE(line[-1]))))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009392 {
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02009393 semsg(_(e_trailing_arg), line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009394 goto erret;
9395 }
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01009396 else if (line != NULL && vim9_bad_comment(skipwhite(line)))
9397 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009398 else
9399 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02009400 line = next_line_from_context(&cctx, FALSE);
Bram Moolenaar4fdae992020-04-12 16:38:57 +02009401 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
Bram Moolenaarb2049902021-01-24 12:53:53 +01009402 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02009403 // beyond the last line
Bram Moolenaarf002a412021-01-24 13:34:18 +01009404#ifdef FEAT_PROFILE
Bram Moolenaarced68a02021-01-24 17:53:47 +01009405 if (cctx.ctx_skip != SKIP_YES)
9406 may_generate_prof_end(&cctx, prof_lnum);
Bram Moolenaarf002a412021-01-24 13:34:18 +01009407#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009408 break;
Bram Moolenaarb2049902021-01-24 12:53:53 +01009409 }
Bram Moolenaarf62d7392021-04-14 12:40:00 +02009410 // Make a copy, splitting off nextcmd and removing trailing spaces
9411 // may change it.
9412 if (line != NULL)
9413 {
9414 line = vim_strsave(line);
9415 vim_free(line_to_free);
9416 line_to_free = line;
9417 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009418 }
9419
Bram Moolenaara80faa82020-04-12 19:37:17 +02009420 CLEAR_FIELD(ea);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009421 ea.cmdlinep = &line;
9422 ea.cmd = skipwhite(line);
9423
Bram Moolenaarb2049902021-01-24 12:53:53 +01009424 if (*ea.cmd == '#')
9425 {
9426 // "#" starts a comment
9427 line = (char_u *)"";
9428 continue;
9429 }
9430
Bram Moolenaarf002a412021-01-24 13:34:18 +01009431#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02009432 if (cctx.ctx_compile_type == CT_PROFILE && cctx.ctx_lnum != prof_lnum
9433 && cctx.ctx_skip != SKIP_YES)
Bram Moolenaarb2049902021-01-24 12:53:53 +01009434 {
9435 may_generate_prof_end(&cctx, prof_lnum);
9436
9437 prof_lnum = cctx.ctx_lnum;
9438 generate_instr(&cctx, ISN_PROF_START);
9439 }
Bram Moolenaarf002a412021-01-24 13:34:18 +01009440#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02009441 if (cctx.ctx_compile_type == CT_DEBUG && cctx.ctx_lnum != debug_lnum
9442 && cctx.ctx_skip != SKIP_YES)
9443 {
9444 debug_lnum = cctx.ctx_lnum;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02009445 generate_instr_debug(&cctx);
Bram Moolenaare99d4222021-06-13 14:01:26 +02009446 }
Bram Moolenaar8cec9272021-06-23 20:20:53 +02009447 cctx.ctx_prev_lnum = cctx.ctx_lnum + 1;
Bram Moolenaarb2049902021-01-24 12:53:53 +01009448
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02009449 // Some things can be recognized by the first character.
9450 switch (*ea.cmd)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009451 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02009452 case '}':
9453 {
9454 // "}" ends a block scope
9455 scopetype_T stype = cctx.ctx_scope == NULL
9456 ? NO_SCOPE : cctx.ctx_scope->se_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009457
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02009458 if (stype == BLOCK_SCOPE)
9459 {
9460 compile_endblock(&cctx);
9461 line = ea.cmd;
9462 }
9463 else
9464 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02009465 emsg(_(e_using_rcurly_outside_if_block_scope));
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02009466 goto erret;
9467 }
9468 if (line != NULL)
9469 line = skipwhite(ea.cmd + 1);
9470 continue;
9471 }
9472
9473 case '{':
9474 // "{" starts a block scope
9475 // "{'a': 1}->func() is something else
9476 if (ends_excmd(*skipwhite(ea.cmd + 1)))
9477 {
9478 line = compile_block(ea.cmd, &cctx);
9479 continue;
9480 }
9481 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009482 }
9483
9484 /*
9485 * COMMAND MODIFIERS
9486 */
Bram Moolenaar02194d22020-10-24 23:08:38 +02009487 cctx.ctx_has_cmdmod = FALSE;
Bram Moolenaare1004402020-10-24 20:49:43 +02009488 if (parse_command_modifiers(&ea, &errormsg, &local_cmdmod, FALSE)
9489 == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009490 {
9491 if (errormsg != NULL)
9492 goto erret;
9493 // empty line or comment
9494 line = (char_u *)"";
9495 continue;
9496 }
Bram Moolenaare1004402020-10-24 20:49:43 +02009497 generate_cmdmods(&cctx, &local_cmdmod);
9498 undo_cmdmod(&local_cmdmod);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009499
Bram Moolenaare88c8e82020-11-01 17:03:37 +01009500 // Check if there was a colon after the last command modifier or before
9501 // the current position.
9502 for (p = ea.cmd; p >= line; --p)
9503 {
9504 if (*p == ':')
9505 starts_with_colon = TRUE;
9506 if (p < ea.cmd && !VIM_ISWHITE(*p))
9507 break;
9508 }
9509
Bram Moolenaarce024c32021-06-26 13:00:49 +02009510 // Skip ":call" to get to the function name, unless using :legacy
Bram Moolenaar575f24b2020-08-12 14:21:11 +02009511 p = ea.cmd;
Bram Moolenaarce024c32021-06-26 13:00:49 +02009512 if (!(local_cmdmod.cmod_flags & CMOD_LEGACY))
Bram Moolenaar575f24b2020-08-12 14:21:11 +02009513 {
Bram Moolenaarce024c32021-06-26 13:00:49 +02009514 if (checkforcmd(&ea.cmd, "call", 3))
9515 {
9516 if (*ea.cmd == '(')
9517 // not for "call()"
9518 ea.cmd = p;
9519 else
9520 ea.cmd = skipwhite(ea.cmd);
9521 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009522
Bram Moolenaarce024c32021-06-26 13:00:49 +02009523 if (!starts_with_colon)
9524 {
9525 int assign;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02009526
Bram Moolenaarce024c32021-06-26 13:00:49 +02009527 // Check for assignment after command modifiers.
9528 assign = may_compile_assignment(&ea, &line, &cctx);
9529 if (assign == OK)
9530 goto nextline;
9531 if (assign == FAIL)
9532 goto erret;
9533 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009534 }
9535
9536 /*
9537 * COMMAND after range
Bram Moolenaar3d48e252020-07-15 14:15:52 +02009538 * 'text'->func() should not be confused with 'a mark
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02009539 * "++nr" and "--nr" are eval commands
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009540 */
Bram Moolenaardf069ee2020-06-22 23:02:51 +02009541 cmd = ea.cmd;
Bram Moolenaarce024c32021-06-26 13:00:49 +02009542 if (!(local_cmdmod.cmod_flags & CMOD_LEGACY)
9543 && (starts_with_colon || !(*cmd == '\''
9544 || (cmd[0] == cmd[1] && (*cmd == '+' || *cmd == '-')))))
Bram Moolenaardf069ee2020-06-22 23:02:51 +02009545 {
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02009546 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009547 if (ea.cmd > cmd)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02009548 {
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009549 if (!starts_with_colon)
9550 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01009551 semsg(_(e_colon_required_before_range_str), cmd);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009552 goto erret;
9553 }
Bram Moolenaarada1d872021-02-20 08:16:51 +01009554 ea.addr_count = 1;
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009555 if (ends_excmd2(line, ea.cmd))
9556 {
9557 // A range without a command: jump to the line.
9558 // TODO: compile to a more efficient command, possibly
9559 // calling parse_cmd_address().
9560 ea.cmdidx = CMD_SIZE;
9561 line = compile_exec(line, &ea, &cctx);
9562 goto nextline;
9563 }
Bram Moolenaar3d48e252020-07-15 14:15:52 +02009564 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02009565 }
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02009566 p = find_ex_command(&ea, NULL,
9567 starts_with_colon || (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01009568 ? NULL : item_exists, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009569
Bram Moolenaard1510ee2021-01-04 16:15:58 +01009570 if (p == NULL)
9571 {
9572 if (cctx.ctx_skip != SKIP_YES)
9573 emsg(_(e_ambiguous_use_of_user_defined_command));
9574 goto erret;
9575 }
9576
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02009577 // When using ":legacy cmd" always use compile_exec().
9578 if (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02009579 {
9580 char_u *start = ea.cmd;
9581
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02009582 switch (ea.cmdidx)
9583 {
9584 case CMD_if:
9585 case CMD_elseif:
9586 case CMD_else:
9587 case CMD_endif:
9588 case CMD_for:
9589 case CMD_endfor:
9590 case CMD_continue:
9591 case CMD_break:
9592 case CMD_while:
9593 case CMD_endwhile:
9594 case CMD_try:
9595 case CMD_catch:
9596 case CMD_finally:
9597 case CMD_endtry:
9598 semsg(_(e_cannot_use_legacy_with_command_str), ea.cmd);
9599 goto erret;
9600 default: break;
9601 }
9602
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02009603 // ":legacy return expr" needs to be handled differently.
9604 if (checkforcmd(&start, "return", 4))
9605 ea.cmdidx = CMD_return;
9606 else
9607 ea.cmdidx = CMD_legacy;
9608 }
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02009609
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009610 if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
9611 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02009612 if (cctx.ctx_skip == SKIP_YES)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01009613 {
9614 line += STRLEN(line);
Bram Moolenaarf665e972020-12-05 19:17:16 +01009615 goto nextline;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01009616 }
9617
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009618 // Expression or function call.
Bram Moolenaar007f9d62020-07-06 23:04:49 +02009619 if (ea.cmdidx != CMD_eval)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009620 {
Bram Moolenaar52c124d2020-12-20 21:43:35 +01009621 // CMD_var cannot happen, compile_assignment() above would be
9622 // used. Most likely an assignment to a non-existing variable.
9623 semsg(_(e_command_not_recognized_str), ea.cmd);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02009624 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009625 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009626 }
9627
Bram Moolenaar3988f642020-08-27 22:43:03 +02009628 if (cctx.ctx_had_return
Bram Moolenaara259d8d2020-01-31 20:10:50 +01009629 && ea.cmdidx != CMD_elseif
9630 && ea.cmdidx != CMD_else
Bram Moolenaarefd88552020-06-18 20:50:10 +02009631 && ea.cmdidx != CMD_endif
9632 && ea.cmdidx != CMD_endfor
9633 && ea.cmdidx != CMD_endwhile
9634 && ea.cmdidx != CMD_catch
9635 && ea.cmdidx != CMD_finally
9636 && ea.cmdidx != CMD_endtry)
9637 {
Bram Moolenaar3988f642020-08-27 22:43:03 +02009638 emsg(_(e_unreachable_code_after_return));
9639 goto erret;
Bram Moolenaarefd88552020-06-18 20:50:10 +02009640 }
9641
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02009642 p = skipwhite(p);
9643 if (ea.cmdidx != CMD_SIZE
9644 && ea.cmdidx != CMD_write && ea.cmdidx != CMD_read)
9645 {
Bram Moolenaar9b123d82020-09-14 22:39:11 +02009646 if (ea.cmdidx >= 0)
9647 ea.argt = excmd_get_argt(ea.cmdidx);
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02009648 if ((ea.argt & EX_BANG) && *p == '!')
9649 {
9650 ea.forceit = TRUE;
9651 p = skipwhite(p + 1);
9652 }
9653 }
9654
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009655 switch (ea.cmdidx)
9656 {
9657 case CMD_def:
Bram Moolenaar04b12692020-05-04 23:24:44 +02009658 ea.arg = p;
9659 line = compile_nested_function(&ea, &cctx);
9660 break;
9661
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009662 case CMD_function:
Bram Moolenaar451c2e32020-08-15 16:33:28 +02009663 // TODO: should we allow this, e.g. to declare a global
9664 // function?
9665 emsg(_(e_cannot_use_function_inside_def));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009666 goto erret;
9667
9668 case CMD_return:
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02009669 line = compile_return(p, check_return_type,
9670 local_cmdmod.cmod_flags & CMOD_LEGACY, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009671 cctx.ctx_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009672 break;
9673
9674 case CMD_let:
Bram Moolenaarc58f5452020-10-21 20:58:52 +02009675 emsg(_(e_cannot_use_let_in_vim9_script));
9676 break;
Bram Moolenaar30fd8202020-09-26 15:09:30 +02009677 case CMD_var:
9678 case CMD_final:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009679 case CMD_const:
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02009680 case CMD_increment:
9681 case CMD_decrement:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009682 line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02009683 if (line == p)
9684 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009685 break;
9686
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02009687 case CMD_unlet:
9688 case CMD_unlockvar:
9689 case CMD_lockvar:
9690 line = compile_unletlock(p, &ea, &cctx);
9691 break;
9692
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009693 case CMD_import:
Bram Moolenaar4db572e2021-07-18 18:21:38 +02009694 emsg(_(e_import_can_only_be_used_in_script));
9695 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009696 break;
9697
9698 case CMD_if:
9699 line = compile_if(p, &cctx);
9700 break;
9701 case CMD_elseif:
9702 line = compile_elseif(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009703 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009704 break;
9705 case CMD_else:
9706 line = compile_else(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009707 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009708 break;
9709 case CMD_endif:
9710 line = compile_endif(p, &cctx);
9711 break;
9712
9713 case CMD_while:
9714 line = compile_while(p, &cctx);
9715 break;
9716 case CMD_endwhile:
9717 line = compile_endwhile(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009718 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009719 break;
9720
9721 case CMD_for:
9722 line = compile_for(p, &cctx);
9723 break;
9724 case CMD_endfor:
9725 line = compile_endfor(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009726 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009727 break;
9728 case CMD_continue:
9729 line = compile_continue(p, &cctx);
9730 break;
9731 case CMD_break:
9732 line = compile_break(p, &cctx);
9733 break;
9734
9735 case CMD_try:
9736 line = compile_try(p, &cctx);
9737 break;
9738 case CMD_catch:
9739 line = compile_catch(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009740 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009741 break;
9742 case CMD_finally:
9743 line = compile_finally(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009744 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009745 break;
9746 case CMD_endtry:
9747 line = compile_endtry(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02009748 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009749 break;
9750 case CMD_throw:
9751 line = compile_throw(p, &cctx);
9752 break;
9753
Bram Moolenaar007f9d62020-07-06 23:04:49 +02009754 case CMD_eval:
Bram Moolenaarc3235272021-07-10 19:42:03 +02009755 line = compile_eval(p, &cctx);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02009756 break;
9757
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009758 case CMD_echo:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009759 case CMD_echon:
Bram Moolenaarad39c092020-02-26 18:23:43 +01009760 case CMD_execute:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02009761 case CMD_echomsg:
9762 case CMD_echoerr:
9763 line = compile_mult_expr(p, ea.cmdidx, &cctx);
Bram Moolenaarad39c092020-02-26 18:23:43 +01009764 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009765
Bram Moolenaarc3516f72020-09-08 22:45:35 +02009766 case CMD_put:
9767 ea.cmd = cmd;
9768 line = compile_put(p, &ea, &cctx);
9769 break;
9770
Bram Moolenaar4c137212021-04-19 16:48:48 +02009771 case CMD_substitute:
9772 if (cctx.ctx_skip == SKIP_YES)
9773 line = (char_u *)"";
9774 else
9775 {
9776 ea.arg = p;
9777 line = compile_substitute(line, &ea, &cctx);
9778 }
9779 break;
9780
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009781 case CMD_redir:
9782 ea.arg = p;
9783 line = compile_redir(line, &ea, &cctx);
9784 break;
9785
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02009786 case CMD_cexpr:
9787 case CMD_lexpr:
9788 case CMD_caddexpr:
9789 case CMD_laddexpr:
9790 case CMD_cgetexpr:
9791 case CMD_lgetexpr:
Bram Moolenaarb7c97812021-05-05 22:51:39 +02009792#ifdef FEAT_QUICKFIX
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02009793 ea.arg = p;
9794 line = compile_cexpr(line, &ea, &cctx);
Bram Moolenaarb7c97812021-05-05 22:51:39 +02009795#else
9796 ex_ni(&ea);
9797 line = NULL;
9798#endif
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02009799 break;
9800
Bram Moolenaar3988f642020-08-27 22:43:03 +02009801 // TODO: any other commands with an expression argument?
Bram Moolenaardf069ee2020-06-22 23:02:51 +02009802
Bram Moolenaarae616492020-07-28 20:07:27 +02009803 case CMD_append:
9804 case CMD_change:
9805 case CMD_insert:
Bram Moolenaar10b94212021-02-19 21:42:57 +01009806 case CMD_k:
Bram Moolenaarf5a48012020-08-01 17:00:03 +02009807 case CMD_t:
Bram Moolenaarae616492020-07-28 20:07:27 +02009808 case CMD_xit:
9809 not_in_vim9(&ea);
9810 goto erret;
9811
Bram Moolenaar002262f2020-07-08 17:47:57 +02009812 case CMD_SIZE:
Bram Moolenaar3988f642020-08-27 22:43:03 +02009813 if (cctx.ctx_skip != SKIP_YES)
9814 {
9815 semsg(_(e_invalid_command_str), ea.cmd);
9816 goto erret;
9817 }
9818 // We don't check for a next command here.
9819 line = (char_u *)"";
9820 break;
Bram Moolenaar002262f2020-07-08 17:47:57 +02009821
Bram Moolenaar20677332021-06-06 17:02:53 +02009822 case CMD_lua:
9823 case CMD_mzscheme:
9824 case CMD_perl:
9825 case CMD_py3:
9826 case CMD_python3:
9827 case CMD_python:
9828 case CMD_pythonx:
9829 case CMD_ruby:
9830 case CMD_tcl:
9831 ea.arg = p;
9832 if (vim_strchr(line, '\n') == NULL)
Bram Moolenaar5163fcc2020-08-27 23:37:09 +02009833 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar20677332021-06-06 17:02:53 +02009834 else
9835 // heredoc lines have been concatenated with NL
9836 // characters in get_function_body()
9837 line = compile_script(line, &cctx);
9838 break;
9839
9840 default:
9841 // Not recognized, execute with do_cmdline_cmd().
9842 ea.arg = p;
9843 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009844 break;
9845 }
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009846nextline:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009847 if (line == NULL)
9848 goto erret;
Bram Moolenaar585fea72020-04-02 22:33:21 +02009849 line = skipwhite(line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009850
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02009851 // Undo any command modifiers.
Bram Moolenaar02194d22020-10-24 23:08:38 +02009852 generate_undo_cmdmods(&cctx);
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02009853
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009854 if (cctx.ctx_type_stack.ga_len < 0)
9855 {
9856 iemsg("Type stack underflow");
9857 goto erret;
9858 }
9859 }
9860
9861 if (cctx.ctx_scope != NULL)
9862 {
9863 if (cctx.ctx_scope->se_type == IF_SCOPE)
9864 emsg(_(e_endif));
9865 else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
9866 emsg(_(e_endwhile));
9867 else if (cctx.ctx_scope->se_type == FOR_SCOPE)
9868 emsg(_(e_endfor));
9869 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02009870 emsg(_(e_missing_rcurly));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009871 goto erret;
9872 }
9873
Bram Moolenaarefd88552020-06-18 20:50:10 +02009874 if (!cctx.ctx_had_return)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009875 {
Bram Moolenaare6174fd2021-06-12 18:30:56 +02009876 if (ufunc->uf_ret_type->tt_type == VAR_UNKNOWN)
9877 ufunc->uf_ret_type = &t_void;
9878 else if (ufunc->uf_ret_type->tt_type != VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009879 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02009880 emsg(_(e_missing_return_statement));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009881 goto erret;
9882 }
9883
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02009884 // Return void if there is no return at the end.
9885 generate_instr(&cctx, ISN_RETURN_VOID);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009886 }
9887
Bram Moolenaar599410c2021-04-10 14:03:43 +02009888 // When compiled with ":silent!" and there was an error don't consider the
9889 // function compiled.
9890 if (emsg_silent == 0 || did_emsg_silent == did_emsg_silent_before)
Bram Moolenaar05afcee2020-03-31 23:32:31 +02009891 {
9892 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
9893 + ufunc->uf_dfunc_idx;
9894 dfunc->df_deleted = FALSE;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01009895 dfunc->df_script_seq = current_sctx.sc_seq;
Bram Moolenaarf002a412021-01-24 13:34:18 +01009896#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02009897 if (cctx.ctx_compile_type == CT_PROFILE)
Bram Moolenaarb2049902021-01-24 12:53:53 +01009898 {
9899 dfunc->df_instr_prof = instr->ga_data;
9900 dfunc->df_instr_prof_count = instr->ga_len;
9901 }
9902 else
Bram Moolenaarf002a412021-01-24 13:34:18 +01009903#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02009904 if (cctx.ctx_compile_type == CT_DEBUG)
9905 {
9906 dfunc->df_instr_debug = instr->ga_data;
9907 dfunc->df_instr_debug_count = instr->ga_len;
9908 }
9909 else
Bram Moolenaarb2049902021-01-24 12:53:53 +01009910 {
9911 dfunc->df_instr = instr->ga_data;
9912 dfunc->df_instr_count = instr->ga_len;
9913 }
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02009914 dfunc->df_varcount = dfunc->df_var_names.ga_len;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02009915 dfunc->df_has_closure = cctx.ctx_has_closure;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02009916 if (cctx.ctx_outer_used)
9917 ufunc->uf_flags |= FC_CLOSURE;
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02009918 ufunc->uf_def_status = UF_COMPILED;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02009919 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009920
9921 ret = OK;
9922
9923erret:
Bram Moolenaar599410c2021-04-10 14:03:43 +02009924 if (ufunc->uf_def_status == UF_COMPILING)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009925 {
Bram Moolenaar05afcee2020-03-31 23:32:31 +02009926 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
9927 + ufunc->uf_dfunc_idx;
Bram Moolenaar20431c92020-03-20 18:39:46 +01009928
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02009929 // Compiling aborted, free the generated instructions.
Bram Moolenaar8238f082021-04-20 21:10:48 +02009930 clear_instr_ga(instr);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01009931 VIM_CLEAR(dfunc->df_name);
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02009932 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +01009933
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02009934 // If using the last entry in the table and it was added above, we
9935 // might as well remove it.
9936 if (!dfunc->df_deleted && new_def_function
Bram Moolenaar45a15082020-05-25 00:28:33 +02009937 && ufunc->uf_dfunc_idx == def_functions.ga_len - 1)
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02009938 {
Bram Moolenaar20431c92020-03-20 18:39:46 +01009939 --def_functions.ga_len;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02009940 ufunc->uf_dfunc_idx = 0;
9941 }
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02009942 ufunc->uf_def_status = UF_COMPILE_ERROR;
Bram Moolenaar20431c92020-03-20 18:39:46 +01009943
Bram Moolenaar3cca2992020-04-02 22:57:36 +02009944 while (cctx.ctx_scope != NULL)
9945 drop_scope(&cctx);
9946
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009947 if (errormsg != NULL)
9948 emsg(errormsg);
Bram Moolenaard66960b2020-10-30 20:46:26 +01009949 else if (did_emsg == did_emsg_before)
Bram Moolenaare13bdec2020-10-16 23:16:47 +02009950 emsg(_(e_compiling_def_function_failed));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009951 }
9952
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009953 if (cctx.ctx_redir_lhs.lhs_name != NULL)
9954 {
9955 if (ret == OK)
9956 {
9957 emsg(_(e_missing_redir_end));
9958 ret = FAIL;
9959 }
9960 vim_free(cctx.ctx_redir_lhs.lhs_name);
Bram Moolenaar753bcf82021-04-21 14:24:24 +02009961 vim_free(cctx.ctx_redir_lhs.lhs_whole);
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02009962 }
9963
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009964 current_sctx = save_current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02009965 estack_compiling = save_estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02009966 cmdmod.cmod_flags = save_cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02009967 if (do_estack_push)
9968 estack_pop();
9969
Bram Moolenaarf62d7392021-04-14 12:40:00 +02009970 vim_free(line_to_free);
Bram Moolenaar20431c92020-03-20 18:39:46 +01009971 free_imported(&cctx);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02009972 free_locals(&cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009973 ga_clear(&cctx.ctx_type_stack);
Bram Moolenaar822ba242020-05-24 23:00:18 +02009974 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009975}
9976
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02009977 void
9978set_function_type(ufunc_T *ufunc)
9979{
9980 int varargs = ufunc->uf_va_name != NULL;
9981 int argcount = ufunc->uf_args.ga_len;
9982
9983 // Create a type for the function, with the return type and any
9984 // argument types.
9985 // A vararg is included in uf_args.ga_len but not in uf_arg_types.
9986 // The type is included in "tt_args".
9987 if (argcount > 0 || varargs)
9988 {
Bram Moolenaar18062fc2021-03-05 21:35:47 +01009989 if (ufunc->uf_type_list.ga_itemsize == 0)
9990 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02009991 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
9992 argcount, &ufunc->uf_type_list);
9993 // Add argument types to the function type.
9994 if (func_type_add_arg_types(ufunc->uf_func_type,
9995 argcount + varargs,
9996 &ufunc->uf_type_list) == FAIL)
9997 return;
9998 ufunc->uf_func_type->tt_argcount = argcount + varargs;
9999 ufunc->uf_func_type->tt_min_argcount =
10000 argcount - ufunc->uf_def_args.ga_len;
10001 if (ufunc->uf_arg_types == NULL)
10002 {
10003 int i;
10004
10005 // lambda does not have argument types.
10006 for (i = 0; i < argcount; ++i)
10007 ufunc->uf_func_type->tt_args[i] = &t_any;
10008 }
10009 else
10010 mch_memmove(ufunc->uf_func_type->tt_args,
10011 ufunc->uf_arg_types, sizeof(type_T *) * argcount);
10012 if (varargs)
10013 {
10014 ufunc->uf_func_type->tt_args[argcount] =
Bram Moolenaar2a389082021-04-09 20:24:31 +020010015 ufunc->uf_va_type == NULL ? &t_list_any : ufunc->uf_va_type;
Bram Moolenaar6ff71d82020-05-24 23:45:24 +020010016 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
10017 }
10018 }
10019 else
10020 // No arguments, can use a predefined type.
10021 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
10022 argcount, &ufunc->uf_type_list);
10023}
10024
10025
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010026/*
10027 * Delete an instruction, free what it contains.
10028 */
Bram Moolenaar20431c92020-03-20 18:39:46 +010010029 void
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010030delete_instr(isn_T *isn)
10031{
10032 switch (isn->isn_type)
10033 {
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010034 case ISN_DEF:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010035 case ISN_EXEC:
Bram Moolenaar20677332021-06-06 17:02:53 +020010036 case ISN_EXEC_SPLIT:
Bram Moolenaar3b1373b2021-05-17 00:01:42 +020010037 case ISN_LEGACY_EVAL:
Bram Moolenaar03290b82020-12-19 16:30:44 +010010038 case ISN_LOADAUTO:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010039 case ISN_LOADB:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010040 case ISN_LOADENV:
10041 case ISN_LOADG:
10042 case ISN_LOADOPT:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010043 case ISN_LOADT:
10044 case ISN_LOADW:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010045 case ISN_PUSHEXC:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010046 case ISN_PUSHFUNC:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010047 case ISN_PUSHS:
Bram Moolenaar08597872020-12-10 19:43:40 +010010048 case ISN_RANGE:
Bram Moolenaar03290b82020-12-19 16:30:44 +010010049 case ISN_STOREAUTO:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010050 case ISN_STOREB:
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010010051 case ISN_STOREENV:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010052 case ISN_STOREG:
Bram Moolenaard3aac292020-04-19 14:32:17 +020010053 case ISN_STORET:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +010010054 case ISN_STOREW:
10055 case ISN_STRINGMEMBER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010056 vim_free(isn->isn_arg.string);
10057 break;
10058
Bram Moolenaar4c137212021-04-19 16:48:48 +020010059 case ISN_SUBSTITUTE:
Bram Moolenaar4f2df372021-04-19 21:06:31 +020010060 {
10061 int idx;
10062 isn_T *list = isn->isn_arg.subs.subs_instr;
10063
10064 vim_free(isn->isn_arg.subs.subs_cmd);
10065 for (idx = 0; list[idx].isn_type != ISN_FINISH; ++idx)
10066 delete_instr(list + idx);
10067 vim_free(list);
10068 }
Bram Moolenaar4c137212021-04-19 16:48:48 +020010069 break;
10070
Bram Moolenaarf18332f2021-05-07 17:55:55 +020010071 case ISN_INSTR:
10072 {
10073 int idx;
10074 isn_T *list = isn->isn_arg.instr;
10075
10076 for (idx = 0; list[idx].isn_type != ISN_FINISH; ++idx)
10077 delete_instr(list + idx);
10078 vim_free(list);
10079 }
10080 break;
10081
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010082 case ISN_LOADS:
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010010083 case ISN_STORES:
10084 vim_free(isn->isn_arg.loadstore.ls_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010085 break;
10086
Bram Moolenaard72c1bf2020-04-19 16:28:59 +020010087 case ISN_UNLET:
Bram Moolenaar7bdaea62020-04-19 18:27:26 +020010088 case ISN_UNLETENV:
Bram Moolenaard72c1bf2020-04-19 16:28:59 +020010089 vim_free(isn->isn_arg.unlet.ul_name);
10090 break;
10091
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010092 case ISN_STOREOPT:
10093 vim_free(isn->isn_arg.storeopt.so_name);
10094 break;
10095
10096 case ISN_PUSHBLOB: // push blob isn_arg.blob
10097 blob_unref(isn->isn_arg.blob);
10098 break;
10099
Bram Moolenaar42a480b2020-02-29 23:23:47 +010010100 case ISN_PUSHJOB:
Bram Moolenaarf4f190d2020-03-01 13:01:16 +010010101#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar42a480b2020-02-29 23:23:47 +010010102 job_unref(isn->isn_arg.job);
Bram Moolenaarf4f190d2020-03-01 13:01:16 +010010103#endif
Bram Moolenaar42a480b2020-02-29 23:23:47 +010010104 break;
10105
10106 case ISN_PUSHCHANNEL:
Bram Moolenaarf4f190d2020-03-01 13:01:16 +010010107#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar42a480b2020-02-29 23:23:47 +010010108 channel_unref(isn->isn_arg.channel);
Bram Moolenaarf4f190d2020-03-01 13:01:16 +010010109#endif
Bram Moolenaar42a480b2020-02-29 23:23:47 +010010110 break;
10111
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010112 case ISN_UCALL:
10113 vim_free(isn->isn_arg.ufunc.cuf_name);
10114 break;
10115
Bram Moolenaar221fcc72020-05-05 19:46:20 +020010116 case ISN_FUNCREF:
10117 {
10118 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
10119 + isn->isn_arg.funcref.fr_func;
Bram Moolenaar077a4232020-12-22 18:33:27 +010010120 ufunc_T *ufunc = dfunc->df_ufunc;
Bram Moolenaara05e5242020-09-19 18:19:19 +020010121
Bram Moolenaar077a4232020-12-22 18:33:27 +010010122 if (ufunc != NULL && func_name_refcount(ufunc->uf_name))
10123 func_ptr_unref(ufunc);
Bram Moolenaara05e5242020-09-19 18:19:19 +020010124 }
10125 break;
10126
10127 case ISN_DCALL:
10128 {
10129 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
10130 + isn->isn_arg.dfunc.cdf_idx;
10131
Bram Moolenaar148ce7a2020-09-23 21:57:23 +020010132 if (dfunc->df_ufunc != NULL
10133 && func_name_refcount(dfunc->df_ufunc->uf_name))
Bram Moolenaara05e5242020-09-19 18:19:19 +020010134 func_ptr_unref(dfunc->df_ufunc);
Bram Moolenaar221fcc72020-05-05 19:46:20 +020010135 }
10136 break;
10137
Bram Moolenaar38ddf332020-07-31 22:05:04 +020010138 case ISN_NEWFUNC:
Bram Moolenaarce658352020-07-31 23:47:12 +020010139 {
10140 char_u *lambda = isn->isn_arg.newfunc.nf_lambda;
10141 ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL);
10142
10143 if (ufunc != NULL)
10144 {
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010145 unlink_def_function(ufunc);
Bram Moolenaarce658352020-07-31 23:47:12 +020010146 func_ptr_unref(ufunc);
10147 }
10148
10149 vim_free(lambda);
10150 vim_free(isn->isn_arg.newfunc.nf_global);
10151 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +020010152 break;
10153
Bram Moolenaar5e654232020-09-16 15:22:00 +020010154 case ISN_CHECKTYPE:
Bram Moolenaaraa210a32021-01-02 15:41:03 +010010155 case ISN_SETTYPE:
Bram Moolenaar5e654232020-09-16 15:22:00 +020010156 free_type(isn->isn_arg.type.ct_type);
10157 break;
10158
Bram Moolenaar02194d22020-10-24 23:08:38 +020010159 case ISN_CMDMOD:
10160 vim_regfree(isn->isn_arg.cmdmod.cf_cmdmod
10161 ->cmod_filter_regmatch.regprog);
10162 vim_free(isn->isn_arg.cmdmod.cf_cmdmod);
10163 break;
10164
Bram Moolenaar4aab88d2020-12-24 21:56:41 +010010165 case ISN_LOADSCRIPT:
10166 case ISN_STORESCRIPT:
10167 vim_free(isn->isn_arg.script.scriptref);
10168 break;
10169
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +010010170 case ISN_TRY:
10171 vim_free(isn->isn_arg.try.try_ref);
10172 break;
10173
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +020010174 case ISN_CEXPR_CORE:
Bram Moolenaardc3e2e62021-05-05 22:40:56 +020010175 vim_free(isn->isn_arg.cexpr.cexpr_ref->cer_cmdline);
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +020010176 vim_free(isn->isn_arg.cexpr.cexpr_ref);
10177 break;
10178
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010179 case ISN_2BOOL:
10180 case ISN_2STRING:
Bram Moolenaar418f1df2020-08-12 21:34:49 +020010181 case ISN_2STRING_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010182 case ISN_ADDBLOB:
10183 case ISN_ADDLIST:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010184 case ISN_ANYINDEX:
10185 case ISN_ANYSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010186 case ISN_BCALL:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +020010187 case ISN_BLOBAPPEND:
Bram Moolenaarcfc30232021-04-11 20:26:34 +020010188 case ISN_BLOBINDEX:
10189 case ISN_BLOBSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010190 case ISN_CATCH:
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +020010191 case ISN_CEXPR_AUCMD:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010192 case ISN_CHECKLEN:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010193 case ISN_CHECKNR:
Bram Moolenaar02194d22020-10-24 23:08:38 +020010194 case ISN_CMDMOD_REV:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010195 case ISN_COMPAREANY:
10196 case ISN_COMPAREBLOB:
10197 case ISN_COMPAREBOOL:
10198 case ISN_COMPAREDICT:
10199 case ISN_COMPAREFLOAT:
10200 case ISN_COMPAREFUNC:
10201 case ISN_COMPARELIST:
10202 case ISN_COMPARENR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010203 case ISN_COMPARESPECIAL:
10204 case ISN_COMPARESTRING:
10205 case ISN_CONCAT:
Bram Moolenaar2bb26582020-10-03 22:52:39 +020010206 case ISN_COND2BOOL:
Bram Moolenaare99d4222021-06-13 14:01:26 +020010207 case ISN_DEBUG:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010208 case ISN_DROP:
10209 case ISN_ECHO:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020010210 case ISN_ECHOERR:
Bram Moolenaarcfe435d2020-04-25 20:02:55 +020010211 case ISN_ECHOMSG:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010212 case ISN_ENDTRY:
Bram Moolenaarcfe435d2020-04-25 20:02:55 +020010213 case ISN_EXECCONCAT:
10214 case ISN_EXECUTE:
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +010010215 case ISN_FINALLY:
Bram Moolenaare99d4222021-06-13 14:01:26 +020010216 case ISN_FINISH:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010217 case ISN_FOR:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010218 case ISN_GETITEM:
10219 case ISN_JUMP:
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +020010220 case ISN_JUMP_IF_ARG_SET:
Bram Moolenaar1dcae592020-10-19 19:02:42 +020010221 case ISN_LISTAPPEND:
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +020010222 case ISN_LISTINDEX:
Bram Moolenaared591872020-08-15 22:14:53 +020010223 case ISN_LISTSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010224 case ISN_LOAD:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +020010225 case ISN_LOADBDICT:
10226 case ISN_LOADGDICT:
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020010227 case ISN_LOADOUTER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010228 case ISN_LOADREG:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +020010229 case ISN_LOADTDICT:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010230 case ISN_LOADV:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +020010231 case ISN_LOADWDICT:
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +020010232 case ISN_LOCKCONST:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010233 case ISN_MEMBER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010234 case ISN_NEGATENR:
10235 case ISN_NEWDICT:
10236 case ISN_NEWLIST:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010237 case ISN_OPANY:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010238 case ISN_OPFLOAT:
10239 case ISN_OPNR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010240 case ISN_PCALL:
Bram Moolenaarbd5da372020-03-31 23:13:10 +020010241 case ISN_PCALL_END:
Bram Moolenaarb2049902021-01-24 12:53:53 +010010242 case ISN_PROF_END:
10243 case ISN_PROF_START:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010244 case ISN_PUSHBOOL:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010245 case ISN_PUSHF:
10246 case ISN_PUSHNR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010247 case ISN_PUSHSPEC:
Bram Moolenaarc3516f72020-09-08 22:45:35 +020010248 case ISN_PUT:
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +020010249 case ISN_REDIREND:
10250 case ISN_REDIRSTART:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010251 case ISN_RETURN:
Bram Moolenaarf57b43c2021-06-15 22:13:27 +020010252 case ISN_RETURN_VOID:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010253 case ISN_SHUFFLE:
10254 case ISN_SLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010255 case ISN_STORE:
Bram Moolenaar4f5e3972020-12-21 17:30:50 +010010256 case ISN_STOREINDEX:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010257 case ISN_STORENR:
10258 case ISN_STOREOUTER:
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +020010259 case ISN_STORERANGE:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010260 case ISN_STOREREG:
Bram Moolenaarcc673e72020-08-16 17:33:35 +020010261 case ISN_STOREV:
10262 case ISN_STRINDEX:
10263 case ISN_STRSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010264 case ISN_THROW:
Bram Moolenaarc150c092021-02-13 15:02:46 +010010265 case ISN_TRYCONT:
Bram Moolenaar752fc692021-01-04 21:57:11 +010010266 case ISN_UNLETINDEX:
Bram Moolenaar5b5ae292021-02-20 17:04:02 +010010267 case ISN_UNLETRANGE:
Bram Moolenaar792f7862020-11-23 08:31:18 +010010268 case ISN_UNPACK:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010269 // nothing allocated
10270 break;
10271 }
10272}
10273
10274/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010275 * Free all instructions for "dfunc" except df_name.
Bram Moolenaar20431c92020-03-20 18:39:46 +010010276 */
10277 static void
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010010278delete_def_function_contents(dfunc_T *dfunc, int mark_deleted)
Bram Moolenaar20431c92020-03-20 18:39:46 +010010279{
10280 int idx;
10281
10282 ga_clear(&dfunc->df_def_args_isn);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +020010283 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +010010284
10285 if (dfunc->df_instr != NULL)
10286 {
10287 for (idx = 0; idx < dfunc->df_instr_count; ++idx)
10288 delete_instr(dfunc->df_instr + idx);
10289 VIM_CLEAR(dfunc->df_instr);
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010010290 dfunc->df_instr = NULL;
Bram Moolenaar20431c92020-03-20 18:39:46 +010010291 }
Bram Moolenaarc2dec4c2021-06-13 15:39:00 +020010292 if (dfunc->df_instr_debug != NULL)
10293 {
10294 for (idx = 0; idx < dfunc->df_instr_debug_count; ++idx)
10295 delete_instr(dfunc->df_instr_debug + idx);
10296 VIM_CLEAR(dfunc->df_instr_debug);
10297 dfunc->df_instr_debug = NULL;
10298 }
Bram Moolenaarc05fe072021-01-24 21:30:48 +010010299#ifdef FEAT_PROFILE
10300 if (dfunc->df_instr_prof != NULL)
10301 {
10302 for (idx = 0; idx < dfunc->df_instr_prof_count; ++idx)
10303 delete_instr(dfunc->df_instr_prof + idx);
10304 VIM_CLEAR(dfunc->df_instr_prof);
10305 dfunc->df_instr_prof = NULL;
10306 }
10307#endif
Bram Moolenaar20431c92020-03-20 18:39:46 +010010308
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010010309 if (mark_deleted)
10310 dfunc->df_deleted = TRUE;
10311 if (dfunc->df_ufunc != NULL)
10312 dfunc->df_ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaar20431c92020-03-20 18:39:46 +010010313}
10314
10315/*
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +020010316 * When a user function is deleted, clear the contents of any associated def
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010317 * function, unless another user function still uses it.
10318 * The position in def_functions can be re-used.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010319 */
10320 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010321unlink_def_function(ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010322{
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +020010323 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010324 {
10325 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
10326 + ufunc->uf_dfunc_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010327
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010328 if (--dfunc->df_refcount <= 0)
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010010329 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +020010330 ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010331 ufunc->uf_dfunc_idx = 0;
10332 if (dfunc->df_ufunc == ufunc)
10333 dfunc->df_ufunc = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010334 }
10335}
10336
Bram Moolenaarfdeab652020-09-19 15:16:50 +020010337/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010338 * Used when a user function refers to an existing dfunc.
Bram Moolenaarfdeab652020-09-19 15:16:50 +020010339 */
10340 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010341link_def_function(ufunc_T *ufunc)
Bram Moolenaarfdeab652020-09-19 15:16:50 +020010342{
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010343 if (ufunc->uf_dfunc_idx > 0)
10344 {
10345 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
10346 + ufunc->uf_dfunc_idx;
Bram Moolenaarfdeab652020-09-19 15:16:50 +020010347
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010348 ++dfunc->df_refcount;
10349 }
Bram Moolenaarfdeab652020-09-19 15:16:50 +020010350}
10351
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010352#if defined(EXITFREE) || defined(PROTO)
Bram Moolenaar20431c92020-03-20 18:39:46 +010010353/*
10354 * Free all functions defined with ":def".
10355 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010356 void
10357free_def_functions(void)
10358{
Bram Moolenaar20431c92020-03-20 18:39:46 +010010359 int idx;
10360
10361 for (idx = 0; idx < def_functions.ga_len; ++idx)
10362 {
10363 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx;
10364
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010010365 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +010010366 vim_free(dfunc->df_name);
Bram Moolenaar20431c92020-03-20 18:39:46 +010010367 }
10368
10369 ga_clear(&def_functions);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010010370}
10371#endif
10372
10373
10374#endif // FEAT_EVAL