blob: 94f30d4395dcb183727cc59d8c8cdf30f916d18e [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;
47 int is_had_return; // every block ends in :return
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010048 int is_if_label; // instruction idx at IF or ELSEIF
49 endlabel_T *is_end_label; // instructions to set end label
50} ifscope_T;
51
52/*
53 * info specific for the scope of :while
54 */
55typedef struct {
56 int ws_top_label; // instruction idx at WHILE
57 endlabel_T *ws_end_label; // instructions to set end
58} whilescope_T;
59
60/*
61 * info specific for the scope of :for
62 */
63typedef struct {
64 int fs_top_label; // instruction idx at FOR
65 endlabel_T *fs_end_label; // break instructions
66} forscope_T;
67
68/*
69 * info specific for the scope of :try
70 */
71typedef struct {
72 int ts_try_label; // instruction idx at TRY
73 endlabel_T *ts_end_label; // jump to :finally or :endtry
74 int ts_catch_label; // instruction idx of last CATCH
75 int ts_caught_all; // "catch" without argument encountered
76} tryscope_T;
77
78typedef enum {
79 NO_SCOPE,
80 IF_SCOPE,
81 WHILE_SCOPE,
82 FOR_SCOPE,
83 TRY_SCOPE,
84 BLOCK_SCOPE
85} scopetype_T;
86
87/*
88 * Info for one scope, pointed to by "ctx_scope".
89 */
90typedef struct scope_S scope_T;
91struct scope_S {
92 scope_T *se_outer; // scope containing this one
93 scopetype_T se_type;
94 int se_local_count; // ctx_locals.ga_len before scope
Bram Moolenaarefd88552020-06-18 20:50:10 +020095 skip_T se_skip_save; // ctx_skip before the block
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010096 union {
97 ifscope_T se_if;
98 whilescope_T se_while;
99 forscope_T se_for;
100 tryscope_T se_try;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +0100101 } se_u;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100102};
103
104/*
105 * Entry for "ctx_locals". Used for arguments and local variables.
106 */
107typedef struct {
108 char_u *lv_name;
109 type_T *lv_type;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200110 int lv_idx; // index of the variable on the stack
Bram Moolenaarab360522021-01-10 14:02:28 +0100111 int lv_from_outer; // nesting level, using ctx_outer scope
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200112 int lv_const; // when TRUE cannot be assigned to
113 int lv_arg; // when TRUE this is an argument
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100114} lvar_T;
115
116/*
117 * Context for compiling lines of Vim script.
118 * Stores info about the local variables and condition stack.
119 */
120struct cctx_S {
121 ufunc_T *ctx_ufunc; // current function
122 int ctx_lnum; // line number in current function
Bram Moolenaar7a092242020-04-16 22:10:49 +0200123 char_u *ctx_line_start; // start of current line or NULL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100124 garray_T ctx_instr; // generated instructions
125
126 garray_T ctx_locals; // currently visible local variables
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200127 int ctx_locals_count; // total number of local variables
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100128
Bram Moolenaar148ce7a2020-09-23 21:57:23 +0200129 int ctx_has_closure; // set to one if a closures was created in
130 // the function
Bram Moolenaarbf67ea12020-05-02 17:52:42 +0200131
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100132 garray_T ctx_imports; // imported items
133
Bram Moolenaar9b68c822020-06-18 19:31:08 +0200134 skip_T ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100135 scope_T *ctx_scope; // current scope, NULL at toplevel
Bram Moolenaarefd88552020-06-18 20:50:10 +0200136 int ctx_had_return; // last seen statement was "return"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100137
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200138 cctx_T *ctx_outer; // outer scope for lambda or nested
139 // function
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200140 int ctx_outer_used; // var in ctx_outer was used
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200141
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100142 garray_T ctx_type_stack; // type of each item on the stack
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200143 garray_T *ctx_type_list; // list of pointers to allocated types
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +0200144
Bram Moolenaar02194d22020-10-24 23:08:38 +0200145 int ctx_has_cmdmod; // ISN_CMDMOD was generated
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100146};
147
Bram Moolenaarcdc40c42020-12-26 17:43:08 +0100148static void delete_def_function_contents(dfunc_T *dfunc, int mark_deleted);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100149
150/*
Bram Moolenaar709664c2020-12-12 14:33:41 +0100151 * Lookup variable "name" in the local scope and return it in "lvar".
Bram Moolenaarab360522021-01-10 14:02:28 +0100152 * "lvar->lv_from_outer" is incremented accordingly.
Bram Moolenaar709664c2020-12-12 14:33:41 +0100153 * If "lvar" is NULL only check if the variable can be found.
154 * Return FAIL if not found.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100155 */
Bram Moolenaar709664c2020-12-12 14:33:41 +0100156 static int
157lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100158{
159 int idx;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100160 lvar_T *lvp;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100161
Bram Moolenaarae8d2de2020-02-13 21:42:24 +0100162 if (len == 0)
Bram Moolenaar709664c2020-12-12 14:33:41 +0100163 return FAIL;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200164
165 // Find local in current function scope.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100166 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
167 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100168 lvp = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
169 if (STRNCMP(name, lvp->lv_name, len) == 0
170 && STRLEN(lvp->lv_name) == len)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200171 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100172 if (lvar != NULL)
173 {
174 *lvar = *lvp;
Bram Moolenaarab360522021-01-10 14:02:28 +0100175 lvar->lv_from_outer = 0;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100176 }
177 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200178 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100179 }
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200180
181 // Find local in outer function scope.
182 if (cctx->ctx_outer != NULL)
183 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100184 if (lookup_local(name, len, lvar, cctx->ctx_outer) == OK)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200185 {
Bram Moolenaar709664c2020-12-12 14:33:41 +0100186 if (lvar != NULL)
187 {
188 cctx->ctx_outer_used = TRUE;
Bram Moolenaarab360522021-01-10 14:02:28 +0100189 ++lvar->lv_from_outer;
Bram Moolenaar709664c2020-12-12 14:33:41 +0100190 }
191 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200192 }
193 }
194
Bram Moolenaar709664c2020-12-12 14:33:41 +0100195 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100196}
197
198/*
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200199 * Lookup an argument in the current function and an enclosing function.
200 * Returns the argument index in "idxp"
201 * Returns the argument type in "type"
202 * Sets "gen_load_outer" to TRUE if found in outer scope.
203 * Returns OK when found, FAIL otherwise.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100204 */
205 static int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200206arg_exists(
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200207 char_u *name,
208 size_t len,
209 int *idxp,
210 type_T **type,
211 int *gen_load_outer,
212 cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100213{
214 int idx;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200215 char_u *va_name;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100216
Bram Moolenaarae8d2de2020-02-13 21:42:24 +0100217 if (len == 0)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200218 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100219 for (idx = 0; idx < cctx->ctx_ufunc->uf_args.ga_len; ++idx)
220 {
221 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx);
222
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200223 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL)
224 {
225 if (idxp != NULL)
226 {
227 // Arguments are located above the frame pointer. One further
228 // if there is a vararg argument
229 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len
230 + STACK_FRAME_SIZE)
231 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0);
232
233 if (cctx->ctx_ufunc->uf_arg_types != NULL)
234 *type = cctx->ctx_ufunc->uf_arg_types[idx];
235 else
236 *type = &t_any;
237 }
238 return OK;
239 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100240 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100241
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200242 va_name = cctx->ctx_ufunc->uf_va_name;
243 if (va_name != NULL
244 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL)
245 {
246 if (idxp != NULL)
247 {
248 // varargs is always the last argument
249 *idxp = -STACK_FRAME_SIZE - 1;
250 *type = cctx->ctx_ufunc->uf_va_type;
251 }
252 return OK;
253 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100254
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200255 if (cctx->ctx_outer != NULL)
256 {
257 // Lookup the name for an argument of the outer function.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200258 if (arg_exists(name, len, idxp, type, gen_load_outer, cctx->ctx_outer)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200259 == OK)
260 {
Bram Moolenaarab360522021-01-10 14:02:28 +0100261 ++*gen_load_outer;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200262 return OK;
263 }
264 }
265
266 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100267}
268
269/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200270 * Lookup a script-local variable in the current script, possibly defined in a
271 * block that contains the function "cctx->ctx_ufunc".
272 * "cctx" is NULL at the script level.
273 * if "len" is <= 0 "name" must be NUL terminated.
274 * Return NULL when not found.
275 */
276 static sallvar_T *
277find_script_var(char_u *name, size_t len, cctx_T *cctx)
278{
279 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
280 hashitem_T *hi;
281 int cc;
282 sallvar_T *sav;
283 ufunc_T *ufunc;
284
285 // Find the list of all script variables with the right name.
286 if (len > 0)
287 {
288 cc = name[len];
289 name[len] = NUL;
290 }
291 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
292 if (len > 0)
293 name[len] = cc;
294 if (HASHITEM_EMPTY(hi))
295 return NULL;
296
297 sav = HI2SAV(hi);
298 if (sav->sav_block_id == 0 || cctx == NULL)
299 // variable defined in the script scope or not in a function.
300 return sav;
301
302 // Go over the variables with this name and find one that was visible
303 // from the function.
304 ufunc = cctx->ctx_ufunc;
305 while (sav != NULL)
306 {
307 int idx;
308
309 // Go over the blocks that this function was defined in. If the
310 // variable block ID matches it was visible to the function.
311 for (idx = 0; idx < ufunc->uf_block_depth; ++idx)
312 if (ufunc->uf_block_ids[idx] == sav->sav_block_id)
313 return sav;
314 sav = sav->sav_next;
315 }
316
317 return NULL;
318}
319
320/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +0100321 * Return TRUE if the script context is Vim9 script.
Bram Moolenaar84367732020-08-23 15:21:55 +0200322 */
323 static int
324script_is_vim9()
325{
326 return SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9;
327}
328
329/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200330 * Lookup a variable (without s: prefix) in the current script.
Bram Moolenaar53900992020-08-22 19:02:02 +0200331 * If "vim9script" is TRUE the script must be Vim9 script. Used for "var"
332 * without "s:".
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200333 * "cctx" is NULL at the script level.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100334 * Returns OK or FAIL.
335 */
336 static int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200337script_var_exists(char_u *name, size_t len, int vim9script, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100338{
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200339 int is_vim9_script;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100340
Bram Moolenaar9c4f5522020-09-25 21:47:28 +0200341 if (current_sctx.sc_sid <= 0)
342 return FAIL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200343 is_vim9_script = script_is_vim9();
344 if (vim9script && !is_vim9_script)
Bram Moolenaar53900992020-08-22 19:02:02 +0200345 return FAIL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200346 if (is_vim9_script)
347 {
348 // Check script variables that were visible where the function was
349 // defined.
350 if (find_script_var(name, len, cctx) != NULL)
351 return OK;
352 }
353 else
354 {
355 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
356 dictitem_T *di;
357 int cc;
358
359 // Check script variables that are currently visible
360 cc = name[len];
361 name[len] = NUL;
362 di = find_var_in_ht(ht, 0, name, TRUE);
363 name[len] = cc;
364 if (di != NULL)
365 return OK;
366 }
367
368 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100369}
370
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100371/*
372 * Check if "p[len]" is already defined, either in script "import_sid" or in
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200373 * compilation context "cctx". "cctx" is NULL at the script level.
Bram Moolenaar0f769812020-09-12 18:32:34 +0200374 * Does not check the global namespace.
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100375 * Return FAIL and give an error if it defined.
376 */
377 int
Bram Moolenaarcbb6bdc2020-07-06 21:53:17 +0200378check_defined(char_u *p, size_t len, cctx_T *cctx)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100379{
Bram Moolenaar0f769812020-09-12 18:32:34 +0200380 int c = p[len];
381 ufunc_T *ufunc = NULL;
Bram Moolenaarad486a02020-08-01 23:22:18 +0200382
383 p[len] = NUL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200384 if (script_var_exists(p, len, FALSE, cctx) == OK
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100385 || (cctx != NULL
Bram Moolenaar709664c2020-12-12 14:33:41 +0100386 && (lookup_local(p, len, NULL, cctx) == OK
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200387 || arg_exists(p, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaarad486a02020-08-01 23:22:18 +0200388 || find_imported(p, len, cctx) != NULL
Bram Moolenaar0f769812020-09-12 18:32:34 +0200389 || (ufunc = find_func_even_dead(p, FALSE, cctx)) != NULL)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100390 {
Bram Moolenaar0f769812020-09-12 18:32:34 +0200391 // A local or script-local function can shadow a global function.
392 if (ufunc == NULL || !func_is_global(ufunc)
393 || (p[0] == 'g' && p[1] == ':'))
394 {
395 p[len] = c;
396 semsg(_(e_name_already_defined_str), p);
397 return FAIL;
398 }
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100399 }
Bram Moolenaarad486a02020-08-01 23:22:18 +0200400 p[len] = c;
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100401 return OK;
402}
403
Bram Moolenaar65b95452020-07-19 14:03:09 +0200404
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100405/////////////////////////////////////////////////////////////////////
406// Following generate_ functions expect the caller to call ga_grow().
407
Bram Moolenaar9b68c822020-06-18 19:31:08 +0200408#define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return NULL
409#define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return OK
Bram Moolenaar080457c2020-03-03 21:53:32 +0100410
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100411/*
412 * Generate an instruction without arguments.
413 * Returns a pointer to the new instruction, NULL if failed.
414 */
415 static isn_T *
416generate_instr(cctx_T *cctx, isntype_T isn_type)
417{
418 garray_T *instr = &cctx->ctx_instr;
419 isn_T *isn;
420
Bram Moolenaar080457c2020-03-03 21:53:32 +0100421 RETURN_NULL_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100422 if (ga_grow(instr, 1) == FAIL)
423 return NULL;
424 isn = ((isn_T *)instr->ga_data) + instr->ga_len;
425 isn->isn_type = isn_type;
426 isn->isn_lnum = cctx->ctx_lnum + 1;
427 ++instr->ga_len;
428
429 return isn;
430}
431
432/*
433 * Generate an instruction without arguments.
434 * "drop" will be removed from the stack.
435 * Returns a pointer to the new instruction, NULL if failed.
436 */
437 static isn_T *
438generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop)
439{
440 garray_T *stack = &cctx->ctx_type_stack;
441
Bram Moolenaar080457c2020-03-03 21:53:32 +0100442 RETURN_NULL_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100443 stack->ga_len -= drop;
444 return generate_instr(cctx, isn_type);
445}
446
447/*
448 * Generate instruction "isn_type" and put "type" on the type stack.
449 */
450 static isn_T *
451generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type)
452{
453 isn_T *isn;
454 garray_T *stack = &cctx->ctx_type_stack;
455
456 if ((isn = generate_instr(cctx, isn_type)) == NULL)
457 return NULL;
458
459 if (ga_grow(stack, 1) == FAIL)
460 return NULL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200461 ((type_T **)stack->ga_data)[stack->ga_len] = type == NULL ? &t_any : type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100462 ++stack->ga_len;
463
464 return isn;
465}
466
467/*
468 * If type at "offset" isn't already VAR_STRING then generate ISN_2STRING.
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200469 * But only for simple types.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100470 */
471 static int
472may_generate_2STRING(int offset, cctx_T *cctx)
473{
474 isn_T *isn;
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200475 isntype_T isntype = ISN_2STRING;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100476 garray_T *stack = &cctx->ctx_type_stack;
477 type_T **type = ((type_T **)stack->ga_data) + stack->ga_len + offset;
478
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200479 switch ((*type)->tt_type)
480 {
481 // nothing to be done
482 case VAR_STRING: return OK;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100483
Bram Moolenaar418f1df2020-08-12 21:34:49 +0200484 // conversion possible
485 case VAR_SPECIAL:
486 case VAR_BOOL:
487 case VAR_NUMBER:
488 case VAR_FLOAT:
489 break;
490
491 // conversion possible (with runtime check)
492 case VAR_ANY:
493 case VAR_UNKNOWN:
494 isntype = ISN_2STRING_ANY;
495 break;
496
497 // conversion not possible
498 case VAR_VOID:
499 case VAR_BLOB:
500 case VAR_FUNC:
501 case VAR_PARTIAL:
502 case VAR_LIST:
503 case VAR_DICT:
504 case VAR_JOB:
505 case VAR_CHANNEL:
506 to_string_error((*type)->tt_type);
507 return FAIL;
508 }
509
510 *type = &t_string;
511 if ((isn = generate_instr(cctx, isntype)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100512 return FAIL;
513 isn->isn_arg.number = offset;
514
515 return OK;
516}
517
518 static int
519check_number_or_float(vartype_T type1, vartype_T type2, char_u *op)
520{
Bram Moolenaar4c683752020-04-05 21:38:23 +0200521 if (!((type1 == VAR_NUMBER || type1 == VAR_FLOAT || type1 == VAR_ANY)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100522 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT
Bram Moolenaar4c683752020-04-05 21:38:23 +0200523 || type2 == VAR_ANY)))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100524 {
525 if (*op == '+')
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200526 emsg(_(e_wrong_argument_type_for_plus));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100527 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200528 semsg(_(e_char_requires_number_or_float_arguments), *op);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100529 return FAIL;
530 }
531 return OK;
532}
533
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200534 static int
535generate_add_instr(
536 cctx_T *cctx,
537 vartype_T vartype,
538 type_T *type1,
539 type_T *type2)
540{
Bram Moolenaar399ea812020-12-15 21:28:57 +0100541 garray_T *stack = &cctx->ctx_type_stack;
542 isn_T *isn = generate_instr_drop(cctx,
543 vartype == VAR_NUMBER ? ISN_OPNR
544 : vartype == VAR_LIST ? ISN_ADDLIST
545 : vartype == VAR_BLOB ? ISN_ADDBLOB
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200546#ifdef FEAT_FLOAT
Bram Moolenaar399ea812020-12-15 21:28:57 +0100547 : vartype == VAR_FLOAT ? ISN_OPFLOAT
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200548#endif
Bram Moolenaar399ea812020-12-15 21:28:57 +0100549 : ISN_OPANY, 1);
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200550
551 if (vartype != VAR_LIST && vartype != VAR_BLOB
552 && type1->tt_type != VAR_ANY
553 && type2->tt_type != VAR_ANY
554 && check_number_or_float(
555 type1->tt_type, type2->tt_type, (char_u *)"+") == FAIL)
556 return FAIL;
557
558 if (isn != NULL)
559 isn->isn_arg.op.op_type = EXPR_ADD;
Bram Moolenaar399ea812020-12-15 21:28:57 +0100560
561 // When concatenating two lists with different member types the member type
562 // becomes "any".
563 if (vartype == VAR_LIST
564 && type1->tt_type == VAR_LIST && type2->tt_type == VAR_LIST
565 && type1->tt_member != type2->tt_member)
566 (((type_T **)stack->ga_data)[stack->ga_len - 1]) = &t_list_any;
567
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200568 return isn == NULL ? FAIL : OK;
569}
570
571/*
572 * Get the type to use for an instruction for an operation on "type1" and
573 * "type2". If they are matching use a type-specific instruction. Otherwise
574 * fall back to runtime type checking.
575 */
576 static vartype_T
577operator_type(type_T *type1, type_T *type2)
578{
579 if (type1->tt_type == type2->tt_type
580 && (type1->tt_type == VAR_NUMBER
581 || type1->tt_type == VAR_LIST
582#ifdef FEAT_FLOAT
583 || type1->tt_type == VAR_FLOAT
584#endif
585 || type1->tt_type == VAR_BLOB))
586 return type1->tt_type;
587 return VAR_ANY;
588}
589
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100590/*
591 * Generate an instruction with two arguments. The instruction depends on the
592 * type of the arguments.
593 */
594 static int
595generate_two_op(cctx_T *cctx, char_u *op)
596{
597 garray_T *stack = &cctx->ctx_type_stack;
598 type_T *type1;
599 type_T *type2;
600 vartype_T vartype;
601 isn_T *isn;
602
Bram Moolenaar080457c2020-03-03 21:53:32 +0100603 RETURN_OK_IF_SKIP(cctx);
604
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200605 // Get the known type of the two items on the stack.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100606 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2];
607 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200608 vartype = operator_type(type1, type2);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100609
610 switch (*op)
611 {
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200612 case '+':
613 if (generate_add_instr(cctx, vartype, type1, type2) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100614 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100615 break;
616
617 case '-':
618 case '*':
619 case '/': if (check_number_or_float(type1->tt_type, type2->tt_type,
620 op) == FAIL)
621 return FAIL;
622 if (vartype == VAR_NUMBER)
623 isn = generate_instr_drop(cctx, ISN_OPNR, 1);
624#ifdef FEAT_FLOAT
625 else if (vartype == VAR_FLOAT)
626 isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1);
627#endif
628 else
629 isn = generate_instr_drop(cctx, ISN_OPANY, 1);
630 if (isn != NULL)
631 isn->isn_arg.op.op_type = *op == '*'
632 ? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB;
633 break;
634
Bram Moolenaar4c683752020-04-05 21:38:23 +0200635 case '%': if ((type1->tt_type != VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100636 && type1->tt_type != VAR_NUMBER)
Bram Moolenaar4c683752020-04-05 21:38:23 +0200637 || (type2->tt_type != VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100638 && type2->tt_type != VAR_NUMBER))
639 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200640 emsg(_(e_percent_requires_number_arguments));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100641 return FAIL;
642 }
643 isn = generate_instr_drop(cctx,
644 vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1);
645 if (isn != NULL)
646 isn->isn_arg.op.op_type = EXPR_REM;
647 break;
648 }
649
650 // correct type of result
Bram Moolenaar4c683752020-04-05 21:38:23 +0200651 if (vartype == VAR_ANY)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100652 {
653 type_T *type = &t_any;
654
655#ifdef FEAT_FLOAT
656 // float+number and number+float results in float
657 if ((type1->tt_type == VAR_NUMBER || type1->tt_type == VAR_FLOAT)
658 && (type2->tt_type == VAR_NUMBER || type2->tt_type == VAR_FLOAT))
659 type = &t_float;
660#endif
661 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type;
662 }
663
664 return OK;
665}
666
667/*
Bram Moolenaara5565e42020-05-09 15:44:01 +0200668 * Get the instruction to use for comparing "type1" with "type2"
669 * Return ISN_DROP when failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100670 */
Bram Moolenaara5565e42020-05-09 15:44:01 +0200671 static isntype_T
Bram Moolenaar657137c2021-01-09 15:45:23 +0100672get_compare_isn(exprtype_T exprtype, vartype_T type1, vartype_T type2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100673{
674 isntype_T isntype = ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100675
Bram Moolenaar4c683752020-04-05 21:38:23 +0200676 if (type1 == VAR_UNKNOWN)
677 type1 = VAR_ANY;
678 if (type2 == VAR_UNKNOWN)
679 type2 = VAR_ANY;
680
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100681 if (type1 == type2)
682 {
683 switch (type1)
684 {
685 case VAR_BOOL: isntype = ISN_COMPAREBOOL; break;
686 case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break;
687 case VAR_NUMBER: isntype = ISN_COMPARENR; break;
688 case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break;
689 case VAR_STRING: isntype = ISN_COMPARESTRING; break;
690 case VAR_BLOB: isntype = ISN_COMPAREBLOB; break;
691 case VAR_LIST: isntype = ISN_COMPARELIST; break;
692 case VAR_DICT: isntype = ISN_COMPAREDICT; break;
693 case VAR_FUNC: isntype = ISN_COMPAREFUNC; break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100694 default: isntype = ISN_COMPAREANY; break;
695 }
696 }
Bram Moolenaar4c683752020-04-05 21:38:23 +0200697 else if (type1 == VAR_ANY || type2 == VAR_ANY
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100698 || ((type1 == VAR_NUMBER || type1 == VAR_FLOAT)
699 && (type2 == VAR_NUMBER || type2 ==VAR_FLOAT)))
700 isntype = ISN_COMPAREANY;
701
Bram Moolenaar657137c2021-01-09 15:45:23 +0100702 if ((exprtype == EXPR_IS || exprtype == EXPR_ISNOT)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100703 && (isntype == ISN_COMPAREBOOL
704 || isntype == ISN_COMPARESPECIAL
705 || isntype == ISN_COMPARENR
706 || isntype == ISN_COMPAREFLOAT))
707 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200708 semsg(_(e_cannot_use_str_with_str),
Bram Moolenaar657137c2021-01-09 15:45:23 +0100709 exprtype == EXPR_IS ? "is" : "isnot" , vartype_name(type1));
Bram Moolenaara5565e42020-05-09 15:44:01 +0200710 return ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100711 }
712 if (isntype == ISN_DROP
Bram Moolenaar657137c2021-01-09 15:45:23 +0100713 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100714 && (type1 == VAR_BOOL || type1 == VAR_SPECIAL
715 || type2 == VAR_BOOL || type2 == VAR_SPECIAL)))
Bram Moolenaar657137c2021-01-09 15:45:23 +0100716 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL
717 && exprtype != EXPR_IS && exprtype != EXPR_ISNOT
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100718 && (type1 == VAR_BLOB || type2 == VAR_BLOB
719 || type1 == VAR_LIST || type2 == VAR_LIST))))
720 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200721 semsg(_(e_cannot_compare_str_with_str),
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100722 vartype_name(type1), vartype_name(type2));
Bram Moolenaara5565e42020-05-09 15:44:01 +0200723 return ISN_DROP;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100724 }
Bram Moolenaara5565e42020-05-09 15:44:01 +0200725 return isntype;
726}
727
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200728 int
Bram Moolenaar657137c2021-01-09 15:45:23 +0100729check_compare_types(exprtype_T type, typval_T *tv1, typval_T *tv2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200730{
731 if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP)
732 return FAIL;
733 return OK;
734}
735
Bram Moolenaara5565e42020-05-09 15:44:01 +0200736/*
737 * Generate an ISN_COMPARE* instruction with a boolean result.
738 */
739 static int
Bram Moolenaar657137c2021-01-09 15:45:23 +0100740generate_COMPARE(cctx_T *cctx, exprtype_T exprtype, int ic)
Bram Moolenaara5565e42020-05-09 15:44:01 +0200741{
742 isntype_T isntype;
743 isn_T *isn;
744 garray_T *stack = &cctx->ctx_type_stack;
745 vartype_T type1;
746 vartype_T type2;
747
748 RETURN_OK_IF_SKIP(cctx);
749
750 // Get the known type of the two items on the stack. If they are matching
751 // use a type-specific instruction. Otherwise fall back to runtime type
752 // checking.
753 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type;
754 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type;
Bram Moolenaar657137c2021-01-09 15:45:23 +0100755 isntype = get_compare_isn(exprtype, type1, type2);
Bram Moolenaara5565e42020-05-09 15:44:01 +0200756 if (isntype == ISN_DROP)
757 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100758
759 if ((isn = generate_instr(cctx, isntype)) == NULL)
760 return FAIL;
Bram Moolenaar657137c2021-01-09 15:45:23 +0100761 isn->isn_arg.op.op_type = exprtype;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100762 isn->isn_arg.op.op_ic = ic;
763
764 // takes two arguments, puts one bool back
765 if (stack->ga_len >= 2)
766 {
767 --stack->ga_len;
768 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
769 }
770
771 return OK;
772}
773
774/*
775 * Generate an ISN_2BOOL instruction.
776 */
777 static int
778generate_2BOOL(cctx_T *cctx, int invert)
779{
780 isn_T *isn;
781 garray_T *stack = &cctx->ctx_type_stack;
782
Bram Moolenaar080457c2020-03-03 21:53:32 +0100783 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100784 if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL)
785 return FAIL;
786 isn->isn_arg.number = invert;
787
788 // type becomes bool
789 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
790
791 return OK;
792}
793
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200794/*
795 * Generate an ISN_COND2BOOL instruction.
796 */
797 static int
798generate_COND2BOOL(cctx_T *cctx)
799{
800 isn_T *isn;
801 garray_T *stack = &cctx->ctx_type_stack;
802
803 RETURN_OK_IF_SKIP(cctx);
804 if ((isn = generate_instr(cctx, ISN_COND2BOOL)) == NULL)
805 return FAIL;
806
807 // type becomes bool
808 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
809
810 return OK;
811}
812
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100813 static int
Bram Moolenaar5e654232020-09-16 15:22:00 +0200814generate_TYPECHECK(
815 cctx_T *cctx,
816 type_T *expected,
817 int offset)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100818{
819 isn_T *isn;
820 garray_T *stack = &cctx->ctx_type_stack;
821
Bram Moolenaar080457c2020-03-03 21:53:32 +0100822 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100823 if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL)
824 return FAIL;
Bram Moolenaar5e654232020-09-16 15:22:00 +0200825 isn->isn_arg.type.ct_type = alloc_type(expected);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100826 isn->isn_arg.type.ct_off = offset;
827
Bram Moolenaar5e654232020-09-16 15:22:00 +0200828 // type becomes expected
829 ((type_T **)stack->ga_data)[stack->ga_len + offset] = expected;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100830
831 return OK;
832}
833
Bram Moolenaaraa210a32021-01-02 15:41:03 +0100834 static int
835generate_SETTYPE(
836 cctx_T *cctx,
837 type_T *expected)
838{
839 isn_T *isn;
840
841 RETURN_OK_IF_SKIP(cctx);
842 if ((isn = generate_instr(cctx, ISN_SETTYPE)) == NULL)
843 return FAIL;
844 isn->isn_arg.type.ct_type = alloc_type(expected);
845 return OK;
846}
847
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100848/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200849 * Return TRUE if "actual" could be "expected" and a runtime typecheck is to be
850 * used. Return FALSE if the types will never match.
851 */
Bram Moolenaar193f6202020-11-16 20:08:35 +0100852 int
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200853use_typecheck(type_T *actual, type_T *expected)
854{
855 if (actual->tt_type == VAR_ANY
856 || actual->tt_type == VAR_UNKNOWN
857 || (actual->tt_type == VAR_FUNC
858 && (expected->tt_type == VAR_FUNC
859 || expected->tt_type == VAR_PARTIAL)
Bram Moolenaar328eac22021-01-07 19:23:08 +0100860 && (actual->tt_member == &t_any || actual->tt_argcount < 0)
861 && ((actual->tt_member == &t_void)
862 == (expected->tt_member == &t_void))))
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200863 return TRUE;
864 if ((actual->tt_type == VAR_LIST || actual->tt_type == VAR_DICT)
865 && actual->tt_type == expected->tt_type)
866 // This takes care of a nested list or dict.
867 return use_typecheck(actual->tt_member, expected->tt_member);
868 return FALSE;
869}
870
871/*
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200872 * Check that
Bram Moolenaar5e654232020-09-16 15:22:00 +0200873 * - "actual" matches "expected" type or
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200874 * - "actual" is a type that can be "expected" type: add a runtime check; or
875 * - return FAIL.
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200876 * If "actual_is_const" is TRUE then the type won't change at runtime, do not
877 * generate a TYPECHECK.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200878 */
879 static int
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200880need_type(
881 type_T *actual,
882 type_T *expected,
883 int offset,
884 cctx_T *cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200885 int silent,
886 int actual_is_const)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200887{
Bram Moolenaar4ed124c2020-09-09 20:03:46 +0200888 if (expected == &t_bool && actual != &t_bool
889 && (actual->tt_flags & TTFLAG_BOOL_OK))
890 {
891 // Using "0", "1" or the result of an expression with "&&" or "||" as a
892 // boolean is OK but requires a conversion.
893 generate_2BOOL(cctx, FALSE);
894 return OK;
895 }
896
Bram Moolenaar8b565c22020-08-30 23:24:20 +0200897 if (check_type(expected, actual, FALSE, 0) == OK)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200898 return OK;
Bram Moolenaar5e654232020-09-16 15:22:00 +0200899
900 // If the actual type can be the expected type add a runtime check.
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200901 // If it's a constant a runtime check makes no sense.
902 if (!actual_is_const && use_typecheck(actual, expected))
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200903 {
Bram Moolenaar5e654232020-09-16 15:22:00 +0200904 generate_TYPECHECK(cctx, expected, offset);
905 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200906 }
Bram Moolenaar5e654232020-09-16 15:22:00 +0200907
908 if (!silent)
909 type_mismatch(expected, actual);
910 return FAIL;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200911}
912
913/*
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100914 * Check that the top of the type stack has a type that can be used as a
915 * condition. Give an error and return FAIL if not.
916 */
917 static int
918bool_on_stack(cctx_T *cctx)
919{
920 garray_T *stack = &cctx->ctx_type_stack;
921 type_T *type;
922
923 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
924 if (type == &t_bool)
925 return OK;
926
927 if (type == &t_any || type == &t_number)
928 // Number 0 and 1 are OK to use as a bool. "any" could also be a bool.
929 // This requires a runtime type check.
930 return generate_COND2BOOL(cctx);
931
932 return need_type(type, &t_bool, -1, cctx, FALSE, FALSE);
933}
934
935/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100936 * Generate an ISN_PUSHNR instruction.
937 */
938 static int
939generate_PUSHNR(cctx_T *cctx, varnumber_T number)
940{
941 isn_T *isn;
Bram Moolenaar29a86ff2020-09-09 14:55:31 +0200942 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100943
Bram Moolenaar080457c2020-03-03 21:53:32 +0100944 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100945 if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL)
946 return FAIL;
947 isn->isn_arg.number = number;
948
Bram Moolenaar29a86ff2020-09-09 14:55:31 +0200949 if (number == 0 || number == 1)
Bram Moolenaar29a86ff2020-09-09 14:55:31 +0200950 // A 0 or 1 number can also be used as a bool.
Bram Moolenaar3868f592020-12-25 13:20:41 +0100951 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_number_bool;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100952 return OK;
953}
954
955/*
956 * Generate an ISN_PUSHBOOL instruction.
957 */
958 static int
959generate_PUSHBOOL(cctx_T *cctx, varnumber_T number)
960{
961 isn_T *isn;
962
Bram Moolenaar080457c2020-03-03 21:53:32 +0100963 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100964 if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL)
965 return FAIL;
966 isn->isn_arg.number = number;
967
968 return OK;
969}
970
971/*
972 * Generate an ISN_PUSHSPEC instruction.
973 */
974 static int
975generate_PUSHSPEC(cctx_T *cctx, varnumber_T number)
976{
977 isn_T *isn;
978
Bram Moolenaar080457c2020-03-03 21:53:32 +0100979 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100980 if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL)
981 return FAIL;
982 isn->isn_arg.number = number;
983
984 return OK;
985}
986
987#ifdef FEAT_FLOAT
988/*
989 * Generate an ISN_PUSHF instruction.
990 */
991 static int
992generate_PUSHF(cctx_T *cctx, float_T fnumber)
993{
994 isn_T *isn;
995
Bram Moolenaar080457c2020-03-03 21:53:32 +0100996 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100997 if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL)
998 return FAIL;
999 isn->isn_arg.fnumber = fnumber;
1000
1001 return OK;
1002}
1003#endif
1004
1005/*
1006 * Generate an ISN_PUSHS instruction.
1007 * Consumes "str".
1008 */
1009 static int
1010generate_PUSHS(cctx_T *cctx, char_u *str)
1011{
1012 isn_T *isn;
1013
Bram Moolenaar508b5612021-01-02 18:17:26 +01001014 if (cctx->ctx_skip == SKIP_YES)
1015 {
1016 vim_free(str);
1017 return OK;
1018 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001019 if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL)
1020 return FAIL;
1021 isn->isn_arg.string = str;
1022
1023 return OK;
1024}
1025
1026/*
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001027 * Generate an ISN_PUSHCHANNEL instruction.
1028 * Consumes "channel".
1029 */
1030 static int
1031generate_PUSHCHANNEL(cctx_T *cctx, channel_T *channel)
1032{
1033 isn_T *isn;
1034
Bram Moolenaar080457c2020-03-03 21:53:32 +01001035 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001036 if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL)
1037 return FAIL;
1038 isn->isn_arg.channel = channel;
1039
1040 return OK;
1041}
1042
1043/*
1044 * Generate an ISN_PUSHJOB instruction.
1045 * Consumes "job".
1046 */
1047 static int
1048generate_PUSHJOB(cctx_T *cctx, job_T *job)
1049{
1050 isn_T *isn;
1051
Bram Moolenaar080457c2020-03-03 21:53:32 +01001052 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +01001053 if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001054 return FAIL;
1055 isn->isn_arg.job = job;
1056
1057 return OK;
1058}
1059
1060/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001061 * Generate an ISN_PUSHBLOB instruction.
1062 * Consumes "blob".
1063 */
1064 static int
1065generate_PUSHBLOB(cctx_T *cctx, blob_T *blob)
1066{
1067 isn_T *isn;
1068
Bram Moolenaar080457c2020-03-03 21:53:32 +01001069 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001070 if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL)
1071 return FAIL;
1072 isn->isn_arg.blob = blob;
1073
1074 return OK;
1075}
1076
1077/*
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001078 * Generate an ISN_PUSHFUNC instruction with name "name".
1079 * Consumes "name".
1080 */
1081 static int
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001082generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001083{
1084 isn_T *isn;
1085
Bram Moolenaar080457c2020-03-03 21:53:32 +01001086 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001087 if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001088 return FAIL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001089 isn->isn_arg.string = name == NULL ? NULL : vim_strsave(name);
Bram Moolenaar42a480b2020-02-29 23:23:47 +01001090
1091 return OK;
1092}
1093
1094/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001095 * Generate an ISN_GETITEM instruction with "index".
1096 */
1097 static int
1098generate_GETITEM(cctx_T *cctx, int index)
1099{
1100 isn_T *isn;
1101 garray_T *stack = &cctx->ctx_type_stack;
1102 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
1103 type_T *item_type = &t_any;
1104
1105 RETURN_OK_IF_SKIP(cctx);
1106
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001107 if (type->tt_type != VAR_LIST)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001108 {
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001109 // cannot happen, caller has checked the type
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001110 emsg(_(e_listreq));
1111 return FAIL;
1112 }
Bram Moolenaarc7db5772020-07-21 20:55:50 +02001113 item_type = type->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001114 if ((isn = generate_instr(cctx, ISN_GETITEM)) == NULL)
1115 return FAIL;
1116 isn->isn_arg.number = index;
1117
1118 // add the item type to the type stack
1119 if (ga_grow(stack, 1) == FAIL)
1120 return FAIL;
1121 ((type_T **)stack->ga_data)[stack->ga_len] = item_type;
1122 ++stack->ga_len;
1123 return OK;
1124}
1125
1126/*
Bram Moolenaar9af78762020-06-16 11:34:42 +02001127 * Generate an ISN_SLICE instruction with "count".
1128 */
1129 static int
1130generate_SLICE(cctx_T *cctx, int count)
1131{
1132 isn_T *isn;
1133
1134 RETURN_OK_IF_SKIP(cctx);
1135 if ((isn = generate_instr(cctx, ISN_SLICE)) == NULL)
1136 return FAIL;
1137 isn->isn_arg.number = count;
1138 return OK;
1139}
1140
1141/*
1142 * Generate an ISN_CHECKLEN instruction with "min_len".
1143 */
1144 static int
1145generate_CHECKLEN(cctx_T *cctx, int min_len, int more_OK)
1146{
1147 isn_T *isn;
1148
1149 RETURN_OK_IF_SKIP(cctx);
1150
1151 if ((isn = generate_instr(cctx, ISN_CHECKLEN)) == NULL)
1152 return FAIL;
1153 isn->isn_arg.checklen.cl_min_len = min_len;
1154 isn->isn_arg.checklen.cl_more_OK = more_OK;
1155
1156 return OK;
1157}
1158
1159/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001160 * Generate an ISN_STORE instruction.
1161 */
1162 static int
1163generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name)
1164{
1165 isn_T *isn;
1166
Bram Moolenaar080457c2020-03-03 21:53:32 +01001167 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001168 if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL)
1169 return FAIL;
1170 if (name != NULL)
1171 isn->isn_arg.string = vim_strsave(name);
1172 else
1173 isn->isn_arg.number = idx;
1174
1175 return OK;
1176}
1177
1178/*
Bram Moolenaarab360522021-01-10 14:02:28 +01001179 * Generate an ISN_STOREOUTER instruction.
1180 */
1181 static int
1182generate_STOREOUTER(cctx_T *cctx, int idx, int level)
1183{
1184 isn_T *isn;
1185
1186 RETURN_OK_IF_SKIP(cctx);
1187 if ((isn = generate_instr_drop(cctx, ISN_STOREOUTER, 1)) == NULL)
1188 return FAIL;
1189 isn->isn_arg.outer.outer_idx = idx;
1190 isn->isn_arg.outer.outer_depth = level;
1191
1192 return OK;
1193}
1194
1195/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001196 * Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE)
1197 */
1198 static int
1199generate_STORENR(cctx_T *cctx, int idx, varnumber_T value)
1200{
1201 isn_T *isn;
1202
Bram Moolenaar080457c2020-03-03 21:53:32 +01001203 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001204 if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL)
1205 return FAIL;
Bram Moolenaara471eea2020-03-04 22:20:26 +01001206 isn->isn_arg.storenr.stnr_idx = idx;
1207 isn->isn_arg.storenr.stnr_val = value;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001208
1209 return OK;
1210}
1211
1212/*
1213 * Generate an ISN_STOREOPT instruction
1214 */
1215 static int
1216generate_STOREOPT(cctx_T *cctx, char_u *name, int opt_flags)
1217{
1218 isn_T *isn;
1219
Bram Moolenaar080457c2020-03-03 21:53:32 +01001220 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1c199f92020-08-07 21:28:34 +02001221 if ((isn = generate_instr_drop(cctx, ISN_STOREOPT, 1)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001222 return FAIL;
1223 isn->isn_arg.storeopt.so_name = vim_strsave(name);
1224 isn->isn_arg.storeopt.so_flags = opt_flags;
1225
1226 return OK;
1227}
1228
1229/*
1230 * Generate an ISN_LOAD or similar instruction.
1231 */
1232 static int
1233generate_LOAD(
1234 cctx_T *cctx,
1235 isntype_T isn_type,
1236 int idx,
1237 char_u *name,
1238 type_T *type)
1239{
1240 isn_T *isn;
1241
Bram Moolenaar080457c2020-03-03 21:53:32 +01001242 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001243 if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL)
1244 return FAIL;
1245 if (name != NULL)
1246 isn->isn_arg.string = vim_strsave(name);
1247 else
1248 isn->isn_arg.number = idx;
1249
1250 return OK;
1251}
1252
1253/*
Bram Moolenaarab360522021-01-10 14:02:28 +01001254 * Generate an ISN_LOADOUTER instruction
1255 */
1256 static int
1257generate_LOADOUTER(
1258 cctx_T *cctx,
1259 int idx,
1260 int nesting,
1261 type_T *type)
1262{
1263 isn_T *isn;
1264
1265 RETURN_OK_IF_SKIP(cctx);
1266 if ((isn = generate_instr_type(cctx, ISN_LOADOUTER, type)) == NULL)
1267 return FAIL;
1268 isn->isn_arg.outer.outer_idx = idx;
1269 isn->isn_arg.outer.outer_depth = nesting;
1270
1271 return OK;
1272}
1273
1274/*
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001275 * Generate an ISN_LOADV instruction for v:var.
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001276 */
1277 static int
1278generate_LOADV(
1279 cctx_T *cctx,
1280 char_u *name,
1281 int error)
1282{
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001283 int di_flags;
1284 int vidx = find_vim_var(name, &di_flags);
1285 type_T *type;
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001286
Bram Moolenaar080457c2020-03-03 21:53:32 +01001287 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001288 if (vidx < 0)
1289 {
1290 if (error)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001291 semsg(_(e_variable_not_found_str), name);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001292 return FAIL;
1293 }
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +02001294 type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001295
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001296 return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001297}
1298
1299/*
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001300 * Generate an ISN_UNLET instruction.
1301 */
1302 static int
Bram Moolenaar7bdaea62020-04-19 18:27:26 +02001303generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001304{
1305 isn_T *isn;
1306
1307 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar7bdaea62020-04-19 18:27:26 +02001308 if ((isn = generate_instr(cctx, isn_type)) == NULL)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001309 return FAIL;
1310 isn->isn_arg.unlet.ul_name = vim_strsave(name);
1311 isn->isn_arg.unlet.ul_forceit = forceit;
1312
1313 return OK;
1314}
1315
1316/*
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02001317 * Generate an ISN_LOCKCONST instruction.
1318 */
1319 static int
1320generate_LOCKCONST(cctx_T *cctx)
1321{
1322 isn_T *isn;
1323
1324 RETURN_OK_IF_SKIP(cctx);
1325 if ((isn = generate_instr(cctx, ISN_LOCKCONST)) == NULL)
1326 return FAIL;
1327 return OK;
1328}
1329
1330/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001331 * Generate an ISN_LOADS instruction.
1332 */
1333 static int
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001334generate_OLDSCRIPT(
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001335 cctx_T *cctx,
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001336 isntype_T isn_type,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001337 char_u *name,
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001338 int sid,
1339 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001340{
1341 isn_T *isn;
1342
Bram Moolenaar080457c2020-03-03 21:53:32 +01001343 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001344 if (isn_type == ISN_LOADS)
1345 isn = generate_instr_type(cctx, isn_type, type);
1346 else
1347 isn = generate_instr_drop(cctx, isn_type, 1);
1348 if (isn == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001349 return FAIL;
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001350 isn->isn_arg.loadstore.ls_name = vim_strsave(name);
1351 isn->isn_arg.loadstore.ls_sid = sid;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001352
1353 return OK;
1354}
1355
1356/*
1357 * Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction.
1358 */
1359 static int
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01001360generate_VIM9SCRIPT(
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001361 cctx_T *cctx,
1362 isntype_T isn_type,
1363 int sid,
1364 int idx,
1365 type_T *type)
1366{
1367 isn_T *isn;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01001368 scriptref_T *sref;
1369 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001370
Bram Moolenaar080457c2020-03-03 21:53:32 +01001371 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001372 if (isn_type == ISN_LOADSCRIPT)
1373 isn = generate_instr_type(cctx, isn_type, type);
1374 else
1375 isn = generate_instr_drop(cctx, isn_type, 1);
1376 if (isn == NULL)
1377 return FAIL;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01001378
1379 // This requires three arguments, which doesn't fit in an instruction, thus
1380 // we need to allocate a struct for this.
1381 sref = ALLOC_ONE(scriptref_T);
1382 if (sref == NULL)
1383 return FAIL;
1384 isn->isn_arg.script.scriptref = sref;
1385 sref->sref_sid = sid;
1386 sref->sref_idx = idx;
1387 sref->sref_seq = si->sn_script_seq;
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001388 sref->sref_type = type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001389 return OK;
1390}
1391
1392/*
1393 * Generate an ISN_NEWLIST instruction.
1394 */
1395 static int
1396generate_NEWLIST(cctx_T *cctx, int count)
1397{
1398 isn_T *isn;
1399 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001400 type_T *type;
1401 type_T *member;
1402
Bram Moolenaar080457c2020-03-03 21:53:32 +01001403 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001404 if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL)
1405 return FAIL;
1406 isn->isn_arg.number = count;
1407
Bram Moolenaar127542b2020-08-09 17:22:04 +02001408 // get the member type from all the items on the stack.
Bram Moolenaar9c2b0662020-09-01 19:56:15 +02001409 if (count == 0)
1410 member = &t_void;
1411 else
1412 member = get_member_type_from_stack(
Bram Moolenaar127542b2020-08-09 17:22:04 +02001413 ((type_T **)stack->ga_data) + stack->ga_len, count, 1,
1414 cctx->ctx_type_list);
1415 type = get_list_type(member, cctx->ctx_type_list);
1416
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001417 // drop the value types
1418 stack->ga_len -= count;
1419
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001420 // add the list type to the type stack
1421 if (ga_grow(stack, 1) == FAIL)
1422 return FAIL;
1423 ((type_T **)stack->ga_data)[stack->ga_len] = type;
1424 ++stack->ga_len;
1425
1426 return OK;
1427}
1428
1429/*
1430 * Generate an ISN_NEWDICT instruction.
1431 */
1432 static int
1433generate_NEWDICT(cctx_T *cctx, int count)
1434{
1435 isn_T *isn;
1436 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001437 type_T *type;
1438 type_T *member;
1439
Bram Moolenaar080457c2020-03-03 21:53:32 +01001440 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001441 if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL)
1442 return FAIL;
1443 isn->isn_arg.number = count;
1444
Bram Moolenaar9c2b0662020-09-01 19:56:15 +02001445 if (count == 0)
1446 member = &t_void;
1447 else
1448 member = get_member_type_from_stack(
Bram Moolenaar127542b2020-08-09 17:22:04 +02001449 ((type_T **)stack->ga_data) + stack->ga_len, count, 2,
1450 cctx->ctx_type_list);
1451 type = get_dict_type(member, cctx->ctx_type_list);
1452
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001453 // drop the key and value types
1454 stack->ga_len -= 2 * count;
1455
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001456 // add the dict type to the type stack
1457 if (ga_grow(stack, 1) == FAIL)
1458 return FAIL;
1459 ((type_T **)stack->ga_data)[stack->ga_len] = type;
1460 ++stack->ga_len;
1461
1462 return OK;
1463}
1464
1465/*
1466 * Generate an ISN_FUNCREF instruction.
1467 */
1468 static int
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001469generate_FUNCREF(cctx_T *cctx, ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001470{
1471 isn_T *isn;
1472 garray_T *stack = &cctx->ctx_type_stack;
1473
Bram Moolenaar080457c2020-03-03 21:53:32 +01001474 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001475 if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL)
1476 return FAIL;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001477 isn->isn_arg.funcref.fr_func = ufunc->uf_dfunc_idx;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02001478 cctx->ctx_has_closure = 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001479
Bram Moolenaarab360522021-01-10 14:02:28 +01001480 // if the referenced function is a closure, it may use items further up in
1481 // the nested context, including this one.
1482 if (ufunc->uf_flags & FC_CLOSURE)
1483 cctx->ctx_ufunc->uf_flags |= FC_CLOSURE;
1484
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001485 if (ga_grow(stack, 1) == FAIL)
1486 return FAIL;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001487 ((type_T **)stack->ga_data)[stack->ga_len] =
1488 ufunc->uf_func_type == NULL ? &t_func_any : ufunc->uf_func_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001489 ++stack->ga_len;
1490
1491 return OK;
1492}
1493
1494/*
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001495 * Generate an ISN_NEWFUNC instruction.
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001496 * "lambda_name" and "func_name" must be in allocated memory and will be
1497 * consumed.
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001498 */
1499 static int
1500generate_NEWFUNC(cctx_T *cctx, char_u *lambda_name, char_u *func_name)
1501{
1502 isn_T *isn;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001503
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001504 if (cctx->ctx_skip == SKIP_YES)
1505 {
1506 vim_free(lambda_name);
1507 vim_free(func_name);
1508 return OK;
1509 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001510 if ((isn = generate_instr(cctx, ISN_NEWFUNC)) == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001511 {
1512 vim_free(lambda_name);
1513 vim_free(func_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001514 return FAIL;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001515 }
1516 isn->isn_arg.newfunc.nf_lambda = lambda_name;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001517 isn->isn_arg.newfunc.nf_global = func_name;
1518
1519 return OK;
1520}
1521
1522/*
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001523 * Generate an ISN_DEF instruction: list functions
1524 */
1525 static int
1526generate_DEF(cctx_T *cctx, char_u *name, size_t len)
1527{
1528 isn_T *isn;
1529
1530 RETURN_OK_IF_SKIP(cctx);
1531 if ((isn = generate_instr(cctx, ISN_DEF)) == NULL)
1532 return FAIL;
1533 if (len > 0)
1534 {
1535 isn->isn_arg.string = vim_strnsave(name, len);
1536 if (isn->isn_arg.string == NULL)
1537 return FAIL;
1538 }
1539 return OK;
1540}
1541
1542/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001543 * Generate an ISN_JUMP instruction.
1544 */
1545 static int
1546generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where)
1547{
1548 isn_T *isn;
1549 garray_T *stack = &cctx->ctx_type_stack;
1550
Bram Moolenaar080457c2020-03-03 21:53:32 +01001551 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001552 if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL)
1553 return FAIL;
1554 isn->isn_arg.jump.jump_when = when;
1555 isn->isn_arg.jump.jump_where = where;
1556
1557 if (when != JUMP_ALWAYS && stack->ga_len > 0)
1558 --stack->ga_len;
1559
1560 return OK;
1561}
1562
1563 static int
1564generate_FOR(cctx_T *cctx, int loop_idx)
1565{
1566 isn_T *isn;
1567 garray_T *stack = &cctx->ctx_type_stack;
1568
Bram Moolenaar080457c2020-03-03 21:53:32 +01001569 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001570 if ((isn = generate_instr(cctx, ISN_FOR)) == NULL)
1571 return FAIL;
1572 isn->isn_arg.forloop.for_idx = loop_idx;
1573
1574 if (ga_grow(stack, 1) == FAIL)
1575 return FAIL;
1576 // type doesn't matter, will be stored next
1577 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
1578 ++stack->ga_len;
1579
1580 return OK;
1581}
1582
1583/*
1584 * Generate an ISN_BCALL instruction.
Bram Moolenaar389df252020-07-09 21:20:47 +02001585 * "method_call" is TRUE for "value->method()"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001586 * Return FAIL if the number of arguments is wrong.
1587 */
1588 static int
Bram Moolenaar389df252020-07-09 21:20:47 +02001589generate_BCALL(cctx_T *cctx, int func_idx, int argcount, int method_call)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001590{
1591 isn_T *isn;
1592 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar389df252020-07-09 21:20:47 +02001593 int argoff;
Bram Moolenaara1224cb2020-10-22 12:31:49 +02001594 type_T **argtypes = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001595
Bram Moolenaar080457c2020-03-03 21:53:32 +01001596 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar389df252020-07-09 21:20:47 +02001597 argoff = check_internal_func(func_idx, argcount);
1598 if (argoff < 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001599 return FAIL;
1600
Bram Moolenaar389df252020-07-09 21:20:47 +02001601 if (method_call && argoff > 1)
1602 {
1603 if ((isn = generate_instr(cctx, ISN_SHUFFLE)) == NULL)
1604 return FAIL;
1605 isn->isn_arg.shuffle.shfl_item = argcount;
1606 isn->isn_arg.shuffle.shfl_up = argoff - 1;
1607 }
1608
Bram Moolenaaraf7a9062020-10-21 16:49:17 +02001609 if (argcount > 0)
1610 {
1611 // Check the types of the arguments.
1612 argtypes = ((type_T **)stack->ga_data) + stack->ga_len - argcount;
1613 if (internal_func_check_arg_types(argtypes, func_idx, argcount) == FAIL)
Bram Moolenaar94738d82020-10-21 14:25:07 +02001614 return FAIL;
Bram Moolenaaraf7a9062020-10-21 16:49:17 +02001615 }
Bram Moolenaar94738d82020-10-21 14:25:07 +02001616
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001617 if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL)
1618 return FAIL;
1619 isn->isn_arg.bfunc.cbf_idx = func_idx;
1620 isn->isn_arg.bfunc.cbf_argcount = argcount;
1621
Bram Moolenaar94738d82020-10-21 14:25:07 +02001622 // Drop the argument types and push the return type.
1623 stack->ga_len -= argcount;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001624 if (ga_grow(stack, 1) == FAIL)
1625 return FAIL;
1626 ((type_T **)stack->ga_data)[stack->ga_len] =
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +01001627 internal_func_ret_type(func_idx, argcount, argtypes);
Bram Moolenaar94738d82020-10-21 14:25:07 +02001628 ++stack->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001629
1630 return OK;
1631}
1632
1633/*
Bram Moolenaar1dcae592020-10-19 19:02:42 +02001634 * Generate an ISN_LISTAPPEND instruction. Works like add().
1635 * Argument count is already checked.
1636 */
1637 static int
1638generate_LISTAPPEND(cctx_T *cctx)
1639{
1640 garray_T *stack = &cctx->ctx_type_stack;
1641 type_T *list_type;
1642 type_T *item_type;
1643 type_T *expected;
1644
1645 // Caller already checked that list_type is a list.
1646 list_type = ((type_T **)stack->ga_data)[stack->ga_len - 2];
1647 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
1648 expected = list_type->tt_member;
1649 if (need_type(item_type, expected, -1, cctx, FALSE, FALSE) == FAIL)
1650 return FAIL;
1651
1652 if (generate_instr(cctx, ISN_LISTAPPEND) == NULL)
1653 return FAIL;
1654
1655 --stack->ga_len; // drop the argument
1656 return OK;
1657}
1658
1659/*
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02001660 * Generate an ISN_BLOBAPPEND instruction. Works like add().
1661 * Argument count is already checked.
1662 */
1663 static int
1664generate_BLOBAPPEND(cctx_T *cctx)
1665{
1666 garray_T *stack = &cctx->ctx_type_stack;
1667 type_T *item_type;
1668
1669 // Caller already checked that blob_type is a blob.
1670 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
1671 if (need_type(item_type, &t_number, -1, cctx, FALSE, FALSE) == FAIL)
1672 return FAIL;
1673
1674 if (generate_instr(cctx, ISN_BLOBAPPEND) == NULL)
1675 return FAIL;
1676
1677 --stack->ga_len; // drop the argument
1678 return OK;
1679}
1680
1681/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001682 * Generate an ISN_DCALL or ISN_UCALL instruction.
1683 * Return FAIL if the number of arguments is wrong.
1684 */
1685 static int
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01001686generate_CALL(cctx_T *cctx, ufunc_T *ufunc, int pushed_argcount)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001687{
1688 isn_T *isn;
1689 garray_T *stack = &cctx->ctx_type_stack;
1690 int regular_args = ufunc->uf_args.ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01001691 int argcount = pushed_argcount;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001692
Bram Moolenaar080457c2020-03-03 21:53:32 +01001693 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001694 if (argcount > regular_args && !has_varargs(ufunc))
1695 {
Bram Moolenaarb185a402020-09-18 22:42:00 +02001696 semsg(_(e_toomanyarg), printable_func_name(ufunc));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001697 return FAIL;
1698 }
1699 if (argcount < regular_args - ufunc->uf_def_args.ga_len)
1700 {
Bram Moolenaarb185a402020-09-18 22:42:00 +02001701 semsg(_(e_toofewarg), printable_func_name(ufunc));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001702 return FAIL;
1703 }
1704
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02001705 if (ufunc->uf_def_status != UF_NOT_COMPILED)
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001706 {
1707 int i;
1708
1709 for (i = 0; i < argcount; ++i)
1710 {
1711 type_T *expected;
1712 type_T *actual;
1713
1714 if (i < regular_args)
1715 {
1716 if (ufunc->uf_arg_types == NULL)
1717 continue;
1718 expected = ufunc->uf_arg_types[i];
1719 }
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001720 else if (ufunc->uf_va_type == NULL || ufunc->uf_va_type == &t_any)
1721 // possibly a lambda or "...: any"
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001722 expected = &t_any;
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001723 else
1724 expected = ufunc->uf_va_type->tt_member;
1725 actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001726 if (need_type(actual, expected, -argcount + i, cctx,
1727 TRUE, FALSE) == FAIL)
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001728 {
1729 arg_type_mismatch(expected, actual, i + 1);
1730 return FAIL;
1731 }
1732 }
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02001733 if (ufunc->uf_def_status == UF_TO_BE_COMPILED)
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001734 if (compile_def_function(ufunc, ufunc->uf_ret_type == NULL, NULL)
1735 == FAIL)
Bram Moolenaar822ba242020-05-24 23:00:18 +02001736 return FAIL;
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001737 }
1738
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001739 if ((isn = generate_instr(cctx,
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02001740 ufunc->uf_def_status != UF_NOT_COMPILED ? ISN_DCALL
Bram Moolenaar822ba242020-05-24 23:00:18 +02001741 : ISN_UCALL)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001742 return FAIL;
Bram Moolenaara05e5242020-09-19 18:19:19 +02001743 if (isn->isn_type == ISN_DCALL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001744 {
1745 isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx;
1746 isn->isn_arg.dfunc.cdf_argcount = argcount;
1747 }
1748 else
1749 {
1750 // A user function may be deleted and redefined later, can't use the
1751 // ufunc pointer, need to look it up again at runtime.
1752 isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name);
1753 isn->isn_arg.ufunc.cuf_argcount = argcount;
1754 }
1755
1756 stack->ga_len -= argcount; // drop the arguments
1757 if (ga_grow(stack, 1) == FAIL)
1758 return FAIL;
1759 // add return value
1760 ((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type;
1761 ++stack->ga_len;
1762
1763 return OK;
1764}
1765
1766/*
1767 * Generate an ISN_UCALL instruction when the function isn't defined yet.
1768 */
1769 static int
1770generate_UCALL(cctx_T *cctx, char_u *name, int argcount)
1771{
1772 isn_T *isn;
1773 garray_T *stack = &cctx->ctx_type_stack;
1774
Bram Moolenaar080457c2020-03-03 21:53:32 +01001775 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001776 if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL)
1777 return FAIL;
1778 isn->isn_arg.ufunc.cuf_name = vim_strsave(name);
1779 isn->isn_arg.ufunc.cuf_argcount = argcount;
1780
1781 stack->ga_len -= argcount; // drop the arguments
Bram Moolenaar26e117e2020-02-04 21:24:15 +01001782 if (ga_grow(stack, 1) == FAIL)
1783 return FAIL;
1784 // add return value
1785 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
1786 ++stack->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001787
1788 return OK;
1789}
1790
1791/*
1792 * Generate an ISN_PCALL instruction.
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001793 * "type" is the type of the FuncRef.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001794 */
1795 static int
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001796generate_PCALL(
1797 cctx_T *cctx,
1798 int argcount,
1799 char_u *name,
1800 type_T *type,
1801 int at_top)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001802{
1803 isn_T *isn;
1804 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001805 type_T *ret_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001806
Bram Moolenaar080457c2020-03-03 21:53:32 +01001807 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001808
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001809 if (type->tt_type == VAR_ANY)
1810 ret_type = &t_any;
1811 else if (type->tt_type == VAR_FUNC || type->tt_type == VAR_PARTIAL)
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02001812 {
1813 if (type->tt_argcount != -1)
1814 {
1815 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
1816
1817 if (argcount < type->tt_min_argcount - varargs)
1818 {
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01001819 semsg(_(e_toofewarg), name);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02001820 return FAIL;
1821 }
1822 if (!varargs && argcount > type->tt_argcount)
1823 {
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01001824 semsg(_(e_toomanyarg), name);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02001825 return FAIL;
1826 }
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001827 if (type->tt_args != NULL)
1828 {
1829 int i;
1830
1831 for (i = 0; i < argcount; ++i)
1832 {
1833 int offset = -argcount + i - 1;
1834 type_T *actual = ((type_T **)stack->ga_data)[
1835 stack->ga_len + offset];
1836 type_T *expected;
1837
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001838 if (varargs && i >= type->tt_argcount - 1)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001839 expected = type->tt_args[
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001840 type->tt_argcount - 1]->tt_member;
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001841 else
1842 expected = type->tt_args[i];
1843 if (need_type(actual, expected, offset,
1844 cctx, TRUE, FALSE) == FAIL)
1845 {
1846 arg_type_mismatch(expected, actual, i + 1);
1847 return FAIL;
1848 }
1849 }
1850 }
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02001851 }
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001852 ret_type = type->tt_member;
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02001853 }
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001854 else
1855 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001856 semsg(_(e_not_callable_type_str), name);
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001857 return FAIL;
1858 }
1859
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001860 if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL)
1861 return FAIL;
1862 isn->isn_arg.pfunc.cpf_top = at_top;
1863 isn->isn_arg.pfunc.cpf_argcount = argcount;
1864
1865 stack->ga_len -= argcount; // drop the arguments
1866
1867 // drop the funcref/partial, get back the return value
Bram Moolenaara0a9f432020-04-28 21:29:34 +02001868 ((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001869
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001870 // If partial is above the arguments it must be cleared and replaced with
1871 // the return value.
1872 if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL)
1873 return FAIL;
1874
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001875 return OK;
1876}
1877
1878/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001879 * Generate an ISN_STRINGMEMBER instruction.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001880 */
1881 static int
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001882generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001883{
1884 isn_T *isn;
1885 garray_T *stack = &cctx->ctx_type_stack;
1886 type_T *type;
1887
Bram Moolenaar080457c2020-03-03 21:53:32 +01001888 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001889 if ((isn = generate_instr(cctx, ISN_STRINGMEMBER)) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001890 return FAIL;
Bram Moolenaar71ccd032020-06-12 22:59:11 +02001891 isn->isn_arg.string = vim_strnsave(name, len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001892
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001893 // check for dict type
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001894 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001895 if (type->tt_type != VAR_DICT && type != &t_any)
1896 {
1897 emsg(_(e_dictreq));
1898 return FAIL;
1899 }
1900 // change dict type to dict member type
1901 if (type->tt_type == VAR_DICT)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01001902 {
1903 ((type_T **)stack->ga_data)[stack->ga_len - 1] =
1904 type->tt_member == &t_unknown ? &t_any : type->tt_member;
1905 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001906
1907 return OK;
1908}
1909
1910/*
1911 * Generate an ISN_ECHO instruction.
1912 */
1913 static int
1914generate_ECHO(cctx_T *cctx, int with_white, int count)
1915{
1916 isn_T *isn;
1917
Bram Moolenaar080457c2020-03-03 21:53:32 +01001918 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001919 if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL)
1920 return FAIL;
1921 isn->isn_arg.echo.echo_with_white = with_white;
1922 isn->isn_arg.echo.echo_count = count;
1923
1924 return OK;
1925}
1926
Bram Moolenaarad39c092020-02-26 18:23:43 +01001927/*
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001928 * Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction.
Bram Moolenaarad39c092020-02-26 18:23:43 +01001929 */
1930 static int
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001931generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001932{
1933 isn_T *isn;
1934
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001935 if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001936 return FAIL;
1937 isn->isn_arg.number = count;
1938
1939 return OK;
1940}
1941
Bram Moolenaarc3516f72020-09-08 22:45:35 +02001942/*
1943 * Generate an ISN_PUT instruction.
1944 */
1945 static int
1946generate_PUT(cctx_T *cctx, int regname, linenr_T lnum)
1947{
1948 isn_T *isn;
1949
1950 RETURN_OK_IF_SKIP(cctx);
1951 if ((isn = generate_instr(cctx, ISN_PUT)) == NULL)
1952 return FAIL;
1953 isn->isn_arg.put.put_regname = regname;
1954 isn->isn_arg.put.put_lnum = lnum;
1955 return OK;
1956}
1957
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001958 static int
1959generate_EXEC(cctx_T *cctx, char_u *line)
1960{
1961 isn_T *isn;
1962
Bram Moolenaar080457c2020-03-03 21:53:32 +01001963 RETURN_OK_IF_SKIP(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001964 if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL)
1965 return FAIL;
1966 isn->isn_arg.string = vim_strsave(line);
1967 return OK;
1968}
1969
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02001970 static int
1971generate_EXECCONCAT(cctx_T *cctx, int count)
1972{
1973 isn_T *isn;
1974
1975 if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL)
1976 return FAIL;
1977 isn->isn_arg.number = count;
1978 return OK;
1979}
1980
Bram Moolenaar08597872020-12-10 19:43:40 +01001981/*
1982 * Generate ISN_RANGE. Consumes "range". Return OK/FAIL.
1983 */
1984 static int
1985generate_RANGE(cctx_T *cctx, char_u *range)
1986{
1987 isn_T *isn;
1988 garray_T *stack = &cctx->ctx_type_stack;
1989
1990 if ((isn = generate_instr(cctx, ISN_RANGE)) == NULL)
1991 return FAIL;
1992 isn->isn_arg.string = range;
1993
1994 if (ga_grow(stack, 1) == FAIL)
1995 return FAIL;
1996 ((type_T **)stack->ga_data)[stack->ga_len] = &t_number;
1997 ++stack->ga_len;
1998 return OK;
1999}
2000
Bram Moolenaar792f7862020-11-23 08:31:18 +01002001 static int
2002generate_UNPACK(cctx_T *cctx, int var_count, int semicolon)
2003{
2004 isn_T *isn;
2005
2006 RETURN_OK_IF_SKIP(cctx);
2007 if ((isn = generate_instr(cctx, ISN_UNPACK)) == NULL)
2008 return FAIL;
2009 isn->isn_arg.unpack.unp_count = var_count;
2010 isn->isn_arg.unpack.unp_semicolon = semicolon;
2011 return OK;
2012}
2013
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002014/*
Bram Moolenaar02194d22020-10-24 23:08:38 +02002015 * Generate an instruction for any command modifiers.
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002016 */
2017 static int
Bram Moolenaare1004402020-10-24 20:49:43 +02002018generate_cmdmods(cctx_T *cctx, cmdmod_T *cmod)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002019{
2020 isn_T *isn;
2021
Bram Moolenaar02194d22020-10-24 23:08:38 +02002022 if (cmod->cmod_flags != 0
2023 || cmod->cmod_split != 0
2024 || cmod->cmod_verbose != 0
2025 || cmod->cmod_tab != 0
2026 || cmod->cmod_filter_regmatch.regprog != NULL)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002027 {
Bram Moolenaar02194d22020-10-24 23:08:38 +02002028 cctx->ctx_has_cmdmod = TRUE;
2029
2030 if ((isn = generate_instr(cctx, ISN_CMDMOD)) == NULL)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002031 return FAIL;
Bram Moolenaar02194d22020-10-24 23:08:38 +02002032 isn->isn_arg.cmdmod.cf_cmdmod = ALLOC_ONE(cmdmod_T);
2033 if (isn->isn_arg.cmdmod.cf_cmdmod == NULL)
2034 return FAIL;
2035 mch_memmove(isn->isn_arg.cmdmod.cf_cmdmod, cmod, sizeof(cmdmod_T));
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01002036 // filter program now belongs to the instruction
Bram Moolenaar02194d22020-10-24 23:08:38 +02002037 cmod->cmod_filter_regmatch.regprog = NULL;
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002038 }
Bram Moolenaar02194d22020-10-24 23:08:38 +02002039
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002040 return OK;
2041}
2042
2043 static int
Bram Moolenaar02194d22020-10-24 23:08:38 +02002044generate_undo_cmdmods(cctx_T *cctx)
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002045{
Bram Moolenaarf665e972020-12-05 19:17:16 +01002046 if (cctx->ctx_has_cmdmod && generate_instr(cctx, ISN_CMDMOD_REV) == NULL)
2047 return FAIL;
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02002048 return OK;
2049}
2050
2051/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002052 * Reserve space for a local variable.
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002053 * Return the variable or NULL if it failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002054 */
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002055 static lvar_T *
Bram Moolenaare8211a32020-10-09 22:04:29 +02002056reserve_local(
2057 cctx_T *cctx,
2058 char_u *name,
2059 size_t len,
2060 int isConst,
2061 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002062{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002063 lvar_T *lvar;
2064
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002065 if (arg_exists(name, len, NULL, NULL, NULL, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002066 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002067 emsg_namelen(_(e_str_is_used_as_argument), name, (int)len);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002068 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002069 }
2070
2071 if (ga_grow(&cctx->ctx_locals, 1) == FAIL)
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002072 return NULL;
2073 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
Bram Moolenaare8211a32020-10-09 22:04:29 +02002074 CLEAR_POINTER(lvar);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002075
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002076 // Every local variable uses the next entry on the stack. We could re-use
2077 // the last ones when leaving a scope, but then variables used in a closure
2078 // might get overwritten. To keep things simple do not re-use stack
2079 // entries. This is less efficient, but memory is cheap these days.
2080 lvar->lv_idx = cctx->ctx_locals_count++;
2081
Bram Moolenaar71ccd032020-06-12 22:59:11 +02002082 lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002083 lvar->lv_const = isConst;
2084 lvar->lv_type = type;
2085
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002086 return lvar;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002087}
2088
2089/*
Bram Moolenaar20431c92020-03-20 18:39:46 +01002090 * Remove local variables above "new_top".
2091 */
2092 static void
2093unwind_locals(cctx_T *cctx, int new_top)
2094{
2095 if (cctx->ctx_locals.ga_len > new_top)
2096 {
2097 int idx;
2098 lvar_T *lvar;
2099
2100 for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx)
2101 {
2102 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
2103 vim_free(lvar->lv_name);
2104 }
2105 }
2106 cctx->ctx_locals.ga_len = new_top;
2107}
2108
2109/*
2110 * Free all local variables.
2111 */
2112 static void
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002113free_locals(cctx_T *cctx)
Bram Moolenaar20431c92020-03-20 18:39:46 +01002114{
2115 unwind_locals(cctx, 0);
2116 ga_clear(&cctx->ctx_locals);
2117}
2118
2119/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002120 * Find "name" in script-local items of script "sid".
2121 * Returns the index in "sn_var_vals" if found.
2122 * If found but not in "sn_var_vals" returns -1.
2123 * If not found returns -2.
2124 */
2125 int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002126get_script_item_idx(int sid, char_u *name, int check_writable, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002127{
2128 hashtab_T *ht;
2129 dictitem_T *di;
Bram Moolenaar21b9e972020-01-26 19:26:46 +01002130 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002131 svar_T *sv;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002132 int idx;
2133
Bram Moolenaare3d46852020-08-29 13:39:17 +02002134 if (!SCRIPT_ID_VALID(sid))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002135 return -1;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002136 if (sid == current_sctx.sc_sid)
2137 {
Bram Moolenaar209f0202020-10-15 13:57:56 +02002138 sallvar_T *sav = find_script_var(name, 0, cctx);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002139
2140 if (sav == NULL)
2141 return -2;
2142 idx = sav->sav_var_vals_idx;
2143 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
2144 if (check_writable && sv->sv_const)
2145 semsg(_(e_readonlyvar), name);
2146 return idx;
2147 }
2148
2149 // First look the name up in the hashtable.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002150 ht = &SCRIPT_VARS(sid);
2151 di = find_var_in_ht(ht, 0, name, TRUE);
2152 if (di == NULL)
2153 return -2;
2154
2155 // Now find the svar_T index in sn_var_vals.
2156 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
2157 {
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002158 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002159 if (sv->sv_tv == &di->di_tv)
2160 {
2161 if (check_writable && sv->sv_const)
2162 semsg(_(e_readonlyvar), name);
2163 return idx;
2164 }
2165 }
2166 return -1;
2167}
2168
2169/*
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002170 * Find "name" in imported items of the current script or in "cctx" if not
2171 * NULL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002172 */
2173 imported_T *
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002174find_imported(char_u *name, size_t len, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002175{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002176 int idx;
2177
Bram Moolenaare3d46852020-08-29 13:39:17 +02002178 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
Bram Moolenaar8e6cbb72020-07-01 14:38:12 +02002179 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002180 if (cctx != NULL)
2181 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
2182 {
2183 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data)
2184 + idx;
2185
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002186 if (len == 0 ? STRCMP(name, import->imp_name) == 0
2187 : STRLEN(import->imp_name) == len
2188 && STRNCMP(name, import->imp_name, len) == 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002189 return import;
2190 }
2191
Bram Moolenaarefa94442020-08-08 22:16:00 +02002192 return find_imported_in_script(name, len, current_sctx.sc_sid);
2193}
2194
2195 imported_T *
2196find_imported_in_script(char_u *name, size_t len, int sid)
2197{
Bram Moolenaare3d46852020-08-29 13:39:17 +02002198 scriptitem_T *si;
Bram Moolenaarefa94442020-08-08 22:16:00 +02002199 int idx;
2200
Bram Moolenaare3d46852020-08-29 13:39:17 +02002201 if (!SCRIPT_ID_VALID(sid))
2202 return NULL;
2203 si = SCRIPT_ITEM(sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002204 for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
2205 {
2206 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx;
2207
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002208 if (len == 0 ? STRCMP(name, import->imp_name) == 0
2209 : STRLEN(import->imp_name) == len
2210 && STRNCMP(name, import->imp_name, len) == 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002211 return import;
2212 }
2213 return NULL;
2214}
2215
2216/*
Bram Moolenaar20431c92020-03-20 18:39:46 +01002217 * Free all imported variables.
2218 */
2219 static void
2220free_imported(cctx_T *cctx)
2221{
2222 int idx;
2223
2224 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
2225 {
2226 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) + idx;
2227
2228 vim_free(import->imp_name);
2229 }
2230 ga_clear(&cctx->ctx_imports);
2231}
2232
2233/*
Bram Moolenaar23c55272020-06-21 16:58:13 +02002234 * Return a pointer to the next line that isn't empty or only contains a
2235 * comment. Skips over white space.
2236 * Returns NULL if there is none.
2237 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002238 char_u *
2239peek_next_line_from_context(cctx_T *cctx)
Bram Moolenaar23c55272020-06-21 16:58:13 +02002240{
2241 int lnum = cctx->ctx_lnum;
2242
2243 while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len)
2244 {
2245 char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum];
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002246 char_u *p;
Bram Moolenaar23c55272020-06-21 16:58:13 +02002247
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002248 // ignore NULLs inserted for continuation lines
2249 if (line != NULL)
2250 {
2251 p = skipwhite(line);
2252 if (*p != NUL && !vim9_comment_start(p))
2253 return p;
2254 }
Bram Moolenaar23c55272020-06-21 16:58:13 +02002255 }
2256 return NULL;
2257}
2258
2259/*
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002260 * Called when checking for a following operator at "arg". When the rest of
2261 * the line is empty or only a comment, peek the next line. If there is a next
2262 * line return a pointer to it and set "nextp".
2263 * Otherwise skip over white space.
2264 */
2265 static char_u *
2266may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp)
2267{
2268 char_u *p = skipwhite(arg);
2269
2270 *nextp = NULL;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002271 if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p)))
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002272 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002273 *nextp = peek_next_line_from_context(cctx);
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02002274 if (*nextp != NULL)
2275 return *nextp;
2276 }
2277 return p;
2278}
2279
2280/*
Bram Moolenaare6085c52020-04-12 20:19:16 +02002281 * Get the next line of the function from "cctx".
Bram Moolenaar23c55272020-06-21 16:58:13 +02002282 * Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE.
Bram Moolenaare6085c52020-04-12 20:19:16 +02002283 * Returns NULL when at the end.
2284 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002285 char_u *
Bram Moolenaar23c55272020-06-21 16:58:13 +02002286next_line_from_context(cctx_T *cctx, int skip_comment)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002287{
Bram Moolenaar7a092242020-04-16 22:10:49 +02002288 char_u *line;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002289
2290 do
2291 {
2292 ++cctx->ctx_lnum;
2293 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
Bram Moolenaar7a092242020-04-16 22:10:49 +02002294 {
2295 line = NULL;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002296 break;
Bram Moolenaar7a092242020-04-16 22:10:49 +02002297 }
Bram Moolenaare6085c52020-04-12 20:19:16 +02002298 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
Bram Moolenaar7a092242020-04-16 22:10:49 +02002299 cctx->ctx_line_start = line;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002300 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar23c55272020-06-21 16:58:13 +02002301 } while (line == NULL || *skipwhite(line) == NUL
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002302 || (skip_comment && vim9_comment_start(skipwhite(line))));
Bram Moolenaare6085c52020-04-12 20:19:16 +02002303 return line;
2304}
2305
2306/*
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002307 * Skip over white space at "whitep" and assign to "*arg".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002308 * If "*arg" is at the end of the line, advance to the next line.
Bram Moolenaar2c330432020-04-13 14:41:35 +02002309 * Also when "whitep" points to white space and "*arg" is on a "#".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002310 * Return FAIL if beyond the last line, "*arg" is unmodified then.
2311 */
2312 static int
Bram Moolenaar2c330432020-04-13 14:41:35 +02002313may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002314{
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002315 *arg = skipwhite(whitep);
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002316 if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg)))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002317 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002318 char_u *next = next_line_from_context(cctx, TRUE);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002319
2320 if (next == NULL)
2321 return FAIL;
2322 *arg = skipwhite(next);
2323 }
2324 return OK;
2325}
2326
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002327/*
2328 * Idem, and give an error when failed.
2329 */
2330 static int
2331may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx)
2332{
2333 if (may_get_next_line(whitep, arg, cctx) == FAIL)
2334 {
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002335 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002336 emsg(_(e_line_incomplete));
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002337 return FAIL;
2338 }
2339 return OK;
2340}
2341
2342
Bram Moolenaara5565e42020-05-09 15:44:01 +02002343// Structure passed between the compile_expr* functions to keep track of
2344// constants that have been parsed but for which no code was produced yet. If
2345// possible expressions on these constants are applied at compile time. If
2346// that is not possible, the code to push the constants needs to be generated
2347// before other instructions.
Bram Moolenaar1c747212020-05-09 18:28:34 +02002348// Using 50 should be more than enough of 5 levels of ().
2349#define PPSIZE 50
Bram Moolenaara5565e42020-05-09 15:44:01 +02002350typedef struct {
Bram Moolenaar1c747212020-05-09 18:28:34 +02002351 typval_T pp_tv[PPSIZE]; // stack of ppconst constants
Bram Moolenaara5565e42020-05-09 15:44:01 +02002352 int pp_used; // active entries in pp_tv[]
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002353 int pp_is_const; // all generated code was constants, used for a
2354 // list or dict with constant members
Bram Moolenaara5565e42020-05-09 15:44:01 +02002355} ppconst_T;
2356
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002357static int compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const);
Bram Moolenaar1c747212020-05-09 18:28:34 +02002358static int compile_expr0(char_u **arg, cctx_T *cctx);
2359static int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
2360
Bram Moolenaara5565e42020-05-09 15:44:01 +02002361/*
2362 * Generate a PUSH instruction for "tv".
2363 * "tv" will be consumed or cleared.
2364 * Nothing happens if "tv" is NULL or of type VAR_UNKNOWN;
2365 */
2366 static int
2367generate_tv_PUSH(cctx_T *cctx, typval_T *tv)
2368{
2369 if (tv != NULL)
2370 {
2371 switch (tv->v_type)
2372 {
2373 case VAR_UNKNOWN:
2374 break;
2375 case VAR_BOOL:
2376 generate_PUSHBOOL(cctx, tv->vval.v_number);
2377 break;
2378 case VAR_SPECIAL:
2379 generate_PUSHSPEC(cctx, tv->vval.v_number);
2380 break;
2381 case VAR_NUMBER:
2382 generate_PUSHNR(cctx, tv->vval.v_number);
2383 break;
2384#ifdef FEAT_FLOAT
2385 case VAR_FLOAT:
2386 generate_PUSHF(cctx, tv->vval.v_float);
2387 break;
2388#endif
2389 case VAR_BLOB:
2390 generate_PUSHBLOB(cctx, tv->vval.v_blob);
2391 tv->vval.v_blob = NULL;
2392 break;
2393 case VAR_STRING:
2394 generate_PUSHS(cctx, tv->vval.v_string);
2395 tv->vval.v_string = NULL;
2396 break;
2397 default:
2398 iemsg("constant type not supported");
2399 clear_tv(tv);
2400 return FAIL;
2401 }
2402 tv->v_type = VAR_UNKNOWN;
2403 }
2404 return OK;
2405}
2406
2407/*
2408 * Generate code for any ppconst entries.
2409 */
2410 static int
2411generate_ppconst(cctx_T *cctx, ppconst_T *ppconst)
2412{
2413 int i;
2414 int ret = OK;
Bram Moolenaar497f76b2020-05-09 16:44:22 +02002415 int save_skip = cctx->ctx_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002416
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002417 cctx->ctx_skip = SKIP_NOT;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002418 for (i = 0; i < ppconst->pp_used; ++i)
2419 if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL)
2420 ret = FAIL;
2421 ppconst->pp_used = 0;
Bram Moolenaar497f76b2020-05-09 16:44:22 +02002422 cctx->ctx_skip = save_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02002423 return ret;
2424}
2425
2426/*
2427 * Clear ppconst constants. Used when failing.
2428 */
2429 static void
2430clear_ppconst(ppconst_T *ppconst)
2431{
2432 int i;
2433
2434 for (i = 0; i < ppconst->pp_used; ++i)
2435 clear_tv(&ppconst->pp_tv[i]);
2436 ppconst->pp_used = 0;
2437}
2438
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02002439/*
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002440 * Generate an instruction to load script-local variable "name", without the
2441 * leading "s:".
2442 * Also finds imported variables.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002443 */
2444 static int
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002445compile_load_scriptvar(
2446 cctx_T *cctx,
2447 char_u *name, // variable NUL terminated
2448 char_u *start, // start of variable
Bram Moolenaarb35efa52020-02-26 20:15:18 +01002449 char_u **end, // end of variable
2450 int error) // when TRUE may give error
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002451{
Bram Moolenaare3d46852020-08-29 13:39:17 +02002452 scriptitem_T *si;
2453 int idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002454 imported_T *import;
2455
Bram Moolenaare3d46852020-08-29 13:39:17 +02002456 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
2457 return FAIL;
2458 si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002459 idx = get_script_item_idx(current_sctx.sc_sid, name, FALSE, cctx);
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002460 if (idx == -1 || si->sn_version != SCRIPT_VERSION_VIM9)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002461 {
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002462 // variable is not in sn_var_vals: old style script.
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01002463 return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid,
2464 &t_any);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002465 }
2466 if (idx >= 0)
2467 {
2468 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
2469
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01002470 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002471 current_sctx.sc_sid, idx, sv->sv_type);
2472 return OK;
2473 }
2474
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01002475 import = find_imported(name, 0, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002476 if (import != NULL)
2477 {
Bram Moolenaara6294952020-12-27 13:39:50 +01002478 if (import->imp_flags & IMP_FLAGS_STAR)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002479 {
2480 char_u *p = skipwhite(*end);
Bram Moolenaar1c991142020-07-04 13:15:31 +02002481 char_u *exp_name;
2482 int cc;
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002483 ufunc_T *ufunc;
2484 type_T *type;
2485
2486 // Used "import * as Name", need to lookup the member.
2487 if (*p != '.')
2488 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002489 semsg(_(e_expected_dot_after_name_str), start);
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002490 return FAIL;
2491 }
2492 ++p;
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002493 if (VIM_ISWHITE(*p))
2494 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002495 emsg(_(e_no_white_space_allowed_after_dot));
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002496 return FAIL;
2497 }
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002498
Bram Moolenaar1c991142020-07-04 13:15:31 +02002499 // isolate one name
2500 exp_name = p;
2501 while (eval_isnamec(*p))
2502 ++p;
2503 cc = *p;
2504 *p = NUL;
2505
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002506 idx = find_exported(import->imp_sid, exp_name, &ufunc, &type, cctx);
Bram Moolenaar1c991142020-07-04 13:15:31 +02002507 *p = cc;
2508 p = skipwhite(p);
2509
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002510 // TODO: what if it is a function?
2511 if (idx < 0)
2512 return FAIL;
2513 *end = p;
2514
2515 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
2516 import->imp_sid,
2517 idx,
2518 type);
2519 }
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02002520 else if (import->imp_funcname != NULL)
2521 generate_PUSHFUNC(cctx, import->imp_funcname, import->imp_type);
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002522 else
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002523 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
2524 import->imp_sid,
2525 import->imp_var_vals_idx,
2526 import->imp_type);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002527 return OK;
2528 }
2529
Bram Moolenaarb35efa52020-02-26 20:15:18 +01002530 if (error)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002531 semsg(_(e_item_not_found_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002532 return FAIL;
2533}
2534
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002535 static int
2536generate_funcref(cctx_T *cctx, char_u *name)
2537{
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002538 ufunc_T *ufunc = find_func(name, FALSE, cctx);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002539
2540 if (ufunc == NULL)
2541 return FAIL;
2542
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002543 // Need to compile any default values to get the argument types.
2544 if (ufunc->uf_def_status == UF_TO_BE_COMPILED)
2545 if (compile_def_function(ufunc, TRUE, NULL) == FAIL)
2546 return FAIL;
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02002547 return generate_PUSHFUNC(cctx, ufunc->uf_name, ufunc->uf_func_type);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002548}
2549
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002550/*
2551 * Compile a variable name into a load instruction.
2552 * "end" points to just after the name.
Bram Moolenaar0f769812020-09-12 18:32:34 +02002553 * "is_expr" is TRUE when evaluating an expression, might be a funcref.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002554 * When "error" is FALSE do not give an error when not found.
2555 */
2556 static int
Bram Moolenaar0f769812020-09-12 18:32:34 +02002557compile_load(
2558 char_u **arg,
2559 char_u *end_arg,
2560 cctx_T *cctx,
2561 int is_expr,
2562 int error)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002563{
2564 type_T *type;
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002565 char_u *name = NULL;
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01002566 char_u *end = end_arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002567 int res = FAIL;
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002568 int prev_called_emsg = called_emsg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002569
2570 if (*(*arg + 1) == ':')
2571 {
2572 // load namespaced variable
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002573 if (end <= *arg + 2)
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002574 {
2575 isntype_T isn_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002576
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002577 switch (**arg)
2578 {
2579 case 'g': isn_type = ISN_LOADGDICT; break;
2580 case 'w': isn_type = ISN_LOADWDICT; break;
2581 case 't': isn_type = ISN_LOADTDICT; break;
2582 case 'b': isn_type = ISN_LOADBDICT; break;
2583 default:
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002584 semsg(_(e_namespace_not_supported_str), *arg);
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002585 goto theend;
2586 }
2587 if (generate_instr_type(cctx, isn_type, &t_dict_any) == NULL)
2588 goto theend;
2589 res = OK;
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002590 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002591 else
2592 {
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002593 isntype_T isn_type = ISN_DROP;
2594
2595 name = vim_strnsave(*arg + 2, end - (*arg + 2));
2596 if (name == NULL)
2597 return FAIL;
2598
2599 switch (**arg)
2600 {
2601 case 'v': res = generate_LOADV(cctx, name, error);
2602 break;
2603 case 's': res = compile_load_scriptvar(cctx, name,
2604 NULL, NULL, error);
2605 break;
Bram Moolenaar03290b82020-12-19 16:30:44 +01002606 case 'g': if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
2607 isn_type = ISN_LOADG;
2608 else
2609 {
2610 isn_type = ISN_LOADAUTO;
2611 vim_free(name);
2612 name = vim_strnsave(*arg, end - *arg);
2613 if (name == NULL)
2614 return FAIL;
2615 }
2616 break;
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002617 case 'w': isn_type = ISN_LOADW; break;
2618 case 't': isn_type = ISN_LOADT; break;
2619 case 'b': isn_type = ISN_LOADB; break;
Bram Moolenaar918a4242020-12-06 14:37:08 +01002620 default: // cannot happen, just in case
2621 semsg(_(e_namespace_not_supported_str), *arg);
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002622 goto theend;
2623 }
2624 if (isn_type != ISN_DROP)
2625 {
2626 // Global, Buffer-local, Window-local and Tabpage-local
2627 // variables can be defined later, thus we don't check if it
2628 // exists, give error at runtime.
2629 res = generate_LOAD(cctx, isn_type, 0, name, &t_any);
2630 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002631 }
2632 }
2633 else
2634 {
2635 size_t len = end - *arg;
2636 int idx;
2637 int gen_load = FALSE;
Bram Moolenaarab360522021-01-10 14:02:28 +01002638 int gen_load_outer = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002639
2640 name = vim_strnsave(*arg, end - *arg);
2641 if (name == NULL)
2642 return FAIL;
2643
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002644 if (arg_exists(*arg, len, &idx, &type, &gen_load_outer, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002645 {
Bram Moolenaarab360522021-01-10 14:02:28 +01002646 if (gen_load_outer == 0)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002647 gen_load = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002648 }
2649 else
2650 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01002651 lvar_T lvar;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02002652
Bram Moolenaar709664c2020-12-12 14:33:41 +01002653 if (lookup_local(*arg, len, &lvar, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002654 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01002655 type = lvar.lv_type;
2656 idx = lvar.lv_idx;
Bram Moolenaarab360522021-01-10 14:02:28 +01002657 if (lvar.lv_from_outer != 0)
2658 gen_load_outer = lvar.lv_from_outer;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002659 else
2660 gen_load = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002661 }
2662 else
2663 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02002664 // "var" can be script-local even without using "s:" if it
Bram Moolenaar53900992020-08-22 19:02:02 +02002665 // already exists in a Vim9 script or when it's imported.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02002666 if (script_var_exists(*arg, len, TRUE, cctx) == OK
Bram Moolenaar53900992020-08-22 19:02:02 +02002667 || find_imported(name, 0, cctx) != NULL)
2668 res = compile_load_scriptvar(cctx, name, *arg, &end, FALSE);
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002669
Bram Moolenaar0f769812020-09-12 18:32:34 +02002670 // When evaluating an expression and the name starts with an
2671 // uppercase letter or "x:" it can be a user defined function.
Bram Moolenaar53900992020-08-22 19:02:02 +02002672 // TODO: this is just guessing
Bram Moolenaar0f769812020-09-12 18:32:34 +02002673 if (res == FAIL && is_expr
2674 && (ASCII_ISUPPER(*name) || name[1] == ':'))
Bram Moolenaara5565e42020-05-09 15:44:01 +02002675 res = generate_funcref(cctx, name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002676 }
2677 }
2678 if (gen_load)
2679 res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type);
Bram Moolenaarab360522021-01-10 14:02:28 +01002680 if (gen_load_outer > 0)
Bram Moolenaarfd777482020-08-12 19:42:01 +02002681 {
Bram Moolenaarab360522021-01-10 14:02:28 +01002682 res = generate_LOADOUTER(cctx, idx, gen_load_outer, type);
Bram Moolenaarfd777482020-08-12 19:42:01 +02002683 cctx->ctx_outer_used = TRUE;
2684 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002685 }
2686
2687 *arg = end;
2688
2689theend:
Bram Moolenaar599c89c2020-03-28 14:53:20 +01002690 if (res == FAIL && error && called_emsg == prev_called_emsg)
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002691 semsg(_(e_variable_not_found_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002692 vim_free(name);
2693 return res;
2694}
2695
2696/*
2697 * Compile the argument expressions.
2698 * "arg" points to just after the "(" and is advanced to after the ")"
2699 */
2700 static int
2701compile_arguments(char_u **arg, cctx_T *cctx, int *argcount)
2702{
Bram Moolenaar2c330432020-04-13 14:41:35 +02002703 char_u *p = *arg;
2704 char_u *whitep = *arg;
Bram Moolenaar10e4f122020-09-20 22:43:52 +02002705 int must_end = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002706
Bram Moolenaare6085c52020-04-12 20:19:16 +02002707 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002708 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002709 if (may_get_next_line(whitep, &p, cctx) == FAIL)
2710 goto failret;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002711 if (*p == ')')
2712 {
2713 *arg = p + 1;
2714 return OK;
2715 }
Bram Moolenaar10e4f122020-09-20 22:43:52 +02002716 if (must_end)
2717 {
2718 semsg(_(e_missing_comma_before_argument_str), p);
2719 return FAIL;
2720 }
Bram Moolenaare6085c52020-04-12 20:19:16 +02002721
Bram Moolenaara5565e42020-05-09 15:44:01 +02002722 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002723 return FAIL;
2724 ++*argcount;
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002725
2726 if (*p != ',' && *skipwhite(p) == ',')
2727 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02002728 semsg(_(e_no_white_space_allowed_before_str), ",");
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002729 p = skipwhite(p);
2730 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002731 if (*p == ',')
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002732 {
2733 ++p;
Bram Moolenaare6085c52020-04-12 20:19:16 +02002734 if (*p != NUL && !VIM_ISWHITE(*p))
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02002735 semsg(_(e_white_space_required_after_str), ",");
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002736 }
Bram Moolenaar10e4f122020-09-20 22:43:52 +02002737 else
2738 must_end = TRUE;
Bram Moolenaar2c330432020-04-13 14:41:35 +02002739 whitep = p;
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002740 p = skipwhite(p);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002741 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02002742failret:
Bram Moolenaare6085c52020-04-12 20:19:16 +02002743 emsg(_(e_missing_close));
2744 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002745}
2746
2747/*
2748 * Compile a function call: name(arg1, arg2)
2749 * "arg" points to "name", "arg + varlen" to the "(".
2750 * "argcount_init" is 1 for "value->method()"
2751 * Instructions:
2752 * EVAL arg1
2753 * EVAL arg2
2754 * BCALL / DCALL / UCALL
2755 */
2756 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02002757compile_call(
2758 char_u **arg,
2759 size_t varlen,
2760 cctx_T *cctx,
2761 ppconst_T *ppconst,
2762 int argcount_init)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002763{
2764 char_u *name = *arg;
Bram Moolenaar0b76ad52020-01-31 21:20:51 +01002765 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002766 int argcount = argcount_init;
2767 char_u namebuf[100];
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002768 char_u fname_buf[FLEN_FIXED + 1];
2769 char_u *tofree = NULL;
2770 int error = FCERR_NONE;
Bram Moolenaarb3a01942020-11-17 19:56:09 +01002771 ufunc_T *ufunc = NULL;
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002772 int res = FAIL;
Bram Moolenaara1773442020-08-12 15:21:22 +02002773 int is_autoload;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002774
Bram Moolenaara5565e42020-05-09 15:44:01 +02002775 // we can evaluate "has('name')" at compile time
2776 if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0)
2777 {
2778 char_u *s = skipwhite(*arg + varlen + 1);
2779 typval_T argvars[2];
2780
2781 argvars[0].v_type = VAR_UNKNOWN;
2782 if (*s == '"')
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02002783 (void)eval_string(&s, &argvars[0], TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02002784 else if (*s == '\'')
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02002785 (void)eval_lit_string(&s, &argvars[0], TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02002786 s = skipwhite(s);
Bram Moolenaar8cebd432020-11-08 12:49:47 +01002787 if (*s == ')' && argvars[0].v_type == VAR_STRING
2788 && !dynamic_feature(argvars[0].vval.v_string))
Bram Moolenaara5565e42020-05-09 15:44:01 +02002789 {
2790 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used];
2791
2792 *arg = s + 1;
2793 argvars[1].v_type = VAR_UNKNOWN;
2794 tv->v_type = VAR_NUMBER;
2795 tv->vval.v_number = 0;
2796 f_has(argvars, tv);
2797 clear_tv(&argvars[0]);
2798 ++ppconst->pp_used;
2799 return OK;
2800 }
Bram Moolenaar497f76b2020-05-09 16:44:22 +02002801 clear_tv(&argvars[0]);
Bram Moolenaara5565e42020-05-09 15:44:01 +02002802 }
2803
2804 if (generate_ppconst(cctx, ppconst) == FAIL)
2805 return FAIL;
2806
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002807 if (varlen >= sizeof(namebuf))
2808 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002809 semsg(_(e_name_too_long_str), name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002810 return FAIL;
2811 }
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002812 vim_strncpy(namebuf, *arg, varlen);
2813 name = fname_trans_sid(namebuf, fname_buf, &tofree, &error);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002814
2815 *arg = skipwhite(*arg + varlen + 1);
2816 if (compile_arguments(arg, cctx, &argcount) == FAIL)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002817 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002818
Bram Moolenaar03290b82020-12-19 16:30:44 +01002819 is_autoload = vim_strchr(name, AUTOLOAD_CHAR) != NULL;
Bram Moolenaara1773442020-08-12 15:21:22 +02002820 if (ASCII_ISLOWER(*name) && name[1] != ':' && !is_autoload)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002821 {
2822 int idx;
2823
2824 // builtin function
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002825 idx = find_internal_func(name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002826 if (idx >= 0)
Bram Moolenaar1dcae592020-10-19 19:02:42 +02002827 {
2828 if (STRCMP(name, "add") == 0 && argcount == 2)
2829 {
2830 garray_T *stack = &cctx->ctx_type_stack;
2831 type_T *type = ((type_T **)stack->ga_data)[
2832 stack->ga_len - 2];
2833
Bram Moolenaare88c8e82020-11-01 17:03:37 +01002834 // add() can be compiled to instructions if we know the type
Bram Moolenaar1dcae592020-10-19 19:02:42 +02002835 if (type->tt_type == VAR_LIST)
2836 {
2837 // inline "add(list, item)" so that the type can be checked
2838 res = generate_LISTAPPEND(cctx);
2839 idx = -1;
2840 }
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02002841 else if (type->tt_type == VAR_BLOB)
2842 {
2843 // inline "add(blob, nr)" so that the type can be checked
2844 res = generate_BLOBAPPEND(cctx);
2845 idx = -1;
2846 }
Bram Moolenaar1dcae592020-10-19 19:02:42 +02002847 }
2848
2849 if (idx >= 0)
2850 res = generate_BCALL(cctx, idx, argcount, argcount_init == 1);
2851 }
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002852 else
2853 semsg(_(e_unknownfunc), namebuf);
2854 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002855 }
2856
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002857 // An argument or local variable can be a function reference, this
2858 // overrules a function name.
Bram Moolenaar709664c2020-12-12 14:33:41 +01002859 if (lookup_local(namebuf, varlen, NULL, cctx) == FAIL
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002860 && arg_exists(namebuf, varlen, NULL, NULL, NULL, cctx) != OK)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002861 {
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002862 // If we can find the function by name generate the right call.
2863 // Skip global functions here, a local funcref takes precedence.
2864 ufunc = find_func(name, FALSE, cctx);
2865 if (ufunc != NULL && !func_is_global(ufunc))
2866 {
2867 res = generate_CALL(cctx, ufunc, argcount);
2868 goto theend;
2869 }
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002870 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002871
2872 // If the name is a variable, load it and use PCALL.
Bram Moolenaara26b9702020-04-18 19:53:28 +02002873 // Not for g:Func(), we don't know if it is a variable or not.
Bram Moolenaara1773442020-08-12 15:21:22 +02002874 // Not for eome#Func(), it will be loaded later.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002875 p = namebuf;
Bram Moolenaara1773442020-08-12 15:21:22 +02002876 if (STRNCMP(namebuf, "g:", 2) != 0 && !is_autoload
Bram Moolenaar0f769812020-09-12 18:32:34 +02002877 && compile_load(&p, namebuf + varlen, cctx, FALSE, FALSE) == OK)
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002878 {
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002879 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar7e368202020-12-25 21:56:57 +01002880 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002881
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002882 res = generate_PCALL(cctx, argcount, namebuf, type, FALSE);
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002883 goto theend;
2884 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002885
Bram Moolenaar0f769812020-09-12 18:32:34 +02002886 // If we can find a global function by name generate the right call.
2887 if (ufunc != NULL)
2888 {
2889 res = generate_CALL(cctx, ufunc, argcount);
2890 goto theend;
2891 }
2892
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002893 // A global function may be defined only later. Need to figure out at
Bram Moolenaara0a9f432020-04-28 21:29:34 +02002894 // runtime. Also handles a FuncRef at runtime.
Bram Moolenaara1773442020-08-12 15:21:22 +02002895 if (STRNCMP(namebuf, "g:", 2) == 0 || is_autoload)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002896 res = generate_UCALL(cctx, name, argcount);
2897 else
2898 semsg(_(e_unknownfunc), namebuf);
Bram Moolenaar5cab73f2020-02-06 19:25:19 +01002899
2900theend:
2901 vim_free(tofree);
2902 return res;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002903}
2904
2905// like NAMESPACE_CHAR but with 'a' and 'l'.
2906#define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw"
2907
2908/*
2909 * Find the end of a variable or function name. Unlike find_name_end() this
2910 * does not recognize magic braces.
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01002911 * When "use_namespace" is TRUE recognize "b:", "s:", etc.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002912 * Return a pointer to just after the name. Equal to "arg" if there is no
2913 * valid name.
2914 */
Bram Moolenaar2bede172020-11-19 18:53:18 +01002915 char_u *
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01002916to_name_end(char_u *arg, int use_namespace)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002917{
2918 char_u *p;
2919
2920 // Quick check for valid starting character.
2921 if (!eval_isnamec1(*arg))
2922 return arg;
2923
2924 for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p))
2925 // Include a namespace such as "s:var" and "v:var". But "n:" is not
2926 // and can be used in slice "[n:]".
2927 if (*p == ':' && (p != arg + 1
Bram Moolenaarbebaa0d2020-11-20 18:59:19 +01002928 || !use_namespace
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002929 || vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL))
2930 break;
2931 return p;
2932}
2933
2934/*
2935 * Like to_name_end() but also skip over a list or dict constant.
Bram Moolenaar1c991142020-07-04 13:15:31 +02002936 * This intentionally does not handle line continuation.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002937 */
2938 char_u *
2939to_name_const_end(char_u *arg)
2940{
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01002941 char_u *p = to_name_end(arg, TRUE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002942 typval_T rettv;
2943
2944 if (p == arg && *arg == '[')
2945 {
2946
2947 // Can be "[1, 2, 3]->Func()".
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02002948 if (eval_list(&p, &rettv, NULL, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002949 p = arg;
2950 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002951 return p;
2952}
2953
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002954/*
2955 * parse a list: [expr, expr]
2956 * "*arg" points to the '['.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002957 * ppconst->pp_is_const is set if all items are a constant.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002958 */
2959 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002960compile_list(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002961{
2962 char_u *p = skipwhite(*arg + 1);
Bram Moolenaar2c330432020-04-13 14:41:35 +02002963 char_u *whitep = *arg + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002964 int count = 0;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002965 int is_const;
2966 int is_all_const = TRUE; // reset when non-const encountered
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002967
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002968 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002969 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002970 if (may_get_next_line(whitep, &p, cctx) == FAIL)
Bram Moolenaara30590d2020-03-28 22:06:23 +01002971 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002972 semsg(_(e_list_end), *arg);
2973 return FAIL;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002974 }
Bram Moolenaardb199212020-08-12 18:01:53 +02002975 if (*p == ',')
2976 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02002977 semsg(_(e_no_white_space_allowed_before_str), ",");
Bram Moolenaardb199212020-08-12 18:01:53 +02002978 return FAIL;
2979 }
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002980 if (*p == ']')
2981 {
2982 ++p;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002983 break;
Bram Moolenaara30590d2020-03-28 22:06:23 +01002984 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002985 if (compile_expr0_ext(&p, cctx, &is_const) == FAIL)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02002986 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002987 if (!is_const)
2988 is_all_const = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002989 ++count;
2990 if (*p == ',')
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02002991 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002992 ++p;
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02002993 if (*p != ']' && !IS_WHITE_OR_NUL(*p))
2994 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02002995 semsg(_(e_white_space_required_after_str), ",");
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02002996 return FAIL;
2997 }
2998 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02002999 whitep = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003000 p = skipwhite(p);
3001 }
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003002 *arg = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003003
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003004 ppconst->pp_is_const = is_all_const;
3005 return generate_NEWLIST(cctx, count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003006}
3007
3008/*
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003009 * Parse a lambda: "(arg, arg) => expr"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003010 * "*arg" points to the '{'.
Bram Moolenaare462f522020-12-27 14:43:30 +01003011 * Returns OK/FAIL when a lambda is recognized, NOTDONE if it's not a lambda.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003012 */
3013 static int
3014compile_lambda(char_u **arg, cctx_T *cctx)
3015{
Bram Moolenaare462f522020-12-27 14:43:30 +01003016 int r;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003017 typval_T rettv;
3018 ufunc_T *ufunc;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003019 evalarg_T evalarg;
3020
3021 CLEAR_FIELD(evalarg);
3022 evalarg.eval_flags = EVAL_EVALUATE;
3023 evalarg.eval_cctx = cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003024
3025 // Get the funcref in "rettv".
Bram Moolenaare462f522020-12-27 14:43:30 +01003026 r = get_lambda_tv(arg, &rettv, TRUE, &evalarg);
3027 if (r != OK)
Bram Moolenaar2ea79ad2020-10-18 23:32:13 +02003028 {
3029 clear_evalarg(&evalarg, NULL);
Bram Moolenaare462f522020-12-27 14:43:30 +01003030 return r;
Bram Moolenaar2ea79ad2020-10-18 23:32:13 +02003031 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01003032
Bram Moolenaar65c44152020-12-24 15:14:01 +01003033 // "rettv" will now be a partial referencing the function.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003034 ufunc = rettv.vval.v_partial->pt_func;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003035 ++ufunc->uf_refcount;
3036 clear_tv(&rettv);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003037
Bram Moolenaar65c44152020-12-24 15:14:01 +01003038 // Compile the function into instructions.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02003039 compile_def_function(ufunc, TRUE, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003040
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02003041 clear_evalarg(&evalarg, NULL);
3042
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003043 if (ufunc->uf_def_status == UF_COMPILED)
Bram Moolenaar5a849da2020-08-08 16:47:30 +02003044 {
3045 // The return type will now be known.
3046 set_function_type(ufunc);
3047
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003048 // The function reference count will be 1. When the ISN_FUNCREF
3049 // instruction is deleted the reference count is decremented and the
3050 // function is freed.
Bram Moolenaar5a849da2020-08-08 16:47:30 +02003051 return generate_FUNCREF(cctx, ufunc);
3052 }
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003053
3054 func_ptr_unref(ufunc);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003055 return FAIL;
3056}
3057
3058/*
Bram Moolenaare0de1712020-12-02 17:36:54 +01003059 * parse a dict: {key: val, [key]: val}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003060 * "*arg" points to the '{'.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003061 * ppconst->pp_is_const is set if all item values are a constant.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003062 */
3063 static int
Bram Moolenaare0de1712020-12-02 17:36:54 +01003064compile_dict(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003065{
3066 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaarf1a23682020-07-13 18:55:48 +02003067 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003068 int count = 0;
3069 dict_T *d = dict_alloc();
3070 dictitem_T *item;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003071 char_u *whitep = *arg + 1;
Bram Moolenaar2c330432020-04-13 14:41:35 +02003072 char_u *p;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003073 int is_const;
3074 int is_all_const = TRUE; // reset when non-const encountered
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003075
3076 if (d == NULL)
3077 return FAIL;
Bram Moolenaard62d87d2021-01-04 17:40:12 +01003078 if (generate_ppconst(cctx, ppconst) == FAIL)
3079 return FAIL;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003080 for (;;)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003081 {
Bram Moolenaar2bede172020-11-19 18:53:18 +01003082 char_u *key = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003083
Bram Moolenaar23c55272020-06-21 16:58:13 +02003084 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003085 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003086 *arg = NULL;
3087 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003088 }
3089
3090 if (**arg == '}')
3091 break;
3092
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003093 if (**arg == '[')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003094 {
Bram Moolenaar2bede172020-11-19 18:53:18 +01003095 isn_T *isn;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003096
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003097 // {[expr]: value} uses an evaluated key.
Bram Moolenaare0de1712020-12-02 17:36:54 +01003098 *arg = skipwhite(*arg + 1);
Bram Moolenaara5565e42020-05-09 15:44:01 +02003099 if (compile_expr0(arg, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003100 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003101 isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
3102 if (isn->isn_type == ISN_PUSHS)
3103 key = isn->isn_arg.string;
Bram Moolenaarf1a23682020-07-13 18:55:48 +02003104 else
3105 {
3106 type_T *keytype = ((type_T **)stack->ga_data)
Bram Moolenaar2bede172020-11-19 18:53:18 +01003107 [stack->ga_len - 1];
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003108 if (need_type(keytype, &t_string, -1, cctx,
Bram Moolenaar2bede172020-11-19 18:53:18 +01003109 FALSE, FALSE) == FAIL)
Bram Moolenaarf1a23682020-07-13 18:55:48 +02003110 return FAIL;
3111 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01003112 *arg = skipwhite(*arg);
3113 if (**arg != ']')
Bram Moolenaar2bede172020-11-19 18:53:18 +01003114 {
Bram Moolenaare0de1712020-12-02 17:36:54 +01003115 emsg(_(e_missing_matching_bracket_after_dict_key));
3116 return FAIL;
Bram Moolenaar2bede172020-11-19 18:53:18 +01003117 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01003118 ++*arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003119 }
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01003120 else
3121 {
3122 // {"name": value},
3123 // {'name': value},
3124 // {name: value} use "name" as a literal key
3125 key = get_literal_key(arg);
3126 if (key == NULL)
3127 return FAIL;
3128 if (generate_PUSHS(cctx, key) == FAIL)
3129 return FAIL;
3130 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003131
3132 // Check for duplicate keys, if using string keys.
3133 if (key != NULL)
3134 {
3135 item = dict_find(d, key, -1);
3136 if (item != NULL)
3137 {
3138 semsg(_(e_duplicate_key), key);
3139 goto failret;
3140 }
3141 item = dictitem_alloc(key);
3142 if (item != NULL)
3143 {
3144 item->di_tv.v_type = VAR_UNKNOWN;
3145 item->di_tv.v_lock = 0;
3146 if (dict_add(d, item) == FAIL)
3147 dictitem_free(item);
3148 }
3149 }
3150
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003151 if (**arg != ':')
3152 {
Bram Moolenaar17a836c2020-08-12 17:35:58 +02003153 if (*skipwhite(*arg) == ':')
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02003154 semsg(_(e_no_white_space_allowed_before_str), ":");
Bram Moolenaar17a836c2020-08-12 17:35:58 +02003155 else
3156 semsg(_(e_missing_dict_colon), *arg);
3157 return FAIL;
3158 }
3159 whitep = *arg + 1;
3160 if (!IS_WHITE_OR_NUL(*whitep))
3161 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02003162 semsg(_(e_white_space_required_after_str), ":");
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003163 return FAIL;
3164 }
3165
Bram Moolenaar23c55272020-06-21 16:58:13 +02003166 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003167 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003168 *arg = NULL;
3169 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003170 }
3171
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003172 if (compile_expr0_ext(arg, cctx, &is_const) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003173 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003174 if (!is_const)
3175 is_all_const = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003176 ++count;
3177
Bram Moolenaar2c330432020-04-13 14:41:35 +02003178 whitep = *arg;
Bram Moolenaar23c55272020-06-21 16:58:13 +02003179 if (may_get_next_line(whitep, arg, cctx) == FAIL)
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003180 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003181 *arg = NULL;
3182 goto failret;
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003183 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003184 if (**arg == '}')
3185 break;
3186 if (**arg != ',')
3187 {
3188 semsg(_(e_missing_dict_comma), *arg);
3189 goto failret;
3190 }
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02003191 if (IS_WHITE_OR_NUL(*whitep))
3192 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02003193 semsg(_(e_no_white_space_allowed_before_str), ",");
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02003194 return FAIL;
3195 }
Bram Moolenaar2c330432020-04-13 14:41:35 +02003196 whitep = *arg + 1;
Bram Moolenaar9a13e182020-10-19 21:45:07 +02003197 if (!IS_WHITE_OR_NUL(*whitep))
3198 {
3199 semsg(_(e_white_space_required_after_str), ",");
3200 return FAIL;
3201 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003202 *arg = skipwhite(*arg + 1);
3203 }
3204
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003205 *arg = *arg + 1;
3206
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003207 // Allow for following comment, after at least one space.
Bram Moolenaar2c330432020-04-13 14:41:35 +02003208 p = skipwhite(*arg);
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003209 if (VIM_ISWHITE(**arg) && vim9_comment_start(p))
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003210 *arg += STRLEN(*arg);
3211
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003212 dict_unref(d);
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003213 ppconst->pp_is_const = is_all_const;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003214 return generate_NEWDICT(cctx, count);
3215
3216failret:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003217 if (*arg == NULL)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02003218 {
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003219 semsg(_(e_missing_dict_end), _("[end of lines]"));
Bram Moolenaar44aefff2020-10-05 19:23:59 +02003220 *arg = (char_u *)"";
3221 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003222 dict_unref(d);
3223 return FAIL;
3224}
3225
3226/*
3227 * Compile "&option".
3228 */
3229 static int
3230compile_get_option(char_u **arg, cctx_T *cctx)
3231{
3232 typval_T rettv;
3233 char_u *start = *arg;
3234 int ret;
3235
3236 // parse the option and get the current value to get the type.
3237 rettv.v_type = VAR_UNKNOWN;
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003238 ret = eval_option(arg, &rettv, TRUE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003239 if (ret == OK)
3240 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003241 // include the '&' in the name, eval_option() expects it.
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01003242 char_u *name = vim_strnsave(start, *arg - start);
3243 type_T *type = rettv.v_type == VAR_BOOL ? &t_bool
3244 : rettv.v_type == VAR_NUMBER ? &t_number : &t_string;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003245
3246 ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
3247 vim_free(name);
3248 }
3249 clear_tv(&rettv);
3250
3251 return ret;
3252}
3253
3254/*
3255 * Compile "$VAR".
3256 */
3257 static int
3258compile_get_env(char_u **arg, cctx_T *cctx)
3259{
3260 char_u *start = *arg;
3261 int len;
3262 int ret;
3263 char_u *name;
3264
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003265 ++*arg;
3266 len = get_env_len(arg);
3267 if (len == 0)
3268 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003269 semsg(_(e_syntax_error_at_str), start - 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003270 return FAIL;
3271 }
3272
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003273 // include the '$' in the name, eval_env_var() expects it.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003274 name = vim_strnsave(start, len + 1);
3275 ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string);
3276 vim_free(name);
3277 return ret;
3278}
3279
3280/*
3281 * Compile "@r".
3282 */
3283 static int
3284compile_get_register(char_u **arg, cctx_T *cctx)
3285{
3286 int ret;
3287
3288 ++*arg;
3289 if (**arg == NUL)
3290 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003291 semsg(_(e_syntax_error_at_str), *arg - 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003292 return FAIL;
3293 }
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02003294 if (!valid_yank_reg(**arg, FALSE))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003295 {
3296 emsg_invreg(**arg);
3297 return FAIL;
3298 }
3299 ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string);
3300 ++*arg;
3301 return ret;
3302}
3303
3304/*
3305 * Apply leading '!', '-' and '+' to constant "rettv".
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003306 * When "numeric_only" is TRUE do not apply '!'.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003307 */
3308 static int
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003309apply_leader(typval_T *rettv, int numeric_only, char_u *start, char_u **end)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003310{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003311 char_u *p = *end;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003312
3313 // this works from end to start
3314 while (p > start)
3315 {
3316 --p;
3317 if (*p == '-' || *p == '+')
3318 {
3319 // only '-' has an effect, for '+' we only check the type
3320#ifdef FEAT_FLOAT
3321 if (rettv->v_type == VAR_FLOAT)
3322 {
3323 if (*p == '-')
3324 rettv->vval.v_float = -rettv->vval.v_float;
3325 }
3326 else
3327#endif
3328 {
3329 varnumber_T val;
3330 int error = FALSE;
3331
3332 // tv_get_number_chk() accepts a string, but we don't want that
3333 // here
3334 if (check_not_string(rettv) == FAIL)
3335 return FAIL;
3336 val = tv_get_number_chk(rettv, &error);
3337 clear_tv(rettv);
3338 if (error)
3339 return FAIL;
3340 if (*p == '-')
3341 val = -val;
3342 rettv->v_type = VAR_NUMBER;
3343 rettv->vval.v_number = val;
3344 }
3345 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003346 else if (numeric_only)
3347 {
3348 ++p;
3349 break;
3350 }
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003351 else if (*p == '!')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003352 {
3353 int v = tv2bool(rettv);
3354
3355 // '!' is permissive in the type.
3356 clear_tv(rettv);
3357 rettv->v_type = VAR_BOOL;
3358 rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE;
3359 }
3360 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003361 *end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003362 return OK;
3363}
3364
3365/*
3366 * Recognize v: variables that are constants and set "rettv".
3367 */
3368 static void
3369get_vim_constant(char_u **arg, typval_T *rettv)
3370{
3371 if (STRNCMP(*arg, "v:true", 6) == 0)
3372 {
3373 rettv->v_type = VAR_BOOL;
3374 rettv->vval.v_number = VVAL_TRUE;
3375 *arg += 6;
3376 }
3377 else if (STRNCMP(*arg, "v:false", 7) == 0)
3378 {
3379 rettv->v_type = VAR_BOOL;
3380 rettv->vval.v_number = VVAL_FALSE;
3381 *arg += 7;
3382 }
3383 else if (STRNCMP(*arg, "v:null", 6) == 0)
3384 {
3385 rettv->v_type = VAR_SPECIAL;
3386 rettv->vval.v_number = VVAL_NULL;
3387 *arg += 6;
3388 }
3389 else if (STRNCMP(*arg, "v:none", 6) == 0)
3390 {
3391 rettv->v_type = VAR_SPECIAL;
3392 rettv->vval.v_number = VVAL_NONE;
3393 *arg += 6;
3394 }
3395}
3396
Bram Moolenaar657137c2021-01-09 15:45:23 +01003397 exprtype_T
Bram Moolenaar61a89812020-05-07 16:58:17 +02003398get_compare_type(char_u *p, int *len, int *type_is)
3399{
Bram Moolenaar657137c2021-01-09 15:45:23 +01003400 exprtype_T type = EXPR_UNKNOWN;
Bram Moolenaar61a89812020-05-07 16:58:17 +02003401 int i;
3402
3403 switch (p[0])
3404 {
3405 case '=': if (p[1] == '=')
3406 type = EXPR_EQUAL;
3407 else if (p[1] == '~')
3408 type = EXPR_MATCH;
3409 break;
3410 case '!': if (p[1] == '=')
3411 type = EXPR_NEQUAL;
3412 else if (p[1] == '~')
3413 type = EXPR_NOMATCH;
3414 break;
3415 case '>': if (p[1] != '=')
3416 {
3417 type = EXPR_GREATER;
3418 *len = 1;
3419 }
3420 else
3421 type = EXPR_GEQUAL;
3422 break;
3423 case '<': if (p[1] != '=')
3424 {
3425 type = EXPR_SMALLER;
3426 *len = 1;
3427 }
3428 else
3429 type = EXPR_SEQUAL;
3430 break;
3431 case 'i': if (p[1] == 's')
3432 {
3433 // "is" and "isnot"; but not a prefix of a name
3434 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't')
3435 *len = 5;
3436 i = p[*len];
3437 if (!isalnum(i) && i != '_')
3438 {
3439 type = *len == 2 ? EXPR_IS : EXPR_ISNOT;
3440 *type_is = TRUE;
3441 }
3442 }
3443 break;
3444 }
3445 return type;
3446}
3447
3448/*
Bram Moolenaar7e368202020-12-25 21:56:57 +01003449 * Skip over an expression, ignoring most errors.
3450 */
3451 static void
3452skip_expr_cctx(char_u **arg, cctx_T *cctx)
3453{
3454 evalarg_T evalarg;
3455
3456 CLEAR_FIELD(evalarg);
3457 evalarg.eval_cctx = cctx;
3458 skip_expr(arg, &evalarg);
3459}
3460
3461/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003462 * Compile code to apply '-', '+' and '!'.
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003463 * When "numeric_only" is TRUE do not apply '!'.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003464 */
3465 static int
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003466compile_leader(cctx_T *cctx, int numeric_only, char_u *start, char_u **end)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003467{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003468 char_u *p = *end;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003469
3470 // this works from end to start
3471 while (p > start)
3472 {
3473 --p;
Bram Moolenaar79cdf802020-11-18 17:39:05 +01003474 while (VIM_ISWHITE(*p))
3475 --p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003476 if (*p == '-' || *p == '+')
3477 {
3478 int negate = *p == '-';
3479 isn_T *isn;
3480
3481 // TODO: check type
3482 while (p > start && (p[-1] == '-' || p[-1] == '+'))
3483 {
3484 --p;
3485 if (*p == '-')
3486 negate = !negate;
3487 }
3488 // only '-' has an effect, for '+' we only check the type
3489 if (negate)
3490 isn = generate_instr(cctx, ISN_NEGATENR);
3491 else
3492 isn = generate_instr(cctx, ISN_CHECKNR);
3493 if (isn == NULL)
3494 return FAIL;
3495 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003496 else if (numeric_only)
3497 {
3498 ++p;
3499 break;
3500 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003501 else
3502 {
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003503 int invert = *p == '!';
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003504
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003505 while (p > start && (p[-1] == '!' || VIM_ISWHITE(p[-1])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003506 {
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003507 if (p[-1] == '!')
3508 invert = !invert;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003509 --p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003510 }
3511 if (generate_2BOOL(cctx, invert) == FAIL)
3512 return FAIL;
3513 }
3514 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003515 *end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003516 return OK;
3517}
3518
3519/*
Bram Moolenaar7e368202020-12-25 21:56:57 +01003520 * Compile "(expression)": recursive!
3521 * Return FAIL/OK.
3522 */
3523 static int
3524compile_parenthesis(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
3525{
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003526 int ret;
Bram Moolenaar7e368202020-12-25 21:56:57 +01003527
3528 *arg = skipwhite(*arg + 1);
3529 if (ppconst->pp_used <= PPSIZE - 10)
3530 {
3531 ret = compile_expr1(arg, cctx, ppconst);
3532 }
3533 else
3534 {
3535 // Not enough space in ppconst, flush constants.
3536 if (generate_ppconst(cctx, ppconst) == FAIL)
3537 return FAIL;
3538 ret = compile_expr0(arg, cctx);
3539 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003540 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
3541 return FAIL;
Bram Moolenaar7e368202020-12-25 21:56:57 +01003542 if (**arg == ')')
3543 ++*arg;
3544 else if (ret == OK)
3545 {
3546 emsg(_(e_missing_close));
3547 ret = FAIL;
3548 }
3549 return ret;
3550}
3551
3552/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003553 * Compile whatever comes after "name" or "name()".
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003554 * Advances "*arg" only when something was recognized.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003555 */
3556 static int
3557compile_subscript(
3558 char_u **arg,
3559 cctx_T *cctx,
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003560 char_u *start_leader,
3561 char_u **end_leader,
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003562 ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003563{
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003564 char_u *name_start = *end_leader;
3565
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003566 for (;;)
3567 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02003568 char_u *p = skipwhite(*arg);
3569
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003570 if (*p == NUL || (VIM_ISWHITE(**arg) && vim9_comment_start(p)))
Bram Moolenaar23c55272020-06-21 16:58:13 +02003571 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003572 char_u *next = peek_next_line_from_context(cctx);
Bram Moolenaar23c55272020-06-21 16:58:13 +02003573
3574 // If a following line starts with "->{" or "->X" advance to that
3575 // line, so that a line break before "->" is allowed.
Bram Moolenaara7eedf32020-07-10 21:50:41 +02003576 // Also if a following line starts with ".x".
3577 if (next != NULL &&
3578 ((next[0] == '-' && next[1] == '>'
3579 && (next[2] == '{' || ASCII_ISALPHA(next[2])))
Bram Moolenaarb13ab992020-07-27 21:43:28 +02003580 || (next[0] == '.' && eval_isdictc(next[1]))))
Bram Moolenaar23c55272020-06-21 16:58:13 +02003581 {
3582 next = next_line_from_context(cctx, TRUE);
3583 if (next == NULL)
3584 return FAIL;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003585 *arg = next;
3586 p = skipwhite(*arg);
Bram Moolenaar23c55272020-06-21 16:58:13 +02003587 }
3588 }
3589
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01003590 // Do not skip over white space to find the "(", "execute 'x' ()" is
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003591 // not a function call.
3592 if (**arg == '(')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003593 {
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003594 garray_T *stack = &cctx->ctx_type_stack;
3595 type_T *type;
3596 int argcount = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003597
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003598 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003599 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003600 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003601
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003602 // funcref(arg)
Bram Moolenaara0a9f432020-04-28 21:29:34 +02003603 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
3604
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003605 *arg = skipwhite(p + 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003606 if (compile_arguments(arg, cctx, &argcount) == FAIL)
3607 return FAIL;
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003608 if (generate_PCALL(cctx, argcount, name_start, type, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003609 return FAIL;
3610 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003611 else if (*p == '-' && p[1] == '>')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003612 {
Bram Moolenaar637cd7d2020-07-23 19:06:23 +02003613 char_u *pstart = p;
3614
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003615 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003616 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003617 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003618
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003619 // something->method()
3620 // Apply the '!', '-' and '+' first:
3621 // -1.0->func() works like (-1.0)->func()
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003622 if (compile_leader(cctx, TRUE, start_leader, end_leader) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003623 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003624
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003625 p += 2;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003626 *arg = skipwhite(p);
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003627 // No line break supported right after "->".
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003628 if (**arg == '(')
Bram Moolenaar65c44152020-12-24 15:14:01 +01003629 {
Bram Moolenaar7e368202020-12-25 21:56:57 +01003630 int argcount = 1;
3631 char_u *expr;
3632 garray_T *stack;
3633 type_T *type;
3634
3635 // Funcref call: list->(Refs[2])(arg)
3636 // or lambda: list->((arg) => expr)(arg)
3637 // Fist compile the arguments.
3638 expr = *arg;
3639 *arg = skipwhite(*arg + 1);
3640 skip_expr_cctx(arg, cctx);
3641 *arg = skipwhite(*arg);
3642 if (**arg != ')')
3643 {
3644 semsg(_(e_missing_paren), *arg);
3645 return FAIL;
3646 }
3647 ++*arg;
3648 if (**arg != '(')
3649 {
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003650 if (*skipwhite(*arg) == '(')
3651 emsg(_(e_nowhitespace));
3652 else
3653 semsg(_(e_missing_paren), *arg);
Bram Moolenaar7e368202020-12-25 21:56:57 +01003654 return FAIL;
3655 }
3656
3657 *arg = skipwhite(*arg + 1);
3658 if (compile_arguments(arg, cctx, &argcount) == FAIL)
3659 return FAIL;
3660
3661 // Compile the function expression.
3662 if (compile_parenthesis(&expr, cctx, ppconst) == FAIL)
3663 return FAIL;
3664
3665 stack = &cctx->ctx_type_stack;
3666 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
3667 if (generate_PCALL(cctx, argcount,
3668 (char_u *)"[expression]", type, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003669 return FAIL;
3670 }
3671 else
3672 {
3673 // method call: list->method()
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003674 p = *arg;
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003675 if (!eval_isnamec1(*p))
3676 {
Bram Moolenaar637cd7d2020-07-23 19:06:23 +02003677 semsg(_(e_trailing_arg), pstart);
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003678 return FAIL;
3679 }
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003680 if (ASCII_ISALPHA(*p) && p[1] == ':')
3681 p += 2;
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02003682 for ( ; eval_isnamec(*p); ++p)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003683 ;
3684 if (*p != '(')
3685 {
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003686 semsg(_(e_missing_paren), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003687 return FAIL;
3688 }
3689 // TODO: base value may not be the first argument
Bram Moolenaara5565e42020-05-09 15:44:01 +02003690 if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003691 return FAIL;
3692 }
3693 }
Bram Moolenaarbadd8482020-07-31 22:38:17 +02003694 else if (**arg == '[')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003695 {
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003696 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaarb13af502020-02-17 21:12:08 +01003697 type_T **typep;
Bram Moolenaar56acb092020-08-16 14:48:19 +02003698 type_T *valtype;
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003699 vartype_T vtype;
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003700 int is_slice = FALSE;
Bram Moolenaarb13af502020-02-17 21:12:08 +01003701
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003702 // list index: list[123]
Bram Moolenaara6e67e42020-05-15 23:36:40 +02003703 // dict member: dict[key]
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02003704 // string index: text[123]
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003705 // TODO: blob index
3706 // TODO: more arguments
3707 // TODO: recognize list or dict at runtime
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003708 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003709 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003710 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003711
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003712 ++p;
Bram Moolenaara7eedf32020-07-10 21:50:41 +02003713 if (may_get_next_line_error(p, arg, cctx) == FAIL)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003714 return FAIL;
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003715 if (**arg == ':')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003716 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003717 // missing first index is equal to zero
3718 generate_PUSHNR(cctx, 0);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003719 }
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003720 else
3721 {
3722 if (compile_expr0(arg, cctx) == FAIL)
3723 return FAIL;
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003724 if (**arg == ':')
3725 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01003726 semsg(_(e_white_space_required_before_and_after_str_at_str),
3727 ":", *arg);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003728 return FAIL;
3729 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003730 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003731 return FAIL;
3732 *arg = skipwhite(*arg);
3733 }
3734 if (**arg == ':')
3735 {
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003736 is_slice = TRUE;
3737 ++*arg;
3738 if (!IS_WHITE_OR_NUL(**arg) && **arg != ']')
3739 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01003740 semsg(_(e_white_space_required_before_and_after_str_at_str),
3741 ":", *arg);
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003742 return FAIL;
3743 }
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003744 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003745 return FAIL;
3746 if (**arg == ']')
3747 // missing second index is equal to end of string
3748 generate_PUSHNR(cctx, -1);
3749 else
3750 {
3751 if (compile_expr0(arg, cctx) == FAIL)
Bram Moolenaar918a4242020-12-06 14:37:08 +01003752 return FAIL;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003753 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003754 return FAIL;
3755 *arg = skipwhite(*arg);
3756 }
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003757 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003758
3759 if (**arg != ']')
3760 {
3761 emsg(_(e_missbrac));
3762 return FAIL;
3763 }
Bram Moolenaarf2460a32020-02-07 22:09:54 +01003764 *arg = *arg + 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003765
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003766 // We can index a list and a dict. If we don't know the type
3767 // we can use the index value type.
3768 // TODO: If we don't know use an instruction to figure it out at
3769 // runtime.
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003770 typep = ((type_T **)stack->ga_data) + stack->ga_len
3771 - (is_slice ? 3 : 2);
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003772 vtype = (*typep)->tt_type;
Bram Moolenaar56acb092020-08-16 14:48:19 +02003773 valtype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
3774 // If the index is a string, the variable must be a Dict.
3775 if (*typep == &t_any && valtype == &t_string)
3776 vtype = VAR_DICT;
3777 if (vtype == VAR_STRING || vtype == VAR_LIST || vtype == VAR_BLOB)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003778 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003779 if (need_type(valtype, &t_number, -1, cctx,
3780 FALSE, FALSE) == FAIL)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003781 return FAIL;
3782 if (is_slice)
3783 {
3784 valtype = ((type_T **)stack->ga_data)[stack->ga_len - 2];
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003785 if (need_type(valtype, &t_number, -2, cctx,
3786 FALSE, FALSE) == FAIL)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003787 return FAIL;
3788 }
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003789 }
Bram Moolenaar56acb092020-08-16 14:48:19 +02003790
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003791 if (vtype == VAR_DICT)
3792 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003793 if (is_slice)
3794 {
3795 emsg(_(e_cannot_slice_dictionary));
3796 return FAIL;
3797 }
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003798 if ((*typep)->tt_type == VAR_DICT)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003799 {
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003800 *typep = (*typep)->tt_member;
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003801 if (*typep == &t_unknown)
3802 // empty dict was used
3803 *typep = &t_any;
3804 }
Bram Moolenaar7892b952020-07-20 22:09:34 +02003805 else
3806 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003807 if (need_type(*typep, &t_dict_any, -2, cctx,
3808 FALSE, FALSE) == FAIL)
Bram Moolenaar7892b952020-07-20 22:09:34 +02003809 return FAIL;
3810 *typep = &t_any;
3811 }
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003812 if (may_generate_2STRING(-1, cctx) == FAIL)
3813 return FAIL;
3814 if (generate_instr_drop(cctx, ISN_MEMBER, 1) == FAIL)
3815 return FAIL;
3816 }
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02003817 else if (vtype == VAR_STRING)
3818 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003819 *typep = &t_string;
3820 if ((is_slice
3821 ? generate_instr_drop(cctx, ISN_STRSLICE, 2)
3822 : generate_instr_drop(cctx, ISN_STRINDEX, 1)) == FAIL)
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02003823 return FAIL;
3824 }
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003825 else if (vtype == VAR_BLOB)
3826 {
3827 emsg("Sorry, blob index and slice not implemented yet");
3828 return FAIL;
3829 }
Bram Moolenaar6802cce2020-07-19 15:49:49 +02003830 else if (vtype == VAR_LIST || *typep == &t_any)
Bram Moolenaarb13af502020-02-17 21:12:08 +01003831 {
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003832 if (is_slice)
3833 {
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003834 if (generate_instr_drop(cctx,
3835 vtype == VAR_LIST ? ISN_LISTSLICE : ISN_ANYSLICE,
3836 2) == FAIL)
Bram Moolenaared591872020-08-15 22:14:53 +02003837 return FAIL;
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003838 }
Bram Moolenaared591872020-08-15 22:14:53 +02003839 else
3840 {
3841 if ((*typep)->tt_type == VAR_LIST)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003842 {
Bram Moolenaared591872020-08-15 22:14:53 +02003843 *typep = (*typep)->tt_member;
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003844 if (*typep == &t_unknown)
3845 // empty list was used
3846 *typep = &t_any;
3847 }
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003848 if (generate_instr_drop(cctx,
3849 vtype == VAR_LIST ? ISN_LISTINDEX : ISN_ANYINDEX,
3850 1) == FAIL)
Bram Moolenaared591872020-08-15 22:14:53 +02003851 return FAIL;
3852 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003853 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003854 else
3855 {
Bram Moolenaar56acb092020-08-16 14:48:19 +02003856 emsg(_(e_string_list_dict_or_blob_required));
Bram Moolenaarb13af502020-02-17 21:12:08 +01003857 return FAIL;
3858 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003859 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003860 else if (*p == '.' && p[1] != '.')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003861 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003862 // dictionary member: dict.name
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003863 if (generate_ppconst(cctx, ppconst) == FAIL)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003864 return FAIL;
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003865 ppconst->pp_is_const = FALSE;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003866
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003867 *arg = p + 1;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003868 if (may_get_next_line(*arg, arg, cctx) == FAIL)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02003869 {
3870 emsg(_(e_missing_name_after_dot));
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003871 return FAIL;
Bram Moolenaarc1f00662020-10-03 13:41:53 +02003872 }
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003873 p = *arg;
Bram Moolenaarb13ab992020-07-27 21:43:28 +02003874 if (eval_isdictc(*p))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003875 while (eval_isnamec(*p))
3876 MB_PTR_ADV(p);
3877 if (p == *arg)
3878 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003879 semsg(_(e_syntax_error_at_str), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003880 return FAIL;
3881 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02003882 if (generate_STRINGMEMBER(cctx, *arg, p - *arg) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003883 return FAIL;
3884 *arg = p;
3885 }
3886 else
3887 break;
3888 }
3889
3890 // TODO - see handle_subscript():
3891 // Turn "dict.Func" into a partial for "Func" bound to "dict".
3892 // Don't do this when "Func" is already a partial that was bound
3893 // explicitly (pt_auto is FALSE).
3894
3895 return OK;
3896}
3897
3898/*
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003899 * Compile an expression at "*arg" and add instructions to "cctx->ctx_instr".
3900 * "arg" is advanced until after the expression, skipping white space.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003901 *
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003902 * If the value is a constant "ppconst->pp_used" will be non-zero.
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003903 * Before instructions are generated, any values in "ppconst" will generated.
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003904 *
3905 * This is the compiling equivalent of eval1(), eval2(), etc.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003906 */
3907
3908/*
3909 * number number constant
3910 * 0zFFFFFFFF Blob constant
3911 * "string" string constant
3912 * 'string' literal string constant
3913 * &option-name option value
3914 * @r register contents
3915 * identifier variable value
3916 * function() function call
3917 * $VAR environment variable
3918 * (expression) nested expression
3919 * [expr, expr] List
Bram Moolenaare0de1712020-12-02 17:36:54 +01003920 * {key: val, [key]: val} Dictionary
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003921 *
3922 * Also handle:
3923 * ! in front logical NOT
3924 * - in front unary minus
3925 * + in front unary plus (ignored)
3926 * trailing (arg) funcref/partial call
3927 * trailing [] subscript in String or List
3928 * trailing .name entry in Dictionary
3929 * trailing ->name() method call
3930 */
3931 static int
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02003932compile_expr7(
3933 char_u **arg,
3934 cctx_T *cctx,
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003935 ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003936{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003937 char_u *start_leader, *end_leader;
3938 int ret = OK;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003939 typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used];
Bram Moolenaar1c747212020-05-09 18:28:34 +02003940 int used_before = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003941
Bram Moolenaar334a8b42020-10-19 16:07:42 +02003942 ppconst->pp_is_const = FALSE;
3943
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003944 /*
3945 * Skip '!', '-' and '+' characters. They are handled later.
3946 */
3947 start_leader = *arg;
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003948 if (eval_leader(arg, TRUE) == FAIL)
3949 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003950 end_leader = *arg;
3951
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003952 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003953 switch (**arg)
3954 {
3955 /*
3956 * Number constant.
3957 */
3958 case '0': // also for blob starting with 0z
3959 case '1':
3960 case '2':
3961 case '3':
3962 case '4':
3963 case '5':
3964 case '6':
3965 case '7':
3966 case '8':
3967 case '9':
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003968 case '.': if (eval_number(arg, rettv, TRUE, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003969 return FAIL;
Bram Moolenaar4301a722020-08-11 20:51:08 +02003970 // Apply "-" and "+" just before the number now, right to
3971 // left. Matters especially when "->" follows. Stops at
3972 // '!'.
3973 if (apply_leader(rettv, TRUE,
3974 start_leader, &end_leader) == FAIL)
3975 {
3976 clear_tv(rettv);
3977 return FAIL;
3978 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003979 break;
3980
3981 /*
3982 * String constant: "string".
3983 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003984 case '"': if (eval_string(arg, rettv, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003985 return FAIL;
3986 break;
3987
3988 /*
3989 * Literal string constant: 'str''ing'.
3990 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003991 case '\'': if (eval_lit_string(arg, rettv, TRUE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003992 return FAIL;
3993 break;
3994
3995 /*
3996 * Constant Vim variable.
3997 */
Bram Moolenaar7d131b02020-05-08 19:10:34 +02003998 case 'v': get_vim_constant(arg, rettv);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003999 ret = NOTDONE;
4000 break;
4001
4002 /*
Bram Moolenaara5565e42020-05-09 15:44:01 +02004003 * "true" constant
4004 */
4005 case 't': if (STRNCMP(*arg, "true", 4) == 0
4006 && !eval_isnamec((*arg)[4]))
4007 {
4008 *arg += 4;
4009 rettv->v_type = VAR_BOOL;
4010 rettv->vval.v_number = VVAL_TRUE;
4011 }
4012 else
4013 ret = NOTDONE;
4014 break;
4015
4016 /*
4017 * "false" constant
4018 */
4019 case 'f': if (STRNCMP(*arg, "false", 5) == 0
4020 && !eval_isnamec((*arg)[5]))
4021 {
4022 *arg += 5;
4023 rettv->v_type = VAR_BOOL;
4024 rettv->vval.v_number = VVAL_FALSE;
4025 }
4026 else
4027 ret = NOTDONE;
4028 break;
4029
4030 /*
Bram Moolenaar67977822021-01-03 21:53:53 +01004031 * "null" constant
4032 */
4033 case 'n': if (STRNCMP(*arg, "null", 4) == 0
4034 && !eval_isnamec((*arg)[5]))
4035 {
4036 *arg += 4;
4037 rettv->v_type = VAR_SPECIAL;
4038 rettv->vval.v_number = VVAL_NULL;
4039 }
4040 else
4041 ret = NOTDONE;
4042 break;
4043
4044 /*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004045 * List: [expr, expr]
4046 */
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004047 case '[': ret = compile_list(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004048 break;
4049
4050 /*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004051 * Dictionary: {'key': val, 'key': val}
4052 */
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01004053 case '{': ret = compile_dict(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004054 break;
4055
4056 /*
4057 * Option value: &name
4058 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004059 case '&': if (generate_ppconst(cctx, ppconst) == FAIL)
4060 return FAIL;
4061 ret = compile_get_option(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004062 break;
4063
4064 /*
4065 * Environment variable: $VAR.
4066 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004067 case '$': if (generate_ppconst(cctx, ppconst) == FAIL)
4068 return FAIL;
4069 ret = compile_get_env(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004070 break;
4071
4072 /*
4073 * Register contents: @r.
4074 */
Bram Moolenaar3fc71282020-08-21 20:43:17 +02004075 case '@': if (generate_ppconst(cctx, ppconst) == FAIL)
4076 return FAIL;
4077 ret = compile_get_register(arg, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004078 break;
4079 /*
4080 * nested expression: (expression).
Bram Moolenaar65c44152020-12-24 15:14:01 +01004081 * lambda: (arg, arg) => expr
4082 * funcref: (arg, arg) => { statement }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004083 */
Bram Moolenaare462f522020-12-27 14:43:30 +01004084 case '(': // if compile_lambda returns NOTDONE then it must be (expr)
4085 ret = compile_lambda(arg, cctx);
4086 if (ret == NOTDONE)
Bram Moolenaar7e368202020-12-25 21:56:57 +01004087 ret = compile_parenthesis(arg, cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004088 break;
4089
4090 default: ret = NOTDONE;
4091 break;
4092 }
4093 if (ret == FAIL)
4094 return FAIL;
4095
Bram Moolenaar1c747212020-05-09 18:28:34 +02004096 if (rettv->v_type != VAR_UNKNOWN && used_before == ppconst->pp_used)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004097 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02004098 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004099 clear_tv(rettv);
4100 else
4101 // A constant expression can possibly be handled compile time,
4102 // return the value instead of generating code.
4103 ++ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004104 }
4105 else if (ret == NOTDONE)
4106 {
4107 char_u *p;
4108 int r;
4109
4110 if (!eval_isnamec1(**arg))
4111 {
Bram Moolenaare4984292020-12-13 14:19:25 +01004112 if (ends_excmd(*skipwhite(*arg)))
4113 semsg(_(e_empty_expression_str), *arg);
4114 else
4115 semsg(_(e_name_expected_str), *arg);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004116 return FAIL;
4117 }
4118
4119 // "name" or "name()"
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01004120 p = to_name_end(*arg, TRUE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004121 if (*p == '(')
Bram Moolenaara5565e42020-05-09 15:44:01 +02004122 {
4123 r = compile_call(arg, p - *arg, cctx, ppconst, 0);
4124 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004125 else
Bram Moolenaara5565e42020-05-09 15:44:01 +02004126 {
4127 if (generate_ppconst(cctx, ppconst) == FAIL)
4128 return FAIL;
Bram Moolenaar0f769812020-09-12 18:32:34 +02004129 r = compile_load(arg, p, cctx, TRUE, TRUE);
Bram Moolenaara5565e42020-05-09 15:44:01 +02004130 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004131 if (r == FAIL)
4132 return FAIL;
4133 }
4134
Bram Moolenaar5c2fe642020-05-07 23:20:21 +02004135 // Handle following "[]", ".member", etc.
4136 // Then deal with prefixed '-', '+' and '!', if not done already.
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004137 if (compile_subscript(arg, cctx, start_leader, &end_leader,
Bram Moolenaara5565e42020-05-09 15:44:01 +02004138 ppconst) == FAIL)
4139 return FAIL;
4140 if (ppconst->pp_used > 0)
4141 {
4142 // apply the '!', '-' and '+' before the constant
4143 rettv = &ppconst->pp_tv[ppconst->pp_used - 1];
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004144 if (apply_leader(rettv, FALSE, start_leader, &end_leader) == FAIL)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004145 return FAIL;
4146 return OK;
4147 }
Bram Moolenaar59eccb92020-08-10 23:09:37 +02004148 if (compile_leader(cctx, FALSE, start_leader, &end_leader) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004149 return FAIL;
Bram Moolenaar5c2fe642020-05-07 23:20:21 +02004150 return OK;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004151}
4152
4153/*
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004154 * Give the "white on both sides" error, taking the operator from "p[len]".
4155 */
4156 void
4157error_white_both(char_u *op, int len)
4158{
4159 char_u buf[10];
4160
4161 vim_strncpy(buf, op, len);
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004162 semsg(_(e_white_space_required_before_and_after_str_at_str), buf, op);
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004163}
4164
4165/*
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004166 * <type>expr7: runtime type check / conversion
4167 */
4168 static int
4169compile_expr7t(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
4170{
4171 type_T *want_type = NULL;
4172
4173 // Recognize <type>
4174 if (**arg == '<' && eval_isnamec1((*arg)[1]))
4175 {
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004176 ++*arg;
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004177 want_type = parse_type(arg, cctx->ctx_type_list, TRUE);
4178 if (want_type == NULL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004179 return FAIL;
4180
4181 if (**arg != '>')
4182 {
4183 if (*skipwhite(*arg) == '>')
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02004184 semsg(_(e_no_white_space_allowed_before_str), ">");
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004185 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02004186 emsg(_(e_missing_gt));
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004187 return FAIL;
4188 }
4189 ++*arg;
Bram Moolenaar5afd0812021-01-03 18:33:13 +01004190 if (may_get_next_line_error(*arg, arg, cctx) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004191 return FAIL;
4192 }
4193
4194 if (compile_expr7(arg, cctx, ppconst) == FAIL)
4195 return FAIL;
4196
4197 if (want_type != NULL)
4198 {
4199 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaard1103582020-08-14 22:44:25 +02004200 type_T *actual;
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004201
Bram Moolenaard1103582020-08-14 22:44:25 +02004202 generate_ppconst(cctx, ppconst);
4203 actual = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar8b565c22020-08-30 23:24:20 +02004204 if (check_type(want_type, actual, FALSE, 0) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004205 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004206 if (need_type(actual, want_type, -1, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004207 return FAIL;
4208 }
4209 }
4210
4211 return OK;
4212}
4213
4214/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004215 * * number multiplication
4216 * / number division
4217 * % number modulo
4218 */
4219 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004220compile_expr6(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004221{
4222 char_u *op;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004223 char_u *next;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004224 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004225
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004226 // get the first expression
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004227 if (compile_expr7t(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004228 return FAIL;
4229
4230 /*
4231 * Repeat computing, until no "*", "/" or "%" is following.
4232 */
4233 for (;;)
4234 {
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004235 op = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004236 if (*op != '*' && *op != '/' && *op != '%')
4237 break;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004238 if (next != NULL)
4239 {
4240 *arg = next_line_from_context(cctx, TRUE);
4241 op = skipwhite(*arg);
4242 }
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004243
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004244 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[1]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004245 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004246 error_white_both(op, 1);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004247 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004248 }
Bram Moolenaar918a4242020-12-06 14:37:08 +01004249 if (may_get_next_line_error(op + 1, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004250 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004251
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004252 // get the second expression
Bram Moolenaar64d662d2020-08-09 19:02:50 +02004253 if (compile_expr7t(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004254 return FAIL;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004255
4256 if (ppconst->pp_used == ppconst_used + 2
4257 && ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
4258 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004259 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004260 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
4261 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004262 varnumber_T res = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004263
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004264 // both are numbers: compute the result
4265 switch (*op)
4266 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004267 case '*': res = tv1->vval.v_number * tv2->vval.v_number;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004268 break;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004269 case '/': res = tv1->vval.v_number / tv2->vval.v_number;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004270 break;
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004271 case '%': res = tv1->vval.v_number % tv2->vval.v_number;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004272 break;
4273 }
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004274 tv1->vval.v_number = res;
4275 --ppconst->pp_used;
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004276 }
4277 else
4278 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004279 generate_ppconst(cctx, ppconst);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004280 generate_two_op(cctx, op);
4281 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004282 }
4283
4284 return OK;
4285}
4286
4287/*
4288 * + number addition
4289 * - number subtraction
4290 * .. string concatenation
4291 */
4292 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004293compile_expr5(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004294{
4295 char_u *op;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004296 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004297 int oplen;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004298 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004299
4300 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02004301 if (compile_expr6(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004302 return FAIL;
4303
4304 /*
4305 * Repeat computing, until no "+", "-" or ".." is following.
4306 */
4307 for (;;)
4308 {
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004309 op = may_peek_next_line(cctx, *arg, &next);
4310 if (*op != '+' && *op != '-' && !(*op == '.' && *(op + 1) == '.'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004311 break;
4312 oplen = (*op == '.' ? 2 : 1);
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004313 if (next != NULL)
4314 {
4315 *arg = next_line_from_context(cctx, TRUE);
4316 op = skipwhite(*arg);
4317 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004318
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004319 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[oplen]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004320 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004321 error_white_both(op, oplen);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004322 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004323 }
4324
Bram Moolenaare0de1712020-12-02 17:36:54 +01004325 if (may_get_next_line_error(op + oplen, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004326 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004327
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004328 // get the second expression
Bram Moolenaara5565e42020-05-09 15:44:01 +02004329 if (compile_expr6(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004330 return FAIL;
4331
Bram Moolenaara5565e42020-05-09 15:44:01 +02004332 if (ppconst->pp_used == ppconst_used + 2
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004333 && (*op == '.'
Bram Moolenaara5565e42020-05-09 15:44:01 +02004334 ? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING
4335 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING)
4336 : (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
4337 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004338 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02004339 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
4340 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004341
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004342 // concat/subtract/add constant numbers
4343 if (*op == '+')
4344 tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number;
4345 else if (*op == '-')
4346 tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number;
4347 else
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004348 {
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004349 // concatenate constant strings
4350 char_u *s1 = tv1->vval.v_string;
4351 char_u *s2 = tv2->vval.v_string;
4352 size_t len1 = STRLEN(s1);
4353
4354 tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1));
4355 if (tv1->vval.v_string == NULL)
4356 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02004357 clear_ppconst(ppconst);
Bram Moolenaar7d131b02020-05-08 19:10:34 +02004358 return FAIL;
4359 }
4360 mch_memmove(tv1->vval.v_string, s1, len1);
4361 STRCPY(tv1->vval.v_string + len1, s2);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004362 vim_free(s1);
4363 vim_free(s2);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004364 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004365 --ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004366 }
4367 else
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004368 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02004369 generate_ppconst(cctx, ppconst);
Bram Moolenaarf0eefce2020-05-07 22:19:01 +02004370 if (*op == '.')
4371 {
4372 if (may_generate_2STRING(-2, cctx) == FAIL
4373 || may_generate_2STRING(-1, cctx) == FAIL)
4374 return FAIL;
4375 generate_instr_drop(cctx, ISN_CONCAT, 1);
4376 }
4377 else
4378 generate_two_op(cctx, op);
4379 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004380 }
4381
4382 return OK;
4383}
4384
4385/*
4386 * expr5a == expr5b
4387 * expr5a =~ expr5b
4388 * expr5a != expr5b
4389 * expr5a !~ expr5b
4390 * expr5a > expr5b
4391 * expr5a >= expr5b
4392 * expr5a < expr5b
4393 * expr5a <= expr5b
4394 * expr5a is expr5b
4395 * expr5a isnot expr5b
4396 *
4397 * Produces instructions:
4398 * EVAL expr5a Push result of "expr5a"
4399 * EVAL expr5b Push result of "expr5b"
4400 * COMPARE one of the compare instructions
4401 */
4402 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004403compile_expr4(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004404{
Bram Moolenaar657137c2021-01-09 15:45:23 +01004405 exprtype_T type = EXPR_UNKNOWN;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004406 char_u *p;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004407 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004408 int len = 2;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004409 int type_is = FALSE;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004410 int ppconst_used = ppconst->pp_used;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004411
4412 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02004413 if (compile_expr5(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004414 return FAIL;
4415
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004416 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar080457c2020-03-03 21:53:32 +01004417 type = get_compare_type(p, &len, &type_is);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004418
4419 /*
4420 * If there is a comparative operator, use it.
4421 */
4422 if (type != EXPR_UNKNOWN)
4423 {
4424 int ic = FALSE; // Default: do not ignore case
4425
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004426 if (next != NULL)
4427 {
4428 *arg = next_line_from_context(cctx, TRUE);
4429 p = skipwhite(*arg);
4430 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004431 if (type_is && (p[len] == '?' || p[len] == '#'))
4432 {
4433 semsg(_(e_invexpr2), *arg);
4434 return FAIL;
4435 }
4436 // extra question mark appended: ignore case
4437 if (p[len] == '?')
4438 {
4439 ic = TRUE;
4440 ++len;
4441 }
4442 // extra '#' appended: match case (ignored)
4443 else if (p[len] == '#')
4444 ++len;
4445 // nothing appended: match case
4446
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004447 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[len]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004448 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004449 error_white_both(p, len);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004450 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004451 }
4452
4453 // get the second variable
Bram Moolenaar918a4242020-12-06 14:37:08 +01004454 if (may_get_next_line_error(p + len, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004455 return FAIL;
4456
Bram Moolenaara5565e42020-05-09 15:44:01 +02004457 if (compile_expr5(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004458 return FAIL;
4459
Bram Moolenaara5565e42020-05-09 15:44:01 +02004460 if (ppconst->pp_used == ppconst_used + 2)
4461 {
4462 typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2];
4463 typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1];
4464 int ret;
4465
4466 // Both sides are a constant, compute the result now.
4467 // First check for a valid combination of types, this is more
4468 // strict than typval_compare().
Bram Moolenaar543e6f32020-07-10 22:45:38 +02004469 if (check_compare_types(type, tv1, tv2) == FAIL)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004470 ret = FAIL;
4471 else
4472 {
4473 ret = typval_compare(tv1, tv2, type, ic);
4474 tv1->v_type = VAR_BOOL;
4475 tv1->vval.v_number = tv1->vval.v_number
4476 ? VVAL_TRUE : VVAL_FALSE;
4477 clear_tv(tv2);
4478 --ppconst->pp_used;
4479 }
4480 return ret;
4481 }
4482
4483 generate_ppconst(cctx, ppconst);
4484 return generate_COMPARE(cctx, type, ic);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004485 }
4486
4487 return OK;
4488}
4489
Bram Moolenaar7f141552020-05-09 17:35:53 +02004490static int compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
4491
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004492/*
4493 * Compile || or &&.
4494 */
4495 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004496compile_and_or(
4497 char_u **arg,
4498 cctx_T *cctx,
4499 char *op,
4500 ppconst_T *ppconst,
4501 int ppconst_used UNUSED)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004502{
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004503 char_u *next;
4504 char_u *p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004505 int opchar = *op;
4506
4507 if (p[0] == opchar && p[1] == opchar)
4508 {
4509 garray_T *instr = &cctx->ctx_instr;
4510 garray_T end_ga;
4511
4512 /*
4513 * Repeat until there is no following "||" or "&&"
4514 */
4515 ga_init2(&end_ga, sizeof(int), 10);
4516 while (p[0] == opchar && p[1] == opchar)
4517 {
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004518 if (next != NULL)
4519 {
4520 *arg = next_line_from_context(cctx, TRUE);
4521 p = skipwhite(*arg);
4522 }
4523
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004524 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[2]))
4525 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004526 semsg(_(e_white_space_required_before_and_after_str_at_str),
4527 op, *arg);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004528 return FAIL;
4529 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004530
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004531 // TODO: use ppconst if the value is a constant and check
4532 // evaluating to bool
Bram Moolenaara5565e42020-05-09 15:44:01 +02004533 generate_ppconst(cctx, ppconst);
4534
Bram Moolenaarea2d4072020-11-12 12:08:51 +01004535 // Every part must evaluate to a bool.
4536 if (bool_on_stack(cctx) == FAIL)
4537 {
4538 ga_clear(&end_ga);
4539 return FAIL;
4540 }
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004541
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004542 if (ga_grow(&end_ga, 1) == FAIL)
4543 {
4544 ga_clear(&end_ga);
4545 return FAIL;
4546 }
4547 *(((int *)end_ga.ga_data) + end_ga.ga_len) = instr->ga_len;
4548 ++end_ga.ga_len;
4549 generate_JUMP(cctx, opchar == '|'
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004550 ? JUMP_IF_COND_TRUE : JUMP_IF_COND_FALSE, 0);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004551
4552 // eval the next expression
Bram Moolenaar918a4242020-12-06 14:37:08 +01004553 if (may_get_next_line_error(p + 2, arg, cctx) == FAIL)
Bram Moolenaar8bb0f542020-12-06 16:03:55 +01004554 {
4555 ga_clear(&end_ga);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004556 return FAIL;
Bram Moolenaar8bb0f542020-12-06 16:03:55 +01004557 }
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004558
Bram Moolenaara5565e42020-05-09 15:44:01 +02004559 if ((opchar == '|' ? compile_expr3(arg, cctx, ppconst)
4560 : compile_expr4(arg, cctx, ppconst)) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004561 {
4562 ga_clear(&end_ga);
4563 return FAIL;
4564 }
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004565
4566 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004567 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004568 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004569
Bram Moolenaarea2d4072020-11-12 12:08:51 +01004570 // Every part must evaluate to a bool.
4571 if (bool_on_stack(cctx) == FAIL)
4572 {
4573 ga_clear(&end_ga);
4574 return FAIL;
4575 }
4576
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004577 // Fill in the end label in all jumps.
4578 while (end_ga.ga_len > 0)
4579 {
4580 isn_T *isn;
4581
4582 --end_ga.ga_len;
4583 isn = ((isn_T *)instr->ga_data)
4584 + *(((int *)end_ga.ga_data) + end_ga.ga_len);
4585 isn->isn_arg.jump.jump_where = instr->ga_len;
4586 }
4587 ga_clear(&end_ga);
4588 }
4589
4590 return OK;
4591}
4592
4593/*
4594 * expr4a && expr4a && expr4a logical AND
4595 *
4596 * Produces instructions:
4597 * EVAL expr4a Push result of "expr4a"
Bram Moolenaarea2d4072020-11-12 12:08:51 +01004598 * COND2BOOL convert to bool if needed
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004599 * JUMP_IF_COND_FALSE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004600 * EVAL expr4b Push result of "expr4b"
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004601 * JUMP_IF_COND_FALSE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004602 * EVAL expr4c Push result of "expr4c"
4603 * end:
4604 */
4605 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004606compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004607{
Bram Moolenaara5565e42020-05-09 15:44:01 +02004608 int ppconst_used = ppconst->pp_used;
4609
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004610 // get the first variable
Bram Moolenaara5565e42020-05-09 15:44:01 +02004611 if (compile_expr4(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004612 return FAIL;
4613
4614 // || and && work almost the same
Bram Moolenaara5565e42020-05-09 15:44:01 +02004615 return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004616}
4617
4618/*
4619 * expr3a || expr3b || expr3c logical OR
4620 *
4621 * Produces instructions:
4622 * EVAL expr3a Push result of "expr3a"
Bram Moolenaarea2d4072020-11-12 12:08:51 +01004623 * COND2BOOL convert to bool if needed
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004624 * JUMP_IF_COND_TRUE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004625 * EVAL expr3b Push result of "expr3b"
Bram Moolenaar2bb26582020-10-03 22:52:39 +02004626 * JUMP_IF_COND_TRUE end
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004627 * EVAL expr3c Push result of "expr3c"
4628 * end:
4629 */
4630 static int
Bram Moolenaara5565e42020-05-09 15:44:01 +02004631compile_expr2(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004632{
Bram Moolenaara5565e42020-05-09 15:44:01 +02004633 int ppconst_used = ppconst->pp_used;
4634
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004635 // eval the first expression
Bram Moolenaara5565e42020-05-09 15:44:01 +02004636 if (compile_expr3(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004637 return FAIL;
4638
4639 // || and && work almost the same
Bram Moolenaara5565e42020-05-09 15:44:01 +02004640 return compile_and_or(arg, cctx, "||", ppconst, ppconst_used);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004641}
4642
4643/*
4644 * Toplevel expression: expr2 ? expr1a : expr1b
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004645 * Produces instructions:
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004646 * EVAL expr2 Push result of "expr2"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004647 * JUMP_IF_FALSE alt jump if false
4648 * EVAL expr1a
4649 * JUMP_ALWAYS end
4650 * alt: EVAL expr1b
4651 * end:
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004652 *
4653 * Toplevel expression: expr2 ?? expr1
4654 * Produces instructions:
4655 * EVAL expr2 Push result of "expr2"
4656 * JUMP_AND_KEEP_IF_TRUE end jump if true
4657 * EVAL expr1
4658 * end:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004659 */
4660 static int
Bram Moolenaar7e368202020-12-25 21:56:57 +01004661compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004662{
4663 char_u *p;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004664 int ppconst_used = ppconst->pp_used;
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004665 char_u *next;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004666
Bram Moolenaar3988f642020-08-27 22:43:03 +02004667 // Ignore all kinds of errors when not producing code.
4668 if (cctx->ctx_skip == SKIP_YES)
4669 {
Bram Moolenaar7e368202020-12-25 21:56:57 +01004670 skip_expr_cctx(arg, cctx);
Bram Moolenaar3988f642020-08-27 22:43:03 +02004671 return OK;
4672 }
4673
Bram Moolenaar61a89812020-05-07 16:58:17 +02004674 // Evaluate the first expression.
Bram Moolenaara5565e42020-05-09 15:44:01 +02004675 if (compile_expr2(arg, cctx, ppconst) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004676 return FAIL;
4677
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004678 p = may_peek_next_line(cctx, *arg, &next);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004679 if (*p == '?')
4680 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004681 int op_falsy = p[1] == '?';
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004682 garray_T *instr = &cctx->ctx_instr;
4683 garray_T *stack = &cctx->ctx_type_stack;
4684 int alt_idx = instr->ga_len;
Bram Moolenaar38041da2020-06-21 22:17:18 +02004685 int end_idx = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004686 isn_T *isn;
Bram Moolenaar38041da2020-06-21 22:17:18 +02004687 type_T *type1 = NULL;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004688 int has_const_expr = FALSE;
4689 int const_value = FALSE;
4690 int save_skip = cctx->ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004691
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004692 if (next != NULL)
4693 {
4694 *arg = next_line_from_context(cctx, TRUE);
4695 p = skipwhite(*arg);
4696 }
4697
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004698 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1 + op_falsy]))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004699 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004700 semsg(_(e_white_space_required_before_and_after_str_at_str),
4701 op_falsy ? "??" : "?", *arg);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004702 return FAIL;
4703 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004704
Bram Moolenaara5565e42020-05-09 15:44:01 +02004705 if (ppconst->pp_used == ppconst_used + 1)
4706 {
4707 // the condition is a constant, we know whether the ? or the :
4708 // expression is to be evaluated.
4709 has_const_expr = TRUE;
Bram Moolenaar13106602020-10-04 16:06:05 +02004710 if (op_falsy)
4711 const_value = tv2bool(&ppconst->pp_tv[ppconst_used]);
4712 else
4713 {
4714 int error = FALSE;
4715
4716 const_value = tv_get_bool_chk(&ppconst->pp_tv[ppconst_used],
4717 &error);
4718 if (error)
4719 return FAIL;
4720 }
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004721 cctx->ctx_skip = save_skip == SKIP_YES ||
4722 (op_falsy ? const_value : !const_value) ? SKIP_YES : SKIP_NOT;
4723
4724 if (op_falsy && cctx->ctx_skip == SKIP_YES)
4725 // "left ?? right" and "left" is truthy: produce "left"
4726 generate_ppconst(cctx, ppconst);
4727 else
4728 {
4729 clear_tv(&ppconst->pp_tv[ppconst_used]);
4730 --ppconst->pp_used;
4731 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004732 }
4733 else
4734 {
4735 generate_ppconst(cctx, ppconst);
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004736 if (op_falsy)
4737 end_idx = instr->ga_len;
4738 generate_JUMP(cctx, op_falsy
4739 ? JUMP_AND_KEEP_IF_TRUE : JUMP_IF_FALSE, 0);
4740 if (op_falsy)
4741 type1 = ((type_T **)stack->ga_data)[stack->ga_len];
Bram Moolenaara5565e42020-05-09 15:44:01 +02004742 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004743
4744 // evaluate the second expression; any type is accepted
Bram Moolenaar918a4242020-12-06 14:37:08 +01004745 if (may_get_next_line_error(p + 1 + op_falsy, arg, cctx) == FAIL)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +02004746 return FAIL;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004747 if (compile_expr1(arg, cctx, ppconst) == FAIL)
Bram Moolenaara6d53682020-01-28 23:04:06 +01004748 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004749
Bram Moolenaara5565e42020-05-09 15:44:01 +02004750 if (!has_const_expr)
4751 {
4752 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004753
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004754 if (!op_falsy)
4755 {
4756 // remember the type and drop it
4757 --stack->ga_len;
4758 type1 = ((type_T **)stack->ga_data)[stack->ga_len];
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004759
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004760 end_idx = instr->ga_len;
4761 generate_JUMP(cctx, JUMP_ALWAYS, 0);
Bram Moolenaara5565e42020-05-09 15:44:01 +02004762
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004763 // jump here from JUMP_IF_FALSE
4764 isn = ((isn_T *)instr->ga_data) + alt_idx;
4765 isn->isn_arg.jump.jump_where = instr->ga_len;
4766 }
Bram Moolenaara5565e42020-05-09 15:44:01 +02004767 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004768
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004769 if (!op_falsy)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004770 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004771 // Check for the ":".
4772 p = may_peek_next_line(cctx, *arg, &next);
4773 if (*p != ':')
4774 {
4775 emsg(_(e_missing_colon));
4776 return FAIL;
4777 }
4778 if (next != NULL)
4779 {
4780 *arg = next_line_from_context(cctx, TRUE);
4781 p = skipwhite(*arg);
4782 }
Bram Moolenaar67fbdfe2020-06-23 22:26:05 +02004783
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004784 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1]))
4785 {
Bram Moolenaare7a73e02021-01-01 19:17:55 +01004786 semsg(_(e_white_space_required_before_and_after_str_at_str),
4787 ":", p);
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004788 return FAIL;
4789 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004790
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004791 // evaluate the third expression
4792 if (has_const_expr)
4793 cctx->ctx_skip = save_skip == SKIP_YES || const_value
Bram Moolenaar9b68c822020-06-18 19:31:08 +02004794 ? SKIP_YES : SKIP_NOT;
Bram Moolenaar918a4242020-12-06 14:37:08 +01004795 if (may_get_next_line_error(p + 1, arg, cctx) == FAIL)
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004796 return FAIL;
4797 if (compile_expr1(arg, cctx, ppconst) == FAIL)
4798 return FAIL;
4799 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004800
Bram Moolenaara5565e42020-05-09 15:44:01 +02004801 if (!has_const_expr)
4802 {
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004803 type_T **typep;
4804
Bram Moolenaara5565e42020-05-09 15:44:01 +02004805 generate_ppconst(cctx, ppconst);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004806
Bram Moolenaara5565e42020-05-09 15:44:01 +02004807 // If the types differ, the result has a more generic type.
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004808 typep = ((type_T **)stack->ga_data) + stack->ga_len - 1;
4809 common_type(type1, *typep, typep, cctx->ctx_type_list);
Bram Moolenaara5565e42020-05-09 15:44:01 +02004810
Bram Moolenaar92f26c22020-10-03 20:17:30 +02004811 // jump here from JUMP_ALWAYS or JUMP_AND_KEEP_IF_TRUE
Bram Moolenaara5565e42020-05-09 15:44:01 +02004812 isn = ((isn_T *)instr->ga_data) + end_idx;
4813 isn->isn_arg.jump.jump_where = instr->ga_len;
4814 }
4815
4816 cctx->ctx_skip = save_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004817 }
4818 return OK;
4819}
4820
4821/*
Bram Moolenaara5565e42020-05-09 15:44:01 +02004822 * Toplevel expression.
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004823 * Sets "is_const" (if not NULL) to indicate the value is a constant.
4824 * Returns OK or FAIL.
Bram Moolenaara5565e42020-05-09 15:44:01 +02004825 */
4826 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004827compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const)
Bram Moolenaara5565e42020-05-09 15:44:01 +02004828{
4829 ppconst_T ppconst;
4830
4831 CLEAR_FIELD(ppconst);
4832 if (compile_expr1(arg, cctx, &ppconst) == FAIL)
4833 {
4834 clear_ppconst(&ppconst);
4835 return FAIL;
4836 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004837 if (is_const != NULL)
4838 *is_const = ppconst.pp_used > 0 || ppconst.pp_is_const;
Bram Moolenaara5565e42020-05-09 15:44:01 +02004839 if (generate_ppconst(cctx, &ppconst) == FAIL)
4840 return FAIL;
4841 return OK;
4842}
4843
4844/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004845 * Toplevel expression.
4846 */
4847 static int
4848compile_expr0(char_u **arg, cctx_T *cctx)
4849{
4850 return compile_expr0_ext(arg, cctx, NULL);
4851}
4852
4853/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004854 * compile "return [expr]"
4855 */
4856 static char_u *
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004857compile_return(char_u *arg, int check_return_type, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004858{
4859 char_u *p = arg;
4860 garray_T *stack = &cctx->ctx_type_stack;
4861 type_T *stack_type;
4862
4863 if (*p != NUL && *p != '|' && *p != '\n')
4864 {
4865 // compile return argument into instructions
Bram Moolenaara5565e42020-05-09 15:44:01 +02004866 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004867 return NULL;
4868
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004869 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar05a55512020-07-05 15:52:19 +02004870 {
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004871 stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar6b553772020-12-31 13:31:23 +01004872 if (check_return_type && (cctx->ctx_ufunc->uf_ret_type == NULL
Bram Moolenaar328eac22021-01-07 19:23:08 +01004873 || cctx->ctx_ufunc->uf_ret_type == &t_unknown
4874 || cctx->ctx_ufunc->uf_ret_type == &t_any))
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004875 {
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004876 cctx->ctx_ufunc->uf_ret_type = stack_type;
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004877 }
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004878 else
Bram Moolenaar05a55512020-07-05 15:52:19 +02004879 {
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004880 if (cctx->ctx_ufunc->uf_ret_type->tt_type == VAR_VOID
4881 && stack_type->tt_type != VAR_VOID
4882 && stack_type->tt_type != VAR_UNKNOWN)
4883 {
4884 emsg(_(e_returning_value_in_function_without_return_type));
4885 return NULL;
4886 }
4887 if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02004888 cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004889 return NULL;
4890 }
Bram Moolenaar05a55512020-07-05 15:52:19 +02004891 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004892 }
4893 else
4894 {
Bram Moolenaar9e68c322020-12-25 12:38:04 +01004895 // "check_return_type" cannot be TRUE, only used for a lambda which
Bram Moolenaar9be61bb2020-03-30 22:51:24 +02004896 // always has an argument.
Bram Moolenaar4c683752020-04-05 21:38:23 +02004897 if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID
4898 && cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004899 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02004900 emsg(_(e_missing_return_value));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004901 return NULL;
4902 }
4903
4904 // No argument, return zero.
4905 generate_PUSHNR(cctx, 0);
4906 }
Bram Moolenaar8e02faf2020-11-18 16:35:02 +01004907 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_RETURN) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004908 return NULL;
4909
4910 // "return val | endif" is possible
4911 return skipwhite(p);
4912}
4913
4914/*
Bram Moolenaar04b12692020-05-04 23:24:44 +02004915 * Get a line from the compilation context, compatible with exarg_T getline().
4916 * Return a pointer to the line in allocated memory.
4917 * Return NULL for end-of-file or some error.
4918 */
4919 static char_u *
4920exarg_getline(
4921 int c UNUSED,
4922 void *cookie,
4923 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +02004924 getline_opt_T options UNUSED)
Bram Moolenaar04b12692020-05-04 23:24:44 +02004925{
4926 cctx_T *cctx = (cctx_T *)cookie;
Bram Moolenaar66250c92020-08-20 15:02:42 +02004927 char_u *p;
Bram Moolenaar04b12692020-05-04 23:24:44 +02004928
Bram Moolenaar66250c92020-08-20 15:02:42 +02004929 for (;;)
Bram Moolenaar04b12692020-05-04 23:24:44 +02004930 {
Bram Moolenaar2914a202020-09-27 18:24:03 +02004931 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len - 1)
Bram Moolenaar66250c92020-08-20 15:02:42 +02004932 return NULL;
4933 ++cctx->ctx_lnum;
4934 p = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
4935 // Comment lines result in NULL pointers, skip them.
4936 if (p != NULL)
4937 return vim_strsave(p);
Bram Moolenaar04b12692020-05-04 23:24:44 +02004938 }
Bram Moolenaar04b12692020-05-04 23:24:44 +02004939}
4940
4941/*
4942 * Compile a nested :def command.
4943 */
4944 static char_u *
4945compile_nested_function(exarg_T *eap, cctx_T *cctx)
4946{
Bram Moolenaar38ddf332020-07-31 22:05:04 +02004947 int is_global = *eap->arg == 'g' && eap->arg[1] == ':';
Bram Moolenaar04b12692020-05-04 23:24:44 +02004948 char_u *name_start = eap->arg;
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02004949 char_u *name_end = to_name_end(eap->arg, TRUE);
Bram Moolenaareef21022020-08-01 22:16:43 +02004950 char_u *lambda_name;
Bram Moolenaar04b12692020-05-04 23:24:44 +02004951 ufunc_T *ufunc;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01004952 int r = FAIL;
Bram Moolenaar04b12692020-05-04 23:24:44 +02004953
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02004954 if (eap->forceit)
Bram Moolenaar8b848ca2020-09-10 22:28:01 +02004955 {
4956 emsg(_(e_cannot_use_bang_with_nested_def));
4957 return NULL;
4958 }
4959
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01004960 if (*name_start == '/')
4961 {
4962 name_end = skip_regexp(name_start + 1, '/', TRUE);
4963 if (*name_end == '/')
4964 ++name_end;
4965 eap->nextcmd = check_nextcmd(name_end);
4966 }
4967 if (name_end == name_start || *skipwhite(name_end) != '(')
4968 {
4969 if (!ends_excmd2(name_start, name_end))
4970 {
4971 semsg(_(e_invalid_command_str), eap->cmd);
4972 return NULL;
4973 }
4974
4975 // "def" or "def Name": list functions
4976 if (generate_DEF(cctx, name_start, name_end - name_start) == FAIL)
4977 return NULL;
4978 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
4979 }
4980
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02004981 // Only g:Func() can use a namespace.
4982 if (name_start[1] == ':' && !is_global)
4983 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02004984 semsg(_(e_namespace_not_supported_str), name_start);
Bram Moolenaarbcbf4132020-08-01 22:35:13 +02004985 return NULL;
4986 }
Bram Moolenaareef21022020-08-01 22:16:43 +02004987 if (check_defined(name_start, name_end - name_start, cctx) == FAIL)
4988 return NULL;
4989
Bram Moolenaar04b12692020-05-04 23:24:44 +02004990 eap->arg = name_end;
4991 eap->getline = exarg_getline;
4992 eap->cookie = cctx;
Bram Moolenaar9b68c822020-06-18 19:31:08 +02004993 eap->skip = cctx->ctx_skip == SKIP_YES;
Bram Moolenaar04b12692020-05-04 23:24:44 +02004994 eap->forceit = FALSE;
Bram Moolenaar58a52f22020-12-22 18:56:55 +01004995 lambda_name = vim_strsave(get_lambda_name());
4996 if (lambda_name == NULL)
4997 return NULL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02004998 ufunc = define_function(eap, lambda_name);
Bram Moolenaar04b12692020-05-04 23:24:44 +02004999
Bram Moolenaar822ba242020-05-24 23:00:18 +02005000 if (ufunc == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005001 {
5002 r = eap->skip ? OK : FAIL;
5003 goto theend;
5004 }
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02005005 if (ufunc->uf_def_status == UF_TO_BE_COMPILED
Bram Moolenaar822ba242020-05-24 23:00:18 +02005006 && compile_def_function(ufunc, TRUE, cctx) == FAIL)
Bram Moolenaar4ee711f2020-09-23 18:51:11 +02005007 {
5008 func_ptr_unref(ufunc);
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005009 goto theend;
Bram Moolenaar4ee711f2020-09-23 18:51:11 +02005010 }
Bram Moolenaar04b12692020-05-04 23:24:44 +02005011
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005012 if (is_global)
5013 {
5014 char_u *func_name = vim_strnsave(name_start + 2,
5015 name_end - name_start - 2);
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +02005016
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005017 if (func_name == NULL)
5018 r = FAIL;
5019 else
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005020 {
Bram Moolenaareef21022020-08-01 22:16:43 +02005021 r = generate_NEWFUNC(cctx, lambda_name, func_name);
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005022 lambda_name = NULL;
5023 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005024 }
5025 else
5026 {
5027 // Define a local variable for the function reference.
Bram Moolenaare8211a32020-10-09 22:04:29 +02005028 lvar_T *lvar = reserve_local(cctx, name_start, name_end - name_start,
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005029 TRUE, ufunc->uf_func_type);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02005030 int block_depth = cctx->ctx_ufunc->uf_block_depth;
Bram Moolenaare8211a32020-10-09 22:04:29 +02005031
Bram Moolenaareef21022020-08-01 22:16:43 +02005032 if (lvar == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005033 goto theend;
Bram Moolenaar5a849da2020-08-08 16:47:30 +02005034 if (generate_FUNCREF(cctx, ufunc) == FAIL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005035 goto theend;
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005036 r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02005037
5038 // copy over the block scope IDs
5039 if (block_depth > 0)
5040 {
5041 ufunc->uf_block_ids = ALLOC_MULT(int, block_depth);
5042 if (ufunc->uf_block_ids != NULL)
5043 {
5044 mch_memmove(ufunc->uf_block_ids, cctx->ctx_ufunc->uf_block_ids,
5045 sizeof(int) * block_depth);
5046 ufunc->uf_block_depth = block_depth;
5047 }
5048 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005049 }
Bram Moolenaar61a89812020-05-07 16:58:17 +02005050 // TODO: warning for trailing text?
Bram Moolenaar58a52f22020-12-22 18:56:55 +01005051 r = OK;
5052
5053theend:
5054 vim_free(lambda_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +02005055 return r == FAIL ? NULL : (char_u *)"";
Bram Moolenaar04b12692020-05-04 23:24:44 +02005056}
5057
5058/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005059 * Return the length of an assignment operator, or zero if there isn't one.
5060 */
5061 int
5062assignment_len(char_u *p, int *heredoc)
5063{
5064 if (*p == '=')
5065 {
5066 if (p[1] == '<' && p[2] == '<')
5067 {
5068 *heredoc = TRUE;
5069 return 3;
5070 }
5071 return 1;
5072 }
5073 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=')
5074 return 2;
5075 if (STRNCMP(p, "..=", 3) == 0)
5076 return 3;
5077 return 0;
5078}
5079
5080// words that cannot be used as a variable
5081static char *reserved[] = {
5082 "true",
5083 "false",
Bram Moolenaar67977822021-01-03 21:53:53 +01005084 "null",
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005085 NULL
5086};
5087
Bram Moolenaar752fc692021-01-04 21:57:11 +01005088// Destination for an assignment or ":unlet" with an index.
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01005089typedef enum {
5090 dest_local,
5091 dest_option,
5092 dest_env,
5093 dest_global,
Bram Moolenaard3aac292020-04-19 14:32:17 +02005094 dest_buffer,
5095 dest_window,
5096 dest_tab,
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01005097 dest_vimvar,
5098 dest_script,
5099 dest_reg,
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005100 dest_expr,
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01005101} assign_dest_T;
5102
Bram Moolenaar752fc692021-01-04 21:57:11 +01005103// Used by compile_lhs() to store information about the LHS of an assignment
5104// and one argument of ":unlet" with an index.
5105typedef struct {
5106 assign_dest_T lhs_dest; // type of destination
5107
5108 char_u *lhs_name; // allocated name including
5109 // "[expr]" or ".name".
5110 size_t lhs_varlen; // length of the variable without
5111 // "[expr]" or ".name"
5112 char_u *lhs_dest_end; // end of the destination, including
5113 // "[expr]" or ".name".
5114
5115 int lhs_has_index; // has "[expr]" or ".name"
5116
5117 int lhs_new_local; // create new local variable
5118 int lhs_opt_flags; // for when destination is an option
5119 int lhs_vimvaridx; // for when destination is a v:var
5120
5121 lvar_T lhs_local_lvar; // used for existing local destination
5122 lvar_T lhs_arg_lvar; // used for argument destination
5123 lvar_T *lhs_lvar; // points to destination lvar
5124 int lhs_scriptvar_sid;
5125 int lhs_scriptvar_idx;
5126
5127 int lhs_has_type; // type was specified
5128 type_T *lhs_type;
5129 type_T *lhs_member_type;
5130} lhs_T;
5131
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005132/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005133 * Generate the load instruction for "name".
5134 */
5135 static void
5136generate_loadvar(
5137 cctx_T *cctx,
5138 assign_dest_T dest,
5139 char_u *name,
5140 lvar_T *lvar,
5141 type_T *type)
5142{
5143 switch (dest)
5144 {
5145 case dest_option:
5146 // TODO: check the option exists
5147 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
5148 break;
5149 case dest_global:
Bram Moolenaar03290b82020-12-19 16:30:44 +01005150 if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
5151 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
5152 else
5153 generate_LOAD(cctx, ISN_LOADAUTO, 0, name, type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005154 break;
5155 case dest_buffer:
5156 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
5157 break;
5158 case dest_window:
5159 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
5160 break;
5161 case dest_tab:
5162 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
5163 break;
5164 case dest_script:
5165 compile_load_scriptvar(cctx,
5166 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
5167 break;
5168 case dest_env:
5169 // Include $ in the name here
5170 generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
5171 break;
5172 case dest_reg:
5173 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string);
5174 break;
5175 case dest_vimvar:
5176 generate_LOADV(cctx, name + 2, TRUE);
5177 break;
5178 case dest_local:
Bram Moolenaarab360522021-01-10 14:02:28 +01005179 if (lvar->lv_from_outer > 0)
5180 generate_LOADOUTER(cctx, lvar->lv_idx, lvar->lv_from_outer,
5181 type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005182 else
5183 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
5184 break;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005185 case dest_expr:
5186 // list or dict value should already be on the stack.
5187 break;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005188 }
5189}
5190
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005191/*
5192 * Skip over "[expr]" or ".member".
5193 * Does not check for any errors.
5194 */
5195 static char_u *
5196skip_index(char_u *start)
5197{
5198 char_u *p = start;
5199
5200 if (*p == '[')
5201 {
5202 p = skipwhite(p + 1);
5203 (void)skip_expr(&p, NULL);
5204 p = skipwhite(p);
5205 if (*p == ']')
5206 return p + 1;
5207 return p;
5208 }
5209 // if (*p == '.')
5210 return to_name_end(p + 1, TRUE);
5211}
5212
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005213 void
5214vim9_declare_error(char_u *name)
5215{
5216 char *scope = "";
5217
5218 switch (*name)
5219 {
Bram Moolenaar7fe87552020-06-21 20:38:28 +02005220 case 'g': scope = _("global"); break;
5221 case 'b': scope = _("buffer"); break;
5222 case 'w': scope = _("window"); break;
5223 case 't': scope = _("tab"); break;
5224 case 'v': scope = "v:"; break;
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02005225 case '$': semsg(_(e_cannot_declare_an_environment_variable), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005226 return;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005227 case '&': semsg(_(e_cannot_declare_an_option), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005228 return;
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02005229 case '@': semsg(_(e_cannot_declare_a_register_str), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02005230 return;
Bram Moolenaar7fe87552020-06-21 20:38:28 +02005231 default: return;
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005232 }
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02005233 semsg(_(e_cannot_declare_a_scope_variable), scope, name);
Bram Moolenaare55b1c02020-06-21 15:52:59 +02005234}
5235
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005236/*
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005237 * For one assignment figure out the type of destination. Return it in "dest".
5238 * When not recognized "dest" is not set.
5239 * For an option "opt_flags" is set.
5240 * For a v:var "vimvaridx" is set.
5241 * "type" is set to the destination type if known, unchanted otherwise.
5242 * Return FAIL if an error message was given.
5243 */
5244 static int
5245get_var_dest(
5246 char_u *name,
5247 assign_dest_T *dest,
5248 int cmdidx,
5249 int *opt_flags,
5250 int *vimvaridx,
5251 type_T **type,
5252 cctx_T *cctx)
5253{
5254 char_u *p;
5255
5256 if (*name == '&')
5257 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005258 int cc;
5259 long numval;
5260 getoption_T opt_type;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005261
5262 *dest = dest_option;
5263 if (cmdidx == CMD_final || cmdidx == CMD_const)
5264 {
5265 emsg(_(e_const_option));
5266 return FAIL;
5267 }
5268 p = name;
5269 p = find_option_end(&p, opt_flags);
5270 if (p == NULL)
5271 {
5272 // cannot happen?
5273 emsg(_(e_letunexp));
5274 return FAIL;
5275 }
5276 cc = *p;
5277 *p = NUL;
5278 opt_type = get_option_value(skip_option_env_lead(name),
5279 &numval, NULL, *opt_flags);
5280 *p = cc;
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005281 switch (opt_type)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005282 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01005283 case gov_unknown:
5284 semsg(_(e_unknown_option), name);
5285 return FAIL;
5286 case gov_string:
5287 case gov_hidden_string:
5288 *type = &t_string;
5289 break;
5290 case gov_bool:
5291 case gov_hidden_bool:
5292 *type = &t_bool;
5293 break;
5294 case gov_number:
5295 case gov_hidden_number:
5296 *type = &t_number;
5297 break;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005298 }
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005299 }
5300 else if (*name == '$')
5301 {
5302 *dest = dest_env;
5303 *type = &t_string;
5304 }
5305 else if (*name == '@')
5306 {
5307 if (!valid_yank_reg(name[1], FALSE) || name[1] == '.')
5308 {
5309 emsg_invreg(name[1]);
5310 return FAIL;
5311 }
5312 *dest = dest_reg;
5313 *type = &t_string;
5314 }
5315 else if (STRNCMP(name, "g:", 2) == 0)
5316 {
5317 *dest = dest_global;
5318 }
5319 else if (STRNCMP(name, "b:", 2) == 0)
5320 {
5321 *dest = dest_buffer;
5322 }
5323 else if (STRNCMP(name, "w:", 2) == 0)
5324 {
5325 *dest = dest_window;
5326 }
5327 else if (STRNCMP(name, "t:", 2) == 0)
5328 {
5329 *dest = dest_tab;
5330 }
5331 else if (STRNCMP(name, "v:", 2) == 0)
5332 {
5333 typval_T *vtv;
5334 int di_flags;
5335
5336 *vimvaridx = find_vim_var(name + 2, &di_flags);
5337 if (*vimvaridx < 0)
5338 {
5339 semsg(_(e_variable_not_found_str), name);
5340 return FAIL;
5341 }
5342 // We use the current value of "sandbox" here, is that OK?
5343 if (var_check_ro(di_flags, name, FALSE))
5344 return FAIL;
5345 *dest = dest_vimvar;
5346 vtv = get_vim_var_tv(*vimvaridx);
5347 *type = typval2type_vimvar(vtv, cctx->ctx_type_list);
5348 }
5349 return OK;
5350}
5351
5352/*
5353 * Generate a STORE instruction for "dest", not being "dest_local".
5354 * Return FAIL when out of memory.
5355 */
5356 static int
5357generate_store_var(
5358 cctx_T *cctx,
5359 assign_dest_T dest,
5360 int opt_flags,
5361 int vimvaridx,
5362 int scriptvar_idx,
5363 int scriptvar_sid,
5364 type_T *type,
5365 char_u *name)
5366{
5367 switch (dest)
5368 {
5369 case dest_option:
5370 return generate_STOREOPT(cctx, skip_option_env_lead(name),
5371 opt_flags);
5372 case dest_global:
5373 // include g: with the name, easier to execute that way
Bram Moolenaar03290b82020-12-19 16:30:44 +01005374 return generate_STORE(cctx, vim_strchr(name, AUTOLOAD_CHAR) == NULL
5375 ? ISN_STOREG : ISN_STOREAUTO, 0, name);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005376 case dest_buffer:
5377 // include b: with the name, easier to execute that way
5378 return generate_STORE(cctx, ISN_STOREB, 0, name);
5379 case dest_window:
5380 // include w: with the name, easier to execute that way
5381 return generate_STORE(cctx, ISN_STOREW, 0, name);
5382 case dest_tab:
5383 // include t: with the name, easier to execute that way
5384 return generate_STORE(cctx, ISN_STORET, 0, name);
5385 case dest_env:
5386 return generate_STORE(cctx, ISN_STOREENV, 0, name + 1);
5387 case dest_reg:
5388 return generate_STORE(cctx, ISN_STOREREG, name[1], NULL);
5389 case dest_vimvar:
5390 return generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL);
5391 case dest_script:
5392 if (scriptvar_idx < 0)
5393 {
5394 char_u *name_s = name;
Bram Moolenaar41d61962020-12-06 20:12:43 +01005395 int r;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005396
Bram Moolenaar41d61962020-12-06 20:12:43 +01005397 // "s:" is included in the name.
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005398 r = generate_OLDSCRIPT(cctx, ISN_STORES, name_s,
5399 scriptvar_sid, type);
5400 if (name_s != name)
5401 vim_free(name_s);
5402 return r;
5403 }
5404 return generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT,
5405 scriptvar_sid, scriptvar_idx, type);
5406 case dest_local:
5407 case dest_expr:
5408 // cannot happen
5409 break;
5410 }
5411 return FAIL;
5412}
5413
Bram Moolenaar752fc692021-01-04 21:57:11 +01005414 static int
5415is_decl_command(int cmdidx)
5416{
5417 return cmdidx == CMD_let || cmdidx == CMD_var
5418 || cmdidx == CMD_final || cmdidx == CMD_const;
5419}
5420
5421/*
5422 * Figure out the LHS type and other properties for an assignment or one item
5423 * of ":unlet" with an index.
5424 * Returns OK or FAIL.
5425 */
5426 static int
5427compile_lhs(
5428 char_u *var_start,
5429 lhs_T *lhs,
5430 int cmdidx,
5431 int heredoc,
5432 int oplen,
5433 cctx_T *cctx)
5434{
5435 char_u *var_end;
5436 int is_decl = is_decl_command(cmdidx);
5437
5438 CLEAR_POINTER(lhs);
5439 lhs->lhs_dest = dest_local;
5440 lhs->lhs_vimvaridx = -1;
5441 lhs->lhs_scriptvar_idx = -1;
5442
5443 // "dest_end" is the end of the destination, including "[expr]" or
5444 // ".name".
5445 // "var_end" is the end of the variable/option/etc. name.
5446 lhs->lhs_dest_end = skip_var_one(var_start, FALSE);
5447 if (*var_start == '@')
5448 var_end = var_start + 2;
5449 else
5450 {
5451 // skip over the leading "&", "&l:", "&g:" and "$"
5452 var_end = skip_option_env_lead(var_start);
5453 var_end = to_name_end(var_end, TRUE);
5454 }
5455
5456 // "a: type" is declaring variable "a" with a type, not dict "a:".
5457 if (is_decl && lhs->lhs_dest_end == var_start + 2
5458 && lhs->lhs_dest_end[-1] == ':')
5459 --lhs->lhs_dest_end;
5460 if (is_decl && var_end == var_start + 2 && var_end[-1] == ':')
5461 --var_end;
5462
5463 // compute the length of the destination without "[expr]" or ".name"
5464 lhs->lhs_varlen = var_end - var_start;
5465 lhs->lhs_name = vim_strnsave(var_start, lhs->lhs_varlen);
5466 if (lhs->lhs_name == NULL)
5467 return FAIL;
5468 if (heredoc)
5469 lhs->lhs_type = &t_list_string;
5470 else
5471 lhs->lhs_type = &t_any;
5472
5473 if (cctx->ctx_skip != SKIP_YES)
5474 {
5475 int declare_error = FALSE;
5476
5477 if (get_var_dest(lhs->lhs_name, &lhs->lhs_dest, cmdidx,
5478 &lhs->lhs_opt_flags, &lhs->lhs_vimvaridx,
5479 &lhs->lhs_type, cctx) == FAIL)
5480 return FAIL;
5481 if (lhs->lhs_dest != dest_local)
5482 {
5483 // Specific kind of variable recognized.
5484 declare_error = is_decl;
5485 }
5486 else
5487 {
5488 int idx;
5489
5490 // No specific kind of variable recognized, just a name.
5491 for (idx = 0; reserved[idx] != NULL; ++idx)
5492 if (STRCMP(reserved[idx], lhs->lhs_name) == 0)
5493 {
5494 semsg(_(e_cannot_use_reserved_name), lhs->lhs_name);
5495 return FAIL;
5496 }
5497
5498
5499 if (lookup_local(var_start, lhs->lhs_varlen,
5500 &lhs->lhs_local_lvar, cctx) == OK)
5501 lhs->lhs_lvar = &lhs->lhs_local_lvar;
5502 else
5503 {
5504 CLEAR_FIELD(lhs->lhs_arg_lvar);
5505 if (arg_exists(var_start, lhs->lhs_varlen,
5506 &lhs->lhs_arg_lvar.lv_idx, &lhs->lhs_arg_lvar.lv_type,
5507 &lhs->lhs_arg_lvar.lv_from_outer, cctx) == OK)
5508 {
5509 if (is_decl)
5510 {
5511 semsg(_(e_str_is_used_as_argument), lhs->lhs_name);
5512 return FAIL;
5513 }
5514 lhs->lhs_lvar = &lhs->lhs_arg_lvar;
5515 }
5516 }
5517 if (lhs->lhs_lvar != NULL)
5518 {
5519 if (is_decl)
5520 {
5521 semsg(_(e_variable_already_declared), lhs->lhs_name);
5522 return FAIL;
5523 }
5524 }
5525 else
5526 {
5527 int script_namespace = lhs->lhs_varlen > 1
5528 && STRNCMP(var_start, "s:", 2) == 0;
5529 int script_var = (script_namespace
5530 ? script_var_exists(var_start + 2, lhs->lhs_varlen - 2,
5531 FALSE, cctx)
5532 : script_var_exists(var_start, lhs->lhs_varlen,
5533 TRUE, cctx)) == OK;
5534 imported_T *import =
5535 find_imported(var_start, lhs->lhs_varlen, cctx);
5536
5537 if (script_namespace || script_var || import != NULL)
5538 {
5539 char_u *rawname = lhs->lhs_name
5540 + (lhs->lhs_name[1] == ':' ? 2 : 0);
5541
5542 if (is_decl)
5543 {
5544 if (script_namespace)
5545 semsg(_(e_cannot_declare_script_variable_in_function),
5546 lhs->lhs_name);
5547 else
5548 semsg(_(e_variable_already_declared_in_script),
5549 lhs->lhs_name);
5550 return FAIL;
5551 }
5552 else if (cctx->ctx_ufunc->uf_script_ctx_version
5553 == SCRIPT_VERSION_VIM9
5554 && script_namespace
5555 && !script_var && import == NULL)
5556 {
5557 semsg(_(e_unknown_variable_str), lhs->lhs_name);
5558 return FAIL;
5559 }
5560
5561 lhs->lhs_dest = dest_script;
5562
5563 // existing script-local variables should have a type
5564 lhs->lhs_scriptvar_sid = current_sctx.sc_sid;
5565 if (import != NULL)
5566 lhs->lhs_scriptvar_sid = import->imp_sid;
5567 if (SCRIPT_ID_VALID(lhs->lhs_scriptvar_sid))
5568 {
5569 lhs->lhs_scriptvar_idx = get_script_item_idx(
5570 lhs->lhs_scriptvar_sid,
5571 rawname, TRUE, cctx);
5572 if (lhs->lhs_scriptvar_idx >= 0)
5573 {
5574 scriptitem_T *si = SCRIPT_ITEM(
5575 lhs->lhs_scriptvar_sid);
5576 svar_T *sv =
5577 ((svar_T *)si->sn_var_vals.ga_data)
5578 + lhs->lhs_scriptvar_idx;
5579 lhs->lhs_type = sv->sv_type;
5580 }
5581 }
5582 }
5583 else if (check_defined(var_start, lhs->lhs_varlen, cctx)
5584 == FAIL)
5585 return FAIL;
5586 }
5587 }
5588
5589 if (declare_error)
5590 {
5591 vim9_declare_error(lhs->lhs_name);
5592 return FAIL;
5593 }
5594 }
5595
5596 // handle "a:name" as a name, not index "name" on "a"
5597 if (lhs->lhs_varlen > 1 || var_start[lhs->lhs_varlen] != ':')
5598 var_end = lhs->lhs_dest_end;
5599
5600 if (lhs->lhs_dest != dest_option)
5601 {
5602 if (is_decl && *var_end == ':')
5603 {
5604 char_u *p;
5605
5606 // parse optional type: "let var: type = expr"
5607 if (!VIM_ISWHITE(var_end[1]))
5608 {
5609 semsg(_(e_white_space_required_after_str), ":");
5610 return FAIL;
5611 }
5612 p = skipwhite(var_end + 1);
5613 lhs->lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE);
5614 if (lhs->lhs_type == NULL)
5615 return FAIL;
5616 lhs->lhs_has_type = TRUE;
5617 }
5618 else if (lhs->lhs_lvar != NULL)
5619 lhs->lhs_type = lhs->lhs_lvar->lv_type;
5620 }
5621
5622 if (oplen == 3 && !heredoc && lhs->lhs_dest != dest_global
5623 && lhs->lhs_type->tt_type != VAR_STRING
5624 && lhs->lhs_type->tt_type != VAR_ANY)
5625 {
5626 emsg(_(e_can_only_concatenate_to_string));
5627 return FAIL;
5628 }
5629
5630 if (lhs->lhs_lvar == NULL && lhs->lhs_dest == dest_local
5631 && cctx->ctx_skip != SKIP_YES)
5632 {
5633 if (oplen > 1 && !heredoc)
5634 {
5635 // +=, /=, etc. require an existing variable
5636 semsg(_(e_cannot_use_operator_on_new_variable), lhs->lhs_name);
5637 return FAIL;
5638 }
5639 if (!is_decl)
5640 {
5641 semsg(_(e_unknown_variable_str), lhs->lhs_name);
5642 return FAIL;
5643 }
5644
5645 // new local variable
5646 if ((lhs->lhs_type->tt_type == VAR_FUNC
5647 || lhs->lhs_type->tt_type == VAR_PARTIAL)
5648 && var_wrong_func_name(lhs->lhs_name, TRUE))
5649 return FAIL;
5650 lhs->lhs_lvar = reserve_local(cctx, var_start, lhs->lhs_varlen,
5651 cmdidx == CMD_final || cmdidx == CMD_const, lhs->lhs_type);
5652 if (lhs->lhs_lvar == NULL)
5653 return FAIL;
5654 lhs->lhs_new_local = TRUE;
5655 }
5656
5657 lhs->lhs_member_type = lhs->lhs_type;
5658 if (lhs->lhs_dest_end > var_start + lhs->lhs_varlen)
5659 {
5660 // Something follows after the variable: "var[idx]" or "var.key".
5661 // TODO: should we also handle "->func()" here?
5662 if (is_decl)
5663 {
5664 emsg(_(e_cannot_use_index_when_declaring_variable));
5665 return FAIL;
5666 }
5667
5668 if (var_start[lhs->lhs_varlen] == '['
5669 || var_start[lhs->lhs_varlen] == '.')
5670 {
5671 char_u *after = var_start + lhs->lhs_varlen;
5672 char_u *p;
5673
5674 // Only the last index is used below, if there are others
5675 // before it generate code for the expression. Thus for
5676 // "ll[1][2]" the expression is "ll[1]" and "[2]" is the index.
5677 for (;;)
5678 {
5679 p = skip_index(after);
5680 if (*p != '[' && *p != '.')
5681 break;
5682 after = p;
5683 }
5684 if (after > var_start + lhs->lhs_varlen)
5685 {
5686 lhs->lhs_varlen = after - var_start;
5687 lhs->lhs_dest = dest_expr;
5688 // We don't know the type before evaluating the expression,
5689 // use "any" until then.
5690 lhs->lhs_type = &t_any;
5691 }
5692
5693 lhs->lhs_has_index = TRUE;
5694 if (lhs->lhs_type->tt_member == NULL)
5695 lhs->lhs_member_type = &t_any;
5696 else
5697 lhs->lhs_member_type = lhs->lhs_type->tt_member;
5698 }
5699 else
5700 {
5701 semsg("Not supported yet: %s", var_start);
5702 return FAIL;
5703 }
5704 }
5705 return OK;
5706}
5707
5708/*
5709 * Assignment to a list or dict member, or ":unlet" for the item, using the
5710 * information in "lhs".
5711 * Returns OK or FAIL.
5712 */
5713 static int
5714compile_assign_unlet(
5715 char_u *var_start,
5716 lhs_T *lhs,
5717 int is_assign,
5718 type_T *rhs_type,
5719 cctx_T *cctx)
5720{
5721 char_u *p;
5722 int r;
5723 vartype_T dest_type;
5724 size_t varlen = lhs->lhs_varlen;
5725 garray_T *stack = &cctx->ctx_type_stack;
5726
5727 // Compile the "idx" in "var[idx]" or "key" in "var.key".
5728 p = var_start + varlen;
5729 if (*p == '[')
5730 {
5731 p = skipwhite(p + 1);
5732 r = compile_expr0(&p, cctx);
5733 if (r == OK && *skipwhite(p) != ']')
5734 {
5735 // this should not happen
5736 emsg(_(e_missbrac));
5737 r = FAIL;
5738 }
5739 }
5740 else // if (*p == '.')
5741 {
5742 char_u *key_end = to_name_end(p + 1, TRUE);
5743 char_u *key = vim_strnsave(p + 1, key_end - p - 1);
5744
5745 r = generate_PUSHS(cctx, key);
5746 }
5747 if (r == FAIL)
5748 return FAIL;
5749
5750 if (lhs->lhs_type == &t_any)
5751 {
5752 // Index on variable of unknown type: check at runtime.
5753 dest_type = VAR_ANY;
5754 }
5755 else
5756 {
5757 dest_type = lhs->lhs_type->tt_type;
5758 if (dest_type == VAR_DICT && may_generate_2STRING(-1, cctx) == FAIL)
5759 return FAIL;
5760 if (dest_type == VAR_LIST
5761 && ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type
5762 != VAR_NUMBER)
5763 {
5764 emsg(_(e_number_exp));
5765 return FAIL;
5766 }
5767 }
5768
5769 // Load the dict or list. On the stack we then have:
5770 // - value (for assignment, not for :unlet)
5771 // - index
5772 // - variable
5773 if (lhs->lhs_dest == dest_expr)
5774 {
5775 int c = var_start[varlen];
5776
5777 // Evaluate "ll[expr]" of "ll[expr][idx]"
5778 p = var_start;
5779 var_start[varlen] = NUL;
5780 if (compile_expr0(&p, cctx) == OK && p != var_start + varlen)
5781 {
5782 // this should not happen
5783 emsg(_(e_missbrac));
5784 return FAIL;
5785 }
5786 var_start[varlen] = c;
5787
5788 lhs->lhs_type = stack->ga_len == 0 ? &t_void
5789 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
5790 // now we can properly check the type
5791 if (lhs->lhs_type->tt_member != NULL && rhs_type != &t_void
5792 && need_type(rhs_type, lhs->lhs_type->tt_member, -2, cctx,
5793 FALSE, FALSE) == FAIL)
5794 return FAIL;
5795 }
5796 else
5797 generate_loadvar(cctx, lhs->lhs_dest, lhs->lhs_name,
5798 lhs->lhs_lvar, lhs->lhs_type);
5799
5800 if (dest_type == VAR_LIST || dest_type == VAR_DICT || dest_type == VAR_ANY)
5801 {
5802 if (is_assign)
5803 {
5804 isn_T *isn = generate_instr_drop(cctx, ISN_STOREINDEX, 3);
5805
5806 if (isn == NULL)
5807 return FAIL;
5808 isn->isn_arg.vartype = dest_type;
5809 }
5810 else
5811 {
5812 if (generate_instr_drop(cctx, ISN_UNLETINDEX, 2) == NULL)
5813 return FAIL;
5814 }
5815 }
5816 else
5817 {
5818 emsg(_(e_indexable_type_required));
5819 return FAIL;
5820 }
5821
5822 return OK;
5823}
5824
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01005825/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005826 * Compile declaration and assignment:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02005827 * "let name"
5828 * "var name = expr"
5829 * "final name = expr"
5830 * "const name = expr"
5831 * "name = expr"
5832 * "arg" points to "name".
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005833 * Return NULL for an error.
5834 * Return "arg" if it does not look like a variable list.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005835 */
5836 static char_u *
5837compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
5838{
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005839 char_u *var_start;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005840 char_u *p;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005841 char_u *end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005842 char_u *ret = NULL;
5843 int var_count = 0;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005844 int var_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005845 int semicolon = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005846 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005847 garray_T *stack = &cctx->ctx_type_stack;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005848 char_u *op;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005849 int oplen = 0;
5850 int heredoc = FALSE;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005851 type_T *rhs_type = &t_any;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005852 char_u *sp;
Bram Moolenaar752fc692021-01-04 21:57:11 +01005853 int is_decl = is_decl_command(cmdidx);
5854 lhs_T lhs;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005855
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005856 // Skip over the "var" or "[var, var]" to get to any "=".
5857 p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE);
5858 if (p == NULL)
5859 return *arg == '[' ? arg : NULL;
5860
5861 if (var_count > 0 && is_decl)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005862 {
Bram Moolenaarc7db5772020-07-21 20:55:50 +02005863 // TODO: should we allow this, and figure out type inference from list
5864 // members?
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005865 emsg(_(e_cannot_use_list_for_declaration));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005866 return NULL;
5867 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01005868 lhs.lhs_name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005869
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005870 sp = p;
5871 p = skipwhite(p);
5872 op = p;
5873 oplen = assignment_len(p, &heredoc);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005874
5875 if (var_count > 0 && oplen == 0)
5876 // can be something like "[1, 2]->func()"
5877 return arg;
5878
Bram Moolenaar004d9b02020-11-30 21:40:03 +01005879 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !IS_WHITE_OR_NUL(op[oplen])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005880 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02005881 error_white_both(op, oplen);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005882 return NULL;
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02005883 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005884
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005885 if (heredoc)
5886 {
5887 list_T *l;
5888 listitem_T *li;
5889
5890 // [let] varname =<< [trim] {end}
Bram Moolenaar04b12692020-05-04 23:24:44 +02005891 eap->getline = exarg_getline;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005892 eap->cookie = cctx;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02005893 l = heredoc_get(eap, op + 3, FALSE);
Bram Moolenaarc0e29012020-09-27 14:22:48 +02005894 if (l == NULL)
5895 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005896
Bram Moolenaar078269b2020-09-21 20:35:55 +02005897 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005898 {
Bram Moolenaar078269b2020-09-21 20:35:55 +02005899 // Push each line and the create the list.
5900 FOR_ALL_LIST_ITEMS(l, li)
5901 {
5902 generate_PUSHS(cctx, li->li_tv.vval.v_string);
5903 li->li_tv.vval.v_string = NULL;
5904 }
5905 generate_NEWLIST(cctx, l->lv_len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005906 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005907 list_free(l);
5908 p += STRLEN(p);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005909 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005910 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005911 else if (var_count > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005912 {
Bram Moolenaar004d9b02020-11-30 21:40:03 +01005913 char_u *wp;
5914
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005915 // for "[var, var] = expr" evaluate the expression here, loop over the
5916 // list of variables below.
Bram Moolenaar004d9b02020-11-30 21:40:03 +01005917 // A line break may follow the "=".
Bram Moolenaard25ec2c2020-03-30 21:05:45 +02005918
Bram Moolenaar004d9b02020-11-30 21:40:03 +01005919 wp = op + oplen;
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01005920 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01005921 return FAIL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005922 if (compile_expr0(&p, cctx) == FAIL)
5923 return NULL;
5924 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005925
Bram Moolenaar9b68c822020-06-18 19:31:08 +02005926 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005927 {
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02005928 type_T *stacktype;
5929
Bram Moolenaarec5929d2020-04-07 20:53:39 +02005930 stacktype = stack->ga_len == 0 ? &t_void
5931 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005932 if (stacktype->tt_type == VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005933 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02005934 emsg(_(e_cannot_use_void_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005935 goto theend;
5936 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005937 if (need_type(stacktype, &t_list_any, -1, cctx,
5938 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005939 goto theend;
Bram Moolenaare8593122020-07-18 15:17:02 +02005940 // TODO: check the length of a constant list here
Bram Moolenaar9af78762020-06-16 11:34:42 +02005941 generate_CHECKLEN(cctx, semicolon ? var_count - 1 : var_count,
5942 semicolon);
Bram Moolenaardc234ca2020-11-28 18:52:33 +01005943 if (stacktype->tt_member != NULL)
5944 rhs_type = stacktype->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005945 }
5946 }
5947
5948 /*
5949 * Loop over variables in "[var, var] = expr".
5950 * For "var = expr" and "let var: type" this is done only once.
5951 */
5952 if (var_count > 0)
5953 var_start = skipwhite(arg + 1); // skip over the "["
5954 else
5955 var_start = arg;
5956 for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++)
5957 {
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005958 int instr_count = -1;
5959
Bram Moolenaar752fc692021-01-04 21:57:11 +01005960 vim_free(lhs.lhs_name);
5961
5962 /*
5963 * Figure out the LHS type and other properties.
5964 */
5965 if (compile_lhs(var_start, &lhs, cmdidx, heredoc, oplen, cctx) == FAIL)
5966 goto theend;
5967
5968 if (!lhs.lhs_has_index && lhs.lhs_lvar == &lhs.lhs_arg_lvar)
Bram Moolenaar65821722020-08-02 18:58:54 +02005969 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01005970 semsg(_(e_cannot_assign_to_argument), lhs.lhs_name);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005971 goto theend;
5972 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01005973 if (!is_decl && lhs.lhs_lvar != NULL
5974 && lhs.lhs_lvar->lv_const && !lhs.lhs_has_index)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005975 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01005976 semsg(_(e_cannot_assign_to_constant), lhs.lhs_name);
Bram Moolenaardbeecb22020-09-14 18:15:09 +02005977 goto theend;
5978 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005979
5980 if (!heredoc)
5981 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02005982 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005983 {
Bram Moolenaar72abcf42020-06-18 18:26:24 +02005984 if (oplen > 0 && var_count == 0)
5985 {
5986 // skip over the "=" and the expression
5987 p = skipwhite(op + oplen);
5988 compile_expr0(&p, cctx);
5989 }
5990 }
5991 else if (oplen > 0)
5992 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02005993 int is_const = FALSE;
Bram Moolenaar7f764942020-12-02 15:11:18 +01005994 char_u *wp;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02005995
Bram Moolenaar47a519a2020-06-14 23:05:10 +02005996 // For "var = expr" evaluate the expression.
5997 if (var_count == 0)
5998 {
5999 int r;
6000
6001 // for "+=", "*=", "..=" etc. first load the current value
6002 if (*op != '=')
6003 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006004 generate_loadvar(cctx, lhs.lhs_dest, lhs.lhs_name,
6005 lhs.lhs_lvar, lhs.lhs_type);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006006
Bram Moolenaar752fc692021-01-04 21:57:11 +01006007 if (lhs.lhs_has_index)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006008 {
6009 // TODO: get member from list or dict
6010 emsg("Index with operation not supported yet");
6011 goto theend;
6012 }
6013 }
6014
6015 // Compile the expression. Temporarily hide the new local
6016 // variable here, it is not available to this expression.
Bram Moolenaar752fc692021-01-04 21:57:11 +01006017 if (lhs.lhs_new_local)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006018 --cctx->ctx_locals.ga_len;
6019 instr_count = instr->ga_len;
Bram Moolenaar7f764942020-12-02 15:11:18 +01006020 wp = op + oplen;
Bram Moolenaar7f764942020-12-02 15:11:18 +01006021 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
Bram Moolenaar21e51222020-12-04 12:43:29 +01006022 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006023 if (lhs.lhs_new_local)
Bram Moolenaar21e51222020-12-04 12:43:29 +01006024 ++cctx->ctx_locals.ga_len;
Bram Moolenaar7f764942020-12-02 15:11:18 +01006025 goto theend;
Bram Moolenaar21e51222020-12-04 12:43:29 +01006026 }
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006027 r = compile_expr0_ext(&p, cctx, &is_const);
Bram Moolenaar752fc692021-01-04 21:57:11 +01006028 if (lhs.lhs_new_local)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006029 ++cctx->ctx_locals.ga_len;
6030 if (r == FAIL)
6031 goto theend;
6032 }
Bram Moolenaar9af78762020-06-16 11:34:42 +02006033 else if (semicolon && var_idx == var_count - 1)
6034 {
6035 // For "[var; var] = expr" get the rest of the list
6036 if (generate_SLICE(cctx, var_count - 1) == FAIL)
6037 goto theend;
6038 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006039 else
6040 {
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006041 // For "[var, var] = expr" get the "var_idx" item from the
6042 // list.
6043 if (generate_GETITEM(cctx, var_idx) == FAIL)
Bram Moolenaar7f764942020-12-02 15:11:18 +01006044 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006045 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006046
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006047 rhs_type = stack->ga_len == 0 ? &t_void
Bram Moolenaar6802cce2020-07-19 15:49:49 +02006048 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar752fc692021-01-04 21:57:11 +01006049 if (lhs.lhs_lvar != NULL && (is_decl || !lhs.lhs_has_type))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006050 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006051 if ((rhs_type->tt_type == VAR_FUNC
6052 || rhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006053 && var_wrong_func_name(lhs.lhs_name, TRUE))
Bram Moolenaar0f769812020-09-12 18:32:34 +02006054 goto theend;
6055
Bram Moolenaar752fc692021-01-04 21:57:11 +01006056 if (lhs.lhs_new_local && !lhs.lhs_has_type)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006057 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006058 if (rhs_type->tt_type == VAR_VOID)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006059 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006060 emsg(_(e_cannot_use_void_value));
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006061 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006062 }
6063 else
6064 {
Bram Moolenaar04bdd572020-09-23 13:25:32 +02006065 // An empty list or dict has a &t_unknown member,
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006066 // for a variable that implies &t_any.
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006067 if (rhs_type == &t_list_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006068 lhs.lhs_lvar->lv_type = &t_list_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006069 else if (rhs_type == &t_dict_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006070 lhs.lhs_lvar->lv_type = &t_dict_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006071 else if (rhs_type == &t_unknown)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006072 lhs.lhs_lvar->lv_type = &t_any;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006073 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01006074 lhs.lhs_lvar->lv_type = rhs_type;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006075 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006076 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006077 else if (*op == '=')
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006078 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006079 type_T *use_type = lhs.lhs_lvar->lv_type;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006080
Bram Moolenaar71abe482020-09-14 22:28:30 +02006081 // without operator check type here, otherwise below
Bram Moolenaar752fc692021-01-04 21:57:11 +01006082 if (lhs.lhs_has_index)
6083 use_type = lhs.lhs_member_type;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01006084 if (need_type(rhs_type, use_type, -1, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006085 FALSE, is_const) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006086 goto theend;
6087 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006088 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006089 else if (*p != '=' && need_type(rhs_type, lhs.lhs_member_type,
6090 -1, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006091 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006092 }
Bram Moolenaar30fd8202020-09-26 15:09:30 +02006093 else if (cmdidx == CMD_final)
6094 {
6095 emsg(_(e_final_requires_a_value));
6096 goto theend;
6097 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006098 else if (cmdidx == CMD_const)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006099 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02006100 emsg(_(e_const_requires_a_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006101 goto theend;
6102 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006103 else if (!lhs.lhs_has_type || lhs.lhs_dest == dest_option)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006104 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02006105 emsg(_(e_type_or_initialization_required));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006106 goto theend;
6107 }
6108 else
6109 {
6110 // variables are always initialized
6111 if (ga_grow(instr, 1) == FAIL)
6112 goto theend;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006113 switch (lhs.lhs_member_type->tt_type)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006114 {
6115 case VAR_BOOL:
6116 generate_PUSHBOOL(cctx, VVAL_FALSE);
6117 break;
6118 case VAR_FLOAT:
6119#ifdef FEAT_FLOAT
6120 generate_PUSHF(cctx, 0.0);
6121#endif
6122 break;
6123 case VAR_STRING:
6124 generate_PUSHS(cctx, NULL);
6125 break;
6126 case VAR_BLOB:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02006127 generate_PUSHBLOB(cctx, blob_alloc());
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006128 break;
6129 case VAR_FUNC:
6130 generate_PUSHFUNC(cctx, NULL, &t_func_void);
6131 break;
6132 case VAR_LIST:
6133 generate_NEWLIST(cctx, 0);
6134 break;
6135 case VAR_DICT:
6136 generate_NEWDICT(cctx, 0);
6137 break;
6138 case VAR_JOB:
6139 generate_PUSHJOB(cctx, NULL);
6140 break;
6141 case VAR_CHANNEL:
6142 generate_PUSHCHANNEL(cctx, NULL);
6143 break;
6144 case VAR_NUMBER:
6145 case VAR_UNKNOWN:
6146 case VAR_ANY:
6147 case VAR_PARTIAL:
6148 case VAR_VOID:
6149 case VAR_SPECIAL: // cannot happen
6150 generate_PUSHNR(cctx, 0);
6151 break;
6152 }
6153 }
6154 if (var_count == 0)
6155 end = p;
6156 }
6157
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006158 // no need to parse more when skipping
Bram Moolenaar9b68c822020-06-18 19:31:08 +02006159 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02006160 break;
6161
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006162 if (oplen > 0 && *op != '=')
6163 {
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006164 type_T *expected;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006165 type_T *stacktype;
6166
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006167 if (*op == '.')
6168 expected = &t_string;
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006169 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01006170 expected = lhs.lhs_member_type;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006171 stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006172 if (
6173#ifdef FEAT_FLOAT
6174 // If variable is float operation with number is OK.
6175 !(expected == &t_float && stacktype == &t_number) &&
6176#endif
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006177 need_type(stacktype, expected, -1, cctx,
6178 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006179 goto theend;
6180
6181 if (*op == '.')
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02006182 {
6183 if (generate_instr_drop(cctx, ISN_CONCAT, 1) == NULL)
6184 goto theend;
6185 }
6186 else if (*op == '+')
6187 {
6188 if (generate_add_instr(cctx,
Bram Moolenaar752fc692021-01-04 21:57:11 +01006189 operator_type(lhs.lhs_member_type, stacktype),
6190 lhs.lhs_member_type, stacktype) == FAIL)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02006191 goto theend;
6192 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02006193 else if (generate_two_op(cctx, op) == FAIL)
6194 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006195 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006196
Bram Moolenaar752fc692021-01-04 21:57:11 +01006197 if (lhs.lhs_has_index)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006198 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006199 // Use the info in "lhs" to store the value at the index in the
6200 // list or dict.
6201 if (compile_assign_unlet(var_start, &lhs, TRUE, rhs_type, cctx)
6202 == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006203 goto theend;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006204 }
6205 else
6206 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006207 if (is_decl && cmdidx == CMD_const && (lhs.lhs_dest == dest_script
6208 || lhs.lhs_dest == dest_local))
Bram Moolenaar30fd8202020-09-26 15:09:30 +02006209 // ":const var": lock the value, but not referenced variables
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02006210 generate_LOCKCONST(cctx);
6211
Bram Moolenaaraa210a32021-01-02 15:41:03 +01006212 if (is_decl
Bram Moolenaar752fc692021-01-04 21:57:11 +01006213 && (lhs.lhs_type->tt_type == VAR_DICT
6214 || lhs.lhs_type->tt_type == VAR_LIST)
6215 && lhs.lhs_type->tt_member != NULL
6216 && lhs.lhs_type->tt_member != &t_any
6217 && lhs.lhs_type->tt_member != &t_unknown)
Bram Moolenaaraa210a32021-01-02 15:41:03 +01006218 // Set the type in the list or dict, so that it can be checked,
6219 // also in legacy script.
Bram Moolenaar752fc692021-01-04 21:57:11 +01006220 generate_SETTYPE(cctx, lhs.lhs_type);
Bram Moolenaaraa210a32021-01-02 15:41:03 +01006221
Bram Moolenaar752fc692021-01-04 21:57:11 +01006222 if (lhs.lhs_dest != dest_local)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006223 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006224 if (generate_store_var(cctx, lhs.lhs_dest,
6225 lhs.lhs_opt_flags, lhs.lhs_vimvaridx,
6226 lhs.lhs_scriptvar_idx, lhs.lhs_scriptvar_sid,
6227 lhs.lhs_type, lhs.lhs_name) == FAIL)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006228 goto theend;
6229 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01006230 else if (lhs.lhs_lvar != NULL)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006231 {
6232 isn_T *isn = ((isn_T *)instr->ga_data)
6233 + instr->ga_len - 1;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006234
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006235 // optimization: turn "var = 123" from ISN_PUSHNR +
6236 // ISN_STORE into ISN_STORENR
Bram Moolenaarab360522021-01-10 14:02:28 +01006237 if (lhs.lhs_lvar->lv_from_outer == 0
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006238 && instr->ga_len == instr_count + 1
6239 && isn->isn_type == ISN_PUSHNR)
6240 {
6241 varnumber_T val = isn->isn_arg.number;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006242
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006243 isn->isn_type = ISN_STORENR;
Bram Moolenaar752fc692021-01-04 21:57:11 +01006244 isn->isn_arg.storenr.stnr_idx = lhs.lhs_lvar->lv_idx;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006245 isn->isn_arg.storenr.stnr_val = val;
6246 if (stack->ga_len > 0)
6247 --stack->ga_len;
6248 }
Bram Moolenaarab360522021-01-10 14:02:28 +01006249 else if (lhs.lhs_lvar->lv_from_outer > 0)
6250 generate_STOREOUTER(cctx, lhs.lhs_lvar->lv_idx,
6251 lhs.lhs_lvar->lv_from_outer);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006252 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01006253 generate_STORE(cctx, ISN_STORE, lhs.lhs_lvar->lv_idx, NULL);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006254 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02006255 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006256
6257 if (var_idx + 1 < var_count)
Bram Moolenaar752fc692021-01-04 21:57:11 +01006258 var_start = skipwhite(lhs.lhs_dest_end + 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006259 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006260
6261 // for "[var, var] = expr" drop the "expr" value
Bram Moolenaar9af78762020-06-16 11:34:42 +02006262 if (var_count > 0 && !semicolon)
6263 {
Bram Moolenaarec792292020-12-13 21:26:56 +01006264 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
Bram Moolenaar9af78762020-06-16 11:34:42 +02006265 goto theend;
6266 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02006267
Bram Moolenaarb2097502020-07-19 17:17:02 +02006268 ret = skipwhite(end);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006269
6270theend:
Bram Moolenaar752fc692021-01-04 21:57:11 +01006271 vim_free(lhs.lhs_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006272 return ret;
6273}
6274
6275/*
Bram Moolenaar17126b12021-01-07 22:03:02 +01006276 * Check for an assignment at "eap->cmd", compile it if found.
6277 * Return NOTDONE if there is none, FAIL for failure, OK if done.
6278 */
6279 static int
6280may_compile_assignment(exarg_T *eap, char_u **line, cctx_T *cctx)
6281{
6282 char_u *pskip;
6283 char_u *p;
6284
6285 // Assuming the command starts with a variable or function name,
6286 // find what follows.
6287 // Skip over "var.member", "var[idx]" and the like.
6288 // Also "&opt = val", "$ENV = val" and "@r = val".
6289 pskip = (*eap->cmd == '&' || *eap->cmd == '$' || *eap->cmd == '@')
6290 ? eap->cmd + 1 : eap->cmd;
6291 p = to_name_end(pskip, TRUE);
6292 if (p > eap->cmd && *p != NUL)
6293 {
6294 char_u *var_end;
6295 int oplen;
6296 int heredoc;
6297
6298 if (eap->cmd[0] == '@')
6299 var_end = eap->cmd + 2;
6300 else
6301 var_end = find_name_end(pskip, NULL, NULL,
6302 FNE_CHECK_START | FNE_INCL_BR);
6303 oplen = assignment_len(skipwhite(var_end), &heredoc);
6304 if (oplen > 0)
6305 {
6306 size_t len = p - eap->cmd;
6307
6308 // Recognize an assignment if we recognize the variable
6309 // name:
6310 // "g:var = expr"
6311 // "local = expr" where "local" is a local var.
6312 // "script = expr" where "script" is a script-local var.
6313 // "import = expr" where "import" is an imported var
6314 // "&opt = expr"
6315 // "$ENV = expr"
6316 // "@r = expr"
6317 if (*eap->cmd == '&'
6318 || *eap->cmd == '$'
6319 || *eap->cmd == '@'
6320 || ((len) > 2 && eap->cmd[1] == ':')
6321 || lookup_local(eap->cmd, len, NULL, cctx) == OK
6322 || arg_exists(eap->cmd, len, NULL, NULL, NULL, cctx) == OK
6323 || script_var_exists(eap->cmd, len, FALSE, cctx) == OK
6324 || find_imported(eap->cmd, len, cctx) != NULL)
6325 {
6326 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
6327 if (*line == NULL || *line == eap->cmd)
6328 return FAIL;
6329 return OK;
6330 }
6331 }
6332 }
6333
6334 if (*eap->cmd == '[')
6335 {
6336 // [var, var] = expr
6337 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
6338 if (*line == NULL)
6339 return FAIL;
6340 if (*line != eap->cmd)
6341 return OK;
6342 }
6343 return NOTDONE;
6344}
6345
6346/*
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006347 * Check if "name" can be "unlet".
6348 */
6349 int
6350check_vim9_unlet(char_u *name)
6351{
6352 if (name[1] != ':' || vim_strchr((char_u *)"gwtb", *name) == NULL)
6353 {
Bram Moolenaar84367732020-08-23 15:21:55 +02006354 // "unlet s:var" is allowed in legacy script.
6355 if (*name == 's' && !script_is_vim9())
6356 return OK;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006357 semsg(_(e_cannot_unlet_str), name);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006358 return FAIL;
6359 }
6360 return OK;
6361}
6362
6363/*
6364 * Callback passed to ex_unletlock().
6365 */
6366 static int
6367compile_unlet(
6368 lval_T *lvp,
6369 char_u *name_end,
6370 exarg_T *eap,
6371 int deep UNUSED,
6372 void *coookie)
6373{
Bram Moolenaar752fc692021-01-04 21:57:11 +01006374 cctx_T *cctx = coookie;
6375 char_u *p = lvp->ll_name;
6376 int cc = *name_end;
6377 int ret = OK;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006378
Bram Moolenaar752fc692021-01-04 21:57:11 +01006379 if (cctx->ctx_skip == SKIP_YES)
6380 return OK;
6381
6382 *name_end = NUL;
6383 if (*p == '$')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006384 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006385 // :unlet $ENV_VAR
6386 ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit);
6387 }
6388 else if (vim_strchr(p, '.') != NULL || vim_strchr(p, '[') != NULL)
6389 {
6390 lhs_T lhs;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006391
Bram Moolenaar752fc692021-01-04 21:57:11 +01006392 // This is similar to assigning: lookup the list/dict, compile the
6393 // idx/key. Then instead of storing the value unlet the item.
6394 // unlet {list}[idx]
6395 // unlet {dict}[key] dict.key
6396 //
6397 // Figure out the LHS type and other properties.
6398 //
6399 ret = compile_lhs(p, &lhs, CMD_unlet, FALSE, 0, cctx);
6400
6401 // : unlet an indexed item
6402 if (!lhs.lhs_has_index)
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01006403 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01006404 iemsg("called compile_lhs() without an index");
6405 ret = FAIL;
6406 }
6407 else
6408 {
6409 // Use the info in "lhs" to unlet the item at the index in the
6410 // list or dict.
6411 ret = compile_assign_unlet(p, &lhs, FALSE, &t_void, cctx);
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01006412 }
6413
Bram Moolenaar752fc692021-01-04 21:57:11 +01006414 vim_free(lhs.lhs_name);
6415 }
6416 else if (check_vim9_unlet(p) == FAIL)
6417 {
6418 ret = FAIL;
6419 }
6420 else
6421 {
6422 // Normal name. Only supports g:, w:, t: and b: namespaces.
6423 ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006424 }
6425
Bram Moolenaar752fc692021-01-04 21:57:11 +01006426 *name_end = cc;
6427 return ret;
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006428}
6429
6430/*
6431 * compile "unlet var", "lock var" and "unlock var"
6432 * "arg" points to "var".
6433 */
6434 static char_u *
6435compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx)
6436{
6437 char_u *p = arg;
6438
6439 if (eap->cmdidx != CMD_unlet)
6440 {
6441 emsg("Sorry, :lock and unlock not implemented yet");
6442 return NULL;
6443 }
6444
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01006445 ex_unletlock(eap, p, 0, GLV_NO_AUTOLOAD | GLV_COMPILING,
6446 compile_unlet, cctx);
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02006447 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
6448}
6449
6450/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006451 * Compile an :import command.
6452 */
6453 static char_u *
6454compile_import(char_u *arg, cctx_T *cctx)
6455{
Bram Moolenaar1c991142020-07-04 13:15:31 +02006456 return handle_import(arg, &cctx->ctx_imports, 0, NULL, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006457}
6458
6459/*
6460 * generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry".
6461 */
6462 static int
6463compile_jump_to_end(endlabel_T **el, jumpwhen_T when, cctx_T *cctx)
6464{
6465 garray_T *instr = &cctx->ctx_instr;
6466 endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T);
6467
6468 if (endlabel == NULL)
6469 return FAIL;
6470 endlabel->el_next = *el;
6471 *el = endlabel;
6472 endlabel->el_end_label = instr->ga_len;
6473
6474 generate_JUMP(cctx, when, 0);
6475 return OK;
6476}
6477
6478 static void
6479compile_fill_jump_to_end(endlabel_T **el, cctx_T *cctx)
6480{
6481 garray_T *instr = &cctx->ctx_instr;
6482
6483 while (*el != NULL)
6484 {
6485 endlabel_T *cur = (*el);
6486 isn_T *isn;
6487
6488 isn = ((isn_T *)instr->ga_data) + cur->el_end_label;
6489 isn->isn_arg.jump.jump_where = instr->ga_len;
6490 *el = cur->el_next;
6491 vim_free(cur);
6492 }
6493}
6494
Bram Moolenaar3cca2992020-04-02 22:57:36 +02006495 static void
6496compile_free_jump_to_end(endlabel_T **el)
6497{
6498 while (*el != NULL)
6499 {
6500 endlabel_T *cur = (*el);
6501
6502 *el = cur->el_next;
6503 vim_free(cur);
6504 }
6505}
6506
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006507/*
6508 * Create a new scope and set up the generic items.
6509 */
6510 static scope_T *
6511new_scope(cctx_T *cctx, scopetype_T type)
6512{
6513 scope_T *scope = ALLOC_CLEAR_ONE(scope_T);
6514
6515 if (scope == NULL)
6516 return NULL;
6517 scope->se_outer = cctx->ctx_scope;
6518 cctx->ctx_scope = scope;
6519 scope->se_type = type;
6520 scope->se_local_count = cctx->ctx_locals.ga_len;
6521 return scope;
6522}
6523
6524/*
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006525 * Free the current scope and go back to the outer scope.
6526 */
6527 static void
6528drop_scope(cctx_T *cctx)
6529{
6530 scope_T *scope = cctx->ctx_scope;
6531
6532 if (scope == NULL)
6533 {
6534 iemsg("calling drop_scope() without a scope");
6535 return;
6536 }
6537 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar3cca2992020-04-02 22:57:36 +02006538 switch (scope->se_type)
6539 {
6540 case IF_SCOPE:
6541 compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break;
6542 case FOR_SCOPE:
6543 compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break;
6544 case WHILE_SCOPE:
6545 compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break;
6546 case TRY_SCOPE:
6547 compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break;
6548 case NO_SCOPE:
6549 case BLOCK_SCOPE:
6550 break;
6551 }
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006552 vim_free(scope);
6553}
6554
6555/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006556 * compile "if expr"
6557 *
6558 * "if expr" Produces instructions:
6559 * EVAL expr Push result of "expr"
6560 * JUMP_IF_FALSE end
6561 * ... body ...
6562 * end:
6563 *
6564 * "if expr | else" Produces instructions:
6565 * EVAL expr Push result of "expr"
6566 * JUMP_IF_FALSE else
6567 * ... body ...
6568 * JUMP_ALWAYS end
6569 * else:
6570 * ... body ...
6571 * end:
6572 *
6573 * "if expr1 | elseif expr2 | else" Produces instructions:
6574 * EVAL expr Push result of "expr"
6575 * JUMP_IF_FALSE elseif
6576 * ... body ...
6577 * JUMP_ALWAYS end
6578 * elseif:
6579 * EVAL expr Push result of "expr"
6580 * JUMP_IF_FALSE else
6581 * ... body ...
6582 * JUMP_ALWAYS end
6583 * else:
6584 * ... body ...
6585 * end:
6586 */
6587 static char_u *
6588compile_if(char_u *arg, cctx_T *cctx)
6589{
6590 char_u *p = arg;
6591 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaara5565e42020-05-09 15:44:01 +02006592 int instr_count = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006593 scope_T *scope;
Bram Moolenaarefd88552020-06-18 20:50:10 +02006594 skip_T skip_save = cctx->ctx_skip;
Bram Moolenaara5565e42020-05-09 15:44:01 +02006595 ppconst_T ppconst;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006596
Bram Moolenaara5565e42020-05-09 15:44:01 +02006597 CLEAR_FIELD(ppconst);
6598 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006599 {
Bram Moolenaara5565e42020-05-09 15:44:01 +02006600 clear_ppconst(&ppconst);
6601 return NULL;
6602 }
Bram Moolenaarefd88552020-06-18 20:50:10 +02006603 if (cctx->ctx_skip == SKIP_YES)
6604 clear_ppconst(&ppconst);
6605 else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
Bram Moolenaara5565e42020-05-09 15:44:01 +02006606 {
Bram Moolenaar13106602020-10-04 16:06:05 +02006607 int error = FALSE;
6608 int v;
6609
Bram Moolenaara5565e42020-05-09 15:44:01 +02006610 // The expression results in a constant.
Bram Moolenaar13106602020-10-04 16:06:05 +02006611 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error);
Bram Moolenaardda749c2020-10-04 17:24:29 +02006612 clear_ppconst(&ppconst);
Bram Moolenaar13106602020-10-04 16:06:05 +02006613 if (error)
6614 return NULL;
6615 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES;
Bram Moolenaara5565e42020-05-09 15:44:01 +02006616 }
6617 else
6618 {
6619 // Not a constant, generate instructions for the expression.
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006620 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaara5565e42020-05-09 15:44:01 +02006621 if (generate_ppconst(cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006622 return NULL;
Bram Moolenaar13106602020-10-04 16:06:05 +02006623 if (bool_on_stack(cctx) == FAIL)
6624 return NULL;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006625 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006626
6627 scope = new_scope(cctx, IF_SCOPE);
6628 if (scope == NULL)
6629 return NULL;
Bram Moolenaarefd88552020-06-18 20:50:10 +02006630 scope->se_skip_save = skip_save;
6631 // "is_had_return" will be reset if any block does not end in :return
6632 scope->se_u.se_if.is_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006633
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006634 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006635 {
6636 // "where" is set when ":elseif", "else" or ":endif" is found
6637 scope->se_u.se_if.is_if_label = instr->ga_len;
6638 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
6639 }
6640 else
6641 scope->se_u.se_if.is_if_label = -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006642
6643 return p;
6644}
6645
6646 static char_u *
6647compile_elseif(char_u *arg, cctx_T *cctx)
6648{
6649 char_u *p = arg;
6650 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar7f141552020-05-09 17:35:53 +02006651 int instr_count = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006652 isn_T *isn;
6653 scope_T *scope = cctx->ctx_scope;
Bram Moolenaar7f141552020-05-09 17:35:53 +02006654 ppconst_T ppconst;
Bram Moolenaar749639e2020-08-27 23:08:47 +02006655 skip_T save_skip = cctx->ctx_skip;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006656
6657 if (scope == NULL || scope->se_type != IF_SCOPE)
6658 {
6659 emsg(_(e_elseif_without_if));
6660 return NULL;
6661 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01006662 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02006663 if (!cctx->ctx_had_return)
6664 scope->se_u.se_if.is_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006665
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006666 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006667 {
6668 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006669 JUMP_ALWAYS, cctx) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006670 return NULL;
6671 // previous "if" or "elseif" jumps here
6672 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
6673 isn->isn_arg.jump.jump_where = instr->ga_len;
6674 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006675
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006676 // compile "expr"; if we know it evaluates to FALSE skip the block
Bram Moolenaar7f141552020-05-09 17:35:53 +02006677 CLEAR_FIELD(ppconst);
Bram Moolenaar749639e2020-08-27 23:08:47 +02006678 if (cctx->ctx_skip == SKIP_YES)
6679 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaar7f141552020-05-09 17:35:53 +02006680 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006681 {
Bram Moolenaar7f141552020-05-09 17:35:53 +02006682 clear_ppconst(&ppconst);
6683 return NULL;
6684 }
Bram Moolenaar749639e2020-08-27 23:08:47 +02006685 cctx->ctx_skip = save_skip;
Bram Moolenaarefd88552020-06-18 20:50:10 +02006686 if (scope->se_skip_save == SKIP_YES)
6687 clear_ppconst(&ppconst);
6688 else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
Bram Moolenaar7f141552020-05-09 17:35:53 +02006689 {
Bram Moolenaar13106602020-10-04 16:06:05 +02006690 int error = FALSE;
6691 int v;
6692
Bram Moolenaar7f141552020-05-09 17:35:53 +02006693 // The expression results in a constant.
6694 // TODO: how about nesting?
Bram Moolenaar13106602020-10-04 16:06:05 +02006695 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error);
6696 if (error)
6697 return NULL;
6698 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES;
Bram Moolenaar7f141552020-05-09 17:35:53 +02006699 clear_ppconst(&ppconst);
6700 scope->se_u.se_if.is_if_label = -1;
6701 }
6702 else
6703 {
6704 // Not a constant, generate instructions for the expression.
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006705 cctx->ctx_skip = SKIP_UNKNOWN;
Bram Moolenaar7f141552020-05-09 17:35:53 +02006706 if (generate_ppconst(cctx, &ppconst) == FAIL)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006707 return NULL;
Bram Moolenaar13106602020-10-04 16:06:05 +02006708 if (bool_on_stack(cctx) == FAIL)
6709 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006710
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006711 // "where" is set when ":elseif", "else" or ":endif" is found
6712 scope->se_u.se_if.is_if_label = instr->ga_len;
6713 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
6714 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006715
6716 return p;
6717}
6718
6719 static char_u *
6720compile_else(char_u *arg, cctx_T *cctx)
6721{
6722 char_u *p = arg;
6723 garray_T *instr = &cctx->ctx_instr;
6724 isn_T *isn;
6725 scope_T *scope = cctx->ctx_scope;
6726
6727 if (scope == NULL || scope->se_type != IF_SCOPE)
6728 {
6729 emsg(_(e_else_without_if));
6730 return NULL;
6731 }
Bram Moolenaar20431c92020-03-20 18:39:46 +01006732 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02006733 if (!cctx->ctx_had_return)
6734 scope->se_u.se_if.is_had_return = FALSE;
6735 scope->se_u.se_if.is_seen_else = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006736
Bram Moolenaarefd88552020-06-18 20:50:10 +02006737 if (scope->se_skip_save != SKIP_YES)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006738 {
Bram Moolenaarefd88552020-06-18 20:50:10 +02006739 // jump from previous block to the end, unless the else block is empty
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006740 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006741 {
Bram Moolenaarefd88552020-06-18 20:50:10 +02006742 if (!cctx->ctx_had_return
6743 && compile_jump_to_end(&scope->se_u.se_if.is_end_label,
6744 JUMP_ALWAYS, cctx) == FAIL)
6745 return NULL;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006746 }
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006747
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006748 if (cctx->ctx_skip == SKIP_UNKNOWN)
Bram Moolenaarefd88552020-06-18 20:50:10 +02006749 {
6750 if (scope->se_u.se_if.is_if_label >= 0)
6751 {
6752 // previous "if" or "elseif" jumps here
6753 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
6754 isn->isn_arg.jump.jump_where = instr->ga_len;
6755 scope->se_u.se_if.is_if_label = -1;
6756 }
6757 }
6758
Bram Moolenaar280b0dc2020-06-20 13:29:03 +02006759 if (cctx->ctx_skip != SKIP_UNKNOWN)
Bram Moolenaarefd88552020-06-18 20:50:10 +02006760 cctx->ctx_skip = cctx->ctx_skip == SKIP_YES ? SKIP_NOT : SKIP_YES;
6761 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006762
6763 return p;
6764}
6765
6766 static char_u *
6767compile_endif(char_u *arg, cctx_T *cctx)
6768{
6769 scope_T *scope = cctx->ctx_scope;
6770 ifscope_T *ifscope;
6771 garray_T *instr = &cctx->ctx_instr;
6772 isn_T *isn;
6773
6774 if (scope == NULL || scope->se_type != IF_SCOPE)
6775 {
6776 emsg(_(e_endif_without_if));
6777 return NULL;
6778 }
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006779 ifscope = &scope->se_u.se_if;
Bram Moolenaar20431c92020-03-20 18:39:46 +01006780 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaarefd88552020-06-18 20:50:10 +02006781 if (!cctx->ctx_had_return)
6782 ifscope->is_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006783
Bram Moolenaara259d8d2020-01-31 20:10:50 +01006784 if (scope->se_u.se_if.is_if_label >= 0)
6785 {
6786 // previous "if" or "elseif" jumps here
6787 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
6788 isn->isn_arg.jump.jump_where = instr->ga_len;
6789 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006790 // Fill in the "end" label in jumps at the end of the blocks.
6791 compile_fill_jump_to_end(&ifscope->is_end_label, cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02006792 cctx->ctx_skip = scope->se_skip_save;
6793
6794 // If all the blocks end in :return and there is an :else then the
6795 // had_return flag is set.
6796 cctx->ctx_had_return = ifscope->is_had_return && ifscope->is_seen_else;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006797
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006798 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006799 return arg;
6800}
6801
6802/*
Bram Moolenaar792f7862020-11-23 08:31:18 +01006803 * Compile "for var in expr":
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006804 *
6805 * Produces instructions:
6806 * PUSHNR -1
6807 * STORE loop-idx Set index to -1
Bram Moolenaar792f7862020-11-23 08:31:18 +01006808 * EVAL expr result of "expr" on top of stack
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006809 * top: FOR loop-idx, end Increment index, use list on bottom of stack
6810 * - if beyond end, jump to "end"
6811 * - otherwise get item from list and push it
6812 * STORE var Store item in "var"
6813 * ... body ...
6814 * JUMP top Jump back to repeat
6815 * end: DROP Drop the result of "expr"
6816 *
Bram Moolenaar792f7862020-11-23 08:31:18 +01006817 * Compile "for [var1, var2] in expr" - as above, but instead of "STORE var":
6818 * UNPACK 2 Split item in 2
6819 * STORE var1 Store item in "var1"
6820 * STORE var2 Store item in "var2"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006821 */
6822 static char_u *
Bram Moolenaar792f7862020-11-23 08:31:18 +01006823compile_for(char_u *arg_start, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006824{
Bram Moolenaar792f7862020-11-23 08:31:18 +01006825 char_u *arg;
6826 char_u *arg_end;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006827 char_u *name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006828 char_u *p;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01006829 char_u *wp;
Bram Moolenaar792f7862020-11-23 08:31:18 +01006830 int var_count = 0;
6831 int semicolon = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006832 size_t varlen;
6833 garray_T *instr = &cctx->ctx_instr;
6834 garray_T *stack = &cctx->ctx_type_stack;
6835 scope_T *scope;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02006836 lvar_T *loop_lvar; // loop iteration variable
6837 lvar_T *var_lvar; // variable for "var"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006838 type_T *vartype;
Bram Moolenaar792f7862020-11-23 08:31:18 +01006839 type_T *item_type = &t_any;
6840 int idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006841
Bram Moolenaar792f7862020-11-23 08:31:18 +01006842 p = skip_var_list(arg_start, TRUE, &var_count, &semicolon, FALSE);
6843 if (var_count == 0)
6844 var_count = 1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006845
6846 // consume "in"
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01006847 wp = p;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01006848 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
6849 return NULL;
6850 if (STRNCMP(p, "in", 2) != 0 || !IS_WHITE_OR_NUL(p[2]))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006851 {
6852 emsg(_(e_missing_in));
6853 return NULL;
6854 }
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01006855 wp = p + 2;
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01006856 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
6857 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006858
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006859 scope = new_scope(cctx, FOR_SCOPE);
6860 if (scope == NULL)
6861 return NULL;
6862
Bram Moolenaar792f7862020-11-23 08:31:18 +01006863 // Reserve a variable to store the loop iteration counter and initialize it
6864 // to -1.
Bram Moolenaarb84a3812020-05-01 15:44:29 +02006865 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
6866 if (loop_lvar == NULL)
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006867 {
Bram Moolenaarb84a3812020-05-01 15:44:29 +02006868 // out of memory
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006869 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006870 return NULL;
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006871 }
Bram Moolenaarb84a3812020-05-01 15:44:29 +02006872 generate_STORENR(cctx, loop_lvar->lv_idx, -1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006873
6874 // compile "expr", it remains on the stack until "endfor"
6875 arg = p;
Bram Moolenaara5565e42020-05-09 15:44:01 +02006876 if (compile_expr0(&arg, cctx) == FAIL)
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006877 {
6878 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006879 return NULL;
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006880 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01006881 arg_end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006882
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02006883 // Now that we know the type of "var", check that it is a list, now or at
6884 // runtime.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006885 vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
Bram Moolenaar334a8b42020-10-19 16:07:42 +02006886 if (need_type(vartype, &t_list_any, -1, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006887 {
Bram Moolenaar25b70c72020-04-01 16:34:17 +02006888 drop_scope(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006889 return NULL;
6890 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01006891
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02006892 if (vartype->tt_type == VAR_LIST && vartype->tt_member->tt_type != VAR_ANY)
Bram Moolenaar792f7862020-11-23 08:31:18 +01006893 {
6894 if (var_count == 1)
6895 item_type = vartype->tt_member;
6896 else if (vartype->tt_member->tt_type == VAR_LIST
6897 && vartype->tt_member->tt_member->tt_type != VAR_ANY)
6898 item_type = vartype->tt_member->tt_member;
6899 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006900
6901 // "for_end" is set when ":endfor" is found
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01006902 scope->se_u.se_for.fs_top_label = instr->ga_len;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02006903 generate_FOR(cctx, loop_lvar->lv_idx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006904
Bram Moolenaar792f7862020-11-23 08:31:18 +01006905 arg = arg_start;
6906 if (var_count > 1)
6907 {
6908 generate_UNPACK(cctx, var_count, semicolon);
6909 arg = skipwhite(arg + 1); // skip white after '['
6910
6911 // the list item is replaced by a number of items
6912 if (ga_grow(stack, var_count - 1) == FAIL)
6913 {
6914 drop_scope(cctx);
6915 return NULL;
6916 }
6917 --stack->ga_len;
6918 for (idx = 0; idx < var_count; ++idx)
6919 {
6920 ((type_T **)stack->ga_data)[stack->ga_len] =
6921 (semicolon && idx == 0) ? vartype : item_type;
6922 ++stack->ga_len;
6923 }
6924 }
6925
6926 for (idx = 0; idx < var_count; ++idx)
6927 {
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006928 assign_dest_T dest = dest_local;
6929 int opt_flags = 0;
6930 int vimvaridx = -1;
6931 type_T *type = &t_any;
6932
6933 p = skip_var_one(arg, FALSE);
Bram Moolenaar792f7862020-11-23 08:31:18 +01006934 varlen = p - arg;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006935 name = vim_strnsave(arg, varlen);
6936 if (name == NULL)
6937 goto failed;
Bram Moolenaar792f7862020-11-23 08:31:18 +01006938
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006939 // TODO: script var not supported?
6940 if (get_var_dest(name, &dest, CMD_for, &opt_flags,
6941 &vimvaridx, &type, cctx) == FAIL)
6942 goto failed;
6943 if (dest != dest_local)
Bram Moolenaar792f7862020-11-23 08:31:18 +01006944 {
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006945 if (generate_store_var(cctx, dest, opt_flags, vimvaridx,
6946 0, 0, type, name) == FAIL)
6947 goto failed;
Bram Moolenaar792f7862020-11-23 08:31:18 +01006948 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01006949 else
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006950 {
Bram Moolenaar709664c2020-12-12 14:33:41 +01006951 if (lookup_local(arg, varlen, NULL, cctx) == OK)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006952 {
6953 semsg(_(e_variable_already_declared), arg);
6954 goto failed;
6955 }
6956
Bram Moolenaarea870692020-12-02 14:24:30 +01006957 if (STRNCMP(name, "s:", 2) == 0)
6958 {
6959 semsg(_(e_cannot_declare_script_variable_in_function), name);
6960 goto failed;
6961 }
6962
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006963 // Reserve a variable to store "var".
6964 // TODO: check for type
6965 var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any);
6966 if (var_lvar == NULL)
6967 // out of memory or used as an argument
6968 goto failed;
6969
6970 if (semicolon && idx == var_count - 1)
6971 var_lvar->lv_type = vartype;
6972 else
6973 var_lvar->lv_type = item_type;
6974 generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
6975 }
Bram Moolenaar792f7862020-11-23 08:31:18 +01006976
6977 if (*p == ',' || *p == ';')
6978 ++p;
6979 arg = skipwhite(p);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006980 vim_free(name);
Bram Moolenaar792f7862020-11-23 08:31:18 +01006981 }
6982
6983 return arg_end;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01006984
6985failed:
6986 vim_free(name);
6987 drop_scope(cctx);
6988 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006989}
6990
6991/*
6992 * compile "endfor"
6993 */
6994 static char_u *
6995compile_endfor(char_u *arg, cctx_T *cctx)
6996{
6997 garray_T *instr = &cctx->ctx_instr;
6998 scope_T *scope = cctx->ctx_scope;
6999 forscope_T *forscope;
7000 isn_T *isn;
7001
7002 if (scope == NULL || scope->se_type != FOR_SCOPE)
7003 {
7004 emsg(_(e_for));
7005 return NULL;
7006 }
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007007 forscope = &scope->se_u.se_for;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007008 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01007009 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007010
7011 // At end of ":for" scope jump back to the FOR instruction.
7012 generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label);
7013
7014 // Fill in the "end" label in the FOR statement so it can jump here
7015 isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label;
7016 isn->isn_arg.forloop.for_end = instr->ga_len;
7017
7018 // Fill in the "end" label any BREAK statements
7019 compile_fill_jump_to_end(&forscope->fs_end_label, cctx);
7020
7021 // Below the ":for" scope drop the "expr" list from the stack.
7022 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
7023 return NULL;
7024
7025 vim_free(scope);
7026
7027 return arg;
7028}
7029
7030/*
7031 * compile "while expr"
7032 *
7033 * Produces instructions:
7034 * top: EVAL expr Push result of "expr"
7035 * JUMP_IF_FALSE end jump if false
7036 * ... body ...
7037 * JUMP top Jump back to repeat
7038 * end:
7039 *
7040 */
7041 static char_u *
7042compile_while(char_u *arg, cctx_T *cctx)
7043{
7044 char_u *p = arg;
7045 garray_T *instr = &cctx->ctx_instr;
7046 scope_T *scope;
7047
7048 scope = new_scope(cctx, WHILE_SCOPE);
7049 if (scope == NULL)
7050 return NULL;
7051
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007052 scope->se_u.se_while.ws_top_label = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007053
7054 // compile "expr"
Bram Moolenaara5565e42020-05-09 15:44:01 +02007055 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007056 return NULL;
7057
Bram Moolenaar13106602020-10-04 16:06:05 +02007058 if (bool_on_stack(cctx) == FAIL)
7059 return FAIL;
7060
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007061 // "while_end" is set when ":endwhile" is found
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007062 if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007063 JUMP_IF_FALSE, cctx) == FAIL)
7064 return FAIL;
7065
7066 return p;
7067}
7068
7069/*
7070 * compile "endwhile"
7071 */
7072 static char_u *
7073compile_endwhile(char_u *arg, cctx_T *cctx)
7074{
7075 scope_T *scope = cctx->ctx_scope;
7076
7077 if (scope == NULL || scope->se_type != WHILE_SCOPE)
7078 {
7079 emsg(_(e_while));
7080 return NULL;
7081 }
7082 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01007083 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007084
7085 // At end of ":for" scope jump back to the FOR instruction.
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007086 generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007087
7088 // Fill in the "end" label in the WHILE statement so it can jump here.
7089 // And in any jumps for ":break"
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007090 compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007091
7092 vim_free(scope);
7093
7094 return arg;
7095}
7096
7097/*
7098 * compile "continue"
7099 */
7100 static char_u *
7101compile_continue(char_u *arg, cctx_T *cctx)
7102{
7103 scope_T *scope = cctx->ctx_scope;
7104
7105 for (;;)
7106 {
7107 if (scope == NULL)
7108 {
7109 emsg(_(e_continue));
7110 return NULL;
7111 }
7112 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE)
7113 break;
7114 scope = scope->se_outer;
7115 }
7116
7117 // Jump back to the FOR or WHILE instruction.
7118 generate_JUMP(cctx, JUMP_ALWAYS,
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007119 scope->se_type == FOR_SCOPE ? scope->se_u.se_for.fs_top_label
7120 : scope->se_u.se_while.ws_top_label);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007121 return arg;
7122}
7123
7124/*
7125 * compile "break"
7126 */
7127 static char_u *
7128compile_break(char_u *arg, cctx_T *cctx)
7129{
7130 scope_T *scope = cctx->ctx_scope;
7131 endlabel_T **el;
7132
7133 for (;;)
7134 {
7135 if (scope == NULL)
7136 {
7137 emsg(_(e_break));
7138 return NULL;
7139 }
7140 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE)
7141 break;
7142 scope = scope->se_outer;
7143 }
7144
7145 // Jump to the end of the FOR or WHILE loop.
7146 if (scope->se_type == FOR_SCOPE)
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007147 el = &scope->se_u.se_for.fs_end_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007148 else
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007149 el = &scope->se_u.se_while.ws_end_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007150 if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL)
7151 return FAIL;
7152
7153 return arg;
7154}
7155
7156/*
7157 * compile "{" start of block
7158 */
7159 static char_u *
7160compile_block(char_u *arg, cctx_T *cctx)
7161{
7162 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
7163 return NULL;
7164 return skipwhite(arg + 1);
7165}
7166
7167/*
7168 * compile end of block: drop one scope
7169 */
7170 static void
7171compile_endblock(cctx_T *cctx)
7172{
7173 scope_T *scope = cctx->ctx_scope;
7174
7175 cctx->ctx_scope = scope->se_outer;
Bram Moolenaar20431c92020-03-20 18:39:46 +01007176 unwind_locals(cctx, scope->se_local_count);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007177 vim_free(scope);
7178}
7179
7180/*
7181 * compile "try"
7182 * Creates a new scope for the try-endtry, pointing to the first catch and
7183 * finally.
7184 * Creates another scope for the "try" block itself.
7185 * TRY instruction sets up exception handling at runtime.
7186 *
7187 * "try"
7188 * TRY -> catch1, -> finally push trystack entry
7189 * ... try block
7190 * "throw {exception}"
7191 * EVAL {exception}
7192 * THROW create exception
7193 * ... try block
7194 * " catch {expr}"
7195 * JUMP -> finally
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01007196 * catch1: PUSH exception
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007197 * EVAL {expr}
7198 * MATCH
7199 * JUMP nomatch -> catch2
7200 * CATCH remove exception
7201 * ... catch block
7202 * " catch"
7203 * JUMP -> finally
7204 * catch2: CATCH remove exception
7205 * ... catch block
7206 * " finally"
7207 * finally:
7208 * ... finally block
7209 * " endtry"
7210 * ENDTRY pop trystack entry, may rethrow
7211 */
7212 static char_u *
7213compile_try(char_u *arg, cctx_T *cctx)
7214{
7215 garray_T *instr = &cctx->ctx_instr;
7216 scope_T *try_scope;
7217 scope_T *scope;
7218
7219 // scope that holds the jumps that go to catch/finally/endtry
7220 try_scope = new_scope(cctx, TRY_SCOPE);
7221 if (try_scope == NULL)
7222 return NULL;
7223
Bram Moolenaar69f70502021-01-01 16:10:46 +01007224 if (cctx->ctx_skip != SKIP_YES)
7225 {
7226 // "catch" is set when the first ":catch" is found.
7227 // "finally" is set when ":finally" or ":endtry" is found
7228 try_scope->se_u.se_try.ts_try_label = instr->ga_len;
7229 if (generate_instr(cctx, ISN_TRY) == NULL)
7230 return NULL;
7231 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007232
7233 // scope for the try block itself
7234 scope = new_scope(cctx, BLOCK_SCOPE);
7235 if (scope == NULL)
7236 return NULL;
7237
7238 return arg;
7239}
7240
7241/*
7242 * compile "catch {expr}"
7243 */
7244 static char_u *
7245compile_catch(char_u *arg, cctx_T *cctx UNUSED)
7246{
7247 scope_T *scope = cctx->ctx_scope;
7248 garray_T *instr = &cctx->ctx_instr;
7249 char_u *p;
7250 isn_T *isn;
7251
7252 // end block scope from :try or :catch
7253 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
7254 compile_endblock(cctx);
7255 scope = cctx->ctx_scope;
7256
7257 // Error if not in a :try scope
7258 if (scope == NULL || scope->se_type != TRY_SCOPE)
7259 {
7260 emsg(_(e_catch));
7261 return NULL;
7262 }
7263
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007264 if (scope->se_u.se_try.ts_caught_all)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007265 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02007266 emsg(_(e_catch_unreachable_after_catch_all));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007267 return NULL;
7268 }
7269
Bram Moolenaar69f70502021-01-01 16:10:46 +01007270 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007271 {
Bram Moolenaar69f70502021-01-01 16:10:46 +01007272 // Jump from end of previous block to :finally or :endtry
7273 if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label,
7274 JUMP_ALWAYS, cctx) == FAIL)
7275 return NULL;
7276
7277 // End :try or :catch scope: set value in ISN_TRY instruction
7278 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
7279 if (isn->isn_arg.try.try_catch == 0)
7280 isn->isn_arg.try.try_catch = instr->ga_len;
7281 if (scope->se_u.se_try.ts_catch_label != 0)
7282 {
7283 // Previous catch without match jumps here
7284 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
7285 isn->isn_arg.jump.jump_where = instr->ga_len;
7286 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007287 }
7288
7289 p = skipwhite(arg);
Bram Moolenaar7a092242020-04-16 22:10:49 +02007290 if (ends_excmd2(arg, p))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007291 {
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007292 scope->se_u.se_try.ts_caught_all = TRUE;
7293 scope->se_u.se_try.ts_catch_label = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007294 }
7295 else
7296 {
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007297 char_u *end;
7298 char_u *pat;
7299 char_u *tofree = NULL;
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02007300 int dropped = 0;
Bram Moolenaar3dd64602020-02-13 20:31:28 +01007301 int len;
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007302
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007303 // Push v:exception, push {expr} and MATCH
7304 generate_instr_type(cctx, ISN_PUSHEXC, &t_string);
7305
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007306 end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped, NULL);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007307 if (*end != *p)
7308 {
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02007309 semsg(_(e_separator_mismatch_str), p);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007310 vim_free(tofree);
7311 return FAIL;
7312 }
7313 if (tofree == NULL)
Bram Moolenaar3dd64602020-02-13 20:31:28 +01007314 len = (int)(end - (p + 1));
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007315 else
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02007316 len = (int)(end - tofree);
7317 pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len);
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007318 vim_free(tofree);
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02007319 p += len + 2 + dropped;
Bram Moolenaarff80cb62020-02-05 22:10:05 +01007320 if (pat == NULL)
7321 return FAIL;
7322 if (generate_PUSHS(cctx, pat) == FAIL)
7323 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007324
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007325 if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL)
7326 return NULL;
7327
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007328 scope->se_u.se_try.ts_catch_label = instr->ga_len;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007329 if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL)
7330 return NULL;
7331 }
7332
Bram Moolenaar69f70502021-01-01 16:10:46 +01007333 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_CATCH) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007334 return NULL;
7335
7336 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
7337 return NULL;
7338 return p;
7339}
7340
7341 static char_u *
7342compile_finally(char_u *arg, cctx_T *cctx)
7343{
7344 scope_T *scope = cctx->ctx_scope;
7345 garray_T *instr = &cctx->ctx_instr;
7346 isn_T *isn;
7347
7348 // end block scope from :try or :catch
7349 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
7350 compile_endblock(cctx);
7351 scope = cctx->ctx_scope;
7352
7353 // Error if not in a :try scope
7354 if (scope == NULL || scope->se_type != TRY_SCOPE)
7355 {
7356 emsg(_(e_finally));
7357 return NULL;
7358 }
7359
7360 // End :catch or :finally scope: set value in ISN_TRY instruction
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007361 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007362 if (isn->isn_arg.try.try_finally != 0)
7363 {
7364 emsg(_(e_finally_dup));
7365 return NULL;
7366 }
7367
7368 // Fill in the "end" label in jumps at the end of the blocks.
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007369 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007370
Bram Moolenaar585fea72020-04-02 22:33:21 +02007371 isn->isn_arg.try.try_finally = instr->ga_len;
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007372 if (scope->se_u.se_try.ts_catch_label != 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007373 {
7374 // Previous catch without match jumps here
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01007375 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007376 isn->isn_arg.jump.jump_where = instr->ga_len;
Bram Moolenaare8593122020-07-18 15:17:02 +02007377 scope->se_u.se_try.ts_catch_label = 0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007378 }
7379
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007380 // TODO: set index in ts_finally_label jumps
7381
7382 return arg;
7383}
7384
7385 static char_u *
7386compile_endtry(char_u *arg, cctx_T *cctx)
7387{
7388 scope_T *scope = cctx->ctx_scope;
7389 garray_T *instr = &cctx->ctx_instr;
7390 isn_T *isn;
7391
7392 // end block scope from :catch or :finally
7393 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
7394 compile_endblock(cctx);
7395 scope = cctx->ctx_scope;
7396
7397 // Error if not in a :try scope
7398 if (scope == NULL || scope->se_type != TRY_SCOPE)
7399 {
7400 if (scope == NULL)
7401 emsg(_(e_no_endtry));
7402 else if (scope->se_type == WHILE_SCOPE)
7403 emsg(_(e_endwhile));
Bram Moolenaar5b18c242020-01-28 22:30:32 +01007404 else if (scope->se_type == FOR_SCOPE)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007405 emsg(_(e_endfor));
7406 else
7407 emsg(_(e_endif));
7408 return NULL;
7409 }
7410
Bram Moolenaar69f70502021-01-01 16:10:46 +01007411 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007412 {
Bram Moolenaar69f70502021-01-01 16:10:46 +01007413 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
7414 if (isn->isn_arg.try.try_catch == 0
7415 && isn->isn_arg.try.try_finally == 0)
7416 {
7417 emsg(_(e_missing_catch_or_finally));
7418 return NULL;
7419 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007420
Bram Moolenaar69f70502021-01-01 16:10:46 +01007421 // Fill in the "end" label in jumps at the end of the blocks, if not
7422 // done by ":finally".
7423 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007424
Bram Moolenaar69f70502021-01-01 16:10:46 +01007425 // End :catch or :finally scope: set value in ISN_TRY instruction
7426 if (isn->isn_arg.try.try_catch == 0)
7427 isn->isn_arg.try.try_catch = instr->ga_len;
7428 if (isn->isn_arg.try.try_finally == 0)
7429 isn->isn_arg.try.try_finally = instr->ga_len;
Bram Moolenaare8593122020-07-18 15:17:02 +02007430
Bram Moolenaar69f70502021-01-01 16:10:46 +01007431 if (scope->se_u.se_try.ts_catch_label != 0)
7432 {
7433 // Last catch without match jumps here
7434 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
7435 isn->isn_arg.jump.jump_where = instr->ga_len;
7436 }
Bram Moolenaare8593122020-07-18 15:17:02 +02007437 }
7438
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007439 compile_endblock(cctx);
7440
Bram Moolenaar69f70502021-01-01 16:10:46 +01007441 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_ENDTRY) == NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007442 return NULL;
7443 return arg;
7444}
7445
7446/*
7447 * compile "throw {expr}"
7448 */
7449 static char_u *
7450compile_throw(char_u *arg, cctx_T *cctx UNUSED)
7451{
7452 char_u *p = skipwhite(arg);
7453
Bram Moolenaara5565e42020-05-09 15:44:01 +02007454 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007455 return NULL;
7456 if (may_generate_2STRING(-1, cctx) == FAIL)
7457 return NULL;
7458 if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL)
7459 return NULL;
7460
7461 return p;
7462}
7463
7464/*
7465 * compile "echo expr"
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02007466 * compile "echomsg expr"
7467 * compile "echoerr expr"
Bram Moolenaarad39c092020-02-26 18:23:43 +01007468 * compile "execute expr"
7469 */
7470 static char_u *
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02007471compile_mult_expr(char_u *arg, int cmdidx, cctx_T *cctx)
Bram Moolenaarad39c092020-02-26 18:23:43 +01007472{
7473 char_u *p = arg;
Bram Moolenaare4984292020-12-13 14:19:25 +01007474 char_u *prev = arg;
Bram Moolenaarad39c092020-02-26 18:23:43 +01007475 int count = 0;
7476
7477 for (;;)
7478 {
Bram Moolenaare4984292020-12-13 14:19:25 +01007479 if (ends_excmd2(prev, p))
7480 break;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007481 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaarad39c092020-02-26 18:23:43 +01007482 return NULL;
7483 ++count;
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02007484 prev = p;
Bram Moolenaarad39c092020-02-26 18:23:43 +01007485 p = skipwhite(p);
Bram Moolenaarad39c092020-02-26 18:23:43 +01007486 }
7487
Bram Moolenaare4984292020-12-13 14:19:25 +01007488 if (count > 0)
7489 {
7490 if (cmdidx == CMD_echo || cmdidx == CMD_echon)
7491 generate_ECHO(cctx, cmdidx == CMD_echo, count);
7492 else if (cmdidx == CMD_execute)
7493 generate_MULT_EXPR(cctx, ISN_EXECUTE, count);
7494 else if (cmdidx == CMD_echomsg)
7495 generate_MULT_EXPR(cctx, ISN_ECHOMSG, count);
7496 else
7497 generate_MULT_EXPR(cctx, ISN_ECHOERR, count);
7498 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007499 return p;
7500}
7501
7502/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +01007503 * If "eap" has a range that is not a constant generate an ISN_RANGE
Bram Moolenaar08597872020-12-10 19:43:40 +01007504 * instruction to compute it and return OK.
7505 * Otherwise return FAIL, the caller must deal with any range.
7506 */
7507 static int
7508compile_variable_range(exarg_T *eap, cctx_T *cctx)
7509{
7510 char_u *range_end = skip_range(eap->cmd, TRUE, NULL);
7511 char_u *p = skipdigits(eap->cmd);
7512
7513 if (p == range_end)
7514 return FAIL;
7515 return generate_RANGE(cctx, vim_strnsave(eap->cmd, range_end - eap->cmd));
7516}
7517
7518/*
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007519 * :put r
7520 * :put ={expr}
7521 */
7522 static char_u *
7523compile_put(char_u *arg, exarg_T *eap, cctx_T *cctx)
7524{
7525 char_u *line = arg;
7526 linenr_T lnum;
7527 char *errormsg;
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02007528 int above = eap->forceit;
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007529
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007530 eap->regname = *line;
7531
7532 if (eap->regname == '=')
7533 {
7534 char_u *p = line + 1;
7535
7536 if (compile_expr0(&p, cctx) == FAIL)
7537 return NULL;
7538 line = p;
7539 }
7540 else if (eap->regname != NUL)
7541 ++line;
7542
Bram Moolenaar08597872020-12-10 19:43:40 +01007543 if (compile_variable_range(eap, cctx) == OK)
7544 {
7545 lnum = above ? LNUM_VARIABLE_RANGE_ABOVE : LNUM_VARIABLE_RANGE;
7546 }
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007547 else
Bram Moolenaar08597872020-12-10 19:43:40 +01007548 {
7549 // Either no range or a number.
7550 // "errormsg" will not be set because the range is ADDR_LINES.
7551 if (parse_cmd_address(eap, &errormsg, FALSE) == FAIL)
Bram Moolenaar399ea812020-12-15 21:28:57 +01007552 // cannot happen
Bram Moolenaar08597872020-12-10 19:43:40 +01007553 return NULL;
7554 if (eap->addr_count == 0)
7555 lnum = -1;
7556 else
7557 lnum = eap->line2;
7558 if (above)
7559 --lnum;
7560 }
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007561
7562 generate_PUT(cctx, eap->regname, lnum);
7563 return line;
7564}
7565
7566/*
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007567 * A command that is not compiled, execute with legacy code.
7568 */
7569 static char_u *
7570compile_exec(char_u *line, exarg_T *eap, cctx_T *cctx)
7571{
Bram Moolenaar6378c4f2020-04-26 13:50:41 +02007572 char_u *p;
Bram Moolenaar7d41aa82020-04-26 14:29:56 +02007573 int has_expr = FALSE;
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007574 char_u *nextcmd = (char_u *)"";
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007575
Bram Moolenaar9b68c822020-06-18 19:31:08 +02007576 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007577 goto theend;
7578
Bram Moolenaar7d41aa82020-04-26 14:29:56 +02007579 if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE)
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007580 {
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02007581 long argt = eap->argt;
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007582 int usefilter = FALSE;
7583
7584 has_expr = argt & (EX_XFILE | EX_EXPAND);
7585
7586 // If the command can be followed by a bar, find the bar and truncate
7587 // it, so that the following command can be compiled.
7588 // The '|' is overwritten with a NUL, it is put back below.
7589 if ((eap->cmdidx == CMD_write || eap->cmdidx == CMD_read)
7590 && *eap->arg == '!')
7591 // :w !filter or :r !filter or :r! filter
7592 usefilter = TRUE;
7593 if ((argt & EX_TRLBAR) && !usefilter)
7594 {
Bram Moolenaarb8a92962020-08-20 18:02:47 +02007595 eap->argt = argt;
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007596 separate_nextcmd(eap);
7597 if (eap->nextcmd != NULL)
7598 nextcmd = eap->nextcmd;
7599 }
Bram Moolenaara11919f2021-01-02 19:44:56 +01007600 else if (eap->cmdidx == CMD_wincmd)
7601 {
7602 p = eap->arg;
7603 if (*p != NUL)
7604 ++p;
7605 if (*p == 'g' || *p == Ctrl_G)
7606 ++p;
7607 p = skipwhite(p);
7608 if (*p == '|')
7609 {
7610 *p = NUL;
7611 nextcmd = p + 1;
7612 }
7613 }
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007614 }
7615
Bram Moolenaar6378c4f2020-04-26 13:50:41 +02007616 if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0)
7617 {
7618 // expand filename in "syntax include [@group] filename"
7619 has_expr = TRUE;
7620 eap->arg = skipwhite(eap->arg + 7);
7621 if (*eap->arg == '@')
7622 eap->arg = skiptowhite(eap->arg);
7623 }
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007624
Bram Moolenaar56ce9ea2020-12-25 18:35:29 +01007625 if ((eap->cmdidx == CMD_global || eap->cmdidx == CMD_vglobal)
7626 && STRLEN(eap->arg) > 4)
7627 {
7628 int delim = *eap->arg;
7629
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007630 p = skip_regexp_ex(eap->arg + 1, delim, TRUE, NULL, NULL, NULL);
Bram Moolenaar56ce9ea2020-12-25 18:35:29 +01007631 if (*p == delim)
7632 {
7633 eap->arg = p + 1;
7634 has_expr = TRUE;
7635 }
7636 }
7637
Bram Moolenaarecac5912021-01-05 19:23:28 +01007638 if (eap->cmdidx == CMD_folddoopen || eap->cmdidx == CMD_folddoclosed)
7639 {
7640 // TODO: should only expand when appropriate for the command
7641 eap->arg = skiptowhite(eap->arg);
7642 has_expr = TRUE;
7643 }
7644
Bram Moolenaar6378c4f2020-04-26 13:50:41 +02007645 if (has_expr && (p = (char_u *)strstr((char *)eap->arg, "`=")) != NULL)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007646 {
7647 int count = 0;
7648 char_u *start = skipwhite(line);
7649
7650 // :cmd xxx`=expr1`yyy`=expr2`zzz
7651 // PUSHS ":cmd xxx"
7652 // eval expr1
7653 // PUSHS "yyy"
7654 // eval expr2
7655 // PUSHS "zzz"
7656 // EXECCONCAT 5
7657 for (;;)
7658 {
7659 if (p > start)
7660 {
Bram Moolenaar71ccd032020-06-12 22:59:11 +02007661 generate_PUSHS(cctx, vim_strnsave(start, p - start));
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007662 ++count;
7663 }
7664 p += 2;
Bram Moolenaara5565e42020-05-09 15:44:01 +02007665 if (compile_expr0(&p, cctx) == FAIL)
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007666 return NULL;
7667 may_generate_2STRING(-1, cctx);
7668 ++count;
7669 p = skipwhite(p);
7670 if (*p != '`')
7671 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02007672 emsg(_(e_missing_backtick));
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007673 return NULL;
7674 }
7675 start = p + 1;
7676
7677 p = (char_u *)strstr((char *)start, "`=");
7678 if (p == NULL)
7679 {
7680 if (*skipwhite(start) != NUL)
7681 {
7682 generate_PUSHS(cctx, vim_strsave(start));
7683 ++count;
7684 }
7685 break;
7686 }
7687 }
7688 generate_EXECCONCAT(cctx, count);
7689 }
7690 else
7691 generate_EXEC(cctx, line);
7692
7693theend:
Bram Moolenaare9f262b2020-07-05 14:57:51 +02007694 if (*nextcmd != NUL)
7695 {
7696 // the parser expects a pointer to the bar, put it back
7697 --nextcmd;
7698 *nextcmd = '|';
7699 }
7700
7701 return nextcmd;
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02007702}
7703
7704/*
Bram Moolenaar09689a02020-05-09 22:50:08 +02007705 * Add a function to the list of :def functions.
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02007706 * This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet.
Bram Moolenaar09689a02020-05-09 22:50:08 +02007707 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02007708 static int
Bram Moolenaar09689a02020-05-09 22:50:08 +02007709add_def_function(ufunc_T *ufunc)
7710{
7711 dfunc_T *dfunc;
7712
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02007713 if (def_functions.ga_len == 0)
7714 {
7715 // The first position is not used, so that a zero uf_dfunc_idx means it
7716 // wasn't set.
7717 if (ga_grow(&def_functions, 1) == FAIL)
7718 return FAIL;
7719 ++def_functions.ga_len;
7720 }
7721
Bram Moolenaar09689a02020-05-09 22:50:08 +02007722 // Add the function to "def_functions".
7723 if (ga_grow(&def_functions, 1) == FAIL)
7724 return FAIL;
7725 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
7726 CLEAR_POINTER(dfunc);
7727 dfunc->df_idx = def_functions.ga_len;
7728 ufunc->uf_dfunc_idx = dfunc->df_idx;
7729 dfunc->df_ufunc = ufunc;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01007730 dfunc->df_name = vim_strsave(ufunc->uf_name);
7731 ++dfunc->df_refcount;
Bram Moolenaar09689a02020-05-09 22:50:08 +02007732 ++def_functions.ga_len;
7733 return OK;
7734}
7735
7736/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007737 * After ex_function() has collected all the function lines: parse and compile
7738 * the lines into instructions.
7739 * Adds the function to "def_functions".
Bram Moolenaar9e68c322020-12-25 12:38:04 +01007740 * When "check_return_type" is set then set ufunc->uf_ret_type to the type of
7741 * the return statement (used for lambda). When uf_ret_type is already set
7742 * then check that it matches.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02007743 * "outer_cctx" is set for a nested function.
Bram Moolenaar05afcee2020-03-31 23:32:31 +02007744 * This can be used recursively through compile_lambda(), which may reallocate
7745 * "def_functions".
Bram Moolenaar822ba242020-05-24 23:00:18 +02007746 * Returns OK or FAIL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007747 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02007748 int
Bram Moolenaar9e68c322020-12-25 12:38:04 +01007749compile_def_function(ufunc_T *ufunc, int check_return_type, cctx_T *outer_cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007750{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007751 char_u *line = NULL;
7752 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007753 char *errormsg = NULL; // error message
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007754 cctx_T cctx;
7755 garray_T *instr;
Bram Moolenaard66960b2020-10-30 20:46:26 +01007756 int did_emsg_before = did_emsg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007757 int ret = FAIL;
7758 sctx_T save_current_sctx = current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02007759 int save_estack_compiling = estack_compiling;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02007760 int do_estack_push;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02007761 int new_def_function = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007762
Bram Moolenaar25e0f582020-05-25 22:36:50 +02007763 // When using a function that was compiled before: Free old instructions.
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01007764 // The index is reused. Otherwise add a new entry in "def_functions".
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02007765 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007766 {
Bram Moolenaar09689a02020-05-09 22:50:08 +02007767 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
7768 + ufunc->uf_dfunc_idx;
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01007769 delete_def_function_contents(dfunc, FALSE);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007770 }
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02007771 else
7772 {
7773 if (add_def_function(ufunc) == FAIL)
7774 return FAIL;
7775 new_def_function = TRUE;
7776 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007777
Bram Moolenaar985116a2020-07-12 17:31:09 +02007778 ufunc->uf_def_status = UF_COMPILING;
7779
Bram Moolenaara80faa82020-04-12 19:37:17 +02007780 CLEAR_FIELD(cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007781 cctx.ctx_ufunc = ufunc;
7782 cctx.ctx_lnum = -1;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02007783 cctx.ctx_outer = outer_cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007784 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
7785 ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50);
7786 ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10);
7787 cctx.ctx_type_list = &ufunc->uf_type_list;
7788 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
7789 instr = &cctx.ctx_instr;
7790
Bram Moolenaar25e0f582020-05-25 22:36:50 +02007791 // Set the context to the function, it may be compiled when called from
7792 // another script. Set the script version to the most modern one.
7793 // The line number will be set in next_line_from_context().
7794 current_sctx = ufunc->uf_script_ctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007795 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
7796
Bram Moolenaar25e0f582020-05-25 22:36:50 +02007797 // Make sure error messages are OK.
7798 do_estack_push = !estack_top_is_ufunc(ufunc, 1);
7799 if (do_estack_push)
7800 estack_push_ufunc(ufunc, 1);
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02007801 estack_compiling = TRUE;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02007802
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007803 if (ufunc->uf_def_args.ga_len > 0)
7804 {
7805 int count = ufunc->uf_def_args.ga_len;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007806 int first_def_arg = ufunc->uf_args.ga_len - count;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007807 int i;
7808 char_u *arg;
7809 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
Bram Moolenaarb8070e32020-07-23 20:56:04 +02007810 int did_set_arg_type = FALSE;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007811
7812 // Produce instructions for the default values of optional arguments.
7813 // Store the instruction index in uf_def_arg_idx[] so that we know
7814 // where to start when the function is called, depending on the number
7815 // of arguments.
7816 ufunc->uf_def_arg_idx = ALLOC_CLEAR_MULT(int, count + 1);
7817 if (ufunc->uf_def_arg_idx == NULL)
7818 goto erret;
7819 for (i = 0; i < count; ++i)
7820 {
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007821 garray_T *stack = &cctx.ctx_type_stack;
7822 type_T *val_type;
7823 int arg_idx = first_def_arg + i;
7824
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007825 ufunc->uf_def_arg_idx[i] = instr->ga_len;
7826 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
Bram Moolenaara5565e42020-05-09 15:44:01 +02007827 if (compile_expr0(&arg, &cctx) == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007828 goto erret;
7829
7830 // If no type specified use the type of the default value.
7831 // Otherwise check that the default value type matches the
7832 // specified type.
7833 val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
7834 if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02007835 {
7836 did_set_arg_type = TRUE;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007837 ufunc->uf_arg_types[arg_idx] = val_type;
Bram Moolenaarb8070e32020-07-23 20:56:04 +02007838 }
Bram Moolenaar8b565c22020-08-30 23:24:20 +02007839 else if (check_type(ufunc->uf_arg_types[arg_idx], val_type,
7840 TRUE, arg_idx + 1) == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007841 goto erret;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02007842
7843 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007844 goto erret;
7845 }
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007846 ufunc->uf_def_arg_idx[count] = instr->ga_len;
Bram Moolenaarb8070e32020-07-23 20:56:04 +02007847
7848 if (did_set_arg_type)
7849 set_function_type(ufunc);
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01007850 }
7851
7852 /*
7853 * Loop over all the lines of the function and generate instructions.
7854 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007855 for (;;)
7856 {
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02007857 exarg_T ea;
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02007858 int starts_with_colon = FALSE;
7859 char_u *cmd;
Bram Moolenaar02194d22020-10-24 23:08:38 +02007860 cmdmod_T local_cmdmod;
Bram Moolenaar5b1c8fe2020-02-21 18:42:43 +01007861
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02007862 // Bail out on the first error to avoid a flood of errors and report
7863 // the right line number when inside try/catch.
Bram Moolenaard66960b2020-10-30 20:46:26 +01007864 if (did_emsg_before != did_emsg)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02007865 goto erret;
7866
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007867 if (line != NULL && *line == '|')
7868 // the line continues after a '|'
7869 ++line;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02007870 else if (line != NULL && *skipwhite(line) != NUL
Bram Moolenaar7a092242020-04-16 22:10:49 +02007871 && !(*line == '#' && (line == cctx.ctx_line_start
7872 || VIM_ISWHITE(line[-1]))))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007873 {
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02007874 semsg(_(e_trailing_arg), line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007875 goto erret;
7876 }
7877 else
7878 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02007879 line = next_line_from_context(&cctx, FALSE);
Bram Moolenaar4fdae992020-04-12 16:38:57 +02007880 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007881 // beyond the last line
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007882 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007883 }
7884
Bram Moolenaara80faa82020-04-12 19:37:17 +02007885 CLEAR_FIELD(ea);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007886 ea.cmdlinep = &line;
7887 ea.cmd = skipwhite(line);
7888
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007889 // Some things can be recognized by the first character.
7890 switch (*ea.cmd)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007891 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007892 case '#':
Bram Moolenaare0de1712020-12-02 17:36:54 +01007893 // "#" starts a comment
7894 line = (char_u *)"";
7895 continue;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007896
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007897 case '}':
7898 {
7899 // "}" ends a block scope
7900 scopetype_T stype = cctx.ctx_scope == NULL
7901 ? NO_SCOPE : cctx.ctx_scope->se_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007902
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007903 if (stype == BLOCK_SCOPE)
7904 {
7905 compile_endblock(&cctx);
7906 line = ea.cmd;
7907 }
7908 else
7909 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02007910 emsg(_(e_using_rcurly_outside_if_block_scope));
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02007911 goto erret;
7912 }
7913 if (line != NULL)
7914 line = skipwhite(ea.cmd + 1);
7915 continue;
7916 }
7917
7918 case '{':
7919 // "{" starts a block scope
7920 // "{'a': 1}->func() is something else
7921 if (ends_excmd(*skipwhite(ea.cmd + 1)))
7922 {
7923 line = compile_block(ea.cmd, &cctx);
7924 continue;
7925 }
7926 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007927 }
7928
7929 /*
7930 * COMMAND MODIFIERS
7931 */
Bram Moolenaar02194d22020-10-24 23:08:38 +02007932 cctx.ctx_has_cmdmod = FALSE;
Bram Moolenaare1004402020-10-24 20:49:43 +02007933 if (parse_command_modifiers(&ea, &errormsg, &local_cmdmod, FALSE)
7934 == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007935 {
7936 if (errormsg != NULL)
7937 goto erret;
7938 // empty line or comment
7939 line = (char_u *)"";
7940 continue;
7941 }
Bram Moolenaare1004402020-10-24 20:49:43 +02007942 generate_cmdmods(&cctx, &local_cmdmod);
7943 undo_cmdmod(&local_cmdmod);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007944
Bram Moolenaare88c8e82020-11-01 17:03:37 +01007945 // Check if there was a colon after the last command modifier or before
7946 // the current position.
7947 for (p = ea.cmd; p >= line; --p)
7948 {
7949 if (*p == ':')
7950 starts_with_colon = TRUE;
7951 if (p < ea.cmd && !VIM_ISWHITE(*p))
7952 break;
7953 }
7954
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007955 // Skip ":call" to get to the function name.
Bram Moolenaar575f24b2020-08-12 14:21:11 +02007956 p = ea.cmd;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007957 if (checkforcmd(&ea.cmd, "call", 3))
Bram Moolenaar575f24b2020-08-12 14:21:11 +02007958 {
7959 if (*ea.cmd == '(')
7960 // not for "call()"
7961 ea.cmd = p;
7962 else
7963 ea.cmd = skipwhite(ea.cmd);
7964 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007965
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02007966 if (!starts_with_colon)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007967 {
Bram Moolenaar17126b12021-01-07 22:03:02 +01007968 int assign;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02007969
Bram Moolenaar17126b12021-01-07 22:03:02 +01007970 // Check for assignment after command modifiers.
7971 assign = may_compile_assignment(&ea, &line, &cctx);
7972 if (assign == OK)
7973 goto nextline;
7974 if (assign == FAIL)
7975 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007976 }
7977
7978 /*
7979 * COMMAND after range
Bram Moolenaar3d48e252020-07-15 14:15:52 +02007980 * 'text'->func() should not be confused with 'a mark
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007981 */
Bram Moolenaardf069ee2020-06-22 23:02:51 +02007982 cmd = ea.cmd;
Bram Moolenaar7c5ad342020-08-12 15:48:55 +02007983 if (*cmd != '\'' || starts_with_colon)
Bram Moolenaardf069ee2020-06-22 23:02:51 +02007984 {
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02007985 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02007986 if (ea.cmd > cmd)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02007987 {
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02007988 if (!starts_with_colon)
7989 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01007990 semsg(_(e_colon_required_before_range_str), cmd);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02007991 goto erret;
7992 }
7993 if (ends_excmd2(line, ea.cmd))
7994 {
7995 // A range without a command: jump to the line.
7996 // TODO: compile to a more efficient command, possibly
7997 // calling parse_cmd_address().
7998 ea.cmdidx = CMD_SIZE;
7999 line = compile_exec(line, &ea, &cctx);
8000 goto nextline;
8001 }
Bram Moolenaar3d48e252020-07-15 14:15:52 +02008002 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02008003 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02008004 p = find_ex_command(&ea, NULL, starts_with_colon ? NULL
Bram Moolenaar709664c2020-12-12 14:33:41 +01008005 : (int (*)(char_u *, size_t, void *, cctx_T *))lookup_local,
Bram Moolenaar5b1c8fe2020-02-21 18:42:43 +01008006 &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008007
Bram Moolenaard1510ee2021-01-04 16:15:58 +01008008 if (p == NULL)
8009 {
8010 if (cctx.ctx_skip != SKIP_YES)
8011 emsg(_(e_ambiguous_use_of_user_defined_command));
8012 goto erret;
8013 }
8014
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008015 if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
8016 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02008017 if (cctx.ctx_skip == SKIP_YES)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01008018 {
8019 line += STRLEN(line);
Bram Moolenaarf665e972020-12-05 19:17:16 +01008020 goto nextline;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01008021 }
8022
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008023 // Expression or function call.
Bram Moolenaar007f9d62020-07-06 23:04:49 +02008024 if (ea.cmdidx != CMD_eval)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008025 {
Bram Moolenaar52c124d2020-12-20 21:43:35 +01008026 // CMD_var cannot happen, compile_assignment() above would be
8027 // used. Most likely an assignment to a non-existing variable.
8028 semsg(_(e_command_not_recognized_str), ea.cmd);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02008029 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008030 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008031 }
8032
Bram Moolenaar3988f642020-08-27 22:43:03 +02008033 if (cctx.ctx_had_return
Bram Moolenaara259d8d2020-01-31 20:10:50 +01008034 && ea.cmdidx != CMD_elseif
8035 && ea.cmdidx != CMD_else
Bram Moolenaarefd88552020-06-18 20:50:10 +02008036 && ea.cmdidx != CMD_endif
8037 && ea.cmdidx != CMD_endfor
8038 && ea.cmdidx != CMD_endwhile
8039 && ea.cmdidx != CMD_catch
8040 && ea.cmdidx != CMD_finally
8041 && ea.cmdidx != CMD_endtry)
8042 {
Bram Moolenaar3988f642020-08-27 22:43:03 +02008043 emsg(_(e_unreachable_code_after_return));
8044 goto erret;
Bram Moolenaarefd88552020-06-18 20:50:10 +02008045 }
8046
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02008047 p = skipwhite(p);
8048 if (ea.cmdidx != CMD_SIZE
8049 && ea.cmdidx != CMD_write && ea.cmdidx != CMD_read)
8050 {
Bram Moolenaar9b123d82020-09-14 22:39:11 +02008051 if (ea.cmdidx >= 0)
8052 ea.argt = excmd_get_argt(ea.cmdidx);
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02008053 if ((ea.argt & EX_BANG) && *p == '!')
8054 {
8055 ea.forceit = TRUE;
8056 p = skipwhite(p + 1);
8057 }
8058 }
8059
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008060 switch (ea.cmdidx)
8061 {
8062 case CMD_def:
Bram Moolenaar04b12692020-05-04 23:24:44 +02008063 ea.arg = p;
8064 line = compile_nested_function(&ea, &cctx);
8065 break;
8066
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008067 case CMD_function:
Bram Moolenaar451c2e32020-08-15 16:33:28 +02008068 // TODO: should we allow this, e.g. to declare a global
8069 // function?
8070 emsg(_(e_cannot_use_function_inside_def));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008071 goto erret;
8072
8073 case CMD_return:
Bram Moolenaar9e68c322020-12-25 12:38:04 +01008074 line = compile_return(p, check_return_type, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008075 cctx.ctx_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008076 break;
8077
8078 case CMD_let:
Bram Moolenaarc58f5452020-10-21 20:58:52 +02008079 emsg(_(e_cannot_use_let_in_vim9_script));
8080 break;
Bram Moolenaar30fd8202020-09-26 15:09:30 +02008081 case CMD_var:
8082 case CMD_final:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008083 case CMD_const:
8084 line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02008085 if (line == p)
8086 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008087 break;
8088
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02008089 case CMD_unlet:
8090 case CMD_unlockvar:
8091 case CMD_lockvar:
8092 line = compile_unletlock(p, &ea, &cctx);
8093 break;
8094
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008095 case CMD_import:
8096 line = compile_import(p, &cctx);
8097 break;
8098
8099 case CMD_if:
8100 line = compile_if(p, &cctx);
8101 break;
8102 case CMD_elseif:
8103 line = compile_elseif(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008104 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008105 break;
8106 case CMD_else:
8107 line = compile_else(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008108 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008109 break;
8110 case CMD_endif:
8111 line = compile_endif(p, &cctx);
8112 break;
8113
8114 case CMD_while:
8115 line = compile_while(p, &cctx);
8116 break;
8117 case CMD_endwhile:
8118 line = compile_endwhile(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008119 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008120 break;
8121
8122 case CMD_for:
8123 line = compile_for(p, &cctx);
8124 break;
8125 case CMD_endfor:
8126 line = compile_endfor(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008127 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008128 break;
8129 case CMD_continue:
8130 line = compile_continue(p, &cctx);
8131 break;
8132 case CMD_break:
8133 line = compile_break(p, &cctx);
8134 break;
8135
8136 case CMD_try:
8137 line = compile_try(p, &cctx);
8138 break;
8139 case CMD_catch:
8140 line = compile_catch(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008141 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008142 break;
8143 case CMD_finally:
8144 line = compile_finally(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008145 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008146 break;
8147 case CMD_endtry:
8148 line = compile_endtry(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02008149 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008150 break;
8151 case CMD_throw:
8152 line = compile_throw(p, &cctx);
8153 break;
8154
Bram Moolenaar007f9d62020-07-06 23:04:49 +02008155 case CMD_eval:
8156 if (compile_expr0(&p, &cctx) == FAIL)
8157 goto erret;
8158
Bram Moolenaar3988f642020-08-27 22:43:03 +02008159 // drop the result
Bram Moolenaar007f9d62020-07-06 23:04:49 +02008160 generate_instr_drop(&cctx, ISN_DROP, 1);
8161
8162 line = skipwhite(p);
8163 break;
8164
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008165 case CMD_echo:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008166 case CMD_echon:
Bram Moolenaarad39c092020-02-26 18:23:43 +01008167 case CMD_execute:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02008168 case CMD_echomsg:
8169 case CMD_echoerr:
8170 line = compile_mult_expr(p, ea.cmdidx, &cctx);
Bram Moolenaarad39c092020-02-26 18:23:43 +01008171 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008172
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008173 case CMD_put:
8174 ea.cmd = cmd;
8175 line = compile_put(p, &ea, &cctx);
8176 break;
8177
Bram Moolenaar3988f642020-08-27 22:43:03 +02008178 // TODO: any other commands with an expression argument?
Bram Moolenaardf069ee2020-06-22 23:02:51 +02008179
Bram Moolenaarae616492020-07-28 20:07:27 +02008180 case CMD_append:
8181 case CMD_change:
8182 case CMD_insert:
Bram Moolenaarf5a48012020-08-01 17:00:03 +02008183 case CMD_t:
Bram Moolenaarae616492020-07-28 20:07:27 +02008184 case CMD_xit:
8185 not_in_vim9(&ea);
8186 goto erret;
8187
Bram Moolenaar002262f2020-07-08 17:47:57 +02008188 case CMD_SIZE:
Bram Moolenaar3988f642020-08-27 22:43:03 +02008189 if (cctx.ctx_skip != SKIP_YES)
8190 {
8191 semsg(_(e_invalid_command_str), ea.cmd);
8192 goto erret;
8193 }
8194 // We don't check for a next command here.
8195 line = (char_u *)"";
8196 break;
Bram Moolenaar002262f2020-07-08 17:47:57 +02008197
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008198 default:
Bram Moolenaar5163fcc2020-08-27 23:37:09 +02008199 if (cctx.ctx_skip == SKIP_YES)
8200 {
8201 // We don't check for a next command here.
8202 line = (char_u *)"";
8203 }
8204 else
8205 {
8206 // Not recognized, execute with do_cmdline_cmd().
8207 ea.arg = p;
8208 line = compile_exec(line, &ea, &cctx);
8209 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008210 break;
8211 }
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02008212nextline:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008213 if (line == NULL)
8214 goto erret;
Bram Moolenaar585fea72020-04-02 22:33:21 +02008215 line = skipwhite(line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008216
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02008217 // Undo any command modifiers.
Bram Moolenaar02194d22020-10-24 23:08:38 +02008218 generate_undo_cmdmods(&cctx);
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02008219
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008220 if (cctx.ctx_type_stack.ga_len < 0)
8221 {
8222 iemsg("Type stack underflow");
8223 goto erret;
8224 }
8225 }
8226
8227 if (cctx.ctx_scope != NULL)
8228 {
8229 if (cctx.ctx_scope->se_type == IF_SCOPE)
8230 emsg(_(e_endif));
8231 else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
8232 emsg(_(e_endwhile));
8233 else if (cctx.ctx_scope->se_type == FOR_SCOPE)
8234 emsg(_(e_endfor));
8235 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02008236 emsg(_(e_missing_rcurly));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008237 goto erret;
8238 }
8239
Bram Moolenaarefd88552020-06-18 20:50:10 +02008240 if (!cctx.ctx_had_return)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008241 {
8242 if (ufunc->uf_ret_type->tt_type != VAR_VOID)
8243 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02008244 emsg(_(e_missing_return_statement));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008245 goto erret;
8246 }
8247
8248 // Return zero if there is no return at the end.
Bram Moolenaar299f3032021-01-08 20:53:09 +01008249 generate_instr(&cctx, ISN_RETURN_ZERO);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008250 }
8251
Bram Moolenaar05afcee2020-03-31 23:32:31 +02008252 {
8253 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8254 + ufunc->uf_dfunc_idx;
8255 dfunc->df_deleted = FALSE;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01008256 dfunc->df_script_seq = current_sctx.sc_seq;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02008257 dfunc->df_instr = instr->ga_data;
8258 dfunc->df_instr_count = instr->ga_len;
Bram Moolenaarb84a3812020-05-01 15:44:29 +02008259 dfunc->df_varcount = cctx.ctx_locals_count;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02008260 dfunc->df_has_closure = cctx.ctx_has_closure;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02008261 if (cctx.ctx_outer_used)
8262 ufunc->uf_flags |= FC_CLOSURE;
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02008263 ufunc->uf_def_status = UF_COMPILED;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02008264 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008265
8266 ret = OK;
8267
8268erret:
8269 if (ret == FAIL)
8270 {
Bram Moolenaar20431c92020-03-20 18:39:46 +01008271 int idx;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02008272 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8273 + ufunc->uf_dfunc_idx;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008274
8275 for (idx = 0; idx < instr->ga_len; ++idx)
8276 delete_instr(((isn_T *)instr->ga_data) + idx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008277 ga_clear(instr);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008278 VIM_CLEAR(dfunc->df_name);
Bram Moolenaar20431c92020-03-20 18:39:46 +01008279
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02008280 // If using the last entry in the table and it was added above, we
8281 // might as well remove it.
8282 if (!dfunc->df_deleted && new_def_function
Bram Moolenaar45a15082020-05-25 00:28:33 +02008283 && ufunc->uf_dfunc_idx == def_functions.ga_len - 1)
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02008284 {
Bram Moolenaar20431c92020-03-20 18:39:46 +01008285 --def_functions.ga_len;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02008286 ufunc->uf_dfunc_idx = 0;
8287 }
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02008288 ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008289
Bram Moolenaar3cca2992020-04-02 22:57:36 +02008290 while (cctx.ctx_scope != NULL)
8291 drop_scope(&cctx);
8292
Bram Moolenaar20431c92020-03-20 18:39:46 +01008293 // Don't execute this function body.
8294 ga_clear_strings(&ufunc->uf_lines);
8295
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008296 if (errormsg != NULL)
8297 emsg(errormsg);
Bram Moolenaard66960b2020-10-30 20:46:26 +01008298 else if (did_emsg == did_emsg_before)
Bram Moolenaare13bdec2020-10-16 23:16:47 +02008299 emsg(_(e_compiling_def_function_failed));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008300 }
8301
8302 current_sctx = save_current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02008303 estack_compiling = save_estack_compiling;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02008304 if (do_estack_push)
8305 estack_pop();
8306
Bram Moolenaar20431c92020-03-20 18:39:46 +01008307 free_imported(&cctx);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02008308 free_locals(&cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008309 ga_clear(&cctx.ctx_type_stack);
Bram Moolenaar822ba242020-05-24 23:00:18 +02008310 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008311}
8312
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02008313 void
8314set_function_type(ufunc_T *ufunc)
8315{
8316 int varargs = ufunc->uf_va_name != NULL;
8317 int argcount = ufunc->uf_args.ga_len;
8318
8319 // Create a type for the function, with the return type and any
8320 // argument types.
8321 // A vararg is included in uf_args.ga_len but not in uf_arg_types.
8322 // The type is included in "tt_args".
8323 if (argcount > 0 || varargs)
8324 {
8325 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
8326 argcount, &ufunc->uf_type_list);
8327 // Add argument types to the function type.
8328 if (func_type_add_arg_types(ufunc->uf_func_type,
8329 argcount + varargs,
8330 &ufunc->uf_type_list) == FAIL)
8331 return;
8332 ufunc->uf_func_type->tt_argcount = argcount + varargs;
8333 ufunc->uf_func_type->tt_min_argcount =
8334 argcount - ufunc->uf_def_args.ga_len;
8335 if (ufunc->uf_arg_types == NULL)
8336 {
8337 int i;
8338
8339 // lambda does not have argument types.
8340 for (i = 0; i < argcount; ++i)
8341 ufunc->uf_func_type->tt_args[i] = &t_any;
8342 }
8343 else
8344 mch_memmove(ufunc->uf_func_type->tt_args,
8345 ufunc->uf_arg_types, sizeof(type_T *) * argcount);
8346 if (varargs)
8347 {
8348 ufunc->uf_func_type->tt_args[argcount] =
8349 ufunc->uf_va_type == NULL ? &t_any : ufunc->uf_va_type;
8350 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
8351 }
8352 }
8353 else
8354 // No arguments, can use a predefined type.
8355 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
8356 argcount, &ufunc->uf_type_list);
8357}
8358
8359
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008360/*
8361 * Delete an instruction, free what it contains.
8362 */
Bram Moolenaar20431c92020-03-20 18:39:46 +01008363 void
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008364delete_instr(isn_T *isn)
8365{
8366 switch (isn->isn_type)
8367 {
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008368 case ISN_DEF:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008369 case ISN_EXEC:
Bram Moolenaar03290b82020-12-19 16:30:44 +01008370 case ISN_LOADAUTO:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008371 case ISN_LOADB:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008372 case ISN_LOADENV:
8373 case ISN_LOADG:
8374 case ISN_LOADOPT:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008375 case ISN_LOADT:
8376 case ISN_LOADW:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008377 case ISN_PUSHEXC:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008378 case ISN_PUSHFUNC:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008379 case ISN_PUSHS:
Bram Moolenaar08597872020-12-10 19:43:40 +01008380 case ISN_RANGE:
Bram Moolenaar03290b82020-12-19 16:30:44 +01008381 case ISN_STOREAUTO:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008382 case ISN_STOREB:
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01008383 case ISN_STOREENV:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008384 case ISN_STOREG:
Bram Moolenaard3aac292020-04-19 14:32:17 +02008385 case ISN_STORET:
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01008386 case ISN_STOREW:
8387 case ISN_STRINGMEMBER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008388 vim_free(isn->isn_arg.string);
8389 break;
8390
8391 case ISN_LOADS:
Bram Moolenaarb283a8a2020-02-02 22:24:04 +01008392 case ISN_STORES:
8393 vim_free(isn->isn_arg.loadstore.ls_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008394 break;
8395
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02008396 case ISN_UNLET:
Bram Moolenaar7bdaea62020-04-19 18:27:26 +02008397 case ISN_UNLETENV:
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02008398 vim_free(isn->isn_arg.unlet.ul_name);
8399 break;
8400
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008401 case ISN_STOREOPT:
8402 vim_free(isn->isn_arg.storeopt.so_name);
8403 break;
8404
8405 case ISN_PUSHBLOB: // push blob isn_arg.blob
8406 blob_unref(isn->isn_arg.blob);
8407 break;
8408
Bram Moolenaar42a480b2020-02-29 23:23:47 +01008409 case ISN_PUSHJOB:
Bram Moolenaarf4f190d2020-03-01 13:01:16 +01008410#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar42a480b2020-02-29 23:23:47 +01008411 job_unref(isn->isn_arg.job);
Bram Moolenaarf4f190d2020-03-01 13:01:16 +01008412#endif
Bram Moolenaar42a480b2020-02-29 23:23:47 +01008413 break;
8414
8415 case ISN_PUSHCHANNEL:
Bram Moolenaarf4f190d2020-03-01 13:01:16 +01008416#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar42a480b2020-02-29 23:23:47 +01008417 channel_unref(isn->isn_arg.channel);
Bram Moolenaarf4f190d2020-03-01 13:01:16 +01008418#endif
Bram Moolenaar42a480b2020-02-29 23:23:47 +01008419 break;
8420
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008421 case ISN_UCALL:
8422 vim_free(isn->isn_arg.ufunc.cuf_name);
8423 break;
8424
Bram Moolenaar221fcc72020-05-05 19:46:20 +02008425 case ISN_FUNCREF:
8426 {
8427 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8428 + isn->isn_arg.funcref.fr_func;
Bram Moolenaar077a4232020-12-22 18:33:27 +01008429 ufunc_T *ufunc = dfunc->df_ufunc;
Bram Moolenaara05e5242020-09-19 18:19:19 +02008430
Bram Moolenaar077a4232020-12-22 18:33:27 +01008431 if (ufunc != NULL && func_name_refcount(ufunc->uf_name))
8432 func_ptr_unref(ufunc);
Bram Moolenaara05e5242020-09-19 18:19:19 +02008433 }
8434 break;
8435
8436 case ISN_DCALL:
8437 {
8438 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8439 + isn->isn_arg.dfunc.cdf_idx;
8440
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02008441 if (dfunc->df_ufunc != NULL
8442 && func_name_refcount(dfunc->df_ufunc->uf_name))
Bram Moolenaara05e5242020-09-19 18:19:19 +02008443 func_ptr_unref(dfunc->df_ufunc);
Bram Moolenaar221fcc72020-05-05 19:46:20 +02008444 }
8445 break;
8446
Bram Moolenaar38ddf332020-07-31 22:05:04 +02008447 case ISN_NEWFUNC:
Bram Moolenaarce658352020-07-31 23:47:12 +02008448 {
8449 char_u *lambda = isn->isn_arg.newfunc.nf_lambda;
8450 ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL);
8451
8452 if (ufunc != NULL)
8453 {
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008454 unlink_def_function(ufunc);
Bram Moolenaarce658352020-07-31 23:47:12 +02008455 func_ptr_unref(ufunc);
8456 }
8457
8458 vim_free(lambda);
8459 vim_free(isn->isn_arg.newfunc.nf_global);
8460 }
Bram Moolenaar38ddf332020-07-31 22:05:04 +02008461 break;
8462
Bram Moolenaar5e654232020-09-16 15:22:00 +02008463 case ISN_CHECKTYPE:
Bram Moolenaaraa210a32021-01-02 15:41:03 +01008464 case ISN_SETTYPE:
Bram Moolenaar5e654232020-09-16 15:22:00 +02008465 free_type(isn->isn_arg.type.ct_type);
8466 break;
8467
Bram Moolenaar02194d22020-10-24 23:08:38 +02008468 case ISN_CMDMOD:
8469 vim_regfree(isn->isn_arg.cmdmod.cf_cmdmod
8470 ->cmod_filter_regmatch.regprog);
8471 vim_free(isn->isn_arg.cmdmod.cf_cmdmod);
8472 break;
8473
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01008474 case ISN_LOADSCRIPT:
8475 case ISN_STORESCRIPT:
8476 vim_free(isn->isn_arg.script.scriptref);
8477 break;
8478
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008479 case ISN_2BOOL:
8480 case ISN_2STRING:
Bram Moolenaar418f1df2020-08-12 21:34:49 +02008481 case ISN_2STRING_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008482 case ISN_ADDBLOB:
8483 case ISN_ADDLIST:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008484 case ISN_ANYINDEX:
8485 case ISN_ANYSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008486 case ISN_BCALL:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02008487 case ISN_BLOBAPPEND:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008488 case ISN_CATCH:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008489 case ISN_CHECKLEN:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008490 case ISN_CHECKNR:
Bram Moolenaar02194d22020-10-24 23:08:38 +02008491 case ISN_CMDMOD_REV:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008492 case ISN_COMPAREANY:
8493 case ISN_COMPAREBLOB:
8494 case ISN_COMPAREBOOL:
8495 case ISN_COMPAREDICT:
8496 case ISN_COMPAREFLOAT:
8497 case ISN_COMPAREFUNC:
8498 case ISN_COMPARELIST:
8499 case ISN_COMPARENR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008500 case ISN_COMPARESPECIAL:
8501 case ISN_COMPARESTRING:
8502 case ISN_CONCAT:
Bram Moolenaar2bb26582020-10-03 22:52:39 +02008503 case ISN_COND2BOOL:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008504 case ISN_DROP:
8505 case ISN_ECHO:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02008506 case ISN_ECHOERR:
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008507 case ISN_ECHOMSG:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008508 case ISN_ENDTRY:
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02008509 case ISN_EXECCONCAT:
8510 case ISN_EXECUTE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008511 case ISN_FOR:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008512 case ISN_GETITEM:
8513 case ISN_JUMP:
Bram Moolenaar1dcae592020-10-19 19:02:42 +02008514 case ISN_LISTAPPEND:
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02008515 case ISN_LISTINDEX:
Bram Moolenaared591872020-08-15 22:14:53 +02008516 case ISN_LISTSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008517 case ISN_LOAD:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02008518 case ISN_LOADBDICT:
8519 case ISN_LOADGDICT:
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02008520 case ISN_LOADOUTER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008521 case ISN_LOADREG:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02008522 case ISN_LOADTDICT:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008523 case ISN_LOADV:
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02008524 case ISN_LOADWDICT:
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02008525 case ISN_LOCKCONST:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008526 case ISN_MEMBER:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008527 case ISN_NEGATENR:
8528 case ISN_NEWDICT:
8529 case ISN_NEWLIST:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008530 case ISN_OPANY:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008531 case ISN_OPFLOAT:
8532 case ISN_OPNR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008533 case ISN_PCALL:
Bram Moolenaarbd5da372020-03-31 23:13:10 +02008534 case ISN_PCALL_END:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008535 case ISN_PUSHBOOL:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008536 case ISN_PUSHF:
8537 case ISN_PUSHNR:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008538 case ISN_PUSHSPEC:
Bram Moolenaarc3516f72020-09-08 22:45:35 +02008539 case ISN_PUT:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008540 case ISN_RETURN:
Bram Moolenaar299f3032021-01-08 20:53:09 +01008541 case ISN_RETURN_ZERO:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008542 case ISN_SHUFFLE:
8543 case ISN_SLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008544 case ISN_STORE:
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01008545 case ISN_STOREINDEX:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008546 case ISN_STORENR:
8547 case ISN_STOREOUTER:
8548 case ISN_STOREREG:
Bram Moolenaarcc673e72020-08-16 17:33:35 +02008549 case ISN_STOREV:
8550 case ISN_STRINDEX:
8551 case ISN_STRSLICE:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008552 case ISN_THROW:
8553 case ISN_TRY:
Bram Moolenaar752fc692021-01-04 21:57:11 +01008554 case ISN_UNLETINDEX:
Bram Moolenaar792f7862020-11-23 08:31:18 +01008555 case ISN_UNPACK:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008556 // nothing allocated
8557 break;
8558 }
8559}
8560
8561/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008562 * Free all instructions for "dfunc" except df_name.
Bram Moolenaar20431c92020-03-20 18:39:46 +01008563 */
8564 static void
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01008565delete_def_function_contents(dfunc_T *dfunc, int mark_deleted)
Bram Moolenaar20431c92020-03-20 18:39:46 +01008566{
8567 int idx;
8568
8569 ga_clear(&dfunc->df_def_args_isn);
8570
8571 if (dfunc->df_instr != NULL)
8572 {
8573 for (idx = 0; idx < dfunc->df_instr_count; ++idx)
8574 delete_instr(dfunc->df_instr + idx);
8575 VIM_CLEAR(dfunc->df_instr);
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01008576 dfunc->df_instr = NULL;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008577 }
8578
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01008579 if (mark_deleted)
8580 dfunc->df_deleted = TRUE;
8581 if (dfunc->df_ufunc != NULL)
8582 dfunc->df_ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaar20431c92020-03-20 18:39:46 +01008583}
8584
8585/*
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02008586 * When a user function is deleted, clear the contents of any associated def
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008587 * function, unless another user function still uses it.
8588 * The position in def_functions can be re-used.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008589 */
8590 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008591unlink_def_function(ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008592{
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02008593 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008594 {
8595 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8596 + ufunc->uf_dfunc_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008597
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008598 if (--dfunc->df_refcount <= 0)
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01008599 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02008600 ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008601 ufunc->uf_dfunc_idx = 0;
8602 if (dfunc->df_ufunc == ufunc)
8603 dfunc->df_ufunc = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008604 }
8605}
8606
Bram Moolenaarfdeab652020-09-19 15:16:50 +02008607/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008608 * Used when a user function refers to an existing dfunc.
Bram Moolenaarfdeab652020-09-19 15:16:50 +02008609 */
8610 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008611link_def_function(ufunc_T *ufunc)
Bram Moolenaarfdeab652020-09-19 15:16:50 +02008612{
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008613 if (ufunc->uf_dfunc_idx > 0)
8614 {
8615 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
8616 + ufunc->uf_dfunc_idx;
Bram Moolenaarfdeab652020-09-19 15:16:50 +02008617
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008618 ++dfunc->df_refcount;
8619 }
Bram Moolenaarfdeab652020-09-19 15:16:50 +02008620}
8621
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008622#if defined(EXITFREE) || defined(PROTO)
Bram Moolenaar20431c92020-03-20 18:39:46 +01008623/*
8624 * Free all functions defined with ":def".
8625 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008626 void
8627free_def_functions(void)
8628{
Bram Moolenaar20431c92020-03-20 18:39:46 +01008629 int idx;
8630
8631 for (idx = 0; idx < def_functions.ga_len; ++idx)
8632 {
8633 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx;
8634
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01008635 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01008636 vim_free(dfunc->df_name);
Bram Moolenaar20431c92020-03-20 18:39:46 +01008637 }
8638
8639 ga_clear(&def_functions);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008640}
8641#endif
8642
8643
8644#endif // FEAT_EVAL