blob: a9c36ac38c11536d563ac1dafb60f2e4f648c611 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * eval.c: Expression evaluation.
12 */
Bram Moolenaarfefecb02016-02-27 21:27:20 +010013#define USING_FLOAT_STUFF
Bram Moolenaar071d4272004-06-13 20:20:40 +000014
15#include "vim.h"
16
Bram Moolenaar8c8de832008-06-24 22:58:06 +000017#if defined(FEAT_EVAL) || defined(PROTO)
18
Bram Moolenaar314f11d2010-08-09 22:07:08 +020019#ifdef VMS
20# include <float.h>
21#endif
22
Bram Moolenaar9ef486d2005-01-17 22:23:00 +000023static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
Bram Moolenaar8c8de832008-06-24 22:58:06 +000024
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +010025#define NAMESPACE_CHAR (char_u *)"abglstvw"
26
Bram Moolenaar532c7802005-01-27 14:44:31 +000027/*
Bram Moolenaard9fba312005-06-26 22:34:35 +000028 * When recursively copying lists and dicts we need to remember which ones we
29 * have done to avoid endless recursiveness. This unique ID is used for that.
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +000030 * The last bit is used for previous_funccal, ignored when comparing.
Bram Moolenaard9fba312005-06-26 22:34:35 +000031 */
32static int current_copyID = 0;
Bram Moolenaar8502c702014-06-17 12:51:16 +020033
Bram Moolenaar071d4272004-06-13 20:20:40 +000034/*
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000035 * Info used by a ":for" loop.
36 */
Bram Moolenaar33570922005-01-25 22:26:29 +000037typedef struct
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000038{
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010039 int fi_semicolon; // TRUE if ending in '; var]'
40 int fi_varcount; // nr of variables in the list
Bram Moolenaarb7a78f72020-06-28 18:43:40 +020041 int fi_break_count; // nr of line breaks encountered
Bram Moolenaar5d18efe2019-12-01 21:11:22 +010042 listwatch_T fi_lw; // keep an eye on the item used.
43 list_T *fi_list; // list being used
44 int fi_bi; // index of blob
45 blob_T *fi_blob; // blob being used
Bram Moolenaar33570922005-01-25 22:26:29 +000046} forinfo_T;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000047
Bram Moolenaar48e697e2016-01-23 22:17:30 +010048static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +020049static int eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg);
50static int eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg);
51static int eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg);
52static int eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg);
53static int eval6(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string);
54static int eval7(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string);
Bram Moolenaar0b1cd522020-06-27 13:11:50 +020055static int eval7_leader(typval_T *rettv, int numeric_only, char_u *start_leader, char_u **end_leaderp);
Bram Moolenaara40058a2005-07-11 22:42:07 +000056
Bram Moolenaar48e697e2016-01-23 22:17:30 +010057static int free_unref_items(int copyID);
Bram Moolenaar5843f5f2019-08-20 20:13:45 +020058static char_u *make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end);
Bram Moolenaar2c704a72010-06-03 21:17:25 +020059
Bram Moolenaare21c1582019-03-02 11:57:09 +010060/*
61 * Return "n1" divided by "n2", taking care of dividing by zero.
62 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +020063 varnumber_T
Bram Moolenaare21c1582019-03-02 11:57:09 +010064num_divide(varnumber_T n1, varnumber_T n2)
65{
66 varnumber_T result;
67
68 if (n2 == 0) // give an error message?
69 {
70 if (n1 == 0)
71 result = VARNUM_MIN; // similar to NaN
72 else if (n1 < 0)
73 result = -VARNUM_MAX;
74 else
75 result = VARNUM_MAX;
76 }
77 else
78 result = n1 / n2;
79
80 return result;
81}
82
83/*
84 * Return "n1" modulus "n2", taking care of dividing by zero.
85 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +020086 varnumber_T
Bram Moolenaare21c1582019-03-02 11:57:09 +010087num_modulus(varnumber_T n1, varnumber_T n2)
88{
89 // Give an error when n2 is 0?
90 return (n2 == 0) ? 0 : (n1 % n2);
91}
92
Bram Moolenaara1fa8922017-01-12 20:06:33 +010093#if defined(EBCDIC) || defined(PROTO)
94/*
95 * Compare struct fst by function name.
96 */
97 static int
98compare_func_name(const void *s1, const void *s2)
99{
100 struct fst *p1 = (struct fst *)s1;
101 struct fst *p2 = (struct fst *)s2;
102
103 return STRCMP(p1->f_name, p2->f_name);
104}
105
106/*
107 * Sort the function table by function name.
Bram Moolenaarb5443cc2019-01-15 20:19:40 +0100108 * The sorting of the table above is ASCII dependent.
Bram Moolenaara1fa8922017-01-12 20:06:33 +0100109 * On machines using EBCDIC we have to sort it.
110 */
111 static void
112sortFunctions(void)
113{
114 int funcCnt = (int)(sizeof(functions) / sizeof(struct fst)) - 1;
115
116 qsort(functions, (size_t)funcCnt, sizeof(struct fst), compare_func_name);
117}
118#endif
119
Bram Moolenaar33570922005-01-25 22:26:29 +0000120/*
121 * Initialize the global and v: variables.
Bram Moolenaara7043832005-01-21 11:56:39 +0000122 */
123 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100124eval_init(void)
Bram Moolenaara7043832005-01-21 11:56:39 +0000125{
Bram Moolenaare5cdf152019-08-29 22:09:46 +0200126 evalvars_init();
Bram Moolenaara9b579f2016-07-17 18:29:19 +0200127 func_init();
Bram Moolenaar33570922005-01-25 22:26:29 +0000128
Bram Moolenaar2c704a72010-06-03 21:17:25 +0200129#ifdef EBCDIC
130 /*
Bram Moolenaar195ea0f2011-11-30 14:57:31 +0100131 * Sort the function table, to enable binary search.
Bram Moolenaar2c704a72010-06-03 21:17:25 +0200132 */
133 sortFunctions();
134#endif
Bram Moolenaara7043832005-01-21 11:56:39 +0000135}
136
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000137#if defined(EXITFREE) || defined(PROTO)
138 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100139eval_clear(void)
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000140{
Bram Moolenaare5cdf152019-08-29 22:09:46 +0200141 evalvars_clear();
Bram Moolenaar7ebcba62020-01-12 17:42:55 +0100142 free_scriptnames(); // must come after evalvars_clear().
Bram Moolenaar9b486ca2011-05-19 18:26:40 +0200143 free_locales();
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000144
Bram Moolenaarda6c0332019-09-01 16:01:30 +0200145 // autoloaded script names
146 free_autoload_scriptnames();
Bram Moolenaaraa35dd12006-04-29 22:03:41 +0000147
Bram Moolenaar75ee5442019-06-06 18:05:25 +0200148 // unreferenced lists and dicts
149 (void)garbage_collect(FALSE);
Bram Moolenaarc07f67a2019-06-06 19:03:17 +0200150
151 // functions not garbage collected
152 free_all_functions();
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000153}
154#endif
155
Bram Moolenaare6b53242020-07-01 17:28:33 +0200156 void
Bram Moolenaar37c83712020-06-30 21:18:36 +0200157fill_evalarg_from_eap(evalarg_T *evalarg, exarg_T *eap, int skip)
158{
159 CLEAR_FIELD(*evalarg);
160 evalarg->eval_flags = skip ? 0 : EVAL_EVALUATE;
161 if (eap != NULL && getline_equal(eap->getline, eap->cookie, getsourceline))
162 {
163 evalarg->eval_getline = eap->getline;
164 evalarg->eval_cookie = eap->cookie;
165 }
166}
167
Bram Moolenaar071d4272004-06-13 20:20:40 +0000168/*
169 * Top level evaluation function, returning a boolean.
170 * Sets "error" to TRUE if there was an error.
171 * Return TRUE or FALSE.
172 */
173 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100174eval_to_bool(
175 char_u *arg,
176 int *error,
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200177 exarg_T *eap,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100178 int skip) // only parse, don't execute
Bram Moolenaar071d4272004-06-13 20:20:40 +0000179{
Bram Moolenaar33570922005-01-25 22:26:29 +0000180 typval_T tv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200181 varnumber_T retval = FALSE;
Bram Moolenaarfaf86262020-06-27 23:07:36 +0200182 evalarg_T evalarg;
183
Bram Moolenaar37c83712020-06-30 21:18:36 +0200184 fill_evalarg_from_eap(&evalarg, eap, skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000185
186 if (skip)
187 ++emsg_skip;
Bram Moolenaarfaf86262020-06-27 23:07:36 +0200188 if (eval0(arg, &tv, eap, &evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000189 *error = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000190 else
191 {
192 *error = FALSE;
193 if (!skip)
194 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100195 retval = (tv_get_number_chk(&tv, error) != 0);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000196 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000197 }
198 }
199 if (skip)
200 --emsg_skip;
Bram Moolenaarfaf86262020-06-27 23:07:36 +0200201 clear_evalarg(&evalarg, eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000202
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200203 return (int)retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000204}
205
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100206/*
207 * Call eval1() and give an error message if not done at a lower level.
208 */
209 static int
Bram Moolenaar47e880d2020-06-30 22:02:02 +0200210eval1_emsg(char_u **arg, typval_T *rettv, exarg_T *eap)
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100211{
Bram Moolenaar6acc79f2019-01-14 22:53:31 +0100212 char_u *start = *arg;
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100213 int ret;
214 int did_emsg_before = did_emsg;
215 int called_emsg_before = called_emsg;
Bram Moolenaar47e880d2020-06-30 22:02:02 +0200216 evalarg_T evalarg;
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100217
Bram Moolenaar47e880d2020-06-30 22:02:02 +0200218 fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip);
219
220 ret = eval1(arg, rettv, &evalarg);
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100221 if (ret == FAIL)
222 {
223 // Report the invalid expression unless the expression evaluation has
224 // been cancelled due to an aborting error, an interrupt, or an
225 // exception, or we already gave a more specific error.
226 // Also check called_emsg for when using assert_fails().
227 if (!aborting() && did_emsg == did_emsg_before
228 && called_emsg == called_emsg_before)
Bram Moolenaar6acc79f2019-01-14 22:53:31 +0100229 semsg(_(e_invexpr2), start);
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100230 }
Bram Moolenaar47e880d2020-06-30 22:02:02 +0200231 clear_evalarg(&evalarg, eap);
Bram Moolenaarce9d50d2019-01-14 22:22:29 +0100232 return ret;
233}
234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100235/*
Bram Moolenaara9c01042020-06-07 14:50:50 +0200236 * Return whether a typval is a valid expression to pass to eval_expr_typval()
237 * or eval_expr_to_bool(). An empty string returns FALSE;
238 */
239 int
240eval_expr_valid_arg(typval_T *tv)
241{
242 return tv->v_type != VAR_UNKNOWN
243 && (tv->v_type != VAR_STRING
244 || (tv->vval.v_string != NULL && *tv->vval.v_string != NUL));
245}
246
247/*
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100248 * Evaluate an expression, which can be a function, partial or string.
249 * Pass arguments "argv[argc]".
250 * Return the result in "rettv" and OK or FAIL.
251 */
Bram Moolenaar543c9b12019-04-05 22:50:40 +0200252 int
Bram Moolenaar48570482017-10-30 21:48:41 +0100253eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv)
254{
255 char_u *s;
Bram Moolenaar48570482017-10-30 21:48:41 +0100256 char_u buf[NUMBUFLEN];
Bram Moolenaarc6538bc2019-08-03 18:17:11 +0200257 funcexe_T funcexe;
Bram Moolenaar48570482017-10-30 21:48:41 +0100258
259 if (expr->v_type == VAR_FUNC)
260 {
261 s = expr->vval.v_string;
262 if (s == NULL || *s == NUL)
263 return FAIL;
Bram Moolenaara80faa82020-04-12 19:37:17 +0200264 CLEAR_FIELD(funcexe);
Bram Moolenaarc6538bc2019-08-03 18:17:11 +0200265 funcexe.evaluate = TRUE;
266 if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL)
Bram Moolenaar48570482017-10-30 21:48:41 +0100267 return FAIL;
268 }
269 else if (expr->v_type == VAR_PARTIAL)
270 {
271 partial_T *partial = expr->vval.v_partial;
272
Bram Moolenaar9d8d0b52020-04-24 22:47:31 +0200273 if (partial == NULL)
274 return FAIL;
275
Bram Moolenaar822ba242020-05-24 23:00:18 +0200276 if (partial->pt_func != NULL
Bram Moolenaar0cb5bcf2020-06-20 18:19:09 +0200277 && partial->pt_func->uf_def_status != UF_NOT_COMPILED)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100278 {
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +0200279 if (call_def_function(partial->pt_func, argc, argv,
280 partial, rettv) == FAIL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100281 return FAIL;
282 }
283 else
284 {
285 s = partial_name(partial);
286 if (s == NULL || *s == NUL)
287 return FAIL;
Bram Moolenaara80faa82020-04-12 19:37:17 +0200288 CLEAR_FIELD(funcexe);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100289 funcexe.evaluate = TRUE;
290 funcexe.partial = partial;
291 if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL)
292 return FAIL;
293 }
Bram Moolenaar48570482017-10-30 21:48:41 +0100294 }
295 else
296 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100297 s = tv_get_string_buf_chk(expr, buf);
Bram Moolenaar48570482017-10-30 21:48:41 +0100298 if (s == NULL)
299 return FAIL;
300 s = skipwhite(s);
Bram Moolenaar47e880d2020-06-30 22:02:02 +0200301 if (eval1_emsg(&s, rettv, NULL) == FAIL)
Bram Moolenaar48570482017-10-30 21:48:41 +0100302 return FAIL;
Bram Moolenaarf96e9de2020-08-03 22:39:28 +0200303 if (*skipwhite(s) != NUL) // check for trailing chars after expr
Bram Moolenaar48570482017-10-30 21:48:41 +0100304 {
Bram Moolenaara43ebe92018-07-14 17:25:01 +0200305 clear_tv(rettv);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100306 semsg(_(e_invexpr2), s);
Bram Moolenaar48570482017-10-30 21:48:41 +0100307 return FAIL;
308 }
309 }
310 return OK;
311}
312
313/*
314 * Like eval_to_bool() but using a typval_T instead of a string.
315 * Works for string, funcref and partial.
316 */
317 int
318eval_expr_to_bool(typval_T *expr, int *error)
319{
320 typval_T rettv;
321 int res;
322
323 if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL)
324 {
325 *error = TRUE;
326 return FALSE;
327 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100328 res = (tv_get_number_chk(&rettv, error) != 0);
Bram Moolenaar48570482017-10-30 21:48:41 +0100329 clear_tv(&rettv);
330 return res;
331}
332
Bram Moolenaar071d4272004-06-13 20:20:40 +0000333/*
334 * Top level evaluation function, returning a string. If "skip" is TRUE,
335 * only parsing to "nextcmd" is done, without reporting errors. Return
336 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
337 */
338 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100339eval_to_string_skip(
340 char_u *arg,
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200341 exarg_T *eap,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100342 int skip) // only parse, don't execute
Bram Moolenaar071d4272004-06-13 20:20:40 +0000343{
Bram Moolenaar33570922005-01-25 22:26:29 +0000344 typval_T tv;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000345 char_u *retval;
Bram Moolenaar006ad482020-06-30 20:55:15 +0200346 evalarg_T evalarg;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000347
Bram Moolenaar37c83712020-06-30 21:18:36 +0200348 fill_evalarg_from_eap(&evalarg, eap, skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000349 if (skip)
350 ++emsg_skip;
Bram Moolenaar006ad482020-06-30 20:55:15 +0200351 if (eval0(arg, &tv, eap, &evalarg) == FAIL || skip)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000352 retval = NULL;
353 else
354 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100355 retval = vim_strsave(tv_get_string(&tv));
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000356 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000357 }
358 if (skip)
359 --emsg_skip;
Bram Moolenaar006ad482020-06-30 20:55:15 +0200360 clear_evalarg(&evalarg, eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000361
362 return retval;
363}
364
365/*
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000366 * Skip over an expression at "*pp".
367 * Return FAIL for an error, OK otherwise.
368 */
369 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100370skip_expr(char_u **pp)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000371{
Bram Moolenaar33570922005-01-25 22:26:29 +0000372 typval_T rettv;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000373
374 *pp = skipwhite(*pp);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200375 return eval1(pp, &rettv, NULL);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000376}
377
378/*
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200379 * Skip over an expression at "*pp".
380 * If in Vim9 script and line breaks are encountered, the lines are
381 * concatenated. "evalarg->eval_tofree" will be set accordingly.
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200382 * "arg" is advanced to just after the expression.
383 * "start" is set to the start of the expression, "end" to just after the end.
384 * Also when the expression is copied to allocated memory.
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200385 * Return FAIL for an error, OK otherwise.
386 */
387 int
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200388skip_expr_concatenate(
389 char_u **arg,
390 char_u **start,
391 char_u **end,
392 evalarg_T *evalarg)
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200393{
394 typval_T rettv;
395 int res;
Bram Moolenaareb6880b2020-07-12 17:07:05 +0200396 int vim9script = in_vim9script();
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200397 garray_T *gap = &evalarg->eval_ga;
398 int save_flags = evalarg == NULL ? 0 : evalarg->eval_flags;
399
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200400 if (vim9script
401 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL))
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200402 {
403 ga_init2(gap, sizeof(char_u *), 10);
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200404 // leave room for "start"
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200405 if (ga_grow(gap, 1) == OK)
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200406 ++gap->ga_len;
407 }
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200408 *start = *arg;
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200409
410 // Don't evaluate the expression.
411 if (evalarg != NULL)
412 evalarg->eval_flags &= ~EVAL_EVALUATE;
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200413 *arg = skipwhite(*arg);
414 res = eval1(arg, &rettv, evalarg);
415 *end = *arg;
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200416 if (evalarg != NULL)
417 evalarg->eval_flags = save_flags;
418
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200419 if (vim9script
420 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL))
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200421 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200422 if (evalarg->eval_ga.ga_len == 1)
423 {
424 // just one line, no need to concatenate
425 ga_clear(gap);
426 gap->ga_itemsize = 0;
427 }
428 else
429 {
430 char_u *p;
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200431 size_t endoff = STRLEN(*arg);
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200432
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200433 // Line breaks encountered, concatenate all the lines.
434 *((char_u **)gap->ga_data) = *start;
435 p = ga_concat_strings(gap, "");
436
437 // free the lines only when using getsourceline()
438 if (evalarg->eval_cookie != NULL)
439 {
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200440 // Do not free the first line, the caller can still use it.
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200441 *((char_u **)gap->ga_data) = NULL;
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200442 // Do not free the last line, "arg" points into it, free it
443 // later.
444 vim_free(evalarg->eval_tofree);
445 evalarg->eval_tofree =
446 ((char_u **)gap->ga_data)[gap->ga_len - 1];
447 ((char_u **)gap->ga_data)[gap->ga_len - 1] = NULL;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200448 ga_clear_strings(gap);
449 }
450 else
451 ga_clear(gap);
452 gap->ga_itemsize = 0;
453 if (p == NULL)
454 return FAIL;
455 *start = p;
Bram Moolenaar8e2730a2020-07-08 22:01:49 +0200456 vim_free(evalarg->eval_tofree_lambda);
457 evalarg->eval_tofree_lambda = p;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200458 // Compute "end" relative to the end.
459 *end = *start + STRLEN(*start) - endoff;
460 }
Bram Moolenaare40fbc22020-06-27 18:06:45 +0200461 }
462
463 return res;
464}
465
466/*
Bram Moolenaar7a4b8982020-07-08 17:36:21 +0200467 * Top level evaluation function, returning a string. Does not handle line
468 * breaks.
Bram Moolenaara85fb752008-09-07 11:55:43 +0000469 * When "convert" is TRUE convert a List into a sequence of lines and convert
470 * a Float to a String.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000471 * Return pointer to allocated memory, or NULL for failure.
472 */
473 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100474eval_to_string(
475 char_u *arg,
Bram Moolenaar7454a062016-01-30 15:14:10 +0100476 int convert)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000477{
Bram Moolenaar33570922005-01-25 22:26:29 +0000478 typval_T tv;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000479 char_u *retval;
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000480 garray_T ga;
Bram Moolenaar798b30b2009-04-22 10:56:16 +0000481#ifdef FEAT_FLOAT
Bram Moolenaara85fb752008-09-07 11:55:43 +0000482 char_u numbuf[NUMBUFLEN];
Bram Moolenaar798b30b2009-04-22 10:56:16 +0000483#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000484
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200485 if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000486 retval = NULL;
487 else
488 {
Bram Moolenaara85fb752008-09-07 11:55:43 +0000489 if (convert && tv.v_type == VAR_LIST)
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000490 {
491 ga_init2(&ga, (int)sizeof(char), 80);
Bram Moolenaar9bf749b2008-07-27 13:57:29 +0000492 if (tv.vval.v_list != NULL)
Bram Moolenaar213b10a2011-08-10 12:38:08 +0200493 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +0200494 list_join(&ga, tv.vval.v_list, (char_u *)"\n", TRUE, FALSE, 0);
Bram Moolenaar213b10a2011-08-10 12:38:08 +0200495 if (tv.vval.v_list->lv_len > 0)
496 ga_append(&ga, NL);
497 }
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000498 ga_append(&ga, NUL);
499 retval = (char_u *)ga.ga_data;
500 }
Bram Moolenaara85fb752008-09-07 11:55:43 +0000501#ifdef FEAT_FLOAT
502 else if (convert && tv.v_type == VAR_FLOAT)
503 {
504 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float);
505 retval = vim_strsave(numbuf);
506 }
507#endif
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000508 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100509 retval = vim_strsave(tv_get_string(&tv));
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000510 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000511 }
Bram Moolenaarb7a78f72020-06-28 18:43:40 +0200512 clear_evalarg(&EVALARG_EVALUATE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000513
514 return retval;
515}
516
517/*
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000518 * Call eval_to_string() without using current local variables and using
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +0200519 * textwinlock. When "use_sandbox" is TRUE use the sandbox.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000520 */
521 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100522eval_to_string_safe(
523 char_u *arg,
Bram Moolenaar7454a062016-01-30 15:14:10 +0100524 int use_sandbox)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000525{
526 char_u *retval;
Bram Moolenaar27e80c82018-10-14 21:41:01 +0200527 funccal_entry_T funccal_entry;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528
Bram Moolenaar27e80c82018-10-14 21:41:01 +0200529 save_funccal(&funccal_entry);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000530 if (use_sandbox)
531 ++sandbox;
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +0200532 ++textwinlock;
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200533 retval = eval_to_string(arg, FALSE);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000534 if (use_sandbox)
535 --sandbox;
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +0200536 --textwinlock;
Bram Moolenaar27e80c82018-10-14 21:41:01 +0200537 restore_funccal();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000538 return retval;
539}
540
Bram Moolenaar071d4272004-06-13 20:20:40 +0000541/*
542 * Top level evaluation function, returning a number.
543 * Evaluates "expr" silently.
544 * Returns -1 for an error.
545 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200546 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +0100547eval_to_number(char_u *expr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000548{
Bram Moolenaar33570922005-01-25 22:26:29 +0000549 typval_T rettv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200550 varnumber_T retval;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +0000551 char_u *p = skipwhite(expr);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000552
553 ++emsg_off;
554
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200555 if (eval1(&p, &rettv, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000556 retval = -1;
557 else
558 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100559 retval = tv_get_number_chk(&rettv, NULL);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000560 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000561 }
562 --emsg_off;
563
564 return retval;
565}
566
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000567/*
Bram Moolenaar4770d092006-01-12 23:22:24 +0000568 * Top level evaluation function.
569 * Returns an allocated typval_T with the result.
570 * Returns NULL when there is an error.
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000571 */
572 typval_T *
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200573eval_expr(char_u *arg, exarg_T *eap)
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000574{
575 typval_T *tv;
Bram Moolenaar37c83712020-06-30 21:18:36 +0200576 evalarg_T evalarg;
577
578 fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip);
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000579
Bram Moolenaarc799fe22019-05-28 23:08:19 +0200580 tv = ALLOC_ONE(typval_T);
Bram Moolenaar37c83712020-06-30 21:18:36 +0200581 if (tv != NULL && eval0(arg, tv, eap, &evalarg) == FAIL)
Bram Moolenaard23a8232018-02-10 18:45:26 +0100582 VIM_CLEAR(tv);
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000583
Bram Moolenaar37c83712020-06-30 21:18:36 +0200584 clear_evalarg(&evalarg, eap);
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000585 return tv;
586}
587
Bram Moolenaar071d4272004-06-13 20:20:40 +0000588/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +0100589 * Call some Vim script function and return the result in "*rettv".
Bram Moolenaarffa96842018-06-12 22:05:14 +0200590 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc]
591 * should have type VAR_UNKNOWN.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000592 * Returns OK or FAIL.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000593 */
Bram Moolenaar82139082011-09-14 16:52:09 +0200594 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100595call_vim_function(
596 char_u *func,
597 int argc,
Bram Moolenaarffa96842018-06-12 22:05:14 +0200598 typval_T *argv,
Bram Moolenaarded27a12018-08-01 19:06:03 +0200599 typval_T *rettv)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000600{
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000601 int ret;
Bram Moolenaarc6538bc2019-08-03 18:17:11 +0200602 funcexe_T funcexe;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000603
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100604 rettv->v_type = VAR_UNKNOWN; // clear_tv() uses this
Bram Moolenaara80faa82020-04-12 19:37:17 +0200605 CLEAR_FIELD(funcexe);
Bram Moolenaarc6538bc2019-08-03 18:17:11 +0200606 funcexe.firstline = curwin->w_cursor.lnum;
607 funcexe.lastline = curwin->w_cursor.lnum;
608 funcexe.evaluate = TRUE;
609 ret = call_func(func, -1, rettv, argc, argv, &funcexe);
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000610 if (ret == FAIL)
611 clear_tv(rettv);
612
613 return ret;
614}
615
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100616/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +0100617 * Call Vim script function "func" and return the result as a number.
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100618 * Returns -1 when calling the function fails.
Bram Moolenaarffa96842018-06-12 22:05:14 +0200619 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should
620 * have type VAR_UNKNOWN.
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100621 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200622 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +0100623call_func_retnr(
624 char_u *func,
625 int argc,
Bram Moolenaarded27a12018-08-01 19:06:03 +0200626 typval_T *argv)
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100627{
628 typval_T rettv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200629 varnumber_T retval;
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100630
Bram Moolenaarded27a12018-08-01 19:06:03 +0200631 if (call_vim_function(func, argc, argv, &rettv) == FAIL)
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100632 return -1;
633
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100634 retval = tv_get_number_chk(&rettv, NULL);
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100635 clear_tv(&rettv);
636 return retval;
637}
638
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000639/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +0100640 * Call Vim script function "func" and return the result as a string.
Bram Moolenaar25ceb222005-07-30 22:45:36 +0000641 * Returns NULL when calling the function fails.
Bram Moolenaarffa96842018-06-12 22:05:14 +0200642 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should
643 * have type VAR_UNKNOWN.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000644 */
645 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100646call_func_retstr(
647 char_u *func,
648 int argc,
Bram Moolenaarded27a12018-08-01 19:06:03 +0200649 typval_T *argv)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000650{
651 typval_T rettv;
Bram Moolenaar25ceb222005-07-30 22:45:36 +0000652 char_u *retval;
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000653
Bram Moolenaarded27a12018-08-01 19:06:03 +0200654 if (call_vim_function(func, argc, argv, &rettv) == FAIL)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000655 return NULL;
656
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100657 retval = vim_strsave(tv_get_string(&rettv));
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000658 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000659 return retval;
660}
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000661
Bram Moolenaar25ceb222005-07-30 22:45:36 +0000662/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +0100663 * Call Vim script function "func" and return the result as a List.
Bram Moolenaarffa96842018-06-12 22:05:14 +0200664 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should
665 * have type VAR_UNKNOWN.
Bram Moolenaar9bf749b2008-07-27 13:57:29 +0000666 * Returns NULL when there is something wrong.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000667 */
668 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100669call_func_retlist(
670 char_u *func,
671 int argc,
Bram Moolenaarded27a12018-08-01 19:06:03 +0200672 typval_T *argv)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000673{
674 typval_T rettv;
675
Bram Moolenaarded27a12018-08-01 19:06:03 +0200676 if (call_vim_function(func, argc, argv, &rettv) == FAIL)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +0000677 return NULL;
678
679 if (rettv.v_type != VAR_LIST)
680 {
681 clear_tv(&rettv);
682 return NULL;
683 }
684
685 return rettv.vval.v_list;
686}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000687
Bram Moolenaar071d4272004-06-13 20:20:40 +0000688#ifdef FEAT_FOLDING
689/*
690 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
691 * it in "*cp". Doesn't give error messages.
692 */
693 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100694eval_foldexpr(char_u *arg, int *cp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000695{
Bram Moolenaar33570922005-01-25 22:26:29 +0000696 typval_T tv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200697 varnumber_T retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000698 char_u *s;
Bram Moolenaard1f56e62006-02-22 21:25:37 +0000699 int use_sandbox = was_set_insecurely((char_u *)"foldexpr",
700 OPT_LOCAL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000701
702 ++emsg_off;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000703 if (use_sandbox)
704 ++sandbox;
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +0200705 ++textwinlock;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706 *cp = NUL;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200707 if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000708 retval = 0;
709 else
710 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100711 // If the result is a number, just return the number.
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000712 if (tv.v_type == VAR_NUMBER)
713 retval = tv.vval.v_number;
Bram Moolenaar758711c2005-02-02 23:11:38 +0000714 else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000715 retval = 0;
716 else
717 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100718 // If the result is a string, check if there is a non-digit before
719 // the number.
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000720 s = tv.vval.v_string;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000721 if (!VIM_ISDIGIT(*s) && *s != '-')
722 *cp = *s++;
723 retval = atol((char *)s);
724 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000725 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000726 }
727 --emsg_off;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000728 if (use_sandbox)
729 --sandbox;
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +0200730 --textwinlock;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +0200731 clear_evalarg(&EVALARG_EVALUATE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000732
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200733 return (int)retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000734}
735#endif
736
Bram Moolenaar071d4272004-06-13 20:20:40 +0000737/*
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000738 * Get an lval: variable, Dict item or List item that can be assigned a value
739 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
740 * "name.key", "name.key[expr]" etc.
741 * Indexing only works if "name" is an existing List or Dictionary.
742 * "name" points to the start of the name.
743 * If "rettv" is not NULL it points to the value to be assigned.
744 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
745 * wrong; must end in space or cmd separator.
746 *
Bram Moolenaar6d977d62014-01-14 15:24:39 +0100747 * flags:
748 * GLV_QUIET: do not give error messages
Bram Moolenaar3a257732017-02-21 20:47:13 +0100749 * GLV_READ_ONLY: will not change the variable
Bram Moolenaar6d977d62014-01-14 15:24:39 +0100750 * GLV_NO_AUTOLOAD: do not use script autoloading
751 *
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000752 * Returns a pointer to just after the name, including indexes.
Bram Moolenaara7043832005-01-21 11:56:39 +0000753 * When an evaluation error occurs "lp->ll_name" is NULL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000754 * Returns NULL for a parsing error. Still need to free items in "lp"!
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000755 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +0200756 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100757get_lval(
758 char_u *name,
759 typval_T *rettv,
760 lval_T *lp,
761 int unlet,
762 int skip,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100763 int flags, // GLV_ values
764 int fne_flags) // flags for find_name_end()
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000765{
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000766 char_u *p;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000767 char_u *expr_start, *expr_end;
768 int cc;
Bram Moolenaar33570922005-01-25 22:26:29 +0000769 dictitem_T *v;
770 typval_T var1;
771 typval_T var2;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000772 int empty1 = FALSE;
Bram Moolenaar33570922005-01-25 22:26:29 +0000773 listitem_T *ni;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000774 char_u *key = NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000775 int len;
Bram Moolenaar33570922005-01-25 22:26:29 +0000776 hashtab_T *ht;
Bram Moolenaar6d977d62014-01-14 15:24:39 +0100777 int quiet = flags & GLV_QUIET;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000778
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100779 // Clear everything in "lp".
Bram Moolenaara80faa82020-04-12 19:37:17 +0200780 CLEAR_POINTER(lp);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000781
782 if (skip)
783 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100784 // When skipping just find the end of the name.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000785 lp->ll_name = name;
Bram Moolenaar9b5384b2020-06-29 22:31:36 +0200786 lp->ll_name_end = find_name_end(name, NULL, NULL,
787 FNE_INCL_BR | fne_flags);
788 return lp->ll_name_end;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000789 }
790
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100791 // Find the end of the name.
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +0000792 p = find_name_end(name, &expr_start, &expr_end, fne_flags);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100793 lp->ll_name_end = p;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000794 if (expr_start != NULL)
795 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100796 // Don't expand the name when we already know there is an error.
Bram Moolenaar1c465442017-03-12 20:10:05 +0100797 if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000798 && *p != '[' && *p != '.')
799 {
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +0200800 semsg(_(e_trailing_arg), p);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000801 return NULL;
802 }
803
804 lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p);
805 if (lp->ll_exp_name == NULL)
806 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100807 // Report an invalid expression in braces, unless the
808 // expression evaluation has been cancelled due to an
809 // aborting error, an interrupt, or an exception.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000810 if (!aborting() && !quiet)
811 {
Bram Moolenaarce5e58e2005-01-19 22:24:34 +0000812 emsg_severe = TRUE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100813 semsg(_(e_invarg2), name);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000814 return NULL;
815 }
816 }
817 lp->ll_name = lp->ll_exp_name;
818 }
819 else
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100820 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000821 lp->ll_name = name;
822
Bram Moolenaareb6880b2020-07-12 17:07:05 +0200823 if (in_vim9script() && *p == ':')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100824 {
Bram Moolenaar21b9e972020-01-26 19:26:46 +0100825 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100826 char_u *tp = skipwhite(p + 1);
827
828 // parse the type after the name
829 lp->ll_type = parse_type(&tp, &si->sn_type_list);
830 lp->ll_name_end = tp;
831 }
832 }
833
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100834 // Without [idx] or .key we are done.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000835 if ((*p != '[' && *p != '.') || lp->ll_name == NULL)
836 return p;
837
838 cc = *p;
839 *p = NUL;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100840 // Only pass &ht when we would write to the variable, it prevents autoload
841 // as well.
Bram Moolenaar6e65d592017-12-07 22:11:27 +0100842 v = find_var(lp->ll_name, (flags & GLV_READ_ONLY) ? NULL : &ht,
843 flags & GLV_NO_AUTOLOAD);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000844 if (v == NULL && !quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100845 semsg(_(e_undefvar), lp->ll_name);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000846 *p = cc;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000847 if (v == NULL)
848 return NULL;
849
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000850 /*
851 * Loop until no more [idx] or .key is following.
852 */
Bram Moolenaar33570922005-01-25 22:26:29 +0000853 lp->ll_tv = &v->di_tv;
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100854 var1.v_type = VAR_UNKNOWN;
855 var2.v_type = VAR_UNKNOWN;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000856 while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT))
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000857 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000858 if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL)
859 && !(lp->ll_tv->v_type == VAR_DICT
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +0100860 && lp->ll_tv->vval.v_dict != NULL)
861 && !(lp->ll_tv->v_type == VAR_BLOB
862 && lp->ll_tv->vval.v_blob != NULL))
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000863 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000864 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100865 emsg(_("E689: Can only index a List, Dictionary or Blob"));
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000866 return NULL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000867 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000868 if (lp->ll_range)
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000869 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000870 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100871 emsg(_("E708: [:] must come last"));
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000872 return NULL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000873 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000874
Bram Moolenaar8c711452005-01-14 21:53:12 +0000875 len = -1;
876 if (*p == '.')
877 {
878 key = p + 1;
879 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len)
880 ;
881 if (len == 0)
882 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000883 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100884 emsg(_(e_emptykey));
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000885 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000886 }
887 p = key + len;
888 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000889 else
890 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100891 // Get the index [expr] or the first index [expr: ].
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000892 p = skipwhite(p + 1);
Bram Moolenaar8c711452005-01-14 21:53:12 +0000893 if (*p == ':')
894 empty1 = TRUE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000895 else
896 {
Bram Moolenaar8c711452005-01-14 21:53:12 +0000897 empty1 = FALSE;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200898 if (eval1(&p, &var1, &EVALARG_EVALUATE) == FAIL) // recursive!
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000899 return NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100900 if (tv_get_string_chk(&var1) == NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000901 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100902 // not a number or string
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000903 clear_tv(&var1);
904 return NULL;
905 }
Bram Moolenaar6a250262020-08-04 15:53:01 +0200906 p = skipwhite(p);
Bram Moolenaar8c711452005-01-14 21:53:12 +0000907 }
908
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100909 // Optionally get the second index [ :expr].
Bram Moolenaar8c711452005-01-14 21:53:12 +0000910 if (*p == ':')
911 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000912 if (lp->ll_tv->v_type == VAR_DICT)
Bram Moolenaar8c711452005-01-14 21:53:12 +0000913 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000914 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100915 emsg(_(e_dictrange));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100916 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000917 return NULL;
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000918 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +0100919 if (rettv != NULL
920 && !(rettv->v_type == VAR_LIST
Bram Moolenaarc0f5a782019-01-13 15:16:13 +0100921 && rettv->vval.v_list != NULL)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +0100922 && !(rettv->v_type == VAR_BLOB
Bram Moolenaarc0f5a782019-01-13 15:16:13 +0100923 && rettv->vval.v_blob != NULL))
Bram Moolenaar8c711452005-01-14 21:53:12 +0000924 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000925 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100926 emsg(_("E709: [:] requires a List or Blob value"));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100927 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000928 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000929 }
930 p = skipwhite(p + 1);
931 if (*p == ']')
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000932 lp->ll_empty2 = TRUE;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000933 else
934 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000935 lp->ll_empty2 = FALSE;
Bram Moolenaar32e35112020-05-14 22:41:15 +0200936 // recursive!
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200937 if (eval1(&p, &var2, &EVALARG_EVALUATE) == FAIL)
Bram Moolenaar8c711452005-01-14 21:53:12 +0000938 {
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100939 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000940 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000941 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +0100942 if (tv_get_string_chk(&var2) == NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000943 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100944 // not a number or string
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100945 clear_tv(&var1);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000946 clear_tv(&var2);
947 return NULL;
948 }
Bram Moolenaar8c711452005-01-14 21:53:12 +0000949 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000950 lp->ll_range = TRUE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000951 }
Bram Moolenaar8c711452005-01-14 21:53:12 +0000952 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000953 lp->ll_range = FALSE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000954
Bram Moolenaar8c711452005-01-14 21:53:12 +0000955 if (*p != ']')
Bram Moolenaar6cc16192005-01-08 21:49:45 +0000956 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000957 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100958 emsg(_(e_missbrac));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +0100959 clear_tv(&var1);
960 clear_tv(&var2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000961 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000962 }
963
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100964 // Skip to past ']'.
Bram Moolenaar8c711452005-01-14 21:53:12 +0000965 ++p;
966 }
967
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000968 if (lp->ll_tv->v_type == VAR_DICT)
Bram Moolenaar8c711452005-01-14 21:53:12 +0000969 {
970 if (len == -1)
971 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100972 // "[key]": get key from "var1"
973 key = tv_get_string_chk(&var1); // is number or string
Bram Moolenaar0921ecf2016-04-03 22:44:36 +0200974 if (key == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +0000975 {
Bram Moolenaar8c711452005-01-14 21:53:12 +0000976 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +0000977 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +0000978 }
979 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +0000980 lp->ll_list = NULL;
981 lp->ll_dict = lp->ll_tv->vval.v_dict;
Bram Moolenaarce5e58e2005-01-19 22:24:34 +0000982 lp->ll_di = dict_find(lp->ll_dict, key, len);
Bram Moolenaar4228bec2011-03-27 16:03:15 +0200983
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100984 // When assigning to a scope dictionary check that a function and
985 // variable name is valid (only variable name unless it is l: or
986 // g: dictionary). Disallow overwriting a builtin function.
Bram Moolenaarbdb62052012-07-16 17:31:53 +0200987 if (rettv != NULL && lp->ll_dict->dv_scope != 0)
Bram Moolenaar4228bec2011-03-27 16:03:15 +0200988 {
Bram Moolenaarbdb62052012-07-16 17:31:53 +0200989 int prevval;
990 int wrong;
991
992 if (len != -1)
993 {
994 prevval = key[len];
995 key[len] = NUL;
996 }
Bram Moolenaar4380d1e2013-06-09 20:51:00 +0200997 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +0100998 prevval = 0; // avoid compiler warning
Bram Moolenaarbdb62052012-07-16 17:31:53 +0200999 wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE
1000 && rettv->v_type == VAR_FUNC
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001001 && var_check_func_name(key, lp->ll_di == NULL))
Bram Moolenaarbdb62052012-07-16 17:31:53 +02001002 || !valid_varname(key);
1003 if (len != -1)
1004 key[len] = prevval;
1005 if (wrong)
Bram Moolenaarea04a6e2020-04-23 13:38:02 +02001006 {
1007 clear_tv(&var1);
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001008 return NULL;
Bram Moolenaarea04a6e2020-04-23 13:38:02 +02001009 }
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001010 }
1011
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001012 if (lp->ll_di == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001013 {
Bram Moolenaar31b81602019-02-10 22:14:27 +01001014 // Can't add "v:" or "a:" variable.
Bram Moolenaarda6c0332019-09-01 16:01:30 +02001015 if (lp->ll_dict == get_vimvar_dict()
Bram Moolenaar31b81602019-02-10 22:14:27 +01001016 || &lp->ll_dict->dv_hashtab == get_funccal_args_ht())
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001017 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001018 semsg(_(e_illvar), name);
Bram Moolenaarab89d7a2019-03-17 14:43:31 +01001019 clear_tv(&var1);
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001020 return NULL;
1021 }
1022
Bram Moolenaar31b81602019-02-10 22:14:27 +01001023 // Key does not exist in dict: may need to add it.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001024 if (*p == '[' || *p == '.' || unlet)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001025 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001026 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001027 semsg(_(e_dictkey), key);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001028 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001029 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001030 }
1031 if (len == -1)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001032 lp->ll_newkey = vim_strsave(key);
Bram Moolenaar8c711452005-01-14 21:53:12 +00001033 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001034 lp->ll_newkey = vim_strnsave(key, len);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001035 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001036 if (lp->ll_newkey == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001037 p = NULL;
1038 break;
1039 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001040 // existing variable, need to check if it can be changed
Bram Moolenaar3a257732017-02-21 20:47:13 +01001041 else if ((flags & GLV_READ_ONLY) == 0
1042 && var_check_ro(lp->ll_di->di_flags, name, FALSE))
Bram Moolenaar49439c42017-02-20 23:07:05 +01001043 {
1044 clear_tv(&var1);
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001045 return NULL;
Bram Moolenaar49439c42017-02-20 23:07:05 +01001046 }
Bram Moolenaar4228bec2011-03-27 16:03:15 +02001047
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001048 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001049 lp->ll_tv = &lp->ll_di->di_tv;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001050 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001051 else if (lp->ll_tv->v_type == VAR_BLOB)
1052 {
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001053 long bloblen = blob_len(lp->ll_tv->vval.v_blob);
1054
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001055 /*
1056 * Get the number and item for the only or first index of the List.
1057 */
1058 if (empty1)
1059 lp->ll_n1 = 0;
1060 else
1061 // is number or string
1062 lp->ll_n1 = (long)tv_get_number(&var1);
1063 clear_tv(&var1);
1064
1065 if (lp->ll_n1 < 0
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001066 || lp->ll_n1 > bloblen
1067 || (lp->ll_range && lp->ll_n1 == bloblen))
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001068 {
1069 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001070 semsg(_(e_blobidx), lp->ll_n1);
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001071 clear_tv(&var2);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001072 return NULL;
1073 }
1074 if (lp->ll_range && !lp->ll_empty2)
1075 {
1076 lp->ll_n2 = (long)tv_get_number(&var2);
1077 clear_tv(&var2);
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001078 if (lp->ll_n2 < 0
1079 || lp->ll_n2 >= bloblen
1080 || lp->ll_n2 < lp->ll_n1)
1081 {
1082 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001083 semsg(_(e_blobidx), lp->ll_n2);
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001084 return NULL;
1085 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001086 }
1087 lp->ll_blob = lp->ll_tv->vval.v_blob;
1088 lp->ll_tv = NULL;
Bram Moolenaar61be3762019-03-19 23:04:17 +01001089 break;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001090 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00001091 else
1092 {
1093 /*
1094 * Get the number and item for the only or first index of the List.
1095 */
1096 if (empty1)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001097 lp->ll_n1 = 0;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001098 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001099 // is number or string
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001100 lp->ll_n1 = (long)tv_get_number(&var1);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001101 clear_tv(&var1);
1102
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001103 lp->ll_dict = NULL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001104 lp->ll_list = lp->ll_tv->vval.v_list;
1105 lp->ll_li = list_find(lp->ll_list, lp->ll_n1);
1106 if (lp->ll_li == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001107 {
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00001108 if (lp->ll_n1 < 0)
1109 {
1110 lp->ll_n1 = 0;
1111 lp->ll_li = list_find(lp->ll_list, lp->ll_n1);
1112 }
1113 }
1114 if (lp->ll_li == NULL)
1115 {
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001116 clear_tv(&var2);
Bram Moolenaare9623882011-04-21 14:27:28 +02001117 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001118 semsg(_(e_listidx), lp->ll_n1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001119 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001120 }
1121
1122 /*
1123 * May need to find the item or absolute index for the second
1124 * index of a range.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001125 * When no index given: "lp->ll_empty2" is TRUE.
1126 * Otherwise "lp->ll_n2" is set to the second index.
Bram Moolenaar8c711452005-01-14 21:53:12 +00001127 */
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001128 if (lp->ll_range && !lp->ll_empty2)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001129 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001130 lp->ll_n2 = (long)tv_get_number(&var2);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001131 // is number or string
Bram Moolenaar8c711452005-01-14 21:53:12 +00001132 clear_tv(&var2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001133 if (lp->ll_n2 < 0)
Bram Moolenaar8c711452005-01-14 21:53:12 +00001134 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001135 ni = list_find(lp->ll_list, lp->ll_n2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00001136 if (ni == NULL)
Bram Moolenaare9623882011-04-21 14:27:28 +02001137 {
1138 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001139 semsg(_(e_listidx), lp->ll_n2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001140 return NULL;
Bram Moolenaare9623882011-04-21 14:27:28 +02001141 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001142 lp->ll_n2 = list_idx_of_item(lp->ll_list, ni);
Bram Moolenaar8c711452005-01-14 21:53:12 +00001143 }
1144
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001145 // Check that lp->ll_n2 isn't before lp->ll_n1.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001146 if (lp->ll_n1 < 0)
1147 lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li);
1148 if (lp->ll_n2 < lp->ll_n1)
Bram Moolenaare9623882011-04-21 14:27:28 +02001149 {
1150 if (!quiet)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001151 semsg(_(e_listidx), lp->ll_n2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001152 return NULL;
Bram Moolenaare9623882011-04-21 14:27:28 +02001153 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001154 }
1155
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001156 lp->ll_tv = &lp->ll_li->li_tv;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001157 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001158 }
1159
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001160 clear_tv(&var1);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001161 lp->ll_name_end = p;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001162 return p;
1163}
1164
1165/*
Bram Moolenaar33570922005-01-25 22:26:29 +00001166 * Clear lval "lp" that was filled by get_lval().
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001167 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02001168 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001169clear_lval(lval_T *lp)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001170{
1171 vim_free(lp->ll_exp_name);
1172 vim_free(lp->ll_newkey);
1173}
1174
1175/*
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00001176 * Set a variable that was parsed by get_lval() to "rettv".
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001177 * "endp" points to just after the parsed name.
Bram Moolenaarff697e62019-02-12 22:28:33 +01001178 * "op" is NULL, "+" for "+=", "-" for "-=", "*" for "*=", "/" for "/=",
1179 * "%" for "%=", "." for ".=" or "=" for "=".
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001180 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +02001181 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001182set_var_lval(
1183 lval_T *lp,
1184 char_u *endp,
1185 typval_T *rettv,
1186 int copy,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001187 int flags, // LET_IS_CONST and/or LET_NO_COMMAND
Bram Moolenaar7454a062016-01-30 15:14:10 +01001188 char_u *op)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001189{
1190 int cc;
Bram Moolenaar33570922005-01-25 22:26:29 +00001191 listitem_T *ri;
1192 dictitem_T *di;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001193
1194 if (lp->ll_tv == NULL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001195 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01001196 cc = *endp;
1197 *endp = NUL;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001198 if (lp->ll_blob != NULL)
1199 {
1200 int error = FALSE, val;
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001201
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001202 if (op != NULL && *op != '=')
1203 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001204 semsg(_(e_letwrong), op);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001205 return;
1206 }
1207
1208 if (lp->ll_range && rettv->v_type == VAR_BLOB)
1209 {
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001210 int il, ir;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001211
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001212 if (lp->ll_empty2)
1213 lp->ll_n2 = blob_len(lp->ll_blob) - 1;
1214
1215 if (lp->ll_n2 - lp->ll_n1 + 1 != blob_len(rettv->vval.v_blob))
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001216 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001217 emsg(_("E972: Blob value does not have the right number of bytes"));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001218 return;
1219 }
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001220 if (lp->ll_empty2)
1221 lp->ll_n2 = blob_len(lp->ll_blob);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001222
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001223 ir = 0;
1224 for (il = lp->ll_n1; il <= lp->ll_n2; il++)
1225 blob_set(lp->ll_blob, il,
1226 blob_get(rettv->vval.v_blob, ir++));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001227 }
1228 else
1229 {
1230 val = (int)tv_get_number_chk(rettv, &error);
1231 if (!error)
1232 {
1233 garray_T *gap = &lp->ll_blob->bv_ga;
1234
1235 // Allow for appending a byte. Setting a byte beyond
1236 // the end is an error otherwise.
1237 if (lp->ll_n1 < gap->ga_len
1238 || (lp->ll_n1 == gap->ga_len
1239 && ga_grow(&lp->ll_blob->bv_ga, 1) == OK))
1240 {
1241 blob_set(lp->ll_blob, lp->ll_n1, val);
1242 if (lp->ll_n1 == gap->ga_len)
1243 ++gap->ga_len;
1244 }
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001245 // error for invalid range was already given in get_lval()
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001246 }
1247 }
1248 }
1249 else if (op != NULL && *op != '=')
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001250 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01001251 typval_T tv;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001252
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001253 if (flags & LET_IS_CONST)
Bram Moolenaar9937a052019-06-15 15:45:06 +02001254 {
1255 emsg(_(e_cannot_mod));
1256 *endp = cc;
1257 return;
1258 }
1259
Bram Moolenaarff697e62019-02-12 22:28:33 +01001260 // handle +=, -=, *=, /=, %= and .=
Bram Moolenaar79518e22017-02-17 16:31:35 +01001261 di = NULL;
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02001262 if (eval_variable(lp->ll_name, (int)STRLEN(lp->ll_name),
Bram Moolenaar79518e22017-02-17 16:31:35 +01001263 &tv, &di, TRUE, FALSE) == OK)
1264 {
1265 if ((di == NULL
Bram Moolenaar05c00c02019-02-11 22:00:11 +01001266 || (!var_check_ro(di->di_flags, lp->ll_name, FALSE)
1267 && !tv_check_lock(&di->di_tv, lp->ll_name, FALSE)))
Bram Moolenaar79518e22017-02-17 16:31:35 +01001268 && tv_op(&tv, rettv, op) == OK)
1269 set_var(lp->ll_name, &tv, FALSE);
1270 clear_tv(&tv);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001271 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001272 }
Bram Moolenaar79518e22017-02-17 16:31:35 +01001273 else
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +02001274 {
1275 if (lp->ll_type != NULL
1276 && check_typval_type(lp->ll_type, rettv) == FAIL)
1277 return;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001278 set_var_const(lp->ll_name, lp->ll_type, rettv, copy, flags);
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +02001279 }
Bram Moolenaar79518e22017-02-17 16:31:35 +01001280 *endp = cc;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001281 }
Bram Moolenaar05c00c02019-02-11 22:00:11 +01001282 else if (var_check_lock(lp->ll_newkey == NULL
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00001283 ? lp->ll_tv->v_lock
Bram Moolenaar77354e72015-04-21 16:49:05 +02001284 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE))
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00001285 ;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001286 else if (lp->ll_range)
1287 {
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02001288 listitem_T *ll_li = lp->ll_li;
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01001289 int ll_n1 = lp->ll_n1;
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02001290
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001291 if (flags & LET_IS_CONST)
Bram Moolenaar9937a052019-06-15 15:45:06 +02001292 {
1293 emsg(_("E996: Cannot lock a range"));
1294 return;
1295 }
1296
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02001297 /*
1298 * Check whether any of the list items is locked
1299 */
Bram Moolenaarb2a851f2014-12-07 00:18:33 +01001300 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; )
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02001301 {
Bram Moolenaar05c00c02019-02-11 22:00:11 +01001302 if (var_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02001303 return;
1304 ri = ri->li_next;
1305 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1))
1306 break;
1307 ll_li = ll_li->li_next;
1308 ++ll_n1;
1309 }
1310
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001311 /*
1312 * Assign the List values to the list items.
1313 */
1314 for (ri = rettv->vval.v_list->lv_first; ri != NULL; )
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001315 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001316 if (op != NULL && *op != '=')
1317 tv_op(&lp->ll_li->li_tv, &ri->li_tv, op);
1318 else
1319 {
1320 clear_tv(&lp->ll_li->li_tv);
1321 copy_tv(&ri->li_tv, &lp->ll_li->li_tv);
1322 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001323 ri = ri->li_next;
1324 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == lp->ll_n1))
1325 break;
1326 if (lp->ll_li->li_next == NULL)
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001327 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001328 // Need to add an empty item.
Bram Moolenaar4463f292005-09-25 22:20:24 +00001329 if (list_append_number(lp->ll_list, 0) == FAIL)
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001330 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001331 ri = NULL;
1332 break;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001333 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001334 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001335 lp->ll_li = lp->ll_li->li_next;
1336 ++lp->ll_n1;
1337 }
1338 if (ri != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001339 emsg(_("E710: List value has more items than target"));
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001340 else if (lp->ll_empty2
1341 ? (lp->ll_li != NULL && lp->ll_li->li_next != NULL)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001342 : lp->ll_n1 != lp->ll_n2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001343 emsg(_("E711: List value has not enough items"));
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001344 }
1345 else
1346 {
1347 /*
1348 * Assign to a List or Dictionary item.
1349 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001350 if (flags & LET_IS_CONST)
Bram Moolenaar9937a052019-06-15 15:45:06 +02001351 {
1352 emsg(_("E996: Cannot lock a list or dict"));
1353 return;
1354 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001355 if (lp->ll_newkey != NULL)
1356 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001357 if (op != NULL && *op != '=')
1358 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001359 semsg(_(e_letwrong), op);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001360 return;
1361 }
1362
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001363 // Need to add an item to the Dictionary.
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00001364 di = dictitem_alloc(lp->ll_newkey);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001365 if (di == NULL)
1366 return;
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00001367 if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL)
1368 {
1369 vim_free(di);
1370 return;
1371 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001372 lp->ll_tv = &di->di_tv;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001373 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001374 else if (op != NULL && *op != '=')
1375 {
1376 tv_op(lp->ll_tv, rettv, op);
1377 return;
1378 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001379 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001380 clear_tv(lp->ll_tv);
Bram Moolenaar8c711452005-01-14 21:53:12 +00001381
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001382 /*
1383 * Assign the value to the variable or list item.
1384 */
1385 if (copy)
1386 copy_tv(rettv, lp->ll_tv);
1387 else
1388 {
1389 *lp->ll_tv = *rettv;
Bram Moolenaar758711c2005-02-02 23:11:38 +00001390 lp->ll_tv->v_lock = 0;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001391 init_tv(rettv);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001392 }
1393 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001394}
1395
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001396/*
Bram Moolenaarff697e62019-02-12 22:28:33 +01001397 * Handle "tv1 += tv2", "tv1 -= tv2", "tv1 *= tv2", "tv1 /= tv2", "tv1 %= tv2"
1398 * and "tv1 .= tv2"
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001399 * Returns OK or FAIL.
1400 */
1401 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001402tv_op(typval_T *tv1, typval_T *tv2, char_u *op)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001403{
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001404 varnumber_T n;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001405 char_u numbuf[NUMBUFLEN];
1406 char_u *s;
1407
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001408 // Can't do anything with a Funcref, Dict, v:true on the right.
Bram Moolenaar520e1e42016-01-23 19:46:28 +01001409 if (tv2->v_type != VAR_FUNC && tv2->v_type != VAR_DICT
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01001410 && tv2->v_type != VAR_BOOL && tv2->v_type != VAR_SPECIAL)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001411 {
1412 switch (tv1->v_type)
1413 {
Bram Moolenaar835dc632016-02-07 14:27:38 +01001414 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02001415 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001416 case VAR_VOID:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001417 case VAR_DICT:
1418 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001419 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01001420 case VAR_BOOL:
Bram Moolenaar520e1e42016-01-23 19:46:28 +01001421 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01001422 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01001423 case VAR_CHANNEL:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001424 break;
1425
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001426 case VAR_BLOB:
1427 if (*op != '+' || tv2->v_type != VAR_BLOB)
1428 break;
1429 // BLOB += BLOB
1430 if (tv1->vval.v_blob != NULL && tv2->vval.v_blob != NULL)
1431 {
1432 blob_T *b1 = tv1->vval.v_blob;
1433 blob_T *b2 = tv2->vval.v_blob;
1434 int i, len = blob_len(b2);
1435 for (i = 0; i < len; i++)
1436 ga_append(&b1->bv_ga, blob_get(b2, i));
1437 }
1438 return OK;
1439
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001440 case VAR_LIST:
1441 if (*op != '+' || tv2->v_type != VAR_LIST)
1442 break;
Bram Moolenaarff697e62019-02-12 22:28:33 +01001443 // List += List
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001444 if (tv1->vval.v_list != NULL && tv2->vval.v_list != NULL)
1445 list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL);
1446 return OK;
1447
1448 case VAR_NUMBER:
1449 case VAR_STRING:
1450 if (tv2->v_type == VAR_LIST)
1451 break;
Bram Moolenaarff697e62019-02-12 22:28:33 +01001452 if (vim_strchr((char_u *)"+-*/%", *op) != NULL)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001453 {
Bram Moolenaarff697e62019-02-12 22:28:33 +01001454 // nr += nr , nr -= nr , nr *=nr , nr /= nr , nr %= nr
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001455 n = tv_get_number(tv1);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001456#ifdef FEAT_FLOAT
1457 if (tv2->v_type == VAR_FLOAT)
1458 {
1459 float_T f = n;
1460
Bram Moolenaarff697e62019-02-12 22:28:33 +01001461 if (*op == '%')
1462 break;
1463 switch (*op)
1464 {
1465 case '+': f += tv2->vval.v_float; break;
1466 case '-': f -= tv2->vval.v_float; break;
1467 case '*': f *= tv2->vval.v_float; break;
1468 case '/': f /= tv2->vval.v_float; break;
1469 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001470 clear_tv(tv1);
1471 tv1->v_type = VAR_FLOAT;
1472 tv1->vval.v_float = f;
1473 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001474 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001475#endif
1476 {
Bram Moolenaarff697e62019-02-12 22:28:33 +01001477 switch (*op)
1478 {
1479 case '+': n += tv_get_number(tv2); break;
1480 case '-': n -= tv_get_number(tv2); break;
1481 case '*': n *= tv_get_number(tv2); break;
Bram Moolenaare21c1582019-03-02 11:57:09 +01001482 case '/': n = num_divide(n, tv_get_number(tv2)); break;
1483 case '%': n = num_modulus(n, tv_get_number(tv2)); break;
Bram Moolenaarff697e62019-02-12 22:28:33 +01001484 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001485 clear_tv(tv1);
1486 tv1->v_type = VAR_NUMBER;
1487 tv1->vval.v_number = n;
1488 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001489 }
1490 else
1491 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001492 if (tv2->v_type == VAR_FLOAT)
1493 break;
1494
Bram Moolenaarff697e62019-02-12 22:28:33 +01001495 // str .= str
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001496 s = tv_get_string(tv1);
1497 s = concat_str(s, tv_get_string_buf(tv2, numbuf));
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001498 clear_tv(tv1);
1499 tv1->v_type = VAR_STRING;
1500 tv1->vval.v_string = s;
1501 }
1502 return OK;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001503
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001504 case VAR_FLOAT:
Bram Moolenaar5fac4672016-03-02 22:16:32 +01001505#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001506 {
1507 float_T f;
1508
Bram Moolenaarff697e62019-02-12 22:28:33 +01001509 if (*op == '%' || *op == '.'
1510 || (tv2->v_type != VAR_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001511 && tv2->v_type != VAR_NUMBER
1512 && tv2->v_type != VAR_STRING))
1513 break;
1514 if (tv2->v_type == VAR_FLOAT)
1515 f = tv2->vval.v_float;
1516 else
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001517 f = tv_get_number(tv2);
Bram Moolenaarff697e62019-02-12 22:28:33 +01001518 switch (*op)
1519 {
1520 case '+': tv1->vval.v_float += f; break;
1521 case '-': tv1->vval.v_float -= f; break;
1522 case '*': tv1->vval.v_float *= f; break;
1523 case '/': tv1->vval.v_float /= f; break;
1524 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001525 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001526#endif
Bram Moolenaar5fac4672016-03-02 22:16:32 +01001527 return OK;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001528 }
1529 }
1530
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001531 semsg(_(e_letwrong), op);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001532 return FAIL;
1533}
1534
1535/*
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001536 * Evaluate the expression used in a ":for var in expr" command.
1537 * "arg" points to "var".
1538 * Set "*errp" to TRUE for an error, FALSE otherwise;
1539 * Return a pointer that holds the info. Null when there is an error.
1540 */
1541 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001542eval_for_line(
1543 char_u *arg,
1544 int *errp,
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001545 exarg_T *eap,
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001546 evalarg_T *evalarg)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001547{
Bram Moolenaar33570922005-01-25 22:26:29 +00001548 forinfo_T *fi;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001549 char_u *expr;
Bram Moolenaar33570922005-01-25 22:26:29 +00001550 typval_T tv;
1551 list_T *l;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001552 int skip = !(evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001553
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001554 *errp = TRUE; // default: there is an error
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001555
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001556 fi = ALLOC_CLEAR_ONE(forinfo_T);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001557 if (fi == NULL)
1558 return NULL;
1559
Bram Moolenaar47a519a2020-06-14 23:05:10 +02001560 expr = skip_var_list(arg, TRUE, &fi->fi_varcount, &fi->fi_semicolon, FALSE);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001561 if (expr == NULL)
1562 return fi;
1563
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001564 expr = skipwhite_and_linebreak(expr, evalarg);
1565 if (expr[0] != 'i' || expr[1] != 'n'
1566 || !(expr[2] == NUL || VIM_ISWHITE(expr[2])))
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001567 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001568 emsg(_(e_missing_in));
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001569 return fi;
1570 }
1571
1572 if (skip)
1573 ++emsg_skip;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001574 expr = skipwhite_and_linebreak(expr + 2, evalarg);
1575 if (eval0(expr, &tv, eap, evalarg) == OK)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001576 {
1577 *errp = FALSE;
1578 if (!skip)
1579 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001580 if (tv.v_type == VAR_LIST)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00001581 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001582 l = tv.vval.v_list;
1583 if (l == NULL)
1584 {
1585 // a null list is like an empty list: do nothing
1586 clear_tv(&tv);
1587 }
1588 else
1589 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001590 // Need a real list here.
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02001591 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001592
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001593 // No need to increment the refcount, it's already set for
1594 // the list being used in "tv".
1595 fi->fi_list = l;
1596 list_add_watch(l, &fi->fi_lw);
1597 fi->fi_lw.lw_item = l->lv_first;
1598 }
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00001599 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001600 else if (tv.v_type == VAR_BLOB)
Bram Moolenaard8585ed2016-05-01 23:05:53 +02001601 {
Bram Moolenaardd29ea12019-01-23 21:56:21 +01001602 fi->fi_bi = 0;
1603 if (tv.vval.v_blob != NULL)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001604 {
Bram Moolenaardd29ea12019-01-23 21:56:21 +01001605 typval_T btv;
1606
1607 // Make a copy, so that the iteration still works when the
1608 // blob is changed.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001609 blob_copy(tv.vval.v_blob, &btv);
Bram Moolenaardd29ea12019-01-23 21:56:21 +01001610 fi->fi_blob = btv.vval.v_blob;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001611 }
Bram Moolenaardd29ea12019-01-23 21:56:21 +01001612 clear_tv(&tv);
Bram Moolenaard8585ed2016-05-01 23:05:53 +02001613 }
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001614 else
1615 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001616 emsg(_(e_listreq));
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001617 clear_tv(&tv);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001618 }
1619 }
1620 }
1621 if (skip)
1622 --emsg_skip;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001623 fi->fi_break_count = evalarg->eval_break_count;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001624
1625 return fi;
1626}
1627
1628/*
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001629 * Used when looping over a :for line, skip the "in expr" part.
1630 */
1631 void
1632skip_for_lines(void *fi_void, evalarg_T *evalarg)
1633{
1634 forinfo_T *fi = (forinfo_T *)fi_void;
1635 int i;
1636
1637 for (i = 0; i < fi->fi_break_count; ++i)
1638 eval_next_line(evalarg);
1639}
1640
1641/*
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001642 * Use the first item in a ":for" list. Advance to the next.
1643 * Assign the values to the variable (list). "arg" points to the first one.
1644 * Return TRUE when a valid item was found, FALSE when at end of list or
1645 * something wrong.
1646 */
1647 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001648next_for_item(void *fi_void, char_u *arg)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001649{
Bram Moolenaarc4b99e02013-06-23 14:30:47 +02001650 forinfo_T *fi = (forinfo_T *)fi_void;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001651 int result;
Bram Moolenaareb6880b2020-07-12 17:07:05 +02001652 int flag = in_vim9script() ? LET_NO_COMMAND : 0;
Bram Moolenaar33570922005-01-25 22:26:29 +00001653 listitem_T *item;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001654
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001655 if (fi->fi_blob != NULL)
1656 {
1657 typval_T tv;
1658
1659 if (fi->fi_bi >= blob_len(fi->fi_blob))
1660 return FALSE;
1661 tv.v_type = VAR_NUMBER;
1662 tv.v_lock = VAR_FIXED;
1663 tv.vval.v_number = blob_get(fi->fi_blob, fi->fi_bi);
1664 ++fi->fi_bi;
Bram Moolenaar9937a052019-06-15 15:45:06 +02001665 return ex_let_vars(arg, &tv, TRUE, fi->fi_semicolon,
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001666 fi->fi_varcount, flag, NULL) == OK;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001667 }
1668
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001669 item = fi->fi_lw.lw_item;
1670 if (item == NULL)
1671 result = FALSE;
1672 else
1673 {
1674 fi->fi_lw.lw_item = item->li_next;
Bram Moolenaar9937a052019-06-15 15:45:06 +02001675 result = (ex_let_vars(arg, &item->li_tv, TRUE, fi->fi_semicolon,
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001676 fi->fi_varcount, flag, NULL) == OK);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001677 }
1678 return result;
1679}
1680
1681/*
1682 * Free the structure used to store info used by ":for".
1683 */
1684 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001685free_for_info(void *fi_void)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001686{
Bram Moolenaar33570922005-01-25 22:26:29 +00001687 forinfo_T *fi = (forinfo_T *)fi_void;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001688
Bram Moolenaarab7013c2005-01-09 21:23:56 +00001689 if (fi != NULL && fi->fi_list != NULL)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00001690 {
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001691 list_rem_watch(fi->fi_list, &fi->fi_lw);
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00001692 list_unref(fi->fi_list);
1693 }
Bram Moolenaarecc8bc42019-01-13 16:07:21 +01001694 if (fi != NULL && fi->fi_blob != NULL)
1695 blob_unref(fi->fi_blob);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001696 vim_free(fi);
1697}
1698
Bram Moolenaar071d4272004-06-13 20:20:40 +00001699 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001700set_context_for_expression(
1701 expand_T *xp,
1702 char_u *arg,
1703 cmdidx_T cmdidx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001704{
1705 int got_eq = FALSE;
1706 int c;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001707 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001708
Bram Moolenaar8f76e6b2019-11-26 16:50:30 +01001709 if (cmdidx == CMD_let || cmdidx == CMD_const)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001710 {
1711 xp->xp_context = EXPAND_USER_VARS;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001712 if (vim_strpbrk(arg, (char_u *)"\"'+-*/%.=!?~|&$([<>,#") == NULL)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001713 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001714 // ":let var1 var2 ...": find last space.
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001715 for (p = arg + STRLEN(arg); p >= arg; )
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001716 {
1717 xp->xp_pattern = p;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001718 MB_PTR_BACK(arg, p);
Bram Moolenaar1c465442017-03-12 20:10:05 +01001719 if (VIM_ISWHITE(*p))
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001720 break;
1721 }
1722 return;
1723 }
1724 }
1725 else
1726 xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS
1727 : EXPAND_EXPRESSION;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001728 while ((xp->xp_pattern = vim_strpbrk(arg,
1729 (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL)
1730 {
1731 c = *xp->xp_pattern;
1732 if (c == '&')
1733 {
1734 c = xp->xp_pattern[1];
1735 if (c == '&')
1736 {
1737 ++xp->xp_pattern;
1738 xp->xp_context = cmdidx != CMD_let || got_eq
1739 ? EXPAND_EXPRESSION : EXPAND_NOTHING;
1740 }
1741 else if (c != ' ')
Bram Moolenaar11cbeb12005-03-11 22:51:16 +00001742 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001743 xp->xp_context = EXPAND_SETTINGS;
Bram Moolenaar11cbeb12005-03-11 22:51:16 +00001744 if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':')
1745 xp->xp_pattern += 2;
1746
1747 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001748 }
1749 else if (c == '$')
1750 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001751 // environment variable
Bram Moolenaar071d4272004-06-13 20:20:40 +00001752 xp->xp_context = EXPAND_ENV_VARS;
1753 }
1754 else if (c == '=')
1755 {
1756 got_eq = TRUE;
1757 xp->xp_context = EXPAND_EXPRESSION;
1758 }
Bram Moolenaara32095f2016-03-28 19:27:13 +02001759 else if (c == '#'
1760 && xp->xp_context == EXPAND_EXPRESSION)
1761 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001762 // Autoload function/variable contains '#'.
Bram Moolenaara32095f2016-03-28 19:27:13 +02001763 break;
1764 }
Bram Moolenaar8a349ff2014-11-12 20:09:06 +01001765 else if ((c == '<' || c == '#')
Bram Moolenaar071d4272004-06-13 20:20:40 +00001766 && xp->xp_context == EXPAND_FUNCTIONS
1767 && vim_strchr(xp->xp_pattern, '(') == NULL)
1768 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001769 // Function name can start with "<SNR>" and contain '#'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001770 break;
1771 }
1772 else if (cmdidx != CMD_let || got_eq)
1773 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001774 if (c == '"') // string
Bram Moolenaar071d4272004-06-13 20:20:40 +00001775 {
1776 while ((c = *++xp->xp_pattern) != NUL && c != '"')
1777 if (c == '\\' && xp->xp_pattern[1] != NUL)
1778 ++xp->xp_pattern;
1779 xp->xp_context = EXPAND_NOTHING;
1780 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001781 else if (c == '\'') // literal string
Bram Moolenaar071d4272004-06-13 20:20:40 +00001782 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001783 // Trick: '' is like stopping and starting a literal string.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001784 while ((c = *++xp->xp_pattern) != NUL && c != '\'')
1785 /* skip */ ;
1786 xp->xp_context = EXPAND_NOTHING;
1787 }
1788 else if (c == '|')
1789 {
1790 if (xp->xp_pattern[1] == '|')
1791 {
1792 ++xp->xp_pattern;
1793 xp->xp_context = EXPAND_EXPRESSION;
1794 }
1795 else
1796 xp->xp_context = EXPAND_COMMANDS;
1797 }
1798 else
1799 xp->xp_context = EXPAND_EXPRESSION;
1800 }
1801 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001802 // Doesn't look like something valid, expand as an expression
1803 // anyway.
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001804 xp->xp_context = EXPAND_EXPRESSION;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001805 arg = xp->xp_pattern;
1806 if (*arg != NUL)
1807 while ((c = *++arg) != NUL && (c == ' ' || c == '\t'))
1808 /* skip */ ;
1809 }
1810 xp->xp_pattern = arg;
1811}
1812
Bram Moolenaar071d4272004-06-13 20:20:40 +00001813/*
Bram Moolenaarea6553b2016-03-27 15:13:38 +02001814 * Return TRUE if "pat" matches "text".
1815 * Does not use 'cpo' and always uses 'magic'.
1816 */
Bram Moolenaarecaa70e2019-07-14 14:55:39 +02001817 int
Bram Moolenaarea6553b2016-03-27 15:13:38 +02001818pattern_match(char_u *pat, char_u *text, int ic)
1819{
1820 int matches = FALSE;
1821 char_u *save_cpo;
1822 regmatch_T regmatch;
1823
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001824 // avoid 'l' flag in 'cpoptions'
Bram Moolenaarea6553b2016-03-27 15:13:38 +02001825 save_cpo = p_cpo;
1826 p_cpo = (char_u *)"";
1827 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
1828 if (regmatch.regprog != NULL)
1829 {
1830 regmatch.rm_ic = ic;
1831 matches = vim_regexec_nl(&regmatch, text, (colnr_T)0);
1832 vim_regfree(regmatch.regprog);
1833 }
1834 p_cpo = save_cpo;
1835 return matches;
1836}
1837
1838/*
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001839 * Handle a name followed by "(". Both for just "name(arg)" and for
1840 * "expr->name(arg)".
1841 * Returns OK or FAIL.
1842 */
1843 static int
1844eval_func(
1845 char_u **arg, // points to "(", will be advanced
Bram Moolenaare6b53242020-07-01 17:28:33 +02001846 evalarg_T *evalarg,
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001847 char_u *name,
1848 int name_len,
1849 typval_T *rettv,
Bram Moolenaar32e35112020-05-14 22:41:15 +02001850 int flags,
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001851 typval_T *basetv) // "expr" for "expr->name(arg)"
1852{
Bram Moolenaar32e35112020-05-14 22:41:15 +02001853 int evaluate = flags & EVAL_EVALUATE;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001854 char_u *s = name;
1855 int len = name_len;
1856 partial_T *partial;
1857 int ret = OK;
1858
1859 if (!evaluate)
1860 check_vars(s, len);
1861
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001862 // If "s" is the name of a variable of type VAR_FUNC
1863 // use its contents.
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001864 s = deref_func_name(s, &len, &partial, !evaluate);
1865
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001866 // Need to make a copy, in case evaluating the arguments makes
1867 // the name invalid.
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001868 s = vim_strsave(s);
Bram Moolenaar32e35112020-05-14 22:41:15 +02001869 if (s == NULL || (flags & EVAL_CONSTANT))
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001870 ret = FAIL;
1871 else
1872 {
1873 funcexe_T funcexe;
1874
1875 // Invoke the function.
Bram Moolenaara80faa82020-04-12 19:37:17 +02001876 CLEAR_FIELD(funcexe);
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001877 funcexe.firstline = curwin->w_cursor.lnum;
1878 funcexe.lastline = curwin->w_cursor.lnum;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001879 funcexe.evaluate = evaluate;
1880 funcexe.partial = partial;
1881 funcexe.basetv = basetv;
Bram Moolenaare6b53242020-07-01 17:28:33 +02001882 ret = get_func_tv(s, len, rettv, arg, evalarg, &funcexe);
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001883 }
1884 vim_free(s);
1885
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001886 // If evaluate is FALSE rettv->v_type was not set in
1887 // get_func_tv, but it's needed in handle_subscript() to parse
1888 // what follows. So set it here.
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001889 if (rettv->v_type == VAR_UNKNOWN && !evaluate && **arg == '(')
1890 {
1891 rettv->vval.v_string = NULL;
1892 rettv->v_type = VAR_FUNC;
1893 }
1894
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01001895 // Stop the expression evaluation when immediately
1896 // aborting on error, or when an interrupt occurred or
1897 // an exception was thrown but not caught.
Bram Moolenaar761fdf02019-08-05 23:10:16 +02001898 if (evaluate && aborting())
1899 {
1900 if (ret == OK)
1901 clear_tv(rettv);
1902 ret = FAIL;
1903 }
1904 return ret;
1905}
1906
1907/*
Bram Moolenaar962d7212020-07-04 14:15:00 +02001908 * If inside Vim9 script, "arg" points to the end of a line (ignoring a #
1909 * comment) and there is a next line, return the next line (skipping blanks)
1910 * and set "getnext".
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001911 * Otherwise just return "arg" unmodified and set "getnext" to FALSE.
1912 * "arg" must point somewhere inside a line, not at the start.
1913 */
Bram Moolenaar71478202020-06-26 22:46:27 +02001914 char_u *
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001915eval_next_non_blank(char_u *arg, evalarg_T *evalarg, int *getnext)
1916{
Bram Moolenaar9d489562020-07-30 20:08:50 +02001917 char_u *p = skipwhite(arg);
1918
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001919 *getnext = FALSE;
Bram Moolenaareb6880b2020-07-12 17:07:05 +02001920 if (in_vim9script()
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001921 && evalarg != NULL
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001922 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL)
Bram Moolenaar9d489562020-07-30 20:08:50 +02001923 && (*p == NUL || (VIM_ISWHITE(p[-1]) && vim9_comment_start(p))))
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001924 {
Bram Moolenaar9d489562020-07-30 20:08:50 +02001925 char_u *next;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001926
1927 if (evalarg->eval_cookie != NULL)
Bram Moolenaar9d489562020-07-30 20:08:50 +02001928 next = getline_peek(evalarg->eval_getline, evalarg->eval_cookie);
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001929 else
Bram Moolenaar9d489562020-07-30 20:08:50 +02001930 next = peek_next_line_from_context(evalarg->eval_cctx);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001931
Bram Moolenaar9d489562020-07-30 20:08:50 +02001932 if (next != NULL)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001933 {
1934 *getnext = TRUE;
Bram Moolenaar9d489562020-07-30 20:08:50 +02001935 return skipwhite(next);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001936 }
1937 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02001938 return p;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001939}
1940
1941/*
Bram Moolenaare40fbc22020-06-27 18:06:45 +02001942 * To be called after eval_next_non_blank() sets "getnext" to TRUE.
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001943 */
Bram Moolenaar71478202020-06-26 22:46:27 +02001944 char_u *
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001945eval_next_line(evalarg_T *evalarg)
1946{
Bram Moolenaare40fbc22020-06-27 18:06:45 +02001947 garray_T *gap = &evalarg->eval_ga;
1948 char_u *line;
1949
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001950 if (evalarg->eval_cookie != NULL)
1951 line = evalarg->eval_getline(0, evalarg->eval_cookie, 0, TRUE);
1952 else
1953 line = next_line_from_context(evalarg->eval_cctx, TRUE);
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001954 ++evalarg->eval_break_count;
Bram Moolenaare40fbc22020-06-27 18:06:45 +02001955 if (gap->ga_itemsize > 0 && ga_grow(gap, 1) == OK)
1956 {
1957 // Going to concatenate the lines after parsing.
1958 ((char_u **)gap->ga_data)[gap->ga_len] = line;
1959 ++gap->ga_len;
1960 }
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02001961 else if (evalarg->eval_cookie != NULL)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02001962 {
1963 vim_free(evalarg->eval_tofree);
1964 evalarg->eval_tofree = line;
1965 }
1966 return skipwhite(line);
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001967}
1968
Bram Moolenaare6b53242020-07-01 17:28:33 +02001969/*
1970 * Call eval_next_non_blank() and get the next line if needed.
1971 */
Bram Moolenaar9215f012020-06-27 21:18:00 +02001972 char_u *
1973skipwhite_and_linebreak(char_u *arg, evalarg_T *evalarg)
1974{
1975 int getnext;
1976 char_u *p = skipwhite(arg);
1977
Bram Moolenaar962d7212020-07-04 14:15:00 +02001978 if (evalarg == NULL)
1979 return skipwhite(arg);
Bram Moolenaar9215f012020-06-27 21:18:00 +02001980 eval_next_non_blank(p, evalarg, &getnext);
1981 if (getnext)
1982 return eval_next_line(evalarg);
1983 return p;
1984}
1985
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001986/*
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02001987 * After using "evalarg" filled from "eap": free the memory.
Bram Moolenaarfaf86262020-06-27 23:07:36 +02001988 */
1989 void
1990clear_evalarg(evalarg_T *evalarg, exarg_T *eap)
1991{
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02001992 if (evalarg != NULL)
Bram Moolenaarfaf86262020-06-27 23:07:36 +02001993 {
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02001994 if (evalarg->eval_tofree != NULL)
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001995 {
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02001996 if (eap != NULL)
1997 {
1998 // We may need to keep the original command line, e.g. for
1999 // ":let" it has the variable names. But we may also need the
2000 // new one, "nextcmd" points into it. Keep both.
2001 vim_free(eap->cmdline_tofree);
2002 eap->cmdline_tofree = *eap->cmdlinep;
2003 *eap->cmdlinep = evalarg->eval_tofree;
2004 }
2005 else
2006 vim_free(evalarg->eval_tofree);
2007 evalarg->eval_tofree = NULL;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02002008 }
Bram Moolenaar8e2730a2020-07-08 22:01:49 +02002009
2010 vim_free(evalarg->eval_tofree_lambda);
2011 evalarg->eval_tofree_lambda = NULL;
Bram Moolenaarfaf86262020-06-27 23:07:36 +02002012 }
2013}
2014
2015/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002016 * The "evaluate" argument: When FALSE, the argument is only parsed but not
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002017 * executed. The function may return OK, but the rettv will be of type
Bram Moolenaar071d4272004-06-13 20:20:40 +00002018 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
2019 */
2020
2021/*
2022 * Handle zero level expression.
2023 * This calls eval1() and handles error message and nextcmd.
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002024 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
Bram Moolenaar4463f292005-09-25 22:20:24 +00002025 * Note: "rettv.v_lock" is not set.
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002026 * "evalarg" can be NULL, EVALARG_EVALUATE or a pointer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002027 * Return OK or FAIL.
2028 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02002029 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002030eval0(
2031 char_u *arg,
2032 typval_T *rettv,
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002033 exarg_T *eap,
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002034 evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002035{
2036 int ret;
2037 char_u *p;
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01002038 int did_emsg_before = did_emsg;
2039 int called_emsg_before = called_emsg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002040 int flags = evalarg == NULL ? 0 : evalarg->eval_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002041
2042 p = skipwhite(arg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002043 ret = eval1(&p, rettv, evalarg);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002044 p = skipwhite(p);
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002045
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002046 if (ret == FAIL || !ends_excmd2(arg, p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002047 {
2048 if (ret != FAIL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002049 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002050 /*
2051 * Report the invalid expression unless the expression evaluation has
2052 * been cancelled due to an aborting error, an interrupt, or an
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01002053 * exception, or we already gave a more specific error.
2054 * Also check called_emsg for when using assert_fails().
Bram Moolenaar071d4272004-06-13 20:20:40 +00002055 */
Bram Moolenaar32e35112020-05-14 22:41:15 +02002056 if (!aborting()
2057 && did_emsg == did_emsg_before
2058 && called_emsg == called_emsg_before
2059 && (flags & EVAL_CONSTANT) == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002060 semsg(_(e_invexpr2), arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002061 ret = FAIL;
2062 }
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002063
2064 if (eap != NULL)
2065 eap->nextcmd = check_nextcmd(p);
2066
Bram Moolenaar071d4272004-06-13 20:20:40 +00002067 return ret;
2068}
2069
2070/*
2071 * Handle top level expression:
Bram Moolenaarb67cc162009-02-04 15:27:06 +00002072 * expr2 ? expr1 : expr1
Bram Moolenaar071d4272004-06-13 20:20:40 +00002073 *
2074 * "arg" must point to the first non-white of the expression.
2075 * "arg" is advanced to the next non-white after the recognized expression.
2076 *
Bram Moolenaar4463f292005-09-25 22:20:24 +00002077 * Note: "rettv.v_lock" is not set.
2078 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00002079 * Return OK or FAIL.
2080 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02002081 int
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002082eval1(char_u **arg, typval_T *rettv, evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002083{
Bram Moolenaar793648f2020-06-26 21:28:25 +02002084 char_u *p;
2085 int getnext;
2086
Bram Moolenaar071d4272004-06-13 20:20:40 +00002087 /*
2088 * Get the first variable.
2089 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002090 if (eval2(arg, rettv, evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002091 return FAIL;
2092
Bram Moolenaar793648f2020-06-26 21:28:25 +02002093 p = eval_next_non_blank(*arg, evalarg, &getnext);
2094 if (*p == '?')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002095 {
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002096 int result;
2097 typval_T var2;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002098 evalarg_T *evalarg_used = evalarg;
2099 evalarg_T local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002100 int orig_flags;
Bram Moolenaar7acde512020-06-24 23:02:40 +02002101 int evaluate;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002102
2103 if (evalarg == NULL)
2104 {
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002105 CLEAR_FIELD(local_evalarg);
2106 evalarg_used = &local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002107 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002108 orig_flags = evalarg_used->eval_flags;
2109 evaluate = evalarg_used->eval_flags & EVAL_EVALUATE;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002110
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002111 if (getnext)
2112 *arg = eval_next_line(evalarg_used);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002113 else
2114 *arg = p;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002115
Bram Moolenaar071d4272004-06-13 20:20:40 +00002116 result = FALSE;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002117 if (evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002118 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002119 int error = FALSE;
2120
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002121 if (tv_get_number_chk(rettv, &error) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002122 result = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002123 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002124 if (error)
2125 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002126 }
2127
2128 /*
Bram Moolenaar32e35112020-05-14 22:41:15 +02002129 * Get the second variable. Recursive!
Bram Moolenaar071d4272004-06-13 20:20:40 +00002130 */
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002131 *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used);
2132 evalarg_used->eval_flags = result ? orig_flags
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002133 : orig_flags & ~EVAL_EVALUATE;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002134 if (eval1(arg, rettv, evalarg_used) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002135 return FAIL;
2136
2137 /*
2138 * Check for the ":".
2139 */
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002140 p = eval_next_non_blank(*arg, evalarg_used, &getnext);
Bram Moolenaar793648f2020-06-26 21:28:25 +02002141 if (*p != ':')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002142 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002143 emsg(_(e_missing_colon));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002144 if (evaluate && result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002145 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002146 return FAIL;
2147 }
Bram Moolenaar793648f2020-06-26 21:28:25 +02002148 if (getnext)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002149 *arg = eval_next_line(evalarg_used);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002150 else
2151 *arg = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002152
2153 /*
Bram Moolenaar32e35112020-05-14 22:41:15 +02002154 * Get the third variable. Recursive!
Bram Moolenaar071d4272004-06-13 20:20:40 +00002155 */
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002156 *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used);
2157 evalarg_used->eval_flags = !result ? orig_flags
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002158 : orig_flags & ~EVAL_EVALUATE;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002159 if (eval1(arg, &var2, evalarg_used) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002160 {
2161 if (evaluate && result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002162 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002163 return FAIL;
2164 }
2165 if (evaluate && !result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002166 *rettv = var2;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002167
2168 if (evalarg == NULL)
2169 clear_evalarg(&local_evalarg, NULL);
2170 else
2171 evalarg->eval_flags = orig_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002172 }
2173
2174 return OK;
2175}
2176
2177/*
2178 * Handle first level expression:
2179 * expr2 || expr2 || expr2 logical OR
2180 *
2181 * "arg" must point to the first non-white of the expression.
2182 * "arg" is advanced to the next non-white after the recognized expression.
2183 *
2184 * Return OK or FAIL.
2185 */
2186 static int
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002187eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002188{
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002189 char_u *p;
2190 int getnext;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002191
2192 /*
2193 * Get the first variable.
2194 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002195 if (eval3(arg, rettv, evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002196 return FAIL;
2197
2198 /*
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002199 * Handle the "||" operator.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002200 */
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002201 p = eval_next_non_blank(*arg, evalarg, &getnext);
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002202 if (p[0] == '|' && p[1] == '|')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002203 {
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002204 evalarg_T *evalarg_used = evalarg;
2205 evalarg_T local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002206 int evaluate;
2207 int orig_flags;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002208 long result = FALSE;
2209 typval_T var2;
2210 int error;
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002211 int vim9script = in_vim9script();
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002212
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002213 if (evalarg == NULL)
2214 {
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002215 CLEAR_FIELD(local_evalarg);
2216 evalarg_used = &local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002217 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002218 orig_flags = evalarg_used->eval_flags;
2219 evaluate = orig_flags & EVAL_EVALUATE;
2220 if (evaluate)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002221 {
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002222 if (vim9script)
2223 {
2224 result = tv2bool(rettv);
2225 }
2226 else
2227 {
2228 error = FALSE;
2229 if (tv_get_number_chk(rettv, &error) != 0)
2230 result = TRUE;
2231 clear_tv(rettv);
2232 if (error)
2233 return FAIL;
2234 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002235 }
2236
2237 /*
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002238 * Repeat until there is no following "||".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002239 */
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002240 while (p[0] == '|' && p[1] == '|')
2241 {
2242 if (getnext)
2243 *arg = eval_next_line(evalarg_used);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002244 else
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002245 {
2246 if (evaluate && in_vim9script() && !VIM_ISWHITE(p[-1]))
2247 {
2248 error_white_both(p, 2);
2249 clear_tv(rettv);
2250 return FAIL;
2251 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02002252 *arg = p;
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002253 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002254
2255 /*
2256 * Get the second variable.
2257 */
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002258 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2]))
2259 {
2260 error_white_both(p, 2);
2261 clear_tv(rettv);
2262 return FAIL;
2263 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002264 *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used);
2265 evalarg_used->eval_flags = !result ? orig_flags
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002266 : orig_flags & ~EVAL_EVALUATE;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002267 if (eval3(arg, &var2, evalarg_used) == FAIL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002268 return FAIL;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002269
2270 /*
2271 * Compute the result.
2272 */
2273 if (evaluate && !result)
2274 {
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002275 if (vim9script)
2276 {
2277 clear_tv(rettv);
2278 *rettv = var2;
2279 result = tv2bool(rettv);
2280 }
2281 else
2282 {
2283 if (tv_get_number_chk(&var2, &error) != 0)
2284 result = TRUE;
2285 clear_tv(&var2);
2286 if (error)
2287 return FAIL;
2288 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002289 }
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002290 if (evaluate && !vim9script)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002291 {
2292 rettv->v_type = VAR_NUMBER;
2293 rettv->vval.v_number = result;
2294 }
2295
2296 p = eval_next_non_blank(*arg, evalarg_used, &getnext);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002297 }
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002298
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002299 if (evalarg == NULL)
2300 clear_evalarg(&local_evalarg, NULL);
2301 else
2302 evalarg->eval_flags = orig_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002303 }
2304
2305 return OK;
2306}
2307
2308/*
2309 * Handle second level expression:
2310 * expr3 && expr3 && expr3 logical AND
2311 *
2312 * "arg" must point to the first non-white of the expression.
2313 * "arg" is advanced to the next non-white after the recognized expression.
2314 *
2315 * Return OK or FAIL.
2316 */
2317 static int
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002318eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002319{
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002320 char_u *p;
2321 int getnext;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002322
2323 /*
2324 * Get the first variable.
2325 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002326 if (eval4(arg, rettv, evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002327 return FAIL;
2328
2329 /*
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002330 * Handle the "&&" operator.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002331 */
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002332 p = eval_next_non_blank(*arg, evalarg, &getnext);
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002333 if (p[0] == '&' && p[1] == '&')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002334 {
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002335 evalarg_T *evalarg_used = evalarg;
2336 evalarg_T local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002337 int orig_flags;
2338 int evaluate;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002339 long result = TRUE;
2340 typval_T var2;
2341 int error;
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002342 int vim9script = in_vim9script();
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002343
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002344 if (evalarg == NULL)
2345 {
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002346 CLEAR_FIELD(local_evalarg);
2347 evalarg_used = &local_evalarg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002348 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002349 orig_flags = evalarg_used->eval_flags;
2350 evaluate = orig_flags & EVAL_EVALUATE;
2351 if (evaluate)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002352 {
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002353 if (vim9script)
2354 {
2355 result = tv2bool(rettv);
2356 }
2357 else
2358 {
2359 error = FALSE;
2360 if (tv_get_number_chk(rettv, &error) == 0)
2361 result = FALSE;
2362 clear_tv(rettv);
2363 if (error)
2364 return FAIL;
2365 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002366 }
2367
2368 /*
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002369 * Repeat until there is no following "&&".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002370 */
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002371 while (p[0] == '&' && p[1] == '&')
2372 {
2373 if (getnext)
2374 *arg = eval_next_line(evalarg_used);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002375 else
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002376 {
2377 if (evaluate && in_vim9script() && !VIM_ISWHITE(p[-1]))
2378 {
2379 error_white_both(p, 2);
2380 clear_tv(rettv);
2381 return FAIL;
2382 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02002383 *arg = p;
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002384 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002385
2386 /*
2387 * Get the second variable.
2388 */
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +02002389 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2]))
2390 {
2391 error_white_both(p, 2);
2392 clear_tv(rettv);
2393 return FAIL;
2394 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002395 *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used);
2396 evalarg_used->eval_flags = result ? orig_flags
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002397 : orig_flags & ~EVAL_EVALUATE;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002398 if (eval4(arg, &var2, evalarg_used) == FAIL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002399 return FAIL;
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002400
2401 /*
2402 * Compute the result.
2403 */
2404 if (evaluate && result)
2405 {
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002406 if (vim9script)
2407 {
2408 clear_tv(rettv);
2409 *rettv = var2;
2410 result = tv2bool(rettv);
2411 }
2412 else
2413 {
2414 if (tv_get_number_chk(&var2, &error) == 0)
2415 result = FALSE;
2416 clear_tv(&var2);
2417 if (error)
2418 return FAIL;
2419 }
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002420 }
Bram Moolenaar8c34ea52020-07-13 22:29:02 +02002421 if (evaluate && !vim9script)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002422 {
2423 rettv->v_type = VAR_NUMBER;
2424 rettv->vval.v_number = result;
2425 }
2426
2427 p = eval_next_non_blank(*arg, evalarg_used, &getnext);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002428 }
Bram Moolenaarbe7ee482020-06-26 21:38:51 +02002429
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002430 if (evalarg == NULL)
2431 clear_evalarg(&local_evalarg, NULL);
2432 else
2433 evalarg->eval_flags = orig_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002434 }
2435
2436 return OK;
2437}
2438
2439/*
2440 * Handle third level expression:
2441 * var1 == var2
2442 * var1 =~ var2
2443 * var1 != var2
2444 * var1 !~ var2
2445 * var1 > var2
2446 * var1 >= var2
2447 * var1 < var2
2448 * var1 <= var2
Bram Moolenaar8a283e52005-01-06 23:28:25 +00002449 * var1 is var2
2450 * var1 isnot var2
Bram Moolenaar071d4272004-06-13 20:20:40 +00002451 *
2452 * "arg" must point to the first non-white of the expression.
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002453 * "arg" is advanced to just after the recognized expression.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002454 *
2455 * Return OK or FAIL.
2456 */
2457 static int
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002458eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002459{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002460 char_u *p;
Bram Moolenaare6536aa2020-06-26 22:00:38 +02002461 int getnext;
Bram Moolenaar87396072019-12-31 22:36:18 +01002462 exptype_T type = EXPR_UNKNOWN;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002463 int len = 2;
Bram Moolenaar696ba232020-07-29 21:20:41 +02002464 int type_is = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002465
2466 /*
2467 * Get the first variable.
2468 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002469 if (eval5(arg, rettv, evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002470 return FAIL;
2471
Bram Moolenaare6536aa2020-06-26 22:00:38 +02002472 p = eval_next_non_blank(*arg, evalarg, &getnext);
Bram Moolenaar696ba232020-07-29 21:20:41 +02002473 type = get_compare_type(p, &len, &type_is);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002474
2475 /*
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002476 * If there is a comparative operator, use it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002477 */
Bram Moolenaar87396072019-12-31 22:36:18 +01002478 if (type != EXPR_UNKNOWN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002479 {
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02002480 typval_T var2;
2481 int ic;
2482 int vim9script = in_vim9script();
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002483 int evaluate = evalarg == NULL
2484 ? 0 : (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02002485
Bram Moolenaare6536aa2020-06-26 22:00:38 +02002486 if (getnext)
2487 *arg = eval_next_line(evalarg);
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002488 else if (evaluate && vim9script && !VIM_ISWHITE(**arg))
2489 {
2490 error_white_both(p, len);
2491 clear_tv(rettv);
2492 return FAIL;
2493 }
Bram Moolenaare6536aa2020-06-26 22:00:38 +02002494
Bram Moolenaar696ba232020-07-29 21:20:41 +02002495 if (vim9script && type_is && (p[len] == '?' || p[len] == '#'))
2496 {
2497 semsg(_(e_invexpr2), p);
2498 clear_tv(rettv);
2499 return FAIL;
2500 }
2501
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002502 // extra question mark appended: ignore case
Bram Moolenaar071d4272004-06-13 20:20:40 +00002503 if (p[len] == '?')
2504 {
2505 ic = TRUE;
2506 ++len;
2507 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002508 // extra '#' appended: match case
Bram Moolenaar071d4272004-06-13 20:20:40 +00002509 else if (p[len] == '#')
2510 {
2511 ic = FALSE;
2512 ++len;
2513 }
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02002514 // nothing appended: use 'ignorecase' if not in Vim script
Bram Moolenaar071d4272004-06-13 20:20:40 +00002515 else
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02002516 ic = vim9script ? FALSE : p_ic;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002517
2518 /*
2519 * Get the second variable.
2520 */
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002521 if (evaluate && vim9script && !IS_WHITE_OR_NUL(p[len]))
2522 {
2523 error_white_both(p, 1);
2524 clear_tv(rettv);
2525 return FAIL;
2526 }
Bram Moolenaar9215f012020-06-27 21:18:00 +02002527 *arg = skipwhite_and_linebreak(p + len, evalarg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002528 if (eval5(arg, &var2, evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002529 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002530 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002531 return FAIL;
2532 }
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002533 if (evaluate)
Bram Moolenaar31988702018-02-13 12:57:42 +01002534 {
Bram Moolenaar543e6f32020-07-10 22:45:38 +02002535 int ret;
Bram Moolenaar31988702018-02-13 12:57:42 +01002536
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02002537 if (vim9script && check_compare_types(type, rettv, &var2) == FAIL)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02002538 {
2539 ret = FAIL;
2540 clear_tv(rettv);
2541 }
2542 else
2543 ret = typval_compare(rettv, &var2, type, ic);
Bram Moolenaar31988702018-02-13 12:57:42 +01002544 clear_tv(&var2);
2545 return ret;
2546 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002547 }
2548
2549 return OK;
2550}
2551
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002552 void
2553eval_addblob(typval_T *tv1, typval_T *tv2)
2554{
2555 blob_T *b1 = tv1->vval.v_blob;
2556 blob_T *b2 = tv2->vval.v_blob;
2557 blob_T *b = blob_alloc();
2558 int i;
2559
2560 if (b != NULL)
2561 {
2562 for (i = 0; i < blob_len(b1); i++)
2563 ga_append(&b->bv_ga, blob_get(b1, i));
2564 for (i = 0; i < blob_len(b2); i++)
2565 ga_append(&b->bv_ga, blob_get(b2, i));
2566
2567 clear_tv(tv1);
2568 rettv_blob_set(tv1, b);
2569 }
2570}
2571
2572 int
2573eval_addlist(typval_T *tv1, typval_T *tv2)
2574{
2575 typval_T var3;
2576
2577 // concatenate Lists
2578 if (list_concat(tv1->vval.v_list, tv2->vval.v_list, &var3) == FAIL)
2579 {
2580 clear_tv(tv1);
2581 clear_tv(tv2);
2582 return FAIL;
2583 }
2584 clear_tv(tv1);
2585 *tv1 = var3;
2586 return OK;
2587}
2588
Bram Moolenaar071d4272004-06-13 20:20:40 +00002589/*
2590 * Handle fourth level expression:
2591 * + number addition
2592 * - number subtraction
Bram Moolenaar558ca4a2019-04-04 18:15:38 +02002593 * . string concatenation (if script version is 1)
Bram Moolenaar0f248b02019-04-04 15:36:05 +02002594 * .. string concatenation
Bram Moolenaar071d4272004-06-13 20:20:40 +00002595 *
2596 * "arg" must point to the first non-white of the expression.
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002597 * "arg" is advanced to just after the recognized expression.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002598 *
2599 * Return OK or FAIL.
2600 */
2601 static int
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002602eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002603{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002604 /*
2605 * Get the first variable.
2606 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002607 if (eval6(arg, rettv, evalarg, FALSE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002608 return FAIL;
2609
2610 /*
2611 * Repeat computing, until no '+', '-' or '.' is following.
2612 */
2613 for (;;)
2614 {
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002615 int evaluate;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002616 int getnext;
2617 char_u *p;
2618 int op;
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002619 int oplen;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002620 int concat;
2621 typval_T var2;
2622
Bram Moolenaar558ca4a2019-04-04 18:15:38 +02002623 // "." is only string concatenation when scriptversion is 1
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002624 p = eval_next_non_blank(*arg, evalarg, &getnext);
2625 op = *p;
2626 concat = op == '.' && (*(p + 1) == '.' || current_sctx.sc_version < 2);
Bram Moolenaar558ca4a2019-04-04 18:15:38 +02002627 if (op != '+' && op != '-' && !concat)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002628 break;
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002629
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002630 evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002631 oplen = (concat && p[1] == '.') ? 2 : 1;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002632 if (getnext)
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002633 *arg = eval_next_line(evalarg);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002634 else
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002635 {
2636 if (evaluate && in_vim9script() && !VIM_ISWHITE(**arg))
2637 {
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002638 error_white_both(p, oplen);
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002639 clear_tv(rettv);
2640 return FAIL;
2641 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02002642 *arg = p;
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002643 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002644 if ((op != '+' || (rettv->v_type != VAR_LIST
2645 && rettv->v_type != VAR_BLOB))
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002646#ifdef FEAT_FLOAT
2647 && (op == '.' || rettv->v_type != VAR_FLOAT)
2648#endif
2649 )
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002650 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002651 // For "list + ...", an illegal use of the first operand as
2652 // a number cannot be determined before evaluating the 2nd
2653 // operand: if this is also a list, all is ok.
2654 // For "something . ...", "something - ..." or "non-list + ...",
2655 // we know that the first operand needs to be a string or number
2656 // without evaluating the 2nd operand. So check before to avoid
2657 // side effects after an error.
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002658 if (evaluate && tv_get_string_chk(rettv) == NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002659 {
2660 clear_tv(rettv);
2661 return FAIL;
2662 }
2663 }
2664
Bram Moolenaar071d4272004-06-13 20:20:40 +00002665 /*
2666 * Get the second variable.
2667 */
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02002668 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[oplen]))
2669 {
2670 error_white_both(p, oplen);
2671 clear_tv(rettv);
2672 return FAIL;
2673 }
2674 *arg = skipwhite_and_linebreak(*arg + oplen, evalarg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002675 if (eval6(arg, &var2, evalarg, op == '.') == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002676 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002677 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002678 return FAIL;
2679 }
2680
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002681 if (evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002682 {
2683 /*
2684 * Compute the result.
2685 */
2686 if (op == '.')
2687 {
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002688 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
2689 char_u *s1 = tv_get_string_buf(rettv, buf1);
2690 char_u *s2 = tv_get_string_buf_chk(&var2, buf2);
2691
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002692 if (s2 == NULL) // type error ?
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002693 {
2694 clear_tv(rettv);
2695 clear_tv(&var2);
2696 return FAIL;
2697 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002698 p = concat_str(s1, s2);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002699 clear_tv(rettv);
2700 rettv->v_type = VAR_STRING;
2701 rettv->vval.v_string = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002702 }
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002703 else if (op == '+' && rettv->v_type == VAR_BLOB
2704 && var2.v_type == VAR_BLOB)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002705 eval_addblob(rettv, &var2);
Bram Moolenaare9a41262005-01-15 22:18:47 +00002706 else if (op == '+' && rettv->v_type == VAR_LIST
2707 && var2.v_type == VAR_LIST)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00002708 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002709 if (eval_addlist(rettv, &var2) == FAIL)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00002710 return FAIL;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00002711 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002712 else
2713 {
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002714 int error = FALSE;
2715 varnumber_T n1, n2;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002716#ifdef FEAT_FLOAT
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002717 float_T f1 = 0, f2 = 0;
2718
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002719 if (rettv->v_type == VAR_FLOAT)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002720 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002721 f1 = rettv->vval.v_float;
2722 n1 = 0;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002723 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002724 else
2725#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002726 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002727 n1 = tv_get_number_chk(rettv, &error);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002728 if (error)
2729 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002730 // This can only happen for "list + non-list". For
2731 // "non-list + ..." or "something - ...", we returned
2732 // before evaluating the 2nd operand.
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002733 clear_tv(rettv);
2734 return FAIL;
2735 }
2736#ifdef FEAT_FLOAT
2737 if (var2.v_type == VAR_FLOAT)
2738 f1 = n1;
2739#endif
2740 }
2741#ifdef FEAT_FLOAT
2742 if (var2.v_type == VAR_FLOAT)
2743 {
2744 f2 = var2.vval.v_float;
2745 n2 = 0;
2746 }
2747 else
2748#endif
2749 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002750 n2 = tv_get_number_chk(&var2, &error);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002751 if (error)
2752 {
2753 clear_tv(rettv);
2754 clear_tv(&var2);
2755 return FAIL;
2756 }
2757#ifdef FEAT_FLOAT
2758 if (rettv->v_type == VAR_FLOAT)
2759 f2 = n2;
2760#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002761 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002762 clear_tv(rettv);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002763
2764#ifdef FEAT_FLOAT
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002765 // If there is a float on either side the result is a float.
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002766 if (rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT)
2767 {
2768 if (op == '+')
2769 f1 = f1 + f2;
2770 else
2771 f1 = f1 - f2;
2772 rettv->v_type = VAR_FLOAT;
2773 rettv->vval.v_float = f1;
2774 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002775 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002776#endif
2777 {
2778 if (op == '+')
2779 n1 = n1 + n2;
2780 else
2781 n1 = n1 - n2;
2782 rettv->v_type = VAR_NUMBER;
2783 rettv->vval.v_number = n1;
2784 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002785 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002786 clear_tv(&var2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002787 }
2788 }
2789 return OK;
2790}
2791
2792/*
2793 * Handle fifth level expression:
2794 * * number multiplication
2795 * / number division
2796 * % number modulo
2797 *
2798 * "arg" must point to the first non-white of the expression.
Bram Moolenaarff1cd392020-08-05 11:51:30 +02002799 * "arg" is advanced to just after the recognized expression.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002800 *
2801 * Return OK or FAIL.
2802 */
2803 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002804eval6(
2805 char_u **arg,
2806 typval_T *rettv,
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002807 evalarg_T *evalarg,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002808 int want_string) // after "." operator
Bram Moolenaar071d4272004-06-13 20:20:40 +00002809{
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002810#ifdef FEAT_FLOAT
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002811 int use_float = FALSE;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002812#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002813
2814 /*
2815 * Get the first variable.
2816 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002817 if (eval7(arg, rettv, evalarg, want_string) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002818 return FAIL;
2819
2820 /*
2821 * Repeat computing, until no '*', '/' or '%' is following.
2822 */
2823 for (;;)
2824 {
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002825 int evaluate;
2826 int getnext;
2827 typval_T var2;
Bram Moolenaar9d489562020-07-30 20:08:50 +02002828 char_u *p;
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002829 int op;
2830 varnumber_T n1, n2;
2831#ifdef FEAT_FLOAT
2832 float_T f1, f2;
2833#endif
2834 int error;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002835
Bram Moolenaar9d489562020-07-30 20:08:50 +02002836 p = eval_next_non_blank(*arg, evalarg, &getnext);
2837 op = *p;
Bram Moolenaarb8be54d2019-07-14 18:22:59 +02002838 if (op != '*' && op != '/' && op != '%')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002839 break;
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002840
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002841 evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002842 if (getnext)
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002843 *arg = eval_next_line(evalarg);
Bram Moolenaar9d489562020-07-30 20:08:50 +02002844 else
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002845 {
2846 if (evaluate && in_vim9script() && !VIM_ISWHITE(**arg))
2847 {
2848 error_white_both(p, 1);
2849 clear_tv(rettv);
2850 return FAIL;
2851 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02002852 *arg = p;
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002853 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002854
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02002855#ifdef FEAT_FLOAT
2856 f1 = 0;
2857 f2 = 0;
2858#endif
2859 error = FALSE;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002860 if (evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002861 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002862#ifdef FEAT_FLOAT
2863 if (rettv->v_type == VAR_FLOAT)
2864 {
2865 f1 = rettv->vval.v_float;
2866 use_float = TRUE;
2867 n1 = 0;
2868 }
2869 else
2870#endif
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002871 n1 = tv_get_number_chk(rettv, &error);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002872 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002873 if (error)
2874 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002875 }
2876 else
2877 n1 = 0;
2878
2879 /*
2880 * Get the second variable.
2881 */
Bram Moolenaarb4caa162020-08-05 11:36:52 +02002882 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[1]))
2883 {
2884 error_white_both(p, 1);
2885 clear_tv(rettv);
2886 return FAIL;
2887 }
2888 *arg = skipwhite_and_linebreak(*arg + 1, evalarg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002889 if (eval7(arg, &var2, evalarg, FALSE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002890 return FAIL;
2891
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02002892 if (evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002893 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002894#ifdef FEAT_FLOAT
2895 if (var2.v_type == VAR_FLOAT)
2896 {
2897 if (!use_float)
2898 {
2899 f1 = n1;
2900 use_float = TRUE;
2901 }
2902 f2 = var2.vval.v_float;
2903 n2 = 0;
2904 }
2905 else
2906#endif
2907 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01002908 n2 = tv_get_number_chk(&var2, &error);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002909 clear_tv(&var2);
2910 if (error)
2911 return FAIL;
2912#ifdef FEAT_FLOAT
2913 if (use_float)
2914 f2 = n2;
2915#endif
2916 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002917
2918 /*
2919 * Compute the result.
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002920 * When either side is a float the result is a float.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002921 */
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002922#ifdef FEAT_FLOAT
2923 if (use_float)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002924 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002925 if (op == '*')
2926 f1 = f1 * f2;
2927 else if (op == '/')
2928 {
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002929# ifdef VMS
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002930 // VMS crashes on divide by zero, work around it
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002931 if (f2 == 0.0)
2932 {
2933 if (f1 == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002934 f1 = -1 * __F_FLT_MAX - 1L; // similar to NaN
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002935 else if (f1 < 0)
Bram Moolenaar314f11d2010-08-09 22:07:08 +02002936 f1 = -1 * __F_FLT_MAX;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002937 else
Bram Moolenaar314f11d2010-08-09 22:07:08 +02002938 f1 = __F_FLT_MAX;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002939 }
2940 else
2941 f1 = f1 / f2;
2942# else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01002943 // We rely on the floating point library to handle divide
2944 // by zero to result in "inf" and not a crash.
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002945 f1 = f1 / f2;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02002946# endif
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002947 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002948 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002949 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002950 emsg(_(e_modulus));
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002951 return FAIL;
2952 }
2953 rettv->v_type = VAR_FLOAT;
2954 rettv->vval.v_float = f1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002955 }
2956 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002957#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002958 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002959 if (op == '*')
2960 n1 = n1 * n2;
2961 else if (op == '/')
Bram Moolenaare21c1582019-03-02 11:57:09 +01002962 n1 = num_divide(n1, n2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002963 else
Bram Moolenaare21c1582019-03-02 11:57:09 +01002964 n1 = num_modulus(n1, n2);
2965
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002966 rettv->v_type = VAR_NUMBER;
2967 rettv->vval.v_number = n1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002968 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002969 }
2970 }
2971
2972 return OK;
2973}
2974
2975/*
2976 * Handle sixth level expression:
2977 * number number constant
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002978 * 0zFFFFFFFF Blob constant
Bram Moolenaarbae0c162007-05-10 19:30:25 +00002979 * "string" string constant
2980 * 'string' literal string constant
Bram Moolenaar071d4272004-06-13 20:20:40 +00002981 * &option-name option value
2982 * @r register contents
2983 * identifier variable value
2984 * function() function call
2985 * $VAR environment variable
2986 * (expression) nested expression
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002987 * [expr, expr] List
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002988 * {arg, arg -> expr} Lambda
Bram Moolenaard5abb4c2019-07-13 22:46:10 +02002989 * {key: val, key: val} Dictionary
Bram Moolenaar4c6d9042019-07-16 22:04:02 +02002990 * #{key: val, key: val} Dictionary with literal keys
Bram Moolenaar071d4272004-06-13 20:20:40 +00002991 *
2992 * Also handle:
2993 * ! in front logical NOT
2994 * - in front unary minus
2995 * + in front unary plus (ignored)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002996 * trailing [] subscript in String or List
2997 * trailing .name entry in Dictionary
Bram Moolenaarac92e252019-08-03 21:58:38 +02002998 * trailing ->name() method call
Bram Moolenaar071d4272004-06-13 20:20:40 +00002999 *
3000 * "arg" must point to the first non-white of the expression.
Bram Moolenaarff1cd392020-08-05 11:51:30 +02003001 * "arg" is advanced to just after the recognized expression.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003002 *
3003 * Return OK or FAIL.
3004 */
3005 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003006eval7(
3007 char_u **arg,
3008 typval_T *rettv,
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003009 evalarg_T *evalarg,
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003010 int want_string) // after "." operator
Bram Moolenaar071d4272004-06-13 20:20:40 +00003011{
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003012 int evaluate = evalarg != NULL
3013 && (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003014 int len;
3015 char_u *s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003016 char_u *start_leader, *end_leader;
3017 int ret = OK;
3018 char_u *alias;
3019
3020 /*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003021 * Initialise variable so that clear_tv() can't mistake this for a
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003022 * string and free a string that isn't there.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003023 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003024 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003025
3026 /*
Bram Moolenaaredf3f972016-08-29 22:49:24 +02003027 * Skip '!', '-' and '+' characters. They are handled later.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003028 */
3029 start_leader = *arg;
3030 while (**arg == '!' || **arg == '-' || **arg == '+')
3031 *arg = skipwhite(*arg + 1);
3032 end_leader = *arg;
3033
Bram Moolenaar558ca4a2019-04-04 18:15:38 +02003034 if (**arg == '.' && (!isdigit(*(*arg + 1))
3035#ifdef FEAT_FLOAT
3036 || current_sctx.sc_version < 2
3037#endif
3038 ))
3039 {
3040 semsg(_(e_invexpr2), *arg);
3041 ++*arg;
3042 return FAIL;
3043 }
3044
Bram Moolenaar071d4272004-06-13 20:20:40 +00003045 switch (**arg)
3046 {
3047 /*
3048 * Number constant.
3049 */
3050 case '0':
3051 case '1':
3052 case '2':
3053 case '3':
3054 case '4':
3055 case '5':
3056 case '6':
3057 case '7':
3058 case '8':
3059 case '9':
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003060 case '.': ret = eval_number(arg, rettv, evaluate, want_string);
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02003061
3062 // Apply prefixed "-" and "+" now. Matters especially when
3063 // "->" follows.
3064 if (ret == OK && evaluate && end_leader > start_leader)
3065 ret = eval7_leader(rettv, TRUE, start_leader, &end_leader);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003066 break;
3067
3068 /*
3069 * String constant: "string".
3070 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003071 case '"': ret = eval_string(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003072 break;
3073
3074 /*
Bram Moolenaar8c711452005-01-14 21:53:12 +00003075 * Literal string constant: 'str''ing'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003076 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003077 case '\'': ret = eval_lit_string(arg, rettv, evaluate);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003078 break;
3079
3080 /*
3081 * List: [expr, expr]
3082 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003083 case '[': ret = eval_list(arg, rettv, evalarg, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003084 break;
3085
3086 /*
Bram Moolenaar4c6d9042019-07-16 22:04:02 +02003087 * Dictionary: #{key: val, key: val}
Bram Moolenaard5abb4c2019-07-13 22:46:10 +02003088 */
Bram Moolenaar4c6d9042019-07-16 22:04:02 +02003089 case '#': if ((*arg)[1] == '{')
Bram Moolenaard5abb4c2019-07-13 22:46:10 +02003090 {
3091 ++*arg;
Bram Moolenaar8ea93902020-06-27 14:11:53 +02003092 ret = eval_dict(arg, rettv, evalarg, TRUE);
Bram Moolenaard5abb4c2019-07-13 22:46:10 +02003093 }
3094 else
3095 ret = NOTDONE;
3096 break;
3097
3098 /*
Bram Moolenaar069c1e72016-07-15 21:25:08 +02003099 * Lambda: {arg, arg -> expr}
Bram Moolenaard5abb4c2019-07-13 22:46:10 +02003100 * Dictionary: {'key': val, 'key': val}
Bram Moolenaar8c711452005-01-14 21:53:12 +00003101 */
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003102 case '{': ret = get_lambda_tv(arg, rettv, evalarg);
Bram Moolenaar069c1e72016-07-15 21:25:08 +02003103 if (ret == NOTDONE)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02003104 ret = eval_dict(arg, rettv, evalarg, FALSE);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003105 break;
3106
3107 /*
Bram Moolenaare9a41262005-01-15 22:18:47 +00003108 * Option value: &name
Bram Moolenaar071d4272004-06-13 20:20:40 +00003109 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003110 case '&': ret = eval_option(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003111 break;
3112
3113 /*
3114 * Environment variable: $VAR.
3115 */
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003116 case '$': ret = eval_env_var(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003117 break;
3118
3119 /*
3120 * Register contents: @r.
3121 */
3122 case '@': ++*arg;
3123 if (evaluate)
3124 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003125 rettv->v_type = VAR_STRING;
Bram Moolenaarb7cb42b2014-04-02 19:55:10 +02003126 rettv->vval.v_string = get_reg_contents(**arg,
3127 GREG_EXPR_SRC);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003128 }
3129 if (**arg != NUL)
3130 ++*arg;
3131 break;
3132
3133 /*
3134 * nested expression: (expression).
3135 */
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003136 case '(': {
Bram Moolenaar9215f012020-06-27 21:18:00 +02003137 *arg = skipwhite_and_linebreak(*arg + 1, evalarg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003138 ret = eval1(arg, rettv, evalarg); // recursive!
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02003139
Bram Moolenaar9215f012020-06-27 21:18:00 +02003140 *arg = skipwhite_and_linebreak(*arg, evalarg);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02003141 if (**arg == ')')
3142 ++*arg;
3143 else if (ret == OK)
3144 {
3145 emsg(_(e_missing_close));
3146 clear_tv(rettv);
3147 ret = FAIL;
3148 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003149 }
3150 break;
3151
Bram Moolenaar8c711452005-01-14 21:53:12 +00003152 default: ret = NOTDONE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003153 break;
3154 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00003155
3156 if (ret == NOTDONE)
3157 {
3158 /*
3159 * Must be a variable or function name.
3160 * Can also be a curly-braces kind of name: {expr}.
3161 */
3162 s = *arg;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003163 len = get_name_len(arg, &alias, evaluate, TRUE);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003164 if (alias != NULL)
3165 s = alias;
3166
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003167 if (len <= 0)
Bram Moolenaar8c711452005-01-14 21:53:12 +00003168 ret = FAIL;
3169 else
3170 {
Bram Moolenaar3ac9c472020-07-13 21:28:03 +02003171 int flags = evalarg == NULL ? 0 : evalarg->eval_flags;
3172
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003173 if (**arg == '(')
3174 // "name(..." recursive!
Bram Moolenaare6b53242020-07-01 17:28:33 +02003175 ret = eval_func(arg, evalarg, s, len, rettv, flags, NULL);
Bram Moolenaar227a69d2020-05-15 18:17:28 +02003176 else if (flags & EVAL_CONSTANT)
3177 ret = FAIL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003178 else if (evaluate)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02003179 {
3180 // get the value of "true", "false" or a variable
3181 if (len == 4 && in_vim9script() && STRNCMP(s, "true", 4) == 0)
3182 {
3183 rettv->v_type = VAR_BOOL;
3184 rettv->vval.v_number = VVAL_TRUE;
3185 }
3186 else if (len == 5 && in_vim9script()
3187 && STRNCMP(s, "false", 4) == 0)
3188 {
3189 rettv->v_type = VAR_BOOL;
3190 rettv->vval.v_number = VVAL_FALSE;
3191 }
3192 else
3193 ret = eval_variable(s, len, rettv, NULL, TRUE, FALSE);
3194 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00003195 else
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02003196 {
Bram Moolenaar9a78e6d2020-07-01 18:29:55 +02003197 // skip the name
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02003198 check_vars(s, len);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00003199 ret = OK;
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02003200 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00003201 }
Bram Moolenaar3c2d6532011-02-01 13:48:53 +01003202 vim_free(alias);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003203 }
3204
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003205 // Handle following '[', '(' and '.' for expr[expr], expr.name,
3206 // expr(expr), expr->name(expr)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003207 if (ret == OK)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003208 ret = handle_subscript(arg, rettv, evalarg, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003209
3210 /*
3211 * Apply logical NOT and unary '-', from right to left, ignore '+'.
3212 */
3213 if (ret == OK && evaluate && end_leader > start_leader)
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02003214 ret = eval7_leader(rettv, FALSE, start_leader, &end_leader);
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003215 return ret;
3216}
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003217
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003218/*
3219 * Apply the leading "!" and "-" before an eval7 expression to "rettv".
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02003220 * When "numeric_only" is TRUE only handle "+" and "-".
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003221 * Adjusts "end_leaderp" until it is at "start_leader".
3222 */
3223 static int
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02003224eval7_leader(
3225 typval_T *rettv,
3226 int numeric_only,
3227 char_u *start_leader,
3228 char_u **end_leaderp)
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003229{
3230 char_u *end_leader = *end_leaderp;
3231 int ret = OK;
3232 int error = FALSE;
3233 varnumber_T val = 0;
3234#ifdef FEAT_FLOAT
3235 float_T f = 0.0;
3236
3237 if (rettv->v_type == VAR_FLOAT)
3238 f = rettv->vval.v_float;
3239 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003240#endif
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003241 val = tv_get_number_chk(rettv, &error);
3242 if (error)
3243 {
3244 clear_tv(rettv);
3245 ret = FAIL;
3246 }
3247 else
3248 {
3249 while (end_leader > start_leader)
3250 {
3251 --end_leader;
3252 if (*end_leader == '!')
3253 {
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02003254 if (numeric_only)
3255 {
3256 ++end_leader;
3257 break;
3258 }
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003259#ifdef FEAT_FLOAT
3260 if (rettv->v_type == VAR_FLOAT)
3261 f = !f;
3262 else
3263#endif
3264 val = !val;
3265 }
3266 else if (*end_leader == '-')
3267 {
3268#ifdef FEAT_FLOAT
3269 if (rettv->v_type == VAR_FLOAT)
3270 f = -f;
3271 else
3272#endif
3273 val = -val;
3274 }
3275 }
3276#ifdef FEAT_FLOAT
3277 if (rettv->v_type == VAR_FLOAT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003278 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003279 clear_tv(rettv);
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003280 rettv->vval.v_float = f;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003281 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003282 else
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003283#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003284 {
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003285 clear_tv(rettv);
3286 rettv->v_type = VAR_NUMBER;
3287 rettv->vval.v_number = val;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003288 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003289 }
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02003290 *end_leaderp = end_leader;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003291 return ret;
3292}
3293
3294/*
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003295 * Call the function referred to in "rettv".
3296 */
3297 static int
3298call_func_rettv(
3299 char_u **arg,
Bram Moolenaare6b53242020-07-01 17:28:33 +02003300 evalarg_T *evalarg,
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003301 typval_T *rettv,
3302 int evaluate,
3303 dict_T *selfdict,
3304 typval_T *basetv)
3305{
3306 partial_T *pt = NULL;
3307 funcexe_T funcexe;
3308 typval_T functv;
3309 char_u *s;
3310 int ret;
3311
3312 // need to copy the funcref so that we can clear rettv
3313 if (evaluate)
3314 {
3315 functv = *rettv;
3316 rettv->v_type = VAR_UNKNOWN;
3317
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003318 // Invoke the function. Recursive!
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003319 if (functv.v_type == VAR_PARTIAL)
3320 {
3321 pt = functv.vval.v_partial;
3322 s = partial_name(pt);
3323 }
3324 else
3325 s = functv.vval.v_string;
3326 }
3327 else
3328 s = (char_u *)"";
3329
Bram Moolenaara80faa82020-04-12 19:37:17 +02003330 CLEAR_FIELD(funcexe);
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003331 funcexe.firstline = curwin->w_cursor.lnum;
3332 funcexe.lastline = curwin->w_cursor.lnum;
3333 funcexe.evaluate = evaluate;
3334 funcexe.partial = pt;
3335 funcexe.selfdict = selfdict;
3336 funcexe.basetv = basetv;
Bram Moolenaare6b53242020-07-01 17:28:33 +02003337 ret = get_func_tv(s, -1, rettv, arg, evalarg, &funcexe);
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003338
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003339 // Clear the funcref afterwards, so that deleting it while
3340 // evaluating the arguments is possible (see test55).
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003341 if (evaluate)
3342 clear_tv(&functv);
3343
3344 return ret;
3345}
3346
3347/*
3348 * Evaluate "->method()".
3349 * "*arg" points to the '-'.
3350 * Returns FAIL or OK. "*arg" is advanced to after the ')'.
3351 */
3352 static int
3353eval_lambda(
3354 char_u **arg,
3355 typval_T *rettv,
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003356 evalarg_T *evalarg,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003357 int verbose) // give error messages
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003358{
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003359 int evaluate = evalarg != NULL
3360 && (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003361 typval_T base = *rettv;
3362 int ret;
3363
3364 // Skip over the ->.
3365 *arg += 2;
3366 rettv->v_type = VAR_UNKNOWN;
3367
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003368 ret = get_lambda_tv(arg, rettv, evalarg);
Bram Moolenaar0ff822d2019-12-08 18:41:34 +01003369 if (ret != OK)
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003370 return FAIL;
3371 else if (**arg != '(')
3372 {
3373 if (verbose)
3374 {
3375 if (*skipwhite(*arg) == '(')
Bram Moolenaardb99f9f2020-03-23 22:12:22 +01003376 emsg(_(e_nowhitespace));
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003377 else
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003378 semsg(_(e_missing_paren), "lambda");
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003379 }
3380 clear_tv(rettv);
Bram Moolenaar86173482019-10-01 17:02:16 +02003381 ret = FAIL;
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003382 }
Bram Moolenaar86173482019-10-01 17:02:16 +02003383 else
Bram Moolenaare6b53242020-07-01 17:28:33 +02003384 ret = call_func_rettv(arg, evalarg, rettv, evaluate, NULL, &base);
Bram Moolenaar86173482019-10-01 17:02:16 +02003385
3386 // Clear the funcref afterwards, so that deleting it while
3387 // evaluating the arguments is possible (see test55).
3388 if (evaluate)
3389 clear_tv(&base);
3390
3391 return ret;
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003392}
3393
3394/*
Bram Moolenaarac92e252019-08-03 21:58:38 +02003395 * Evaluate "->method()".
3396 * "*arg" points to the '-'.
3397 * Returns FAIL or OK. "*arg" is advanced to after the ')'.
3398 */
3399 static int
3400eval_method(
3401 char_u **arg,
3402 typval_T *rettv,
Bram Moolenaare6b53242020-07-01 17:28:33 +02003403 evalarg_T *evalarg,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003404 int verbose) // give error messages
Bram Moolenaarac92e252019-08-03 21:58:38 +02003405{
3406 char_u *name;
3407 long len;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003408 char_u *alias;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003409 typval_T base = *rettv;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003410 int ret;
Bram Moolenaare6b53242020-07-01 17:28:33 +02003411 int evaluate = evalarg != NULL
3412 && (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaarac92e252019-08-03 21:58:38 +02003413
3414 // Skip over the ->.
3415 *arg += 2;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003416 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003417
Bram Moolenaarac92e252019-08-03 21:58:38 +02003418 name = *arg;
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003419 len = get_name_len(arg, &alias, evaluate, TRUE);
3420 if (alias != NULL)
3421 name = alias;
3422
3423 if (len <= 0)
Bram Moolenaarac92e252019-08-03 21:58:38 +02003424 {
3425 if (verbose)
3426 emsg(_("E260: Missing name after ->"));
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003427 ret = FAIL;
Bram Moolenaarac92e252019-08-03 21:58:38 +02003428 }
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003429 else
Bram Moolenaarac92e252019-08-03 21:58:38 +02003430 {
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02003431 *arg = skipwhite(*arg);
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003432 if (**arg != '(')
3433 {
3434 if (verbose)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003435 semsg(_(e_missing_paren), name);
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003436 ret = FAIL;
3437 }
Bram Moolenaar51841322019-08-08 21:10:01 +02003438 else if (VIM_ISWHITE((*arg)[-1]))
3439 {
3440 if (verbose)
Bram Moolenaardb99f9f2020-03-23 22:12:22 +01003441 emsg(_(e_nowhitespace));
Bram Moolenaar51841322019-08-08 21:10:01 +02003442 ret = FAIL;
3443 }
Bram Moolenaar761fdf02019-08-05 23:10:16 +02003444 else
Bram Moolenaare6b53242020-07-01 17:28:33 +02003445 ret = eval_func(arg, evalarg, name, len, rettv,
Bram Moolenaar32e35112020-05-14 22:41:15 +02003446 evaluate ? EVAL_EVALUATE : 0, &base);
Bram Moolenaarac92e252019-08-03 21:58:38 +02003447 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02003448
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02003449 // Clear the funcref afterwards, so that deleting it while
3450 // evaluating the arguments is possible (see test55).
Bram Moolenaarac92e252019-08-03 21:58:38 +02003451 if (evaluate)
3452 clear_tv(&base);
3453
Bram Moolenaarac92e252019-08-03 21:58:38 +02003454 return ret;
3455}
3456
3457/*
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00003458 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
3459 * "*arg" points to the '[' or '.'.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003460 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
3461 */
3462 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003463eval_index(
3464 char_u **arg,
3465 typval_T *rettv,
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003466 evalarg_T *evalarg,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003467 int verbose) // give error messages
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003468{
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003469 int evaluate = evalarg != NULL
3470 && (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003471 int empty1 = FALSE, empty2 = FALSE;
Bram Moolenaar33570922005-01-25 22:26:29 +00003472 typval_T var1, var2;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003473 long i;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003474 long n1, n2 = 0;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003475 long len = -1;
3476 int range = FALSE;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003477 char_u *s;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003478 char_u *key = NULL;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003479
Bram Moolenaara03f2332016-02-06 18:09:59 +01003480 switch (rettv->v_type)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003481 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01003482 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003483 case VAR_PARTIAL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003484 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003485 emsg(_("E695: Cannot index a Funcref"));
Bram Moolenaara03f2332016-02-06 18:09:59 +01003486 return FAIL;
3487 case VAR_FLOAT:
Bram Moolenaar2a876e42013-06-12 22:08:58 +02003488#ifdef FEAT_FLOAT
Bram Moolenaara03f2332016-02-06 18:09:59 +01003489 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003490 emsg(_(e_float_as_string));
Bram Moolenaara03f2332016-02-06 18:09:59 +01003491 return FAIL;
Bram Moolenaar2a876e42013-06-12 22:08:58 +02003492#endif
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003493 case VAR_BOOL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003494 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01003495 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01003496 case VAR_CHANNEL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003497 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003498 emsg(_("E909: Cannot index a special variable"));
Bram Moolenaara03f2332016-02-06 18:09:59 +01003499 return FAIL;
3500 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02003501 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003502 case VAR_VOID:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003503 if (evaluate)
3504 return FAIL;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003505 // FALLTHROUGH
Bram Moolenaara03f2332016-02-06 18:09:59 +01003506
3507 case VAR_STRING:
3508 case VAR_NUMBER:
3509 case VAR_LIST:
3510 case VAR_DICT:
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003511 case VAR_BLOB:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003512 break;
Bram Moolenaar520e1e42016-01-23 19:46:28 +01003513 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003514
Bram Moolenaar0a38dd22015-08-25 16:49:01 +02003515 init_tv(&var1);
3516 init_tv(&var2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003517 if (**arg == '.')
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003518 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00003519 /*
3520 * dict.name
3521 */
3522 key = *arg + 1;
Bram Moolenaarb13ab992020-07-27 21:43:28 +02003523 for (len = 0; eval_isdictc(key[len]); ++len)
Bram Moolenaar8c711452005-01-14 21:53:12 +00003524 ;
3525 if (len == 0)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003526 return FAIL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003527 *arg = skipwhite(key + len);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003528 }
3529 else
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003530 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00003531 /*
3532 * something[idx]
3533 *
3534 * Get the (first) variable from inside the [].
3535 */
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003536 *arg = skipwhite_and_linebreak(*arg + 1, evalarg);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003537 if (**arg == ':')
3538 empty1 = TRUE;
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003539 else if (eval1(arg, &var1, evalarg) == FAIL) // recursive!
Bram Moolenaar8c711452005-01-14 21:53:12 +00003540 return FAIL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003541 else if (evaluate && tv_get_string_chk(&var1) == NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003542 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003543 // not a number or string
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003544 clear_tv(&var1);
3545 return FAIL;
3546 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00003547
3548 /*
3549 * Get the second variable from inside the [:].
3550 */
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003551 *arg = skipwhite_and_linebreak(*arg, evalarg);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003552 if (**arg == ':')
3553 {
3554 range = TRUE;
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003555 *arg = skipwhite_and_linebreak(*arg + 1, evalarg);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003556 if (**arg == ']')
3557 empty2 = TRUE;
Bram Moolenaare40fbc22020-06-27 18:06:45 +02003558 else if (eval1(arg, &var2, evalarg) == FAIL) // recursive!
Bram Moolenaar8c711452005-01-14 21:53:12 +00003559 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003560 if (!empty1)
3561 clear_tv(&var1);
3562 return FAIL;
3563 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003564 else if (evaluate && tv_get_string_chk(&var2) == NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003565 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003566 // not a number or string
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003567 if (!empty1)
3568 clear_tv(&var1);
3569 clear_tv(&var2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003570 return FAIL;
3571 }
3572 }
3573
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003574 // Check for the ']'.
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003575 *arg = skipwhite_and_linebreak(*arg, evalarg);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003576 if (**arg != ']')
3577 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003578 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003579 emsg(_(e_missbrac));
Bram Moolenaar8c711452005-01-14 21:53:12 +00003580 clear_tv(&var1);
3581 if (range)
3582 clear_tv(&var2);
3583 return FAIL;
3584 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003585 *arg = skipwhite(*arg + 1); // skip the ']'
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003586 }
3587
3588 if (evaluate)
3589 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00003590 n1 = 0;
3591 if (!empty1 && rettv->v_type != VAR_DICT)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003592 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003593 n1 = tv_get_number(&var1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003594 clear_tv(&var1);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003595 }
3596 if (range)
3597 {
3598 if (empty2)
3599 n2 = -1;
3600 else
3601 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003602 n2 = tv_get_number(&var2);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003603 clear_tv(&var2);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003604 }
3605 }
3606
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003607 switch (rettv->v_type)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003608 {
Bram Moolenaar835dc632016-02-07 14:27:38 +01003609 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02003610 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003611 case VAR_VOID:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003612 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003613 case VAR_PARTIAL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003614 case VAR_FLOAT:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01003615 case VAR_BOOL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01003616 case VAR_SPECIAL:
3617 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01003618 case VAR_CHANNEL:
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003619 break; // not evaluating, skipping over subscript
Bram Moolenaara03f2332016-02-06 18:09:59 +01003620
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003621 case VAR_NUMBER:
3622 case VAR_STRING:
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003623 s = tv_get_string(rettv);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003624 len = (long)STRLEN(s);
3625 if (range)
3626 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003627 // The resulting variable is a substring. If the indexes
3628 // are out of range the result is empty.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003629 if (n1 < 0)
3630 {
3631 n1 = len + n1;
3632 if (n1 < 0)
3633 n1 = 0;
3634 }
3635 if (n2 < 0)
3636 n2 = len + n2;
3637 else if (n2 >= len)
3638 n2 = len;
3639 if (n1 >= len || n2 < 0 || n1 > n2)
3640 s = NULL;
3641 else
Bram Moolenaardf44a272020-06-07 20:49:05 +02003642 s = vim_strnsave(s + n1, n2 - n1 + 1);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003643 }
3644 else
3645 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003646 // The resulting variable is a string of a single
3647 // character. If the index is too big or negative the
3648 // result is empty.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003649 if (n1 >= len || n1 < 0)
3650 s = NULL;
3651 else
3652 s = vim_strnsave(s + n1, 1);
3653 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003654 clear_tv(rettv);
3655 rettv->v_type = VAR_STRING;
3656 rettv->vval.v_string = s;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003657 break;
3658
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003659 case VAR_BLOB:
3660 len = blob_len(rettv->vval.v_blob);
3661 if (range)
3662 {
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01003663 // The resulting variable is a sub-blob. If the indexes
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003664 // are out of range the result is empty.
3665 if (n1 < 0)
3666 {
3667 n1 = len + n1;
3668 if (n1 < 0)
3669 n1 = 0;
3670 }
3671 if (n2 < 0)
3672 n2 = len + n2;
3673 else if (n2 >= len)
3674 n2 = len - 1;
3675 if (n1 >= len || n2 < 0 || n1 > n2)
3676 {
3677 clear_tv(rettv);
3678 rettv->v_type = VAR_BLOB;
3679 rettv->vval.v_blob = NULL;
3680 }
3681 else
3682 {
3683 blob_T *blob = blob_alloc();
3684
3685 if (blob != NULL)
3686 {
3687 if (ga_grow(&blob->bv_ga, n2 - n1 + 1) == FAIL)
3688 {
3689 blob_free(blob);
3690 return FAIL;
3691 }
3692 blob->bv_ga.ga_len = n2 - n1 + 1;
3693 for (i = n1; i <= n2; i++)
3694 blob_set(blob, i - n1,
3695 blob_get(rettv->vval.v_blob, i));
3696
3697 clear_tv(rettv);
3698 rettv_blob_set(rettv, blob);
3699 }
3700 }
3701 }
3702 else
3703 {
Bram Moolenaara5be9b62019-01-24 12:31:44 +01003704 // The resulting variable is a byte value.
3705 // If the index is too big or negative that is an error.
3706 if (n1 < 0)
3707 n1 = len + n1;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003708 if (n1 < len && n1 >= 0)
3709 {
Bram Moolenaara5be9b62019-01-24 12:31:44 +01003710 int v = blob_get(rettv->vval.v_blob, n1);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003711
3712 clear_tv(rettv);
3713 rettv->v_type = VAR_NUMBER;
3714 rettv->vval.v_number = v;
3715 }
3716 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003717 semsg(_(e_blobidx), n1);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003718 }
3719 break;
3720
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003721 case VAR_LIST:
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003722 len = list_len(rettv->vval.v_list);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003723 if (n1 < 0)
3724 n1 = len + n1;
3725 if (!empty1 && (n1 < 0 || n1 >= len))
3726 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003727 // For a range we allow invalid values and return an empty
3728 // list. A list index out of range is an error.
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003729 if (!range)
3730 {
3731 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003732 semsg(_(e_listidx), n1);
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003733 return FAIL;
3734 }
3735 n1 = len;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003736 }
3737 if (range)
3738 {
Bram Moolenaar33570922005-01-25 22:26:29 +00003739 list_T *l;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003740
3741 if (n2 < 0)
3742 n2 = len + n2;
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00003743 else if (n2 >= len)
3744 n2 = len - 1;
3745 if (!empty2 && (n2 < 0 || n2 + 1 < n1))
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003746 n2 = -1;
Bram Moolenaar9af78762020-06-16 11:34:42 +02003747 l = list_slice(rettv->vval.v_list, n1, n2);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003748 if (l == NULL)
3749 return FAIL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003750 clear_tv(rettv);
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02003751 rettv_list_set(rettv, l);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003752 }
3753 else
3754 {
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003755 copy_tv(&list_find(rettv->vval.v_list, n1)->li_tv, &var1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003756 clear_tv(rettv);
3757 *rettv = var1;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003758 }
3759 break;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003760
3761 case VAR_DICT:
3762 if (range)
3763 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003764 if (verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003765 emsg(_(e_dictrange));
Bram Moolenaar8c711452005-01-14 21:53:12 +00003766 if (len == -1)
3767 clear_tv(&var1);
3768 return FAIL;
3769 }
3770 {
Bram Moolenaar33570922005-01-25 22:26:29 +00003771 dictitem_T *item;
Bram Moolenaar8c711452005-01-14 21:53:12 +00003772
3773 if (len == -1)
3774 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01003775 key = tv_get_string_chk(&var1);
Bram Moolenaar0921ecf2016-04-03 22:44:36 +02003776 if (key == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00003777 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00003778 clear_tv(&var1);
3779 return FAIL;
3780 }
3781 }
3782
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00003783 item = dict_find(rettv->vval.v_dict, key, (int)len);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003784
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00003785 if (item == NULL && verbose)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003786 semsg(_(e_dictkey), key);
Bram Moolenaar8c711452005-01-14 21:53:12 +00003787 if (len == -1)
3788 clear_tv(&var1);
3789 if (item == NULL)
3790 return FAIL;
3791
3792 copy_tv(&item->di_tv, &var1);
3793 clear_tv(rettv);
3794 *rettv = var1;
3795 }
3796 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003797 }
3798 }
3799
Bram Moolenaar49cd9572005-01-03 21:06:01 +00003800 return OK;
3801}
3802
3803/*
Bram Moolenaar4c683752020-04-05 21:38:23 +02003804 * Return the function name of partial "pt".
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003805 */
3806 char_u *
3807partial_name(partial_T *pt)
3808{
3809 if (pt->pt_name != NULL)
3810 return pt->pt_name;
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02003811 if (pt->pt_func != NULL)
3812 return pt->pt_func->uf_name;
3813 return (char_u *)"";
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003814}
3815
Bram Moolenaarddecc252016-04-06 22:59:37 +02003816 static void
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02003817partial_free(partial_T *pt)
Bram Moolenaarddecc252016-04-06 22:59:37 +02003818{
3819 int i;
3820
3821 for (i = 0; i < pt->pt_argc; ++i)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02003822 clear_tv(&pt->pt_argv[i]);
Bram Moolenaarddecc252016-04-06 22:59:37 +02003823 vim_free(pt->pt_argv);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02003824 dict_unref(pt->pt_dict);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02003825 if (pt->pt_name != NULL)
3826 {
3827 func_unref(pt->pt_name);
3828 vim_free(pt->pt_name);
3829 }
3830 else
3831 func_ptr_unref(pt->pt_func);
Bram Moolenaarf7779c62020-05-03 15:38:16 +02003832
3833 if (pt->pt_funcstack != NULL)
3834 {
3835 // Decrease the reference count for the context of a closure. If down
3836 // to zero free it and clear the variables on the stack.
3837 if (--pt->pt_funcstack->fs_refcount == 0)
3838 {
3839 garray_T *gap = &pt->pt_funcstack->fs_ga;
3840 typval_T *stack = gap->ga_data;
3841
3842 for (i = 0; i < gap->ga_len; ++i)
3843 clear_tv(stack + i);
3844 ga_clear(gap);
3845 vim_free(pt->pt_funcstack);
3846 }
3847 pt->pt_funcstack = NULL;
3848 }
3849
Bram Moolenaarddecc252016-04-06 22:59:37 +02003850 vim_free(pt);
3851}
3852
3853/*
3854 * Unreference a closure: decrement the reference count and free it when it
3855 * becomes zero.
3856 */
3857 void
3858partial_unref(partial_T *pt)
3859{
3860 if (pt != NULL && --pt->pt_refcount <= 0)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02003861 partial_free(pt);
Bram Moolenaarddecc252016-04-06 22:59:37 +02003862}
3863
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003864/*
Bram Moolenaar520e1e42016-01-23 19:46:28 +01003865 * Return the next (unique) copy ID.
3866 * Used for serializing nested structures.
3867 */
3868 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003869get_copyID(void)
Bram Moolenaar520e1e42016-01-23 19:46:28 +01003870{
3871 current_copyID += COPYID_INC;
3872 return current_copyID;
3873}
3874
3875/*
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003876 * Garbage collection for lists and dictionaries.
3877 *
3878 * We use reference counts to be able to free most items right away when they
3879 * are no longer used. But for composite items it's possible that it becomes
3880 * unused while the reference count is > 0: When there is a recursive
3881 * reference. Example:
3882 * :let l = [1, 2, 3]
3883 * :let d = {9: l}
3884 * :let l[1] = d
3885 *
3886 * Since this is quite unusual we handle this with garbage collection: every
3887 * once in a while find out which lists and dicts are not referenced from any
3888 * variable.
3889 *
3890 * Here is a good reference text about garbage collection (refers to Python
3891 * but it applies to all reference-counting mechanisms):
3892 * http://python.ca/nas/python/gc/
Bram Moolenaard9fba312005-06-26 22:34:35 +00003893 */
Bram Moolenaard9fba312005-06-26 22:34:35 +00003894
3895/*
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003896 * Do garbage collection for lists and dicts.
Bram Moolenaar574860b2016-05-24 17:33:34 +02003897 * When "testing" is TRUE this is called from test_garbagecollect_now().
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003898 * Return TRUE if some memory was freed.
Bram Moolenaard9fba312005-06-26 22:34:35 +00003899 */
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003900 int
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02003901garbage_collect(int testing)
Bram Moolenaard9fba312005-06-26 22:34:35 +00003902{
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00003903 int copyID;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01003904 int abort = FALSE;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003905 buf_T *buf;
3906 win_T *wp;
Bram Moolenaar934b1362015-02-04 23:06:45 +01003907 int did_free = FALSE;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003908 tabpage_T *tp;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003909
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02003910 if (!testing)
3911 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003912 // Only do this once.
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02003913 want_garbage_collect = FALSE;
3914 may_garbage_collect = FALSE;
3915 garbage_collect_at_exit = FALSE;
3916 }
Bram Moolenaar9fecb462006-09-05 10:59:47 +00003917
Bram Moolenaar3fbcc122019-12-30 19:19:53 +01003918 // The execution stack can grow big, limit the size.
3919 if (exestack.ga_maxlen - exestack.ga_len > 500)
3920 {
3921 size_t new_len;
3922 char_u *pp;
3923 int n;
3924
3925 // Keep 150% of the current size, with a minimum of the growth size.
3926 n = exestack.ga_len / 2;
3927 if (n < exestack.ga_growsize)
3928 n = exestack.ga_growsize;
3929
3930 // Don't make it bigger though.
3931 if (exestack.ga_len + n < exestack.ga_maxlen)
3932 {
3933 new_len = exestack.ga_itemsize * (exestack.ga_len + n);
3934 pp = vim_realloc(exestack.ga_data, new_len);
3935 if (pp == NULL)
3936 return FAIL;
3937 exestack.ga_maxlen = exestack.ga_len + n;
3938 exestack.ga_data = pp;
3939 }
3940 }
3941
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003942 // We advance by two because we add one for items referenced through
3943 // previous_funccal.
Bram Moolenaar520e1e42016-01-23 19:46:28 +01003944 copyID = get_copyID();
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00003945
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003946 /*
3947 * 1. Go through all accessible variables and mark all lists and dicts
3948 * with copyID.
3949 */
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00003950
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003951 // Don't free variables in the previous_funccal list unless they are only
3952 // referenced through previous_funccal. This must be first, because if
3953 // the item is referenced elsewhere the funccal must not be freed.
Bram Moolenaara9b579f2016-07-17 18:29:19 +02003954 abort = abort || set_ref_in_previous_funccal(copyID);
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00003955
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003956 // script-local variables
Bram Moolenaare5cdf152019-08-29 22:09:46 +02003957 abort = abort || garbage_collect_scriptvars(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003958
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003959 // buffer-local variables
Bram Moolenaar29323592016-07-24 22:04:11 +02003960 FOR_ALL_BUFFERS(buf)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01003961 abort = abort || set_ref_in_item(&buf->b_bufvar.di_tv, copyID,
3962 NULL, NULL);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003963
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003964 // window-local variables
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003965 FOR_ALL_TAB_WINDOWS(tp, wp)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01003966 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID,
3967 NULL, NULL);
Bram Moolenaar3bb28552013-04-15 18:25:59 +02003968 if (aucmd_win != NULL)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01003969 abort = abort || set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID,
3970 NULL, NULL);
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01003971#ifdef FEAT_PROP_POPUP
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003972 FOR_ALL_POPUPWINS(wp)
Bram Moolenaar4d784b22019-05-25 19:51:39 +02003973 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID,
3974 NULL, NULL);
Bram Moolenaar4d784b22019-05-25 19:51:39 +02003975 FOR_ALL_TABPAGES(tp)
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003976 FOR_ALL_POPUPWINS_IN_TAB(tp, wp)
Bram Moolenaar4d784b22019-05-25 19:51:39 +02003977 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID,
3978 NULL, NULL);
3979#endif
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003980
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003981 // tabpage-local variables
Bram Moolenaar29323592016-07-24 22:04:11 +02003982 FOR_ALL_TABPAGES(tp)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01003983 abort = abort || set_ref_in_item(&tp->tp_winvar.di_tv, copyID,
3984 NULL, NULL);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003985 // global variables
Bram Moolenaarda6c0332019-09-01 16:01:30 +02003986 abort = abort || garbage_collect_globvars(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003987
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003988 // function-local variables
Bram Moolenaara9b579f2016-07-17 18:29:19 +02003989 abort = abort || set_ref_in_call_stack(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003990
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003991 // named functions (matters for closures)
Bram Moolenaarbc7ce672016-08-01 22:49:22 +02003992 abort = abort || set_ref_in_functions(copyID);
3993
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003994 // function call arguments, if v:testing is set.
Bram Moolenaara9b579f2016-07-17 18:29:19 +02003995 abort = abort || set_ref_in_func_args(copyID);
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02003996
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01003997 // v: vars
Bram Moolenaare5cdf152019-08-29 22:09:46 +02003998 abort = abort || garbage_collect_vimvars(copyID);
Bram Moolenaard812df62008-11-09 12:46:09 +00003999
Bram Moolenaar75a1a942019-06-20 03:45:36 +02004000 // callbacks in buffers
4001 abort = abort || set_ref_in_buffers(copyID);
4002
Bram Moolenaar1dced572012-04-05 16:54:08 +02004003#ifdef FEAT_LUA
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004004 abort = abort || set_ref_in_lua(copyID);
Bram Moolenaar1dced572012-04-05 16:54:08 +02004005#endif
4006
Bram Moolenaardb913952012-06-29 12:54:53 +02004007#ifdef FEAT_PYTHON
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004008 abort = abort || set_ref_in_python(copyID);
Bram Moolenaardb913952012-06-29 12:54:53 +02004009#endif
4010
4011#ifdef FEAT_PYTHON3
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004012 abort = abort || set_ref_in_python3(copyID);
Bram Moolenaardb913952012-06-29 12:54:53 +02004013#endif
4014
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01004015#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar3780bb92016-04-12 22:18:53 +02004016 abort = abort || set_ref_in_channel(copyID);
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004017 abort = abort || set_ref_in_job(copyID);
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004018#endif
Bram Moolenaar3266c852016-04-30 18:07:05 +02004019#ifdef FEAT_NETBEANS_INTG
4020 abort = abort || set_ref_in_nb_channel(copyID);
4021#endif
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004022
Bram Moolenaare3188e22016-05-31 21:13:04 +02004023#ifdef FEAT_TIMERS
4024 abort = abort || set_ref_in_timer(copyID);
4025#endif
4026
Bram Moolenaar8f77c5a2017-04-30 14:21:00 +02004027#ifdef FEAT_QUICKFIX
4028 abort = abort || set_ref_in_quickfix(copyID);
4029#endif
4030
Bram Moolenaara2c45a12017-07-27 22:14:59 +02004031#ifdef FEAT_TERMINAL
4032 abort = abort || set_ref_in_term(copyID);
4033#endif
4034
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01004035#ifdef FEAT_PROP_POPUP
Bram Moolenaar75a1a942019-06-20 03:45:36 +02004036 abort = abort || set_ref_in_popups(copyID);
4037#endif
4038
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004039 if (!abort)
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004040 {
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004041 /*
4042 * 2. Free lists and dictionaries that are not referenced.
4043 */
4044 did_free = free_unref_items(copyID);
4045
4046 /*
4047 * 3. Check if any funccal can be freed now.
Bram Moolenaara9b579f2016-07-17 18:29:19 +02004048 * This may call us back recursively.
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004049 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02004050 free_unref_funccal(copyID, testing);
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004051 }
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004052 else if (p_verbose > 0)
4053 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01004054 verb_msg(_("Not enough memory to set references, garbage collection aborted!"));
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004055 }
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004056
4057 return did_free;
4058}
4059
4060/*
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004061 * Free lists, dictionaries, channels and jobs that are no longer referenced.
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004062 */
4063 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004064free_unref_items(int copyID)
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004065{
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00004066 int did_free = FALSE;
4067
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004068 // Let all "free" functions know that we are here. This means no
4069 // dictionaries, lists, channels or jobs are to be freed, because we will
4070 // do that here.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004071 in_free_unref_items = TRUE;
4072
4073 /*
4074 * PASS 1: free the contents of the items. We don't free the items
4075 * themselves yet, so that it is possible to decrement refcount counters
4076 */
4077
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004078 // Go through the list of dicts and free items without the copyID.
Bram Moolenaarcd524592016-07-17 14:57:05 +02004079 did_free |= dict_free_nonref(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004080
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004081 // Go through the list of lists and free items without the copyID.
Bram Moolenaarda861d62016-07-17 15:46:27 +02004082 did_free |= list_free_nonref(copyID);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004083
4084#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004085 // Go through the list of jobs and free items without the copyID. This
4086 // must happen before doing channels, because jobs refer to channels, but
4087 // the reference from the channel to the job isn't tracked.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004088 did_free |= free_unused_jobs_contents(copyID, COPYID_MASK);
4089
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004090 // Go through the list of channels and free items without the copyID.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004091 did_free |= free_unused_channels_contents(copyID, COPYID_MASK);
4092#endif
4093
4094 /*
4095 * PASS 2: free the items themselves.
4096 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02004097 dict_free_items(copyID);
Bram Moolenaarda861d62016-07-17 15:46:27 +02004098 list_free_items(copyID);
Bram Moolenaar835dc632016-02-07 14:27:38 +01004099
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004100#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004101 // Go through the list of jobs and free items without the copyID. This
4102 // must happen before doing channels, because jobs refer to channels, but
4103 // the reference from the channel to the job isn't tracked.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004104 free_unused_jobs(copyID, COPYID_MASK);
4105
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004106 // Go through the list of channels and free items without the copyID.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004107 free_unused_channels(copyID, COPYID_MASK);
4108#endif
4109
4110 in_free_unref_items = FALSE;
4111
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004112 return did_free;
4113}
4114
4115/*
4116 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004117 * "list_stack" is used to add lists to be marked. Can be NULL.
4118 *
4119 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004120 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004121 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004122set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004123{
4124 int todo;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004125 int abort = FALSE;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004126 hashitem_T *hi;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004127 hashtab_T *cur_ht;
4128 ht_stack_T *ht_stack = NULL;
4129 ht_stack_T *tempitem;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004130
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004131 cur_ht = ht;
4132 for (;;)
4133 {
4134 if (!abort)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004135 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004136 // Mark each item in the hashtab. If the item contains a hashtab
4137 // it is added to ht_stack, if it contains a list it is added to
4138 // list_stack.
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004139 todo = (int)cur_ht->ht_used;
4140 for (hi = cur_ht->ht_array; todo > 0; ++hi)
4141 if (!HASHITEM_EMPTY(hi))
4142 {
4143 --todo;
4144 abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID,
4145 &ht_stack, list_stack);
4146 }
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004147 }
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004148
4149 if (ht_stack == NULL)
4150 break;
4151
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004152 // take an item from the stack
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004153 cur_ht = ht_stack->ht;
4154 tempitem = ht_stack;
4155 ht_stack = ht_stack->prev;
4156 free(tempitem);
4157 }
4158
4159 return abort;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004160}
4161
4162/*
Bram Moolenaar7be3ab22019-06-23 01:46:15 +02004163 * Mark a dict and its items with "copyID".
4164 * Returns TRUE if setting references failed somehow.
4165 */
4166 int
4167set_ref_in_dict(dict_T *d, int copyID)
4168{
4169 if (d != NULL && d->dv_copyID != copyID)
4170 {
4171 d->dv_copyID = copyID;
4172 return set_ref_in_ht(&d->dv_hashtab, copyID, NULL);
4173 }
4174 return FALSE;
4175}
4176
4177/*
4178 * Mark a list and its items with "copyID".
4179 * Returns TRUE if setting references failed somehow.
4180 */
4181 int
4182set_ref_in_list(list_T *ll, int copyID)
4183{
4184 if (ll != NULL && ll->lv_copyID != copyID)
4185 {
4186 ll->lv_copyID = copyID;
4187 return set_ref_in_list_items(ll, copyID, NULL);
4188 }
4189 return FALSE;
4190}
4191
4192/*
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004193 * Mark all lists and dicts referenced through list "l" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004194 * "ht_stack" is used to add hashtabs to be marked. Can be NULL.
4195 *
4196 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004197 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004198 int
Bram Moolenaar7be3ab22019-06-23 01:46:15 +02004199set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004200{
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004201 listitem_T *li;
4202 int abort = FALSE;
4203 list_T *cur_l;
4204 list_stack_T *list_stack = NULL;
4205 list_stack_T *tempitem;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004206
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004207 cur_l = l;
4208 for (;;)
4209 {
Bram Moolenaar50985eb2020-01-27 22:09:39 +01004210 if (!abort && cur_l->lv_first != &range_list_item)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004211 // Mark each item in the list. If the item contains a hashtab
4212 // it is added to ht_stack, if it contains a list it is added to
4213 // list_stack.
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004214 for (li = cur_l->lv_first; !abort && li != NULL; li = li->li_next)
4215 abort = abort || set_ref_in_item(&li->li_tv, copyID,
4216 ht_stack, &list_stack);
4217 if (list_stack == NULL)
4218 break;
4219
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004220 // take an item from the stack
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004221 cur_l = list_stack->list;
4222 tempitem = list_stack;
4223 list_stack = list_stack->prev;
4224 free(tempitem);
4225 }
4226
4227 return abort;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004228}
4229
4230/*
4231 * Mark all lists and dicts referenced through typval "tv" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004232 * "list_stack" is used to add lists to be marked. Can be NULL.
4233 * "ht_stack" is used to add hashtabs to be marked. Can be NULL.
4234 *
4235 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004236 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004237 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004238set_ref_in_item(
4239 typval_T *tv,
4240 int copyID,
4241 ht_stack_T **ht_stack,
4242 list_stack_T **list_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00004243{
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004244 int abort = FALSE;
Bram Moolenaard9fba312005-06-26 22:34:35 +00004245
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004246 if (tv->v_type == VAR_DICT)
Bram Moolenaard9fba312005-06-26 22:34:35 +00004247 {
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004248 dict_T *dd = tv->vval.v_dict;
4249
Bram Moolenaara03f2332016-02-06 18:09:59 +01004250 if (dd != NULL && dd->dv_copyID != copyID)
4251 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004252 // Didn't see this dict yet.
Bram Moolenaara03f2332016-02-06 18:09:59 +01004253 dd->dv_copyID = copyID;
4254 if (ht_stack == NULL)
Bram Moolenaard9fba312005-06-26 22:34:35 +00004255 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01004256 abort = set_ref_in_ht(&dd->dv_hashtab, copyID, list_stack);
4257 }
4258 else
4259 {
4260 ht_stack_T *newitem = (ht_stack_T*)malloc(sizeof(ht_stack_T));
4261 if (newitem == NULL)
4262 abort = TRUE;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004263 else
4264 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01004265 newitem->ht = &dd->dv_hashtab;
4266 newitem->prev = *ht_stack;
4267 *ht_stack = newitem;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004268 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00004269 }
Bram Moolenaara03f2332016-02-06 18:09:59 +01004270 }
4271 }
4272 else if (tv->v_type == VAR_LIST)
4273 {
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004274 list_T *ll = tv->vval.v_list;
4275
Bram Moolenaara03f2332016-02-06 18:09:59 +01004276 if (ll != NULL && ll->lv_copyID != copyID)
4277 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004278 // Didn't see this list yet.
Bram Moolenaara03f2332016-02-06 18:09:59 +01004279 ll->lv_copyID = copyID;
4280 if (list_stack == NULL)
Bram Moolenaard9fba312005-06-26 22:34:35 +00004281 {
Bram Moolenaar7be3ab22019-06-23 01:46:15 +02004282 abort = set_ref_in_list_items(ll, copyID, ht_stack);
Bram Moolenaara03f2332016-02-06 18:09:59 +01004283 }
4284 else
4285 {
4286 list_stack_T *newitem = (list_stack_T*)malloc(
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004287 sizeof(list_stack_T));
Bram Moolenaara03f2332016-02-06 18:09:59 +01004288 if (newitem == NULL)
4289 abort = TRUE;
4290 else
4291 {
4292 newitem->list = ll;
4293 newitem->prev = *list_stack;
4294 *list_stack = newitem;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004295 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00004296 }
Bram Moolenaara03f2332016-02-06 18:09:59 +01004297 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00004298 }
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004299 else if (tv->v_type == VAR_FUNC)
4300 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004301 abort = set_ref_in_func(tv->vval.v_string, NULL, copyID);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004302 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004303 else if (tv->v_type == VAR_PARTIAL)
4304 {
4305 partial_T *pt = tv->vval.v_partial;
4306 int i;
4307
Bram Moolenaarb68b3462020-05-06 21:06:30 +02004308 if (pt != NULL && pt->pt_copyID != copyID)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004309 {
Bram Moolenaarb68b3462020-05-06 21:06:30 +02004310 // Didn't see this partial yet.
4311 pt->pt_copyID = copyID;
4312
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004313 abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004314
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004315 if (pt->pt_dict != NULL)
4316 {
4317 typval_T dtv;
4318
4319 dtv.v_type = VAR_DICT;
4320 dtv.vval.v_dict = pt->pt_dict;
4321 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4322 }
4323
4324 for (i = 0; i < pt->pt_argc; ++i)
4325 abort = abort || set_ref_in_item(&pt->pt_argv[i], copyID,
4326 ht_stack, list_stack);
Bram Moolenaarf7779c62020-05-03 15:38:16 +02004327 if (pt->pt_funcstack != NULL)
4328 {
4329 typval_T *stack = pt->pt_funcstack->fs_ga.ga_data;
4330
4331 for (i = 0; i < pt->pt_funcstack->fs_ga.ga_len; ++i)
4332 abort = abort || set_ref_in_item(stack + i, copyID,
4333 ht_stack, list_stack);
4334 }
4335
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004336 }
4337 }
4338#ifdef FEAT_JOB_CHANNEL
4339 else if (tv->v_type == VAR_JOB)
4340 {
4341 job_T *job = tv->vval.v_job;
4342 typval_T dtv;
4343
4344 if (job != NULL && job->jv_copyID != copyID)
4345 {
Bram Moolenaar0239acb2016-04-11 21:02:54 +02004346 job->jv_copyID = copyID;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004347 if (job->jv_channel != NULL)
4348 {
4349 dtv.v_type = VAR_CHANNEL;
4350 dtv.vval.v_channel = job->jv_channel;
4351 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4352 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004353 if (job->jv_exit_cb.cb_partial != NULL)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004354 {
4355 dtv.v_type = VAR_PARTIAL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004356 dtv.vval.v_partial = job->jv_exit_cb.cb_partial;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004357 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4358 }
4359 }
4360 }
4361 else if (tv->v_type == VAR_CHANNEL)
4362 {
4363 channel_T *ch =tv->vval.v_channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004364 ch_part_T part;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004365 typval_T dtv;
4366 jsonq_T *jq;
4367 cbq_T *cq;
4368
4369 if (ch != NULL && ch->ch_copyID != copyID)
4370 {
Bram Moolenaar0239acb2016-04-11 21:02:54 +02004371 ch->ch_copyID = copyID;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004372 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004373 {
4374 for (jq = ch->ch_part[part].ch_json_head.jq_next; jq != NULL;
4375 jq = jq->jq_next)
4376 set_ref_in_item(jq->jq_value, copyID, ht_stack, list_stack);
4377 for (cq = ch->ch_part[part].ch_cb_head.cq_next; cq != NULL;
4378 cq = cq->cq_next)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004379 if (cq->cq_callback.cb_partial != NULL)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004380 {
4381 dtv.v_type = VAR_PARTIAL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004382 dtv.vval.v_partial = cq->cq_callback.cb_partial;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004383 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4384 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004385 if (ch->ch_part[part].ch_callback.cb_partial != NULL)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004386 {
4387 dtv.v_type = VAR_PARTIAL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004388 dtv.vval.v_partial =
4389 ch->ch_part[part].ch_callback.cb_partial;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004390 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4391 }
4392 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004393 if (ch->ch_callback.cb_partial != NULL)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004394 {
4395 dtv.v_type = VAR_PARTIAL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004396 dtv.vval.v_partial = ch->ch_callback.cb_partial;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004397 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4398 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004399 if (ch->ch_close_cb.cb_partial != NULL)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004400 {
4401 dtv.v_type = VAR_PARTIAL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004402 dtv.vval.v_partial = ch->ch_close_cb.cb_partial;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004403 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
4404 }
4405 }
4406 }
4407#endif
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01004408 return abort;
Bram Moolenaard9fba312005-06-26 22:34:35 +00004409}
4410
Bram Moolenaar8c711452005-01-14 21:53:12 +00004411/*
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004412 * Return a string with the string representation of a variable.
4413 * If the memory is allocated "tofree" is set to it, otherwise NULL.
Bram Moolenaar8a283e52005-01-06 23:28:25 +00004414 * "numbuf" is used for a number.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004415 * When "copyID" is not NULL replace recursive lists and dicts with "...".
Bram Moolenaar35422f42017-08-05 16:33:56 +02004416 * When both "echo_style" and "composite_val" are FALSE, put quotes around
4417 * stings as "string()", otherwise does not put quotes around strings, as
4418 * ":echo" displays values.
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004419 * When "restore_copyID" is FALSE, repeated items in dictionaries and lists
4420 * are replaced with "...".
Bram Moolenaar92c5aba2007-08-14 20:29:31 +00004421 * May return NULL.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004422 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02004423 char_u *
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004424echo_string_core(
Bram Moolenaar7454a062016-01-30 15:14:10 +01004425 typval_T *tv,
4426 char_u **tofree,
4427 char_u *numbuf,
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004428 int copyID,
4429 int echo_style,
4430 int restore_copyID,
Bram Moolenaar35422f42017-08-05 16:33:56 +02004431 int composite_val)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004432{
Bram Moolenaare9a41262005-01-15 22:18:47 +00004433 static int recurse = 0;
4434 char_u *r = NULL;
4435
Bram Moolenaar33570922005-01-25 22:26:29 +00004436 if (recurse >= DICT_MAXNEST)
Bram Moolenaare9a41262005-01-15 22:18:47 +00004437 {
Bram Moolenaar8502c702014-06-17 12:51:16 +02004438 if (!did_echo_string_emsg)
4439 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004440 // Only give this message once for a recursive call to avoid
4441 // flooding the user with errors. And stop iterating over lists
4442 // and dicts.
Bram Moolenaar8502c702014-06-17 12:51:16 +02004443 did_echo_string_emsg = TRUE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004444 emsg(_("E724: variable nested too deep for displaying"));
Bram Moolenaar8502c702014-06-17 12:51:16 +02004445 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00004446 *tofree = NULL;
Bram Moolenaar8502c702014-06-17 12:51:16 +02004447 return (char_u *)"{E724}";
Bram Moolenaare9a41262005-01-15 22:18:47 +00004448 }
4449 ++recurse;
4450
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004451 switch (tv->v_type)
4452 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004453 case VAR_STRING:
Bram Moolenaar35422f42017-08-05 16:33:56 +02004454 if (echo_style && !composite_val)
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004455 {
4456 *tofree = NULL;
Bram Moolenaar35422f42017-08-05 16:33:56 +02004457 r = tv->vval.v_string;
4458 if (r == NULL)
4459 r = (char_u *)"";
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004460 }
4461 else
4462 {
4463 *tofree = string_quote(tv->vval.v_string, FALSE);
4464 r = *tofree;
4465 }
4466 break;
4467
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004468 case VAR_FUNC:
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004469 if (echo_style)
4470 {
4471 *tofree = NULL;
4472 r = tv->vval.v_string;
4473 }
4474 else
4475 {
4476 *tofree = string_quote(tv->vval.v_string, TRUE);
4477 r = *tofree;
4478 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00004479 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004480
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004481 case VAR_PARTIAL:
Bram Moolenaar24c77a12016-03-24 21:23:06 +01004482 {
4483 partial_T *pt = tv->vval.v_partial;
4484 char_u *fname = string_quote(pt == NULL ? NULL
Bram Moolenaar437bafe2016-08-01 15:40:54 +02004485 : partial_name(pt), FALSE);
Bram Moolenaar24c77a12016-03-24 21:23:06 +01004486 garray_T ga;
4487 int i;
4488 char_u *tf;
4489
4490 ga_init2(&ga, 1, 100);
4491 ga_concat(&ga, (char_u *)"function(");
4492 if (fname != NULL)
4493 {
4494 ga_concat(&ga, fname);
4495 vim_free(fname);
4496 }
4497 if (pt != NULL && pt->pt_argc > 0)
4498 {
4499 ga_concat(&ga, (char_u *)", [");
4500 for (i = 0; i < pt->pt_argc; ++i)
4501 {
4502 if (i > 0)
4503 ga_concat(&ga, (char_u *)", ");
4504 ga_concat(&ga,
4505 tv2string(&pt->pt_argv[i], &tf, numbuf, copyID));
4506 vim_free(tf);
4507 }
4508 ga_concat(&ga, (char_u *)"]");
4509 }
4510 if (pt != NULL && pt->pt_dict != NULL)
4511 {
4512 typval_T dtv;
4513
4514 ga_concat(&ga, (char_u *)", ");
4515 dtv.v_type = VAR_DICT;
4516 dtv.vval.v_dict = pt->pt_dict;
4517 ga_concat(&ga, tv2string(&dtv, &tf, numbuf, copyID));
4518 vim_free(tf);
4519 }
4520 ga_concat(&ga, (char_u *)")");
4521
4522 *tofree = ga.ga_data;
4523 r = *tofree;
4524 break;
4525 }
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004526
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004527 case VAR_BLOB:
Bram Moolenaar8c8b8bb2019-01-13 17:48:04 +01004528 r = blob2string(tv->vval.v_blob, tofree, numbuf);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004529 break;
4530
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004531 case VAR_LIST:
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004532 if (tv->vval.v_list == NULL)
4533 {
Bram Moolenaardb950e42020-04-22 19:13:19 +02004534 // NULL list is equivalent to empty list.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004535 *tofree = NULL;
Bram Moolenaardb950e42020-04-22 19:13:19 +02004536 r = (char_u *)"[]";
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004537 }
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004538 else if (copyID != 0 && tv->vval.v_list->lv_copyID == copyID
4539 && tv->vval.v_list->lv_len > 0)
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004540 {
4541 *tofree = NULL;
4542 r = (char_u *)"[...]";
4543 }
4544 else
4545 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004546 int old_copyID = tv->vval.v_list->lv_copyID;
4547
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004548 tv->vval.v_list->lv_copyID = copyID;
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004549 *tofree = list2string(tv, copyID, restore_copyID);
4550 if (restore_copyID)
4551 tv->vval.v_list->lv_copyID = old_copyID;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004552 r = *tofree;
4553 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00004554 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004555
Bram Moolenaar8c711452005-01-14 21:53:12 +00004556 case VAR_DICT:
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004557 if (tv->vval.v_dict == NULL)
4558 {
Bram Moolenaarea04a6e2020-04-23 13:38:02 +02004559 // NULL dict is equivalent to empty dict.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004560 *tofree = NULL;
Bram Moolenaarea04a6e2020-04-23 13:38:02 +02004561 r = (char_u *)"{}";
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004562 }
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004563 else if (copyID != 0 && tv->vval.v_dict->dv_copyID == copyID
4564 && tv->vval.v_dict->dv_hashtab.ht_used != 0)
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004565 {
4566 *tofree = NULL;
4567 r = (char_u *)"{...}";
4568 }
4569 else
4570 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004571 int old_copyID = tv->vval.v_dict->dv_copyID;
Bram Moolenaarea04a6e2020-04-23 13:38:02 +02004572
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004573 tv->vval.v_dict->dv_copyID = copyID;
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004574 *tofree = dict2string(tv, copyID, restore_copyID);
4575 if (restore_copyID)
4576 tv->vval.v_dict->dv_copyID = old_copyID;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004577 r = *tofree;
4578 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00004579 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004580
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004581 case VAR_NUMBER:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004582 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02004583 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004584 case VAR_VOID:
Bram Moolenaar35422f42017-08-05 16:33:56 +02004585 *tofree = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004586 r = tv_get_string_buf(tv, numbuf);
Bram Moolenaar35422f42017-08-05 16:33:56 +02004587 break;
4588
Bram Moolenaar835dc632016-02-07 14:27:38 +01004589 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01004590 case VAR_CHANNEL:
Bram Moolenaare9a41262005-01-15 22:18:47 +00004591 *tofree = NULL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004592 r = tv_get_string_buf(tv, numbuf);
Bram Moolenaar35422f42017-08-05 16:33:56 +02004593 if (composite_val)
4594 {
4595 *tofree = string_quote(r, FALSE);
4596 r = *tofree;
4597 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004598 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004599
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004600 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01004601#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004602 *tofree = NULL;
4603 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float);
4604 r = numbuf;
4605 break;
4606#endif
4607
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01004608 case VAR_BOOL:
Bram Moolenaar520e1e42016-01-23 19:46:28 +01004609 case VAR_SPECIAL:
4610 *tofree = NULL;
Bram Moolenaar17a13432016-01-24 14:22:10 +01004611 r = (char_u *)get_var_special_name(tv->vval.v_number);
Bram Moolenaar520e1e42016-01-23 19:46:28 +01004612 break;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004613 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00004614
Bram Moolenaar8502c702014-06-17 12:51:16 +02004615 if (--recurse == 0)
4616 did_echo_string_emsg = FALSE;
Bram Moolenaare9a41262005-01-15 22:18:47 +00004617 return r;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004618}
4619
4620/*
4621 * Return a string with the string representation of a variable.
4622 * If the memory is allocated "tofree" is set to it, otherwise NULL.
4623 * "numbuf" is used for a number.
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004624 * Does not put quotes around strings, as ":echo" displays values.
4625 * When "copyID" is not NULL replace recursive lists and dicts with "...".
4626 * May return NULL.
4627 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02004628 char_u *
Bram Moolenaar18dfb442016-05-31 22:31:23 +02004629echo_string(
4630 typval_T *tv,
4631 char_u **tofree,
4632 char_u *numbuf,
4633 int copyID)
4634{
4635 return echo_string_core(tv, tofree, numbuf, copyID, TRUE, FALSE, FALSE);
4636}
4637
4638/*
Bram Moolenaar33570922005-01-25 22:26:29 +00004639 * Return string "str" in ' quotes, doubling ' characters.
4640 * If "str" is NULL an empty string is assumed.
Bram Moolenaar8c711452005-01-14 21:53:12 +00004641 * If "function" is TRUE make it function('string').
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004642 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02004643 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01004644string_quote(char_u *str, int function)
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004645{
Bram Moolenaar33570922005-01-25 22:26:29 +00004646 unsigned len;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004647 char_u *p, *r, *s;
4648
Bram Moolenaar33570922005-01-25 22:26:29 +00004649 len = (function ? 13 : 3);
4650 if (str != NULL)
4651 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004652 len += (unsigned)STRLEN(str);
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004653 for (p = str; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaar33570922005-01-25 22:26:29 +00004654 if (*p == '\'')
4655 ++len;
4656 }
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004657 s = r = alloc(len);
4658 if (r != NULL)
4659 {
4660 if (function)
4661 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004662 STRCPY(r, "function('");
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004663 r += 10;
4664 }
4665 else
Bram Moolenaar8c711452005-01-14 21:53:12 +00004666 *r++ = '\'';
Bram Moolenaar33570922005-01-25 22:26:29 +00004667 if (str != NULL)
4668 for (p = str; *p != NUL; )
4669 {
4670 if (*p == '\'')
4671 *r++ = '\'';
4672 MB_COPY_CHAR(p, r);
4673 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004674 *r++ = '\'';
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004675 if (function)
4676 *r++ = ')';
4677 *r++ = NUL;
4678 }
4679 return s;
4680}
4681
Bram Moolenaar520e1e42016-01-23 19:46:28 +01004682#if defined(FEAT_FLOAT) || defined(PROTO)
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004683/*
4684 * Convert the string "text" to a floating point number.
4685 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
4686 * this always uses a decimal point.
4687 * Returns the length of the text that was consumed.
4688 */
Bram Moolenaar520e1e42016-01-23 19:46:28 +01004689 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004690string2float(
4691 char_u *text,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004692 float_T *value) // result stored here
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004693{
4694 char *s = (char *)text;
4695 float_T f;
4696
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004697 // MS-Windows does not deal with "inf" and "nan" properly.
Bram Moolenaar62473612017-01-08 19:25:40 +01004698 if (STRNICMP(text, "inf", 3) == 0)
4699 {
4700 *value = INFINITY;
4701 return 3;
4702 }
4703 if (STRNICMP(text, "-inf", 3) == 0)
4704 {
4705 *value = -INFINITY;
4706 return 4;
4707 }
4708 if (STRNICMP(text, "nan", 3) == 0)
4709 {
4710 *value = NAN;
4711 return 3;
4712 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004713 f = strtod(s, &s);
4714 *value = f;
4715 return (int)((char_u *)s - text);
4716}
4717#endif
4718
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00004719/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004720 * Translate a String variable into a position.
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004721 * Returns NULL when there is an error.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004722 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004723 pos_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01004724var2fpos(
4725 typval_T *varp,
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004726 int dollar_lnum, // TRUE when $ is last line
4727 int *fnum) // set to fnum for '0, 'A, etc.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004728{
Bram Moolenaar261bfea2006-03-01 22:12:31 +00004729 char_u *name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004730 static pos_T pos;
Bram Moolenaar261bfea2006-03-01 22:12:31 +00004731 pos_T *pp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004732
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004733 // Argument can be [lnum, col, coladd].
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004734 if (varp->v_type == VAR_LIST)
4735 {
4736 list_T *l;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004737 int len;
Bram Moolenaara5525202006-03-02 22:52:09 +00004738 int error = FALSE;
Bram Moolenaar477933c2007-07-17 14:32:23 +00004739 listitem_T *li;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004740
4741 l = varp->vval.v_list;
4742 if (l == NULL)
4743 return NULL;
4744
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004745 // Get the line number
Bram Moolenaara5525202006-03-02 22:52:09 +00004746 pos.lnum = list_find_nr(l, 0L, &error);
4747 if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004748 return NULL; // invalid line number
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004749
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004750 // Get the column number
Bram Moolenaara5525202006-03-02 22:52:09 +00004751 pos.col = list_find_nr(l, 1L, &error);
4752 if (error)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004753 return NULL;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004754 len = (long)STRLEN(ml_get(pos.lnum));
Bram Moolenaar477933c2007-07-17 14:32:23 +00004755
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004756 // We accept "$" for the column number: last column.
Bram Moolenaar477933c2007-07-17 14:32:23 +00004757 li = list_find(l, 1L);
4758 if (li != NULL && li->li_tv.v_type == VAR_STRING
4759 && li->li_tv.vval.v_string != NULL
4760 && STRCMP(li->li_tv.vval.v_string, "$") == 0)
4761 pos.col = len + 1;
4762
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004763 // Accept a position up to the NUL after the line.
Bram Moolenaar4c3f5362006-04-11 21:38:50 +00004764 if (pos.col == 0 || (int)pos.col > len + 1)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004765 return NULL; // invalid column number
Bram Moolenaara5525202006-03-02 22:52:09 +00004766 --pos.col;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004767
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004768 // Get the virtual offset. Defaults to zero.
Bram Moolenaara5525202006-03-02 22:52:09 +00004769 pos.coladd = list_find_nr(l, 2L, &error);
4770 if (error)
4771 pos.coladd = 0;
Bram Moolenaara5525202006-03-02 22:52:09 +00004772
Bram Moolenaar32466aa2006-02-24 23:53:04 +00004773 return &pos;
4774 }
4775
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004776 name = tv_get_string_chk(varp);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004777 if (name == NULL)
4778 return NULL;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004779 if (name[0] == '.') // cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00004780 return &curwin->w_cursor;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004781 if (name[0] == 'v' && name[1] == NUL) // Visual start
Bram Moolenaar9ecd0232008-06-20 15:31:51 +00004782 {
4783 if (VIsual_active)
4784 return &VIsual;
4785 return &curwin->w_cursor;
4786 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004787 if (name[0] == '\'') // mark
Bram Moolenaar071d4272004-06-13 20:20:40 +00004788 {
Bram Moolenaar9d182dd2013-01-23 15:53:15 +01004789 pp = getmark_buf_fnum(curbuf, name[1], FALSE, fnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004790 if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0)
4791 return NULL;
4792 return pp;
4793 }
Bram Moolenaara5525202006-03-02 22:52:09 +00004794
Bram Moolenaara5525202006-03-02 22:52:09 +00004795 pos.coladd = 0;
Bram Moolenaara5525202006-03-02 22:52:09 +00004796
Bram Moolenaar477933c2007-07-17 14:32:23 +00004797 if (name[0] == 'w' && dollar_lnum)
Bram Moolenaarf52c7252006-02-10 23:23:57 +00004798 {
4799 pos.col = 0;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004800 if (name[1] == '0') // "w0": first visible line
Bram Moolenaarf52c7252006-02-10 23:23:57 +00004801 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00004802 update_topline();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004803 // In silent Ex mode topline is zero, but that's not a valid line
4804 // number; use one instead.
Bram Moolenaara1d5fa62017-04-03 22:02:55 +02004805 pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1;
Bram Moolenaarf52c7252006-02-10 23:23:57 +00004806 return &pos;
4807 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004808 else if (name[1] == '$') // "w$": last visible line
Bram Moolenaarf52c7252006-02-10 23:23:57 +00004809 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00004810 validate_botline();
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004811 // In silent Ex mode botline is zero, return zero then.
Bram Moolenaara1d5fa62017-04-03 22:02:55 +02004812 pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0;
Bram Moolenaarf52c7252006-02-10 23:23:57 +00004813 return &pos;
4814 }
4815 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004816 else if (name[0] == '$') // last column or line
Bram Moolenaar071d4272004-06-13 20:20:40 +00004817 {
Bram Moolenaar477933c2007-07-17 14:32:23 +00004818 if (dollar_lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004819 {
4820 pos.lnum = curbuf->b_ml.ml_line_count;
4821 pos.col = 0;
4822 }
4823 else
4824 {
4825 pos.lnum = curwin->w_cursor.lnum;
4826 pos.col = (colnr_T)STRLEN(ml_get_curline());
4827 }
4828 return &pos;
4829 }
4830 return NULL;
4831}
4832
4833/*
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004834 * Convert list in "arg" into a position and optional file number.
4835 * When "fnump" is NULL there is no file number, only 3 items.
4836 * Note that the column is passed on as-is, the caller may want to decrement
4837 * it to use 1 for the first column.
4838 * Return FAIL when conversion is not possible, doesn't check the position for
4839 * validity.
4840 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004841 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004842list2fpos(
4843 typval_T *arg,
4844 pos_T *posp,
4845 int *fnump,
4846 colnr_T *curswantp)
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004847{
4848 list_T *l = arg->vval.v_list;
4849 long i = 0;
4850 long n;
4851
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004852 // List must be: [fnum, lnum, col, coladd, curswant], where "fnum" is only
4853 // there when "fnump" isn't NULL; "coladd" and "curswant" are optional.
Bram Moolenaarbde35262006-07-23 20:12:24 +00004854 if (arg->v_type != VAR_LIST
4855 || l == NULL
4856 || l->lv_len < (fnump == NULL ? 2 : 3)
Bram Moolenaar493c1782014-05-28 14:34:46 +02004857 || l->lv_len > (fnump == NULL ? 4 : 5))
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004858 return FAIL;
4859
4860 if (fnump != NULL)
4861 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004862 n = list_find_nr(l, i++, NULL); // fnum
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004863 if (n < 0)
4864 return FAIL;
4865 if (n == 0)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004866 n = curbuf->b_fnum; // current buffer
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004867 *fnump = n;
4868 }
4869
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004870 n = list_find_nr(l, i++, NULL); // lnum
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004871 if (n < 0)
4872 return FAIL;
4873 posp->lnum = n;
4874
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004875 n = list_find_nr(l, i++, NULL); // col
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004876 if (n < 0)
4877 return FAIL;
4878 posp->col = n;
4879
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004880 n = list_find_nr(l, i, NULL); // off
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004881 if (n < 0)
Bram Moolenaarbde35262006-07-23 20:12:24 +00004882 posp->coladd = 0;
4883 else
4884 posp->coladd = n;
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004885
Bram Moolenaar493c1782014-05-28 14:34:46 +02004886 if (curswantp != NULL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004887 *curswantp = list_find_nr(l, i + 1, NULL); // curswant
Bram Moolenaar493c1782014-05-28 14:34:46 +02004888
Bram Moolenaar0e34f622006-03-03 23:00:03 +00004889 return OK;
4890}
4891
4892/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004893 * Get the length of an environment variable name.
4894 * Advance "arg" to the first character after the name.
4895 * Return 0 for error.
4896 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +02004897 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004898get_env_len(char_u **arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004899{
4900 char_u *p;
4901 int len;
4902
4903 for (p = *arg; vim_isIDc(*p); ++p)
4904 ;
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004905 if (p == *arg) // no name found
Bram Moolenaar071d4272004-06-13 20:20:40 +00004906 return 0;
4907
4908 len = (int)(p - *arg);
4909 *arg = p;
4910 return len;
4911}
4912
4913/*
4914 * Get the length of the name of a function or internal variable.
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004915 * "arg" is advanced to after the name.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004916 * Return 0 if something is wrong.
4917 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02004918 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004919get_id_len(char_u **arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920{
4921 char_u *p;
4922 int len;
4923
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004924 // Find the end of the name.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004925 for (p = *arg; eval_isnamec(*p); ++p)
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01004926 {
4927 if (*p == ':')
4928 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004929 // "s:" is start of "s:var", but "n:" is not and can be used in
4930 // slice "[n:]". Also "xx:" is not a namespace.
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01004931 len = (int)(p - *arg);
4932 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, **arg) == NULL)
4933 || len > 1)
4934 break;
4935 }
4936 }
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004937 if (p == *arg) // no name found
Bram Moolenaar071d4272004-06-13 20:20:40 +00004938 return 0;
4939
4940 len = (int)(p - *arg);
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02004941 *arg = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004942
4943 return len;
4944}
4945
4946/*
Bram Moolenaara7043832005-01-21 11:56:39 +00004947 * Get the length of the name of a variable or function.
4948 * Only the name is recognized, does not handle ".key" or "[idx]".
Bram Moolenaar071d4272004-06-13 20:20:40 +00004949 * "arg" is advanced to the first non-white character after the name.
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004950 * Return -1 if curly braces expansion failed.
4951 * Return 0 if something else is wrong.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004952 * If the name contains 'magic' {}'s, expand them and return the
4953 * expanded name in an allocated string via 'alias' - caller must free.
4954 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +02004955 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004956get_name_len(
4957 char_u **arg,
4958 char_u **alias,
4959 int evaluate,
4960 int verbose)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004961{
4962 int len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004963 char_u *p;
4964 char_u *expr_start;
4965 char_u *expr_end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004966
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004967 *alias = NULL; // default to no alias
Bram Moolenaar071d4272004-06-13 20:20:40 +00004968
4969 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA
4970 && (*arg)[2] == (int)KE_SNR)
4971 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004972 // hard coded <SNR>, already translated
Bram Moolenaar071d4272004-06-13 20:20:40 +00004973 *arg += 3;
4974 return get_id_len(arg) + 3;
4975 }
4976 len = eval_fname_script(*arg);
4977 if (len > 0)
4978 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01004979 // literal "<SID>", "s:" or "<SNR>"
Bram Moolenaar071d4272004-06-13 20:20:40 +00004980 *arg += len;
4981 }
4982
Bram Moolenaar071d4272004-06-13 20:20:40 +00004983 /*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004984 * Find the end of the name; check for {} construction.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004985 */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00004986 p = find_name_end(*arg, &expr_start, &expr_end,
4987 len > 0 ? 0 : FNE_CHECK_START);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004988 if (expr_start != NULL)
4989 {
4990 char_u *temp_string;
4991
4992 if (!evaluate)
4993 {
4994 len += (int)(p - *arg);
4995 *arg = skipwhite(p);
4996 return len;
4997 }
4998
4999 /*
5000 * Include any <SID> etc in the expanded string:
5001 * Thus the -len here.
5002 */
5003 temp_string = make_expanded_name(*arg - len, expr_start, expr_end, p);
5004 if (temp_string == NULL)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005005 return -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005006 *alias = temp_string;
5007 *arg = skipwhite(p);
5008 return (int)STRLEN(temp_string);
5009 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005010
5011 len += get_id_len(arg);
Bram Moolenaar8309b052019-01-13 16:46:22 +01005012 // Only give an error when there is something, otherwise it will be
5013 // reported at a higher level.
5014 if (len == 0 && verbose && **arg != NUL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005015 semsg(_(e_invexpr2), *arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005016
5017 return len;
5018}
5019
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005020/*
5021 * Find the end of a variable or function name, taking care of magic braces.
5022 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
5023 * start and end of the first magic braces item.
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00005024 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005025 * Return a pointer to just after the name. Equal to "arg" if there is no
5026 * valid name.
5027 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005028 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005029find_name_end(
5030 char_u *arg,
5031 char_u **expr_start,
5032 char_u **expr_end,
5033 int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005034{
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005035 int mb_nest = 0;
5036 int br_nest = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005037 char_u *p;
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01005038 int len;
Bram Moolenaareb6880b2020-07-12 17:07:05 +02005039 int vim9script = in_vim9script();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005040
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005041 if (expr_start != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005042 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005043 *expr_start = NULL;
5044 *expr_end = NULL;
5045 }
5046
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005047 // Quick check for valid starting character.
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02005048 if ((flags & FNE_CHECK_START) && !eval_isnamec1(*arg)
5049 && (*arg != '{' || vim9script))
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00005050 return arg;
5051
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005052 for (p = arg; *p != NUL
5053 && (eval_isnamec(*p)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02005054 || (*p == '{' && !vim9script)
Bram Moolenaar63be3d42020-07-23 13:11:37 +02005055 || ((flags & FNE_INCL_BR) && (*p == '['
Bram Moolenaarb13ab992020-07-27 21:43:28 +02005056 || (*p == '.' && eval_isdictc(p[1]))))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005057 || mb_nest != 0
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005058 || br_nest != 0); MB_PTR_ADV(p))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005059 {
Bram Moolenaar8af24422005-08-08 22:06:28 +00005060 if (*p == '\'')
5061 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005062 // skip over 'string' to avoid counting [ and ] inside it.
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005063 for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p))
Bram Moolenaar8af24422005-08-08 22:06:28 +00005064 ;
5065 if (*p == NUL)
5066 break;
5067 }
5068 else if (*p == '"')
5069 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005070 // skip over "str\"ing" to avoid counting [ and ] inside it.
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005071 for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p))
Bram Moolenaar8af24422005-08-08 22:06:28 +00005072 if (*p == '\\' && p[1] != NUL)
5073 ++p;
5074 if (*p == NUL)
5075 break;
5076 }
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01005077 else if (br_nest == 0 && mb_nest == 0 && *p == ':')
5078 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005079 // "s:" is start of "s:var", but "n:" is not and can be used in
5080 // slice "[n:]". Also "xx:" is not a namespace. But {ns}: is.
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01005081 len = (int)(p - arg);
5082 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, *arg) == NULL)
Bram Moolenaar4119cf82016-01-17 14:59:01 +01005083 || (len > 1 && p[-1] != '}'))
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01005084 break;
5085 }
Bram Moolenaar8af24422005-08-08 22:06:28 +00005086
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005087 if (mb_nest == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005088 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005089 if (*p == '[')
5090 ++br_nest;
5091 else if (*p == ']')
5092 --br_nest;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005093 }
Bram Moolenaar8af24422005-08-08 22:06:28 +00005094
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02005095 if (br_nest == 0 && !vim9script)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005096 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005097 if (*p == '{')
5098 {
5099 mb_nest++;
5100 if (expr_start != NULL && *expr_start == NULL)
5101 *expr_start = p;
5102 }
5103 else if (*p == '}')
5104 {
5105 mb_nest--;
5106 if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL)
5107 *expr_end = p;
5108 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005109 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005110 }
5111
5112 return p;
5113}
5114
5115/*
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005116 * Expands out the 'magic' {}'s in a variable/function name.
5117 * Note that this can call itself recursively, to deal with
5118 * constructs like foo{bar}{baz}{bam}
5119 * The four pointer arguments point to "foo{expre}ss{ion}bar"
5120 * "in_start" ^
5121 * "expr_start" ^
5122 * "expr_end" ^
5123 * "in_end" ^
5124 *
5125 * Returns a new allocated string, which the caller must free.
5126 * Returns NULL for failure.
5127 */
5128 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005129make_expanded_name(
5130 char_u *in_start,
5131 char_u *expr_start,
5132 char_u *expr_end,
5133 char_u *in_end)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005134{
5135 char_u c1;
5136 char_u *retval = NULL;
5137 char_u *temp_result;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005138
5139 if (expr_end == NULL || in_end == NULL)
5140 return NULL;
5141 *expr_start = NUL;
5142 *expr_end = NUL;
5143 c1 = *in_end;
5144 *in_end = NUL;
5145
Bram Moolenaarb171fb12020-06-24 20:34:03 +02005146 temp_result = eval_to_string(expr_start + 1, FALSE);
5147 if (temp_result != NULL)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005148 {
Bram Moolenaar964b3742019-05-24 18:54:09 +02005149 retval = alloc(STRLEN(temp_result) + (expr_start - in_start)
5150 + (in_end - expr_end) + 1);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005151 if (retval != NULL)
5152 {
5153 STRCPY(retval, in_start);
5154 STRCAT(retval, temp_result);
5155 STRCAT(retval, expr_end + 1);
5156 }
5157 }
5158 vim_free(temp_result);
5159
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005160 *in_end = c1; // put char back for error messages
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005161 *expr_start = '{';
5162 *expr_end = '}';
5163
5164 if (retval != NULL)
5165 {
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00005166 temp_result = find_name_end(retval, &expr_start, &expr_end, 0);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005167 if (expr_start != NULL)
5168 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005169 // Further expansion!
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005170 temp_result = make_expanded_name(retval, expr_start,
5171 expr_end, temp_result);
5172 vim_free(retval);
5173 retval = temp_result;
5174 }
5175 }
5176
5177 return retval;
5178}
5179
5180/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005181 * Return TRUE if character "c" can be used in a variable or function name.
Bram Moolenaare9a41262005-01-15 22:18:47 +00005182 * Does not include '{' or '}' for magic braces.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005183 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005184 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005185eval_isnamec(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005186{
Bram Moolenaarb13ab992020-07-27 21:43:28 +02005187 return ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR;
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00005188}
5189
5190/*
5191 * Return TRUE if character "c" can be used as the first character in a
5192 * variable or function name (excluding '{' and '}').
5193 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005194 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005195eval_isnamec1(int c)
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00005196{
Bram Moolenaarb13ab992020-07-27 21:43:28 +02005197 return ASCII_ISALPHA(c) || c == '_';
5198}
5199
5200/*
5201 * Return TRUE if character "c" can be used as the first character of a
5202 * dictionary key.
5203 */
5204 int
5205eval_isdictc(int c)
5206{
5207 return ASCII_ISALNUM(c) || c == '_';
Bram Moolenaar071d4272004-06-13 20:20:40 +00005208}
5209
5210/*
Bram Moolenaarac92e252019-08-03 21:58:38 +02005211 * Handle:
5212 * - expr[expr], expr[expr:expr] subscript
5213 * - ".name" lookup
5214 * - function call with Funcref variable: func(expr)
5215 * - method call: var->method()
5216 *
5217 * Can all be combined in any order: dict.func(expr)[idx]['func'](expr)->len()
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005218 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005219 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005220handle_subscript(
5221 char_u **arg,
5222 typval_T *rettv,
Bram Moolenaare40fbc22020-06-27 18:06:45 +02005223 evalarg_T *evalarg,
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02005224 int verbose) // give error messages
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005225{
Bram Moolenaare40fbc22020-06-27 18:06:45 +02005226 int evaluate = evalarg != NULL
5227 && (evalarg->eval_flags & EVAL_EVALUATE);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005228 int ret = OK;
5229 dict_T *selfdict = NULL;
Bram Moolenaar442af2f2020-07-03 21:09:52 +02005230 int check_white = TRUE;
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005231 int getnext;
5232 char_u *p;
Bram Moolenaar442af2f2020-07-03 21:09:52 +02005233
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005234 while (ret == OK)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02005235 {
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005236 // When at the end of the line and ".name" or "->{" or "->X" follows in
5237 // the next line then consume the line break.
5238 p = eval_next_non_blank(*arg, evalarg, &getnext);
5239 if (getnext
Bram Moolenaarb13ab992020-07-27 21:43:28 +02005240 && ((rettv->v_type == VAR_DICT && *p == '.' && eval_isdictc(p[1]))
Bram Moolenaar9d489562020-07-30 20:08:50 +02005241 || (p[0] == '-' && p[1] == '>'
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005242 && (p[2] == '{' || ASCII_ISALPHA(p[2])))))
Bram Moolenaar442af2f2020-07-03 21:09:52 +02005243 {
5244 *arg = eval_next_line(evalarg);
5245 check_white = FALSE;
5246 }
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005247
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005248 if ((**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC
5249 || rettv->v_type == VAR_PARTIAL))
5250 && (!check_white || !VIM_ISWHITE(*(*arg - 1))))
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005251 {
Bram Moolenaare6b53242020-07-01 17:28:33 +02005252 ret = call_func_rettv(arg, evalarg, rettv, evaluate,
5253 selfdict, NULL);
Bram Moolenaar3f242a82016-03-18 19:39:25 +01005254
Bram Moolenaar22a0c0c2019-08-09 23:25:08 +02005255 // Stop the expression evaluation when immediately aborting on
5256 // error, or when an interrupt occurred or an exception was thrown
5257 // but not caught.
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005258 if (aborting())
5259 {
5260 if (ret == OK)
5261 clear_tv(rettv);
5262 ret = FAIL;
5263 }
5264 dict_unref(selfdict);
5265 selfdict = NULL;
5266 }
Bram Moolenaar9d489562020-07-30 20:08:50 +02005267 else if (p[0] == '-' && p[1] == '>')
Bram Moolenaarac92e252019-08-03 21:58:38 +02005268 {
Bram Moolenaar9d489562020-07-30 20:08:50 +02005269 *arg = p;
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02005270 if (ret == OK)
5271 {
5272 if ((*arg)[2] == '{')
5273 // expr->{lambda}()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02005274 ret = eval_lambda(arg, rettv, evalarg, verbose);
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02005275 else
5276 // expr->name()
Bram Moolenaare6b53242020-07-01 17:28:33 +02005277 ret = eval_method(arg, rettv, evalarg, verbose);
Bram Moolenaar9cfe8f62019-08-17 21:04:16 +02005278 }
Bram Moolenaarac92e252019-08-03 21:58:38 +02005279 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005280 // "." is ".name" lookup when we found a dict or when evaluating and
5281 // scriptversion is at least 2, where string concatenation is "..".
5282 else if (**arg == '['
5283 || (**arg == '.' && (rettv->v_type == VAR_DICT
5284 || (!evaluate
5285 && (*arg)[1] != '.'
5286 && current_sctx.sc_version >= 2))))
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005287 {
5288 dict_unref(selfdict);
5289 if (rettv->v_type == VAR_DICT)
5290 {
5291 selfdict = rettv->vval.v_dict;
5292 if (selfdict != NULL)
5293 ++selfdict->dv_refcount;
5294 }
5295 else
5296 selfdict = NULL;
Bram Moolenaare40fbc22020-06-27 18:06:45 +02005297 if (eval_index(arg, rettv, evalarg, verbose) == FAIL)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005298 {
5299 clear_tv(rettv);
5300 ret = FAIL;
5301 }
5302 }
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02005303 else
5304 break;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005305 }
Bram Moolenaarab1fa392016-03-15 19:33:34 +01005306
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005307 // Turn "dict.Func" into a partial for "Func" bound to "dict".
5308 // Don't do this when "Func" is already a partial that was bound
5309 // explicitly (pt_auto is FALSE).
Bram Moolenaar1d429612016-05-24 15:44:17 +02005310 if (selfdict != NULL
5311 && (rettv->v_type == VAR_FUNC
5312 || (rettv->v_type == VAR_PARTIAL
5313 && (rettv->vval.v_partial->pt_auto
5314 || rettv->vval.v_partial->pt_dict == NULL))))
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005315 selfdict = make_partial(selfdict, rettv);
Bram Moolenaarab1fa392016-03-15 19:33:34 +01005316
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00005317 dict_unref(selfdict);
5318 return ret;
5319}
5320
5321/*
Bram Moolenaare9a41262005-01-15 22:18:47 +00005322 * Make a copy of an item.
5323 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005324 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
5325 * reference to an already copied list/dict can be used.
5326 * Returns FAIL or OK.
Bram Moolenaare9a41262005-01-15 22:18:47 +00005327 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02005328 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005329item_copy(
5330 typval_T *from,
5331 typval_T *to,
5332 int deep,
5333 int copyID)
Bram Moolenaare9a41262005-01-15 22:18:47 +00005334{
5335 static int recurse = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005336 int ret = OK;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005337
Bram Moolenaar33570922005-01-25 22:26:29 +00005338 if (recurse >= DICT_MAXNEST)
Bram Moolenaare9a41262005-01-15 22:18:47 +00005339 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005340 emsg(_("E698: variable nested too deep for making a copy"));
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005341 return FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005342 }
5343 ++recurse;
5344
5345 switch (from->v_type)
5346 {
5347 case VAR_NUMBER:
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005348 case VAR_FLOAT:
Bram Moolenaare9a41262005-01-15 22:18:47 +00005349 case VAR_STRING:
5350 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01005351 case VAR_PARTIAL:
Bram Moolenaar9b4a15d2020-01-11 16:05:23 +01005352 case VAR_BOOL:
Bram Moolenaar15550002016-01-31 18:45:24 +01005353 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01005354 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01005355 case VAR_CHANNEL:
Bram Moolenaare9a41262005-01-15 22:18:47 +00005356 copy_tv(from, to);
5357 break;
5358 case VAR_LIST:
5359 to->v_type = VAR_LIST;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00005360 to->v_lock = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005361 if (from->vval.v_list == NULL)
5362 to->vval.v_list = NULL;
5363 else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID)
5364 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005365 // use the copy made earlier
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005366 to->vval.v_list = from->vval.v_list->lv_copylist;
5367 ++to->vval.v_list->lv_refcount;
5368 }
5369 else
5370 to->vval.v_list = list_copy(from->vval.v_list, deep, copyID);
5371 if (to->vval.v_list == NULL)
5372 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005373 break;
Bram Moolenaar3d28b582019-01-15 22:44:17 +01005374 case VAR_BLOB:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005375 ret = blob_copy(from->vval.v_blob, to);
Bram Moolenaar3d28b582019-01-15 22:44:17 +01005376 break;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005377 case VAR_DICT:
5378 to->v_type = VAR_DICT;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00005379 to->v_lock = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005380 if (from->vval.v_dict == NULL)
5381 to->vval.v_dict = NULL;
5382 else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID)
5383 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005384 // use the copy made earlier
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005385 to->vval.v_dict = from->vval.v_dict->dv_copydict;
5386 ++to->vval.v_dict->dv_refcount;
5387 }
5388 else
5389 to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID);
5390 if (to->vval.v_dict == NULL)
5391 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005392 break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01005393 case VAR_UNKNOWN:
Bram Moolenaar4c683752020-04-05 21:38:23 +02005394 case VAR_ANY:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005395 case VAR_VOID:
Bram Moolenaardd589232020-02-29 17:38:12 +01005396 internal_error_no_abort("item_copy(UNKNOWN)");
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005397 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005398 }
5399 --recurse;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005400 return ret;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005401}
5402
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005403 void
5404echo_one(typval_T *rettv, int with_space, int *atstart, int *needclr)
5405{
5406 char_u *tofree;
5407 char_u numbuf[NUMBUFLEN];
5408 char_u *p = echo_string(rettv, &tofree, numbuf, get_copyID());
5409
5410 if (*atstart)
5411 {
5412 *atstart = FALSE;
5413 // Call msg_start() after eval1(), evaluating the expression
5414 // may cause a message to appear.
5415 if (with_space)
5416 {
5417 // Mark the saved text as finishing the line, so that what
5418 // follows is displayed on a new line when scrolling back
5419 // at the more prompt.
5420 msg_sb_eol();
5421 msg_start();
5422 }
5423 }
5424 else if (with_space)
5425 msg_puts_attr(" ", echo_attr);
5426
5427 if (p != NULL)
5428 for ( ; *p != NUL && !got_int; ++p)
5429 {
5430 if (*p == '\n' || *p == '\r' || *p == TAB)
5431 {
5432 if (*p != TAB && *needclr)
5433 {
5434 // remove any text still there from the command
5435 msg_clr_eos();
5436 *needclr = FALSE;
5437 }
5438 msg_putchar_attr(*p, echo_attr);
5439 }
5440 else
5441 {
5442 if (has_mbyte)
5443 {
5444 int i = (*mb_ptr2len)(p);
5445
5446 (void)msg_outtrans_len_attr(p, i, echo_attr);
5447 p += i - 1;
5448 }
5449 else
5450 (void)msg_outtrans_len_attr(p, 1, echo_attr);
5451 }
5452 }
5453 vim_free(tofree);
5454}
5455
Bram Moolenaare9a41262005-01-15 22:18:47 +00005456/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005457 * ":echo expr1 ..." print each argument separated with a space, add a
5458 * newline at the end.
5459 * ":echon expr1 ..." print each argument plain.
5460 */
5461 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005462ex_echo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005463{
5464 char_u *arg = eap->arg;
Bram Moolenaar33570922005-01-25 22:26:29 +00005465 typval_T rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005466 char_u *p;
5467 int needclr = TRUE;
5468 int atstart = TRUE;
Bram Moolenaar76a63452018-11-28 20:38:37 +01005469 int did_emsg_before = did_emsg;
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01005470 int called_emsg_before = called_emsg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02005471 evalarg_T evalarg;
5472
Bram Moolenaare707c882020-07-01 13:07:37 +02005473 fill_evalarg_from_eap(&evalarg, eap, eap->skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005474
5475 if (eap->skip)
5476 ++emsg_skip;
Bram Moolenaar7a092242020-04-16 22:10:49 +02005477 while ((!ends_excmd2(eap->cmd, arg) || *arg == '"') && !got_int)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005478 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005479 // If eval1() causes an error message the text from the command may
5480 // still need to be cleared. E.g., "echo 22,44".
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005481 need_clr_eos = needclr;
5482
Bram Moolenaar071d4272004-06-13 20:20:40 +00005483 p = arg;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02005484 if (eval1(&arg, &rettv, &evalarg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005485 {
5486 /*
5487 * Report the invalid expression unless the expression evaluation
5488 * has been cancelled due to an aborting error, an interrupt, or an
5489 * exception.
5490 */
Bram Moolenaarc0f5a782019-01-13 15:16:13 +01005491 if (!aborting() && did_emsg == did_emsg_before
5492 && called_emsg == called_emsg_before)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005493 semsg(_(e_invexpr2), p);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005494 need_clr_eos = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005495 break;
5496 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005497 need_clr_eos = FALSE;
5498
Bram Moolenaar071d4272004-06-13 20:20:40 +00005499 if (!eap->skip)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005500 echo_one(&rettv, eap->cmdidx == CMD_echo, &atstart, &needclr);
Bram Moolenaar81bf7082005-02-12 14:31:42 +00005501
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005502 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005503 arg = skipwhite(arg);
5504 }
5505 eap->nextcmd = check_nextcmd(arg);
Bram Moolenaarfaf86262020-06-27 23:07:36 +02005506 clear_evalarg(&evalarg, eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005507
5508 if (eap->skip)
5509 --emsg_skip;
5510 else
5511 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005512 // remove text that may still be there from the command
Bram Moolenaar071d4272004-06-13 20:20:40 +00005513 if (needclr)
5514 msg_clr_eos();
5515 if (eap->cmdidx == CMD_echo)
5516 msg_end();
5517 }
5518}
5519
5520/*
5521 * ":echohl {name}".
5522 */
5523 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005524ex_echohl(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005525{
Bram Moolenaar1b9645d2017-09-17 23:03:31 +02005526 echo_attr = syn_name2attr(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005527}
5528
5529/*
Bram Moolenaarda6c0332019-09-01 16:01:30 +02005530 * Returns the :echo attribute
5531 */
5532 int
5533get_echo_attr(void)
5534{
5535 return echo_attr;
5536}
5537
5538/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005539 * ":execute expr1 ..." execute the result of an expression.
5540 * ":echomsg expr1 ..." Print a message
5541 * ":echoerr expr1 ..." Print an error
5542 * Each gets spaces around each argument and a newline at the end for
5543 * echo commands
5544 */
5545 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005546ex_execute(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005547{
5548 char_u *arg = eap->arg;
Bram Moolenaar33570922005-01-25 22:26:29 +00005549 typval_T rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005550 int ret = OK;
5551 char_u *p;
5552 garray_T ga;
5553 int len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005554
5555 ga_init2(&ga, 1, 80);
5556
5557 if (eap->skip)
5558 ++emsg_skip;
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02005559 while (!ends_excmd2(eap->cmd, arg) || *arg == '"')
Bram Moolenaar071d4272004-06-13 20:20:40 +00005560 {
Bram Moolenaar47e880d2020-06-30 22:02:02 +02005561 ret = eval1_emsg(&arg, &rettv, eap);
Bram Moolenaarce9d50d2019-01-14 22:22:29 +01005562 if (ret == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005563 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005564
5565 if (!eap->skip)
5566 {
Bram Moolenaar461a7fc2018-12-22 13:28:07 +01005567 char_u buf[NUMBUFLEN];
5568
5569 if (eap->cmdidx == CMD_execute)
Bram Moolenaarb6625912020-01-08 20:09:01 +01005570 {
5571 if (rettv.v_type == VAR_CHANNEL || rettv.v_type == VAR_JOB)
5572 {
5573 emsg(_(e_inval_string));
5574 p = NULL;
5575 }
5576 else
5577 p = tv_get_string_buf(&rettv, buf);
5578 }
Bram Moolenaar461a7fc2018-12-22 13:28:07 +01005579 else
5580 p = tv_stringify(&rettv, buf);
Bram Moolenaar9db2afe2020-01-08 18:56:20 +01005581 if (p == NULL)
5582 {
5583 clear_tv(&rettv);
5584 ret = FAIL;
5585 break;
5586 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005587 len = (int)STRLEN(p);
5588 if (ga_grow(&ga, len + 2) == FAIL)
5589 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005590 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005591 ret = FAIL;
5592 break;
5593 }
5594 if (ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005595 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' ';
Bram Moolenaar071d4272004-06-13 20:20:40 +00005596 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005597 ga.ga_len += len;
5598 }
5599
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005600 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005601 arg = skipwhite(arg);
5602 }
5603
5604 if (ret != FAIL && ga.ga_data != NULL)
5605 {
Bram Moolenaar57002ad2017-03-16 19:04:19 +01005606 if (eap->cmdidx == CMD_echomsg || eap->cmdidx == CMD_echoerr)
5607 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005608 // Mark the already saved text as finishing the line, so that what
5609 // follows is displayed on a new line when scrolling back at the
5610 // more prompt.
Bram Moolenaar57002ad2017-03-16 19:04:19 +01005611 msg_sb_eol();
Bram Moolenaar57002ad2017-03-16 19:04:19 +01005612 }
5613
Bram Moolenaar071d4272004-06-13 20:20:40 +00005614 if (eap->cmdidx == CMD_echomsg)
Bram Moolenaar4770d092006-01-12 23:22:24 +00005615 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005616 msg_attr(ga.ga_data, echo_attr);
Bram Moolenaar4770d092006-01-12 23:22:24 +00005617 out_flush();
5618 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005619 else if (eap->cmdidx == CMD_echoerr)
5620 {
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02005621 int save_did_emsg = did_emsg;
5622
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005623 // We don't want to abort following commands, restore did_emsg.
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005624 emsg(ga.ga_data);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005625 if (!force_abort)
5626 did_emsg = save_did_emsg;
5627 }
5628 else if (eap->cmdidx == CMD_execute)
5629 do_cmdline((char_u *)ga.ga_data,
5630 eap->getline, eap->cookie, DOCMD_NOWAIT|DOCMD_VERBOSE);
5631 }
5632
5633 ga_clear(&ga);
5634
5635 if (eap->skip)
5636 --emsg_skip;
5637
5638 eap->nextcmd = check_nextcmd(arg);
5639}
5640
5641/*
5642 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
5643 * "arg" points to the "&" or '+' when called, to "option" when returning.
5644 * Returns NULL when no option name found. Otherwise pointer to the char
5645 * after the option name.
5646 */
Bram Moolenaar0522ba02019-08-27 22:48:30 +02005647 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005648find_option_end(char_u **arg, int *opt_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005649{
5650 char_u *p = *arg;
5651
5652 ++p;
5653 if (*p == 'g' && p[1] == ':')
5654 {
5655 *opt_flags = OPT_GLOBAL;
5656 p += 2;
5657 }
5658 else if (*p == 'l' && p[1] == ':')
5659 {
5660 *opt_flags = OPT_LOCAL;
5661 p += 2;
5662 }
5663 else
5664 *opt_flags = 0;
5665
5666 if (!ASCII_ISALPHA(*p))
5667 return NULL;
5668 *arg = p;
5669
5670 if (p[0] == 't' && p[1] == '_' && p[2] != NUL && p[3] != NUL)
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005671 p += 4; // termcap option
Bram Moolenaar071d4272004-06-13 20:20:40 +00005672 else
5673 while (ASCII_ISALPHA(*p))
5674 ++p;
5675 return p;
5676}
5677
5678/*
Bram Moolenaar661b1822005-07-28 22:36:45 +00005679 * Display script name where an item was last set.
5680 * Should only be invoked when 'verbose' is non-zero.
5681 */
5682 void
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005683last_set_msg(sctx_T script_ctx)
Bram Moolenaar661b1822005-07-28 22:36:45 +00005684{
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00005685 char_u *p;
5686
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005687 if (script_ctx.sc_sid != 0)
Bram Moolenaar661b1822005-07-28 22:36:45 +00005688 {
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005689 p = home_replace_save(NULL, get_scriptname(script_ctx.sc_sid));
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00005690 if (p != NULL)
5691 {
5692 verbose_enter();
Bram Moolenaar32526b32019-01-19 17:43:09 +01005693 msg_puts(_("\n\tLast set from "));
5694 msg_puts((char *)p);
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005695 if (script_ctx.sc_lnum > 0)
5696 {
Bram Moolenaar64e74c92019-12-22 15:38:06 +01005697 msg_puts(_(line_msg));
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005698 msg_outnum((long)script_ctx.sc_lnum);
5699 }
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00005700 verbose_leave();
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005701 vim_free(p);
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00005702 }
Bram Moolenaar661b1822005-07-28 22:36:45 +00005703 }
5704}
5705
Bram Moolenaarb005cd82019-09-04 15:54:55 +02005706#endif // FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005707
5708/*
5709 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
Bram Moolenaar72ab7292016-07-19 19:10:51 +02005710 * When "sub" is NULL "expr" is used, must be a VAR_FUNC or VAR_PARTIAL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005711 * "flags" can be "g" to do a global substitute.
5712 * Returns an allocated string, NULL for error.
5713 */
5714 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005715do_string_sub(
5716 char_u *str,
5717 char_u *pat,
5718 char_u *sub,
Bram Moolenaar72ab7292016-07-19 19:10:51 +02005719 typval_T *expr,
Bram Moolenaar7454a062016-01-30 15:14:10 +01005720 char_u *flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005721{
5722 int sublen;
5723 regmatch_T regmatch;
5724 int i;
5725 int do_all;
5726 char_u *tail;
Bram Moolenaare90c8532014-11-05 16:03:44 +01005727 char_u *end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005728 garray_T ga;
5729 char_u *ret;
5730 char_u *save_cpo;
Bram Moolenaar8af26912014-01-23 20:09:34 +01005731 char_u *zero_width = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005732
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005733 // Make 'cpoptions' empty, so that the 'l' flag doesn't work here
Bram Moolenaar071d4272004-06-13 20:20:40 +00005734 save_cpo = p_cpo;
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +00005735 p_cpo = empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005736
5737 ga_init2(&ga, 1, 200);
5738
5739 do_all = (flags[0] == 'g');
5740
5741 regmatch.rm_ic = p_ic;
5742 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
5743 if (regmatch.regprog != NULL)
5744 {
5745 tail = str;
Bram Moolenaare90c8532014-11-05 16:03:44 +01005746 end = str + STRLEN(str);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005747 while (vim_regexec_nl(&regmatch, str, (colnr_T)(tail - str)))
5748 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005749 // Skip empty match except for first match.
Bram Moolenaar8af26912014-01-23 20:09:34 +01005750 if (regmatch.startp[0] == regmatch.endp[0])
5751 {
5752 if (zero_width == regmatch.startp[0])
5753 {
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005754 // avoid getting stuck on a match with an empty string
Bram Moolenaar1614a142019-10-06 22:00:13 +02005755 i = mb_ptr2len(tail);
Bram Moolenaar8e7048c2014-06-12 18:39:22 +02005756 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail,
5757 (size_t)i);
5758 ga.ga_len += i;
5759 tail += i;
Bram Moolenaar8af26912014-01-23 20:09:34 +01005760 continue;
5761 }
5762 zero_width = regmatch.startp[0];
5763 }
5764
Bram Moolenaar071d4272004-06-13 20:20:40 +00005765 /*
5766 * Get some space for a temporary buffer to do the substitution
5767 * into. It will contain:
5768 * - The text up to where the match is.
5769 * - The substituted text.
5770 * - The text after the match.
5771 */
Bram Moolenaar72ab7292016-07-19 19:10:51 +02005772 sublen = vim_regsub(&regmatch, sub, expr, tail, FALSE, TRUE, FALSE);
Bram Moolenaare90c8532014-11-05 16:03:44 +01005773 if (ga_grow(&ga, (int)((end - tail) + sublen -
Bram Moolenaar071d4272004-06-13 20:20:40 +00005774 (regmatch.endp[0] - regmatch.startp[0]))) == FAIL)
5775 {
5776 ga_clear(&ga);
5777 break;
5778 }
5779
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005780 // copy the text up to where the match is
Bram Moolenaar071d4272004-06-13 20:20:40 +00005781 i = (int)(regmatch.startp[0] - tail);
5782 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005783 // add the substituted text
Bram Moolenaar72ab7292016-07-19 19:10:51 +02005784 (void)vim_regsub(&regmatch, sub, expr, (char_u *)ga.ga_data
Bram Moolenaar071d4272004-06-13 20:20:40 +00005785 + ga.ga_len + i, TRUE, TRUE, FALSE);
5786 ga.ga_len += i + sublen - 1;
Bram Moolenaarceb84af2013-09-29 21:11:05 +02005787 tail = regmatch.endp[0];
5788 if (*tail == NUL)
5789 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005790 if (!do_all)
5791 break;
5792 }
5793
5794 if (ga.ga_data != NULL)
5795 STRCPY((char *)ga.ga_data + ga.ga_len, tail);
5796
Bram Moolenaar473de612013-06-08 18:19:48 +02005797 vim_regfree(regmatch.regprog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005798 }
5799
5800 ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data);
5801 ga_clear(&ga);
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +00005802 if (p_cpo == empty_option)
5803 p_cpo = save_cpo;
5804 else
Bram Moolenaar5d18efe2019-12-01 21:11:22 +01005805 // Darn, evaluating {sub} expression or {expr} changed the value.
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +00005806 free_string_option(save_cpo);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005807
5808 return ret;
5809}