blob: d8119c566576f9bc9498bb01c2913b44ba479592 [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/*
Bram Moolenaardc7c3662021-12-20 15:04:29 +000011 * vim9compile.c: compiling a :def function
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010012 */
13
14#define USING_FLOAT_STUFF
15#include "vim.h"
16
17#if defined(FEAT_EVAL) || defined(PROTO)
18
Bram Moolenaardc7c3662021-12-20 15:04:29 +000019// When not generating protos this is included in proto.h
20#ifdef PROTO
21# include "vim9.h"
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010022#endif
23
Bram Moolenaardc7c3662021-12-20 15:04:29 +000024// Functions defined with :def are stored in this growarray.
25// They are never removed, so that they can be found by index.
26// Deleted functions have the df_deleted flag set.
27garray_T def_functions = {0, 0, sizeof(dfunc_T), 50, NULL};
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010028
Bram Moolenaarcdc40c42020-12-26 17:43:08 +010029static void delete_def_function_contents(dfunc_T *dfunc, int mark_deleted);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010030
31/*
Bram Moolenaar709664c2020-12-12 14:33:41 +010032 * Lookup variable "name" in the local scope and return it in "lvar".
Bram Moolenaarab360522021-01-10 14:02:28 +010033 * "lvar->lv_from_outer" is incremented accordingly.
Bram Moolenaar709664c2020-12-12 14:33:41 +010034 * If "lvar" is NULL only check if the variable can be found.
35 * Return FAIL if not found.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010036 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +000037 int
Bram Moolenaar709664c2020-12-12 14:33:41 +010038lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010039{
40 int idx;
Bram Moolenaar709664c2020-12-12 14:33:41 +010041 lvar_T *lvp;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010042
Bram Moolenaarae8d2de2020-02-13 21:42:24 +010043 if (len == 0)
Bram Moolenaar709664c2020-12-12 14:33:41 +010044 return FAIL;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020045
46 // Find local in current function scope.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010047 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
48 {
Bram Moolenaar709664c2020-12-12 14:33:41 +010049 lvp = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
50 if (STRNCMP(name, lvp->lv_name, len) == 0
51 && STRLEN(lvp->lv_name) == len)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020052 {
Bram Moolenaar709664c2020-12-12 14:33:41 +010053 if (lvar != NULL)
54 {
55 *lvar = *lvp;
Bram Moolenaarab360522021-01-10 14:02:28 +010056 lvar->lv_from_outer = 0;
Bram Moolenaar709664c2020-12-12 14:33:41 +010057 }
58 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020059 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010060 }
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020061
62 // Find local in outer function scope.
63 if (cctx->ctx_outer != NULL)
64 {
Bram Moolenaar709664c2020-12-12 14:33:41 +010065 if (lookup_local(name, len, lvar, cctx->ctx_outer) == OK)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020066 {
Bram Moolenaar709664c2020-12-12 14:33:41 +010067 if (lvar != NULL)
68 {
69 cctx->ctx_outer_used = TRUE;
Bram Moolenaarab360522021-01-10 14:02:28 +010070 ++lvar->lv_from_outer;
Bram Moolenaar709664c2020-12-12 14:33:41 +010071 }
72 return OK;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +020073 }
74 }
75
Bram Moolenaar709664c2020-12-12 14:33:41 +010076 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010077}
78
79/*
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +020080 * Lookup an argument in the current function and an enclosing function.
81 * Returns the argument index in "idxp"
82 * Returns the argument type in "type"
83 * Sets "gen_load_outer" to TRUE if found in outer scope.
84 * Returns OK when found, FAIL otherwise.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010085 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +000086 int
Bram Moolenaarfbbcd002020-10-15 12:46:44 +020087arg_exists(
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +020088 char_u *name,
89 size_t len,
90 int *idxp,
91 type_T **type,
92 int *gen_load_outer,
93 cctx_T *cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010094{
95 int idx;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +020096 char_u *va_name;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010097
Bram Moolenaarae8d2de2020-02-13 21:42:24 +010098 if (len == 0)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +020099 return FAIL;
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200100 for (idx = 0; idx < cctx->ctx_ufunc->uf_args_visible; ++idx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100101 {
102 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx);
103
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200104 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL)
105 {
106 if (idxp != NULL)
107 {
108 // Arguments are located above the frame pointer. One further
109 // if there is a vararg argument
110 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len
111 + STACK_FRAME_SIZE)
112 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0);
113
114 if (cctx->ctx_ufunc->uf_arg_types != NULL)
115 *type = cctx->ctx_ufunc->uf_arg_types[idx];
116 else
117 *type = &t_any;
118 }
119 return OK;
120 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100121 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100122
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200123 va_name = cctx->ctx_ufunc->uf_va_name;
124 if (va_name != NULL
125 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL)
126 {
127 if (idxp != NULL)
128 {
129 // varargs is always the last argument
130 *idxp = -STACK_FRAME_SIZE - 1;
131 *type = cctx->ctx_ufunc->uf_va_type;
132 }
133 return OK;
134 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100135
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200136 if (cctx->ctx_outer != NULL)
137 {
138 // Lookup the name for an argument of the outer function.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200139 if (arg_exists(name, len, idxp, type, gen_load_outer, cctx->ctx_outer)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200140 == OK)
141 {
Bram Moolenaar44ec21c2021-02-12 21:50:57 +0100142 if (gen_load_outer != NULL)
143 ++*gen_load_outer;
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +0200144 return OK;
145 }
146 }
147
148 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100149}
150
151/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200152 * Lookup a script-local variable in the current script, possibly defined in a
153 * block that contains the function "cctx->ctx_ufunc".
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000154 * "cctx" is NULL at the script level, "cstack" is NULL in a function.
Bram Moolenaar18062fc2021-03-05 21:35:47 +0100155 * If "len" is <= 0 "name" must be NUL terminated.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200156 * Return NULL when not found.
157 */
158 static sallvar_T *
Bram Moolenaardce24412022-02-08 20:35:30 +0000159find_script_var(char_u *name, size_t len, cctx_T *cctx, cstack_T *cstack)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200160{
161 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
162 hashitem_T *hi;
163 int cc;
164 sallvar_T *sav;
165 ufunc_T *ufunc;
166
167 // Find the list of all script variables with the right name.
168 if (len > 0)
169 {
170 cc = name[len];
171 name[len] = NUL;
172 }
173 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
174 if (len > 0)
175 name[len] = cc;
176 if (HASHITEM_EMPTY(hi))
177 return NULL;
178
179 sav = HI2SAV(hi);
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200180 if (sav->sav_block_id == 0)
181 // variable defined in the top script scope is always visible
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200182 return sav;
183
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200184 if (cctx == NULL)
185 {
Bram Moolenaardce24412022-02-08 20:35:30 +0000186 // Not in a function scope, find variable with block ID equal to or
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000187 // smaller than the current block id. Use "cstack" to go up the block
188 // scopes.
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200189 while (sav != NULL)
190 {
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000191 int idx;
Bram Moolenaardce24412022-02-08 20:35:30 +0000192
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000193 for (idx = cstack->cs_idx; idx >= 0; --idx)
194 if (cstack->cs_block_id[idx] == sav->sav_block_id)
Bram Moolenaardce24412022-02-08 20:35:30 +0000195 break;
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000196 if (idx >= 0)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200197 break;
198 sav = sav->sav_next;
199 }
200 return sav;
201 }
202
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200203 // Go over the variables with this name and find one that was visible
204 // from the function.
205 ufunc = cctx->ctx_ufunc;
206 while (sav != NULL)
207 {
208 int idx;
209
210 // Go over the blocks that this function was defined in. If the
211 // variable block ID matches it was visible to the function.
212 for (idx = 0; idx < ufunc->uf_block_depth; ++idx)
213 if (ufunc->uf_block_ids[idx] == sav->sav_block_id)
214 return sav;
215 sav = sav->sav_next;
216 }
217
Bram Moolenaar58493cf2022-01-06 12:23:30 +0000218 // Not found, variable was not visible.
219 return NULL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200220}
221
222/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +0100223 * Return TRUE if the script context is Vim9 script.
Bram Moolenaar84367732020-08-23 15:21:55 +0200224 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000225 int
Bram Moolenaar84367732020-08-23 15:21:55 +0200226script_is_vim9()
227{
228 return SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9;
229}
230
231/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200232 * Lookup a variable (without s: prefix) in the current script.
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000233 * "cctx" is NULL at the script level, "cstack" is NULL in a function.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100234 * Returns OK or FAIL.
235 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000236 int
Bram Moolenaardce24412022-02-08 20:35:30 +0000237script_var_exists(char_u *name, size_t len, cctx_T *cctx, cstack_T *cstack)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100238{
Bram Moolenaar9c4f5522020-09-25 21:47:28 +0200239 if (current_sctx.sc_sid <= 0)
240 return FAIL;
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200241 if (script_is_vim9())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200242 {
243 // Check script variables that were visible where the function was
244 // defined.
Bram Moolenaardce24412022-02-08 20:35:30 +0000245 if (find_script_var(name, len, cctx, cstack) != NULL)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200246 return OK;
247 }
248 else
249 {
250 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
251 dictitem_T *di;
252 int cc;
253
254 // Check script variables that are currently visible
255 cc = name[len];
256 name[len] = NUL;
257 di = find_var_in_ht(ht, 0, name, TRUE);
258 name[len] = cc;
259 if (di != NULL)
260 return OK;
261 }
262
263 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100264}
265
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100266/*
Bram Moolenaare0890d62021-02-17 14:52:14 +0100267 * Return TRUE if "name" is a local variable, argument, script variable or
268 * imported.
269 */
270 static int
271variable_exists(char_u *name, size_t len, cctx_T *cctx)
272{
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100273 return (cctx != NULL
274 && (lookup_local(name, len, NULL, cctx) == OK
275 || arg_exists(name, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaardce24412022-02-08 20:35:30 +0000276 || script_var_exists(name, len, cctx, NULL) == OK
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000277 || find_imported(name, len, FALSE) != NULL;
Bram Moolenaare0890d62021-02-17 14:52:14 +0100278}
279
280/*
Bram Moolenaar6914e872021-03-06 21:01:09 +0100281 * Return TRUE if "name" is a local variable, argument, script variable,
282 * imported or function.
283 */
284 static int
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100285item_exists(char_u *name, size_t len, int cmd UNUSED, cctx_T *cctx)
Bram Moolenaar6914e872021-03-06 21:01:09 +0100286{
Bram Moolenaar0631bb42022-02-13 21:20:21 +0000287 return variable_exists(name, len, cctx);
Bram Moolenaar6914e872021-03-06 21:01:09 +0100288}
289
290/*
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100291 * Check if "p[len]" is already defined, either in script "import_sid" or in
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000292 * compilation context "cctx".
293 * "cctx" is NULL at the script level, "cstack" is NULL in a function.
Bram Moolenaar0f769812020-09-12 18:32:34 +0200294 * Does not check the global namespace.
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100295 * If "is_arg" is TRUE the error message is for an argument name.
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100296 * Return FAIL and give an error if it defined.
297 */
298 int
Bram Moolenaardce24412022-02-08 20:35:30 +0000299check_defined(
300 char_u *p,
301 size_t len,
302 cctx_T *cctx,
303 cstack_T *cstack,
304 int is_arg)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100305{
Bram Moolenaar0f769812020-09-12 18:32:34 +0200306 int c = p[len];
307 ufunc_T *ufunc = NULL;
Bram Moolenaarad486a02020-08-01 23:22:18 +0200308
Bram Moolenaarda479c72021-04-10 21:01:38 +0200309 // underscore argument is OK
310 if (len == 1 && *p == '_')
311 return OK;
312
Bram Moolenaardce24412022-02-08 20:35:30 +0000313 if (script_var_exists(p, len, cctx, cstack) == OK)
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100314 {
315 if (is_arg)
316 semsg(_(e_argument_already_declared_in_script_str), p);
317 else
318 semsg(_(e_variable_already_declared_in_script_str), p);
319 return FAIL;
320 }
321
Bram Moolenaarad486a02020-08-01 23:22:18 +0200322 p[len] = NUL;
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100323 if ((cctx != NULL
Bram Moolenaar709664c2020-12-12 14:33:41 +0100324 && (lookup_local(p, len, NULL, cctx) == OK
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200325 || arg_exists(p, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000326 || find_imported(p, len, FALSE) != NULL
Bram Moolenaaracc4b562022-01-24 13:54:45 +0000327 || (ufunc = find_func_even_dead(p, 0)) != NULL)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100328 {
Bram Moolenaar0f769812020-09-12 18:32:34 +0200329 // A local or script-local function can shadow a global function.
Bram Moolenaar577dc932021-06-27 15:35:40 +0200330 if (ufunc == NULL || ((ufunc->uf_flags & FC_DEAD) == 0
331 && (!func_is_global(ufunc)
332 || (p[0] == 'g' && p[1] == ':'))))
Bram Moolenaar0f769812020-09-12 18:32:34 +0200333 {
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100334 if (is_arg)
335 semsg(_(e_argument_name_shadows_existing_variable_str), p);
336 else
337 semsg(_(e_name_already_defined_str), p);
Bram Moolenaar0f769812020-09-12 18:32:34 +0200338 p[len] = c;
Bram Moolenaar0f769812020-09-12 18:32:34 +0200339 return FAIL;
340 }
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100341 }
Bram Moolenaarad486a02020-08-01 23:22:18 +0200342 p[len] = c;
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100343 return OK;
344}
345
Bram Moolenaar65b95452020-07-19 14:03:09 +0200346
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100347/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200348 * Return TRUE if "actual" could be "expected" and a runtime typecheck is to be
349 * used. Return FALSE if the types will never match.
350 */
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +0200351 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200352use_typecheck(type_T *actual, type_T *expected)
353{
354 if (actual->tt_type == VAR_ANY
355 || actual->tt_type == VAR_UNKNOWN
356 || (actual->tt_type == VAR_FUNC
357 && (expected->tt_type == VAR_FUNC
358 || expected->tt_type == VAR_PARTIAL)
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000359 && (actual->tt_member == &t_any
360 || actual->tt_member == &t_unknown
361 || actual->tt_argcount < 0)
362 && (actual->tt_member == &t_unknown ||
363 (actual->tt_member == &t_void)
Bram Moolenaar328eac22021-01-07 19:23:08 +0100364 == (expected->tt_member == &t_void))))
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200365 return TRUE;
366 if ((actual->tt_type == VAR_LIST || actual->tt_type == VAR_DICT)
367 && actual->tt_type == expected->tt_type)
368 // This takes care of a nested list or dict.
369 return use_typecheck(actual->tt_member, expected->tt_member);
370 return FALSE;
371}
372
373/*
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200374 * Check that
Bram Moolenaar5e654232020-09-16 15:22:00 +0200375 * - "actual" matches "expected" type or
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200376 * - "actual" is a type that can be "expected" type: add a runtime check; or
377 * - return FAIL.
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200378 * If "actual_is_const" is TRUE then the type won't change at runtime, do not
379 * generate a TYPECHECK.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200380 */
Bram Moolenaara1c51952022-02-02 16:20:26 +0000381 int
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200382need_type_where(
383 type_T *actual,
384 type_T *expected,
385 int offset,
386 where_T where,
387 cctx_T *cctx,
388 int silent,
389 int actual_is_const)
390{
Bram Moolenaar44a89772021-12-18 12:31:33 +0000391 int ret;
392
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200393 if (expected == &t_bool && actual != &t_bool
394 && (actual->tt_flags & TTFLAG_BOOL_OK))
395 {
396 // Using "0", "1" or the result of an expression with "&&" or "||" as a
397 // boolean is OK but requires a conversion.
398 generate_2BOOL(cctx, FALSE, offset);
399 return OK;
400 }
401
Bram Moolenaar44a89772021-12-18 12:31:33 +0000402 ret = check_type_maybe(expected, actual, FALSE, where);
403 if (ret == OK)
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200404 return OK;
405
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000406 // If actual a constant a runtime check makes no sense. If it's
407 // null_function it is OK.
408 if (actual_is_const && ret == MAYBE && actual == &t_func_unknown)
409 return OK;
410
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200411 // If the actual type can be the expected type add a runtime check.
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000412 if (!actual_is_const && ret == MAYBE && use_typecheck(actual, expected))
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200413 {
414 generate_TYPECHECK(cctx, expected, offset, where.wt_index);
415 return OK;
416 }
417
418 if (!silent)
419 type_mismatch_where(expected, actual, where);
420 return FAIL;
421}
422
Bram Moolenaar351ead02021-01-16 16:07:01 +0100423 int
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200424need_type(
425 type_T *actual,
426 type_T *expected,
427 int offset,
Bram Moolenaar351ead02021-01-16 16:07:01 +0100428 int arg_idx,
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200429 cctx_T *cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200430 int silent,
431 int actual_is_const)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200432{
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +0200433 where_T where = WHERE_INIT;
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100434
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100435 where.wt_index = arg_idx;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200436 return need_type_where(actual, expected, offset, where,
437 cctx, silent, actual_is_const);
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200438}
439
440/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100441 * Reserve space for a local variable.
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200442 * Return the variable or NULL if it failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100443 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000444 lvar_T *
Bram Moolenaare8211a32020-10-09 22:04:29 +0200445reserve_local(
446 cctx_T *cctx,
447 char_u *name,
448 size_t len,
449 int isConst,
450 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100451{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100452 lvar_T *lvar;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200453 dfunc_T *dfunc;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100454
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200455 if (arg_exists(name, len, NULL, NULL, NULL, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100456 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200457 emsg_namelen(_(e_str_is_used_as_argument), name, (int)len);
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200458 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100459 }
460
Bram Moolenaar35578162021-08-02 19:10:38 +0200461 if (GA_GROW_FAILS(&cctx->ctx_locals, 1))
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200462 return NULL;
463 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
Bram Moolenaare8211a32020-10-09 22:04:29 +0200464 CLEAR_POINTER(lvar);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100465
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200466 // Every local variable uses the next entry on the stack. We could re-use
467 // the last ones when leaving a scope, but then variables used in a closure
468 // might get overwritten. To keep things simple do not re-use stack
469 // entries. This is less efficient, but memory is cheap these days.
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200470 dfunc = ((dfunc_T *)def_functions.ga_data) + cctx->ctx_ufunc->uf_dfunc_idx;
471 lvar->lv_idx = dfunc->df_var_names.ga_len;
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200472
Bram Moolenaar71ccd032020-06-12 22:59:11 +0200473 lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100474 lvar->lv_const = isConst;
475 lvar->lv_type = type;
476
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200477 // Remember the name for debugging.
Bram Moolenaar35578162021-08-02 19:10:38 +0200478 if (GA_GROW_FAILS(&dfunc->df_var_names, 1))
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200479 return NULL;
480 ((char_u **)dfunc->df_var_names.ga_data)[lvar->lv_idx] =
481 vim_strsave(lvar->lv_name);
482 ++dfunc->df_var_names.ga_len;
483
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200484 return lvar;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100485}
486
487/*
Bram Moolenaar08251752021-01-11 21:20:18 +0100488 * If "check_writable" is ASSIGN_CONST give an error if the variable was
489 * defined with :final or :const, if "check_writable" is ASSIGN_FINAL give an
490 * error if the variable was defined with :const.
491 */
492 static int
493check_item_writable(svar_T *sv, int check_writable, char_u *name)
494{
495 if ((check_writable == ASSIGN_CONST && sv->sv_const != 0)
496 || (check_writable == ASSIGN_FINAL
497 && sv->sv_const == ASSIGN_CONST))
498 {
Bram Moolenaard8e44472021-07-21 22:20:33 +0200499 semsg(_(e_cannot_change_readonly_variable_str), name);
Bram Moolenaar08251752021-01-11 21:20:18 +0100500 return FAIL;
501 }
502 return OK;
503}
504
505/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100506 * Find "name" in script-local items of script "sid".
Bram Moolenaar08251752021-01-11 21:20:18 +0100507 * Pass "check_writable" to check_item_writable().
Bram Moolenaar7a3b8022022-02-14 19:53:03 +0000508 * "cctx" is NULL at the script level, "cstack" is NULL in a function.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100509 * Returns the index in "sn_var_vals" if found.
510 * If found but not in "sn_var_vals" returns -1.
Bram Moolenaar08251752021-01-11 21:20:18 +0100511 * If not found or the variable is not writable returns -2.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100512 */
513 int
Bram Moolenaarb6a138e2022-02-08 21:17:22 +0000514get_script_item_idx(
515 int sid,
516 char_u *name,
517 int check_writable,
518 cctx_T *cctx,
519 cstack_T *cstack)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100520{
521 hashtab_T *ht;
522 dictitem_T *di;
Bram Moolenaar21b9e972020-01-26 19:26:46 +0100523 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200524 svar_T *sv;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100525 int idx;
526
Bram Moolenaare3d46852020-08-29 13:39:17 +0200527 if (!SCRIPT_ID_VALID(sid))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100528 return -1;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200529 if (sid == current_sctx.sc_sid)
530 {
Bram Moolenaarb6a138e2022-02-08 21:17:22 +0000531 sallvar_T *sav = find_script_var(name, 0, cctx, cstack);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200532
533 if (sav == NULL)
534 return -2;
535 idx = sav->sav_var_vals_idx;
536 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar08251752021-01-11 21:20:18 +0100537 if (check_item_writable(sv, check_writable, name) == FAIL)
538 return -2;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200539 return idx;
540 }
541
542 // First look the name up in the hashtable.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100543 ht = &SCRIPT_VARS(sid);
544 di = find_var_in_ht(ht, 0, name, TRUE);
545 if (di == NULL)
Bram Moolenaar577bd852022-01-10 18:42:52 +0000546 {
547 if (si->sn_autoload_prefix != NULL)
548 {
549 hashitem_T *hi;
550
551 // A variable exported from an autoload script is in the global
552 // variables, we can find it in the all_vars table.
553 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
554 if (!HASHITEM_EMPTY(hi))
555 return HI2SAV(hi)->sav_var_vals_idx;
556 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100557 return -2;
Bram Moolenaar577bd852022-01-10 18:42:52 +0000558 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100559
560 // Now find the svar_T index in sn_var_vals.
561 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
562 {
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200563 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100564 if (sv->sv_tv == &di->di_tv)
565 {
Bram Moolenaar08251752021-01-11 21:20:18 +0100566 if (check_item_writable(sv, check_writable, name) == FAIL)
567 return -2;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100568 return idx;
569 }
570 }
571 return -1;
572}
573
Yegappan Lakshmanan782b43d2022-01-08 18:43:40 +0000574 static imported_T *
575find_imported_in_script(char_u *name, size_t len, int sid)
576{
577 scriptitem_T *si;
578 int idx;
579
580 if (!SCRIPT_ID_VALID(sid))
581 return NULL;
582 si = SCRIPT_ITEM(sid);
583 for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
584 {
585 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx;
586
587 if (len == 0 ? STRCMP(name, import->imp_name) == 0
588 : STRLEN(import->imp_name) == len
589 && STRNCMP(name, import->imp_name, len) == 0)
590 return import;
591 }
592 return NULL;
593}
594
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100595/*
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000596 * Find "name" in imported items of the current script.
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000597 * If "load" is TRUE and the script was not loaded yet, load it now.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100598 */
599 imported_T *
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000600find_imported(char_u *name, size_t len, int load)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100601{
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000602 imported_T *ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100603
Bram Moolenaare3d46852020-08-29 13:39:17 +0200604 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
Bram Moolenaar8e6cbb72020-07-01 14:38:12 +0200605 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100606
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000607 ret = find_imported_in_script(name, len, current_sctx.sc_sid);
Bram Moolenaarb697dc22022-01-22 11:27:29 +0000608 if (ret != NULL && load && (ret->imp_flags & IMP_FLAGS_AUTOLOAD))
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000609 {
Bram Moolenaar17d36cb2022-01-12 11:46:40 +0000610 scid_T dummy;
611
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000612 // script found before but not loaded yet
Bram Moolenaarb697dc22022-01-22 11:27:29 +0000613 ret->imp_flags &= ~IMP_FLAGS_AUTOLOAD;
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000614 (void)do_source(SCRIPT_ITEM(ret->imp_sid)->sn_name, FALSE,
Bram Moolenaar17d36cb2022-01-12 11:46:40 +0000615 DOSO_NONE, &dummy);
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000616 }
617 return ret;
Bram Moolenaarefa94442020-08-08 22:16:00 +0200618}
619
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100620/*
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000621 * Called when checking for a following operator at "arg". When the rest of
622 * the line is empty or only a comment, peek the next line. If there is a next
623 * line return a pointer to it and set "nextp".
624 * Otherwise skip over white space.
625 */
626 char_u *
627may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp)
628{
629 char_u *p = skipwhite(arg);
630
631 *nextp = NULL;
632 if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p)))
633 {
634 *nextp = peek_next_line_from_context(cctx);
635 if (*nextp != NULL)
636 return *nextp;
637 }
638 return p;
639}
640
641/*
Bram Moolenaar23c55272020-06-21 16:58:13 +0200642 * Return a pointer to the next line that isn't empty or only contains a
643 * comment. Skips over white space.
644 * Returns NULL if there is none.
645 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200646 char_u *
647peek_next_line_from_context(cctx_T *cctx)
Bram Moolenaar23c55272020-06-21 16:58:13 +0200648{
649 int lnum = cctx->ctx_lnum;
650
651 while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len)
652 {
653 char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum];
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +0200654 char_u *p;
Bram Moolenaar23c55272020-06-21 16:58:13 +0200655
Bram Moolenaarba60cc42020-08-12 19:15:33 +0200656 // ignore NULLs inserted for continuation lines
657 if (line != NULL)
658 {
659 p = skipwhite(line);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +0100660 if (vim9_bad_comment(p))
661 return NULL;
Bram Moolenaarba60cc42020-08-12 19:15:33 +0200662 if (*p != NUL && !vim9_comment_start(p))
663 return p;
664 }
Bram Moolenaar23c55272020-06-21 16:58:13 +0200665 }
666 return NULL;
667}
668
669/*
Bram Moolenaare6085c52020-04-12 20:19:16 +0200670 * Get the next line of the function from "cctx".
Bram Moolenaar23c55272020-06-21 16:58:13 +0200671 * Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE.
Bram Moolenaare6085c52020-04-12 20:19:16 +0200672 * Returns NULL when at the end.
673 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200674 char_u *
Bram Moolenaar23c55272020-06-21 16:58:13 +0200675next_line_from_context(cctx_T *cctx, int skip_comment)
Bram Moolenaare6085c52020-04-12 20:19:16 +0200676{
Bram Moolenaar7a092242020-04-16 22:10:49 +0200677 char_u *line;
Bram Moolenaare6085c52020-04-12 20:19:16 +0200678
679 do
680 {
681 ++cctx->ctx_lnum;
682 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200683 {
684 line = NULL;
Bram Moolenaare6085c52020-04-12 20:19:16 +0200685 break;
Bram Moolenaar7a092242020-04-16 22:10:49 +0200686 }
Bram Moolenaare6085c52020-04-12 20:19:16 +0200687 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
Bram Moolenaar7a092242020-04-16 22:10:49 +0200688 cctx->ctx_line_start = line;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200689 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar23c55272020-06-21 16:58:13 +0200690 } while (line == NULL || *skipwhite(line) == NUL
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +0200691 || (skip_comment && vim9_comment_start(skipwhite(line))));
Bram Moolenaare6085c52020-04-12 20:19:16 +0200692 return line;
693}
694
695/*
Bram Moolenaar5afd0812021-01-03 18:33:13 +0100696 * Skip over white space at "whitep" and assign to "*arg".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200697 * If "*arg" is at the end of the line, advance to the next line.
Bram Moolenaar2c330432020-04-13 14:41:35 +0200698 * Also when "whitep" points to white space and "*arg" is on a "#".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200699 * Return FAIL if beyond the last line, "*arg" is unmodified then.
700 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000701 int
Bram Moolenaar2c330432020-04-13 14:41:35 +0200702may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200703{
Bram Moolenaar5afd0812021-01-03 18:33:13 +0100704 *arg = skipwhite(whitep);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +0100705 if (vim9_bad_comment(*arg))
706 return FAIL;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200707 if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg)))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200708 {
Bram Moolenaar23c55272020-06-21 16:58:13 +0200709 char_u *next = next_line_from_context(cctx, TRUE);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200710
711 if (next == NULL)
712 return FAIL;
713 *arg = skipwhite(next);
714 }
715 return OK;
716}
717
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200718/*
719 * Idem, and give an error when failed.
720 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000721 int
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200722may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx)
723{
724 if (may_get_next_line(whitep, arg, cctx) == FAIL)
725 {
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100726 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200727 emsg(_(e_line_incomplete));
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200728 return FAIL;
729 }
730 return OK;
731}
732
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100733/*
Bram Moolenaar04b12692020-05-04 23:24:44 +0200734 * Get a line from the compilation context, compatible with exarg_T getline().
735 * Return a pointer to the line in allocated memory.
736 * Return NULL for end-of-file or some error.
737 */
738 static char_u *
739exarg_getline(
740 int c UNUSED,
741 void *cookie,
742 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +0200743 getline_opt_T options UNUSED)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200744{
745 cctx_T *cctx = (cctx_T *)cookie;
Bram Moolenaar66250c92020-08-20 15:02:42 +0200746 char_u *p;
Bram Moolenaar04b12692020-05-04 23:24:44 +0200747
Bram Moolenaar66250c92020-08-20 15:02:42 +0200748 for (;;)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200749 {
Bram Moolenaar2914a202020-09-27 18:24:03 +0200750 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len - 1)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200751 return NULL;
752 ++cctx->ctx_lnum;
753 p = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
754 // Comment lines result in NULL pointers, skip them.
755 if (p != NULL)
756 return vim_strsave(p);
Bram Moolenaar04b12692020-05-04 23:24:44 +0200757 }
Bram Moolenaar04b12692020-05-04 23:24:44 +0200758}
759
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +0100760 void
761fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx)
762{
763 eap->getline = exarg_getline;
764 eap->cookie = cctx;
Bram Moolenaar4f3321f2022-03-13 13:12:27 +0000765 eap->skip = cctx->ctx_skip == SKIP_YES;
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +0100766}
767
Bram Moolenaar04b12692020-05-04 23:24:44 +0200768/*
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000769 * Return TRUE if "ufunc" should be compiled, taking into account whether
770 * "profile" indicates profiling is to be done.
771 */
772 int
773func_needs_compiling(ufunc_T *ufunc, compiletype_T compile_type)
774{
775 switch (ufunc->uf_def_status)
776 {
777 case UF_TO_BE_COMPILED:
778 return TRUE;
779
780 case UF_COMPILED:
781 {
782 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
783 + ufunc->uf_dfunc_idx;
784
785 switch (compile_type)
786 {
787 case CT_PROFILE:
788#ifdef FEAT_PROFILE
789 return dfunc->df_instr_prof == NULL;
790#endif
791 case CT_NONE:
792 return dfunc->df_instr == NULL;
793 case CT_DEBUG:
794 return dfunc->df_instr_debug == NULL;
795 }
796 }
797
798 case UF_NOT_COMPILED:
799 case UF_COMPILE_ERROR:
800 case UF_COMPILING:
801 break;
802 }
803 return FALSE;
804}
805
806/*
Bram Moolenaar04b12692020-05-04 23:24:44 +0200807 * Compile a nested :def command.
808 */
809 static char_u *
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +0000810compile_nested_function(exarg_T *eap, cctx_T *cctx, garray_T *lines_to_free)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200811{
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200812 int is_global = *eap->arg == 'g' && eap->arg[1] == ':';
Bram Moolenaar04b12692020-05-04 23:24:44 +0200813 char_u *name_start = eap->arg;
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200814 char_u *name_end = to_name_end(eap->arg, TRUE);
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000815 int off;
816 char_u *func_name;
Bram Moolenaareef21022020-08-01 22:16:43 +0200817 char_u *lambda_name;
Bram Moolenaar04b12692020-05-04 23:24:44 +0200818 ufunc_T *ufunc;
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100819 int r = FAIL;
Bram Moolenaarffcfddc2021-07-11 20:22:30 +0200820 compiletype_T compile_type;
Bram Moolenaar04b12692020-05-04 23:24:44 +0200821
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200822 if (eap->forceit)
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200823 {
824 emsg(_(e_cannot_use_bang_with_nested_def));
825 return NULL;
826 }
827
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100828 if (*name_start == '/')
829 {
830 name_end = skip_regexp(name_start + 1, '/', TRUE);
831 if (*name_end == '/')
832 ++name_end;
Bram Moolenaar63b91732021-08-05 20:40:03 +0200833 set_nextcmd(eap, name_end);
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100834 }
835 if (name_end == name_start || *skipwhite(name_end) != '(')
836 {
837 if (!ends_excmd2(name_start, name_end))
838 {
Bram Moolenaardea5ab02022-02-23 22:12:02 +0000839 if (*skipwhite(name_end) == '.')
840 semsg(_(e_cannot_define_dict_func_in_vim9_script_str),
841 eap->cmd);
842 else
843 semsg(_(e_invalid_command_str), eap->cmd);
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100844 return NULL;
845 }
846
847 // "def" or "def Name": list functions
848 if (generate_DEF(cctx, name_start, name_end - name_start) == FAIL)
849 return NULL;
850 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
851 }
852
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200853 // Only g:Func() can use a namespace.
854 if (name_start[1] == ':' && !is_global)
855 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200856 semsg(_(e_namespace_not_supported_str), name_start);
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200857 return NULL;
858 }
Bram Moolenaar4f3321f2022-03-13 13:12:27 +0000859 if (cctx->ctx_skip != SKIP_YES
860 && check_defined(name_start, name_end - name_start, cctx,
Bram Moolenaardce24412022-02-08 20:35:30 +0000861 NULL, FALSE) == FAIL)
Bram Moolenaareef21022020-08-01 22:16:43 +0200862 return NULL;
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000863 if (!ASCII_ISUPPER(is_global ? name_start[2] : name_start[0]))
864 {
Bram Moolenaar3787f262022-02-07 21:54:01 +0000865 semsg(_(e_function_name_must_start_with_capital_str), name_start);
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000866 return NULL;
867 }
Bram Moolenaareef21022020-08-01 22:16:43 +0200868
Bram Moolenaar04b12692020-05-04 23:24:44 +0200869 eap->arg = name_end;
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +0100870 fill_exarg_from_cctx(eap, cctx);
871
Bram Moolenaar04b12692020-05-04 23:24:44 +0200872 eap->forceit = FALSE;
Bram Moolenaar38453522021-11-28 22:00:12 +0000873 // We use the special <Lamba>99 name, but it's not really a lambda.
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100874 lambda_name = vim_strsave(get_lambda_name());
875 if (lambda_name == NULL)
876 return NULL;
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000877
878 // This may free the current line, make a copy of the name.
879 off = is_global ? 2 : 0;
880 func_name = vim_strnsave(name_start + off, name_end - name_start - off);
881 if (func_name == NULL)
882 {
883 r = FAIL;
884 goto theend;
885 }
886
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +0000887 ufunc = define_function(eap, lambda_name, lines_to_free);
Bram Moolenaar822ba242020-05-24 23:00:18 +0200888 if (ufunc == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100889 {
890 r = eap->skip ? OK : FAIL;
891 goto theend;
892 }
Bram Moolenaar7473a842021-12-28 17:55:26 +0000893 if (eap->nextcmd != NULL)
894 {
895 semsg(_(e_text_found_after_str_str),
896 eap->cmdidx == CMD_def ? "enddef" : "endfunction", eap->nextcmd);
897 r = FAIL;
Bram Moolenaard2939812021-12-30 17:09:05 +0000898 func_ptr_unref(ufunc);
Bram Moolenaar7473a842021-12-28 17:55:26 +0000899 goto theend;
900 }
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100901
902 // copy over the block scope IDs before compiling
903 if (!is_global && cctx->ctx_ufunc->uf_block_depth > 0)
904 {
905 int block_depth = cctx->ctx_ufunc->uf_block_depth;
906
907 ufunc->uf_block_ids = ALLOC_MULT(int, block_depth);
908 if (ufunc->uf_block_ids != NULL)
909 {
910 mch_memmove(ufunc->uf_block_ids, cctx->ctx_ufunc->uf_block_ids,
911 sizeof(int) * block_depth);
912 ufunc->uf_block_depth = block_depth;
913 }
914 }
915
Bram Moolenaar96923b72022-03-15 15:57:04 +0000916 update_has_breakpoint(ufunc);
Bram Moolenaarffcfddc2021-07-11 20:22:30 +0200917 compile_type = COMPILE_TYPE(ufunc);
918#ifdef FEAT_PROFILE
919 // If the outer function is profiled, also compile the nested function for
920 // profiling.
921 if (cctx->ctx_compile_type == CT_PROFILE)
922 compile_type = CT_PROFILE;
923#endif
924 if (func_needs_compiling(ufunc, compile_type)
925 && compile_def_function(ufunc, TRUE, compile_type, cctx) == FAIL)
Bram Moolenaar4ee711f2020-09-23 18:51:11 +0200926 {
927 func_ptr_unref(ufunc);
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100928 goto theend;
Bram Moolenaar4ee711f2020-09-23 18:51:11 +0200929 }
Bram Moolenaar04b12692020-05-04 23:24:44 +0200930
Bram Moolenaar648594e2021-07-11 17:55:01 +0200931#ifdef FEAT_PROFILE
932 // When the outer function is compiled for profiling, the nested function
933 // may be called without profiling. Compile it here in the right context.
Bram Moolenaarffcfddc2021-07-11 20:22:30 +0200934 if (compile_type == CT_PROFILE && func_needs_compiling(ufunc, CT_NONE))
Bram Moolenaar648594e2021-07-11 17:55:01 +0200935 compile_def_function(ufunc, FALSE, CT_NONE, cctx);
936#endif
937
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200938 if (is_global)
939 {
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000940 r = generate_NEWFUNC(cctx, lambda_name, func_name);
941 func_name = NULL;
942 lambda_name = NULL;
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200943 }
944 else
945 {
946 // Define a local variable for the function reference.
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000947 lvar_T *lvar = reserve_local(cctx, func_name, name_end - name_start,
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200948 TRUE, ufunc->uf_func_type);
Bram Moolenaare8211a32020-10-09 22:04:29 +0200949
Bram Moolenaareef21022020-08-01 22:16:43 +0200950 if (lvar == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100951 goto theend;
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200952 if (generate_FUNCREF(cctx, ufunc) == FAIL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100953 goto theend;
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200954 r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
955 }
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100956
957theend:
958 vim_free(lambda_name);
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000959 vim_free(func_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200960 return r == FAIL ? NULL : (char_u *)"";
Bram Moolenaar04b12692020-05-04 23:24:44 +0200961}
962
963/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100964 * Return the length of an assignment operator, or zero if there isn't one.
965 */
966 int
967assignment_len(char_u *p, int *heredoc)
968{
969 if (*p == '=')
970 {
971 if (p[1] == '<' && p[2] == '<')
972 {
973 *heredoc = TRUE;
974 return 3;
975 }
976 return 1;
977 }
978 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=')
979 return 2;
980 if (STRNCMP(p, "..=", 3) == 0)
981 return 3;
982 return 0;
983}
984
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100985/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +0200986 * Generate the load instruction for "name".
987 */
988 static void
989generate_loadvar(
990 cctx_T *cctx,
991 assign_dest_T dest,
992 char_u *name,
993 lvar_T *lvar,
994 type_T *type)
995{
996 switch (dest)
997 {
998 case dest_option:
Bram Moolenaardcb53be2021-12-09 14:23:43 +0000999 case dest_func_option:
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001000 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
1001 break;
1002 case dest_global:
Bram Moolenaar03290b82020-12-19 16:30:44 +01001003 if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
1004 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
1005 else
1006 generate_LOAD(cctx, ISN_LOADAUTO, 0, name, type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001007 break;
1008 case dest_buffer:
1009 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
1010 break;
1011 case dest_window:
1012 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
1013 break;
1014 case dest_tab:
1015 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
1016 break;
1017 case dest_script:
1018 compile_load_scriptvar(cctx,
1019 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
1020 break;
1021 case dest_env:
1022 // Include $ in the name here
1023 generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
1024 break;
1025 case dest_reg:
1026 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string);
1027 break;
1028 case dest_vimvar:
1029 generate_LOADV(cctx, name + 2, TRUE);
1030 break;
1031 case dest_local:
Bram Moolenaarab360522021-01-10 14:02:28 +01001032 if (lvar->lv_from_outer > 0)
1033 generate_LOADOUTER(cctx, lvar->lv_idx, lvar->lv_from_outer,
1034 type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001035 else
1036 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
1037 break;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001038 case dest_expr:
1039 // list or dict value should already be on the stack.
1040 break;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001041 }
1042}
1043
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001044/*
1045 * Skip over "[expr]" or ".member".
1046 * Does not check for any errors.
1047 */
1048 static char_u *
1049skip_index(char_u *start)
1050{
1051 char_u *p = start;
1052
1053 if (*p == '[')
1054 {
1055 p = skipwhite(p + 1);
1056 (void)skip_expr(&p, NULL);
1057 p = skipwhite(p);
1058 if (*p == ']')
1059 return p + 1;
1060 return p;
1061 }
1062 // if (*p == '.')
1063 return to_name_end(p + 1, TRUE);
1064}
1065
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001066 void
1067vim9_declare_error(char_u *name)
1068{
1069 char *scope = "";
1070
1071 switch (*name)
1072 {
Bram Moolenaar7fe87552020-06-21 20:38:28 +02001073 case 'g': scope = _("global"); break;
1074 case 'b': scope = _("buffer"); break;
1075 case 'w': scope = _("window"); break;
1076 case 't': scope = _("tab"); break;
1077 case 'v': scope = "v:"; break;
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02001078 case '$': semsg(_(e_cannot_declare_an_environment_variable), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001079 return;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001080 case '&': semsg(_(e_cannot_declare_an_option), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001081 return;
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02001082 case '@': semsg(_(e_cannot_declare_a_register_str), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001083 return;
Bram Moolenaar7fe87552020-06-21 20:38:28 +02001084 default: return;
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001085 }
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02001086 semsg(_(e_cannot_declare_a_scope_variable), scope, name);
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001087}
1088
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001089/*
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001090 * For one assignment figure out the type of destination. Return it in "dest".
1091 * When not recognized "dest" is not set.
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001092 * For an option "option_scope" is set.
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001093 * For a v:var "vimvaridx" is set.
1094 * "type" is set to the destination type if known, unchanted otherwise.
1095 * Return FAIL if an error message was given.
1096 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001097 int
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001098get_var_dest(
1099 char_u *name,
1100 assign_dest_T *dest,
1101 int cmdidx,
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001102 int *option_scope,
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001103 int *vimvaridx,
1104 type_T **type,
1105 cctx_T *cctx)
1106{
1107 char_u *p;
1108
1109 if (*name == '&')
1110 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001111 int cc;
1112 long numval;
1113 getoption_T opt_type;
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001114 int opt_p_flags;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001115
1116 *dest = dest_option;
1117 if (cmdidx == CMD_final || cmdidx == CMD_const)
1118 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00001119 emsg(_(e_cannot_lock_option));
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001120 return FAIL;
1121 }
1122 p = name;
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001123 p = find_option_end(&p, option_scope);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001124 if (p == NULL)
1125 {
1126 // cannot happen?
Bram Moolenaar108010a2021-06-27 22:03:33 +02001127 emsg(_(e_unexpected_characters_in_assignment));
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001128 return FAIL;
1129 }
1130 cc = *p;
1131 *p = NUL;
1132 opt_type = get_option_value(skip_option_env_lead(name),
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001133 &numval, NULL, &opt_p_flags, *option_scope);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001134 *p = cc;
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001135 switch (opt_type)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001136 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001137 case gov_unknown:
Bram Moolenaare1242042021-12-16 20:56:57 +00001138 semsg(_(e_unknown_option_str), name);
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001139 return FAIL;
1140 case gov_string:
1141 case gov_hidden_string:
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001142 if (opt_p_flags & P_FUNC)
1143 {
1144 // might be a Funcref, check the type later
1145 *type = &t_any;
1146 *dest = dest_func_option;
1147 }
1148 else
1149 {
1150 *type = &t_string;
1151 }
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001152 break;
1153 case gov_bool:
1154 case gov_hidden_bool:
1155 *type = &t_bool;
1156 break;
1157 case gov_number:
1158 case gov_hidden_number:
1159 *type = &t_number;
1160 break;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001161 }
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001162 }
1163 else if (*name == '$')
1164 {
1165 *dest = dest_env;
1166 *type = &t_string;
1167 }
1168 else if (*name == '@')
1169 {
Bram Moolenaar13e45d12021-06-26 13:28:35 +02001170 if (name[1] != '@'
1171 && (!valid_yank_reg(name[1], FALSE) || name[1] == '.'))
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001172 {
1173 emsg_invreg(name[1]);
1174 return FAIL;
1175 }
1176 *dest = dest_reg;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02001177 *type = name[1] == '#' ? &t_number_or_string : &t_string;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001178 }
1179 else if (STRNCMP(name, "g:", 2) == 0)
1180 {
1181 *dest = dest_global;
1182 }
1183 else if (STRNCMP(name, "b:", 2) == 0)
1184 {
1185 *dest = dest_buffer;
1186 }
1187 else if (STRNCMP(name, "w:", 2) == 0)
1188 {
1189 *dest = dest_window;
1190 }
1191 else if (STRNCMP(name, "t:", 2) == 0)
1192 {
1193 *dest = dest_tab;
1194 }
1195 else if (STRNCMP(name, "v:", 2) == 0)
1196 {
1197 typval_T *vtv;
1198 int di_flags;
1199
1200 *vimvaridx = find_vim_var(name + 2, &di_flags);
1201 if (*vimvaridx < 0)
1202 {
1203 semsg(_(e_variable_not_found_str), name);
1204 return FAIL;
1205 }
1206 // We use the current value of "sandbox" here, is that OK?
1207 if (var_check_ro(di_flags, name, FALSE))
1208 return FAIL;
1209 *dest = dest_vimvar;
1210 vtv = get_vim_var_tv(*vimvaridx);
1211 *type = typval2type_vimvar(vtv, cctx->ctx_type_list);
1212 }
1213 return OK;
1214}
1215
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001216 static int
Bram Moolenaar752fc692021-01-04 21:57:11 +01001217is_decl_command(int cmdidx)
1218{
1219 return cmdidx == CMD_let || cmdidx == CMD_var
1220 || cmdidx == CMD_final || cmdidx == CMD_const;
1221}
1222
1223/*
1224 * Figure out the LHS type and other properties for an assignment or one item
1225 * of ":unlet" with an index.
1226 * Returns OK or FAIL.
1227 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001228 int
Bram Moolenaar752fc692021-01-04 21:57:11 +01001229compile_lhs(
1230 char_u *var_start,
1231 lhs_T *lhs,
1232 int cmdidx,
1233 int heredoc,
1234 int oplen,
1235 cctx_T *cctx)
1236{
1237 char_u *var_end;
1238 int is_decl = is_decl_command(cmdidx);
1239
1240 CLEAR_POINTER(lhs);
1241 lhs->lhs_dest = dest_local;
1242 lhs->lhs_vimvaridx = -1;
1243 lhs->lhs_scriptvar_idx = -1;
1244
1245 // "dest_end" is the end of the destination, including "[expr]" or
1246 // ".name".
1247 // "var_end" is the end of the variable/option/etc. name.
1248 lhs->lhs_dest_end = skip_var_one(var_start, FALSE);
1249 if (*var_start == '@')
1250 var_end = var_start + 2;
1251 else
1252 {
1253 // skip over the leading "&", "&l:", "&g:" and "$"
1254 var_end = skip_option_env_lead(var_start);
1255 var_end = to_name_end(var_end, TRUE);
1256 }
1257
1258 // "a: type" is declaring variable "a" with a type, not dict "a:".
1259 if (is_decl && lhs->lhs_dest_end == var_start + 2
1260 && lhs->lhs_dest_end[-1] == ':')
1261 --lhs->lhs_dest_end;
1262 if (is_decl && var_end == var_start + 2 && var_end[-1] == ':')
1263 --var_end;
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001264 lhs->lhs_end = lhs->lhs_dest_end;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001265
1266 // compute the length of the destination without "[expr]" or ".name"
1267 lhs->lhs_varlen = var_end - var_start;
Bram Moolenaar753bcf82021-04-21 14:24:24 +02001268 lhs->lhs_varlen_total = lhs->lhs_varlen;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001269 lhs->lhs_name = vim_strnsave(var_start, lhs->lhs_varlen);
1270 if (lhs->lhs_name == NULL)
1271 return FAIL;
Bram Moolenaar08251752021-01-11 21:20:18 +01001272
1273 if (lhs->lhs_dest_end > var_start + lhs->lhs_varlen)
1274 // Something follows after the variable: "var[idx]" or "var.key".
1275 lhs->lhs_has_index = TRUE;
1276
Bram Moolenaar752fc692021-01-04 21:57:11 +01001277 if (heredoc)
1278 lhs->lhs_type = &t_list_string;
1279 else
1280 lhs->lhs_type = &t_any;
1281
1282 if (cctx->ctx_skip != SKIP_YES)
1283 {
1284 int declare_error = FALSE;
1285
1286 if (get_var_dest(lhs->lhs_name, &lhs->lhs_dest, cmdidx,
1287 &lhs->lhs_opt_flags, &lhs->lhs_vimvaridx,
1288 &lhs->lhs_type, cctx) == FAIL)
1289 return FAIL;
Bram Moolenaard877a572021-04-01 19:42:48 +02001290 if (lhs->lhs_dest != dest_local
1291 && cmdidx != CMD_const && cmdidx != CMD_final)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001292 {
1293 // Specific kind of variable recognized.
1294 declare_error = is_decl;
1295 }
1296 else
1297 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01001298 // No specific kind of variable recognized, just a name.
Bram Moolenaard0edaf92021-05-28 21:06:08 +02001299 if (check_reserved_name(lhs->lhs_name) == FAIL)
1300 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001301
1302 if (lookup_local(var_start, lhs->lhs_varlen,
1303 &lhs->lhs_local_lvar, cctx) == OK)
1304 lhs->lhs_lvar = &lhs->lhs_local_lvar;
1305 else
1306 {
1307 CLEAR_FIELD(lhs->lhs_arg_lvar);
1308 if (arg_exists(var_start, lhs->lhs_varlen,
1309 &lhs->lhs_arg_lvar.lv_idx, &lhs->lhs_arg_lvar.lv_type,
1310 &lhs->lhs_arg_lvar.lv_from_outer, cctx) == OK)
1311 {
1312 if (is_decl)
1313 {
1314 semsg(_(e_str_is_used_as_argument), lhs->lhs_name);
1315 return FAIL;
1316 }
1317 lhs->lhs_lvar = &lhs->lhs_arg_lvar;
1318 }
1319 }
1320 if (lhs->lhs_lvar != NULL)
1321 {
1322 if (is_decl)
1323 {
1324 semsg(_(e_variable_already_declared), lhs->lhs_name);
1325 return FAIL;
1326 }
1327 }
1328 else
1329 {
1330 int script_namespace = lhs->lhs_varlen > 1
1331 && STRNCMP(var_start, "s:", 2) == 0;
1332 int script_var = (script_namespace
1333 ? script_var_exists(var_start + 2, lhs->lhs_varlen - 2,
Bram Moolenaardce24412022-02-08 20:35:30 +00001334 cctx, NULL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001335 : script_var_exists(var_start, lhs->lhs_varlen,
Bram Moolenaardce24412022-02-08 20:35:30 +00001336 cctx, NULL)) == OK;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001337 imported_T *import =
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00001338 find_imported(var_start, lhs->lhs_varlen, FALSE);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001339
1340 if (script_namespace || script_var || import != NULL)
1341 {
1342 char_u *rawname = lhs->lhs_name
1343 + (lhs->lhs_name[1] == ':' ? 2 : 0);
1344
Bram Moolenaarafa048f2022-02-22 20:43:36 +00001345 if (script_namespace && current_script_is_vim9())
1346 {
1347 semsg(_(e_cannot_use_s_colon_in_vim9_script_str),
1348 var_start);
1349 return FAIL;
1350 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001351 if (is_decl)
1352 {
1353 if (script_namespace)
Bram Moolenaara749a422022-02-12 19:52:25 +00001354 semsg(_(e_cannot_declare_script_variable_in_function_str),
Bram Moolenaar752fc692021-01-04 21:57:11 +01001355 lhs->lhs_name);
1356 else
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001357 semsg(_(e_variable_already_declared_in_script_str),
Bram Moolenaar752fc692021-01-04 21:57:11 +01001358 lhs->lhs_name);
1359 return FAIL;
1360 }
1361 else if (cctx->ctx_ufunc->uf_script_ctx_version
1362 == SCRIPT_VERSION_VIM9
1363 && script_namespace
1364 && !script_var && import == NULL)
1365 {
1366 semsg(_(e_unknown_variable_str), lhs->lhs_name);
1367 return FAIL;
1368 }
1369
1370 lhs->lhs_dest = dest_script;
1371
1372 // existing script-local variables should have a type
1373 lhs->lhs_scriptvar_sid = current_sctx.sc_sid;
1374 if (import != NULL)
Bram Moolenaard5f400c2022-01-06 21:10:28 +00001375 {
1376 char_u *dot = vim_strchr(var_start, '.');
1377 char_u *p;
1378
1379 // for an import the name is what comes after the dot
1380 if (dot == NULL)
1381 {
1382 semsg(_(e_no_dot_after_imported_name_str),
1383 var_start);
1384 return FAIL;
1385 }
1386 p = skipwhite(dot + 1);
1387 var_end = to_name_end(p, TRUE);
1388 if (var_end == p)
1389 {
1390 semsg(_(e_missing_name_after_imported_name_str),
1391 var_start);
1392 return FAIL;
1393 }
1394 vim_free(lhs->lhs_name);
1395 lhs->lhs_varlen = var_end - p;
1396 lhs->lhs_name = vim_strnsave(p, lhs->lhs_varlen);
1397 if (lhs->lhs_name == NULL)
1398 return FAIL;
1399 rawname = lhs->lhs_name;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001400 lhs->lhs_scriptvar_sid = import->imp_sid;
Bram Moolenaard5f400c2022-01-06 21:10:28 +00001401 // TODO: where do we check this name is exported?
1402
1403 // Check if something follows: "exp.var[idx]" or
1404 // "exp.var.key".
1405 lhs->lhs_has_index = lhs->lhs_dest_end
1406 > skipwhite(var_end);
1407 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001408 if (SCRIPT_ID_VALID(lhs->lhs_scriptvar_sid))
1409 {
Bram Moolenaar08251752021-01-11 21:20:18 +01001410 // Check writable only when no index follows.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001411 lhs->lhs_scriptvar_idx = get_script_item_idx(
Bram Moolenaar08251752021-01-11 21:20:18 +01001412 lhs->lhs_scriptvar_sid, rawname,
1413 lhs->lhs_has_index ? ASSIGN_FINAL : ASSIGN_CONST,
Bram Moolenaarb6a138e2022-02-08 21:17:22 +00001414 cctx, NULL);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001415 if (lhs->lhs_scriptvar_idx >= 0)
1416 {
1417 scriptitem_T *si = SCRIPT_ITEM(
1418 lhs->lhs_scriptvar_sid);
1419 svar_T *sv =
1420 ((svar_T *)si->sn_var_vals.ga_data)
1421 + lhs->lhs_scriptvar_idx;
1422 lhs->lhs_type = sv->sv_type;
1423 }
1424 }
1425 }
Bram Moolenaardce24412022-02-08 20:35:30 +00001426 else if (check_defined(var_start, lhs->lhs_varlen, cctx,
1427 NULL, FALSE) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001428 return FAIL;
1429 }
1430 }
1431
1432 if (declare_error)
1433 {
1434 vim9_declare_error(lhs->lhs_name);
1435 return FAIL;
1436 }
1437 }
1438
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001439 // handle "a:name" as a name, not index "name" in "a"
Bram Moolenaar752fc692021-01-04 21:57:11 +01001440 if (lhs->lhs_varlen > 1 || var_start[lhs->lhs_varlen] != ':')
1441 var_end = lhs->lhs_dest_end;
1442
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001443 if (lhs->lhs_dest != dest_option && lhs->lhs_dest != dest_func_option)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001444 {
1445 if (is_decl && *var_end == ':')
1446 {
1447 char_u *p;
1448
1449 // parse optional type: "let var: type = expr"
1450 if (!VIM_ISWHITE(var_end[1]))
1451 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01001452 semsg(_(e_white_space_required_after_str_str), ":", var_end);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001453 return FAIL;
1454 }
1455 p = skipwhite(var_end + 1);
1456 lhs->lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE);
1457 if (lhs->lhs_type == NULL)
1458 return FAIL;
1459 lhs->lhs_has_type = TRUE;
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001460 lhs->lhs_end = p;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001461 }
1462 else if (lhs->lhs_lvar != NULL)
1463 lhs->lhs_type = lhs->lhs_lvar->lv_type;
1464 }
1465
Bram Moolenaare42939a2021-04-05 17:11:17 +02001466 if (oplen == 3 && !heredoc
1467 && lhs->lhs_dest != dest_global
1468 && !lhs->lhs_has_index
1469 && lhs->lhs_type->tt_type != VAR_STRING
1470 && lhs->lhs_type->tt_type != VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001471 {
1472 emsg(_(e_can_only_concatenate_to_string));
1473 return FAIL;
1474 }
1475
1476 if (lhs->lhs_lvar == NULL && lhs->lhs_dest == dest_local
1477 && cctx->ctx_skip != SKIP_YES)
1478 {
1479 if (oplen > 1 && !heredoc)
1480 {
1481 // +=, /=, etc. require an existing variable
1482 semsg(_(e_cannot_use_operator_on_new_variable), lhs->lhs_name);
1483 return FAIL;
1484 }
1485 if (!is_decl)
1486 {
1487 semsg(_(e_unknown_variable_str), lhs->lhs_name);
1488 return FAIL;
1489 }
1490
Bram Moolenaar3f327882021-03-17 20:56:38 +01001491 // Check the name is valid for a funcref.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001492 if ((lhs->lhs_type->tt_type == VAR_FUNC
1493 || lhs->lhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01001494 && var_wrong_func_name(lhs->lhs_name, TRUE))
Bram Moolenaar752fc692021-01-04 21:57:11 +01001495 return FAIL;
Bram Moolenaar3f327882021-03-17 20:56:38 +01001496
1497 // New local variable.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001498 lhs->lhs_lvar = reserve_local(cctx, var_start, lhs->lhs_varlen,
1499 cmdidx == CMD_final || cmdidx == CMD_const, lhs->lhs_type);
1500 if (lhs->lhs_lvar == NULL)
1501 return FAIL;
1502 lhs->lhs_new_local = TRUE;
1503 }
1504
1505 lhs->lhs_member_type = lhs->lhs_type;
Bram Moolenaar08251752021-01-11 21:20:18 +01001506 if (lhs->lhs_has_index)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001507 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001508 char_u *after = var_start + lhs->lhs_varlen;
1509 char_u *p;
1510
Bram Moolenaar752fc692021-01-04 21:57:11 +01001511 // Something follows after the variable: "var[idx]" or "var.key".
Bram Moolenaar752fc692021-01-04 21:57:11 +01001512 if (is_decl)
1513 {
1514 emsg(_(e_cannot_use_index_when_declaring_variable));
1515 return FAIL;
1516 }
1517
Bram Moolenaarc750d912021-11-29 22:02:12 +00001518 // Now: var_start[lhs->lhs_varlen] is '[' or '.'
1519 // Only the last index is used below, if there are others
1520 // before it generate code for the expression. Thus for
1521 // "ll[1][2]" the expression is "ll[1]" and "[2]" is the index.
1522 for (;;)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001523 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001524 p = skip_index(after);
1525 if (*p != '[' && *p != '.')
Bram Moolenaar752fc692021-01-04 21:57:11 +01001526 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001527 lhs->lhs_varlen_total = p - var_start;
1528 break;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001529 }
Bram Moolenaarc750d912021-11-29 22:02:12 +00001530 after = p;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001531 }
Bram Moolenaarc750d912021-11-29 22:02:12 +00001532 if (after > var_start + lhs->lhs_varlen)
1533 {
1534 lhs->lhs_varlen = after - var_start;
1535 lhs->lhs_dest = dest_expr;
1536 // We don't know the type before evaluating the expression,
1537 // use "any" until then.
1538 lhs->lhs_type = &t_any;
1539 }
1540
1541 if (lhs->lhs_type->tt_member == NULL)
1542 lhs->lhs_member_type = &t_any;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001543 else
Bram Moolenaarc750d912021-11-29 22:02:12 +00001544 lhs->lhs_member_type = lhs->lhs_type->tt_member;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001545 }
1546 return OK;
1547}
1548
1549/*
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001550 * Figure out the LHS and check a few errors.
1551 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001552 int
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001553compile_assign_lhs(
1554 char_u *var_start,
1555 lhs_T *lhs,
1556 int cmdidx,
1557 int is_decl,
1558 int heredoc,
1559 int oplen,
1560 cctx_T *cctx)
1561{
1562 if (compile_lhs(var_start, lhs, cmdidx, heredoc, oplen, cctx) == FAIL)
1563 return FAIL;
1564
1565 if (!lhs->lhs_has_index && lhs->lhs_lvar == &lhs->lhs_arg_lvar)
1566 {
1567 semsg(_(e_cannot_assign_to_argument), lhs->lhs_name);
1568 return FAIL;
1569 }
1570 if (!is_decl && lhs->lhs_lvar != NULL
1571 && lhs->lhs_lvar->lv_const && !lhs->lhs_has_index)
1572 {
1573 semsg(_(e_cannot_assign_to_constant), lhs->lhs_name);
1574 return FAIL;
1575 }
1576 return OK;
1577}
1578
1579/*
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02001580 * Return TRUE if "lhs" has a range index: "[expr : expr]".
1581 */
1582 static int
1583has_list_index(char_u *idx_start, cctx_T *cctx)
1584{
1585 char_u *p = idx_start;
1586 int save_skip;
1587
1588 if (*p != '[')
1589 return FALSE;
1590
1591 p = skipwhite(p + 1);
1592 if (*p == ':')
1593 return TRUE;
1594
1595 save_skip = cctx->ctx_skip;
1596 cctx->ctx_skip = SKIP_YES;
1597 (void)compile_expr0(&p, cctx);
1598 cctx->ctx_skip = save_skip;
1599 return *skipwhite(p) == ':';
1600}
1601
1602/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02001603 * For an assignment with an index, compile the "idx" in "var[idx]" or "key" in
1604 * "var.key".
Bram Moolenaar752fc692021-01-04 21:57:11 +01001605 */
1606 static int
Bram Moolenaare42939a2021-04-05 17:11:17 +02001607compile_assign_index(
Bram Moolenaar752fc692021-01-04 21:57:11 +01001608 char_u *var_start,
1609 lhs_T *lhs,
Bram Moolenaare42939a2021-04-05 17:11:17 +02001610 int *range,
Bram Moolenaar752fc692021-01-04 21:57:11 +01001611 cctx_T *cctx)
1612{
Bram Moolenaar752fc692021-01-04 21:57:11 +01001613 size_t varlen = lhs->lhs_varlen;
Bram Moolenaare42939a2021-04-05 17:11:17 +02001614 char_u *p;
1615 int r = OK;
Bram Moolenaar68452172021-04-12 21:21:02 +02001616 int need_white_before = TRUE;
1617 int empty_second;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001618
Bram Moolenaar752fc692021-01-04 21:57:11 +01001619 p = var_start + varlen;
1620 if (*p == '[')
1621 {
1622 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02001623 if (*p == ':')
1624 {
1625 // empty first index, push zero
1626 r = generate_PUSHNR(cctx, 0);
1627 need_white_before = FALSE;
1628 }
1629 else
1630 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001631
1632 if (r == OK && *skipwhite(p) == ':')
1633 {
1634 // unlet var[idx : idx]
Bram Moolenaar68452172021-04-12 21:21:02 +02001635 // blob[idx : idx] = value
Bram Moolenaare42939a2021-04-05 17:11:17 +02001636 *range = TRUE;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001637 p = skipwhite(p);
Bram Moolenaar68452172021-04-12 21:21:02 +02001638 empty_second = *skipwhite(p + 1) == ']';
1639 if ((need_white_before && !IS_WHITE_OR_NUL(p[-1]))
1640 || (!empty_second && !IS_WHITE_OR_NUL(p[1])))
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001641 {
1642 semsg(_(e_white_space_required_before_and_after_str_at_str),
1643 ":", p);
1644 return FAIL;
1645 }
1646 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02001647 if (*p == ']')
1648 // empty second index, push "none"
1649 r = generate_PUSHSPEC(cctx, VVAL_NONE);
1650 else
1651 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001652 }
1653
Bram Moolenaar752fc692021-01-04 21:57:11 +01001654 if (r == OK && *skipwhite(p) != ']')
1655 {
1656 // this should not happen
Bram Moolenaare1242042021-12-16 20:56:57 +00001657 emsg(_(e_missing_closing_square_brace));
Bram Moolenaar752fc692021-01-04 21:57:11 +01001658 r = FAIL;
1659 }
1660 }
1661 else // if (*p == '.')
1662 {
1663 char_u *key_end = to_name_end(p + 1, TRUE);
1664 char_u *key = vim_strnsave(p + 1, key_end - p - 1);
1665
Zdenek Dohnal9fe17d42021-08-04 22:30:52 +02001666 r = generate_PUSHS(cctx, &key);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001667 }
Bram Moolenaare42939a2021-04-05 17:11:17 +02001668 return r;
1669}
1670
1671/*
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001672 * For a LHS with an index, load the variable to be indexed.
1673 */
1674 static int
1675compile_load_lhs(
1676 lhs_T *lhs,
1677 char_u *var_start,
1678 type_T *rhs_type,
1679 cctx_T *cctx)
1680{
1681 if (lhs->lhs_dest == dest_expr)
1682 {
1683 size_t varlen = lhs->lhs_varlen;
1684 int c = var_start[varlen];
Bram Moolenaare97976b2021-08-01 13:17:17 +02001685 int lines_len = cctx->ctx_ufunc->uf_lines.ga_len;
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001686 char_u *p = var_start;
Bram Moolenaare97976b2021-08-01 13:17:17 +02001687 int res;
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001688
Bram Moolenaare97976b2021-08-01 13:17:17 +02001689 // Evaluate "ll[expr]" of "ll[expr][idx]". End the line with a NUL and
1690 // limit the lines array length to avoid skipping to a following line.
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001691 var_start[varlen] = NUL;
Bram Moolenaare97976b2021-08-01 13:17:17 +02001692 cctx->ctx_ufunc->uf_lines.ga_len = cctx->ctx_lnum + 1;
1693 res = compile_expr0(&p, cctx);
1694 var_start[varlen] = c;
1695 cctx->ctx_ufunc->uf_lines.ga_len = lines_len;
1696 if (res == FAIL || p != var_start + varlen)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001697 {
1698 // this should not happen
Bram Moolenaare97976b2021-08-01 13:17:17 +02001699 if (res != FAIL)
Bram Moolenaare1242042021-12-16 20:56:57 +00001700 emsg(_(e_missing_closing_square_brace));
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001701 return FAIL;
1702 }
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001703
Bram Moolenaar078a4612022-01-04 15:17:03 +00001704 lhs->lhs_type = cctx->ctx_type_stack.ga_len == 0 ? &t_void
1705 : get_type_on_stack(cctx, 0);
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001706 // now we can properly check the type
1707 if (rhs_type != NULL && lhs->lhs_type->tt_member != NULL
1708 && rhs_type != &t_void
1709 && need_type(rhs_type, lhs->lhs_type->tt_member, -2, 0, cctx,
1710 FALSE, FALSE) == FAIL)
1711 return FAIL;
1712 }
1713 else
1714 generate_loadvar(cctx, lhs->lhs_dest, lhs->lhs_name,
1715 lhs->lhs_lvar, lhs->lhs_type);
1716 return OK;
1717}
1718
1719/*
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001720 * Produce code for loading "lhs" and also take care of an index.
1721 * Return OK/FAIL.
1722 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001723 int
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001724compile_load_lhs_with_index(lhs_T *lhs, char_u *var_start, cctx_T *cctx)
1725{
1726 compile_load_lhs(lhs, var_start, NULL, cctx);
1727
1728 if (lhs->lhs_has_index)
1729 {
1730 int range = FALSE;
1731
1732 // Get member from list or dict. First compile the
1733 // index value.
1734 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
1735 return FAIL;
1736 if (range)
1737 {
1738 semsg(_(e_cannot_use_range_with_assignment_operator_str),
1739 var_start);
1740 return FAIL;
1741 }
1742
1743 // Get the member.
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02001744 if (compile_member(FALSE, NULL, cctx) == FAIL)
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001745 return FAIL;
1746 }
1747 return OK;
1748}
1749
1750/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02001751 * Assignment to a list or dict member, or ":unlet" for the item, using the
1752 * information in "lhs".
1753 * Returns OK or FAIL.
1754 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001755 int
Bram Moolenaare42939a2021-04-05 17:11:17 +02001756compile_assign_unlet(
1757 char_u *var_start,
1758 lhs_T *lhs,
1759 int is_assign,
1760 type_T *rhs_type,
1761 cctx_T *cctx)
1762{
Bram Moolenaare42939a2021-04-05 17:11:17 +02001763 vartype_T dest_type;
Bram Moolenaare42939a2021-04-05 17:11:17 +02001764 int range = FALSE;
1765
Bram Moolenaar68452172021-04-12 21:21:02 +02001766 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001767 return FAIL;
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02001768 if (is_assign && range
1769 && lhs->lhs_type->tt_type != VAR_LIST
1770 && lhs->lhs_type != &t_blob
1771 && lhs->lhs_type != &t_any)
Bram Moolenaar68452172021-04-12 21:21:02 +02001772 {
1773 semsg(_(e_cannot_use_range_with_assignment_str), var_start);
1774 return FAIL;
1775 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001776
1777 if (lhs->lhs_type == &t_any)
1778 {
1779 // Index on variable of unknown type: check at runtime.
1780 dest_type = VAR_ANY;
1781 }
1782 else
1783 {
1784 dest_type = lhs->lhs_type->tt_type;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001785 if (dest_type == VAR_DICT && range)
1786 {
1787 emsg(e_cannot_use_range_with_dictionary);
1788 return FAIL;
1789 }
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02001790 if (dest_type == VAR_DICT
1791 && may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001792 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02001793 if (dest_type == VAR_LIST || dest_type == VAR_BLOB)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001794 {
Bram Moolenaar51e93322021-04-17 20:44:56 +02001795 type_T *type;
1796
1797 if (range)
1798 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001799 type = get_type_on_stack(cctx, 1);
Bram Moolenaar51e93322021-04-17 20:44:56 +02001800 if (need_type(type, &t_number,
1801 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001802 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02001803 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001804 type = get_type_on_stack(cctx, 0);
Bram Moolenaar53ba6ca2022-03-10 19:23:28 +00001805 if ((dest_type != VAR_BLOB && type->tt_type != VAR_SPECIAL)
Bram Moolenaar51e93322021-04-17 20:44:56 +02001806 && need_type(type, &t_number,
1807 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001808 return FAIL;
1809 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001810 }
1811
1812 // Load the dict or list. On the stack we then have:
1813 // - value (for assignment, not for :unlet)
1814 // - index
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001815 // - for [a : b] second index
Bram Moolenaar752fc692021-01-04 21:57:11 +01001816 // - variable
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001817 if (compile_load_lhs(lhs, var_start, rhs_type, cctx) == FAIL)
1818 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001819
Bram Moolenaar68452172021-04-12 21:21:02 +02001820 if (dest_type == VAR_LIST || dest_type == VAR_DICT
1821 || dest_type == VAR_BLOB || dest_type == VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001822 {
1823 if (is_assign)
1824 {
Bram Moolenaar68452172021-04-12 21:21:02 +02001825 if (range)
1826 {
1827 if (generate_instr_drop(cctx, ISN_STORERANGE, 4) == NULL)
1828 return FAIL;
1829 }
1830 else
1831 {
1832 isn_T *isn = generate_instr_drop(cctx, ISN_STOREINDEX, 3);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001833
Bram Moolenaar68452172021-04-12 21:21:02 +02001834 if (isn == NULL)
1835 return FAIL;
1836 isn->isn_arg.vartype = dest_type;
1837 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001838 }
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001839 else if (range)
1840 {
1841 if (generate_instr_drop(cctx, ISN_UNLETRANGE, 3) == NULL)
1842 return FAIL;
1843 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001844 else
1845 {
1846 if (generate_instr_drop(cctx, ISN_UNLETINDEX, 2) == NULL)
1847 return FAIL;
1848 }
1849 }
1850 else
1851 {
1852 emsg(_(e_indexable_type_required));
1853 return FAIL;
1854 }
1855
1856 return OK;
1857}
1858
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001859/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001860 * Compile declaration and assignment:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001861 * "let name"
1862 * "var name = expr"
1863 * "final name = expr"
1864 * "const name = expr"
1865 * "name = expr"
1866 * "arg" points to "name".
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001867 * "++arg" and "--arg"
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001868 * Return NULL for an error.
1869 * Return "arg" if it does not look like a variable list.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001870 */
1871 static char_u *
1872compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
1873{
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001874 char_u *var_start;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001875 char_u *p;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001876 char_u *end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001877 char_u *ret = NULL;
1878 int var_count = 0;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001879 int var_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001880 int semicolon = 0;
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02001881 int did_generate_slice = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001882 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001883 char_u *op;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001884 int oplen = 0;
1885 int heredoc = FALSE;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001886 int incdec = FALSE;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001887 type_T *rhs_type = &t_any;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001888 char_u *sp;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001889 int is_decl = is_decl_command(cmdidx);
1890 lhs_T lhs;
Bram Moolenaar77709b12021-04-03 21:01:01 +02001891 long start_lnum = SOURCING_LNUM;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001892
Bram Moolenaare1d12112022-03-05 11:37:48 +00001893 // Skip over the "varname" or "[varname, varname]" to get to any "=".
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001894 p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE);
1895 if (p == NULL)
1896 return *arg == '[' ? arg : NULL;
1897
Bram Moolenaar752fc692021-01-04 21:57:11 +01001898 lhs.lhs_name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001899
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001900 sp = p;
1901 p = skipwhite(p);
1902 op = p;
1903 oplen = assignment_len(p, &heredoc);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001904
1905 if (var_count > 0 && oplen == 0)
1906 // can be something like "[1, 2]->func()"
1907 return arg;
1908
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001909 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !IS_WHITE_OR_NUL(op[oplen])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001910 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001911 error_white_both(op, oplen);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001912 return NULL;
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001913 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001914 if (eap->cmdidx == CMD_increment || eap->cmdidx == CMD_decrement)
1915 {
Bram Moolenaar22480d12021-06-25 21:31:09 +02001916 if (VIM_ISWHITE(eap->cmd[2]))
1917 {
1918 semsg(_(e_no_white_space_allowed_after_str_str),
1919 eap->cmdidx == CMD_increment ? "++" : "--", eap->cmd);
1920 return NULL;
1921 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001922 op = (char_u *)(eap->cmdidx == CMD_increment ? "+=" : "-=");
1923 oplen = 2;
1924 incdec = TRUE;
1925 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001926
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001927 if (heredoc)
1928 {
1929 list_T *l;
1930 listitem_T *li;
1931
1932 // [let] varname =<< [trim] {end}
Bram Moolenaar04b12692020-05-04 23:24:44 +02001933 eap->getline = exarg_getline;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001934 eap->cookie = cctx;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02001935 l = heredoc_get(eap, op + 3, FALSE);
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001936 if (l == NULL)
1937 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001938
Bram Moolenaar078269b2020-09-21 20:35:55 +02001939 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001940 {
Bram Moolenaar078269b2020-09-21 20:35:55 +02001941 // Push each line and the create the list.
1942 FOR_ALL_LIST_ITEMS(l, li)
1943 {
Zdenek Dohnal9fe17d42021-08-04 22:30:52 +02001944 generate_PUSHS(cctx, &li->li_tv.vval.v_string);
Bram Moolenaar078269b2020-09-21 20:35:55 +02001945 li->li_tv.vval.v_string = NULL;
1946 }
1947 generate_NEWLIST(cctx, l->lv_len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001948 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001949 list_free(l);
1950 p += STRLEN(p);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001951 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001952 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001953 else if (var_count > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001954 {
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001955 char_u *wp;
1956
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001957 // for "[var, var] = expr" evaluate the expression here, loop over the
1958 // list of variables below.
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001959 // A line break may follow the "=".
Bram Moolenaard25ec2c2020-03-30 21:05:45 +02001960
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001961 wp = op + oplen;
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001962 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001963 return FAIL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001964 if (compile_expr0(&p, cctx) == FAIL)
1965 return NULL;
1966 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001967
Bram Moolenaar9b68c822020-06-18 19:31:08 +02001968 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001969 {
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001970 type_T *stacktype;
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001971 int needed_list_len;
1972 int did_check = FALSE;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001973
Bram Moolenaar078a4612022-01-04 15:17:03 +00001974 stacktype = cctx->ctx_type_stack.ga_len == 0 ? &t_void
1975 : get_type_on_stack(cctx, 0);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001976 if (stacktype->tt_type == VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001977 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001978 emsg(_(e_cannot_use_void_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001979 goto theend;
1980 }
Bram Moolenaar351ead02021-01-16 16:07:01 +01001981 if (need_type(stacktype, &t_list_any, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001982 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001983 goto theend;
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001984 // If a constant list was used we can check the length right here.
1985 needed_list_len = semicolon ? var_count - 1 : var_count;
1986 if (instr->ga_len > 0)
1987 {
1988 isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
1989
1990 if (isn->isn_type == ISN_NEWLIST)
1991 {
1992 did_check = TRUE;
1993 if (semicolon ? isn->isn_arg.number < needed_list_len
1994 : isn->isn_arg.number != needed_list_len)
1995 {
1996 semsg(_(e_expected_nr_items_but_got_nr),
Bram Moolenaarf60a6342022-01-15 14:16:37 +00001997 needed_list_len, (int)isn->isn_arg.number);
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001998 goto theend;
1999 }
2000 }
2001 }
2002 if (!did_check)
2003 generate_CHECKLEN(cctx, needed_list_len, semicolon);
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002004 if (stacktype->tt_member != NULL)
2005 rhs_type = stacktype->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002006 }
2007 }
2008
2009 /*
2010 * Loop over variables in "[var, var] = expr".
2011 * For "var = expr" and "let var: type" this is done only once.
2012 */
2013 if (var_count > 0)
2014 var_start = skipwhite(arg + 1); // skip over the "["
2015 else
2016 var_start = arg;
2017 for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++)
2018 {
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002019 int instr_count = -1;
2020 int save_lnum;
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002021 int skip_store = FALSE;
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002022 type_T *inferred_type = NULL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002023
Bram Moolenaarf93bbd02021-04-10 22:35:43 +02002024 if (var_start[0] == '_' && !eval_isnamec(var_start[1]))
2025 {
2026 // Ignore underscore in "[a, _, b] = list".
2027 if (var_count > 0)
2028 {
2029 var_start = skipwhite(var_start + 2);
2030 continue;
2031 }
2032 emsg(_(e_cannot_use_underscore_here));
2033 goto theend;
2034 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01002035 vim_free(lhs.lhs_name);
2036
2037 /*
2038 * Figure out the LHS type and other properties.
2039 */
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02002040 if (compile_assign_lhs(var_start, &lhs, cmdidx,
2041 is_decl, heredoc, oplen, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002042 goto theend;
Bram Moolenaar81530e32021-07-28 21:25:49 +02002043 if (heredoc)
2044 {
2045 SOURCING_LNUM = start_lnum;
2046 if (lhs.lhs_has_type
2047 && need_type(&t_list_string, lhs.lhs_type,
2048 -1, 0, cctx, FALSE, FALSE) == FAIL)
2049 goto theend;
2050 }
2051 else
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002052 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002053 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002054 {
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002055 if (oplen > 0 && var_count == 0)
2056 {
2057 // skip over the "=" and the expression
2058 p = skipwhite(op + oplen);
Bram Moolenaar169502f2021-04-21 12:19:35 +02002059 (void)compile_expr0(&p, cctx);
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002060 }
2061 }
2062 else if (oplen > 0)
2063 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002064 int is_const = FALSE;
Bram Moolenaar7f764942020-12-02 15:11:18 +01002065 char_u *wp;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002066
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02002067 // for "+=", "*=", "..=" etc. first load the current value
2068 if (*op != '='
2069 && compile_load_lhs_with_index(&lhs, var_start,
2070 cctx) == FAIL)
2071 goto theend;
2072
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002073 // For "var = expr" evaluate the expression.
2074 if (var_count == 0)
2075 {
2076 int r;
2077
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002078 // Compile the expression.
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002079 instr_count = instr->ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002080 if (incdec)
Bram Moolenaar21e51222020-12-04 12:43:29 +01002081 {
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002082 r = generate_PUSHNR(cctx, 1);
2083 }
2084 else
2085 {
2086 // Temporarily hide the new local variable here, it is
2087 // not available to this expression.
2088 if (lhs.lhs_new_local)
2089 --cctx->ctx_locals.ga_len;
2090 wp = op + oplen;
2091 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
2092 {
2093 if (lhs.lhs_new_local)
2094 ++cctx->ctx_locals.ga_len;
2095 goto theend;
2096 }
2097 r = compile_expr0_ext(&p, cctx, &is_const);
Bram Moolenaar752fc692021-01-04 21:57:11 +01002098 if (lhs.lhs_new_local)
Bram Moolenaar21e51222020-12-04 12:43:29 +01002099 ++cctx->ctx_locals.ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002100 if (r == FAIL)
2101 goto theend;
Bram Moolenaar21e51222020-12-04 12:43:29 +01002102 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002103 }
Bram Moolenaar9af78762020-06-16 11:34:42 +02002104 else if (semicolon && var_idx == var_count - 1)
2105 {
2106 // For "[var; var] = expr" get the rest of the list
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02002107 did_generate_slice = TRUE;
Bram Moolenaar9af78762020-06-16 11:34:42 +02002108 if (generate_SLICE(cctx, var_count - 1) == FAIL)
2109 goto theend;
2110 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002111 else
2112 {
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002113 // For "[var, var] = expr" get the "var_idx" item from the
2114 // list.
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02002115 if (generate_GETITEM(cctx, var_idx, *op != '=') == FAIL)
Bram Moolenaar7f764942020-12-02 15:11:18 +01002116 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002117 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002118
Bram Moolenaar078a4612022-01-04 15:17:03 +00002119 rhs_type = cctx->ctx_type_stack.ga_len == 0 ? &t_void
2120 : get_type_on_stack(cctx, 0);
Bram Moolenaar752fc692021-01-04 21:57:11 +01002121 if (lhs.lhs_lvar != NULL && (is_decl || !lhs.lhs_has_type))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002122 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002123 if ((rhs_type->tt_type == VAR_FUNC
2124 || rhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01002125 && !lhs.lhs_has_index
Bram Moolenaar752fc692021-01-04 21:57:11 +01002126 && var_wrong_func_name(lhs.lhs_name, TRUE))
Bram Moolenaar0f769812020-09-12 18:32:34 +02002127 goto theend;
2128
Bram Moolenaar752fc692021-01-04 21:57:11 +01002129 if (lhs.lhs_new_local && !lhs.lhs_has_type)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002130 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002131 if (rhs_type->tt_type == VAR_VOID)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002132 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002133 emsg(_(e_cannot_use_void_value));
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002134 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002135 }
2136 else
2137 {
Bram Moolenaar04bdd572020-09-23 13:25:32 +02002138 // An empty list or dict has a &t_unknown member,
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002139 // for a variable that implies &t_any.
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002140 if (rhs_type == &t_list_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002141 lhs.lhs_lvar->lv_type = &t_list_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002142 else if (rhs_type == &t_dict_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002143 lhs.lhs_lvar->lv_type = &t_dict_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002144 else if (rhs_type == &t_unknown)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002145 lhs.lhs_lvar->lv_type = &t_any;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002146 else
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002147 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002148 lhs.lhs_lvar->lv_type = rhs_type;
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002149 inferred_type = rhs_type;
2150 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002151 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002152 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002153 else if (*op == '=')
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002154 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002155 type_T *use_type = lhs.lhs_lvar->lv_type;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002156 where_T where = WHERE_INIT;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002157
Bram Moolenaar77709b12021-04-03 21:01:01 +02002158 // Without operator check type here, otherwise below.
2159 // Use the line number of the assignment.
2160 SOURCING_LNUM = start_lnum;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002161 where.wt_index = var_count > 0 ? var_idx + 1 : 0;
2162 where.wt_variable = var_count > 0;
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02002163 // If assigning to a list or dict member, use the
2164 // member type. Not for "list[:] =".
2165 if (lhs.lhs_has_index
2166 && !has_list_index(var_start + lhs.lhs_varlen,
2167 cctx))
Bram Moolenaar752fc692021-01-04 21:57:11 +01002168 use_type = lhs.lhs_member_type;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002169 if (need_type_where(rhs_type, use_type, -1, where,
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002170 cctx, FALSE, is_const) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002171 goto theend;
2172 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002173 }
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002174 else
2175 {
2176 type_T *lhs_type = lhs.lhs_member_type;
2177
2178 // Special case: assigning to @# can use a number or a
2179 // string.
Bram Moolenaaraf647e72021-08-05 19:01:17 +02002180 // Also: can assign a number to a float.
2181 if ((lhs_type == &t_number_or_string
2182 || lhs_type == &t_float)
2183 && rhs_type->tt_type == VAR_NUMBER)
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002184 lhs_type = &t_number;
2185 if (*p != '=' && need_type(rhs_type, lhs_type,
Bram Moolenaar351ead02021-01-16 16:07:01 +01002186 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002187 goto theend;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002188 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002189 }
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002190 else if (cmdidx == CMD_final)
2191 {
2192 emsg(_(e_final_requires_a_value));
2193 goto theend;
2194 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002195 else if (cmdidx == CMD_const)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002196 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02002197 emsg(_(e_const_requires_a_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002198 goto theend;
2199 }
Bram Moolenaardcb53be2021-12-09 14:23:43 +00002200 else if (!lhs.lhs_has_type || lhs.lhs_dest == dest_option
2201 || lhs.lhs_dest == dest_func_option)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002202 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02002203 emsg(_(e_type_or_initialization_required));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002204 goto theend;
2205 }
2206 else
2207 {
2208 // variables are always initialized
Bram Moolenaar35578162021-08-02 19:10:38 +02002209 if (GA_GROW_FAILS(instr, 1))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002210 goto theend;
Bram Moolenaar752fc692021-01-04 21:57:11 +01002211 switch (lhs.lhs_member_type->tt_type)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002212 {
2213 case VAR_BOOL:
2214 generate_PUSHBOOL(cctx, VVAL_FALSE);
2215 break;
2216 case VAR_FLOAT:
2217#ifdef FEAT_FLOAT
2218 generate_PUSHF(cctx, 0.0);
2219#endif
2220 break;
2221 case VAR_STRING:
2222 generate_PUSHS(cctx, NULL);
2223 break;
2224 case VAR_BLOB:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02002225 generate_PUSHBLOB(cctx, blob_alloc());
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002226 break;
2227 case VAR_FUNC:
2228 generate_PUSHFUNC(cctx, NULL, &t_func_void);
2229 break;
2230 case VAR_LIST:
2231 generate_NEWLIST(cctx, 0);
2232 break;
2233 case VAR_DICT:
2234 generate_NEWDICT(cctx, 0);
2235 break;
2236 case VAR_JOB:
2237 generate_PUSHJOB(cctx, NULL);
2238 break;
2239 case VAR_CHANNEL:
2240 generate_PUSHCHANNEL(cctx, NULL);
2241 break;
2242 case VAR_NUMBER:
2243 case VAR_UNKNOWN:
2244 case VAR_ANY:
2245 case VAR_PARTIAL:
2246 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02002247 case VAR_INSTR:
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002248 case VAR_SPECIAL: // cannot happen
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002249 // This is skipped for local variables, they are always
2250 // initialized to zero. But in a "for" or "while" loop
2251 // the value may have been changed.
2252 if (lhs.lhs_dest == dest_local
2253 && !inside_loop_scope(cctx))
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002254 skip_store = TRUE;
2255 else
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002256 {
2257 instr_count = instr->ga_len;
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002258 generate_PUSHNR(cctx, 0);
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002259 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002260 break;
2261 }
2262 }
2263 if (var_count == 0)
2264 end = p;
2265 }
2266
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002267 // no need to parse more when skipping
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002268 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002269 break;
2270
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002271 if (oplen > 0 && *op != '=')
2272 {
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002273 type_T *expected;
Bram Moolenaarc3160722021-08-02 21:12:05 +02002274 type_T *stacktype = NULL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002275
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002276 if (*op == '.')
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002277 {
2278 if (may_generate_2STRING(-1, FALSE, cctx) == FAIL)
2279 goto theend;
2280 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002281 else
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002282 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002283 expected = lhs.lhs_member_type;
Bram Moolenaar078a4612022-01-04 15:17:03 +00002284 stacktype = get_type_on_stack(cctx, 0);
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002285 if (
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002286#ifdef FEAT_FLOAT
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002287 // If variable is float operation with number is OK.
Bram Moolenaar7bf9a072021-08-02 21:55:15 +02002288 !(expected == &t_float && (stacktype == &t_number
2289 || stacktype == &t_number_bool)) &&
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002290#endif
Bram Moolenaar351ead02021-01-16 16:07:01 +01002291 need_type(stacktype, expected, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002292 FALSE, FALSE) == FAIL)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002293 goto theend;
2294 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002295
2296 if (*op == '.')
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02002297 {
2298 if (generate_instr_drop(cctx, ISN_CONCAT, 1) == NULL)
2299 goto theend;
2300 }
2301 else if (*op == '+')
2302 {
2303 if (generate_add_instr(cctx,
Bram Moolenaar752fc692021-01-04 21:57:11 +01002304 operator_type(lhs.lhs_member_type, stacktype),
Bram Moolenaar07802042021-09-09 23:01:14 +02002305 lhs.lhs_member_type, stacktype,
2306 EXPR_APPEND) == FAIL)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02002307 goto theend;
2308 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002309 else if (generate_two_op(cctx, op) == FAIL)
2310 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002311 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002312
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002313 // Use the line number of the assignment for store instruction.
2314 save_lnum = cctx->ctx_lnum;
2315 cctx->ctx_lnum = start_lnum - 1;
2316
Bram Moolenaar752fc692021-01-04 21:57:11 +01002317 if (lhs.lhs_has_index)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002318 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002319 // Use the info in "lhs" to store the value at the index in the
2320 // list or dict.
2321 if (compile_assign_unlet(var_start, &lhs, TRUE, rhs_type, cctx)
2322 == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002323 {
2324 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002325 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002326 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002327 }
2328 else
2329 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002330 if (is_decl && cmdidx == CMD_const && (lhs.lhs_dest == dest_script
Bram Moolenaard877a572021-04-01 19:42:48 +02002331 || lhs.lhs_dest == dest_global
Bram Moolenaar752fc692021-01-04 21:57:11 +01002332 || lhs.lhs_dest == dest_local))
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002333 // ":const var": lock the value, but not referenced variables
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002334 generate_LOCKCONST(cctx);
2335
Bram Moolenaar10d6f182022-01-04 15:54:38 +00002336 if ((lhs.lhs_type->tt_type == VAR_DICT
Bram Moolenaar752fc692021-01-04 21:57:11 +01002337 || lhs.lhs_type->tt_type == VAR_LIST)
2338 && lhs.lhs_type->tt_member != NULL
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002339 && lhs.lhs_type->tt_member != &t_any
Bram Moolenaar752fc692021-01-04 21:57:11 +01002340 && lhs.lhs_type->tt_member != &t_unknown)
Bram Moolenaaraa210a32021-01-02 15:41:03 +01002341 // Set the type in the list or dict, so that it can be checked,
Bram Moolenaar10d6f182022-01-04 15:54:38 +00002342 // also in legacy script.
Bram Moolenaar752fc692021-01-04 21:57:11 +01002343 generate_SETTYPE(cctx, lhs.lhs_type);
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002344 else if (inferred_type != NULL
2345 && (inferred_type->tt_type == VAR_DICT
2346 || inferred_type->tt_type == VAR_LIST)
2347 && inferred_type->tt_member != NULL
2348 && inferred_type->tt_member != &t_unknown
2349 && inferred_type->tt_member != &t_any)
2350 // Set the type in the list or dict, so that it can be checked,
2351 // also in legacy script.
2352 generate_SETTYPE(cctx, inferred_type);
Bram Moolenaaraa210a32021-01-02 15:41:03 +01002353
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002354 if (!skip_store && generate_store_lhs(cctx, &lhs,
2355 instr_count, is_decl) == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002356 {
2357 cctx->ctx_lnum = save_lnum;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02002358 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002359 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002360 }
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002361 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002362
2363 if (var_idx + 1 < var_count)
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00002364 var_start = skipwhite(lhs.lhs_end + 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002365 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002366
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02002367 // For "[var, var] = expr" drop the "expr" value.
2368 // Also for "[var, var; _] = expr".
2369 if (var_count > 0 && (!semicolon || !did_generate_slice))
Bram Moolenaar9af78762020-06-16 11:34:42 +02002370 {
Bram Moolenaarec792292020-12-13 21:26:56 +01002371 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
Bram Moolenaar9af78762020-06-16 11:34:42 +02002372 goto theend;
2373 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002374
Bram Moolenaarb2097502020-07-19 17:17:02 +02002375 ret = skipwhite(end);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002376
2377theend:
Bram Moolenaar752fc692021-01-04 21:57:11 +01002378 vim_free(lhs.lhs_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002379 return ret;
2380}
2381
2382/*
Bram Moolenaar17126b12021-01-07 22:03:02 +01002383 * Check for an assignment at "eap->cmd", compile it if found.
2384 * Return NOTDONE if there is none, FAIL for failure, OK if done.
2385 */
2386 static int
2387may_compile_assignment(exarg_T *eap, char_u **line, cctx_T *cctx)
2388{
2389 char_u *pskip;
2390 char_u *p;
2391
2392 // Assuming the command starts with a variable or function name,
2393 // find what follows.
2394 // Skip over "var.member", "var[idx]" and the like.
2395 // Also "&opt = val", "$ENV = val" and "@r = val".
2396 pskip = (*eap->cmd == '&' || *eap->cmd == '$' || *eap->cmd == '@')
2397 ? eap->cmd + 1 : eap->cmd;
2398 p = to_name_end(pskip, TRUE);
2399 if (p > eap->cmd && *p != NUL)
2400 {
2401 char_u *var_end;
2402 int oplen;
2403 int heredoc;
2404
2405 if (eap->cmd[0] == '@')
2406 var_end = eap->cmd + 2;
2407 else
2408 var_end = find_name_end(pskip, NULL, NULL,
2409 FNE_CHECK_START | FNE_INCL_BR);
2410 oplen = assignment_len(skipwhite(var_end), &heredoc);
2411 if (oplen > 0)
2412 {
2413 size_t len = p - eap->cmd;
2414
2415 // Recognize an assignment if we recognize the variable
2416 // name:
2417 // "g:var = expr"
2418 // "local = expr" where "local" is a local var.
2419 // "script = expr" where "script" is a script-local var.
2420 // "import = expr" where "import" is an imported var
2421 // "&opt = expr"
2422 // "$ENV = expr"
2423 // "@r = expr"
2424 if (*eap->cmd == '&'
2425 || *eap->cmd == '$'
2426 || *eap->cmd == '@'
2427 || ((len) > 2 && eap->cmd[1] == ':')
Bram Moolenaare0890d62021-02-17 14:52:14 +01002428 || variable_exists(eap->cmd, len, cctx))
Bram Moolenaar17126b12021-01-07 22:03:02 +01002429 {
2430 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
2431 if (*line == NULL || *line == eap->cmd)
2432 return FAIL;
2433 return OK;
2434 }
2435 }
2436 }
2437
2438 if (*eap->cmd == '[')
2439 {
Bram Moolenaar8b716f52022-02-15 21:17:56 +00002440 // might be "[var, var] = expr"
Bram Moolenaar17126b12021-01-07 22:03:02 +01002441 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
2442 if (*line == NULL)
2443 return FAIL;
2444 if (*line != eap->cmd)
2445 return OK;
2446 }
2447 return NOTDONE;
2448}
2449
Bram Moolenaar9a015112021-12-31 14:06:45 +00002450/*
2451 * Check if arguments of "ufunc" shadow variables in "cctx".
2452 * Return OK or FAIL.
2453 */
2454 static int
2455check_args_shadowing(ufunc_T *ufunc, cctx_T *cctx)
2456{
2457 int i;
2458 char_u *arg;
2459 int r = OK;
2460
2461 // Make sure arguments are not found when compiling a second time.
2462 ufunc->uf_args_visible = 0;
2463
2464 // Check for arguments shadowing variables from the context.
2465 for (i = 0; i < ufunc->uf_args.ga_len; ++i)
2466 {
2467 arg = ((char_u **)(ufunc->uf_args.ga_data))[i];
Bram Moolenaardce24412022-02-08 20:35:30 +00002468 if (check_defined(arg, STRLEN(arg), cctx, NULL, TRUE) == FAIL)
Bram Moolenaar9a015112021-12-31 14:06:45 +00002469 {
2470 r = FAIL;
2471 break;
2472 }
2473 }
2474 ufunc->uf_args_visible = ufunc->uf_args.ga_len;
2475 return r;
2476}
2477
Bram Moolenaar7b829262021-10-13 15:04:34 +01002478
2479/*
Bram Moolenaar09689a02020-05-09 22:50:08 +02002480 * Add a function to the list of :def functions.
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002481 * This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet.
Bram Moolenaar09689a02020-05-09 22:50:08 +02002482 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02002483 static int
Bram Moolenaar09689a02020-05-09 22:50:08 +02002484add_def_function(ufunc_T *ufunc)
2485{
2486 dfunc_T *dfunc;
2487
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002488 if (def_functions.ga_len == 0)
2489 {
2490 // The first position is not used, so that a zero uf_dfunc_idx means it
2491 // wasn't set.
Bram Moolenaar35578162021-08-02 19:10:38 +02002492 if (GA_GROW_FAILS(&def_functions, 1))
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002493 return FAIL;
2494 ++def_functions.ga_len;
2495 }
2496
Bram Moolenaar09689a02020-05-09 22:50:08 +02002497 // Add the function to "def_functions".
Bram Moolenaar35578162021-08-02 19:10:38 +02002498 if (GA_GROW_FAILS(&def_functions, 1))
Bram Moolenaar09689a02020-05-09 22:50:08 +02002499 return FAIL;
2500 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
2501 CLEAR_POINTER(dfunc);
2502 dfunc->df_idx = def_functions.ga_len;
2503 ufunc->uf_dfunc_idx = dfunc->df_idx;
2504 dfunc->df_ufunc = ufunc;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002505 dfunc->df_name = vim_strsave(ufunc->uf_name);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002506 ga_init2(&dfunc->df_var_names, sizeof(char_u *), 10);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002507 ++dfunc->df_refcount;
Bram Moolenaar09689a02020-05-09 22:50:08 +02002508 ++def_functions.ga_len;
2509 return OK;
2510}
2511
2512/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002513 * After ex_function() has collected all the function lines: parse and compile
2514 * the lines into instructions.
2515 * Adds the function to "def_functions".
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002516 * When "check_return_type" is set then set ufunc->uf_ret_type to the type of
2517 * the return statement (used for lambda). When uf_ret_type is already set
2518 * then check that it matches.
Bram Moolenaarb2049902021-01-24 12:53:53 +01002519 * When "profiling" is true add ISN_PROF_START instructions.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002520 * "outer_cctx" is set for a nested function.
Bram Moolenaar05afcee2020-03-31 23:32:31 +02002521 * This can be used recursively through compile_lambda(), which may reallocate
2522 * "def_functions".
Bram Moolenaar822ba242020-05-24 23:00:18 +02002523 * Returns OK or FAIL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002524 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02002525 int
Bram Moolenaarb2049902021-01-24 12:53:53 +01002526compile_def_function(
Bram Moolenaare99d4222021-06-13 14:01:26 +02002527 ufunc_T *ufunc,
2528 int check_return_type,
2529 compiletype_T compile_type,
2530 cctx_T *outer_cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002531{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002532 char_u *line = NULL;
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002533 garray_T lines_to_free;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002534 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002535 char *errormsg = NULL; // error message
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002536 cctx_T cctx;
2537 garray_T *instr;
Bram Moolenaard66960b2020-10-30 20:46:26 +01002538 int did_emsg_before = did_emsg;
Bram Moolenaar599410c2021-04-10 14:03:43 +02002539 int did_emsg_silent_before = did_emsg_silent;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002540 int ret = FAIL;
2541 sctx_T save_current_sctx = current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02002542 int save_estack_compiling = estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002543 int save_cmod_flags = cmdmod.cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002544 int do_estack_push;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02002545 int new_def_function = FALSE;
Bram Moolenaarf002a412021-01-24 13:34:18 +01002546#ifdef FEAT_PROFILE
Bram Moolenaarb2049902021-01-24 12:53:53 +01002547 int prof_lnum = -1;
Bram Moolenaarf002a412021-01-24 13:34:18 +01002548#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02002549 int debug_lnum = -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002550
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002551 // allocated lines are freed at the end
2552 ga_init2(&lines_to_free, sizeof(char_u *), 50);
2553
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002554 // When using a function that was compiled before: Free old instructions.
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01002555 // The index is reused. Otherwise add a new entry in "def_functions".
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002556 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002557 {
Bram Moolenaar09689a02020-05-09 22:50:08 +02002558 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
2559 + ufunc->uf_dfunc_idx;
Bram Moolenaar3b814af2021-06-15 10:22:17 +02002560 isn_T *instr_dest = NULL;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002561
2562 switch (compile_type)
2563 {
2564 case CT_PROFILE:
2565#ifdef FEAT_PROFILE
2566 instr_dest = dfunc->df_instr_prof; break;
2567#endif
2568 case CT_NONE: instr_dest = dfunc->df_instr; break;
2569 case CT_DEBUG: instr_dest = dfunc->df_instr_debug; break;
2570 }
2571 if (instr_dest != NULL)
2572 // Was compiled in this mode before: Free old instructions.
2573 delete_def_function_contents(dfunc, FALSE);
2574 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002575 }
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02002576 else
2577 {
2578 if (add_def_function(ufunc) == FAIL)
2579 return FAIL;
2580 new_def_function = TRUE;
2581 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002582
Bram Moolenaar96923b72022-03-15 15:57:04 +00002583 if ((ufunc->uf_flags & FC_CLOSURE) && outer_cctx == NULL)
2584 {
2585 semsg(_(e_compiling_closure_without_context_str),
2586 printable_func_name(ufunc));
2587 return FAIL;
2588 }
2589
Bram Moolenaar985116a2020-07-12 17:31:09 +02002590 ufunc->uf_def_status = UF_COMPILING;
2591
Bram Moolenaara80faa82020-04-12 19:37:17 +02002592 CLEAR_FIELD(cctx);
Bram Moolenaarb2049902021-01-24 12:53:53 +01002593
Bram Moolenaare99d4222021-06-13 14:01:26 +02002594 cctx.ctx_compile_type = compile_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002595 cctx.ctx_ufunc = ufunc;
2596 cctx.ctx_lnum = -1;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002597 cctx.ctx_outer = outer_cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002598 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
Bram Moolenaar078a4612022-01-04 15:17:03 +00002599 // Each entry on the type stack consists of two type pointers.
2600 ga_init2(&cctx.ctx_type_stack, sizeof(type2_T), 50);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002601 cctx.ctx_type_list = &ufunc->uf_type_list;
2602 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
2603 instr = &cctx.ctx_instr;
2604
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002605 // Set the context to the function, it may be compiled when called from
2606 // another script. Set the script version to the most modern one.
2607 // The line number will be set in next_line_from_context().
2608 current_sctx = ufunc->uf_script_ctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002609 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
2610
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002611 // Don't use the flag from ":legacy" here.
2612 cmdmod.cmod_flags &= ~CMOD_LEGACY;
2613
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002614 // Make sure error messages are OK.
2615 do_estack_push = !estack_top_is_ufunc(ufunc, 1);
2616 if (do_estack_push)
2617 estack_push_ufunc(ufunc, 1);
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02002618 estack_compiling = TRUE;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002619
Bram Moolenaar9a015112021-12-31 14:06:45 +00002620 if (check_args_shadowing(ufunc, &cctx) == FAIL)
2621 goto erret;
2622
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002623 if (ufunc->uf_def_args.ga_len > 0)
2624 {
2625 int count = ufunc->uf_def_args.ga_len;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002626 int first_def_arg = ufunc->uf_args.ga_len - count;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002627 int i;
2628 char_u *arg;
2629 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002630 int did_set_arg_type = FALSE;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002631
2632 // Produce instructions for the default values of optional arguments.
Bram Moolenaar12bce952021-03-11 20:04:04 +01002633 SOURCING_LNUM = 0; // line number unknown
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002634 for (i = 0; i < count; ++i)
2635 {
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002636 type_T *val_type;
2637 int arg_idx = first_def_arg + i;
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02002638 where_T where = WHERE_INIT;
Bram Moolenaar12bce952021-03-11 20:04:04 +01002639 int r;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02002640 int jump_instr_idx = instr->ga_len;
2641 isn_T *isn;
2642
2643 // Use a JUMP_IF_ARG_SET instruction to skip if the value was given.
2644 if (generate_JUMP_IF_ARG_SET(&cctx, i - count - off) == FAIL)
2645 goto erret;
Bram Moolenaar12bce952021-03-11 20:04:04 +01002646
2647 // Make sure later arguments are not found.
Bram Moolenaare28d9b32021-07-03 18:56:53 +02002648 ufunc->uf_args_visible = arg_idx;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002649
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002650 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
Bram Moolenaar12bce952021-03-11 20:04:04 +01002651 r = compile_expr0(&arg, &cctx);
2652
Bram Moolenaar12bce952021-03-11 20:04:04 +01002653 if (r == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002654 goto erret;
2655
2656 // If no type specified use the type of the default value.
2657 // Otherwise check that the default value type matches the
2658 // specified type.
Bram Moolenaar078a4612022-01-04 15:17:03 +00002659 val_type = get_type_on_stack(&cctx, 0);
Bram Moolenaarf785aa12021-02-11 21:19:34 +01002660 where.wt_index = arg_idx + 1;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002661 if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002662 {
2663 did_set_arg_type = TRUE;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002664 ufunc->uf_arg_types[arg_idx] = val_type;
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002665 }
Bram Moolenaarfa46ead2021-12-22 13:18:39 +00002666 else if (need_type_where(val_type, ufunc->uf_arg_types[arg_idx],
2667 -1, where, &cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002668 goto erret;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002669
2670 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002671 goto erret;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02002672
2673 // set instruction index in JUMP_IF_ARG_SET to here
2674 isn = ((isn_T *)instr->ga_data) + jump_instr_idx;
2675 isn->isn_arg.jumparg.jump_where = instr->ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002676 }
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002677
2678 if (did_set_arg_type)
2679 set_function_type(ufunc);
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002680 }
Bram Moolenaare28d9b32021-07-03 18:56:53 +02002681 ufunc->uf_args_visible = ufunc->uf_args.ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002682
2683 /*
2684 * Loop over all the lines of the function and generate instructions.
2685 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002686 for (;;)
2687 {
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002688 exarg_T ea;
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002689 int starts_with_colon = FALSE;
2690 char_u *cmd;
Bram Moolenaar02194d22020-10-24 23:08:38 +02002691 cmdmod_T local_cmdmod;
Bram Moolenaar5b1c8fe2020-02-21 18:42:43 +01002692
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002693 // Bail out on the first error to avoid a flood of errors and report
2694 // the right line number when inside try/catch.
Bram Moolenaard66960b2020-10-30 20:46:26 +01002695 if (did_emsg_before != did_emsg)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002696 goto erret;
2697
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002698 if (line != NULL && *line == '|')
2699 // the line continues after a '|'
2700 ++line;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002701 else if (line != NULL && *skipwhite(line) != NUL
Bram Moolenaar7a092242020-04-16 22:10:49 +02002702 && !(*line == '#' && (line == cctx.ctx_line_start
2703 || VIM_ISWHITE(line[-1]))))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002704 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00002705 semsg(_(e_trailing_characters_str), line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002706 goto erret;
2707 }
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01002708 else if (line != NULL && vim9_bad_comment(skipwhite(line)))
2709 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002710 else
2711 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002712 line = next_line_from_context(&cctx, FALSE);
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002713 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
Bram Moolenaarb2049902021-01-24 12:53:53 +01002714 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002715 // beyond the last line
Bram Moolenaarf002a412021-01-24 13:34:18 +01002716#ifdef FEAT_PROFILE
Bram Moolenaarced68a02021-01-24 17:53:47 +01002717 if (cctx.ctx_skip != SKIP_YES)
2718 may_generate_prof_end(&cctx, prof_lnum);
Bram Moolenaarf002a412021-01-24 13:34:18 +01002719#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002720 break;
Bram Moolenaarb2049902021-01-24 12:53:53 +01002721 }
Bram Moolenaarf62d7392021-04-14 12:40:00 +02002722 // Make a copy, splitting off nextcmd and removing trailing spaces
2723 // may change it.
2724 if (line != NULL)
2725 {
2726 line = vim_strsave(line);
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002727 if (ga_add_string(&lines_to_free, line) == FAIL)
2728 goto erret;
Bram Moolenaarf62d7392021-04-14 12:40:00 +02002729 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002730 }
2731
Bram Moolenaara80faa82020-04-12 19:37:17 +02002732 CLEAR_FIELD(ea);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002733 ea.cmdlinep = &line;
2734 ea.cmd = skipwhite(line);
2735
Bram Moolenaarb2049902021-01-24 12:53:53 +01002736 if (*ea.cmd == '#')
2737 {
2738 // "#" starts a comment
2739 line = (char_u *)"";
2740 continue;
2741 }
2742
Bram Moolenaarf002a412021-01-24 13:34:18 +01002743#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02002744 if (cctx.ctx_compile_type == CT_PROFILE && cctx.ctx_lnum != prof_lnum
2745 && cctx.ctx_skip != SKIP_YES)
Bram Moolenaarb2049902021-01-24 12:53:53 +01002746 {
2747 may_generate_prof_end(&cctx, prof_lnum);
2748
2749 prof_lnum = cctx.ctx_lnum;
2750 generate_instr(&cctx, ISN_PROF_START);
2751 }
Bram Moolenaarf002a412021-01-24 13:34:18 +01002752#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02002753 if (cctx.ctx_compile_type == CT_DEBUG && cctx.ctx_lnum != debug_lnum
2754 && cctx.ctx_skip != SKIP_YES)
2755 {
2756 debug_lnum = cctx.ctx_lnum;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002757 generate_instr_debug(&cctx);
Bram Moolenaare99d4222021-06-13 14:01:26 +02002758 }
Bram Moolenaar8cec9272021-06-23 20:20:53 +02002759 cctx.ctx_prev_lnum = cctx.ctx_lnum + 1;
Bram Moolenaarb2049902021-01-24 12:53:53 +01002760
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002761 // Some things can be recognized by the first character.
2762 switch (*ea.cmd)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002763 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002764 case '}':
2765 {
2766 // "}" ends a block scope
2767 scopetype_T stype = cctx.ctx_scope == NULL
2768 ? NO_SCOPE : cctx.ctx_scope->se_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002769
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002770 if (stype == BLOCK_SCOPE)
2771 {
2772 compile_endblock(&cctx);
2773 line = ea.cmd;
2774 }
2775 else
2776 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002777 emsg(_(e_using_rcurly_outside_if_block_scope));
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002778 goto erret;
2779 }
2780 if (line != NULL)
2781 line = skipwhite(ea.cmd + 1);
2782 continue;
2783 }
2784
2785 case '{':
2786 // "{" starts a block scope
2787 // "{'a': 1}->func() is something else
2788 if (ends_excmd(*skipwhite(ea.cmd + 1)))
2789 {
2790 line = compile_block(ea.cmd, &cctx);
2791 continue;
2792 }
2793 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002794 }
2795
2796 /*
2797 * COMMAND MODIFIERS
2798 */
Bram Moolenaar02194d22020-10-24 23:08:38 +02002799 cctx.ctx_has_cmdmod = FALSE;
Bram Moolenaare1004402020-10-24 20:49:43 +02002800 if (parse_command_modifiers(&ea, &errormsg, &local_cmdmod, FALSE)
2801 == FAIL)
Bram Moolenaarbc510062022-02-14 21:19:04 +00002802 goto erret;
Bram Moolenaare1004402020-10-24 20:49:43 +02002803 generate_cmdmods(&cctx, &local_cmdmod);
2804 undo_cmdmod(&local_cmdmod);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002805
Bram Moolenaare88c8e82020-11-01 17:03:37 +01002806 // Check if there was a colon after the last command modifier or before
2807 // the current position.
2808 for (p = ea.cmd; p >= line; --p)
2809 {
2810 if (*p == ':')
2811 starts_with_colon = TRUE;
2812 if (p < ea.cmd && !VIM_ISWHITE(*p))
2813 break;
2814 }
2815
Bram Moolenaarce024c32021-06-26 13:00:49 +02002816 // Skip ":call" to get to the function name, unless using :legacy
Bram Moolenaar575f24b2020-08-12 14:21:11 +02002817 p = ea.cmd;
Bram Moolenaarce024c32021-06-26 13:00:49 +02002818 if (!(local_cmdmod.cmod_flags & CMOD_LEGACY))
Bram Moolenaar575f24b2020-08-12 14:21:11 +02002819 {
Bram Moolenaarce024c32021-06-26 13:00:49 +02002820 if (checkforcmd(&ea.cmd, "call", 3))
2821 {
2822 if (*ea.cmd == '(')
2823 // not for "call()"
2824 ea.cmd = p;
2825 else
2826 ea.cmd = skipwhite(ea.cmd);
2827 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002828
Bram Moolenaarce024c32021-06-26 13:00:49 +02002829 if (!starts_with_colon)
2830 {
2831 int assign;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002832
Bram Moolenaarce024c32021-06-26 13:00:49 +02002833 // Check for assignment after command modifiers.
2834 assign = may_compile_assignment(&ea, &line, &cctx);
2835 if (assign == OK)
2836 goto nextline;
2837 if (assign == FAIL)
2838 goto erret;
2839 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002840 }
2841
2842 /*
2843 * COMMAND after range
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002844 * 'text'->func() should not be confused with 'a mark
Bram Moolenaarc1e6c7b2022-02-20 18:26:46 +00002845 * 0z1234->func() should not be confused with a zero line number
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002846 * "++nr" and "--nr" are eval commands
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02002847 * in "$ENV->func()" the "$" is not a range
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002848 */
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002849 cmd = ea.cmd;
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002850 if ((*cmd != '$' || starts_with_colon)
Bram Moolenaarc1e6c7b2022-02-20 18:26:46 +00002851 && (starts_with_colon
2852 || !(*cmd == '\''
2853 || (cmd[0] == '0' && cmd[1] == 'z')
2854 || (cmd[0] != NUL && cmd[0] == cmd[1]
Bram Moolenaard3a11782022-01-05 16:50:40 +00002855 && (*cmd == '+' || *cmd == '-')))))
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002856 {
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02002857 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002858 if (ea.cmd > cmd)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002859 {
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002860 if (!starts_with_colon
2861 && !(local_cmdmod.cmod_flags & CMOD_LEGACY))
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002862 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01002863 semsg(_(e_colon_required_before_range_str), cmd);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002864 goto erret;
2865 }
Bram Moolenaarada1d872021-02-20 08:16:51 +01002866 ea.addr_count = 1;
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002867 if (ends_excmd2(line, ea.cmd))
2868 {
2869 // A range without a command: jump to the line.
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00002870 generate_EXEC(&cctx, ISN_EXECRANGE,
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002871 vim_strnsave(cmd, ea.cmd - cmd));
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00002872 line = ea.cmd;
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002873 goto nextline;
2874 }
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002875 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002876 }
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002877 p = find_ex_command(&ea, NULL,
2878 starts_with_colon || (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01002879 ? NULL : item_exists, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002880
Bram Moolenaard1510ee2021-01-04 16:15:58 +01002881 if (p == NULL)
2882 {
2883 if (cctx.ctx_skip != SKIP_YES)
Bram Moolenaarbed34f02022-01-19 20:48:37 +00002884 semsg(_(e_ambiguous_use_of_user_defined_command_str), ea.cmd);
Bram Moolenaard1510ee2021-01-04 16:15:58 +01002885 goto erret;
2886 }
2887
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002888 // When using ":legacy cmd" always use compile_exec().
2889 if (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002890 {
2891 char_u *start = ea.cmd;
2892
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02002893 switch (ea.cmdidx)
2894 {
2895 case CMD_if:
2896 case CMD_elseif:
2897 case CMD_else:
2898 case CMD_endif:
2899 case CMD_for:
2900 case CMD_endfor:
2901 case CMD_continue:
2902 case CMD_break:
2903 case CMD_while:
2904 case CMD_endwhile:
2905 case CMD_try:
2906 case CMD_catch:
2907 case CMD_finally:
2908 case CMD_endtry:
2909 semsg(_(e_cannot_use_legacy_with_command_str), ea.cmd);
2910 goto erret;
2911 default: break;
2912 }
2913
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002914 // ":legacy return expr" needs to be handled differently.
2915 if (checkforcmd(&start, "return", 4))
2916 ea.cmdidx = CMD_return;
2917 else
2918 ea.cmdidx = CMD_legacy;
2919 }
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002920
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002921 if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
2922 {
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002923 if (cctx.ctx_skip == SKIP_YES && ea.cmdidx != CMD_eval)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002924 {
2925 line += STRLEN(line);
Bram Moolenaarf665e972020-12-05 19:17:16 +01002926 goto nextline;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002927 }
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002928 else if (ea.cmdidx != CMD_eval)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002929 {
Bram Moolenaar52c124d2020-12-20 21:43:35 +01002930 // CMD_var cannot happen, compile_assignment() above would be
2931 // used. Most likely an assignment to a non-existing variable.
2932 semsg(_(e_command_not_recognized_str), ea.cmd);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02002933 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002934 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002935 }
2936
Bram Moolenaar3988f642020-08-27 22:43:03 +02002937 if (cctx.ctx_had_return
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002938 && ea.cmdidx != CMD_elseif
2939 && ea.cmdidx != CMD_else
Bram Moolenaarefd88552020-06-18 20:50:10 +02002940 && ea.cmdidx != CMD_endif
2941 && ea.cmdidx != CMD_endfor
2942 && ea.cmdidx != CMD_endwhile
2943 && ea.cmdidx != CMD_catch
2944 && ea.cmdidx != CMD_finally
2945 && ea.cmdidx != CMD_endtry)
2946 {
Bram Moolenaar3988f642020-08-27 22:43:03 +02002947 emsg(_(e_unreachable_code_after_return));
2948 goto erret;
Bram Moolenaarefd88552020-06-18 20:50:10 +02002949 }
2950
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002951 p = skipwhite(p);
2952 if (ea.cmdidx != CMD_SIZE
2953 && ea.cmdidx != CMD_write && ea.cmdidx != CMD_read)
2954 {
Bram Moolenaar9b123d82020-09-14 22:39:11 +02002955 if (ea.cmdidx >= 0)
2956 ea.argt = excmd_get_argt(ea.cmdidx);
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002957 if ((ea.argt & EX_BANG) && *p == '!')
2958 {
2959 ea.forceit = TRUE;
2960 p = skipwhite(p + 1);
2961 }
2962 }
2963
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002964 switch (ea.cmdidx)
2965 {
2966 case CMD_def:
Bram Moolenaar38453522021-11-28 22:00:12 +00002967 case CMD_function:
Bram Moolenaar04b12692020-05-04 23:24:44 +02002968 ea.arg = p;
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002969 line = compile_nested_function(&ea, &cctx, &lines_to_free);
Bram Moolenaar04b12692020-05-04 23:24:44 +02002970 break;
2971
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002972 case CMD_return:
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002973 line = compile_return(p, check_return_type,
2974 local_cmdmod.cmod_flags & CMOD_LEGACY, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02002975 cctx.ctx_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002976 break;
2977
2978 case CMD_let:
Bram Moolenaarc58f5452020-10-21 20:58:52 +02002979 emsg(_(e_cannot_use_let_in_vim9_script));
2980 break;
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002981 case CMD_var:
2982 case CMD_final:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002983 case CMD_const:
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002984 case CMD_increment:
2985 case CMD_decrement:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002986 line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002987 if (line == p)
Bram Moolenaar8b716f52022-02-15 21:17:56 +00002988 {
2989 emsg(_(e_invalid_assignment));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002990 line = NULL;
Bram Moolenaar8b716f52022-02-15 21:17:56 +00002991 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002992 break;
2993
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002994 case CMD_unlet:
2995 case CMD_unlockvar:
2996 case CMD_lockvar:
2997 line = compile_unletlock(p, &ea, &cctx);
2998 break;
2999
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003000 case CMD_import:
Bram Moolenaar4db572e2021-07-18 18:21:38 +02003001 emsg(_(e_import_can_only_be_used_in_script));
3002 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003003 break;
3004
3005 case CMD_if:
3006 line = compile_if(p, &cctx);
3007 break;
3008 case CMD_elseif:
3009 line = compile_elseif(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003010 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003011 break;
3012 case CMD_else:
3013 line = compile_else(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003014 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003015 break;
3016 case CMD_endif:
3017 line = compile_endif(p, &cctx);
3018 break;
3019
3020 case CMD_while:
3021 line = compile_while(p, &cctx);
3022 break;
3023 case CMD_endwhile:
3024 line = compile_endwhile(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003025 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003026 break;
3027
3028 case CMD_for:
3029 line = compile_for(p, &cctx);
3030 break;
3031 case CMD_endfor:
3032 line = compile_endfor(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003033 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003034 break;
3035 case CMD_continue:
3036 line = compile_continue(p, &cctx);
3037 break;
3038 case CMD_break:
3039 line = compile_break(p, &cctx);
3040 break;
3041
3042 case CMD_try:
3043 line = compile_try(p, &cctx);
3044 break;
3045 case CMD_catch:
3046 line = compile_catch(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003047 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003048 break;
3049 case CMD_finally:
3050 line = compile_finally(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003051 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003052 break;
3053 case CMD_endtry:
3054 line = compile_endtry(p, &cctx);
3055 break;
3056 case CMD_throw:
3057 line = compile_throw(p, &cctx);
3058 break;
3059
Bram Moolenaar007f9d62020-07-06 23:04:49 +02003060 case CMD_eval:
Bram Moolenaarc3235272021-07-10 19:42:03 +02003061 line = compile_eval(p, &cctx);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02003062 break;
3063
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003064 case CMD_echo:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003065 case CMD_echon:
Bram Moolenaarad39c092020-02-26 18:23:43 +01003066 case CMD_execute:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02003067 case CMD_echomsg:
3068 case CMD_echoerr:
Bram Moolenaar7de62622021-08-07 15:05:47 +02003069 case CMD_echoconsole:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02003070 line = compile_mult_expr(p, ea.cmdidx, &cctx);
Bram Moolenaarad39c092020-02-26 18:23:43 +01003071 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003072
Bram Moolenaarc3516f72020-09-08 22:45:35 +02003073 case CMD_put:
3074 ea.cmd = cmd;
3075 line = compile_put(p, &ea, &cctx);
3076 break;
3077
Bram Moolenaar4c137212021-04-19 16:48:48 +02003078 case CMD_substitute:
Bram Moolenaar7b829262021-10-13 15:04:34 +01003079 if (check_global_and_subst(ea.cmd, p) == FAIL)
3080 goto erret;
Bram Moolenaar4c137212021-04-19 16:48:48 +02003081 if (cctx.ctx_skip == SKIP_YES)
3082 line = (char_u *)"";
3083 else
3084 {
3085 ea.arg = p;
3086 line = compile_substitute(line, &ea, &cctx);
3087 }
3088 break;
3089
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003090 case CMD_redir:
3091 ea.arg = p;
3092 line = compile_redir(line, &ea, &cctx);
3093 break;
3094
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003095 case CMD_cexpr:
3096 case CMD_lexpr:
3097 case CMD_caddexpr:
3098 case CMD_laddexpr:
3099 case CMD_cgetexpr:
3100 case CMD_lgetexpr:
Bram Moolenaarb7c97812021-05-05 22:51:39 +02003101#ifdef FEAT_QUICKFIX
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003102 ea.arg = p;
3103 line = compile_cexpr(line, &ea, &cctx);
Bram Moolenaarb7c97812021-05-05 22:51:39 +02003104#else
3105 ex_ni(&ea);
3106 line = NULL;
3107#endif
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003108 break;
3109
Bram Moolenaarae616492020-07-28 20:07:27 +02003110 case CMD_append:
3111 case CMD_change:
3112 case CMD_insert:
Bram Moolenaar10b94212021-02-19 21:42:57 +01003113 case CMD_k:
Bram Moolenaarf5a48012020-08-01 17:00:03 +02003114 case CMD_t:
Bram Moolenaarae616492020-07-28 20:07:27 +02003115 case CMD_xit:
3116 not_in_vim9(&ea);
3117 goto erret;
3118
Bram Moolenaar002262f2020-07-08 17:47:57 +02003119 case CMD_SIZE:
Bram Moolenaar3988f642020-08-27 22:43:03 +02003120 if (cctx.ctx_skip != SKIP_YES)
3121 {
3122 semsg(_(e_invalid_command_str), ea.cmd);
3123 goto erret;
3124 }
3125 // We don't check for a next command here.
3126 line = (char_u *)"";
3127 break;
Bram Moolenaar002262f2020-07-08 17:47:57 +02003128
Bram Moolenaar20677332021-06-06 17:02:53 +02003129 case CMD_lua:
3130 case CMD_mzscheme:
3131 case CMD_perl:
3132 case CMD_py3:
3133 case CMD_python3:
3134 case CMD_python:
3135 case CMD_pythonx:
3136 case CMD_ruby:
3137 case CMD_tcl:
3138 ea.arg = p;
3139 if (vim_strchr(line, '\n') == NULL)
Bram Moolenaar5163fcc2020-08-27 23:37:09 +02003140 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar20677332021-06-06 17:02:53 +02003141 else
3142 // heredoc lines have been concatenated with NL
3143 // characters in get_function_body()
3144 line = compile_script(line, &cctx);
3145 break;
3146
Bram Moolenaar107f7322022-02-06 17:30:41 +00003147 case CMD_vim9script:
Bram Moolenaar8cbf2492022-02-06 20:28:13 +00003148 if (cctx.ctx_skip != SKIP_YES)
3149 {
3150 emsg(_(e_vim9script_can_only_be_used_in_script));
3151 goto erret;
3152 }
3153 line = (char_u *)"";
3154 break;
Bram Moolenaar107f7322022-02-06 17:30:41 +00003155
Bram Moolenaar7b829262021-10-13 15:04:34 +01003156 case CMD_global:
3157 if (check_global_and_subst(ea.cmd, p) == FAIL)
3158 goto erret;
3159 // FALLTHROUGH
Bram Moolenaar20677332021-06-06 17:02:53 +02003160 default:
3161 // Not recognized, execute with do_cmdline_cmd().
3162 ea.arg = p;
3163 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003164 break;
3165 }
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02003166nextline:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003167 if (line == NULL)
3168 goto erret;
Bram Moolenaar585fea72020-04-02 22:33:21 +02003169 line = skipwhite(line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003170
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02003171 // Undo any command modifiers.
Bram Moolenaar02194d22020-10-24 23:08:38 +02003172 generate_undo_cmdmods(&cctx);
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02003173
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003174 if (cctx.ctx_type_stack.ga_len < 0)
3175 {
3176 iemsg("Type stack underflow");
3177 goto erret;
3178 }
3179 }
3180
3181 if (cctx.ctx_scope != NULL)
3182 {
3183 if (cctx.ctx_scope->se_type == IF_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003184 emsg(_(e_missing_endif));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003185 else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003186 emsg(_(e_missing_endwhile));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003187 else if (cctx.ctx_scope->se_type == FOR_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003188 emsg(_(e_missing_endfor));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003189 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003190 emsg(_(e_missing_rcurly));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003191 goto erret;
3192 }
3193
Bram Moolenaarefd88552020-06-18 20:50:10 +02003194 if (!cctx.ctx_had_return)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003195 {
Bram Moolenaare6174fd2021-06-12 18:30:56 +02003196 if (ufunc->uf_ret_type->tt_type == VAR_UNKNOWN)
3197 ufunc->uf_ret_type = &t_void;
3198 else if (ufunc->uf_ret_type->tt_type != VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003199 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003200 emsg(_(e_missing_return_statement));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003201 goto erret;
3202 }
3203
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003204 // Return void if there is no return at the end.
3205 generate_instr(&cctx, ISN_RETURN_VOID);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003206 }
3207
Bram Moolenaar599410c2021-04-10 14:03:43 +02003208 // When compiled with ":silent!" and there was an error don't consider the
3209 // function compiled.
3210 if (emsg_silent == 0 || did_emsg_silent == did_emsg_silent_before)
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003211 {
3212 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3213 + ufunc->uf_dfunc_idx;
3214 dfunc->df_deleted = FALSE;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003215 dfunc->df_script_seq = current_sctx.sc_seq;
Bram Moolenaarf002a412021-01-24 13:34:18 +01003216#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02003217 if (cctx.ctx_compile_type == CT_PROFILE)
Bram Moolenaarb2049902021-01-24 12:53:53 +01003218 {
3219 dfunc->df_instr_prof = instr->ga_data;
3220 dfunc->df_instr_prof_count = instr->ga_len;
3221 }
3222 else
Bram Moolenaarf002a412021-01-24 13:34:18 +01003223#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02003224 if (cctx.ctx_compile_type == CT_DEBUG)
3225 {
3226 dfunc->df_instr_debug = instr->ga_data;
3227 dfunc->df_instr_debug_count = instr->ga_len;
3228 }
3229 else
Bram Moolenaarb2049902021-01-24 12:53:53 +01003230 {
3231 dfunc->df_instr = instr->ga_data;
3232 dfunc->df_instr_count = instr->ga_len;
3233 }
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02003234 dfunc->df_varcount = dfunc->df_var_names.ga_len;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02003235 dfunc->df_has_closure = cctx.ctx_has_closure;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02003236 if (cctx.ctx_outer_used)
3237 ufunc->uf_flags |= FC_CLOSURE;
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003238 ufunc->uf_def_status = UF_COMPILED;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003239 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003240
3241 ret = OK;
3242
3243erret:
Bram Moolenaar599410c2021-04-10 14:03:43 +02003244 if (ufunc->uf_def_status == UF_COMPILING)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003245 {
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003246 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3247 + ufunc->uf_dfunc_idx;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003248
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02003249 // Compiling aborted, free the generated instructions.
Bram Moolenaar8238f082021-04-20 21:10:48 +02003250 clear_instr_ga(instr);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003251 VIM_CLEAR(dfunc->df_name);
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02003252 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003253
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003254 // If using the last entry in the table and it was added above, we
3255 // might as well remove it.
3256 if (!dfunc->df_deleted && new_def_function
Bram Moolenaar45a15082020-05-25 00:28:33 +02003257 && ufunc->uf_dfunc_idx == def_functions.ga_len - 1)
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003258 {
Bram Moolenaar20431c92020-03-20 18:39:46 +01003259 --def_functions.ga_len;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003260 ufunc->uf_dfunc_idx = 0;
3261 }
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003262 ufunc->uf_def_status = UF_COMPILE_ERROR;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003263
Bram Moolenaar3cca2992020-04-02 22:57:36 +02003264 while (cctx.ctx_scope != NULL)
3265 drop_scope(&cctx);
3266
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003267 if (errormsg != NULL)
3268 emsg(errormsg);
Bram Moolenaard66960b2020-10-30 20:46:26 +01003269 else if (did_emsg == did_emsg_before)
Bram Moolenaare13bdec2020-10-16 23:16:47 +02003270 emsg(_(e_compiling_def_function_failed));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003271 }
3272
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003273 if (cctx.ctx_redir_lhs.lhs_name != NULL)
3274 {
3275 if (ret == OK)
3276 {
3277 emsg(_(e_missing_redir_end));
3278 ret = FAIL;
3279 }
3280 vim_free(cctx.ctx_redir_lhs.lhs_name);
Bram Moolenaar753bcf82021-04-21 14:24:24 +02003281 vim_free(cctx.ctx_redir_lhs.lhs_whole);
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003282 }
3283
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003284 current_sctx = save_current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02003285 estack_compiling = save_estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003286 cmdmod.cmod_flags = save_cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02003287 if (do_estack_push)
3288 estack_pop();
3289
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00003290 ga_clear_strings(&lines_to_free);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02003291 free_locals(&cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003292 ga_clear(&cctx.ctx_type_stack);
Bram Moolenaar822ba242020-05-24 23:00:18 +02003293 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003294}
3295
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003296 void
3297set_function_type(ufunc_T *ufunc)
3298{
3299 int varargs = ufunc->uf_va_name != NULL;
3300 int argcount = ufunc->uf_args.ga_len;
3301
3302 // Create a type for the function, with the return type and any
3303 // argument types.
3304 // A vararg is included in uf_args.ga_len but not in uf_arg_types.
3305 // The type is included in "tt_args".
3306 if (argcount > 0 || varargs)
3307 {
Bram Moolenaar18062fc2021-03-05 21:35:47 +01003308 if (ufunc->uf_type_list.ga_itemsize == 0)
3309 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003310 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
3311 argcount, &ufunc->uf_type_list);
3312 // Add argument types to the function type.
3313 if (func_type_add_arg_types(ufunc->uf_func_type,
3314 argcount + varargs,
3315 &ufunc->uf_type_list) == FAIL)
3316 return;
3317 ufunc->uf_func_type->tt_argcount = argcount + varargs;
3318 ufunc->uf_func_type->tt_min_argcount =
3319 argcount - ufunc->uf_def_args.ga_len;
3320 if (ufunc->uf_arg_types == NULL)
3321 {
3322 int i;
3323
3324 // lambda does not have argument types.
3325 for (i = 0; i < argcount; ++i)
3326 ufunc->uf_func_type->tt_args[i] = &t_any;
3327 }
3328 else
3329 mch_memmove(ufunc->uf_func_type->tt_args,
3330 ufunc->uf_arg_types, sizeof(type_T *) * argcount);
3331 if (varargs)
3332 {
3333 ufunc->uf_func_type->tt_args[argcount] =
Bram Moolenaar2a389082021-04-09 20:24:31 +02003334 ufunc->uf_va_type == NULL ? &t_list_any : ufunc->uf_va_type;
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003335 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
3336 }
3337 }
3338 else
3339 // No arguments, can use a predefined type.
3340 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
3341 argcount, &ufunc->uf_type_list);
3342}
3343
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003344/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003345 * Free all instructions for "dfunc" except df_name.
Bram Moolenaar20431c92020-03-20 18:39:46 +01003346 */
3347 static void
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003348delete_def_function_contents(dfunc_T *dfunc, int mark_deleted)
Bram Moolenaar20431c92020-03-20 18:39:46 +01003349{
3350 int idx;
3351
3352 ga_clear(&dfunc->df_def_args_isn);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02003353 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003354
3355 if (dfunc->df_instr != NULL)
3356 {
3357 for (idx = 0; idx < dfunc->df_instr_count; ++idx)
3358 delete_instr(dfunc->df_instr + idx);
3359 VIM_CLEAR(dfunc->df_instr);
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003360 dfunc->df_instr = NULL;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003361 }
Bram Moolenaarc2dec4c2021-06-13 15:39:00 +02003362 if (dfunc->df_instr_debug != NULL)
3363 {
3364 for (idx = 0; idx < dfunc->df_instr_debug_count; ++idx)
3365 delete_instr(dfunc->df_instr_debug + idx);
3366 VIM_CLEAR(dfunc->df_instr_debug);
3367 dfunc->df_instr_debug = NULL;
3368 }
Bram Moolenaarc05fe072021-01-24 21:30:48 +01003369#ifdef FEAT_PROFILE
3370 if (dfunc->df_instr_prof != NULL)
3371 {
3372 for (idx = 0; idx < dfunc->df_instr_prof_count; ++idx)
3373 delete_instr(dfunc->df_instr_prof + idx);
3374 VIM_CLEAR(dfunc->df_instr_prof);
3375 dfunc->df_instr_prof = NULL;
3376 }
3377#endif
Bram Moolenaar20431c92020-03-20 18:39:46 +01003378
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003379 if (mark_deleted)
3380 dfunc->df_deleted = TRUE;
3381 if (dfunc->df_ufunc != NULL)
3382 dfunc->df_ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003383}
3384
3385/*
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003386 * When a user function is deleted, clear the contents of any associated def
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003387 * function, unless another user function still uses it.
3388 * The position in def_functions can be re-used.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003389 */
3390 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003391unlink_def_function(ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003392{
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003393 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003394 {
3395 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3396 + ufunc->uf_dfunc_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003397
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003398 if (--dfunc->df_refcount <= 0)
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003399 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003400 ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003401 ufunc->uf_dfunc_idx = 0;
3402 if (dfunc->df_ufunc == ufunc)
3403 dfunc->df_ufunc = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003404 }
3405}
3406
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003407/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003408 * Used when a user function refers to an existing dfunc.
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003409 */
3410 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003411link_def_function(ufunc_T *ufunc)
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003412{
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003413 if (ufunc->uf_dfunc_idx > 0)
3414 {
3415 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3416 + ufunc->uf_dfunc_idx;
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003417
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003418 ++dfunc->df_refcount;
3419 }
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003420}
3421
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003422#if defined(EXITFREE) || defined(PROTO)
Bram Moolenaar20431c92020-03-20 18:39:46 +01003423/*
3424 * Free all functions defined with ":def".
3425 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003426 void
3427free_def_functions(void)
3428{
Bram Moolenaar20431c92020-03-20 18:39:46 +01003429 int idx;
3430
3431 for (idx = 0; idx < def_functions.ga_len; ++idx)
3432 {
3433 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx;
3434
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003435 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003436 vim_free(dfunc->df_name);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003437 }
3438
3439 ga_clear(&def_functions);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003440}
3441#endif
3442
3443
3444#endif // FEAT_EVAL