blob: edbd33e4b185af877ff3ca4300ec21cf0a4315c5 [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".
154 * "cctx" is NULL at the script level.
Bram Moolenaardce24412022-02-08 20:35:30 +0000155 * "cstack_T" is NULL in a function.
Bram Moolenaar18062fc2021-03-05 21:35:47 +0100156 * If "len" is <= 0 "name" must be NUL terminated.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200157 * Return NULL when not found.
158 */
159 static sallvar_T *
Bram Moolenaardce24412022-02-08 20:35:30 +0000160find_script_var(char_u *name, size_t len, cctx_T *cctx, cstack_T *cstack)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200161{
162 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
163 hashitem_T *hi;
164 int cc;
165 sallvar_T *sav;
166 ufunc_T *ufunc;
167
168 // Find the list of all script variables with the right name.
169 if (len > 0)
170 {
171 cc = name[len];
172 name[len] = NUL;
173 }
174 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
175 if (len > 0)
176 name[len] = cc;
177 if (HASHITEM_EMPTY(hi))
178 return NULL;
179
180 sav = HI2SAV(hi);
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200181 if (sav->sav_block_id == 0)
182 // variable defined in the top script scope is always visible
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200183 return sav;
184
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200185 if (cctx == NULL)
186 {
Bram Moolenaardce24412022-02-08 20:35:30 +0000187 // Not in a function scope, find variable with block ID equal to or
188 // smaller than the current block id. If "cstack" is not NULL go up
189 // the block scopes (more accurate).
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200190 while (sav != NULL)
191 {
Bram Moolenaardce24412022-02-08 20:35:30 +0000192 if (cstack != NULL)
193 {
194 int idx;
195
196 for (idx = cstack->cs_idx; idx >= 0; --idx)
197 if (cstack->cs_block_id[idx] == sav->sav_block_id)
198 break;
199 if (idx >= 0)
200 break;
201 }
202 else if (sav->sav_block_id <= si->sn_current_block_id)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +0200203 break;
204 sav = sav->sav_next;
205 }
206 return sav;
207 }
208
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200209 // Go over the variables with this name and find one that was visible
210 // from the function.
211 ufunc = cctx->ctx_ufunc;
212 while (sav != NULL)
213 {
214 int idx;
215
216 // Go over the blocks that this function was defined in. If the
217 // variable block ID matches it was visible to the function.
218 for (idx = 0; idx < ufunc->uf_block_depth; ++idx)
219 if (ufunc->uf_block_ids[idx] == sav->sav_block_id)
220 return sav;
221 sav = sav->sav_next;
222 }
223
Bram Moolenaar58493cf2022-01-06 12:23:30 +0000224 // Not found, variable was not visible.
225 return NULL;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200226}
227
228/*
Bram Moolenaar8e7d6222020-12-18 19:49:56 +0100229 * Return TRUE if the script context is Vim9 script.
Bram Moolenaar84367732020-08-23 15:21:55 +0200230 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000231 int
Bram Moolenaar84367732020-08-23 15:21:55 +0200232script_is_vim9()
233{
234 return SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9;
235}
236
237/*
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200238 * Lookup a variable (without s: prefix) in the current script.
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200239 * "cctx" is NULL at the script level.
Bram Moolenaardce24412022-02-08 20:35:30 +0000240 * "cstack" is NULL in a function.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100241 * Returns OK or FAIL.
242 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000243 int
Bram Moolenaardce24412022-02-08 20:35:30 +0000244script_var_exists(char_u *name, size_t len, cctx_T *cctx, cstack_T *cstack)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100245{
Bram Moolenaar9c4f5522020-09-25 21:47:28 +0200246 if (current_sctx.sc_sid <= 0)
247 return FAIL;
Bram Moolenaar15e5e532021-04-07 21:21:13 +0200248 if (script_is_vim9())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200249 {
250 // Check script variables that were visible where the function was
251 // defined.
Bram Moolenaardce24412022-02-08 20:35:30 +0000252 if (find_script_var(name, len, cctx, cstack) != NULL)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200253 return OK;
254 }
255 else
256 {
257 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
258 dictitem_T *di;
259 int cc;
260
261 // Check script variables that are currently visible
262 cc = name[len];
263 name[len] = NUL;
264 di = find_var_in_ht(ht, 0, name, TRUE);
265 name[len] = cc;
266 if (di != NULL)
267 return OK;
268 }
269
270 return FAIL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100271}
272
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100273/*
Bram Moolenaare0890d62021-02-17 14:52:14 +0100274 * Return TRUE if "name" is a local variable, argument, script variable or
275 * imported.
276 */
277 static int
278variable_exists(char_u *name, size_t len, cctx_T *cctx)
279{
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100280 return (cctx != NULL
281 && (lookup_local(name, len, NULL, cctx) == OK
282 || arg_exists(name, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaardce24412022-02-08 20:35:30 +0000283 || script_var_exists(name, len, cctx, NULL) == OK
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000284 || find_imported(name, len, FALSE) != NULL;
Bram Moolenaare0890d62021-02-17 14:52:14 +0100285}
286
287/*
Bram Moolenaar6914e872021-03-06 21:01:09 +0100288 * Return TRUE if "name" is a local variable, argument, script variable,
289 * imported or function.
290 */
291 static int
Bram Moolenaar77b10ff2021-03-14 13:21:35 +0100292item_exists(char_u *name, size_t len, int cmd UNUSED, cctx_T *cctx)
Bram Moolenaar6914e872021-03-06 21:01:09 +0100293{
Bram Moolenaar0631bb42022-02-13 21:20:21 +0000294 return variable_exists(name, len, cctx);
Bram Moolenaar6914e872021-03-06 21:01:09 +0100295}
296
297/*
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100298 * Check if "p[len]" is already defined, either in script "import_sid" or in
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200299 * compilation context "cctx". "cctx" is NULL at the script level.
Bram Moolenaar0f769812020-09-12 18:32:34 +0200300 * Does not check the global namespace.
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100301 * If "is_arg" is TRUE the error message is for an argument name.
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100302 * Return FAIL and give an error if it defined.
303 */
304 int
Bram Moolenaardce24412022-02-08 20:35:30 +0000305check_defined(
306 char_u *p,
307 size_t len,
308 cctx_T *cctx,
309 cstack_T *cstack,
310 int is_arg)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100311{
Bram Moolenaar0f769812020-09-12 18:32:34 +0200312 int c = p[len];
313 ufunc_T *ufunc = NULL;
Bram Moolenaarad486a02020-08-01 23:22:18 +0200314
Bram Moolenaarda479c72021-04-10 21:01:38 +0200315 // underscore argument is OK
316 if (len == 1 && *p == '_')
317 return OK;
318
Bram Moolenaardce24412022-02-08 20:35:30 +0000319 if (script_var_exists(p, len, cctx, cstack) == OK)
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100320 {
321 if (is_arg)
322 semsg(_(e_argument_already_declared_in_script_str), p);
323 else
324 semsg(_(e_variable_already_declared_in_script_str), p);
325 return FAIL;
326 }
327
Bram Moolenaarad486a02020-08-01 23:22:18 +0200328 p[len] = NUL;
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100329 if ((cctx != NULL
Bram Moolenaar709664c2020-12-12 14:33:41 +0100330 && (lookup_local(p, len, NULL, cctx) == OK
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200331 || arg_exists(p, len, NULL, NULL, NULL, cctx) == OK))
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000332 || find_imported(p, len, FALSE) != NULL
Bram Moolenaaracc4b562022-01-24 13:54:45 +0000333 || (ufunc = find_func_even_dead(p, 0)) != NULL)
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100334 {
Bram Moolenaar0f769812020-09-12 18:32:34 +0200335 // A local or script-local function can shadow a global function.
Bram Moolenaar577dc932021-06-27 15:35:40 +0200336 if (ufunc == NULL || ((ufunc->uf_flags & FC_DEAD) == 0
337 && (!func_is_global(ufunc)
338 || (p[0] == 'g' && p[1] == ':'))))
Bram Moolenaar0f769812020-09-12 18:32:34 +0200339 {
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100340 if (is_arg)
341 semsg(_(e_argument_name_shadows_existing_variable_str), p);
342 else
343 semsg(_(e_name_already_defined_str), p);
Bram Moolenaar0f769812020-09-12 18:32:34 +0200344 p[len] = c;
Bram Moolenaar0f769812020-09-12 18:32:34 +0200345 return FAIL;
346 }
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100347 }
Bram Moolenaarad486a02020-08-01 23:22:18 +0200348 p[len] = c;
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100349 return OK;
350}
351
Bram Moolenaar65b95452020-07-19 14:03:09 +0200352
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100353/*
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200354 * Return TRUE if "actual" could be "expected" and a runtime typecheck is to be
355 * used. Return FALSE if the types will never match.
356 */
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +0200357 static int
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200358use_typecheck(type_T *actual, type_T *expected)
359{
360 if (actual->tt_type == VAR_ANY
361 || actual->tt_type == VAR_UNKNOWN
362 || (actual->tt_type == VAR_FUNC
363 && (expected->tt_type == VAR_FUNC
364 || expected->tt_type == VAR_PARTIAL)
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000365 && (actual->tt_member == &t_any
366 || actual->tt_member == &t_unknown
367 || actual->tt_argcount < 0)
368 && (actual->tt_member == &t_unknown ||
369 (actual->tt_member == &t_void)
Bram Moolenaar328eac22021-01-07 19:23:08 +0100370 == (expected->tt_member == &t_void))))
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200371 return TRUE;
372 if ((actual->tt_type == VAR_LIST || actual->tt_type == VAR_DICT)
373 && actual->tt_type == expected->tt_type)
374 // This takes care of a nested list or dict.
375 return use_typecheck(actual->tt_member, expected->tt_member);
376 return FALSE;
377}
378
379/*
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200380 * Check that
Bram Moolenaar5e654232020-09-16 15:22:00 +0200381 * - "actual" matches "expected" type or
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200382 * - "actual" is a type that can be "expected" type: add a runtime check; or
383 * - return FAIL.
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200384 * If "actual_is_const" is TRUE then the type won't change at runtime, do not
385 * generate a TYPECHECK.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200386 */
Bram Moolenaara1c51952022-02-02 16:20:26 +0000387 int
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200388need_type_where(
389 type_T *actual,
390 type_T *expected,
391 int offset,
392 where_T where,
393 cctx_T *cctx,
394 int silent,
395 int actual_is_const)
396{
Bram Moolenaar44a89772021-12-18 12:31:33 +0000397 int ret;
398
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200399 if (expected == &t_bool && actual != &t_bool
400 && (actual->tt_flags & TTFLAG_BOOL_OK))
401 {
402 // Using "0", "1" or the result of an expression with "&&" or "||" as a
403 // boolean is OK but requires a conversion.
404 generate_2BOOL(cctx, FALSE, offset);
405 return OK;
406 }
407
Bram Moolenaar44a89772021-12-18 12:31:33 +0000408 ret = check_type_maybe(expected, actual, FALSE, where);
409 if (ret == OK)
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200410 return OK;
411
412 // If the actual type can be the expected type add a runtime check.
413 // If it's a constant a runtime check makes no sense.
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000414 if (!actual_is_const && ret == MAYBE && use_typecheck(actual, expected))
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200415 {
416 generate_TYPECHECK(cctx, expected, offset, where.wt_index);
417 return OK;
418 }
419
420 if (!silent)
421 type_mismatch_where(expected, actual, where);
422 return FAIL;
423}
424
Bram Moolenaar351ead02021-01-16 16:07:01 +0100425 int
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200426need_type(
427 type_T *actual,
428 type_T *expected,
429 int offset,
Bram Moolenaar351ead02021-01-16 16:07:01 +0100430 int arg_idx,
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200431 cctx_T *cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200432 int silent,
433 int actual_is_const)
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200434{
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +0200435 where_T where = WHERE_INIT;
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100436
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100437 where.wt_index = arg_idx;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200438 return need_type_where(actual, expected, offset, where,
439 cctx, silent, actual_is_const);
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +0200440}
441
442/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100443 * Reserve space for a local variable.
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200444 * Return the variable or NULL if it failed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100445 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000446 lvar_T *
Bram Moolenaare8211a32020-10-09 22:04:29 +0200447reserve_local(
448 cctx_T *cctx,
449 char_u *name,
450 size_t len,
451 int isConst,
452 type_T *type)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100453{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100454 lvar_T *lvar;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200455 dfunc_T *dfunc;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100456
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200457 if (arg_exists(name, len, NULL, NULL, NULL, cctx) == OK)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100458 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200459 emsg_namelen(_(e_str_is_used_as_argument), name, (int)len);
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200460 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100461 }
462
Bram Moolenaar35578162021-08-02 19:10:38 +0200463 if (GA_GROW_FAILS(&cctx->ctx_locals, 1))
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200464 return NULL;
465 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
Bram Moolenaare8211a32020-10-09 22:04:29 +0200466 CLEAR_POINTER(lvar);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100467
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200468 // Every local variable uses the next entry on the stack. We could re-use
469 // the last ones when leaving a scope, but then variables used in a closure
470 // might get overwritten. To keep things simple do not re-use stack
471 // entries. This is less efficient, but memory is cheap these days.
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200472 dfunc = ((dfunc_T *)def_functions.ga_data) + cctx->ctx_ufunc->uf_dfunc_idx;
473 lvar->lv_idx = dfunc->df_var_names.ga_len;
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200474
Bram Moolenaar71ccd032020-06-12 22:59:11 +0200475 lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100476 lvar->lv_const = isConst;
477 lvar->lv_type = type;
478
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200479 // Remember the name for debugging.
Bram Moolenaar35578162021-08-02 19:10:38 +0200480 if (GA_GROW_FAILS(&dfunc->df_var_names, 1))
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +0200481 return NULL;
482 ((char_u **)dfunc->df_var_names.ga_data)[lvar->lv_idx] =
483 vim_strsave(lvar->lv_name);
484 ++dfunc->df_var_names.ga_len;
485
Bram Moolenaarb84a3812020-05-01 15:44:29 +0200486 return lvar;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100487}
488
489/*
Bram Moolenaar08251752021-01-11 21:20:18 +0100490 * If "check_writable" is ASSIGN_CONST give an error if the variable was
491 * defined with :final or :const, if "check_writable" is ASSIGN_FINAL give an
492 * error if the variable was defined with :const.
493 */
494 static int
495check_item_writable(svar_T *sv, int check_writable, char_u *name)
496{
497 if ((check_writable == ASSIGN_CONST && sv->sv_const != 0)
498 || (check_writable == ASSIGN_FINAL
499 && sv->sv_const == ASSIGN_CONST))
500 {
Bram Moolenaard8e44472021-07-21 22:20:33 +0200501 semsg(_(e_cannot_change_readonly_variable_str), name);
Bram Moolenaar08251752021-01-11 21:20:18 +0100502 return FAIL;
503 }
504 return OK;
505}
506
507/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100508 * Find "name" in script-local items of script "sid".
Bram Moolenaar08251752021-01-11 21:20:18 +0100509 * Pass "check_writable" to check_item_writable().
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100510 * Returns the index in "sn_var_vals" if found.
511 * If found but not in "sn_var_vals" returns -1.
Bram Moolenaar08251752021-01-11 21:20:18 +0100512 * If not found or the variable is not writable returns -2.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100513 */
514 int
Bram Moolenaarb6a138e2022-02-08 21:17:22 +0000515get_script_item_idx(
516 int sid,
517 char_u *name,
518 int check_writable,
519 cctx_T *cctx,
520 cstack_T *cstack)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100521{
522 hashtab_T *ht;
523 dictitem_T *di;
Bram Moolenaar21b9e972020-01-26 19:26:46 +0100524 scriptitem_T *si = SCRIPT_ITEM(sid);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200525 svar_T *sv;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100526 int idx;
527
Bram Moolenaare3d46852020-08-29 13:39:17 +0200528 if (!SCRIPT_ID_VALID(sid))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100529 return -1;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200530 if (sid == current_sctx.sc_sid)
531 {
Bram Moolenaarb6a138e2022-02-08 21:17:22 +0000532 sallvar_T *sav = find_script_var(name, 0, cctx, cstack);
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200533
534 if (sav == NULL)
535 return -2;
536 idx = sav->sav_var_vals_idx;
537 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar08251752021-01-11 21:20:18 +0100538 if (check_item_writable(sv, check_writable, name) == FAIL)
539 return -2;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200540 return idx;
541 }
542
543 // First look the name up in the hashtable.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100544 ht = &SCRIPT_VARS(sid);
545 di = find_var_in_ht(ht, 0, name, TRUE);
546 if (di == NULL)
Bram Moolenaar577bd852022-01-10 18:42:52 +0000547 {
548 if (si->sn_autoload_prefix != NULL)
549 {
550 hashitem_T *hi;
551
552 // A variable exported from an autoload script is in the global
553 // variables, we can find it in the all_vars table.
554 hi = hash_find(&si->sn_all_vars.dv_hashtab, name);
555 if (!HASHITEM_EMPTY(hi))
556 return HI2SAV(hi)->sav_var_vals_idx;
557 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100558 return -2;
Bram Moolenaar577bd852022-01-10 18:42:52 +0000559 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100560
561 // Now find the svar_T index in sn_var_vals.
562 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
563 {
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200564 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100565 if (sv->sv_tv == &di->di_tv)
566 {
Bram Moolenaar08251752021-01-11 21:20:18 +0100567 if (check_item_writable(sv, check_writable, name) == FAIL)
568 return -2;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100569 return idx;
570 }
571 }
572 return -1;
573}
574
Yegappan Lakshmanan782b43d2022-01-08 18:43:40 +0000575 static imported_T *
576find_imported_in_script(char_u *name, size_t len, int sid)
577{
578 scriptitem_T *si;
579 int idx;
580
581 if (!SCRIPT_ID_VALID(sid))
582 return NULL;
583 si = SCRIPT_ITEM(sid);
584 for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
585 {
586 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx;
587
588 if (len == 0 ? STRCMP(name, import->imp_name) == 0
589 : STRLEN(import->imp_name) == len
590 && STRNCMP(name, import->imp_name, len) == 0)
591 return import;
592 }
593 return NULL;
594}
595
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100596/*
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000597 * Find "name" in imported items of the current script.
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000598 * If "load" is TRUE and the script was not loaded yet, load it now.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100599 */
600 imported_T *
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000601find_imported(char_u *name, size_t len, int load)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100602{
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000603 imported_T *ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100604
Bram Moolenaare3d46852020-08-29 13:39:17 +0200605 if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
Bram Moolenaar8e6cbb72020-07-01 14:38:12 +0200606 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100607
Bram Moolenaar4b1d9632022-02-13 21:51:08 +0000608 ret = find_imported_in_script(name, len, current_sctx.sc_sid);
Bram Moolenaarb697dc22022-01-22 11:27:29 +0000609 if (ret != NULL && load && (ret->imp_flags & IMP_FLAGS_AUTOLOAD))
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000610 {
Bram Moolenaar17d36cb2022-01-12 11:46:40 +0000611 scid_T dummy;
612
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000613 // script found before but not loaded yet
Bram Moolenaarb697dc22022-01-22 11:27:29 +0000614 ret->imp_flags &= ~IMP_FLAGS_AUTOLOAD;
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000615 (void)do_source(SCRIPT_ITEM(ret->imp_sid)->sn_name, FALSE,
Bram Moolenaar17d36cb2022-01-12 11:46:40 +0000616 DOSO_NONE, &dummy);
Bram Moolenaardc4451d2022-01-09 21:36:37 +0000617 }
618 return ret;
Bram Moolenaarefa94442020-08-08 22:16:00 +0200619}
620
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100621/*
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000622 * Called when checking for a following operator at "arg". When the rest of
623 * the line is empty or only a comment, peek the next line. If there is a next
624 * line return a pointer to it and set "nextp".
625 * Otherwise skip over white space.
626 */
627 char_u *
628may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp)
629{
630 char_u *p = skipwhite(arg);
631
632 *nextp = NULL;
633 if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p)))
634 {
635 *nextp = peek_next_line_from_context(cctx);
636 if (*nextp != NULL)
637 return *nextp;
638 }
639 return p;
640}
641
642/*
Bram Moolenaar23c55272020-06-21 16:58:13 +0200643 * Return a pointer to the next line that isn't empty or only contains a
644 * comment. Skips over white space.
645 * Returns NULL if there is none.
646 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200647 char_u *
648peek_next_line_from_context(cctx_T *cctx)
Bram Moolenaar23c55272020-06-21 16:58:13 +0200649{
650 int lnum = cctx->ctx_lnum;
651
652 while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len)
653 {
654 char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum];
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +0200655 char_u *p;
Bram Moolenaar23c55272020-06-21 16:58:13 +0200656
Bram Moolenaarba60cc42020-08-12 19:15:33 +0200657 // ignore NULLs inserted for continuation lines
658 if (line != NULL)
659 {
660 p = skipwhite(line);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +0100661 if (vim9_bad_comment(p))
662 return NULL;
Bram Moolenaarba60cc42020-08-12 19:15:33 +0200663 if (*p != NUL && !vim9_comment_start(p))
664 return p;
665 }
Bram Moolenaar23c55272020-06-21 16:58:13 +0200666 }
667 return NULL;
668}
669
670/*
Bram Moolenaare6085c52020-04-12 20:19:16 +0200671 * Get the next line of the function from "cctx".
Bram Moolenaar23c55272020-06-21 16:58:13 +0200672 * Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE.
Bram Moolenaare6085c52020-04-12 20:19:16 +0200673 * Returns NULL when at the end.
674 */
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200675 char_u *
Bram Moolenaar23c55272020-06-21 16:58:13 +0200676next_line_from_context(cctx_T *cctx, int skip_comment)
Bram Moolenaare6085c52020-04-12 20:19:16 +0200677{
Bram Moolenaar7a092242020-04-16 22:10:49 +0200678 char_u *line;
Bram Moolenaare6085c52020-04-12 20:19:16 +0200679
680 do
681 {
682 ++cctx->ctx_lnum;
683 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200684 {
685 line = NULL;
Bram Moolenaare6085c52020-04-12 20:19:16 +0200686 break;
Bram Moolenaar7a092242020-04-16 22:10:49 +0200687 }
Bram Moolenaare6085c52020-04-12 20:19:16 +0200688 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
Bram Moolenaar7a092242020-04-16 22:10:49 +0200689 cctx->ctx_line_start = line;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200690 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar23c55272020-06-21 16:58:13 +0200691 } while (line == NULL || *skipwhite(line) == NUL
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +0200692 || (skip_comment && vim9_comment_start(skipwhite(line))));
Bram Moolenaare6085c52020-04-12 20:19:16 +0200693 return line;
694}
695
696/*
Bram Moolenaar5afd0812021-01-03 18:33:13 +0100697 * Skip over white space at "whitep" and assign to "*arg".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200698 * If "*arg" is at the end of the line, advance to the next line.
Bram Moolenaar2c330432020-04-13 14:41:35 +0200699 * Also when "whitep" points to white space and "*arg" is on a "#".
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200700 * Return FAIL if beyond the last line, "*arg" is unmodified then.
701 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000702 int
Bram Moolenaar2c330432020-04-13 14:41:35 +0200703may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx)
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200704{
Bram Moolenaar5afd0812021-01-03 18:33:13 +0100705 *arg = skipwhite(whitep);
Bram Moolenaar4b3e1962021-03-18 21:37:55 +0100706 if (vim9_bad_comment(*arg))
707 return FAIL;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200708 if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg)))
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200709 {
Bram Moolenaar23c55272020-06-21 16:58:13 +0200710 char_u *next = next_line_from_context(cctx, TRUE);
Bram Moolenaar9c7e6dd2020-04-12 20:55:20 +0200711
712 if (next == NULL)
713 return FAIL;
714 *arg = skipwhite(next);
715 }
716 return OK;
717}
718
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200719/*
720 * Idem, and give an error when failed.
721 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +0000722 int
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200723may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx)
724{
725 if (may_get_next_line(whitep, arg, cctx) == FAIL)
726 {
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100727 SOURCING_LNUM = cctx->ctx_lnum + 1;
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200728 emsg(_(e_line_incomplete));
Bram Moolenaara7eedf32020-07-10 21:50:41 +0200729 return FAIL;
730 }
731 return OK;
732}
733
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100734/*
Bram Moolenaar04b12692020-05-04 23:24:44 +0200735 * Get a line from the compilation context, compatible with exarg_T getline().
736 * Return a pointer to the line in allocated memory.
737 * Return NULL for end-of-file or some error.
738 */
739 static char_u *
740exarg_getline(
741 int c UNUSED,
742 void *cookie,
743 int indent UNUSED,
Bram Moolenaar66250c92020-08-20 15:02:42 +0200744 getline_opt_T options UNUSED)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200745{
746 cctx_T *cctx = (cctx_T *)cookie;
Bram Moolenaar66250c92020-08-20 15:02:42 +0200747 char_u *p;
Bram Moolenaar04b12692020-05-04 23:24:44 +0200748
Bram Moolenaar66250c92020-08-20 15:02:42 +0200749 for (;;)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200750 {
Bram Moolenaar2914a202020-09-27 18:24:03 +0200751 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len - 1)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200752 return NULL;
753 ++cctx->ctx_lnum;
754 p = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
755 // Comment lines result in NULL pointers, skip them.
756 if (p != NULL)
757 return vim_strsave(p);
Bram Moolenaar04b12692020-05-04 23:24:44 +0200758 }
Bram Moolenaar04b12692020-05-04 23:24:44 +0200759}
760
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +0100761 void
762fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx)
763{
764 eap->getline = exarg_getline;
765 eap->cookie = cctx;
766}
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 {
839 semsg(_(e_invalid_command_str), eap->cmd);
840 return NULL;
841 }
842
843 // "def" or "def Name": list functions
844 if (generate_DEF(cctx, name_start, name_end - name_start) == FAIL)
845 return NULL;
846 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
847 }
848
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200849 // Only g:Func() can use a namespace.
850 if (name_start[1] == ':' && !is_global)
851 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200852 semsg(_(e_namespace_not_supported_str), name_start);
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200853 return NULL;
854 }
Bram Moolenaardce24412022-02-08 20:35:30 +0000855 if (check_defined(name_start, name_end - name_start, cctx,
856 NULL, FALSE) == FAIL)
Bram Moolenaareef21022020-08-01 22:16:43 +0200857 return NULL;
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000858 if (!ASCII_ISUPPER(is_global ? name_start[2] : name_start[0]))
859 {
Bram Moolenaar3787f262022-02-07 21:54:01 +0000860 semsg(_(e_function_name_must_start_with_capital_str), name_start);
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000861 return NULL;
862 }
Bram Moolenaareef21022020-08-01 22:16:43 +0200863
Bram Moolenaar04b12692020-05-04 23:24:44 +0200864 eap->arg = name_end;
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +0100865 fill_exarg_from_cctx(eap, cctx);
866
Bram Moolenaar04b12692020-05-04 23:24:44 +0200867 eap->forceit = FALSE;
Bram Moolenaar38453522021-11-28 22:00:12 +0000868 // We use the special <Lamba>99 name, but it's not really a lambda.
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100869 lambda_name = vim_strsave(get_lambda_name());
870 if (lambda_name == NULL)
871 return NULL;
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000872
873 // This may free the current line, make a copy of the name.
874 off = is_global ? 2 : 0;
875 func_name = vim_strnsave(name_start + off, name_end - name_start - off);
876 if (func_name == NULL)
877 {
878 r = FAIL;
879 goto theend;
880 }
881
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +0000882 ufunc = define_function(eap, lambda_name, lines_to_free);
Bram Moolenaar822ba242020-05-24 23:00:18 +0200883 if (ufunc == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100884 {
885 r = eap->skip ? OK : FAIL;
886 goto theend;
887 }
Bram Moolenaar7473a842021-12-28 17:55:26 +0000888 if (eap->nextcmd != NULL)
889 {
890 semsg(_(e_text_found_after_str_str),
891 eap->cmdidx == CMD_def ? "enddef" : "endfunction", eap->nextcmd);
892 r = FAIL;
Bram Moolenaard2939812021-12-30 17:09:05 +0000893 func_ptr_unref(ufunc);
Bram Moolenaar7473a842021-12-28 17:55:26 +0000894 goto theend;
895 }
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100896
897 // copy over the block scope IDs before compiling
898 if (!is_global && cctx->ctx_ufunc->uf_block_depth > 0)
899 {
900 int block_depth = cctx->ctx_ufunc->uf_block_depth;
901
902 ufunc->uf_block_ids = ALLOC_MULT(int, block_depth);
903 if (ufunc->uf_block_ids != NULL)
904 {
905 mch_memmove(ufunc->uf_block_ids, cctx->ctx_ufunc->uf_block_ids,
906 sizeof(int) * block_depth);
907 ufunc->uf_block_depth = block_depth;
908 }
909 }
910
Bram Moolenaarffcfddc2021-07-11 20:22:30 +0200911 compile_type = COMPILE_TYPE(ufunc);
912#ifdef FEAT_PROFILE
913 // If the outer function is profiled, also compile the nested function for
914 // profiling.
915 if (cctx->ctx_compile_type == CT_PROFILE)
916 compile_type = CT_PROFILE;
917#endif
918 if (func_needs_compiling(ufunc, compile_type)
919 && compile_def_function(ufunc, TRUE, compile_type, cctx) == FAIL)
Bram Moolenaar4ee711f2020-09-23 18:51:11 +0200920 {
921 func_ptr_unref(ufunc);
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100922 goto theend;
Bram Moolenaar4ee711f2020-09-23 18:51:11 +0200923 }
Bram Moolenaar04b12692020-05-04 23:24:44 +0200924
Bram Moolenaar648594e2021-07-11 17:55:01 +0200925#ifdef FEAT_PROFILE
926 // When the outer function is compiled for profiling, the nested function
927 // may be called without profiling. Compile it here in the right context.
Bram Moolenaarffcfddc2021-07-11 20:22:30 +0200928 if (compile_type == CT_PROFILE && func_needs_compiling(ufunc, CT_NONE))
Bram Moolenaar648594e2021-07-11 17:55:01 +0200929 compile_def_function(ufunc, FALSE, CT_NONE, cctx);
930#endif
931
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200932 if (is_global)
933 {
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000934 r = generate_NEWFUNC(cctx, lambda_name, func_name);
935 func_name = NULL;
936 lambda_name = NULL;
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200937 }
938 else
939 {
940 // Define a local variable for the function reference.
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000941 lvar_T *lvar = reserve_local(cctx, func_name, name_end - name_start,
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200942 TRUE, ufunc->uf_func_type);
Bram Moolenaare8211a32020-10-09 22:04:29 +0200943
Bram Moolenaareef21022020-08-01 22:16:43 +0200944 if (lvar == NULL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100945 goto theend;
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200946 if (generate_FUNCREF(cctx, ufunc) == FAIL)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100947 goto theend;
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200948 r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
949 }
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100950
951theend:
952 vim_free(lambda_name);
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +0000953 vim_free(func_name);
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200954 return r == FAIL ? NULL : (char_u *)"";
Bram Moolenaar04b12692020-05-04 23:24:44 +0200955}
956
957/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100958 * Return the length of an assignment operator, or zero if there isn't one.
959 */
960 int
961assignment_len(char_u *p, int *heredoc)
962{
963 if (*p == '=')
964 {
965 if (p[1] == '<' && p[2] == '<')
966 {
967 *heredoc = TRUE;
968 return 3;
969 }
970 return 1;
971 }
972 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=')
973 return 2;
974 if (STRNCMP(p, "..=", 3) == 0)
975 return 3;
976 return 0;
977}
978
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100979/*
Bram Moolenaar1cc2a942020-05-10 19:10:31 +0200980 * Generate the load instruction for "name".
981 */
982 static void
983generate_loadvar(
984 cctx_T *cctx,
985 assign_dest_T dest,
986 char_u *name,
987 lvar_T *lvar,
988 type_T *type)
989{
990 switch (dest)
991 {
992 case dest_option:
Bram Moolenaardcb53be2021-12-09 14:23:43 +0000993 case dest_func_option:
Bram Moolenaar1cc2a942020-05-10 19:10:31 +0200994 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
995 break;
996 case dest_global:
Bram Moolenaar03290b82020-12-19 16:30:44 +0100997 if (vim_strchr(name, AUTOLOAD_CHAR) == NULL)
998 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
999 else
1000 generate_LOAD(cctx, ISN_LOADAUTO, 0, name, type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001001 break;
1002 case dest_buffer:
1003 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
1004 break;
1005 case dest_window:
1006 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
1007 break;
1008 case dest_tab:
1009 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
1010 break;
1011 case dest_script:
1012 compile_load_scriptvar(cctx,
1013 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
1014 break;
1015 case dest_env:
1016 // Include $ in the name here
1017 generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
1018 break;
1019 case dest_reg:
1020 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string);
1021 break;
1022 case dest_vimvar:
1023 generate_LOADV(cctx, name + 2, TRUE);
1024 break;
1025 case dest_local:
Bram Moolenaarab360522021-01-10 14:02:28 +01001026 if (lvar->lv_from_outer > 0)
1027 generate_LOADOUTER(cctx, lvar->lv_idx, lvar->lv_from_outer,
1028 type);
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001029 else
1030 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
1031 break;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001032 case dest_expr:
1033 // list or dict value should already be on the stack.
1034 break;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001035 }
1036}
1037
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001038/*
1039 * Skip over "[expr]" or ".member".
1040 * Does not check for any errors.
1041 */
1042 static char_u *
1043skip_index(char_u *start)
1044{
1045 char_u *p = start;
1046
1047 if (*p == '[')
1048 {
1049 p = skipwhite(p + 1);
1050 (void)skip_expr(&p, NULL);
1051 p = skipwhite(p);
1052 if (*p == ']')
1053 return p + 1;
1054 return p;
1055 }
1056 // if (*p == '.')
1057 return to_name_end(p + 1, TRUE);
1058}
1059
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001060 void
1061vim9_declare_error(char_u *name)
1062{
1063 char *scope = "";
1064
1065 switch (*name)
1066 {
Bram Moolenaar7fe87552020-06-21 20:38:28 +02001067 case 'g': scope = _("global"); break;
1068 case 'b': scope = _("buffer"); break;
1069 case 'w': scope = _("window"); break;
1070 case 't': scope = _("tab"); break;
1071 case 'v': scope = "v:"; break;
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02001072 case '$': semsg(_(e_cannot_declare_an_environment_variable), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001073 return;
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001074 case '&': semsg(_(e_cannot_declare_an_option), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001075 return;
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02001076 case '@': semsg(_(e_cannot_declare_a_register_str), name);
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +02001077 return;
Bram Moolenaar7fe87552020-06-21 20:38:28 +02001078 default: return;
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001079 }
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02001080 semsg(_(e_cannot_declare_a_scope_variable), scope, name);
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001081}
1082
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001083/*
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001084 * For one assignment figure out the type of destination. Return it in "dest".
1085 * When not recognized "dest" is not set.
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001086 * For an option "option_scope" is set.
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001087 * For a v:var "vimvaridx" is set.
1088 * "type" is set to the destination type if known, unchanted otherwise.
1089 * Return FAIL if an error message was given.
1090 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001091 int
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001092get_var_dest(
1093 char_u *name,
1094 assign_dest_T *dest,
1095 int cmdidx,
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001096 int *option_scope,
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001097 int *vimvaridx,
1098 type_T **type,
1099 cctx_T *cctx)
1100{
1101 char_u *p;
1102
1103 if (*name == '&')
1104 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001105 int cc;
1106 long numval;
1107 getoption_T opt_type;
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001108 int opt_p_flags;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001109
1110 *dest = dest_option;
1111 if (cmdidx == CMD_final || cmdidx == CMD_const)
1112 {
Bram Moolenaard82a47d2022-01-05 20:24:39 +00001113 emsg(_(e_cannot_lock_option));
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001114 return FAIL;
1115 }
1116 p = name;
Yegappan Lakshmanan64095532021-12-06 11:03:55 +00001117 p = find_option_end(&p, option_scope);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001118 if (p == NULL)
1119 {
1120 // cannot happen?
Bram Moolenaar108010a2021-06-27 22:03:33 +02001121 emsg(_(e_unexpected_characters_in_assignment));
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001122 return FAIL;
1123 }
1124 cc = *p;
1125 *p = NUL;
1126 opt_type = get_option_value(skip_option_env_lead(name),
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001127 &numval, NULL, &opt_p_flags, *option_scope);
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001128 *p = cc;
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001129 switch (opt_type)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001130 {
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001131 case gov_unknown:
Bram Moolenaare1242042021-12-16 20:56:57 +00001132 semsg(_(e_unknown_option_str), name);
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001133 return FAIL;
1134 case gov_string:
1135 case gov_hidden_string:
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001136 if (opt_p_flags & P_FUNC)
1137 {
1138 // might be a Funcref, check the type later
1139 *type = &t_any;
1140 *dest = dest_func_option;
1141 }
1142 else
1143 {
1144 *type = &t_string;
1145 }
Bram Moolenaardd1f4262020-12-31 17:41:01 +01001146 break;
1147 case gov_bool:
1148 case gov_hidden_bool:
1149 *type = &t_bool;
1150 break;
1151 case gov_number:
1152 case gov_hidden_number:
1153 *type = &t_number;
1154 break;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001155 }
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001156 }
1157 else if (*name == '$')
1158 {
1159 *dest = dest_env;
1160 *type = &t_string;
1161 }
1162 else if (*name == '@')
1163 {
Bram Moolenaar13e45d12021-06-26 13:28:35 +02001164 if (name[1] != '@'
1165 && (!valid_yank_reg(name[1], FALSE) || name[1] == '.'))
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001166 {
1167 emsg_invreg(name[1]);
1168 return FAIL;
1169 }
1170 *dest = dest_reg;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02001171 *type = name[1] == '#' ? &t_number_or_string : &t_string;
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001172 }
1173 else if (STRNCMP(name, "g:", 2) == 0)
1174 {
1175 *dest = dest_global;
1176 }
1177 else if (STRNCMP(name, "b:", 2) == 0)
1178 {
1179 *dest = dest_buffer;
1180 }
1181 else if (STRNCMP(name, "w:", 2) == 0)
1182 {
1183 *dest = dest_window;
1184 }
1185 else if (STRNCMP(name, "t:", 2) == 0)
1186 {
1187 *dest = dest_tab;
1188 }
1189 else if (STRNCMP(name, "v:", 2) == 0)
1190 {
1191 typval_T *vtv;
1192 int di_flags;
1193
1194 *vimvaridx = find_vim_var(name + 2, &di_flags);
1195 if (*vimvaridx < 0)
1196 {
1197 semsg(_(e_variable_not_found_str), name);
1198 return FAIL;
1199 }
1200 // We use the current value of "sandbox" here, is that OK?
1201 if (var_check_ro(di_flags, name, FALSE))
1202 return FAIL;
1203 *dest = dest_vimvar;
1204 vtv = get_vim_var_tv(*vimvaridx);
1205 *type = typval2type_vimvar(vtv, cctx->ctx_type_list);
1206 }
1207 return OK;
1208}
1209
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001210 static int
Bram Moolenaar752fc692021-01-04 21:57:11 +01001211is_decl_command(int cmdidx)
1212{
1213 return cmdidx == CMD_let || cmdidx == CMD_var
1214 || cmdidx == CMD_final || cmdidx == CMD_const;
1215}
1216
1217/*
1218 * Figure out the LHS type and other properties for an assignment or one item
1219 * of ":unlet" with an index.
1220 * Returns OK or FAIL.
1221 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001222 int
Bram Moolenaar752fc692021-01-04 21:57:11 +01001223compile_lhs(
1224 char_u *var_start,
1225 lhs_T *lhs,
1226 int cmdidx,
1227 int heredoc,
1228 int oplen,
1229 cctx_T *cctx)
1230{
1231 char_u *var_end;
1232 int is_decl = is_decl_command(cmdidx);
1233
1234 CLEAR_POINTER(lhs);
1235 lhs->lhs_dest = dest_local;
1236 lhs->lhs_vimvaridx = -1;
1237 lhs->lhs_scriptvar_idx = -1;
1238
1239 // "dest_end" is the end of the destination, including "[expr]" or
1240 // ".name".
1241 // "var_end" is the end of the variable/option/etc. name.
1242 lhs->lhs_dest_end = skip_var_one(var_start, FALSE);
1243 if (*var_start == '@')
1244 var_end = var_start + 2;
1245 else
1246 {
1247 // skip over the leading "&", "&l:", "&g:" and "$"
1248 var_end = skip_option_env_lead(var_start);
1249 var_end = to_name_end(var_end, TRUE);
1250 }
1251
1252 // "a: type" is declaring variable "a" with a type, not dict "a:".
1253 if (is_decl && lhs->lhs_dest_end == var_start + 2
1254 && lhs->lhs_dest_end[-1] == ':')
1255 --lhs->lhs_dest_end;
1256 if (is_decl && var_end == var_start + 2 && var_end[-1] == ':')
1257 --var_end;
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001258 lhs->lhs_end = lhs->lhs_dest_end;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001259
1260 // compute the length of the destination without "[expr]" or ".name"
1261 lhs->lhs_varlen = var_end - var_start;
Bram Moolenaar753bcf82021-04-21 14:24:24 +02001262 lhs->lhs_varlen_total = lhs->lhs_varlen;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001263 lhs->lhs_name = vim_strnsave(var_start, lhs->lhs_varlen);
1264 if (lhs->lhs_name == NULL)
1265 return FAIL;
Bram Moolenaar08251752021-01-11 21:20:18 +01001266
1267 if (lhs->lhs_dest_end > var_start + lhs->lhs_varlen)
1268 // Something follows after the variable: "var[idx]" or "var.key".
1269 lhs->lhs_has_index = TRUE;
1270
Bram Moolenaar752fc692021-01-04 21:57:11 +01001271 if (heredoc)
1272 lhs->lhs_type = &t_list_string;
1273 else
1274 lhs->lhs_type = &t_any;
1275
1276 if (cctx->ctx_skip != SKIP_YES)
1277 {
1278 int declare_error = FALSE;
1279
1280 if (get_var_dest(lhs->lhs_name, &lhs->lhs_dest, cmdidx,
1281 &lhs->lhs_opt_flags, &lhs->lhs_vimvaridx,
1282 &lhs->lhs_type, cctx) == FAIL)
1283 return FAIL;
Bram Moolenaard877a572021-04-01 19:42:48 +02001284 if (lhs->lhs_dest != dest_local
1285 && cmdidx != CMD_const && cmdidx != CMD_final)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001286 {
1287 // Specific kind of variable recognized.
1288 declare_error = is_decl;
1289 }
1290 else
1291 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01001292 // No specific kind of variable recognized, just a name.
Bram Moolenaard0edaf92021-05-28 21:06:08 +02001293 if (check_reserved_name(lhs->lhs_name) == FAIL)
1294 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001295
1296 if (lookup_local(var_start, lhs->lhs_varlen,
1297 &lhs->lhs_local_lvar, cctx) == OK)
1298 lhs->lhs_lvar = &lhs->lhs_local_lvar;
1299 else
1300 {
1301 CLEAR_FIELD(lhs->lhs_arg_lvar);
1302 if (arg_exists(var_start, lhs->lhs_varlen,
1303 &lhs->lhs_arg_lvar.lv_idx, &lhs->lhs_arg_lvar.lv_type,
1304 &lhs->lhs_arg_lvar.lv_from_outer, cctx) == OK)
1305 {
1306 if (is_decl)
1307 {
1308 semsg(_(e_str_is_used_as_argument), lhs->lhs_name);
1309 return FAIL;
1310 }
1311 lhs->lhs_lvar = &lhs->lhs_arg_lvar;
1312 }
1313 }
1314 if (lhs->lhs_lvar != NULL)
1315 {
1316 if (is_decl)
1317 {
1318 semsg(_(e_variable_already_declared), lhs->lhs_name);
1319 return FAIL;
1320 }
1321 }
1322 else
1323 {
1324 int script_namespace = lhs->lhs_varlen > 1
1325 && STRNCMP(var_start, "s:", 2) == 0;
1326 int script_var = (script_namespace
1327 ? script_var_exists(var_start + 2, lhs->lhs_varlen - 2,
Bram Moolenaardce24412022-02-08 20:35:30 +00001328 cctx, NULL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001329 : script_var_exists(var_start, lhs->lhs_varlen,
Bram Moolenaardce24412022-02-08 20:35:30 +00001330 cctx, NULL)) == OK;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001331 imported_T *import =
Bram Moolenaar4b1d9632022-02-13 21:51:08 +00001332 find_imported(var_start, lhs->lhs_varlen, FALSE);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001333
1334 if (script_namespace || script_var || import != NULL)
1335 {
1336 char_u *rawname = lhs->lhs_name
1337 + (lhs->lhs_name[1] == ':' ? 2 : 0);
1338
1339 if (is_decl)
1340 {
1341 if (script_namespace)
Bram Moolenaara749a422022-02-12 19:52:25 +00001342 semsg(_(e_cannot_declare_script_variable_in_function_str),
Bram Moolenaar752fc692021-01-04 21:57:11 +01001343 lhs->lhs_name);
1344 else
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001345 semsg(_(e_variable_already_declared_in_script_str),
Bram Moolenaar752fc692021-01-04 21:57:11 +01001346 lhs->lhs_name);
1347 return FAIL;
1348 }
1349 else if (cctx->ctx_ufunc->uf_script_ctx_version
1350 == SCRIPT_VERSION_VIM9
1351 && script_namespace
1352 && !script_var && import == NULL)
1353 {
1354 semsg(_(e_unknown_variable_str), lhs->lhs_name);
1355 return FAIL;
1356 }
1357
1358 lhs->lhs_dest = dest_script;
1359
1360 // existing script-local variables should have a type
1361 lhs->lhs_scriptvar_sid = current_sctx.sc_sid;
1362 if (import != NULL)
Bram Moolenaard5f400c2022-01-06 21:10:28 +00001363 {
1364 char_u *dot = vim_strchr(var_start, '.');
1365 char_u *p;
1366
1367 // for an import the name is what comes after the dot
1368 if (dot == NULL)
1369 {
1370 semsg(_(e_no_dot_after_imported_name_str),
1371 var_start);
1372 return FAIL;
1373 }
1374 p = skipwhite(dot + 1);
1375 var_end = to_name_end(p, TRUE);
1376 if (var_end == p)
1377 {
1378 semsg(_(e_missing_name_after_imported_name_str),
1379 var_start);
1380 return FAIL;
1381 }
1382 vim_free(lhs->lhs_name);
1383 lhs->lhs_varlen = var_end - p;
1384 lhs->lhs_name = vim_strnsave(p, lhs->lhs_varlen);
1385 if (lhs->lhs_name == NULL)
1386 return FAIL;
1387 rawname = lhs->lhs_name;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001388 lhs->lhs_scriptvar_sid = import->imp_sid;
Bram Moolenaard5f400c2022-01-06 21:10:28 +00001389 // TODO: where do we check this name is exported?
1390
1391 // Check if something follows: "exp.var[idx]" or
1392 // "exp.var.key".
1393 lhs->lhs_has_index = lhs->lhs_dest_end
1394 > skipwhite(var_end);
1395 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001396 if (SCRIPT_ID_VALID(lhs->lhs_scriptvar_sid))
1397 {
Bram Moolenaar08251752021-01-11 21:20:18 +01001398 // Check writable only when no index follows.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001399 lhs->lhs_scriptvar_idx = get_script_item_idx(
Bram Moolenaar08251752021-01-11 21:20:18 +01001400 lhs->lhs_scriptvar_sid, rawname,
1401 lhs->lhs_has_index ? ASSIGN_FINAL : ASSIGN_CONST,
Bram Moolenaarb6a138e2022-02-08 21:17:22 +00001402 cctx, NULL);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001403 if (lhs->lhs_scriptvar_idx >= 0)
1404 {
1405 scriptitem_T *si = SCRIPT_ITEM(
1406 lhs->lhs_scriptvar_sid);
1407 svar_T *sv =
1408 ((svar_T *)si->sn_var_vals.ga_data)
1409 + lhs->lhs_scriptvar_idx;
1410 lhs->lhs_type = sv->sv_type;
1411 }
1412 }
1413 }
Bram Moolenaardce24412022-02-08 20:35:30 +00001414 else if (check_defined(var_start, lhs->lhs_varlen, cctx,
1415 NULL, FALSE) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001416 return FAIL;
1417 }
1418 }
1419
1420 if (declare_error)
1421 {
1422 vim9_declare_error(lhs->lhs_name);
1423 return FAIL;
1424 }
1425 }
1426
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001427 // handle "a:name" as a name, not index "name" in "a"
Bram Moolenaar752fc692021-01-04 21:57:11 +01001428 if (lhs->lhs_varlen > 1 || var_start[lhs->lhs_varlen] != ':')
1429 var_end = lhs->lhs_dest_end;
1430
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001431 if (lhs->lhs_dest != dest_option && lhs->lhs_dest != dest_func_option)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001432 {
1433 if (is_decl && *var_end == ':')
1434 {
1435 char_u *p;
1436
1437 // parse optional type: "let var: type = expr"
1438 if (!VIM_ISWHITE(var_end[1]))
1439 {
Bram Moolenaarc3fc75d2021-02-07 15:28:09 +01001440 semsg(_(e_white_space_required_after_str_str), ":", var_end);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001441 return FAIL;
1442 }
1443 p = skipwhite(var_end + 1);
1444 lhs->lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE);
1445 if (lhs->lhs_type == NULL)
1446 return FAIL;
1447 lhs->lhs_has_type = TRUE;
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001448 lhs->lhs_end = p;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001449 }
1450 else if (lhs->lhs_lvar != NULL)
1451 lhs->lhs_type = lhs->lhs_lvar->lv_type;
1452 }
1453
Bram Moolenaare42939a2021-04-05 17:11:17 +02001454 if (oplen == 3 && !heredoc
1455 && lhs->lhs_dest != dest_global
1456 && !lhs->lhs_has_index
1457 && lhs->lhs_type->tt_type != VAR_STRING
1458 && lhs->lhs_type->tt_type != VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001459 {
1460 emsg(_(e_can_only_concatenate_to_string));
1461 return FAIL;
1462 }
1463
1464 if (lhs->lhs_lvar == NULL && lhs->lhs_dest == dest_local
1465 && cctx->ctx_skip != SKIP_YES)
1466 {
1467 if (oplen > 1 && !heredoc)
1468 {
1469 // +=, /=, etc. require an existing variable
1470 semsg(_(e_cannot_use_operator_on_new_variable), lhs->lhs_name);
1471 return FAIL;
1472 }
1473 if (!is_decl)
1474 {
1475 semsg(_(e_unknown_variable_str), lhs->lhs_name);
1476 return FAIL;
1477 }
1478
Bram Moolenaar3f327882021-03-17 20:56:38 +01001479 // Check the name is valid for a funcref.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001480 if ((lhs->lhs_type->tt_type == VAR_FUNC
1481 || lhs->lhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01001482 && var_wrong_func_name(lhs->lhs_name, TRUE))
Bram Moolenaar752fc692021-01-04 21:57:11 +01001483 return FAIL;
Bram Moolenaar3f327882021-03-17 20:56:38 +01001484
1485 // New local variable.
Bram Moolenaar752fc692021-01-04 21:57:11 +01001486 lhs->lhs_lvar = reserve_local(cctx, var_start, lhs->lhs_varlen,
1487 cmdidx == CMD_final || cmdidx == CMD_const, lhs->lhs_type);
1488 if (lhs->lhs_lvar == NULL)
1489 return FAIL;
1490 lhs->lhs_new_local = TRUE;
1491 }
1492
1493 lhs->lhs_member_type = lhs->lhs_type;
Bram Moolenaar08251752021-01-11 21:20:18 +01001494 if (lhs->lhs_has_index)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001495 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001496 char_u *after = var_start + lhs->lhs_varlen;
1497 char_u *p;
1498
Bram Moolenaar752fc692021-01-04 21:57:11 +01001499 // Something follows after the variable: "var[idx]" or "var.key".
Bram Moolenaar752fc692021-01-04 21:57:11 +01001500 if (is_decl)
1501 {
1502 emsg(_(e_cannot_use_index_when_declaring_variable));
1503 return FAIL;
1504 }
1505
Bram Moolenaarc750d912021-11-29 22:02:12 +00001506 // Now: var_start[lhs->lhs_varlen] is '[' or '.'
1507 // Only the last index is used below, if there are others
1508 // before it generate code for the expression. Thus for
1509 // "ll[1][2]" the expression is "ll[1]" and "[2]" is the index.
1510 for (;;)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001511 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001512 p = skip_index(after);
1513 if (*p != '[' && *p != '.')
Bram Moolenaar752fc692021-01-04 21:57:11 +01001514 {
Bram Moolenaarc750d912021-11-29 22:02:12 +00001515 lhs->lhs_varlen_total = p - var_start;
1516 break;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001517 }
Bram Moolenaarc750d912021-11-29 22:02:12 +00001518 after = p;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001519 }
Bram Moolenaarc750d912021-11-29 22:02:12 +00001520 if (after > var_start + lhs->lhs_varlen)
1521 {
1522 lhs->lhs_varlen = after - var_start;
1523 lhs->lhs_dest = dest_expr;
1524 // We don't know the type before evaluating the expression,
1525 // use "any" until then.
1526 lhs->lhs_type = &t_any;
1527 }
1528
1529 if (lhs->lhs_type->tt_member == NULL)
1530 lhs->lhs_member_type = &t_any;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001531 else
Bram Moolenaarc750d912021-11-29 22:02:12 +00001532 lhs->lhs_member_type = lhs->lhs_type->tt_member;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001533 }
1534 return OK;
1535}
1536
1537/*
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001538 * Figure out the LHS and check a few errors.
1539 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001540 int
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02001541compile_assign_lhs(
1542 char_u *var_start,
1543 lhs_T *lhs,
1544 int cmdidx,
1545 int is_decl,
1546 int heredoc,
1547 int oplen,
1548 cctx_T *cctx)
1549{
1550 if (compile_lhs(var_start, lhs, cmdidx, heredoc, oplen, cctx) == FAIL)
1551 return FAIL;
1552
1553 if (!lhs->lhs_has_index && lhs->lhs_lvar == &lhs->lhs_arg_lvar)
1554 {
1555 semsg(_(e_cannot_assign_to_argument), lhs->lhs_name);
1556 return FAIL;
1557 }
1558 if (!is_decl && lhs->lhs_lvar != NULL
1559 && lhs->lhs_lvar->lv_const && !lhs->lhs_has_index)
1560 {
1561 semsg(_(e_cannot_assign_to_constant), lhs->lhs_name);
1562 return FAIL;
1563 }
1564 return OK;
1565}
1566
1567/*
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02001568 * Return TRUE if "lhs" has a range index: "[expr : expr]".
1569 */
1570 static int
1571has_list_index(char_u *idx_start, cctx_T *cctx)
1572{
1573 char_u *p = idx_start;
1574 int save_skip;
1575
1576 if (*p != '[')
1577 return FALSE;
1578
1579 p = skipwhite(p + 1);
1580 if (*p == ':')
1581 return TRUE;
1582
1583 save_skip = cctx->ctx_skip;
1584 cctx->ctx_skip = SKIP_YES;
1585 (void)compile_expr0(&p, cctx);
1586 cctx->ctx_skip = save_skip;
1587 return *skipwhite(p) == ':';
1588}
1589
1590/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02001591 * For an assignment with an index, compile the "idx" in "var[idx]" or "key" in
1592 * "var.key".
Bram Moolenaar752fc692021-01-04 21:57:11 +01001593 */
1594 static int
Bram Moolenaare42939a2021-04-05 17:11:17 +02001595compile_assign_index(
Bram Moolenaar752fc692021-01-04 21:57:11 +01001596 char_u *var_start,
1597 lhs_T *lhs,
Bram Moolenaare42939a2021-04-05 17:11:17 +02001598 int *range,
Bram Moolenaar752fc692021-01-04 21:57:11 +01001599 cctx_T *cctx)
1600{
Bram Moolenaar752fc692021-01-04 21:57:11 +01001601 size_t varlen = lhs->lhs_varlen;
Bram Moolenaare42939a2021-04-05 17:11:17 +02001602 char_u *p;
1603 int r = OK;
Bram Moolenaar68452172021-04-12 21:21:02 +02001604 int need_white_before = TRUE;
1605 int empty_second;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001606
Bram Moolenaar752fc692021-01-04 21:57:11 +01001607 p = var_start + varlen;
1608 if (*p == '[')
1609 {
1610 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02001611 if (*p == ':')
1612 {
1613 // empty first index, push zero
1614 r = generate_PUSHNR(cctx, 0);
1615 need_white_before = FALSE;
1616 }
1617 else
1618 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001619
1620 if (r == OK && *skipwhite(p) == ':')
1621 {
1622 // unlet var[idx : idx]
Bram Moolenaar68452172021-04-12 21:21:02 +02001623 // blob[idx : idx] = value
Bram Moolenaare42939a2021-04-05 17:11:17 +02001624 *range = TRUE;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001625 p = skipwhite(p);
Bram Moolenaar68452172021-04-12 21:21:02 +02001626 empty_second = *skipwhite(p + 1) == ']';
1627 if ((need_white_before && !IS_WHITE_OR_NUL(p[-1]))
1628 || (!empty_second && !IS_WHITE_OR_NUL(p[1])))
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001629 {
1630 semsg(_(e_white_space_required_before_and_after_str_at_str),
1631 ":", p);
1632 return FAIL;
1633 }
1634 p = skipwhite(p + 1);
Bram Moolenaar68452172021-04-12 21:21:02 +02001635 if (*p == ']')
1636 // empty second index, push "none"
1637 r = generate_PUSHSPEC(cctx, VVAL_NONE);
1638 else
1639 r = compile_expr0(&p, cctx);
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001640 }
1641
Bram Moolenaar752fc692021-01-04 21:57:11 +01001642 if (r == OK && *skipwhite(p) != ']')
1643 {
1644 // this should not happen
Bram Moolenaare1242042021-12-16 20:56:57 +00001645 emsg(_(e_missing_closing_square_brace));
Bram Moolenaar752fc692021-01-04 21:57:11 +01001646 r = FAIL;
1647 }
1648 }
1649 else // if (*p == '.')
1650 {
1651 char_u *key_end = to_name_end(p + 1, TRUE);
1652 char_u *key = vim_strnsave(p + 1, key_end - p - 1);
1653
Zdenek Dohnal9fe17d42021-08-04 22:30:52 +02001654 r = generate_PUSHS(cctx, &key);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001655 }
Bram Moolenaare42939a2021-04-05 17:11:17 +02001656 return r;
1657}
1658
1659/*
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001660 * For a LHS with an index, load the variable to be indexed.
1661 */
1662 static int
1663compile_load_lhs(
1664 lhs_T *lhs,
1665 char_u *var_start,
1666 type_T *rhs_type,
1667 cctx_T *cctx)
1668{
1669 if (lhs->lhs_dest == dest_expr)
1670 {
1671 size_t varlen = lhs->lhs_varlen;
1672 int c = var_start[varlen];
Bram Moolenaare97976b2021-08-01 13:17:17 +02001673 int lines_len = cctx->ctx_ufunc->uf_lines.ga_len;
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001674 char_u *p = var_start;
Bram Moolenaare97976b2021-08-01 13:17:17 +02001675 int res;
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001676
Bram Moolenaare97976b2021-08-01 13:17:17 +02001677 // Evaluate "ll[expr]" of "ll[expr][idx]". End the line with a NUL and
1678 // limit the lines array length to avoid skipping to a following line.
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001679 var_start[varlen] = NUL;
Bram Moolenaare97976b2021-08-01 13:17:17 +02001680 cctx->ctx_ufunc->uf_lines.ga_len = cctx->ctx_lnum + 1;
1681 res = compile_expr0(&p, cctx);
1682 var_start[varlen] = c;
1683 cctx->ctx_ufunc->uf_lines.ga_len = lines_len;
1684 if (res == FAIL || p != var_start + varlen)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001685 {
1686 // this should not happen
Bram Moolenaare97976b2021-08-01 13:17:17 +02001687 if (res != FAIL)
Bram Moolenaare1242042021-12-16 20:56:57 +00001688 emsg(_(e_missing_closing_square_brace));
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001689 return FAIL;
1690 }
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001691
Bram Moolenaar078a4612022-01-04 15:17:03 +00001692 lhs->lhs_type = cctx->ctx_type_stack.ga_len == 0 ? &t_void
1693 : get_type_on_stack(cctx, 0);
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001694 // now we can properly check the type
1695 if (rhs_type != NULL && lhs->lhs_type->tt_member != NULL
1696 && rhs_type != &t_void
1697 && need_type(rhs_type, lhs->lhs_type->tt_member, -2, 0, cctx,
1698 FALSE, FALSE) == FAIL)
1699 return FAIL;
1700 }
1701 else
1702 generate_loadvar(cctx, lhs->lhs_dest, lhs->lhs_name,
1703 lhs->lhs_lvar, lhs->lhs_type);
1704 return OK;
1705}
1706
1707/*
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001708 * Produce code for loading "lhs" and also take care of an index.
1709 * Return OK/FAIL.
1710 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001711 int
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001712compile_load_lhs_with_index(lhs_T *lhs, char_u *var_start, cctx_T *cctx)
1713{
1714 compile_load_lhs(lhs, var_start, NULL, cctx);
1715
1716 if (lhs->lhs_has_index)
1717 {
1718 int range = FALSE;
1719
1720 // Get member from list or dict. First compile the
1721 // index value.
1722 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
1723 return FAIL;
1724 if (range)
1725 {
1726 semsg(_(e_cannot_use_range_with_assignment_operator_str),
1727 var_start);
1728 return FAIL;
1729 }
1730
1731 // Get the member.
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02001732 if (compile_member(FALSE, NULL, cctx) == FAIL)
Bram Moolenaara369c3d2021-04-21 16:00:10 +02001733 return FAIL;
1734 }
1735 return OK;
1736}
1737
1738/*
Bram Moolenaare42939a2021-04-05 17:11:17 +02001739 * Assignment to a list or dict member, or ":unlet" for the item, using the
1740 * information in "lhs".
1741 * Returns OK or FAIL.
1742 */
Bram Moolenaardc7c3662021-12-20 15:04:29 +00001743 int
Bram Moolenaare42939a2021-04-05 17:11:17 +02001744compile_assign_unlet(
1745 char_u *var_start,
1746 lhs_T *lhs,
1747 int is_assign,
1748 type_T *rhs_type,
1749 cctx_T *cctx)
1750{
Bram Moolenaare42939a2021-04-05 17:11:17 +02001751 vartype_T dest_type;
Bram Moolenaare42939a2021-04-05 17:11:17 +02001752 int range = FALSE;
1753
Bram Moolenaar68452172021-04-12 21:21:02 +02001754 if (compile_assign_index(var_start, lhs, &range, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001755 return FAIL;
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02001756 if (is_assign && range
1757 && lhs->lhs_type->tt_type != VAR_LIST
1758 && lhs->lhs_type != &t_blob
1759 && lhs->lhs_type != &t_any)
Bram Moolenaar68452172021-04-12 21:21:02 +02001760 {
1761 semsg(_(e_cannot_use_range_with_assignment_str), var_start);
1762 return FAIL;
1763 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001764
1765 if (lhs->lhs_type == &t_any)
1766 {
1767 // Index on variable of unknown type: check at runtime.
1768 dest_type = VAR_ANY;
1769 }
1770 else
1771 {
1772 dest_type = lhs->lhs_type->tt_type;
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001773 if (dest_type == VAR_DICT && range)
1774 {
1775 emsg(e_cannot_use_range_with_dictionary);
1776 return FAIL;
1777 }
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02001778 if (dest_type == VAR_DICT
1779 && may_generate_2STRING(-1, FALSE, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001780 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02001781 if (dest_type == VAR_LIST || dest_type == VAR_BLOB)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001782 {
Bram Moolenaar51e93322021-04-17 20:44:56 +02001783 type_T *type;
1784
1785 if (range)
1786 {
Bram Moolenaar078a4612022-01-04 15:17:03 +00001787 type = get_type_on_stack(cctx, 1);
Bram Moolenaar51e93322021-04-17 20:44:56 +02001788 if (need_type(type, &t_number,
1789 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001790 return FAIL;
Bram Moolenaar51e93322021-04-17 20:44:56 +02001791 }
Bram Moolenaar078a4612022-01-04 15:17:03 +00001792 type = get_type_on_stack(cctx, 0);
Bram Moolenaar63cb6562021-07-20 22:21:59 +02001793 if ((dest_type != VAR_BLOB && type != &t_special)
Bram Moolenaar51e93322021-04-17 20:44:56 +02001794 && need_type(type, &t_number,
1795 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001796 return FAIL;
1797 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001798 }
1799
1800 // Load the dict or list. On the stack we then have:
1801 // - value (for assignment, not for :unlet)
1802 // - index
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001803 // - for [a : b] second index
Bram Moolenaar752fc692021-01-04 21:57:11 +01001804 // - variable
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001805 if (compile_load_lhs(lhs, var_start, rhs_type, cctx) == FAIL)
1806 return FAIL;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001807
Bram Moolenaar68452172021-04-12 21:21:02 +02001808 if (dest_type == VAR_LIST || dest_type == VAR_DICT
1809 || dest_type == VAR_BLOB || dest_type == VAR_ANY)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001810 {
1811 if (is_assign)
1812 {
Bram Moolenaar68452172021-04-12 21:21:02 +02001813 if (range)
1814 {
1815 if (generate_instr_drop(cctx, ISN_STORERANGE, 4) == NULL)
1816 return FAIL;
1817 }
1818 else
1819 {
1820 isn_T *isn = generate_instr_drop(cctx, ISN_STOREINDEX, 3);
Bram Moolenaar752fc692021-01-04 21:57:11 +01001821
Bram Moolenaar68452172021-04-12 21:21:02 +02001822 if (isn == NULL)
1823 return FAIL;
1824 isn->isn_arg.vartype = dest_type;
1825 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001826 }
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001827 else if (range)
1828 {
1829 if (generate_instr_drop(cctx, ISN_UNLETRANGE, 3) == NULL)
1830 return FAIL;
1831 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01001832 else
1833 {
1834 if (generate_instr_drop(cctx, ISN_UNLETINDEX, 2) == NULL)
1835 return FAIL;
1836 }
1837 }
1838 else
1839 {
1840 emsg(_(e_indexable_type_required));
1841 return FAIL;
1842 }
1843
1844 return OK;
1845}
1846
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001847/*
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001848 * Compile declaration and assignment:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001849 * "let name"
1850 * "var name = expr"
1851 * "final name = expr"
1852 * "const name = expr"
1853 * "name = expr"
1854 * "arg" points to "name".
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001855 * "++arg" and "--arg"
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001856 * Return NULL for an error.
1857 * Return "arg" if it does not look like a variable list.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001858 */
1859 static char_u *
1860compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
1861{
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001862 char_u *var_start;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001863 char_u *p;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001864 char_u *end = arg;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001865 char_u *ret = NULL;
1866 int var_count = 0;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001867 int var_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001868 int semicolon = 0;
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02001869 int did_generate_slice = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001870 garray_T *instr = &cctx->ctx_instr;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001871 char_u *op;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001872 int oplen = 0;
1873 int heredoc = FALSE;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001874 int incdec = FALSE;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001875 type_T *rhs_type = &t_any;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001876 char_u *sp;
Bram Moolenaar752fc692021-01-04 21:57:11 +01001877 int is_decl = is_decl_command(cmdidx);
1878 lhs_T lhs;
Bram Moolenaar77709b12021-04-03 21:01:01 +02001879 long start_lnum = SOURCING_LNUM;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001880
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001881 // Skip over the "var" or "[var, var]" to get to any "=".
1882 p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE);
1883 if (p == NULL)
1884 return *arg == '[' ? arg : NULL;
1885
Bram Moolenaar752fc692021-01-04 21:57:11 +01001886 lhs.lhs_name = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001887
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001888 sp = p;
1889 p = skipwhite(p);
1890 op = p;
1891 oplen = assignment_len(p, &heredoc);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001892
1893 if (var_count > 0 && oplen == 0)
1894 // can be something like "[1, 2]->func()"
1895 return arg;
1896
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001897 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !IS_WHITE_OR_NUL(op[oplen])))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001898 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001899 error_white_both(op, oplen);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001900 return NULL;
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001901 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001902 if (eap->cmdidx == CMD_increment || eap->cmdidx == CMD_decrement)
1903 {
Bram Moolenaar22480d12021-06-25 21:31:09 +02001904 if (VIM_ISWHITE(eap->cmd[2]))
1905 {
1906 semsg(_(e_no_white_space_allowed_after_str_str),
1907 eap->cmdidx == CMD_increment ? "++" : "--", eap->cmd);
1908 return NULL;
1909 }
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02001910 op = (char_u *)(eap->cmdidx == CMD_increment ? "+=" : "-=");
1911 oplen = 2;
1912 incdec = TRUE;
1913 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001914
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001915 if (heredoc)
1916 {
1917 list_T *l;
1918 listitem_T *li;
1919
1920 // [let] varname =<< [trim] {end}
Bram Moolenaar04b12692020-05-04 23:24:44 +02001921 eap->getline = exarg_getline;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001922 eap->cookie = cctx;
Bram Moolenaar6c2b7b82020-04-14 20:15:49 +02001923 l = heredoc_get(eap, op + 3, FALSE);
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001924 if (l == NULL)
1925 return NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001926
Bram Moolenaar078269b2020-09-21 20:35:55 +02001927 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001928 {
Bram Moolenaar078269b2020-09-21 20:35:55 +02001929 // Push each line and the create the list.
1930 FOR_ALL_LIST_ITEMS(l, li)
1931 {
Zdenek Dohnal9fe17d42021-08-04 22:30:52 +02001932 generate_PUSHS(cctx, &li->li_tv.vval.v_string);
Bram Moolenaar078269b2020-09-21 20:35:55 +02001933 li->li_tv.vval.v_string = NULL;
1934 }
1935 generate_NEWLIST(cctx, l->lv_len);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001936 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001937 list_free(l);
1938 p += STRLEN(p);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001939 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001940 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001941 else if (var_count > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001942 {
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001943 char_u *wp;
1944
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001945 // for "[var, var] = expr" evaluate the expression here, loop over the
1946 // list of variables below.
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001947 // A line break may follow the "=".
Bram Moolenaard25ec2c2020-03-30 21:05:45 +02001948
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001949 wp = op + oplen;
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001950 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001951 return FAIL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001952 if (compile_expr0(&p, cctx) == FAIL)
1953 return NULL;
1954 end = p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001955
Bram Moolenaar9b68c822020-06-18 19:31:08 +02001956 if (cctx->ctx_skip != SKIP_YES)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001957 {
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001958 type_T *stacktype;
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001959 int needed_list_len;
1960 int did_check = FALSE;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02001961
Bram Moolenaar078a4612022-01-04 15:17:03 +00001962 stacktype = cctx->ctx_type_stack.ga_len == 0 ? &t_void
1963 : get_type_on_stack(cctx, 0);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001964 if (stacktype->tt_type == VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001965 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001966 emsg(_(e_cannot_use_void_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001967 goto theend;
1968 }
Bram Moolenaar351ead02021-01-16 16:07:01 +01001969 if (need_type(stacktype, &t_list_any, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001970 FALSE, FALSE) == FAIL)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001971 goto theend;
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001972 // If a constant list was used we can check the length right here.
1973 needed_list_len = semicolon ? var_count - 1 : var_count;
1974 if (instr->ga_len > 0)
1975 {
1976 isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
1977
1978 if (isn->isn_type == ISN_NEWLIST)
1979 {
1980 did_check = TRUE;
1981 if (semicolon ? isn->isn_arg.number < needed_list_len
1982 : isn->isn_arg.number != needed_list_len)
1983 {
1984 semsg(_(e_expected_nr_items_but_got_nr),
Bram Moolenaarf60a6342022-01-15 14:16:37 +00001985 needed_list_len, (int)isn->isn_arg.number);
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00001986 goto theend;
1987 }
1988 }
1989 }
1990 if (!did_check)
1991 generate_CHECKLEN(cctx, needed_list_len, semicolon);
Bram Moolenaardc234ca2020-11-28 18:52:33 +01001992 if (stacktype->tt_member != NULL)
1993 rhs_type = stacktype->tt_member;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001994 }
1995 }
1996
1997 /*
1998 * Loop over variables in "[var, var] = expr".
1999 * For "var = expr" and "let var: type" this is done only once.
2000 */
2001 if (var_count > 0)
2002 var_start = skipwhite(arg + 1); // skip over the "["
2003 else
2004 var_start = arg;
2005 for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++)
2006 {
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002007 int instr_count = -1;
2008 int save_lnum;
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002009 int skip_store = FALSE;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002010
Bram Moolenaarf93bbd02021-04-10 22:35:43 +02002011 if (var_start[0] == '_' && !eval_isnamec(var_start[1]))
2012 {
2013 // Ignore underscore in "[a, _, b] = list".
2014 if (var_count > 0)
2015 {
2016 var_start = skipwhite(var_start + 2);
2017 continue;
2018 }
2019 emsg(_(e_cannot_use_underscore_here));
2020 goto theend;
2021 }
Bram Moolenaar752fc692021-01-04 21:57:11 +01002022 vim_free(lhs.lhs_name);
2023
2024 /*
2025 * Figure out the LHS type and other properties.
2026 */
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02002027 if (compile_assign_lhs(var_start, &lhs, cmdidx,
2028 is_decl, heredoc, oplen, cctx) == FAIL)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002029 goto theend;
Bram Moolenaar81530e32021-07-28 21:25:49 +02002030 if (heredoc)
2031 {
2032 SOURCING_LNUM = start_lnum;
2033 if (lhs.lhs_has_type
2034 && need_type(&t_list_string, lhs.lhs_type,
2035 -1, 0, cctx, FALSE, FALSE) == FAIL)
2036 goto theend;
2037 }
2038 else
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002039 {
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002040 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002041 {
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002042 if (oplen > 0 && var_count == 0)
2043 {
2044 // skip over the "=" and the expression
2045 p = skipwhite(op + oplen);
Bram Moolenaar169502f2021-04-21 12:19:35 +02002046 (void)compile_expr0(&p, cctx);
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002047 }
2048 }
2049 else if (oplen > 0)
2050 {
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002051 int is_const = FALSE;
Bram Moolenaar7f764942020-12-02 15:11:18 +01002052 char_u *wp;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002053
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02002054 // for "+=", "*=", "..=" etc. first load the current value
2055 if (*op != '='
2056 && compile_load_lhs_with_index(&lhs, var_start,
2057 cctx) == FAIL)
2058 goto theend;
2059
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002060 // For "var = expr" evaluate the expression.
2061 if (var_count == 0)
2062 {
2063 int r;
2064
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002065 // Compile the expression.
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002066 instr_count = instr->ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002067 if (incdec)
Bram Moolenaar21e51222020-12-04 12:43:29 +01002068 {
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002069 r = generate_PUSHNR(cctx, 1);
2070 }
2071 else
2072 {
2073 // Temporarily hide the new local variable here, it is
2074 // not available to this expression.
2075 if (lhs.lhs_new_local)
2076 --cctx->ctx_locals.ga_len;
2077 wp = op + oplen;
2078 if (may_get_next_line_error(wp, &p, cctx) == FAIL)
2079 {
2080 if (lhs.lhs_new_local)
2081 ++cctx->ctx_locals.ga_len;
2082 goto theend;
2083 }
2084 r = compile_expr0_ext(&p, cctx, &is_const);
Bram Moolenaar752fc692021-01-04 21:57:11 +01002085 if (lhs.lhs_new_local)
Bram Moolenaar21e51222020-12-04 12:43:29 +01002086 ++cctx->ctx_locals.ga_len;
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002087 if (r == FAIL)
2088 goto theend;
Bram Moolenaar21e51222020-12-04 12:43:29 +01002089 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002090 }
Bram Moolenaar9af78762020-06-16 11:34:42 +02002091 else if (semicolon && var_idx == var_count - 1)
2092 {
2093 // For "[var; var] = expr" get the rest of the list
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02002094 did_generate_slice = TRUE;
Bram Moolenaar9af78762020-06-16 11:34:42 +02002095 if (generate_SLICE(cctx, var_count - 1) == FAIL)
2096 goto theend;
2097 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002098 else
2099 {
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002100 // For "[var, var] = expr" get the "var_idx" item from the
2101 // list.
Bram Moolenaar035bd1c2021-06-21 19:44:11 +02002102 if (generate_GETITEM(cctx, var_idx, *op != '=') == FAIL)
Bram Moolenaar7f764942020-12-02 15:11:18 +01002103 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002104 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002105
Bram Moolenaar078a4612022-01-04 15:17:03 +00002106 rhs_type = cctx->ctx_type_stack.ga_len == 0 ? &t_void
2107 : get_type_on_stack(cctx, 0);
Bram Moolenaar752fc692021-01-04 21:57:11 +01002108 if (lhs.lhs_lvar != NULL && (is_decl || !lhs.lhs_has_type))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002109 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002110 if ((rhs_type->tt_type == VAR_FUNC
2111 || rhs_type->tt_type == VAR_PARTIAL)
Bram Moolenaar3f327882021-03-17 20:56:38 +01002112 && !lhs.lhs_has_index
Bram Moolenaar752fc692021-01-04 21:57:11 +01002113 && var_wrong_func_name(lhs.lhs_name, TRUE))
Bram Moolenaar0f769812020-09-12 18:32:34 +02002114 goto theend;
2115
Bram Moolenaar752fc692021-01-04 21:57:11 +01002116 if (lhs.lhs_new_local && !lhs.lhs_has_type)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002117 {
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002118 if (rhs_type->tt_type == VAR_VOID)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002119 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002120 emsg(_(e_cannot_use_void_value));
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002121 goto theend;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002122 }
2123 else
2124 {
Bram Moolenaar04bdd572020-09-23 13:25:32 +02002125 // An empty list or dict has a &t_unknown member,
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002126 // for a variable that implies &t_any.
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002127 if (rhs_type == &t_list_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002128 lhs.lhs_lvar->lv_type = &t_list_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002129 else if (rhs_type == &t_dict_empty)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002130 lhs.lhs_lvar->lv_type = &t_dict_any;
Bram Moolenaardc234ca2020-11-28 18:52:33 +01002131 else if (rhs_type == &t_unknown)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002132 lhs.lhs_lvar->lv_type = &t_any;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002133 else
Bram Moolenaar752fc692021-01-04 21:57:11 +01002134 lhs.lhs_lvar->lv_type = rhs_type;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002135 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002136 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002137 else if (*op == '=')
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002138 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002139 type_T *use_type = lhs.lhs_lvar->lv_type;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002140 where_T where = WHERE_INIT;
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002141
Bram Moolenaar77709b12021-04-03 21:01:01 +02002142 // Without operator check type here, otherwise below.
2143 // Use the line number of the assignment.
2144 SOURCING_LNUM = start_lnum;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002145 where.wt_index = var_count > 0 ? var_idx + 1 : 0;
2146 where.wt_variable = var_count > 0;
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02002147 // If assigning to a list or dict member, use the
2148 // member type. Not for "list[:] =".
2149 if (lhs.lhs_has_index
2150 && !has_list_index(var_start + lhs.lhs_varlen,
2151 cctx))
Bram Moolenaar752fc692021-01-04 21:57:11 +01002152 use_type = lhs.lhs_member_type;
Bram Moolenaar4270d8b2021-08-07 16:30:42 +02002153 if (need_type_where(rhs_type, use_type, -1, where,
2154 cctx, FALSE, is_const) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002155 goto theend;
2156 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002157 }
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002158 else
2159 {
2160 type_T *lhs_type = lhs.lhs_member_type;
2161
2162 // Special case: assigning to @# can use a number or a
2163 // string.
Bram Moolenaaraf647e72021-08-05 19:01:17 +02002164 // Also: can assign a number to a float.
2165 if ((lhs_type == &t_number_or_string
2166 || lhs_type == &t_float)
2167 && rhs_type->tt_type == VAR_NUMBER)
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002168 lhs_type = &t_number;
2169 if (*p != '=' && need_type(rhs_type, lhs_type,
Bram Moolenaar351ead02021-01-16 16:07:01 +01002170 -1, 0, cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002171 goto theend;
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002172 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002173 }
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002174 else if (cmdidx == CMD_final)
2175 {
2176 emsg(_(e_final_requires_a_value));
2177 goto theend;
2178 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002179 else if (cmdidx == CMD_const)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002180 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02002181 emsg(_(e_const_requires_a_value));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002182 goto theend;
2183 }
Bram Moolenaardcb53be2021-12-09 14:23:43 +00002184 else if (!lhs.lhs_has_type || lhs.lhs_dest == dest_option
2185 || lhs.lhs_dest == dest_func_option)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002186 {
Bram Moolenaarbc4c5052020-08-13 22:47:35 +02002187 emsg(_(e_type_or_initialization_required));
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002188 goto theend;
2189 }
2190 else
2191 {
2192 // variables are always initialized
Bram Moolenaar35578162021-08-02 19:10:38 +02002193 if (GA_GROW_FAILS(instr, 1))
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002194 goto theend;
Bram Moolenaar752fc692021-01-04 21:57:11 +01002195 switch (lhs.lhs_member_type->tt_type)
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002196 {
2197 case VAR_BOOL:
2198 generate_PUSHBOOL(cctx, VVAL_FALSE);
2199 break;
2200 case VAR_FLOAT:
2201#ifdef FEAT_FLOAT
2202 generate_PUSHF(cctx, 0.0);
2203#endif
2204 break;
2205 case VAR_STRING:
2206 generate_PUSHS(cctx, NULL);
2207 break;
2208 case VAR_BLOB:
Bram Moolenaar80b0e5e2020-10-19 20:45:36 +02002209 generate_PUSHBLOB(cctx, blob_alloc());
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002210 break;
2211 case VAR_FUNC:
2212 generate_PUSHFUNC(cctx, NULL, &t_func_void);
2213 break;
2214 case VAR_LIST:
2215 generate_NEWLIST(cctx, 0);
2216 break;
2217 case VAR_DICT:
2218 generate_NEWDICT(cctx, 0);
2219 break;
2220 case VAR_JOB:
2221 generate_PUSHJOB(cctx, NULL);
2222 break;
2223 case VAR_CHANNEL:
2224 generate_PUSHCHANNEL(cctx, NULL);
2225 break;
2226 case VAR_NUMBER:
2227 case VAR_UNKNOWN:
2228 case VAR_ANY:
2229 case VAR_PARTIAL:
2230 case VAR_VOID:
Bram Moolenaarf18332f2021-05-07 17:55:55 +02002231 case VAR_INSTR:
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002232 case VAR_SPECIAL: // cannot happen
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002233 // This is skipped for local variables, they are always
2234 // initialized to zero. But in a "for" or "while" loop
2235 // the value may have been changed.
2236 if (lhs.lhs_dest == dest_local
2237 && !inside_loop_scope(cctx))
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002238 skip_store = TRUE;
2239 else
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002240 {
2241 instr_count = instr->ga_len;
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002242 generate_PUSHNR(cctx, 0);
Bram Moolenaar38ecd972022-01-15 21:44:44 +00002243 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002244 break;
2245 }
2246 }
2247 if (var_count == 0)
2248 end = p;
2249 }
2250
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002251 // no need to parse more when skipping
Bram Moolenaar9b68c822020-06-18 19:31:08 +02002252 if (cctx->ctx_skip == SKIP_YES)
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002253 break;
2254
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002255 if (oplen > 0 && *op != '=')
2256 {
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002257 type_T *expected;
Bram Moolenaarc3160722021-08-02 21:12:05 +02002258 type_T *stacktype = NULL;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002259
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002260 if (*op == '.')
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002261 {
2262 if (may_generate_2STRING(-1, FALSE, cctx) == FAIL)
2263 goto theend;
2264 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002265 else
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002266 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002267 expected = lhs.lhs_member_type;
Bram Moolenaar078a4612022-01-04 15:17:03 +00002268 stacktype = get_type_on_stack(cctx, 0);
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002269 if (
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002270#ifdef FEAT_FLOAT
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002271 // If variable is float operation with number is OK.
Bram Moolenaar7bf9a072021-08-02 21:55:15 +02002272 !(expected == &t_float && (stacktype == &t_number
2273 || stacktype == &t_number_bool)) &&
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002274#endif
Bram Moolenaar351ead02021-01-16 16:07:01 +01002275 need_type(stacktype, expected, -1, 0, cctx,
Bram Moolenaar334a8b42020-10-19 16:07:42 +02002276 FALSE, FALSE) == FAIL)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +02002277 goto theend;
2278 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002279
2280 if (*op == '.')
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02002281 {
2282 if (generate_instr_drop(cctx, ISN_CONCAT, 1) == NULL)
2283 goto theend;
2284 }
2285 else if (*op == '+')
2286 {
2287 if (generate_add_instr(cctx,
Bram Moolenaar752fc692021-01-04 21:57:11 +01002288 operator_type(lhs.lhs_member_type, stacktype),
Bram Moolenaar07802042021-09-09 23:01:14 +02002289 lhs.lhs_member_type, stacktype,
2290 EXPR_APPEND) == FAIL)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +02002291 goto theend;
2292 }
Bram Moolenaar93ad1472020-08-19 22:02:41 +02002293 else if (generate_two_op(cctx, op) == FAIL)
2294 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002295 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002296
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002297 // Use the line number of the assignment for store instruction.
2298 save_lnum = cctx->ctx_lnum;
2299 cctx->ctx_lnum = start_lnum - 1;
2300
Bram Moolenaar752fc692021-01-04 21:57:11 +01002301 if (lhs.lhs_has_index)
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002302 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002303 // Use the info in "lhs" to store the value at the index in the
2304 // list or dict.
2305 if (compile_assign_unlet(var_start, &lhs, TRUE, rhs_type, cctx)
2306 == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002307 {
2308 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002309 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002310 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002311 }
2312 else
2313 {
Bram Moolenaar752fc692021-01-04 21:57:11 +01002314 if (is_decl && cmdidx == CMD_const && (lhs.lhs_dest == dest_script
Bram Moolenaard877a572021-04-01 19:42:48 +02002315 || lhs.lhs_dest == dest_global
Bram Moolenaar752fc692021-01-04 21:57:11 +01002316 || lhs.lhs_dest == dest_local))
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002317 // ":const var": lock the value, but not referenced variables
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002318 generate_LOCKCONST(cctx);
2319
Bram Moolenaar10d6f182022-01-04 15:54:38 +00002320 if ((lhs.lhs_type->tt_type == VAR_DICT
Bram Moolenaar752fc692021-01-04 21:57:11 +01002321 || lhs.lhs_type->tt_type == VAR_LIST)
2322 && lhs.lhs_type->tt_member != NULL
Bram Moolenaar752fc692021-01-04 21:57:11 +01002323 && lhs.lhs_type->tt_member != &t_unknown)
Bram Moolenaaraa210a32021-01-02 15:41:03 +01002324 // Set the type in the list or dict, so that it can be checked,
Bram Moolenaar10d6f182022-01-04 15:54:38 +00002325 // also in legacy script.
Bram Moolenaar752fc692021-01-04 21:57:11 +01002326 generate_SETTYPE(cctx, lhs.lhs_type);
Bram Moolenaaraa210a32021-01-02 15:41:03 +01002327
Bram Moolenaar5cd64792021-12-25 18:23:24 +00002328 if (!skip_store && generate_store_lhs(cctx, &lhs,
2329 instr_count, is_decl) == FAIL)
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002330 {
2331 cctx->ctx_lnum = save_lnum;
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02002332 goto theend;
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002333 }
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002334 }
Bram Moolenaar6977dba2021-07-04 22:48:12 +02002335 cctx->ctx_lnum = save_lnum;
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002336
2337 if (var_idx + 1 < var_count)
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00002338 var_start = skipwhite(lhs.lhs_end + 1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002339 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002340
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +02002341 // For "[var, var] = expr" drop the "expr" value.
2342 // Also for "[var, var; _] = expr".
2343 if (var_count > 0 && (!semicolon || !did_generate_slice))
Bram Moolenaar9af78762020-06-16 11:34:42 +02002344 {
Bram Moolenaarec792292020-12-13 21:26:56 +01002345 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
Bram Moolenaar9af78762020-06-16 11:34:42 +02002346 goto theend;
2347 }
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002348
Bram Moolenaarb2097502020-07-19 17:17:02 +02002349 ret = skipwhite(end);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002350
2351theend:
Bram Moolenaar752fc692021-01-04 21:57:11 +01002352 vim_free(lhs.lhs_name);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002353 return ret;
2354}
2355
2356/*
Bram Moolenaar17126b12021-01-07 22:03:02 +01002357 * Check for an assignment at "eap->cmd", compile it if found.
2358 * Return NOTDONE if there is none, FAIL for failure, OK if done.
2359 */
2360 static int
2361may_compile_assignment(exarg_T *eap, char_u **line, cctx_T *cctx)
2362{
2363 char_u *pskip;
2364 char_u *p;
2365
2366 // Assuming the command starts with a variable or function name,
2367 // find what follows.
2368 // Skip over "var.member", "var[idx]" and the like.
2369 // Also "&opt = val", "$ENV = val" and "@r = val".
2370 pskip = (*eap->cmd == '&' || *eap->cmd == '$' || *eap->cmd == '@')
2371 ? eap->cmd + 1 : eap->cmd;
2372 p = to_name_end(pskip, TRUE);
2373 if (p > eap->cmd && *p != NUL)
2374 {
2375 char_u *var_end;
2376 int oplen;
2377 int heredoc;
2378
2379 if (eap->cmd[0] == '@')
2380 var_end = eap->cmd + 2;
2381 else
2382 var_end = find_name_end(pskip, NULL, NULL,
2383 FNE_CHECK_START | FNE_INCL_BR);
2384 oplen = assignment_len(skipwhite(var_end), &heredoc);
2385 if (oplen > 0)
2386 {
2387 size_t len = p - eap->cmd;
2388
2389 // Recognize an assignment if we recognize the variable
2390 // name:
2391 // "g:var = expr"
2392 // "local = expr" where "local" is a local var.
2393 // "script = expr" where "script" is a script-local var.
2394 // "import = expr" where "import" is an imported var
2395 // "&opt = expr"
2396 // "$ENV = expr"
2397 // "@r = expr"
2398 if (*eap->cmd == '&'
2399 || *eap->cmd == '$'
2400 || *eap->cmd == '@'
2401 || ((len) > 2 && eap->cmd[1] == ':')
Bram Moolenaare0890d62021-02-17 14:52:14 +01002402 || variable_exists(eap->cmd, len, cctx))
Bram Moolenaar17126b12021-01-07 22:03:02 +01002403 {
2404 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
2405 if (*line == NULL || *line == eap->cmd)
2406 return FAIL;
2407 return OK;
2408 }
2409 }
2410 }
2411
2412 if (*eap->cmd == '[')
2413 {
2414 // [var, var] = expr
2415 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx);
2416 if (*line == NULL)
2417 return FAIL;
2418 if (*line != eap->cmd)
2419 return OK;
2420 }
2421 return NOTDONE;
2422}
2423
Bram Moolenaar9a015112021-12-31 14:06:45 +00002424/*
2425 * Check if arguments of "ufunc" shadow variables in "cctx".
2426 * Return OK or FAIL.
2427 */
2428 static int
2429check_args_shadowing(ufunc_T *ufunc, cctx_T *cctx)
2430{
2431 int i;
2432 char_u *arg;
2433 int r = OK;
2434
2435 // Make sure arguments are not found when compiling a second time.
2436 ufunc->uf_args_visible = 0;
2437
2438 // Check for arguments shadowing variables from the context.
2439 for (i = 0; i < ufunc->uf_args.ga_len; ++i)
2440 {
2441 arg = ((char_u **)(ufunc->uf_args.ga_data))[i];
Bram Moolenaardce24412022-02-08 20:35:30 +00002442 if (check_defined(arg, STRLEN(arg), cctx, NULL, TRUE) == FAIL)
Bram Moolenaar9a015112021-12-31 14:06:45 +00002443 {
2444 r = FAIL;
2445 break;
2446 }
2447 }
2448 ufunc->uf_args_visible = ufunc->uf_args.ga_len;
2449 return r;
2450}
2451
Bram Moolenaar7b829262021-10-13 15:04:34 +01002452
2453/*
Bram Moolenaar09689a02020-05-09 22:50:08 +02002454 * Add a function to the list of :def functions.
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002455 * This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet.
Bram Moolenaar09689a02020-05-09 22:50:08 +02002456 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02002457 static int
Bram Moolenaar09689a02020-05-09 22:50:08 +02002458add_def_function(ufunc_T *ufunc)
2459{
2460 dfunc_T *dfunc;
2461
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002462 if (def_functions.ga_len == 0)
2463 {
2464 // The first position is not used, so that a zero uf_dfunc_idx means it
2465 // wasn't set.
Bram Moolenaar35578162021-08-02 19:10:38 +02002466 if (GA_GROW_FAILS(&def_functions, 1))
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002467 return FAIL;
2468 ++def_functions.ga_len;
2469 }
2470
Bram Moolenaar09689a02020-05-09 22:50:08 +02002471 // Add the function to "def_functions".
Bram Moolenaar35578162021-08-02 19:10:38 +02002472 if (GA_GROW_FAILS(&def_functions, 1))
Bram Moolenaar09689a02020-05-09 22:50:08 +02002473 return FAIL;
2474 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
2475 CLEAR_POINTER(dfunc);
2476 dfunc->df_idx = def_functions.ga_len;
2477 ufunc->uf_dfunc_idx = dfunc->df_idx;
2478 dfunc->df_ufunc = ufunc;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002479 dfunc->df_name = vim_strsave(ufunc->uf_name);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002480 ga_init2(&dfunc->df_var_names, sizeof(char_u *), 10);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002481 ++dfunc->df_refcount;
Bram Moolenaar09689a02020-05-09 22:50:08 +02002482 ++def_functions.ga_len;
2483 return OK;
2484}
2485
2486/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002487 * After ex_function() has collected all the function lines: parse and compile
2488 * the lines into instructions.
2489 * Adds the function to "def_functions".
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002490 * When "check_return_type" is set then set ufunc->uf_ret_type to the type of
2491 * the return statement (used for lambda). When uf_ret_type is already set
2492 * then check that it matches.
Bram Moolenaarb2049902021-01-24 12:53:53 +01002493 * When "profiling" is true add ISN_PROF_START instructions.
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002494 * "outer_cctx" is set for a nested function.
Bram Moolenaar05afcee2020-03-31 23:32:31 +02002495 * This can be used recursively through compile_lambda(), which may reallocate
2496 * "def_functions".
Bram Moolenaar822ba242020-05-24 23:00:18 +02002497 * Returns OK or FAIL.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002498 */
Bram Moolenaar822ba242020-05-24 23:00:18 +02002499 int
Bram Moolenaarb2049902021-01-24 12:53:53 +01002500compile_def_function(
Bram Moolenaare99d4222021-06-13 14:01:26 +02002501 ufunc_T *ufunc,
2502 int check_return_type,
2503 compiletype_T compile_type,
2504 cctx_T *outer_cctx)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002505{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002506 char_u *line = NULL;
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002507 garray_T lines_to_free;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002508 char_u *p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002509 char *errormsg = NULL; // error message
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002510 cctx_T cctx;
2511 garray_T *instr;
Bram Moolenaard66960b2020-10-30 20:46:26 +01002512 int did_emsg_before = did_emsg;
Bram Moolenaar599410c2021-04-10 14:03:43 +02002513 int did_emsg_silent_before = did_emsg_silent;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002514 int ret = FAIL;
2515 sctx_T save_current_sctx = current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02002516 int save_estack_compiling = estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002517 int save_cmod_flags = cmdmod.cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002518 int do_estack_push;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02002519 int new_def_function = FALSE;
Bram Moolenaarf002a412021-01-24 13:34:18 +01002520#ifdef FEAT_PROFILE
Bram Moolenaarb2049902021-01-24 12:53:53 +01002521 int prof_lnum = -1;
Bram Moolenaarf002a412021-01-24 13:34:18 +01002522#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02002523 int debug_lnum = -1;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002524
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002525 // allocated lines are freed at the end
2526 ga_init2(&lines_to_free, sizeof(char_u *), 50);
2527
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002528 // When using a function that was compiled before: Free old instructions.
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01002529 // The index is reused. Otherwise add a new entry in "def_functions".
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02002530 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002531 {
Bram Moolenaar09689a02020-05-09 22:50:08 +02002532 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
2533 + ufunc->uf_dfunc_idx;
Bram Moolenaar3b814af2021-06-15 10:22:17 +02002534 isn_T *instr_dest = NULL;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002535
2536 switch (compile_type)
2537 {
2538 case CT_PROFILE:
2539#ifdef FEAT_PROFILE
2540 instr_dest = dfunc->df_instr_prof; break;
2541#endif
2542 case CT_NONE: instr_dest = dfunc->df_instr; break;
2543 case CT_DEBUG: instr_dest = dfunc->df_instr_debug; break;
2544 }
2545 if (instr_dest != NULL)
2546 // Was compiled in this mode before: Free old instructions.
2547 delete_def_function_contents(dfunc, FALSE);
2548 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002549 }
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02002550 else
2551 {
2552 if (add_def_function(ufunc) == FAIL)
2553 return FAIL;
2554 new_def_function = TRUE;
2555 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002556
Bram Moolenaar985116a2020-07-12 17:31:09 +02002557 ufunc->uf_def_status = UF_COMPILING;
2558
Bram Moolenaara80faa82020-04-12 19:37:17 +02002559 CLEAR_FIELD(cctx);
Bram Moolenaarb2049902021-01-24 12:53:53 +01002560
Bram Moolenaare99d4222021-06-13 14:01:26 +02002561 cctx.ctx_compile_type = compile_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002562 cctx.ctx_ufunc = ufunc;
2563 cctx.ctx_lnum = -1;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002564 cctx.ctx_outer = outer_cctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002565 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
Bram Moolenaar078a4612022-01-04 15:17:03 +00002566 // Each entry on the type stack consists of two type pointers.
2567 ga_init2(&cctx.ctx_type_stack, sizeof(type2_T), 50);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002568 cctx.ctx_type_list = &ufunc->uf_type_list;
2569 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
2570 instr = &cctx.ctx_instr;
2571
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002572 // Set the context to the function, it may be compiled when called from
2573 // another script. Set the script version to the most modern one.
2574 // The line number will be set in next_line_from_context().
2575 current_sctx = ufunc->uf_script_ctx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002576 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
2577
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002578 // Don't use the flag from ":legacy" here.
2579 cmdmod.cmod_flags &= ~CMOD_LEGACY;
2580
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002581 // Make sure error messages are OK.
2582 do_estack_push = !estack_top_is_ufunc(ufunc, 1);
2583 if (do_estack_push)
2584 estack_push_ufunc(ufunc, 1);
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02002585 estack_compiling = TRUE;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02002586
Bram Moolenaar9a015112021-12-31 14:06:45 +00002587 if (check_args_shadowing(ufunc, &cctx) == FAIL)
2588 goto erret;
2589
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002590 if (ufunc->uf_def_args.ga_len > 0)
2591 {
2592 int count = ufunc->uf_def_args.ga_len;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002593 int first_def_arg = ufunc->uf_args.ga_len - count;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002594 int i;
2595 char_u *arg;
2596 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002597 int did_set_arg_type = FALSE;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002598
2599 // Produce instructions for the default values of optional arguments.
Bram Moolenaar12bce952021-03-11 20:04:04 +01002600 SOURCING_LNUM = 0; // line number unknown
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002601 for (i = 0; i < count; ++i)
2602 {
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002603 type_T *val_type;
2604 int arg_idx = first_def_arg + i;
Bram Moolenaar7a3fe3e2021-07-22 14:58:47 +02002605 where_T where = WHERE_INIT;
Bram Moolenaar12bce952021-03-11 20:04:04 +01002606 int r;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02002607 int jump_instr_idx = instr->ga_len;
2608 isn_T *isn;
2609
2610 // Use a JUMP_IF_ARG_SET instruction to skip if the value was given.
2611 if (generate_JUMP_IF_ARG_SET(&cctx, i - count - off) == FAIL)
2612 goto erret;
Bram Moolenaar12bce952021-03-11 20:04:04 +01002613
2614 // Make sure later arguments are not found.
Bram Moolenaare28d9b32021-07-03 18:56:53 +02002615 ufunc->uf_args_visible = arg_idx;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002616
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002617 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
Bram Moolenaar12bce952021-03-11 20:04:04 +01002618 r = compile_expr0(&arg, &cctx);
2619
Bram Moolenaar12bce952021-03-11 20:04:04 +01002620 if (r == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002621 goto erret;
2622
2623 // If no type specified use the type of the default value.
2624 // Otherwise check that the default value type matches the
2625 // specified type.
Bram Moolenaar078a4612022-01-04 15:17:03 +00002626 val_type = get_type_on_stack(&cctx, 0);
Bram Moolenaarf785aa12021-02-11 21:19:34 +01002627 where.wt_index = arg_idx + 1;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002628 if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002629 {
2630 did_set_arg_type = TRUE;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002631 ufunc->uf_arg_types[arg_idx] = val_type;
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002632 }
Bram Moolenaarfa46ead2021-12-22 13:18:39 +00002633 else if (need_type_where(val_type, ufunc->uf_arg_types[arg_idx],
2634 -1, where, &cctx, FALSE, FALSE) == FAIL)
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002635 goto erret;
Bram Moolenaar49cf7cc2020-04-07 22:45:00 +02002636
2637 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002638 goto erret;
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +02002639
2640 // set instruction index in JUMP_IF_ARG_SET to here
2641 isn = ((isn_T *)instr->ga_data) + jump_instr_idx;
2642 isn->isn_arg.jumparg.jump_where = instr->ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002643 }
Bram Moolenaarb8070e32020-07-23 20:56:04 +02002644
2645 if (did_set_arg_type)
2646 set_function_type(ufunc);
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002647 }
Bram Moolenaare28d9b32021-07-03 18:56:53 +02002648 ufunc->uf_args_visible = ufunc->uf_args.ga_len;
Bram Moolenaar170fcfc2020-02-06 17:51:35 +01002649
2650 /*
2651 * Loop over all the lines of the function and generate instructions.
2652 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002653 for (;;)
2654 {
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002655 exarg_T ea;
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002656 int starts_with_colon = FALSE;
2657 char_u *cmd;
Bram Moolenaar02194d22020-10-24 23:08:38 +02002658 cmdmod_T local_cmdmod;
Bram Moolenaar5b1c8fe2020-02-21 18:42:43 +01002659
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002660 // Bail out on the first error to avoid a flood of errors and report
2661 // the right line number when inside try/catch.
Bram Moolenaard66960b2020-10-30 20:46:26 +01002662 if (did_emsg_before != did_emsg)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002663 goto erret;
2664
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002665 if (line != NULL && *line == '|')
2666 // the line continues after a '|'
2667 ++line;
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002668 else if (line != NULL && *skipwhite(line) != NUL
Bram Moolenaar7a092242020-04-16 22:10:49 +02002669 && !(*line == '#' && (line == cctx.ctx_line_start
2670 || VIM_ISWHITE(line[-1]))))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002671 {
Bram Moolenaar74409f62022-01-01 15:58:22 +00002672 semsg(_(e_trailing_characters_str), line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002673 goto erret;
2674 }
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01002675 else if (line != NULL && vim9_bad_comment(skipwhite(line)))
2676 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002677 else
2678 {
Bram Moolenaar23c55272020-06-21 16:58:13 +02002679 line = next_line_from_context(&cctx, FALSE);
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002680 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
Bram Moolenaarb2049902021-01-24 12:53:53 +01002681 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002682 // beyond the last line
Bram Moolenaarf002a412021-01-24 13:34:18 +01002683#ifdef FEAT_PROFILE
Bram Moolenaarced68a02021-01-24 17:53:47 +01002684 if (cctx.ctx_skip != SKIP_YES)
2685 may_generate_prof_end(&cctx, prof_lnum);
Bram Moolenaarf002a412021-01-24 13:34:18 +01002686#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002687 break;
Bram Moolenaarb2049902021-01-24 12:53:53 +01002688 }
Bram Moolenaarf62d7392021-04-14 12:40:00 +02002689 // Make a copy, splitting off nextcmd and removing trailing spaces
2690 // may change it.
2691 if (line != NULL)
2692 {
2693 line = vim_strsave(line);
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002694 if (ga_add_string(&lines_to_free, line) == FAIL)
2695 goto erret;
Bram Moolenaarf62d7392021-04-14 12:40:00 +02002696 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002697 }
2698
Bram Moolenaara80faa82020-04-12 19:37:17 +02002699 CLEAR_FIELD(ea);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002700 ea.cmdlinep = &line;
2701 ea.cmd = skipwhite(line);
2702
Bram Moolenaarb2049902021-01-24 12:53:53 +01002703 if (*ea.cmd == '#')
2704 {
2705 // "#" starts a comment
2706 line = (char_u *)"";
2707 continue;
2708 }
2709
Bram Moolenaarf002a412021-01-24 13:34:18 +01002710#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02002711 if (cctx.ctx_compile_type == CT_PROFILE && cctx.ctx_lnum != prof_lnum
2712 && cctx.ctx_skip != SKIP_YES)
Bram Moolenaarb2049902021-01-24 12:53:53 +01002713 {
2714 may_generate_prof_end(&cctx, prof_lnum);
2715
2716 prof_lnum = cctx.ctx_lnum;
2717 generate_instr(&cctx, ISN_PROF_START);
2718 }
Bram Moolenaarf002a412021-01-24 13:34:18 +01002719#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02002720 if (cctx.ctx_compile_type == CT_DEBUG && cctx.ctx_lnum != debug_lnum
2721 && cctx.ctx_skip != SKIP_YES)
2722 {
2723 debug_lnum = cctx.ctx_lnum;
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02002724 generate_instr_debug(&cctx);
Bram Moolenaare99d4222021-06-13 14:01:26 +02002725 }
Bram Moolenaar8cec9272021-06-23 20:20:53 +02002726 cctx.ctx_prev_lnum = cctx.ctx_lnum + 1;
Bram Moolenaarb2049902021-01-24 12:53:53 +01002727
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002728 // Some things can be recognized by the first character.
2729 switch (*ea.cmd)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002730 {
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002731 case '}':
2732 {
2733 // "}" ends a block scope
2734 scopetype_T stype = cctx.ctx_scope == NULL
2735 ? NO_SCOPE : cctx.ctx_scope->se_type;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002736
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002737 if (stype == BLOCK_SCOPE)
2738 {
2739 compile_endblock(&cctx);
2740 line = ea.cmd;
2741 }
2742 else
2743 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002744 emsg(_(e_using_rcurly_outside_if_block_scope));
Bram Moolenaarcb711ab2020-04-16 13:00:29 +02002745 goto erret;
2746 }
2747 if (line != NULL)
2748 line = skipwhite(ea.cmd + 1);
2749 continue;
2750 }
2751
2752 case '{':
2753 // "{" starts a block scope
2754 // "{'a': 1}->func() is something else
2755 if (ends_excmd(*skipwhite(ea.cmd + 1)))
2756 {
2757 line = compile_block(ea.cmd, &cctx);
2758 continue;
2759 }
2760 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002761 }
2762
2763 /*
2764 * COMMAND MODIFIERS
2765 */
Bram Moolenaar02194d22020-10-24 23:08:38 +02002766 cctx.ctx_has_cmdmod = FALSE;
Bram Moolenaare1004402020-10-24 20:49:43 +02002767 if (parse_command_modifiers(&ea, &errormsg, &local_cmdmod, FALSE)
2768 == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002769 {
2770 if (errormsg != NULL)
2771 goto erret;
2772 // empty line or comment
2773 line = (char_u *)"";
2774 continue;
2775 }
Bram Moolenaare1004402020-10-24 20:49:43 +02002776 generate_cmdmods(&cctx, &local_cmdmod);
2777 undo_cmdmod(&local_cmdmod);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002778
Bram Moolenaare88c8e82020-11-01 17:03:37 +01002779 // Check if there was a colon after the last command modifier or before
2780 // the current position.
2781 for (p = ea.cmd; p >= line; --p)
2782 {
2783 if (*p == ':')
2784 starts_with_colon = TRUE;
2785 if (p < ea.cmd && !VIM_ISWHITE(*p))
2786 break;
2787 }
2788
Bram Moolenaarce024c32021-06-26 13:00:49 +02002789 // Skip ":call" to get to the function name, unless using :legacy
Bram Moolenaar575f24b2020-08-12 14:21:11 +02002790 p = ea.cmd;
Bram Moolenaarce024c32021-06-26 13:00:49 +02002791 if (!(local_cmdmod.cmod_flags & CMOD_LEGACY))
Bram Moolenaar575f24b2020-08-12 14:21:11 +02002792 {
Bram Moolenaarce024c32021-06-26 13:00:49 +02002793 if (checkforcmd(&ea.cmd, "call", 3))
2794 {
2795 if (*ea.cmd == '(')
2796 // not for "call()"
2797 ea.cmd = p;
2798 else
2799 ea.cmd = skipwhite(ea.cmd);
2800 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002801
Bram Moolenaarce024c32021-06-26 13:00:49 +02002802 if (!starts_with_colon)
2803 {
2804 int assign;
Bram Moolenaar1cc2a942020-05-10 19:10:31 +02002805
Bram Moolenaarce024c32021-06-26 13:00:49 +02002806 // Check for assignment after command modifiers.
2807 assign = may_compile_assignment(&ea, &line, &cctx);
2808 if (assign == OK)
2809 goto nextline;
2810 if (assign == FAIL)
2811 goto erret;
2812 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002813 }
2814
2815 /*
2816 * COMMAND after range
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002817 * 'text'->func() should not be confused with 'a mark
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002818 * "++nr" and "--nr" are eval commands
Bram Moolenaar5ca5cc62021-08-24 21:56:03 +02002819 * in "$ENV->func()" the "$" is not a range
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002820 */
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002821 cmd = ea.cmd;
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002822 if ((*cmd != '$' || starts_with_colon)
Bram Moolenaarce024c32021-06-26 13:00:49 +02002823 && (starts_with_colon || !(*cmd == '\''
Bram Moolenaard3a11782022-01-05 16:50:40 +00002824 || (cmd[0] != NUL && cmd[0] == cmd[1]
2825 && (*cmd == '+' || *cmd == '-')))))
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002826 {
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02002827 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002828 if (ea.cmd > cmd)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002829 {
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002830 if (!starts_with_colon
2831 && !(local_cmdmod.cmod_flags & CMOD_LEGACY))
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002832 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01002833 semsg(_(e_colon_required_before_range_str), cmd);
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002834 goto erret;
2835 }
Bram Moolenaarada1d872021-02-20 08:16:51 +01002836 ea.addr_count = 1;
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002837 if (ends_excmd2(line, ea.cmd))
2838 {
2839 // A range without a command: jump to the line.
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00002840 generate_EXEC(&cctx, ISN_EXECRANGE,
Bram Moolenaarb579f6e2021-12-04 11:57:00 +00002841 vim_strnsave(cmd, ea.cmd - cmd));
Bram Moolenaare4eed8c2021-12-01 15:22:56 +00002842 line = ea.cmd;
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02002843 goto nextline;
2844 }
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002845 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002846 }
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002847 p = find_ex_command(&ea, NULL,
2848 starts_with_colon || (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01002849 ? NULL : item_exists, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002850
Bram Moolenaard1510ee2021-01-04 16:15:58 +01002851 if (p == NULL)
2852 {
2853 if (cctx.ctx_skip != SKIP_YES)
Bram Moolenaarbed34f02022-01-19 20:48:37 +00002854 semsg(_(e_ambiguous_use_of_user_defined_command_str), ea.cmd);
Bram Moolenaard1510ee2021-01-04 16:15:58 +01002855 goto erret;
2856 }
2857
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002858 // When using ":legacy cmd" always use compile_exec().
2859 if (local_cmdmod.cmod_flags & CMOD_LEGACY)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002860 {
2861 char_u *start = ea.cmd;
2862
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02002863 switch (ea.cmdidx)
2864 {
2865 case CMD_if:
2866 case CMD_elseif:
2867 case CMD_else:
2868 case CMD_endif:
2869 case CMD_for:
2870 case CMD_endfor:
2871 case CMD_continue:
2872 case CMD_break:
2873 case CMD_while:
2874 case CMD_endwhile:
2875 case CMD_try:
2876 case CMD_catch:
2877 case CMD_finally:
2878 case CMD_endtry:
2879 semsg(_(e_cannot_use_legacy_with_command_str), ea.cmd);
2880 goto erret;
2881 default: break;
2882 }
2883
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002884 // ":legacy return expr" needs to be handled differently.
2885 if (checkforcmd(&start, "return", 4))
2886 ea.cmdidx = CMD_return;
2887 else
2888 ea.cmdidx = CMD_legacy;
2889 }
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002890
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002891 if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
2892 {
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002893 if (cctx.ctx_skip == SKIP_YES && ea.cmdidx != CMD_eval)
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002894 {
2895 line += STRLEN(line);
Bram Moolenaarf665e972020-12-05 19:17:16 +01002896 goto nextline;
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002897 }
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002898 else if (ea.cmdidx != CMD_eval)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002899 {
Bram Moolenaar52c124d2020-12-20 21:43:35 +01002900 // CMD_var cannot happen, compile_assignment() above would be
2901 // used. Most likely an assignment to a non-existing variable.
2902 semsg(_(e_command_not_recognized_str), ea.cmd);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02002903 goto erret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002904 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002905 }
2906
Bram Moolenaar3988f642020-08-27 22:43:03 +02002907 if (cctx.ctx_had_return
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002908 && ea.cmdidx != CMD_elseif
2909 && ea.cmdidx != CMD_else
Bram Moolenaarefd88552020-06-18 20:50:10 +02002910 && ea.cmdidx != CMD_endif
2911 && ea.cmdidx != CMD_endfor
2912 && ea.cmdidx != CMD_endwhile
2913 && ea.cmdidx != CMD_catch
2914 && ea.cmdidx != CMD_finally
2915 && ea.cmdidx != CMD_endtry)
2916 {
Bram Moolenaar3988f642020-08-27 22:43:03 +02002917 emsg(_(e_unreachable_code_after_return));
2918 goto erret;
Bram Moolenaarefd88552020-06-18 20:50:10 +02002919 }
2920
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002921 p = skipwhite(p);
2922 if (ea.cmdidx != CMD_SIZE
2923 && ea.cmdidx != CMD_write && ea.cmdidx != CMD_read)
2924 {
Bram Moolenaar9b123d82020-09-14 22:39:11 +02002925 if (ea.cmdidx >= 0)
2926 ea.argt = excmd_get_argt(ea.cmdidx);
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +02002927 if ((ea.argt & EX_BANG) && *p == '!')
2928 {
2929 ea.forceit = TRUE;
2930 p = skipwhite(p + 1);
2931 }
2932 }
2933
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002934 switch (ea.cmdidx)
2935 {
2936 case CMD_def:
Bram Moolenaar38453522021-11-28 22:00:12 +00002937 case CMD_function:
Bram Moolenaar04b12692020-05-04 23:24:44 +02002938 ea.arg = p;
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002939 line = compile_nested_function(&ea, &cctx, &lines_to_free);
Bram Moolenaar04b12692020-05-04 23:24:44 +02002940 break;
2941
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002942 case CMD_return:
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002943 line = compile_return(p, check_return_type,
2944 local_cmdmod.cmod_flags & CMOD_LEGACY, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02002945 cctx.ctx_had_return = TRUE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002946 break;
2947
2948 case CMD_let:
Bram Moolenaarc58f5452020-10-21 20:58:52 +02002949 emsg(_(e_cannot_use_let_in_vim9_script));
2950 break;
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002951 case CMD_var:
2952 case CMD_final:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002953 case CMD_const:
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002954 case CMD_increment:
2955 case CMD_decrement:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002956 line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
Bram Moolenaar47a519a2020-06-14 23:05:10 +02002957 if (line == p)
2958 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002959 break;
2960
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002961 case CMD_unlet:
2962 case CMD_unlockvar:
2963 case CMD_lockvar:
2964 line = compile_unletlock(p, &ea, &cctx);
2965 break;
2966
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002967 case CMD_import:
Bram Moolenaar4db572e2021-07-18 18:21:38 +02002968 emsg(_(e_import_can_only_be_used_in_script));
2969 line = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002970 break;
2971
2972 case CMD_if:
2973 line = compile_if(p, &cctx);
2974 break;
2975 case CMD_elseif:
2976 line = compile_elseif(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02002977 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002978 break;
2979 case CMD_else:
2980 line = compile_else(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02002981 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002982 break;
2983 case CMD_endif:
2984 line = compile_endif(p, &cctx);
2985 break;
2986
2987 case CMD_while:
2988 line = compile_while(p, &cctx);
2989 break;
2990 case CMD_endwhile:
2991 line = compile_endwhile(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02002992 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002993 break;
2994
2995 case CMD_for:
2996 line = compile_for(p, &cctx);
2997 break;
2998 case CMD_endfor:
2999 line = compile_endfor(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003000 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003001 break;
3002 case CMD_continue:
3003 line = compile_continue(p, &cctx);
3004 break;
3005 case CMD_break:
3006 line = compile_break(p, &cctx);
3007 break;
3008
3009 case CMD_try:
3010 line = compile_try(p, &cctx);
3011 break;
3012 case CMD_catch:
3013 line = compile_catch(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_finally:
3017 line = compile_finally(p, &cctx);
Bram Moolenaarefd88552020-06-18 20:50:10 +02003018 cctx.ctx_had_return = FALSE;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003019 break;
3020 case CMD_endtry:
3021 line = compile_endtry(p, &cctx);
3022 break;
3023 case CMD_throw:
3024 line = compile_throw(p, &cctx);
3025 break;
3026
Bram Moolenaar007f9d62020-07-06 23:04:49 +02003027 case CMD_eval:
Bram Moolenaarc3235272021-07-10 19:42:03 +02003028 line = compile_eval(p, &cctx);
Bram Moolenaar007f9d62020-07-06 23:04:49 +02003029 break;
3030
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003031 case CMD_echo:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003032 case CMD_echon:
Bram Moolenaarad39c092020-02-26 18:23:43 +01003033 case CMD_execute:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02003034 case CMD_echomsg:
3035 case CMD_echoerr:
Bram Moolenaar7de62622021-08-07 15:05:47 +02003036 case CMD_echoconsole:
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02003037 line = compile_mult_expr(p, ea.cmdidx, &cctx);
Bram Moolenaarad39c092020-02-26 18:23:43 +01003038 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003039
Bram Moolenaarc3516f72020-09-08 22:45:35 +02003040 case CMD_put:
3041 ea.cmd = cmd;
3042 line = compile_put(p, &ea, &cctx);
3043 break;
3044
Bram Moolenaar4c137212021-04-19 16:48:48 +02003045 case CMD_substitute:
Bram Moolenaar7b829262021-10-13 15:04:34 +01003046 if (check_global_and_subst(ea.cmd, p) == FAIL)
3047 goto erret;
Bram Moolenaar4c137212021-04-19 16:48:48 +02003048 if (cctx.ctx_skip == SKIP_YES)
3049 line = (char_u *)"";
3050 else
3051 {
3052 ea.arg = p;
3053 line = compile_substitute(line, &ea, &cctx);
3054 }
3055 break;
3056
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003057 case CMD_redir:
3058 ea.arg = p;
3059 line = compile_redir(line, &ea, &cctx);
3060 break;
3061
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003062 case CMD_cexpr:
3063 case CMD_lexpr:
3064 case CMD_caddexpr:
3065 case CMD_laddexpr:
3066 case CMD_cgetexpr:
3067 case CMD_lgetexpr:
Bram Moolenaarb7c97812021-05-05 22:51:39 +02003068#ifdef FEAT_QUICKFIX
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003069 ea.arg = p;
3070 line = compile_cexpr(line, &ea, &cctx);
Bram Moolenaarb7c97812021-05-05 22:51:39 +02003071#else
3072 ex_ni(&ea);
3073 line = NULL;
3074#endif
Bram Moolenaar5f7d4c02021-05-05 21:31:39 +02003075 break;
3076
Bram Moolenaarae616492020-07-28 20:07:27 +02003077 case CMD_append:
3078 case CMD_change:
3079 case CMD_insert:
Bram Moolenaar10b94212021-02-19 21:42:57 +01003080 case CMD_k:
Bram Moolenaarf5a48012020-08-01 17:00:03 +02003081 case CMD_t:
Bram Moolenaarae616492020-07-28 20:07:27 +02003082 case CMD_xit:
3083 not_in_vim9(&ea);
3084 goto erret;
3085
Bram Moolenaar002262f2020-07-08 17:47:57 +02003086 case CMD_SIZE:
Bram Moolenaar3988f642020-08-27 22:43:03 +02003087 if (cctx.ctx_skip != SKIP_YES)
3088 {
3089 semsg(_(e_invalid_command_str), ea.cmd);
3090 goto erret;
3091 }
3092 // We don't check for a next command here.
3093 line = (char_u *)"";
3094 break;
Bram Moolenaar002262f2020-07-08 17:47:57 +02003095
Bram Moolenaar20677332021-06-06 17:02:53 +02003096 case CMD_lua:
3097 case CMD_mzscheme:
3098 case CMD_perl:
3099 case CMD_py3:
3100 case CMD_python3:
3101 case CMD_python:
3102 case CMD_pythonx:
3103 case CMD_ruby:
3104 case CMD_tcl:
3105 ea.arg = p;
3106 if (vim_strchr(line, '\n') == NULL)
Bram Moolenaar5163fcc2020-08-27 23:37:09 +02003107 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar20677332021-06-06 17:02:53 +02003108 else
3109 // heredoc lines have been concatenated with NL
3110 // characters in get_function_body()
3111 line = compile_script(line, &cctx);
3112 break;
3113
Bram Moolenaar107f7322022-02-06 17:30:41 +00003114 case CMD_vim9script:
Bram Moolenaar8cbf2492022-02-06 20:28:13 +00003115 if (cctx.ctx_skip != SKIP_YES)
3116 {
3117 emsg(_(e_vim9script_can_only_be_used_in_script));
3118 goto erret;
3119 }
3120 line = (char_u *)"";
3121 break;
Bram Moolenaar107f7322022-02-06 17:30:41 +00003122
Bram Moolenaar7b829262021-10-13 15:04:34 +01003123 case CMD_global:
3124 if (check_global_and_subst(ea.cmd, p) == FAIL)
3125 goto erret;
3126 // FALLTHROUGH
Bram Moolenaar20677332021-06-06 17:02:53 +02003127 default:
3128 // Not recognized, execute with do_cmdline_cmd().
3129 ea.arg = p;
3130 line = compile_exec(line, &ea, &cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003131 break;
3132 }
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02003133nextline:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003134 if (line == NULL)
3135 goto erret;
Bram Moolenaar585fea72020-04-02 22:33:21 +02003136 line = skipwhite(line);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003137
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02003138 // Undo any command modifiers.
Bram Moolenaar02194d22020-10-24 23:08:38 +02003139 generate_undo_cmdmods(&cctx);
Bram Moolenaarf4c6e1e2020-10-23 18:02:32 +02003140
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003141 if (cctx.ctx_type_stack.ga_len < 0)
3142 {
3143 iemsg("Type stack underflow");
3144 goto erret;
3145 }
3146 }
3147
3148 if (cctx.ctx_scope != NULL)
3149 {
3150 if (cctx.ctx_scope->se_type == IF_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003151 emsg(_(e_missing_endif));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003152 else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003153 emsg(_(e_missing_endwhile));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003154 else if (cctx.ctx_scope->se_type == FOR_SCOPE)
Bram Moolenaar1a992222021-12-31 17:25:48 +00003155 emsg(_(e_missing_endfor));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003156 else
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003157 emsg(_(e_missing_rcurly));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003158 goto erret;
3159 }
3160
Bram Moolenaarefd88552020-06-18 20:50:10 +02003161 if (!cctx.ctx_had_return)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003162 {
Bram Moolenaare6174fd2021-06-12 18:30:56 +02003163 if (ufunc->uf_ret_type->tt_type == VAR_UNKNOWN)
3164 ufunc->uf_ret_type = &t_void;
3165 else if (ufunc->uf_ret_type->tt_type != VAR_VOID)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003166 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02003167 emsg(_(e_missing_return_statement));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003168 goto erret;
3169 }
3170
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003171 // Return void if there is no return at the end.
3172 generate_instr(&cctx, ISN_RETURN_VOID);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003173 }
3174
Bram Moolenaar599410c2021-04-10 14:03:43 +02003175 // When compiled with ":silent!" and there was an error don't consider the
3176 // function compiled.
3177 if (emsg_silent == 0 || did_emsg_silent == did_emsg_silent_before)
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003178 {
3179 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3180 + ufunc->uf_dfunc_idx;
3181 dfunc->df_deleted = FALSE;
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003182 dfunc->df_script_seq = current_sctx.sc_seq;
Bram Moolenaarf002a412021-01-24 13:34:18 +01003183#ifdef FEAT_PROFILE
Bram Moolenaare99d4222021-06-13 14:01:26 +02003184 if (cctx.ctx_compile_type == CT_PROFILE)
Bram Moolenaarb2049902021-01-24 12:53:53 +01003185 {
3186 dfunc->df_instr_prof = instr->ga_data;
3187 dfunc->df_instr_prof_count = instr->ga_len;
3188 }
3189 else
Bram Moolenaarf002a412021-01-24 13:34:18 +01003190#endif
Bram Moolenaare99d4222021-06-13 14:01:26 +02003191 if (cctx.ctx_compile_type == CT_DEBUG)
3192 {
3193 dfunc->df_instr_debug = instr->ga_data;
3194 dfunc->df_instr_debug_count = instr->ga_len;
3195 }
3196 else
Bram Moolenaarb2049902021-01-24 12:53:53 +01003197 {
3198 dfunc->df_instr = instr->ga_data;
3199 dfunc->df_instr_count = instr->ga_len;
3200 }
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02003201 dfunc->df_varcount = dfunc->df_var_names.ga_len;
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02003202 dfunc->df_has_closure = cctx.ctx_has_closure;
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02003203 if (cctx.ctx_outer_used)
3204 ufunc->uf_flags |= FC_CLOSURE;
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003205 ufunc->uf_def_status = UF_COMPILED;
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003206 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003207
3208 ret = OK;
3209
3210erret:
Bram Moolenaar599410c2021-04-10 14:03:43 +02003211 if (ufunc->uf_def_status == UF_COMPILING)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003212 {
Bram Moolenaar05afcee2020-03-31 23:32:31 +02003213 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3214 + ufunc->uf_dfunc_idx;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003215
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02003216 // Compiling aborted, free the generated instructions.
Bram Moolenaar8238f082021-04-20 21:10:48 +02003217 clear_instr_ga(instr);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003218 VIM_CLEAR(dfunc->df_name);
Bram Moolenaarcaf1a2f2021-06-15 11:27:21 +02003219 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003220
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003221 // If using the last entry in the table and it was added above, we
3222 // might as well remove it.
3223 if (!dfunc->df_deleted && new_def_function
Bram Moolenaar45a15082020-05-25 00:28:33 +02003224 && ufunc->uf_dfunc_idx == def_functions.ga_len - 1)
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003225 {
Bram Moolenaar20431c92020-03-20 18:39:46 +01003226 --def_functions.ga_len;
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02003227 ufunc->uf_dfunc_idx = 0;
3228 }
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003229 ufunc->uf_def_status = UF_COMPILE_ERROR;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003230
Bram Moolenaar3cca2992020-04-02 22:57:36 +02003231 while (cctx.ctx_scope != NULL)
3232 drop_scope(&cctx);
3233
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003234 if (errormsg != NULL)
3235 emsg(errormsg);
Bram Moolenaard66960b2020-10-30 20:46:26 +01003236 else if (did_emsg == did_emsg_before)
Bram Moolenaare13bdec2020-10-16 23:16:47 +02003237 emsg(_(e_compiling_def_function_failed));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003238 }
3239
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003240 if (cctx.ctx_redir_lhs.lhs_name != NULL)
3241 {
3242 if (ret == OK)
3243 {
3244 emsg(_(e_missing_redir_end));
3245 ret = FAIL;
3246 }
3247 vim_free(cctx.ctx_redir_lhs.lhs_name);
Bram Moolenaar753bcf82021-04-21 14:24:24 +02003248 vim_free(cctx.ctx_redir_lhs.lhs_whole);
Bram Moolenaar2d1c57e2021-04-19 20:50:03 +02003249 }
3250
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003251 current_sctx = save_current_sctx;
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +02003252 estack_compiling = save_estack_compiling;
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003253 cmdmod.cmod_flags = save_cmod_flags;
Bram Moolenaar25e0f582020-05-25 22:36:50 +02003254 if (do_estack_push)
3255 estack_pop();
3256
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00003257 ga_clear_strings(&lines_to_free);
Bram Moolenaarb84a3812020-05-01 15:44:29 +02003258 free_locals(&cctx);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003259 ga_clear(&cctx.ctx_type_stack);
Bram Moolenaar822ba242020-05-24 23:00:18 +02003260 return ret;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003261}
3262
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003263 void
3264set_function_type(ufunc_T *ufunc)
3265{
3266 int varargs = ufunc->uf_va_name != NULL;
3267 int argcount = ufunc->uf_args.ga_len;
3268
3269 // Create a type for the function, with the return type and any
3270 // argument types.
3271 // A vararg is included in uf_args.ga_len but not in uf_arg_types.
3272 // The type is included in "tt_args".
3273 if (argcount > 0 || varargs)
3274 {
Bram Moolenaar18062fc2021-03-05 21:35:47 +01003275 if (ufunc->uf_type_list.ga_itemsize == 0)
3276 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003277 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
3278 argcount, &ufunc->uf_type_list);
3279 // Add argument types to the function type.
3280 if (func_type_add_arg_types(ufunc->uf_func_type,
3281 argcount + varargs,
3282 &ufunc->uf_type_list) == FAIL)
3283 return;
3284 ufunc->uf_func_type->tt_argcount = argcount + varargs;
3285 ufunc->uf_func_type->tt_min_argcount =
3286 argcount - ufunc->uf_def_args.ga_len;
3287 if (ufunc->uf_arg_types == NULL)
3288 {
3289 int i;
3290
3291 // lambda does not have argument types.
3292 for (i = 0; i < argcount; ++i)
3293 ufunc->uf_func_type->tt_args[i] = &t_any;
3294 }
3295 else
3296 mch_memmove(ufunc->uf_func_type->tt_args,
3297 ufunc->uf_arg_types, sizeof(type_T *) * argcount);
3298 if (varargs)
3299 {
3300 ufunc->uf_func_type->tt_args[argcount] =
Bram Moolenaar2a389082021-04-09 20:24:31 +02003301 ufunc->uf_va_type == NULL ? &t_list_any : ufunc->uf_va_type;
Bram Moolenaar6ff71d82020-05-24 23:45:24 +02003302 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
3303 }
3304 }
3305 else
3306 // No arguments, can use a predefined type.
3307 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
3308 argcount, &ufunc->uf_type_list);
3309}
3310
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003311/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003312 * Free all instructions for "dfunc" except df_name.
Bram Moolenaar20431c92020-03-20 18:39:46 +01003313 */
3314 static void
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003315delete_def_function_contents(dfunc_T *dfunc, int mark_deleted)
Bram Moolenaar20431c92020-03-20 18:39:46 +01003316{
3317 int idx;
3318
3319 ga_clear(&dfunc->df_def_args_isn);
Bram Moolenaarb69c6fb2021-06-14 20:40:37 +02003320 ga_clear_strings(&dfunc->df_var_names);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003321
3322 if (dfunc->df_instr != NULL)
3323 {
3324 for (idx = 0; idx < dfunc->df_instr_count; ++idx)
3325 delete_instr(dfunc->df_instr + idx);
3326 VIM_CLEAR(dfunc->df_instr);
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003327 dfunc->df_instr = NULL;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003328 }
Bram Moolenaarc2dec4c2021-06-13 15:39:00 +02003329 if (dfunc->df_instr_debug != NULL)
3330 {
3331 for (idx = 0; idx < dfunc->df_instr_debug_count; ++idx)
3332 delete_instr(dfunc->df_instr_debug + idx);
3333 VIM_CLEAR(dfunc->df_instr_debug);
3334 dfunc->df_instr_debug = NULL;
3335 }
Bram Moolenaarc05fe072021-01-24 21:30:48 +01003336#ifdef FEAT_PROFILE
3337 if (dfunc->df_instr_prof != NULL)
3338 {
3339 for (idx = 0; idx < dfunc->df_instr_prof_count; ++idx)
3340 delete_instr(dfunc->df_instr_prof + idx);
3341 VIM_CLEAR(dfunc->df_instr_prof);
3342 dfunc->df_instr_prof = NULL;
3343 }
3344#endif
Bram Moolenaar20431c92020-03-20 18:39:46 +01003345
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003346 if (mark_deleted)
3347 dfunc->df_deleted = TRUE;
3348 if (dfunc->df_ufunc != NULL)
3349 dfunc->df_ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaar20431c92020-03-20 18:39:46 +01003350}
3351
3352/*
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003353 * When a user function is deleted, clear the contents of any associated def
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003354 * function, unless another user function still uses it.
3355 * The position in def_functions can be re-used.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003356 */
3357 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003358unlink_def_function(ufunc_T *ufunc)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003359{
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003360 if (ufunc->uf_dfunc_idx > 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003361 {
3362 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3363 + ufunc->uf_dfunc_idx;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003364
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003365 if (--dfunc->df_refcount <= 0)
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003366 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +02003367 ufunc->uf_def_status = UF_NOT_COMPILED;
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003368 ufunc->uf_dfunc_idx = 0;
3369 if (dfunc->df_ufunc == ufunc)
3370 dfunc->df_ufunc = NULL;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003371 }
3372}
3373
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003374/*
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003375 * Used when a user function refers to an existing dfunc.
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003376 */
3377 void
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003378link_def_function(ufunc_T *ufunc)
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003379{
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003380 if (ufunc->uf_dfunc_idx > 0)
3381 {
3382 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
3383 + ufunc->uf_dfunc_idx;
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003384
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003385 ++dfunc->df_refcount;
3386 }
Bram Moolenaarfdeab652020-09-19 15:16:50 +02003387}
3388
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003389#if defined(EXITFREE) || defined(PROTO)
Bram Moolenaar20431c92020-03-20 18:39:46 +01003390/*
3391 * Free all functions defined with ":def".
3392 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003393 void
3394free_def_functions(void)
3395{
Bram Moolenaar20431c92020-03-20 18:39:46 +01003396 int idx;
3397
3398 for (idx = 0; idx < def_functions.ga_len; ++idx)
3399 {
3400 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx;
3401
Bram Moolenaarcdc40c42020-12-26 17:43:08 +01003402 delete_def_function_contents(dfunc, TRUE);
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003403 vim_free(dfunc->df_name);
Bram Moolenaar20431c92020-03-20 18:39:46 +01003404 }
3405
3406 ga_clear(&def_functions);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003407}
3408#endif
3409
3410
3411#endif // FEAT_EVAL