diff options
Diffstat (limited to '')
-rw-r--r-- | src/eval.c | 6310 |
1 files changed, 6310 insertions, 0 deletions
diff --git a/src/eval.c b/src/eval.c new file mode 100644 index 0000000..ebd2507 --- /dev/null +++ b/src/eval.c @@ -0,0 +1,6310 @@ +/* vi:set ts=8 sts=4 sw=4 noet: + * + * VIM - Vi IMproved by Bram Moolenaar + * + * Do ":help uganda" in Vim to read copying and usage conditions. + * Do ":help credits" in Vim to see a list of people who contributed. + * See README.txt for an overview of the Vim source code. + */ + +/* + * eval.c: Expression evaluation. + */ +#define USING_FLOAT_STUFF + +#include "vim.h" + +#if defined(FEAT_EVAL) || defined(PROTO) + +#ifdef VMS +# include <float.h> +#endif + +#define NAMESPACE_CHAR (char_u *)"abglstvw" + +/* + * When recursively copying lists and dicts we need to remember which ones we + * have done to avoid endless recursiveness. This unique ID is used for that. + * The last bit is used for previous_funccal, ignored when comparing. + */ +static int current_copyID = 0; + +/* + * Info used by a ":for" loop. + */ +typedef struct +{ + int fi_semicolon; // TRUE if ending in '; var]' + int fi_varcount; // nr of variables in the list + int fi_break_count; // nr of line breaks encountered + listwatch_T fi_lw; // keep an eye on the item used. + list_T *fi_list; // list being used + int fi_bi; // index of blob + blob_T *fi_blob; // blob being used +} forinfo_T; + +static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op); +static int eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg); +static int eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg); +static int eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg); +static int eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg); +static int eval6(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string); +static int eval7(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string); +static int eval7_leader(typval_T *rettv, int numeric_only, char_u *start_leader, char_u **end_leaderp); + +static int free_unref_items(int copyID); +static char_u *make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end); + +/* + * Return "n1" divided by "n2", taking care of dividing by zero. + * If "failed" is not NULL set it to TRUE when dividing by zero fails. + */ + varnumber_T +num_divide(varnumber_T n1, varnumber_T n2, int *failed) +{ + varnumber_T result; + + if (n2 == 0) + { + if (in_vim9script()) + { + emsg(_(e_divide_by_zero)); + if (failed != NULL) + *failed = TRUE; + } + if (n1 == 0) + result = VARNUM_MIN; // similar to NaN + else if (n1 < 0) + result = -VARNUM_MAX; + else + result = VARNUM_MAX; + } + else + result = n1 / n2; + + return result; +} + +/* + * Return "n1" modulus "n2", taking care of dividing by zero. + * If "failed" is not NULL set it to TRUE when dividing by zero fails. + */ + varnumber_T +num_modulus(varnumber_T n1, varnumber_T n2, int *failed) +{ + if (n2 == 0 && in_vim9script()) + { + emsg(_(e_divide_by_zero)); + if (failed != NULL) + *failed = TRUE; + } + return (n2 == 0) ? 0 : (n1 % n2); +} + +#if defined(EBCDIC) || defined(PROTO) +/* + * Compare struct fst by function name. + */ + static int +compare_func_name(const void *s1, const void *s2) +{ + struct fst *p1 = (struct fst *)s1; + struct fst *p2 = (struct fst *)s2; + + return STRCMP(p1->f_name, p2->f_name); +} + +/* + * Sort the function table by function name. + * The sorting of the table above is ASCII dependent. + * On machines using EBCDIC we have to sort it. + */ + static void +sortFunctions(void) +{ + int funcCnt = (int)(sizeof(functions) / sizeof(struct fst)) - 1; + + qsort(functions, (size_t)funcCnt, sizeof(struct fst), compare_func_name); +} +#endif + +/* + * Initialize the global and v: variables. + */ + void +eval_init(void) +{ + evalvars_init(); + func_init(); + +#ifdef EBCDIC + /* + * Sort the function table, to enable binary search. + */ + sortFunctions(); +#endif +} + +#if defined(EXITFREE) || defined(PROTO) + void +eval_clear(void) +{ + evalvars_clear(); + free_scriptnames(); // must come after evalvars_clear(). + free_locales(); + + // autoloaded script names + free_autoload_scriptnames(); + + // unreferenced lists and dicts + (void)garbage_collect(FALSE); + + // functions not garbage collected + free_all_functions(); +} +#endif + + void +fill_evalarg_from_eap(evalarg_T *evalarg, exarg_T *eap, int skip) +{ + CLEAR_FIELD(*evalarg); + evalarg->eval_flags = skip ? 0 : EVAL_EVALUATE; + if (eap != NULL && getline_equal(eap->getline, eap->cookie, getsourceline)) + { + evalarg->eval_getline = eap->getline; + evalarg->eval_cookie = eap->cookie; + } +} + +/* + * Top level evaluation function, returning a boolean. + * Sets "error" to TRUE if there was an error. + * Return TRUE or FALSE. + */ + int +eval_to_bool( + char_u *arg, + int *error, + exarg_T *eap, + int skip) // only parse, don't execute +{ + typval_T tv; + varnumber_T retval = FALSE; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, skip); + + if (skip) + ++emsg_skip; + if (eval0(arg, &tv, eap, &evalarg) == FAIL) + *error = TRUE; + else + { + *error = FALSE; + if (!skip) + { + if (in_vim9script()) + retval = tv_get_bool_chk(&tv, error); + else + retval = (tv_get_number_chk(&tv, error) != 0); + clear_tv(&tv); + } + } + if (skip) + --emsg_skip; + clear_evalarg(&evalarg, eap); + + return (int)retval; +} + +/* + * Call eval1() and give an error message if not done at a lower level. + */ + static int +eval1_emsg(char_u **arg, typval_T *rettv, exarg_T *eap) +{ + char_u *start = *arg; + int ret; + int did_emsg_before = did_emsg; + int called_emsg_before = called_emsg; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); + + ret = eval1(arg, rettv, &evalarg); + if (ret == FAIL) + { + // Report the invalid expression unless the expression evaluation has + // been cancelled due to an aborting error, an interrupt, or an + // exception, or we already gave a more specific error. + // Also check called_emsg for when using assert_fails(). + if (!aborting() && did_emsg == did_emsg_before + && called_emsg == called_emsg_before) + semsg(_(e_invexpr2), start); + } + clear_evalarg(&evalarg, eap); + return ret; +} + +/* + * Return whether a typval is a valid expression to pass to eval_expr_typval() + * or eval_expr_to_bool(). An empty string returns FALSE; + */ + int +eval_expr_valid_arg(typval_T *tv) +{ + return tv->v_type != VAR_UNKNOWN + && (tv->v_type != VAR_STRING + || (tv->vval.v_string != NULL && *tv->vval.v_string != NUL)); +} + +/* + * Evaluate an expression, which can be a function, partial or string. + * Pass arguments "argv[argc]". + * Return the result in "rettv" and OK or FAIL. + */ + int +eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv) +{ + char_u *s; + char_u buf[NUMBUFLEN]; + funcexe_T funcexe; + + if (expr->v_type == VAR_FUNC) + { + s = expr->vval.v_string; + if (s == NULL || *s == NUL) + return FAIL; + CLEAR_FIELD(funcexe); + funcexe.evaluate = TRUE; + if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL) + return FAIL; + } + else if (expr->v_type == VAR_PARTIAL) + { + partial_T *partial = expr->vval.v_partial; + + if (partial == NULL) + return FAIL; + + if (partial->pt_func != NULL + && partial->pt_func->uf_def_status != UF_NOT_COMPILED) + { + if (call_def_function(partial->pt_func, argc, argv, + partial, rettv) == FAIL) + return FAIL; + } + else + { + s = partial_name(partial); + if (s == NULL || *s == NUL) + return FAIL; + CLEAR_FIELD(funcexe); + funcexe.evaluate = TRUE; + funcexe.partial = partial; + if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL) + return FAIL; + } + } + else + { + s = tv_get_string_buf_chk(expr, buf); + if (s == NULL) + return FAIL; + s = skipwhite(s); + if (eval1_emsg(&s, rettv, NULL) == FAIL) + return FAIL; + if (*skipwhite(s) != NUL) // check for trailing chars after expr + { + clear_tv(rettv); + semsg(_(e_invexpr2), s); + return FAIL; + } + } + return OK; +} + +/* + * Like eval_to_bool() but using a typval_T instead of a string. + * Works for string, funcref and partial. + */ + int +eval_expr_to_bool(typval_T *expr, int *error) +{ + typval_T rettv; + int res; + + if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL) + { + *error = TRUE; + return FALSE; + } + res = (tv_get_bool_chk(&rettv, error) != 0); + clear_tv(&rettv); + return res; +} + +/* + * Top level evaluation function, returning a string. If "skip" is TRUE, + * only parsing to "nextcmd" is done, without reporting errors. Return + * pointer to allocated memory, or NULL for failure or when "skip" is TRUE. + */ + char_u * +eval_to_string_skip( + char_u *arg, + exarg_T *eap, + int skip) // only parse, don't execute +{ + typval_T tv; + char_u *retval; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, skip); + if (skip) + ++emsg_skip; + if (eval0(arg, &tv, eap, &evalarg) == FAIL || skip) + retval = NULL; + else + { + retval = vim_strsave(tv_get_string(&tv)); + clear_tv(&tv); + } + if (skip) + --emsg_skip; + clear_evalarg(&evalarg, eap); + + return retval; +} + +/* + * Skip over an expression at "*pp". + * Return FAIL for an error, OK otherwise. + */ + int +skip_expr(char_u **pp, evalarg_T *evalarg) +{ + typval_T rettv; + + *pp = skipwhite(*pp); + return eval1(pp, &rettv, evalarg); +} + +/* + * Skip over an expression at "*pp". + * If in Vim9 script and line breaks are encountered, the lines are + * concatenated. "evalarg->eval_tofree" will be set accordingly. + * "arg" is advanced to just after the expression. + * "start" is set to the start of the expression, "end" to just after the end. + * Also when the expression is copied to allocated memory. + * Return FAIL for an error, OK otherwise. + */ + int +skip_expr_concatenate( + char_u **arg, + char_u **start, + char_u **end, + evalarg_T *evalarg) +{ + typval_T rettv; + int res; + int vim9script = in_vim9script(); + garray_T *gap = evalarg == NULL ? NULL : &evalarg->eval_ga; + int save_flags = evalarg == NULL ? 0 : evalarg->eval_flags; + int evaluate = evalarg == NULL + ? FALSE : (evalarg->eval_flags & EVAL_EVALUATE); + + if (vim9script && evaluate + && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL)) + { + ga_init2(gap, sizeof(char_u *), 10); + // leave room for "start" + if (ga_grow(gap, 1) == OK) + ++gap->ga_len; + } + *start = *arg; + + // Don't evaluate the expression. + if (evalarg != NULL) + evalarg->eval_flags &= ~EVAL_EVALUATE; + *arg = skipwhite(*arg); + res = eval1(arg, &rettv, evalarg); + *end = *arg; + if (evalarg != NULL) + evalarg->eval_flags = save_flags; + + if (vim9script && evaluate + && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL)) + { + if (evalarg->eval_ga.ga_len == 1) + { + // just one line, no need to concatenate + ga_clear(gap); + gap->ga_itemsize = 0; + } + else + { + char_u *p; + size_t endoff = STRLEN(*arg); + + // Line breaks encountered, concatenate all the lines. + *((char_u **)gap->ga_data) = *start; + p = ga_concat_strings(gap, ""); + + // free the lines only when using getsourceline() + if (evalarg->eval_cookie != NULL) + { + // Do not free the first line, the caller can still use it. + *((char_u **)gap->ga_data) = NULL; + // Do not free the last line, "arg" points into it, free it + // later. + vim_free(evalarg->eval_tofree); + evalarg->eval_tofree = + ((char_u **)gap->ga_data)[gap->ga_len - 1]; + ((char_u **)gap->ga_data)[gap->ga_len - 1] = NULL; + ga_clear_strings(gap); + } + else + ga_clear(gap); + gap->ga_itemsize = 0; + if (p == NULL) + return FAIL; + *start = p; + vim_free(evalarg->eval_tofree_lambda); + evalarg->eval_tofree_lambda = p; + // Compute "end" relative to the end. + *end = *start + STRLEN(*start) - endoff; + } + } + + return res; +} + +/* + * Convert "tv" to a string. + * When "convert" is TRUE convert a List into a sequence of lines and convert + * a Float to a String. + * Returns an allocated string (NULL when out of memory). + */ + char_u * +typval2string(typval_T *tv, int convert) +{ + garray_T ga; + char_u *retval; +#ifdef FEAT_FLOAT + char_u numbuf[NUMBUFLEN]; +#endif + + if (convert && tv->v_type == VAR_LIST) + { + ga_init2(&ga, (int)sizeof(char), 80); + if (tv->vval.v_list != NULL) + { + list_join(&ga, tv->vval.v_list, (char_u *)"\n", TRUE, FALSE, 0); + if (tv->vval.v_list->lv_len > 0) + ga_append(&ga, NL); + } + ga_append(&ga, NUL); + retval = (char_u *)ga.ga_data; + } +#ifdef FEAT_FLOAT + else if (convert && tv->v_type == VAR_FLOAT) + { + vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float); + retval = vim_strsave(numbuf); + } +#endif + else + retval = vim_strsave(tv_get_string(tv)); + return retval; +} + +/* + * Top level evaluation function, returning a string. Does not handle line + * breaks. + * When "convert" is TRUE convert a List into a sequence of lines and convert + * a Float to a String. + * Return pointer to allocated memory, or NULL for failure. + */ + char_u * +eval_to_string_eap( + char_u *arg, + int convert, + exarg_T *eap) +{ + typval_T tv; + char_u *retval; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); + if (eval0(arg, &tv, NULL, &evalarg) == FAIL) + retval = NULL; + else + { + retval = typval2string(&tv, convert); + clear_tv(&tv); + } + clear_evalarg(&evalarg, NULL); + + return retval; +} + + char_u * +eval_to_string( + char_u *arg, + int convert) +{ + return eval_to_string_eap(arg, convert, NULL); +} + +/* + * Call eval_to_string() without using current local variables and using + * textwinlock. When "use_sandbox" is TRUE use the sandbox. + * Use legacy Vim script syntax. + */ + char_u * +eval_to_string_safe( + char_u *arg, + int use_sandbox) +{ + char_u *retval; + funccal_entry_T funccal_entry; + int save_sc_version = current_sctx.sc_version; + + current_sctx.sc_version = 1; + save_funccal(&funccal_entry); + if (use_sandbox) + ++sandbox; + ++textwinlock; + retval = eval_to_string(arg, FALSE); + if (use_sandbox) + --sandbox; + --textwinlock; + restore_funccal(); + current_sctx.sc_version = save_sc_version; + return retval; +} + +/* + * Top level evaluation function, returning a number. + * Evaluates "expr" silently. + * Returns -1 for an error. + */ + varnumber_T +eval_to_number(char_u *expr) +{ + typval_T rettv; + varnumber_T retval; + char_u *p = skipwhite(expr); + + ++emsg_off; + + if (eval1(&p, &rettv, &EVALARG_EVALUATE) == FAIL) + retval = -1; + else + { + retval = tv_get_number_chk(&rettv, NULL); + clear_tv(&rettv); + } + --emsg_off; + + return retval; +} + +/* + * Top level evaluation function. + * Returns an allocated typval_T with the result. + * Returns NULL when there is an error. + */ + typval_T * +eval_expr(char_u *arg, exarg_T *eap) +{ + typval_T *tv; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); + + tv = ALLOC_ONE(typval_T); + if (tv != NULL && eval0(arg, tv, eap, &evalarg) == FAIL) + VIM_CLEAR(tv); + + clear_evalarg(&evalarg, eap); + return tv; +} + +/* + * Call some Vim script function and return the result in "*rettv". + * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] + * should have type VAR_UNKNOWN. + * Returns OK or FAIL. + */ + int +call_vim_function( + char_u *func, + int argc, + typval_T *argv, + typval_T *rettv) +{ + int ret; + funcexe_T funcexe; + + rettv->v_type = VAR_UNKNOWN; // clear_tv() uses this + CLEAR_FIELD(funcexe); + funcexe.firstline = curwin->w_cursor.lnum; + funcexe.lastline = curwin->w_cursor.lnum; + funcexe.evaluate = TRUE; + ret = call_func(func, -1, rettv, argc, argv, &funcexe); + if (ret == FAIL) + clear_tv(rettv); + + return ret; +} + +/* + * Call Vim script function "func" and return the result as a number. + * Returns -1 when calling the function fails. + * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should + * have type VAR_UNKNOWN. + */ + varnumber_T +call_func_retnr( + char_u *func, + int argc, + typval_T *argv) +{ + typval_T rettv; + varnumber_T retval; + + if (call_vim_function(func, argc, argv, &rettv) == FAIL) + return -1; + + retval = tv_get_number_chk(&rettv, NULL); + clear_tv(&rettv); + return retval; +} + +/* + * Call Vim script function like call_func_retnr() and drop the result. + * Returns FAIL when calling the function fails. + */ + int +call_func_noret( + char_u *func, + int argc, + typval_T *argv) +{ + typval_T rettv; + + if (call_vim_function(func, argc, argv, &rettv) == FAIL) + return FAIL; + clear_tv(&rettv); + return OK; +} + +/* + * Call Vim script function "func" and return the result as a string. + * Uses "argv" and "argc" as call_func_retnr(). + * Returns NULL when calling the function fails. + */ + void * +call_func_retstr( + char_u *func, + int argc, + typval_T *argv) +{ + typval_T rettv; + char_u *retval; + + if (call_vim_function(func, argc, argv, &rettv) == FAIL) + return NULL; + + retval = vim_strsave(tv_get_string(&rettv)); + clear_tv(&rettv); + return retval; +} + +/* + * Call Vim script function "func" and return the result as a List. + * Uses "argv" and "argc" as call_func_retnr(). + * Returns NULL when there is something wrong. + */ + void * +call_func_retlist( + char_u *func, + int argc, + typval_T *argv) +{ + typval_T rettv; + + if (call_vim_function(func, argc, argv, &rettv) == FAIL) + return NULL; + + if (rettv.v_type != VAR_LIST) + { + clear_tv(&rettv); + return NULL; + } + + return rettv.vval.v_list; +} + +#ifdef FEAT_FOLDING +/* + * Evaluate "arg", which is 'foldexpr'. + * Note: caller must set "curwin" to match "arg". + * Returns the foldlevel, and any character preceding it in "*cp". Doesn't + * give error messages. + */ + int +eval_foldexpr(char_u *arg, int *cp) +{ + typval_T tv; + varnumber_T retval; + char_u *s; + int use_sandbox = was_set_insecurely((char_u *)"foldexpr", + OPT_LOCAL); + + ++emsg_off; + if (use_sandbox) + ++sandbox; + ++textwinlock; + *cp = NUL; + if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL) + retval = 0; + else + { + // If the result is a number, just return the number. + if (tv.v_type == VAR_NUMBER) + retval = tv.vval.v_number; + else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL) + retval = 0; + else + { + // If the result is a string, check if there is a non-digit before + // the number. + s = tv.vval.v_string; + if (!VIM_ISDIGIT(*s) && *s != '-') + *cp = *s++; + retval = atol((char *)s); + } + clear_tv(&tv); + } + --emsg_off; + if (use_sandbox) + --sandbox; + --textwinlock; + clear_evalarg(&EVALARG_EVALUATE, NULL); + + return (int)retval; +} +#endif + +/* + * Get an lval: variable, Dict item or List item that can be assigned a value + * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]", + * "name.key", "name.key[expr]" etc. + * Indexing only works if "name" is an existing List or Dictionary. + * "name" points to the start of the name. + * If "rettv" is not NULL it points to the value to be assigned. + * "unlet" is TRUE for ":unlet": slightly different behavior when something is + * wrong; must end in space or cmd separator. + * + * flags: + * GLV_QUIET: do not give error messages + * GLV_READ_ONLY: will not change the variable + * GLV_NO_AUTOLOAD: do not use script autoloading + * + * Returns a pointer to just after the name, including indexes. + * When an evaluation error occurs "lp->ll_name" is NULL; + * Returns NULL for a parsing error. Still need to free items in "lp"! + */ + char_u * +get_lval( + char_u *name, + typval_T *rettv, + lval_T *lp, + int unlet, + int skip, + int flags, // GLV_ values + int fne_flags) // flags for find_name_end() +{ + char_u *p; + char_u *expr_start, *expr_end; + int cc; + dictitem_T *v; + typval_T var1; + typval_T var2; + int empty1 = FALSE; + listitem_T *ni; + char_u *key = NULL; + int len; + hashtab_T *ht = NULL; + int quiet = flags & GLV_QUIET; + int writing; + + // Clear everything in "lp". + CLEAR_POINTER(lp); + + if (skip || (flags & GLV_COMPILING)) + { + // When skipping or compiling just find the end of the name. + lp->ll_name = name; + lp->ll_name_end = find_name_end(name, NULL, NULL, + FNE_INCL_BR | fne_flags); + return lp->ll_name_end; + } + + // Find the end of the name. + p = find_name_end(name, &expr_start, &expr_end, fne_flags); + lp->ll_name_end = p; + if (expr_start != NULL) + { + // Don't expand the name when we already know there is an error. + if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p) + && *p != '[' && *p != '.') + { + semsg(_(e_trailing_arg), p); + return NULL; + } + + lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p); + if (lp->ll_exp_name == NULL) + { + // Report an invalid expression in braces, unless the + // expression evaluation has been cancelled due to an + // aborting error, an interrupt, or an exception. + if (!aborting() && !quiet) + { + emsg_severe = TRUE; + semsg(_(e_invarg2), name); + return NULL; + } + } + lp->ll_name = lp->ll_exp_name; + } + else + { + lp->ll_name = name; + + if (in_vim9script()) + { + // "a: type" is declaring variable "a" with a type, not "a:". + if (p == name + 2 && p[-1] == ':') + { + --p; + lp->ll_name_end = p; + } + if (*p == ':') + { + scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); + char_u *tp = skipwhite(p + 1); + + // parse the type after the name + lp->ll_type = parse_type(&tp, &si->sn_type_list, !quiet); + if (lp->ll_type == NULL && !quiet) + return NULL; + lp->ll_name_end = tp; + } + } + } + + // Without [idx] or .key we are done. + if ((*p != '[' && *p != '.') || lp->ll_name == NULL) + return p; + + cc = *p; + *p = NUL; + // When we would write to the variable pass &ht and prevent autoload. + writing = !(flags & GLV_READ_ONLY); + v = find_var(lp->ll_name, writing ? &ht : NULL, + (flags & GLV_NO_AUTOLOAD) || writing); + if (v == NULL && !quiet) + semsg(_(e_undefined_variable_str), lp->ll_name); + *p = cc; + if (v == NULL) + return NULL; + + if (in_vim9script() && (flags & GLV_NO_DECL) == 0) + { + if (!quiet) + semsg(_(e_variable_already_declared), lp->ll_name); + return NULL; + } + + /* + * Loop until no more [idx] or .key is following. + */ + lp->ll_tv = &v->di_tv; + var1.v_type = VAR_UNKNOWN; + var2.v_type = VAR_UNKNOWN; + while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT)) + { + if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL) + && !(lp->ll_tv->v_type == VAR_DICT) + && !(lp->ll_tv->v_type == VAR_BLOB + && lp->ll_tv->vval.v_blob != NULL)) + { + if (!quiet) + emsg(_("E689: Can only index a List, Dictionary or Blob")); + return NULL; + } + if (lp->ll_range) + { + if (!quiet) + emsg(_("E708: [:] must come last")); + return NULL; + } + + if (in_vim9script() && lp->ll_valtype == NULL + && lp->ll_tv == &v->di_tv + && ht != NULL && ht == get_script_local_ht()) + { + svar_T *sv = find_typval_in_script(lp->ll_tv); + + // Vim9 script local variable: get the type + if (sv != NULL) + lp->ll_valtype = sv->sv_type; + } + + len = -1; + if (*p == '.') + { + key = p + 1; + for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len) + ; + if (len == 0) + { + if (!quiet) + emsg(_(e_emptykey)); + return NULL; + } + p = key + len; + } + else + { + // Get the index [expr] or the first index [expr: ]. + p = skipwhite(p + 1); + if (*p == ':') + empty1 = TRUE; + else + { + empty1 = FALSE; + if (eval1(&p, &var1, &EVALARG_EVALUATE) == FAIL) // recursive! + return NULL; + if (tv_get_string_chk(&var1) == NULL) + { + // not a number or string + clear_tv(&var1); + return NULL; + } + p = skipwhite(p); + } + + // Optionally get the second index [ :expr]. + if (*p == ':') + { + if (lp->ll_tv->v_type == VAR_DICT) + { + if (!quiet) + emsg(_(e_cannot_slice_dictionary)); + clear_tv(&var1); + return NULL; + } + if (rettv != NULL + && !(rettv->v_type == VAR_LIST + && rettv->vval.v_list != NULL) + && !(rettv->v_type == VAR_BLOB + && rettv->vval.v_blob != NULL)) + { + if (!quiet) + emsg(_("E709: [:] requires a List or Blob value")); + clear_tv(&var1); + return NULL; + } + p = skipwhite(p + 1); + if (*p == ']') + lp->ll_empty2 = TRUE; + else + { + lp->ll_empty2 = FALSE; + // recursive! + if (eval1(&p, &var2, &EVALARG_EVALUATE) == FAIL) + { + clear_tv(&var1); + return NULL; + } + if (tv_get_string_chk(&var2) == NULL) + { + // not a number or string + clear_tv(&var1); + clear_tv(&var2); + return NULL; + } + } + lp->ll_range = TRUE; + } + else + lp->ll_range = FALSE; + + if (*p != ']') + { + if (!quiet) + emsg(_(e_missbrac)); + clear_tv(&var1); + clear_tv(&var2); + return NULL; + } + + // Skip to past ']'. + ++p; + } + + if (lp->ll_tv->v_type == VAR_DICT) + { + if (len == -1) + { + // "[key]": get key from "var1" + key = tv_get_string_chk(&var1); // is number or string + if (key == NULL) + { + clear_tv(&var1); + return NULL; + } + } + lp->ll_list = NULL; + + // a NULL dict is equivalent with an empty dict + if (lp->ll_tv->vval.v_dict == NULL) + { + lp->ll_tv->vval.v_dict = dict_alloc(); + if (lp->ll_tv->vval.v_dict == NULL) + { + clear_tv(&var1); + return NULL; + } + ++lp->ll_tv->vval.v_dict->dv_refcount; + } + lp->ll_dict = lp->ll_tv->vval.v_dict; + + lp->ll_di = dict_find(lp->ll_dict, key, len); + + // When assigning to a scope dictionary check that a function and + // variable name is valid (only variable name unless it is l: or + // g: dictionary). Disallow overwriting a builtin function. + if (rettv != NULL && lp->ll_dict->dv_scope != 0) + { + int prevval; + int wrong; + + if (len != -1) + { + prevval = key[len]; + key[len] = NUL; + } + else + prevval = 0; // avoid compiler warning + wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE + && rettv->v_type == VAR_FUNC + && var_wrong_func_name(key, lp->ll_di == NULL)) + || !valid_varname(key, TRUE); + if (len != -1) + key[len] = prevval; + if (wrong) + { + clear_tv(&var1); + return NULL; + } + } + + if (lp->ll_valtype != NULL) + // use the type of the member + lp->ll_valtype = lp->ll_valtype->tt_member; + + if (lp->ll_di == NULL) + { + // Can't add "v:" or "a:" variable. + if (lp->ll_dict == get_vimvar_dict() + || &lp->ll_dict->dv_hashtab == get_funccal_args_ht()) + { + semsg(_(e_illvar), name); + clear_tv(&var1); + return NULL; + } + + // Key does not exist in dict: may need to add it. + if (*p == '[' || *p == '.' || unlet) + { + if (!quiet) + semsg(_(e_dictkey), key); + clear_tv(&var1); + return NULL; + } + if (len == -1) + lp->ll_newkey = vim_strsave(key); + else + lp->ll_newkey = vim_strnsave(key, len); + clear_tv(&var1); + if (lp->ll_newkey == NULL) + p = NULL; + break; + } + // existing variable, need to check if it can be changed + else if ((flags & GLV_READ_ONLY) == 0 + && (var_check_ro(lp->ll_di->di_flags, name, FALSE) + || var_check_lock(lp->ll_di->di_flags, name, FALSE))) + { + clear_tv(&var1); + return NULL; + } + + clear_tv(&var1); + lp->ll_tv = &lp->ll_di->di_tv; + } + else if (lp->ll_tv->v_type == VAR_BLOB) + { + long bloblen = blob_len(lp->ll_tv->vval.v_blob); + + /* + * Get the number and item for the only or first index of the List. + */ + if (empty1) + lp->ll_n1 = 0; + else + // is number or string + lp->ll_n1 = (long)tv_get_number(&var1); + clear_tv(&var1); + + if (lp->ll_n1 < 0 + || lp->ll_n1 > bloblen + || (lp->ll_range && lp->ll_n1 == bloblen)) + { + if (!quiet) + semsg(_(e_blobidx), lp->ll_n1); + clear_tv(&var2); + return NULL; + } + if (lp->ll_range && !lp->ll_empty2) + { + lp->ll_n2 = (long)tv_get_number(&var2); + clear_tv(&var2); + if (lp->ll_n2 < 0 + || lp->ll_n2 >= bloblen + || lp->ll_n2 < lp->ll_n1) + { + if (!quiet) + semsg(_(e_blobidx), lp->ll_n2); + return NULL; + } + } + lp->ll_blob = lp->ll_tv->vval.v_blob; + lp->ll_tv = NULL; + break; + } + else + { + /* + * Get the number and item for the only or first index of the List. + */ + if (empty1) + lp->ll_n1 = 0; + else + // is number or string + lp->ll_n1 = (long)tv_get_number(&var1); + clear_tv(&var1); + + lp->ll_dict = NULL; + lp->ll_list = lp->ll_tv->vval.v_list; + lp->ll_li = list_find(lp->ll_list, lp->ll_n1); + if (lp->ll_li == NULL) + { + if (lp->ll_n1 < 0) + { + lp->ll_n1 = 0; + lp->ll_li = list_find(lp->ll_list, lp->ll_n1); + } + } + if (lp->ll_li == NULL) + { + clear_tv(&var2); + if (!quiet) + semsg(_(e_listidx), lp->ll_n1); + return NULL; + } + + if (lp->ll_valtype != NULL) + // use the type of the member + lp->ll_valtype = lp->ll_valtype->tt_member; + + /* + * May need to find the item or absolute index for the second + * index of a range. + * When no index given: "lp->ll_empty2" is TRUE. + * Otherwise "lp->ll_n2" is set to the second index. + */ + if (lp->ll_range && !lp->ll_empty2) + { + lp->ll_n2 = (long)tv_get_number(&var2); + // is number or string + clear_tv(&var2); + if (lp->ll_n2 < 0) + { + ni = list_find(lp->ll_list, lp->ll_n2); + if (ni == NULL) + { + if (!quiet) + semsg(_(e_listidx), lp->ll_n2); + return NULL; + } + lp->ll_n2 = list_idx_of_item(lp->ll_list, ni); + } + + // Check that lp->ll_n2 isn't before lp->ll_n1. + if (lp->ll_n1 < 0) + lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li); + if (lp->ll_n2 < lp->ll_n1) + { + if (!quiet) + semsg(_(e_listidx), lp->ll_n2); + return NULL; + } + } + + lp->ll_tv = &lp->ll_li->li_tv; + } + } + + clear_tv(&var1); + lp->ll_name_end = p; + return p; +} + +/* + * Clear lval "lp" that was filled by get_lval(). + */ + void +clear_lval(lval_T *lp) +{ + vim_free(lp->ll_exp_name); + vim_free(lp->ll_newkey); +} + +/* + * Set a variable that was parsed by get_lval() to "rettv". + * "endp" points to just after the parsed name. + * "op" is NULL, "+" for "+=", "-" for "-=", "*" for "*=", "/" for "/=", + * "%" for "%=", "." for ".=" or "=" for "=". + */ + void +set_var_lval( + lval_T *lp, + char_u *endp, + typval_T *rettv, + int copy, + int flags, // ASSIGN_CONST, ASSIGN_NO_DECL + char_u *op) +{ + int cc; + listitem_T *ri; + dictitem_T *di; + + if (lp->ll_tv == NULL) + { + cc = *endp; + *endp = NUL; + if (lp->ll_blob != NULL) + { + int error = FALSE, val; + + if (op != NULL && *op != '=') + { + semsg(_(e_letwrong), op); + return; + } + if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, FALSE)) + return; + + if (lp->ll_range && rettv->v_type == VAR_BLOB) + { + int il, ir; + + if (lp->ll_empty2) + lp->ll_n2 = blob_len(lp->ll_blob) - 1; + + if (lp->ll_n2 - lp->ll_n1 + 1 != blob_len(rettv->vval.v_blob)) + { + emsg(_("E972: Blob value does not have the right number of bytes")); + return; + } + if (lp->ll_empty2) + lp->ll_n2 = blob_len(lp->ll_blob); + + ir = 0; + for (il = lp->ll_n1; il <= lp->ll_n2; il++) + blob_set(lp->ll_blob, il, + blob_get(rettv->vval.v_blob, ir++)); + } + else + { + val = (int)tv_get_number_chk(rettv, &error); + if (!error) + { + garray_T *gap = &lp->ll_blob->bv_ga; + + // Allow for appending a byte. Setting a byte beyond + // the end is an error otherwise. + if (lp->ll_n1 < gap->ga_len + || (lp->ll_n1 == gap->ga_len + && ga_grow(&lp->ll_blob->bv_ga, 1) == OK)) + { + blob_set(lp->ll_blob, lp->ll_n1, val); + if (lp->ll_n1 == gap->ga_len) + ++gap->ga_len; + } + // error for invalid range was already given in get_lval() + } + } + } + else if (op != NULL && *op != '=') + { + typval_T tv; + + if (flags & (ASSIGN_CONST | ASSIGN_FINAL)) + { + emsg(_(e_cannot_mod)); + *endp = cc; + return; + } + + // handle +=, -=, *=, /=, %= and .= + di = NULL; + if (eval_variable(lp->ll_name, (int)STRLEN(lp->ll_name), + &tv, &di, TRUE, FALSE) == OK) + { + if ((di == NULL + || (!var_check_ro(di->di_flags, lp->ll_name, FALSE) + && !tv_check_lock(&di->di_tv, lp->ll_name, FALSE))) + && tv_op(&tv, rettv, op) == OK) + set_var(lp->ll_name, &tv, FALSE); + clear_tv(&tv); + } + } + else + { + if (lp->ll_type != NULL + && check_typval_type(lp->ll_type, rettv, 0) == FAIL) + return; + set_var_const(lp->ll_name, lp->ll_type, rettv, copy, flags); + } + *endp = cc; + } + else if (value_check_lock(lp->ll_newkey == NULL + ? lp->ll_tv->v_lock + : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE)) + ; + else if (lp->ll_range) + { + listitem_T *ll_li = lp->ll_li; + int ll_n1 = lp->ll_n1; + + if (flags & (ASSIGN_CONST | ASSIGN_FINAL)) + { + emsg(_("E996: Cannot lock a range")); + return; + } + + /* + * Check whether any of the list items is locked + */ + for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; ) + { + if (value_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE)) + return; + ri = ri->li_next; + if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1)) + break; + ll_li = ll_li->li_next; + ++ll_n1; + } + + /* + * Assign the List values to the list items. + */ + for (ri = rettv->vval.v_list->lv_first; ri != NULL; ) + { + if (op != NULL && *op != '=') + tv_op(&lp->ll_li->li_tv, &ri->li_tv, op); + else + { + clear_tv(&lp->ll_li->li_tv); + copy_tv(&ri->li_tv, &lp->ll_li->li_tv); + } + ri = ri->li_next; + if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == lp->ll_n1)) + break; + if (lp->ll_li->li_next == NULL) + { + // Need to add an empty item. + if (list_append_number(lp->ll_list, 0) == FAIL) + { + ri = NULL; + break; + } + } + lp->ll_li = lp->ll_li->li_next; + ++lp->ll_n1; + } + if (ri != NULL) + emsg(_(e_list_value_has_more_items_than_targets)); + else if (lp->ll_empty2 + ? (lp->ll_li != NULL && lp->ll_li->li_next != NULL) + : lp->ll_n1 != lp->ll_n2) + emsg(_(e_list_value_does_not_have_enough_items)); + } + else + { + /* + * Assign to a List or Dictionary item. + */ + if (flags & (ASSIGN_CONST | ASSIGN_FINAL)) + { + emsg(_("E996: Cannot lock a list or dict")); + return; + } + + if (lp->ll_valtype != NULL + && check_typval_type(lp->ll_valtype, rettv, 0) == FAIL) + return; + + if (lp->ll_newkey != NULL) + { + if (op != NULL && *op != '=') + { + semsg(_(e_letwrong), op); + return; + } + + // Need to add an item to the Dictionary. + di = dictitem_alloc(lp->ll_newkey); + if (di == NULL) + return; + if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL) + { + vim_free(di); + return; + } + lp->ll_tv = &di->di_tv; + } + else if (op != NULL && *op != '=') + { + tv_op(lp->ll_tv, rettv, op); + return; + } + else + clear_tv(lp->ll_tv); + + /* + * Assign the value to the variable or list item. + */ + if (copy) + copy_tv(rettv, lp->ll_tv); + else + { + *lp->ll_tv = *rettv; + lp->ll_tv->v_lock = 0; + init_tv(rettv); + } + } +} + +/* + * Handle "tv1 += tv2", "tv1 -= tv2", "tv1 *= tv2", "tv1 /= tv2", "tv1 %= tv2" + * and "tv1 .= tv2" + * Returns OK or FAIL. + */ + static int +tv_op(typval_T *tv1, typval_T *tv2, char_u *op) +{ + varnumber_T n; + char_u numbuf[NUMBUFLEN]; + char_u *s; + int failed = FALSE; + + // Can't do anything with a Funcref, Dict, v:true on the right. + if (tv2->v_type != VAR_FUNC && tv2->v_type != VAR_DICT + && tv2->v_type != VAR_BOOL && tv2->v_type != VAR_SPECIAL) + { + switch (tv1->v_type) + { + case VAR_UNKNOWN: + case VAR_ANY: + case VAR_VOID: + case VAR_DICT: + case VAR_FUNC: + case VAR_PARTIAL: + case VAR_BOOL: + case VAR_SPECIAL: + case VAR_JOB: + case VAR_CHANNEL: + break; + + case VAR_BLOB: + if (*op != '+' || tv2->v_type != VAR_BLOB) + break; + // BLOB += BLOB + if (tv1->vval.v_blob != NULL && tv2->vval.v_blob != NULL) + { + blob_T *b1 = tv1->vval.v_blob; + blob_T *b2 = tv2->vval.v_blob; + int i, len = blob_len(b2); + for (i = 0; i < len; i++) + ga_append(&b1->bv_ga, blob_get(b2, i)); + } + return OK; + + case VAR_LIST: + if (*op != '+' || tv2->v_type != VAR_LIST) + break; + // List += List + if (tv2->vval.v_list != NULL) + { + if (tv1->vval.v_list == NULL) + { + tv1->vval.v_list = tv2->vval.v_list; + ++tv1->vval.v_list->lv_refcount; + } + else + list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL); + } + return OK; + + case VAR_NUMBER: + case VAR_STRING: + if (tv2->v_type == VAR_LIST) + break; + if (vim_strchr((char_u *)"+-*/%", *op) != NULL) + { + // nr += nr , nr -= nr , nr *=nr , nr /= nr , nr %= nr + n = tv_get_number(tv1); +#ifdef FEAT_FLOAT + if (tv2->v_type == VAR_FLOAT) + { + float_T f = n; + + if (*op == '%') + break; + switch (*op) + { + case '+': f += tv2->vval.v_float; break; + case '-': f -= tv2->vval.v_float; break; + case '*': f *= tv2->vval.v_float; break; + case '/': f /= tv2->vval.v_float; break; + } + clear_tv(tv1); + tv1->v_type = VAR_FLOAT; + tv1->vval.v_float = f; + } + else +#endif + { + switch (*op) + { + case '+': n += tv_get_number(tv2); break; + case '-': n -= tv_get_number(tv2); break; + case '*': n *= tv_get_number(tv2); break; + case '/': n = num_divide(n, tv_get_number(tv2), + &failed); break; + case '%': n = num_modulus(n, tv_get_number(tv2), + &failed); break; + } + clear_tv(tv1); + tv1->v_type = VAR_NUMBER; + tv1->vval.v_number = n; + } + } + else + { + if (tv2->v_type == VAR_FLOAT) + break; + + // str .= str + s = tv_get_string(tv1); + s = concat_str(s, tv_get_string_buf(tv2, numbuf)); + clear_tv(tv1); + tv1->v_type = VAR_STRING; + tv1->vval.v_string = s; + } + return failed ? FAIL : OK; + + case VAR_FLOAT: +#ifdef FEAT_FLOAT + { + float_T f; + + if (*op == '%' || *op == '.' + || (tv2->v_type != VAR_FLOAT + && tv2->v_type != VAR_NUMBER + && tv2->v_type != VAR_STRING)) + break; + if (tv2->v_type == VAR_FLOAT) + f = tv2->vval.v_float; + else + f = tv_get_number(tv2); + switch (*op) + { + case '+': tv1->vval.v_float += f; break; + case '-': tv1->vval.v_float -= f; break; + case '*': tv1->vval.v_float *= f; break; + case '/': tv1->vval.v_float /= f; break; + } + } +#endif + return OK; + } + } + + semsg(_(e_letwrong), op); + return FAIL; +} + +/* + * Evaluate the expression used in a ":for var in expr" command. + * "arg" points to "var". + * Set "*errp" to TRUE for an error, FALSE otherwise; + * Return a pointer that holds the info. Null when there is an error. + */ + void * +eval_for_line( + char_u *arg, + int *errp, + exarg_T *eap, + evalarg_T *evalarg) +{ + forinfo_T *fi; + char_u *expr; + typval_T tv; + list_T *l; + int skip = !(evalarg->eval_flags & EVAL_EVALUATE); + + *errp = TRUE; // default: there is an error + + fi = ALLOC_CLEAR_ONE(forinfo_T); + if (fi == NULL) + return NULL; + + expr = skip_var_list(arg, TRUE, &fi->fi_varcount, &fi->fi_semicolon, FALSE); + if (expr == NULL) + return fi; + + expr = skipwhite_and_linebreak(expr, evalarg); + if (expr[0] != 'i' || expr[1] != 'n' + || !(expr[2] == NUL || VIM_ISWHITE(expr[2]))) + { + emsg(_(e_missing_in)); + return fi; + } + + if (skip) + ++emsg_skip; + expr = skipwhite_and_linebreak(expr + 2, evalarg); + if (eval0(expr, &tv, eap, evalarg) == OK) + { + *errp = FALSE; + if (!skip) + { + if (tv.v_type == VAR_LIST) + { + l = tv.vval.v_list; + if (l == NULL) + { + // a null list is like an empty list: do nothing + clear_tv(&tv); + } + else + { + // Need a real list here. + CHECK_LIST_MATERIALIZE(l); + + // No need to increment the refcount, it's already set for + // the list being used in "tv". + fi->fi_list = l; + list_add_watch(l, &fi->fi_lw); + fi->fi_lw.lw_item = l->lv_first; + } + } + else if (tv.v_type == VAR_BLOB) + { + fi->fi_bi = 0; + if (tv.vval.v_blob != NULL) + { + typval_T btv; + + // Make a copy, so that the iteration still works when the + // blob is changed. + blob_copy(tv.vval.v_blob, &btv); + fi->fi_blob = btv.vval.v_blob; + } + clear_tv(&tv); + } + else + { + emsg(_(e_listreq)); + clear_tv(&tv); + } + } + } + if (skip) + --emsg_skip; + fi->fi_break_count = evalarg->eval_break_count; + + return fi; +} + +/* + * Used when looping over a :for line, skip the "in expr" part. + */ + void +skip_for_lines(void *fi_void, evalarg_T *evalarg) +{ + forinfo_T *fi = (forinfo_T *)fi_void; + int i; + + for (i = 0; i < fi->fi_break_count; ++i) + eval_next_line(evalarg); +} + +/* + * Use the first item in a ":for" list. Advance to the next. + * Assign the values to the variable (list). "arg" points to the first one. + * Return TRUE when a valid item was found, FALSE when at end of list or + * something wrong. + */ + int +next_for_item(void *fi_void, char_u *arg) +{ + forinfo_T *fi = (forinfo_T *)fi_void; + int result; + int flag = in_vim9script() ? ASSIGN_DECL : 0; + listitem_T *item; + + if (fi->fi_blob != NULL) + { + typval_T tv; + + if (fi->fi_bi >= blob_len(fi->fi_blob)) + return FALSE; + tv.v_type = VAR_NUMBER; + tv.v_lock = VAR_FIXED; + tv.vval.v_number = blob_get(fi->fi_blob, fi->fi_bi); + ++fi->fi_bi; + return ex_let_vars(arg, &tv, TRUE, fi->fi_semicolon, + fi->fi_varcount, flag, NULL) == OK; + } + + item = fi->fi_lw.lw_item; + if (item == NULL) + result = FALSE; + else + { + fi->fi_lw.lw_item = item->li_next; + result = (ex_let_vars(arg, &item->li_tv, TRUE, fi->fi_semicolon, + fi->fi_varcount, flag, NULL) == OK); + } + return result; +} + +/* + * Free the structure used to store info used by ":for". + */ + void +free_for_info(void *fi_void) +{ + forinfo_T *fi = (forinfo_T *)fi_void; + + if (fi != NULL && fi->fi_list != NULL) + { + list_rem_watch(fi->fi_list, &fi->fi_lw); + list_unref(fi->fi_list); + } + if (fi != NULL && fi->fi_blob != NULL) + blob_unref(fi->fi_blob); + vim_free(fi); +} + + void +set_context_for_expression( + expand_T *xp, + char_u *arg, + cmdidx_T cmdidx) +{ + int has_expr = cmdidx != CMD_let && cmdidx != CMD_var; + int c; + char_u *p; + + if (cmdidx == CMD_let || cmdidx == CMD_var + || cmdidx == CMD_const || cmdidx == CMD_final) + { + xp->xp_context = EXPAND_USER_VARS; + if (vim_strpbrk(arg, (char_u *)"\"'+-*/%.=!?~|&$([<>,#") == NULL) + { + // ":let var1 var2 ...": find last space. + for (p = arg + STRLEN(arg); p >= arg; ) + { + xp->xp_pattern = p; + MB_PTR_BACK(arg, p); + if (VIM_ISWHITE(*p)) + break; + } + return; + } + } + else + xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS + : EXPAND_EXPRESSION; + while ((xp->xp_pattern = vim_strpbrk(arg, + (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL) + { + c = *xp->xp_pattern; + if (c == '&') + { + c = xp->xp_pattern[1]; + if (c == '&') + { + ++xp->xp_pattern; + xp->xp_context = has_expr ? EXPAND_EXPRESSION : EXPAND_NOTHING; + } + else if (c != ' ') + { + xp->xp_context = EXPAND_SETTINGS; + if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':') + xp->xp_pattern += 2; + + } + } + else if (c == '$') + { + // environment variable + xp->xp_context = EXPAND_ENV_VARS; + } + else if (c == '=') + { + has_expr = TRUE; + xp->xp_context = EXPAND_EXPRESSION; + } + else if (c == '#' + && xp->xp_context == EXPAND_EXPRESSION) + { + // Autoload function/variable contains '#'. + break; + } + else if ((c == '<' || c == '#') + && xp->xp_context == EXPAND_FUNCTIONS + && vim_strchr(xp->xp_pattern, '(') == NULL) + { + // Function name can start with "<SNR>" and contain '#'. + break; + } + else if (has_expr) + { + if (c == '"') // string + { + while ((c = *++xp->xp_pattern) != NUL && c != '"') + if (c == '\\' && xp->xp_pattern[1] != NUL) + ++xp->xp_pattern; + xp->xp_context = EXPAND_NOTHING; + } + else if (c == '\'') // literal string + { + // Trick: '' is like stopping and starting a literal string. + while ((c = *++xp->xp_pattern) != NUL && c != '\'') + /* skip */ ; + xp->xp_context = EXPAND_NOTHING; + } + else if (c == '|') + { + if (xp->xp_pattern[1] == '|') + { + ++xp->xp_pattern; + xp->xp_context = EXPAND_EXPRESSION; + } + else + xp->xp_context = EXPAND_COMMANDS; + } + else + xp->xp_context = EXPAND_EXPRESSION; + } + else + // Doesn't look like something valid, expand as an expression + // anyway. + xp->xp_context = EXPAND_EXPRESSION; + arg = xp->xp_pattern; + if (*arg != NUL) + while ((c = *++arg) != NUL && (c == ' ' || c == '\t')) + /* skip */ ; + } + + // ":exe one two" completes "two" + if ((cmdidx == CMD_execute + || cmdidx == CMD_echo + || cmdidx == CMD_echon + || cmdidx == CMD_echomsg) + && xp->xp_context == EXPAND_EXPRESSION) + { + for (;;) + { + char_u *n = skiptowhite(arg); + + if (n == arg || IS_WHITE_OR_NUL(*skipwhite(n))) + break; + arg = skipwhite(n); + } + } + + xp->xp_pattern = arg; +} + +/* + * Return TRUE if "pat" matches "text". + * Does not use 'cpo' and always uses 'magic'. + */ + int +pattern_match(char_u *pat, char_u *text, int ic) +{ + int matches = FALSE; + char_u *save_cpo; + regmatch_T regmatch; + + // avoid 'l' flag in 'cpoptions' + save_cpo = p_cpo; + p_cpo = empty_option; + regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); + if (regmatch.regprog != NULL) + { + regmatch.rm_ic = ic; + matches = vim_regexec_nl(®match, text, (colnr_T)0); + vim_regfree(regmatch.regprog); + } + p_cpo = save_cpo; + return matches; +} + +/* + * Handle a name followed by "(". Both for just "name(arg)" and for + * "expr->name(arg)". + * Returns OK or FAIL. + */ + static int +eval_func( + char_u **arg, // points to "(", will be advanced + evalarg_T *evalarg, + char_u *name, + int name_len, + typval_T *rettv, + int flags, + typval_T *basetv) // "expr" for "expr->name(arg)" +{ + int evaluate = flags & EVAL_EVALUATE; + char_u *s = name; + int len = name_len; + partial_T *partial; + int ret = OK; + type_T *type = NULL; + + if (!evaluate) + check_vars(s, len); + + // If "s" is the name of a variable of type VAR_FUNC + // use its contents. + s = deref_func_name(s, &len, &partial, + in_vim9script() ? &type : NULL, !evaluate); + + // Need to make a copy, in case evaluating the arguments makes + // the name invalid. + s = vim_strsave(s); + if (s == NULL || (flags & EVAL_CONSTANT)) + ret = FAIL; + else + { + funcexe_T funcexe; + + // Invoke the function. + CLEAR_FIELD(funcexe); + funcexe.firstline = curwin->w_cursor.lnum; + funcexe.lastline = curwin->w_cursor.lnum; + funcexe.evaluate = evaluate; + funcexe.partial = partial; + funcexe.basetv = basetv; + funcexe.check_type = type; + ret = get_func_tv(s, len, rettv, arg, evalarg, &funcexe); + } + vim_free(s); + + // If evaluate is FALSE rettv->v_type was not set in + // get_func_tv, but it's needed in handle_subscript() to parse + // what follows. So set it here. + if (rettv->v_type == VAR_UNKNOWN && !evaluate && **arg == '(') + { + rettv->vval.v_string = NULL; + rettv->v_type = VAR_FUNC; + } + + // Stop the expression evaluation when immediately + // aborting on error, or when an interrupt occurred or + // an exception was thrown but not caught. + if (evaluate && aborting()) + { + if (ret == OK) + clear_tv(rettv); + ret = FAIL; + } + return ret; +} + +/* + * Get the next line source line without advancing. But do skip over comment + * lines. + */ + static char_u * +getline_peek_skip_comments(evalarg_T *evalarg) +{ + for (;;) + { + char_u *next = getline_peek(evalarg->eval_getline, + evalarg->eval_cookie); + char_u *p; + + if (next == NULL) + break; + p = skipwhite(next); + if (*p != NUL && !vim9_comment_start(p)) + return next; + (void)eval_next_line(evalarg); + } + return NULL; +} + +/* + * If inside Vim9 script, "arg" points to the end of a line (ignoring a # + * comment) and there is a next line, return the next line (skipping blanks) + * and set "getnext". + * Otherwise just return "arg" unmodified and set "getnext" to FALSE. + * "arg" must point somewhere inside a line, not at the start. + */ + char_u * +eval_next_non_blank(char_u *arg, evalarg_T *evalarg, int *getnext) +{ + char_u *p = skipwhite(arg); + + *getnext = FALSE; + if (in_vim9script() + && evalarg != NULL + && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL) + && (*p == NUL || (VIM_ISWHITE(p[-1]) && vim9_comment_start(p)))) + { + char_u *next; + + if (evalarg->eval_cookie != NULL) + next = getline_peek_skip_comments(evalarg); + else + next = peek_next_line_from_context(evalarg->eval_cctx); + + if (next != NULL) + { + *getnext = TRUE; + return skipwhite(next); + } + } + return p; +} + +/* + * To be called after eval_next_non_blank() sets "getnext" to TRUE. + */ + char_u * +eval_next_line(evalarg_T *evalarg) +{ + garray_T *gap = &evalarg->eval_ga; + char_u *line; + + if (evalarg->eval_cookie != NULL) + line = evalarg->eval_getline(0, evalarg->eval_cookie, 0, + GETLINE_CONCAT_ALL); + else + line = next_line_from_context(evalarg->eval_cctx, TRUE); + ++evalarg->eval_break_count; + if (gap->ga_itemsize > 0 && ga_grow(gap, 1) == OK) + { + // Going to concatenate the lines after parsing. + ((char_u **)gap->ga_data)[gap->ga_len] = line; + ++gap->ga_len; + } + else if (evalarg->eval_cookie != NULL) + { + vim_free(evalarg->eval_tofree); + evalarg->eval_tofree = line; + } + return skipwhite(line); +} + +/* + * Call eval_next_non_blank() and get the next line if needed. + */ + char_u * +skipwhite_and_linebreak(char_u *arg, evalarg_T *evalarg) +{ + int getnext; + char_u *p = skipwhite(arg); + + if (evalarg == NULL) + return skipwhite(arg); + eval_next_non_blank(p, evalarg, &getnext); + if (getnext) + return eval_next_line(evalarg); + return p; +} + +/* + * After using "evalarg" filled from "eap": free the memory. + */ + void +clear_evalarg(evalarg_T *evalarg, exarg_T *eap) +{ + if (evalarg != NULL) + { + if (evalarg->eval_tofree != NULL) + { + if (eap != NULL) + { + // We may need to keep the original command line, e.g. for + // ":let" it has the variable names. But we may also need the + // new one, "nextcmd" points into it. Keep both. + vim_free(eap->cmdline_tofree); + eap->cmdline_tofree = *eap->cmdlinep; + *eap->cmdlinep = evalarg->eval_tofree; + } + else + vim_free(evalarg->eval_tofree); + evalarg->eval_tofree = NULL; + } + + vim_free(evalarg->eval_tofree_lambda); + evalarg->eval_tofree_lambda = NULL; + } +} + +/* + * The "evaluate" argument: When FALSE, the argument is only parsed but not + * executed. The function may return OK, but the rettv will be of type + * VAR_UNKNOWN. The function still returns FAIL for a syntax error. + */ + +/* + * Handle zero level expression. + * This calls eval1() and handles error message and nextcmd. + * Put the result in "rettv" when returning OK and "evaluate" is TRUE. + * Note: "rettv.v_lock" is not set. + * "evalarg" can be NULL, EVALARG_EVALUATE or a pointer. + * Return OK or FAIL. + */ + int +eval0( + char_u *arg, + typval_T *rettv, + exarg_T *eap, + evalarg_T *evalarg) +{ + int ret; + char_u *p; + int did_emsg_before = did_emsg; + int called_emsg_before = called_emsg; + int flags = evalarg == NULL ? 0 : evalarg->eval_flags; + + p = skipwhite(arg); + ret = eval1(&p, rettv, evalarg); + p = skipwhite(p); + + if (ret == FAIL || !ends_excmd2(arg, p)) + { + if (ret != FAIL) + clear_tv(rettv); + /* + * Report the invalid expression unless the expression evaluation has + * been cancelled due to an aborting error, an interrupt, or an + * exception, or we already gave a more specific error. + * Also check called_emsg for when using assert_fails(). + */ + if (!aborting() + && did_emsg == did_emsg_before + && called_emsg == called_emsg_before + && (flags & EVAL_CONSTANT) == 0) + semsg(_(e_invexpr2), arg); + + // Some of the expression may not have been consumed. Do not check for + // a next command to avoid more errors, unless "|" is following, which + // could only be a command separator. + if (eap != NULL && skipwhite(p)[0] == '|' && skipwhite(p)[1] != '|') + eap->nextcmd = check_nextcmd(p); + return FAIL; + } + + if (eap != NULL) + eap->nextcmd = check_nextcmd(p); + + return ret; +} + +/* + * Handle top level expression: + * expr2 ? expr1 : expr1 + * expr2 ?? expr1 + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Note: "rettv.v_lock" is not set. + * + * Return OK or FAIL. + */ + int +eval1(char_u **arg, typval_T *rettv, evalarg_T *evalarg) +{ + char_u *p; + int getnext; + + CLEAR_POINTER(rettv); + + /* + * Get the first variable. + */ + if (eval2(arg, rettv, evalarg) == FAIL) + return FAIL; + + p = eval_next_non_blank(*arg, evalarg, &getnext); + if (*p == '?') + { + int op_falsy = p[1] == '?'; + int result; + typval_T var2; + evalarg_T *evalarg_used = evalarg; + evalarg_T local_evalarg; + int orig_flags; + int evaluate; + int vim9script = in_vim9script(); + + if (evalarg == NULL) + { + CLEAR_FIELD(local_evalarg); + evalarg_used = &local_evalarg; + } + orig_flags = evalarg_used->eval_flags; + evaluate = evalarg_used->eval_flags & EVAL_EVALUATE; + + if (getnext) + *arg = eval_next_line(evalarg_used); + else + { + if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) + { + error_white_both(p, 1); + clear_tv(rettv); + return FAIL; + } + *arg = p; + } + + result = FALSE; + if (evaluate) + { + int error = FALSE; + + if (op_falsy) + result = tv2bool(rettv); + else if (vim9script) + result = tv_get_bool_chk(rettv, &error); + else if (tv_get_number_chk(rettv, &error) != 0) + result = TRUE; + if (error || !op_falsy || !result) + clear_tv(rettv); + if (error) + return FAIL; + } + + /* + * Get the second variable. Recursive! + */ + if (op_falsy) + ++*arg; + if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[1])) + { + error_white_both(p, 1); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used); + evalarg_used->eval_flags = (op_falsy ? !result : result) + ? orig_flags : orig_flags & ~EVAL_EVALUATE; + if (eval1(arg, &var2, evalarg_used) == FAIL) + { + evalarg_used->eval_flags = orig_flags; + return FAIL; + } + if (!op_falsy || !result) + *rettv = var2; + + if (!op_falsy) + { + /* + * Check for the ":". + */ + p = eval_next_non_blank(*arg, evalarg_used, &getnext); + if (*p != ':') + { + emsg(_(e_missing_colon)); + if (evaluate && result) + clear_tv(rettv); + evalarg_used->eval_flags = orig_flags; + return FAIL; + } + if (getnext) + *arg = eval_next_line(evalarg_used); + else + { + if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) + { + error_white_both(p, 1); + clear_tv(rettv); + evalarg_used->eval_flags = orig_flags; + return FAIL; + } + *arg = p; + } + + /* + * Get the third variable. Recursive! + */ + if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[1])) + { + error_white_both(p, 1); + clear_tv(rettv); + evalarg_used->eval_flags = orig_flags; + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used); + evalarg_used->eval_flags = !result ? orig_flags + : orig_flags & ~EVAL_EVALUATE; + if (eval1(arg, &var2, evalarg_used) == FAIL) + { + if (evaluate && result) + clear_tv(rettv); + evalarg_used->eval_flags = orig_flags; + return FAIL; + } + if (evaluate && !result) + *rettv = var2; + } + + if (evalarg == NULL) + clear_evalarg(&local_evalarg, NULL); + else + evalarg->eval_flags = orig_flags; + } + + return OK; +} + +/* + * Handle first level expression: + * expr2 || expr2 || expr2 logical OR + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg) +{ + char_u *p; + int getnext; + + /* + * Get the first variable. + */ + if (eval3(arg, rettv, evalarg) == FAIL) + return FAIL; + + /* + * Handle the "||" operator. + */ + p = eval_next_non_blank(*arg, evalarg, &getnext); + if (p[0] == '|' && p[1] == '|') + { + evalarg_T *evalarg_used = evalarg; + evalarg_T local_evalarg; + int evaluate; + int orig_flags; + long result = FALSE; + typval_T var2; + int error = FALSE; + int vim9script = in_vim9script(); + + if (evalarg == NULL) + { + CLEAR_FIELD(local_evalarg); + evalarg_used = &local_evalarg; + } + orig_flags = evalarg_used->eval_flags; + evaluate = orig_flags & EVAL_EVALUATE; + if (evaluate) + { + if (vim9script) + result = tv_get_bool_chk(rettv, &error); + else if (tv_get_number_chk(rettv, &error) != 0) + result = TRUE; + clear_tv(rettv); + if (error) + return FAIL; + } + + /* + * Repeat until there is no following "||". + */ + while (p[0] == '|' && p[1] == '|') + { + if (getnext) + *arg = eval_next_line(evalarg_used); + else + { + if (evaluate && in_vim9script() && !VIM_ISWHITE(p[-1])) + { + error_white_both(p, 2); + clear_tv(rettv); + return FAIL; + } + *arg = p; + } + + /* + * Get the second variable. + */ + if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2])) + { + error_white_both(p, 2); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used); + evalarg_used->eval_flags = !result ? orig_flags + : orig_flags & ~EVAL_EVALUATE; + if (eval3(arg, &var2, evalarg_used) == FAIL) + return FAIL; + + /* + * Compute the result. + */ + if (evaluate && !result) + { + if (vim9script) + result = tv_get_bool_chk(&var2, &error); + else if (tv_get_number_chk(&var2, &error) != 0) + result = TRUE; + clear_tv(&var2); + if (error) + return FAIL; + } + if (evaluate) + { + if (vim9script) + { + rettv->v_type = VAR_BOOL; + rettv->vval.v_number = result ? VVAL_TRUE : VVAL_FALSE; + } + else + { + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = result; + } + } + + p = eval_next_non_blank(*arg, evalarg_used, &getnext); + } + + if (evalarg == NULL) + clear_evalarg(&local_evalarg, NULL); + else + evalarg->eval_flags = orig_flags; + } + + return OK; +} + +/* + * Handle second level expression: + * expr3 && expr3 && expr3 logical AND + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg) +{ + char_u *p; + int getnext; + + /* + * Get the first variable. + */ + if (eval4(arg, rettv, evalarg) == FAIL) + return FAIL; + + /* + * Handle the "&&" operator. + */ + p = eval_next_non_blank(*arg, evalarg, &getnext); + if (p[0] == '&' && p[1] == '&') + { + evalarg_T *evalarg_used = evalarg; + evalarg_T local_evalarg; + int orig_flags; + int evaluate; + long result = TRUE; + typval_T var2; + int error = FALSE; + int vim9script = in_vim9script(); + + if (evalarg == NULL) + { + CLEAR_FIELD(local_evalarg); + evalarg_used = &local_evalarg; + } + orig_flags = evalarg_used->eval_flags; + evaluate = orig_flags & EVAL_EVALUATE; + if (evaluate) + { + if (vim9script) + result = tv_get_bool_chk(rettv, &error); + else if (tv_get_number_chk(rettv, &error) == 0) + result = FALSE; + clear_tv(rettv); + if (error) + return FAIL; + } + + /* + * Repeat until there is no following "&&". + */ + while (p[0] == '&' && p[1] == '&') + { + if (getnext) + *arg = eval_next_line(evalarg_used); + else + { + if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) + { + error_white_both(p, 2); + clear_tv(rettv); + return FAIL; + } + *arg = p; + } + + /* + * Get the second variable. + */ + if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2])) + { + error_white_both(p, 2); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used); + evalarg_used->eval_flags = result ? orig_flags + : orig_flags & ~EVAL_EVALUATE; + CLEAR_FIELD(var2); + if (eval4(arg, &var2, evalarg_used) == FAIL) + return FAIL; + + /* + * Compute the result. + */ + if (evaluate && result) + { + if (vim9script) + result = tv_get_bool_chk(&var2, &error); + else if (tv_get_number_chk(&var2, &error) == 0) + result = FALSE; + clear_tv(&var2); + if (error) + return FAIL; + } + if (evaluate) + { + if (vim9script) + { + rettv->v_type = VAR_BOOL; + rettv->vval.v_number = result ? VVAL_TRUE : VVAL_FALSE; + } + else + { + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = result; + } + } + + p = eval_next_non_blank(*arg, evalarg_used, &getnext); + } + + if (evalarg == NULL) + clear_evalarg(&local_evalarg, NULL); + else + evalarg->eval_flags = orig_flags; + } + + return OK; +} + +/* + * Handle third level expression: + * var1 == var2 + * var1 =~ var2 + * var1 != var2 + * var1 !~ var2 + * var1 > var2 + * var1 >= var2 + * var1 < var2 + * var1 <= var2 + * var1 is var2 + * var1 isnot var2 + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg) +{ + char_u *p; + int getnext; + exprtype_T type = EXPR_UNKNOWN; + int len = 2; + int type_is = FALSE; + + /* + * Get the first variable. + */ + if (eval5(arg, rettv, evalarg) == FAIL) + return FAIL; + + p = eval_next_non_blank(*arg, evalarg, &getnext); + type = get_compare_type(p, &len, &type_is); + + /* + * If there is a comparative operator, use it. + */ + if (type != EXPR_UNKNOWN) + { + typval_T var2; + int ic; + int vim9script = in_vim9script(); + int evaluate = evalarg == NULL + ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); + + if (getnext) + *arg = eval_next_line(evalarg); + else if (evaluate && vim9script && !VIM_ISWHITE(**arg)) + { + error_white_both(p, len); + clear_tv(rettv); + return FAIL; + } + + if (vim9script && type_is && (p[len] == '?' || p[len] == '#')) + { + semsg(_(e_invexpr2), p); + clear_tv(rettv); + return FAIL; + } + + // extra question mark appended: ignore case + if (p[len] == '?') + { + ic = TRUE; + ++len; + } + // extra '#' appended: match case + else if (p[len] == '#') + { + ic = FALSE; + ++len; + } + // nothing appended: use 'ignorecase' if not in Vim script + else + ic = vim9script ? FALSE : p_ic; + + /* + * Get the second variable. + */ + if (evaluate && vim9script && !IS_WHITE_OR_NUL(p[len])) + { + error_white_both(p, 1); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(p + len, evalarg); + if (eval5(arg, &var2, evalarg) == FAIL) + { + clear_tv(rettv); + return FAIL; + } + if (evaluate) + { + int ret; + + if (vim9script && check_compare_types(type, rettv, &var2) == FAIL) + { + ret = FAIL; + clear_tv(rettv); + } + else + ret = typval_compare(rettv, &var2, type, ic); + clear_tv(&var2); + return ret; + } + } + + return OK; +} + +/* + * Make a copy of blob "tv1" and append blob "tv2". + */ + void +eval_addblob(typval_T *tv1, typval_T *tv2) +{ + blob_T *b1 = tv1->vval.v_blob; + blob_T *b2 = tv2->vval.v_blob; + blob_T *b = blob_alloc(); + int i; + + if (b != NULL) + { + for (i = 0; i < blob_len(b1); i++) + ga_append(&b->bv_ga, blob_get(b1, i)); + for (i = 0; i < blob_len(b2); i++) + ga_append(&b->bv_ga, blob_get(b2, i)); + + clear_tv(tv1); + rettv_blob_set(tv1, b); + } +} + +/* + * Make a copy of list "tv1" and append list "tv2". + */ + int +eval_addlist(typval_T *tv1, typval_T *tv2) +{ + typval_T var3; + + // concatenate Lists + if (list_concat(tv1->vval.v_list, tv2->vval.v_list, &var3) == FAIL) + { + clear_tv(tv1); + clear_tv(tv2); + return FAIL; + } + clear_tv(tv1); + *tv1 = var3; + return OK; +} + +/* + * Handle fourth level expression: + * + number addition + * - number subtraction + * . string concatenation (if script version is 1) + * .. string concatenation + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg) +{ + /* + * Get the first variable. + */ + if (eval6(arg, rettv, evalarg, FALSE) == FAIL) + return FAIL; + + /* + * Repeat computing, until no '+', '-' or '.' is following. + */ + for (;;) + { + int evaluate; + int getnext; + char_u *p; + int op; + int oplen; + int concat; + typval_T var2; + int vim9script = in_vim9script(); + + // "." is only string concatenation when scriptversion is 1 + // "+=" and "-=" are assignment + p = eval_next_non_blank(*arg, evalarg, &getnext); + op = *p; + concat = op == '.' && (*(p + 1) == '.' || current_sctx.sc_version < 2); + if ((op != '+' && op != '-' && !concat) || p[1] == '=') + break; + + evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); + oplen = (concat && p[1] == '.') ? 2 : 1; + if (getnext) + *arg = eval_next_line(evalarg); + else + { + if (evaluate && vim9script && !VIM_ISWHITE(**arg)) + { + error_white_both(p, oplen); + clear_tv(rettv); + return FAIL; + } + *arg = p; + } + if ((op != '+' || (rettv->v_type != VAR_LIST + && rettv->v_type != VAR_BLOB)) +#ifdef FEAT_FLOAT + && (op == '.' || rettv->v_type != VAR_FLOAT) +#endif + && evaluate) + { + int error = FALSE; + + // For "list + ...", an illegal use of the first operand as + // a number cannot be determined before evaluating the 2nd + // operand: if this is also a list, all is ok. + // For "something . ...", "something - ..." or "non-list + ...", + // we know that the first operand needs to be a string or number + // without evaluating the 2nd operand. So check before to avoid + // side effects after an error. + if (op != '.') + tv_get_number_chk(rettv, &error); + if ((op == '.' && tv_get_string_chk(rettv) == NULL) || error) + { + clear_tv(rettv); + return FAIL; + } + } + + /* + * Get the second variable. + */ + if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[oplen])) + { + error_white_both(p, oplen); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + oplen, evalarg); + if (eval6(arg, &var2, evalarg, !vim9script && op == '.') == FAIL) + { + clear_tv(rettv); + return FAIL; + } + + if (evaluate) + { + /* + * Compute the result. + */ + if (op == '.') + { + char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; + char_u *s1 = tv_get_string_buf(rettv, buf1); + char_u *s2 = NULL; + + if (vim9script && (var2.v_type == VAR_VOID + || var2.v_type == VAR_CHANNEL + || var2.v_type == VAR_JOB)) + emsg(_(e_inval_string)); +#ifdef FEAT_FLOAT + else if (vim9script && var2.v_type == VAR_FLOAT) + { + vim_snprintf((char *)buf2, NUMBUFLEN, "%g", + var2.vval.v_float); + s2 = buf2; + } +#endif + else + s2 = tv_get_string_buf_chk(&var2, buf2); + if (s2 == NULL) // type error ? + { + clear_tv(rettv); + clear_tv(&var2); + return FAIL; + } + p = concat_str(s1, s2); + clear_tv(rettv); + rettv->v_type = VAR_STRING; + rettv->vval.v_string = p; + } + else if (op == '+' && rettv->v_type == VAR_BLOB + && var2.v_type == VAR_BLOB) + eval_addblob(rettv, &var2); + else if (op == '+' && rettv->v_type == VAR_LIST + && var2.v_type == VAR_LIST) + { + if (eval_addlist(rettv, &var2) == FAIL) + return FAIL; + } + else + { + int error = FALSE; + varnumber_T n1, n2; +#ifdef FEAT_FLOAT + float_T f1 = 0, f2 = 0; + + if (rettv->v_type == VAR_FLOAT) + { + f1 = rettv->vval.v_float; + n1 = 0; + } + else +#endif + { + n1 = tv_get_number_chk(rettv, &error); + if (error) + { + // This can only happen for "list + non-list". For + // "non-list + ..." or "something - ...", we returned + // before evaluating the 2nd operand. + clear_tv(rettv); + return FAIL; + } +#ifdef FEAT_FLOAT + if (var2.v_type == VAR_FLOAT) + f1 = n1; +#endif + } +#ifdef FEAT_FLOAT + if (var2.v_type == VAR_FLOAT) + { + f2 = var2.vval.v_float; + n2 = 0; + } + else +#endif + { + n2 = tv_get_number_chk(&var2, &error); + if (error) + { + clear_tv(rettv); + clear_tv(&var2); + return FAIL; + } +#ifdef FEAT_FLOAT + if (rettv->v_type == VAR_FLOAT) + f2 = n2; +#endif + } + clear_tv(rettv); + +#ifdef FEAT_FLOAT + // If there is a float on either side the result is a float. + if (rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT) + { + if (op == '+') + f1 = f1 + f2; + else + f1 = f1 - f2; + rettv->v_type = VAR_FLOAT; + rettv->vval.v_float = f1; + } + else +#endif + { + if (op == '+') + n1 = n1 + n2; + else + n1 = n1 - n2; + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = n1; + } + } + clear_tv(&var2); + } + } + return OK; +} + +/* + * Handle fifth level expression: + * * number multiplication + * / number division + * % number modulo + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval6( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int want_string) // after "." operator +{ +#ifdef FEAT_FLOAT + int use_float = FALSE; +#endif + + /* + * Get the first variable. + */ + if (eval7(arg, rettv, evalarg, want_string) == FAIL) + return FAIL; + + /* + * Repeat computing, until no '*', '/' or '%' is following. + */ + for (;;) + { + int evaluate; + int getnext; + typval_T var2; + char_u *p; + int op; + varnumber_T n1, n2; +#ifdef FEAT_FLOAT + float_T f1, f2; +#endif + int error; + + p = eval_next_non_blank(*arg, evalarg, &getnext); + op = *p; + if (op != '*' && op != '/' && op != '%') + break; + + evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); + if (getnext) + *arg = eval_next_line(evalarg); + else + { + if (evaluate && in_vim9script() && !VIM_ISWHITE(**arg)) + { + error_white_both(p, 1); + clear_tv(rettv); + return FAIL; + } + *arg = p; + } + +#ifdef FEAT_FLOAT + f1 = 0; + f2 = 0; +#endif + error = FALSE; + if (evaluate) + { +#ifdef FEAT_FLOAT + if (rettv->v_type == VAR_FLOAT) + { + f1 = rettv->vval.v_float; + use_float = TRUE; + n1 = 0; + } + else +#endif + n1 = tv_get_number_chk(rettv, &error); + clear_tv(rettv); + if (error) + return FAIL; + } + else + n1 = 0; + + /* + * Get the second variable. + */ + if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[1])) + { + error_white_both(p, 1); + clear_tv(rettv); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg + 1, evalarg); + if (eval7(arg, &var2, evalarg, FALSE) == FAIL) + return FAIL; + + if (evaluate) + { +#ifdef FEAT_FLOAT + if (var2.v_type == VAR_FLOAT) + { + if (!use_float) + { + f1 = n1; + use_float = TRUE; + } + f2 = var2.vval.v_float; + n2 = 0; + } + else +#endif + { + n2 = tv_get_number_chk(&var2, &error); + clear_tv(&var2); + if (error) + return FAIL; +#ifdef FEAT_FLOAT + if (use_float) + f2 = n2; +#endif + } + + /* + * Compute the result. + * When either side is a float the result is a float. + */ +#ifdef FEAT_FLOAT + if (use_float) + { + if (op == '*') + f1 = f1 * f2; + else if (op == '/') + { +# ifdef VMS + // VMS crashes on divide by zero, work around it + if (f2 == 0.0) + { + if (f1 == 0) + f1 = -1 * __F_FLT_MAX - 1L; // similar to NaN + else if (f1 < 0) + f1 = -1 * __F_FLT_MAX; + else + f1 = __F_FLT_MAX; + } + else + f1 = f1 / f2; +# else + // We rely on the floating point library to handle divide + // by zero to result in "inf" and not a crash. + f1 = f1 / f2; +# endif + } + else + { + emsg(_(e_modulus)); + return FAIL; + } + rettv->v_type = VAR_FLOAT; + rettv->vval.v_float = f1; + } + else +#endif + { + int failed = FALSE; + + if (op == '*') + n1 = n1 * n2; + else if (op == '/') + n1 = num_divide(n1, n2, &failed); + else + n1 = num_modulus(n1, n2, &failed); + if (failed) + return FAIL; + + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = n1; + } + } + } + + return OK; +} + + int +eval_leader(char_u **arg, int vim9) +{ + char_u *s = *arg; + char_u *p = *arg; + + while (*p == '!' || *p == '-' || *p == '+') + { + char_u *n = skipwhite(p + 1); + + // ++, --, -+ and +- are not accepted in Vim9 script + if (vim9 && (*p == '-' || *p == '+') && (*n == '-' || *n == '+')) + { + semsg(_(e_invexpr2), s); + return FAIL; + } + p = n; + } + *arg = p; + return OK; +} + +/* + * Handle sixth level expression: + * number number constant + * 0zFFFFFFFF Blob constant + * "string" string constant + * 'string' literal string constant + * &option-name option value + * @r register contents + * identifier variable value + * function() function call + * $VAR environment variable + * (expression) nested expression + * [expr, expr] List + * {arg, arg -> expr} Lambda + * {key: val, key: val} Dictionary + * #{key: val, key: val} Dictionary with literal keys + * + * Also handle: + * ! in front logical NOT + * - in front unary minus + * + in front unary plus (ignored) + * trailing [] subscript in String or List + * trailing .name entry in Dictionary + * trailing ->name() method call + * + * "arg" must point to the first non-white of the expression. + * "arg" is advanced to just after the recognized expression. + * + * Return OK or FAIL. + */ + static int +eval7( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int want_string) // after "." operator +{ + int evaluate = evalarg != NULL + && (evalarg->eval_flags & EVAL_EVALUATE); + int len; + char_u *s; + char_u *start_leader, *end_leader; + int ret = OK; + char_u *alias; + + /* + * Initialise variable so that clear_tv() can't mistake this for a + * string and free a string that isn't there. + */ + rettv->v_type = VAR_UNKNOWN; + + /* + * Skip '!', '-' and '+' characters. They are handled later. + */ + start_leader = *arg; + if (eval_leader(arg, in_vim9script()) == FAIL) + return FAIL; + end_leader = *arg; + + if (**arg == '.' && (!isdigit(*(*arg + 1)) +#ifdef FEAT_FLOAT + || current_sctx.sc_version < 2 +#endif + )) + { + semsg(_(e_invexpr2), *arg); + ++*arg; + return FAIL; + } + + switch (**arg) + { + /* + * Number constant. + */ + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '.': ret = eval_number(arg, rettv, evaluate, want_string); + + // Apply prefixed "-" and "+" now. Matters especially when + // "->" follows. + if (ret == OK && evaluate && end_leader > start_leader + && rettv->v_type != VAR_BLOB) + ret = eval7_leader(rettv, TRUE, start_leader, &end_leader); + break; + + /* + * String constant: "string". + */ + case '"': ret = eval_string(arg, rettv, evaluate); + break; + + /* + * Literal string constant: 'str''ing'. + */ + case '\'': ret = eval_lit_string(arg, rettv, evaluate); + break; + + /* + * List: [expr, expr] + */ + case '[': ret = eval_list(arg, rettv, evalarg, TRUE); + break; + + /* + * Dictionary: #{key: val, key: val} + */ + case '#': if (!in_vim9script() && (*arg)[1] == '{') + { + ++*arg; + ret = eval_dict(arg, rettv, evalarg, TRUE); + } + else + ret = NOTDONE; + break; + + /* + * Lambda: {arg, arg -> expr} + * Dictionary: {'key': val, 'key': val} + */ + case '{': if (in_vim9script()) + ret = NOTDONE; + else + ret = get_lambda_tv(arg, rettv, in_vim9script(), evalarg); + if (ret == NOTDONE) + ret = eval_dict(arg, rettv, evalarg, FALSE); + break; + + /* + * Option value: &name + */ + case '&': ret = eval_option(arg, rettv, evaluate); + break; + + /* + * Environment variable: $VAR. + */ + case '$': ret = eval_env_var(arg, rettv, evaluate); + break; + + /* + * Register contents: @r. + */ + case '@': ++*arg; + if (evaluate) + { + rettv->v_type = VAR_STRING; + rettv->vval.v_string = get_reg_contents(**arg, + GREG_EXPR_SRC); + } + if (**arg != NUL) + ++*arg; + break; + + /* + * nested expression: (expression). + * lambda: (arg) => expr + */ + case '(': ret = NOTDONE; + if (in_vim9script()) + ret = get_lambda_tv(arg, rettv, TRUE, evalarg); + if (ret == NOTDONE) + { + *arg = skipwhite_and_linebreak(*arg + 1, evalarg); + ret = eval1(arg, rettv, evalarg); // recursive! + + *arg = skipwhite_and_linebreak(*arg, evalarg); + if (**arg == ')') + ++*arg; + else if (ret == OK) + { + emsg(_(e_missing_close)); + clear_tv(rettv); + ret = FAIL; + } + } + break; + + default: ret = NOTDONE; + break; + } + + if (ret == NOTDONE) + { + /* + * Must be a variable or function name. + * Can also be a curly-braces kind of name: {expr}. + */ + s = *arg; + len = get_name_len(arg, &alias, evaluate, TRUE); + if (alias != NULL) + s = alias; + + if (len <= 0) + ret = FAIL; + else + { + int flags = evalarg == NULL ? 0 : evalarg->eval_flags; + + if ((in_vim9script() ? **arg : *skipwhite(*arg)) == '(') + { + // "name(..." recursive! + *arg = skipwhite(*arg); + ret = eval_func(arg, evalarg, s, len, rettv, flags, NULL); + } + else if (flags & EVAL_CONSTANT) + ret = FAIL; + else if (evaluate) + { + // get the value of "true", "false" or a variable + if (len == 4 && in_vim9script() && STRNCMP(s, "true", 4) == 0) + { + rettv->v_type = VAR_BOOL; + rettv->vval.v_number = VVAL_TRUE; + ret = OK; + } + else if (len == 5 && in_vim9script() + && STRNCMP(s, "false", 5) == 0) + { + rettv->v_type = VAR_BOOL; + rettv->vval.v_number = VVAL_FALSE; + ret = OK; + } + else if (len == 4 && in_vim9script() + && STRNCMP(s, "null", 4) == 0) + { + rettv->v_type = VAR_SPECIAL; + rettv->vval.v_number = VVAL_NULL; + ret = OK; + } + else + ret = eval_variable(s, len, rettv, NULL, TRUE, FALSE); + } + else + { + // skip the name + check_vars(s, len); + ret = OK; + } + } + vim_free(alias); + } + + // Handle following '[', '(' and '.' for expr[expr], expr.name, + // expr(expr), expr->name(expr) + if (ret == OK) + ret = handle_subscript(arg, rettv, evalarg, TRUE); + + /* + * Apply logical NOT and unary '-', from right to left, ignore '+'. + */ + if (ret == OK && evaluate && end_leader > start_leader) + ret = eval7_leader(rettv, FALSE, start_leader, &end_leader); + return ret; +} + +/* + * Apply the leading "!" and "-" before an eval7 expression to "rettv". + * When "numeric_only" is TRUE only handle "+" and "-". + * Adjusts "end_leaderp" until it is at "start_leader". + */ + static int +eval7_leader( + typval_T *rettv, + int numeric_only, + char_u *start_leader, + char_u **end_leaderp) +{ + char_u *end_leader = *end_leaderp; + int ret = OK; + int error = FALSE; + varnumber_T val = 0; + vartype_T type = rettv->v_type; +#ifdef FEAT_FLOAT + float_T f = 0.0; + + if (rettv->v_type == VAR_FLOAT) + f = rettv->vval.v_float; + else +#endif + { + while (VIM_ISWHITE(end_leader[-1])) + --end_leader; + if (in_vim9script() && end_leader[-1] == '!') + val = tv2bool(rettv); + else + val = tv_get_number_chk(rettv, &error); + } + if (error) + { + clear_tv(rettv); + ret = FAIL; + } + else + { + while (end_leader > start_leader) + { + --end_leader; + if (*end_leader == '!') + { + if (numeric_only) + { + ++end_leader; + break; + } +#ifdef FEAT_FLOAT + if (rettv->v_type == VAR_FLOAT) + { + if (in_vim9script()) + { + rettv->v_type = VAR_BOOL; + val = f == 0.0 ? VVAL_TRUE : VVAL_FALSE; + } + else + f = !f; + } + else +#endif + { + val = !val; + type = VAR_BOOL; + } + } + else if (*end_leader == '-') + { +#ifdef FEAT_FLOAT + if (rettv->v_type == VAR_FLOAT) + f = -f; + else +#endif + { + val = -val; + type = VAR_NUMBER; + } + } + } +#ifdef FEAT_FLOAT + if (rettv->v_type == VAR_FLOAT) + { + clear_tv(rettv); + rettv->vval.v_float = f; + } + else +#endif + { + clear_tv(rettv); + if (in_vim9script()) + rettv->v_type = type; + else + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = val; + } + } + *end_leaderp = end_leader; + return ret; +} + +/* + * Call the function referred to in "rettv". + */ + static int +call_func_rettv( + char_u **arg, + evalarg_T *evalarg, + typval_T *rettv, + int evaluate, + dict_T *selfdict, + typval_T *basetv) +{ + partial_T *pt = NULL; + funcexe_T funcexe; + typval_T functv; + char_u *s; + int ret; + + // need to copy the funcref so that we can clear rettv + if (evaluate) + { + functv = *rettv; + rettv->v_type = VAR_UNKNOWN; + + // Invoke the function. Recursive! + if (functv.v_type == VAR_PARTIAL) + { + pt = functv.vval.v_partial; + s = partial_name(pt); + } + else + s = functv.vval.v_string; + } + else + s = (char_u *)""; + + CLEAR_FIELD(funcexe); + funcexe.firstline = curwin->w_cursor.lnum; + funcexe.lastline = curwin->w_cursor.lnum; + funcexe.evaluate = evaluate; + funcexe.partial = pt; + funcexe.selfdict = selfdict; + funcexe.basetv = basetv; + ret = get_func_tv(s, -1, rettv, arg, evalarg, &funcexe); + + // Clear the funcref afterwards, so that deleting it while + // evaluating the arguments is possible (see test55). + if (evaluate) + clear_tv(&functv); + + return ret; +} + +/* + * Evaluate "->method()". + * "*arg" points to "method". + * Returns FAIL or OK. "*arg" is advanced to after the ')'. + */ + static int +eval_lambda( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int verbose) // give error messages +{ + int evaluate = evalarg != NULL + && (evalarg->eval_flags & EVAL_EVALUATE); + typval_T base = *rettv; + int ret; + + rettv->v_type = VAR_UNKNOWN; + + if (**arg == '{') + { + // ->{lambda}() + ret = get_lambda_tv(arg, rettv, FALSE, evalarg); + } + else + { + // ->(lambda)() + ++*arg; + ret = eval1(arg, rettv, evalarg); + *arg = skipwhite_and_linebreak(*arg, evalarg); + if (**arg != ')') + { + emsg(_(e_missing_close)); + ret = FAIL; + } + ++*arg; + } + if (ret != OK) + return FAIL; + else if (**arg != '(') + { + if (verbose) + { + if (*skipwhite(*arg) == '(') + emsg(_(e_nowhitespace)); + else + semsg(_(e_missing_paren), "lambda"); + } + clear_tv(rettv); + ret = FAIL; + } + else + ret = call_func_rettv(arg, evalarg, rettv, evaluate, NULL, &base); + + // Clear the funcref afterwards, so that deleting it while + // evaluating the arguments is possible (see test55). + if (evaluate) + clear_tv(&base); + + return ret; +} + +/* + * Evaluate "->method()". + * "*arg" points to "method". + * Returns FAIL or OK. "*arg" is advanced to after the ')'. + */ + static int +eval_method( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int verbose) // give error messages +{ + char_u *name; + long len; + char_u *alias; + typval_T base = *rettv; + int ret; + int evaluate = evalarg != NULL + && (evalarg->eval_flags & EVAL_EVALUATE); + + rettv->v_type = VAR_UNKNOWN; + + name = *arg; + len = get_name_len(arg, &alias, evaluate, TRUE); + if (alias != NULL) + name = alias; + + if (len <= 0) + { + if (verbose) + emsg(_("E260: Missing name after ->")); + ret = FAIL; + } + else + { + *arg = skipwhite(*arg); + if (**arg != '(') + { + if (verbose) + semsg(_(e_missing_paren), name); + ret = FAIL; + } + else if (VIM_ISWHITE((*arg)[-1])) + { + if (verbose) + emsg(_(e_nowhitespace)); + ret = FAIL; + } + else + ret = eval_func(arg, evalarg, name, len, rettv, + evaluate ? EVAL_EVALUATE : 0, &base); + } + + // Clear the funcref afterwards, so that deleting it while + // evaluating the arguments is possible (see test55). + if (evaluate) + clear_tv(&base); + + return ret; +} + +/* + * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key". + * "*arg" points to the '[' or '.'. + * Returns FAIL or OK. "*arg" is advanced to after the ']'. + */ + static int +eval_index( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int verbose) // give error messages +{ + int evaluate = evalarg != NULL + && (evalarg->eval_flags & EVAL_EVALUATE); + int empty1 = FALSE, empty2 = FALSE; + typval_T var1, var2; + int range = FALSE; + char_u *key = NULL; + int keylen = -1; + int vim9 = in_vim9script(); + + if (check_can_index(rettv, evaluate, verbose) == FAIL) + return FAIL; + + init_tv(&var1); + init_tv(&var2); + if (**arg == '.') + { + /* + * dict.name + */ + key = *arg + 1; + for (keylen = 0; eval_isdictc(key[keylen]); ++keylen) + ; + if (keylen == 0) + return FAIL; + *arg = key + keylen; + } + else + { + /* + * something[idx] + * + * Get the (first) variable from inside the []. + */ + *arg = skipwhite_and_linebreak(*arg + 1, evalarg); + if (**arg == ':') + empty1 = TRUE; + else if (eval1(arg, &var1, evalarg) == FAIL) // recursive! + return FAIL; + else if (vim9 && **arg == ':') + { + semsg(_(e_white_space_required_before_and_after_str_at_str), + ":", *arg); + clear_tv(&var1); + return FAIL; + } + else if (evaluate && tv_get_string_chk(&var1) == NULL) + { + // not a number or string + clear_tv(&var1); + return FAIL; + } + + /* + * Get the second variable from inside the [:]. + */ + *arg = skipwhite_and_linebreak(*arg, evalarg); + if (**arg == ':') + { + range = TRUE; + ++*arg; + if (vim9 && !IS_WHITE_OR_NUL(**arg) && **arg != ']') + { + semsg(_(e_white_space_required_before_and_after_str_at_str), + ":", *arg - 1); + if (!empty1) + clear_tv(&var1); + return FAIL; + } + *arg = skipwhite_and_linebreak(*arg, evalarg); + if (**arg == ']') + empty2 = TRUE; + else if (eval1(arg, &var2, evalarg) == FAIL) // recursive! + { + if (!empty1) + clear_tv(&var1); + return FAIL; + } + else if (evaluate && tv_get_string_chk(&var2) == NULL) + { + // not a number or string + if (!empty1) + clear_tv(&var1); + clear_tv(&var2); + return FAIL; + } + } + + // Check for the ']'. + *arg = skipwhite_and_linebreak(*arg, evalarg); + if (**arg != ']') + { + if (verbose) + emsg(_(e_missbrac)); + clear_tv(&var1); + if (range) + clear_tv(&var2); + return FAIL; + } + *arg = *arg + 1; // skip over the ']' + } + + if (evaluate) + { + int res = eval_index_inner(rettv, range, + empty1 ? NULL : &var1, empty2 ? NULL : &var2, FALSE, + key, keylen, verbose); + + if (!empty1) + clear_tv(&var1); + if (range) + clear_tv(&var2); + return res; + } + return OK; +} + +/* + * Check if "rettv" can have an [index] or [sli:ce] + */ + int +check_can_index(typval_T *rettv, int evaluate, int verbose) +{ + switch (rettv->v_type) + { + case VAR_FUNC: + case VAR_PARTIAL: + if (verbose) + emsg(_("E695: Cannot index a Funcref")); + return FAIL; + case VAR_FLOAT: +#ifdef FEAT_FLOAT + if (verbose) + emsg(_(e_float_as_string)); + return FAIL; +#endif + case VAR_BOOL: + case VAR_SPECIAL: + case VAR_JOB: + case VAR_CHANNEL: + if (verbose) + emsg(_(e_cannot_index_special_variable)); + return FAIL; + case VAR_UNKNOWN: + case VAR_ANY: + case VAR_VOID: + if (evaluate) + { + emsg(_(e_cannot_index_special_variable)); + return FAIL; + } + // FALLTHROUGH + + case VAR_STRING: + case VAR_LIST: + case VAR_DICT: + case VAR_BLOB: + break; + case VAR_NUMBER: + if (in_vim9script()) + emsg(_(e_cannot_index_number)); + break; + } + return OK; +} + +/* + * slice() function + */ + void +f_slice(typval_T *argvars, typval_T *rettv) +{ + if (check_can_index(argvars, TRUE, FALSE) == OK) + { + copy_tv(argvars, rettv); + eval_index_inner(rettv, TRUE, argvars + 1, + argvars[2].v_type == VAR_UNKNOWN ? NULL : argvars + 2, + TRUE, NULL, 0, FALSE); + } +} + +/* + * Apply index or range to "rettv". + * "var1" is the first index, NULL for [:expr]. + * "var2" is the second index, NULL for [expr] and [expr: ] + * "exclusive" is TRUE for slice(): second index is exclusive, use character + * index for string. + * Alternatively, "key" is not NULL, then key[keylen] is the dict index. + */ + int +eval_index_inner( + typval_T *rettv, + int is_range, + typval_T *var1, + typval_T *var2, + int exclusive, + char_u *key, + int keylen, + int verbose) +{ + varnumber_T n1, n2 = 0; + long len; + + n1 = 0; + if (var1 != NULL && rettv->v_type != VAR_DICT) + n1 = tv_get_number(var1); + + if (is_range) + { + if (rettv->v_type == VAR_DICT) + { + if (verbose) + emsg(_(e_cannot_slice_dictionary)); + return FAIL; + } + if (var2 != NULL) + n2 = tv_get_number(var2); + else + n2 = VARNUM_MAX; + } + + switch (rettv->v_type) + { + case VAR_UNKNOWN: + case VAR_ANY: + case VAR_VOID: + case VAR_FUNC: + case VAR_PARTIAL: + case VAR_FLOAT: + case VAR_BOOL: + case VAR_SPECIAL: + case VAR_JOB: + case VAR_CHANNEL: + break; // not evaluating, skipping over subscript + + case VAR_NUMBER: + case VAR_STRING: + { + char_u *s = tv_get_string(rettv); + + len = (long)STRLEN(s); + if (in_vim9script() || exclusive) + { + if (is_range) + s = string_slice(s, n1, n2, exclusive); + else + s = char_from_string(s, n1); + } + else if (is_range) + { + // The resulting variable is a substring. If the indexes + // are out of range the result is empty. + if (n1 < 0) + { + n1 = len + n1; + if (n1 < 0) + n1 = 0; + } + if (n2 < 0) + n2 = len + n2; + else if (n2 >= len) + n2 = len; + if (exclusive) + --n2; + if (n1 >= len || n2 < 0 || n1 > n2) + s = NULL; + else + s = vim_strnsave(s + n1, n2 - n1 + 1); + } + else + { + // The resulting variable is a string of a single + // character. If the index is too big or negative the + // result is empty. + if (n1 >= len || n1 < 0) + s = NULL; + else + s = vim_strnsave(s + n1, 1); + } + clear_tv(rettv); + rettv->v_type = VAR_STRING; + rettv->vval.v_string = s; + } + break; + + case VAR_BLOB: + len = blob_len(rettv->vval.v_blob); + if (is_range) + { + // The resulting variable is a sub-blob. If the indexes + // are out of range the result is empty. + if (n1 < 0) + { + n1 = len + n1; + if (n1 < 0) + n1 = 0; + } + if (n2 < 0) + n2 = len + n2; + else if (n2 >= len) + n2 = len - (exclusive ? 0 : 1); + if (exclusive) + --n2; + if (n1 >= len || n2 < 0 || n1 > n2) + { + clear_tv(rettv); + rettv->v_type = VAR_BLOB; + rettv->vval.v_blob = NULL; + } + else + { + blob_T *blob = blob_alloc(); + long i; + + if (blob != NULL) + { + if (ga_grow(&blob->bv_ga, n2 - n1 + 1) == FAIL) + { + blob_free(blob); + return FAIL; + } + blob->bv_ga.ga_len = n2 - n1 + 1; + for (i = n1; i <= n2; i++) + blob_set(blob, i - n1, + blob_get(rettv->vval.v_blob, i)); + + clear_tv(rettv); + rettv_blob_set(rettv, blob); + } + } + } + else + { + // The resulting variable is a byte value. + // If the index is too big or negative that is an error. + if (n1 < 0) + n1 = len + n1; + if (n1 < len && n1 >= 0) + { + int v = blob_get(rettv->vval.v_blob, n1); + + clear_tv(rettv); + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = v; + } + else + semsg(_(e_blobidx), n1); + } + break; + + case VAR_LIST: + if (var1 == NULL) + n1 = 0; + if (var2 == NULL) + n2 = VARNUM_MAX; + if (list_slice_or_index(rettv->vval.v_list, + is_range, n1, n2, exclusive, rettv, verbose) == FAIL) + return FAIL; + break; + + case VAR_DICT: + { + dictitem_T *item; + typval_T tmp; + + if (key == NULL) + { + key = tv_get_string_chk(var1); + if (key == NULL) + return FAIL; + } + + item = dict_find(rettv->vval.v_dict, key, (int)keylen); + + if (item == NULL && verbose) + semsg(_(e_dictkey), key); + if (item == NULL) + return FAIL; + + copy_tv(&item->di_tv, &tmp); + clear_tv(rettv); + *rettv = tmp; + } + break; + } + return OK; +} + +/* + * Return the function name of partial "pt". + */ + char_u * +partial_name(partial_T *pt) +{ + if (pt->pt_name != NULL) + return pt->pt_name; + if (pt->pt_func != NULL) + return pt->pt_func->uf_name; + return (char_u *)""; +} + + static void +partial_free(partial_T *pt) +{ + int i; + + for (i = 0; i < pt->pt_argc; ++i) + clear_tv(&pt->pt_argv[i]); + vim_free(pt->pt_argv); + dict_unref(pt->pt_dict); + if (pt->pt_name != NULL) + { + func_unref(pt->pt_name); + vim_free(pt->pt_name); + } + else + func_ptr_unref(pt->pt_func); + + // Decrease the reference count for the context of a closure. If down + // to the minimum it may be time to free it. + if (pt->pt_funcstack != NULL) + { + --pt->pt_funcstack->fs_refcount; + funcstack_check_refcount(pt->pt_funcstack); + } + + vim_free(pt); +} + +/* + * Unreference a closure: decrement the reference count and free it when it + * becomes zero. + */ + void +partial_unref(partial_T *pt) +{ + if (pt != NULL) + { + if (--pt->pt_refcount <= 0) + partial_free(pt); + + // If the reference count goes down to one, the funcstack may be the + // only reference and can be freed if no other partials reference it. + else if (pt->pt_refcount == 1 && pt->pt_funcstack != NULL) + funcstack_check_refcount(pt->pt_funcstack); + } +} + +/* + * Return the next (unique) copy ID. + * Used for serializing nested structures. + */ + int +get_copyID(void) +{ + current_copyID += COPYID_INC; + return current_copyID; +} + +/* + * Garbage collection for lists and dictionaries. + * + * We use reference counts to be able to free most items right away when they + * are no longer used. But for composite items it's possible that it becomes + * unused while the reference count is > 0: When there is a recursive + * reference. Example: + * :let l = [1, 2, 3] + * :let d = {9: l} + * :let l[1] = d + * + * Since this is quite unusual we handle this with garbage collection: every + * once in a while find out which lists and dicts are not referenced from any + * variable. + * + * Here is a good reference text about garbage collection (refers to Python + * but it applies to all reference-counting mechanisms): + * http://python.ca/nas/python/gc/ + */ + +/* + * Do garbage collection for lists and dicts. + * When "testing" is TRUE this is called from test_garbagecollect_now(). + * Return TRUE if some memory was freed. + */ + int +garbage_collect(int testing) +{ + int copyID; + int abort = FALSE; + buf_T *buf; + win_T *wp; + int did_free = FALSE; + tabpage_T *tp; + + if (!testing) + { + // Only do this once. + want_garbage_collect = FALSE; + may_garbage_collect = FALSE; + garbage_collect_at_exit = FALSE; + } + + // The execution stack can grow big, limit the size. + if (exestack.ga_maxlen - exestack.ga_len > 500) + { + size_t new_len; + char_u *pp; + int n; + + // Keep 150% of the current size, with a minimum of the growth size. + n = exestack.ga_len / 2; + if (n < exestack.ga_growsize) + n = exestack.ga_growsize; + + // Don't make it bigger though. + if (exestack.ga_len + n < exestack.ga_maxlen) + { + new_len = exestack.ga_itemsize * (exestack.ga_len + n); + pp = vim_realloc(exestack.ga_data, new_len); + if (pp == NULL) + return FAIL; + exestack.ga_maxlen = exestack.ga_len + n; + exestack.ga_data = pp; + } + } + + // We advance by two because we add one for items referenced through + // previous_funccal. + copyID = get_copyID(); + + /* + * 1. Go through all accessible variables and mark all lists and dicts + * with copyID. + */ + + // Don't free variables in the previous_funccal list unless they are only + // referenced through previous_funccal. This must be first, because if + // the item is referenced elsewhere the funccal must not be freed. + abort = abort || set_ref_in_previous_funccal(copyID); + + // script-local variables + abort = abort || garbage_collect_scriptvars(copyID); + + // buffer-local variables + FOR_ALL_BUFFERS(buf) + abort = abort || set_ref_in_item(&buf->b_bufvar.di_tv, copyID, + NULL, NULL); + + // window-local variables + FOR_ALL_TAB_WINDOWS(tp, wp) + abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, + NULL, NULL); + if (aucmd_win != NULL) + abort = abort || set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID, + NULL, NULL); +#ifdef FEAT_PROP_POPUP + FOR_ALL_POPUPWINS(wp) + abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, + NULL, NULL); + FOR_ALL_TABPAGES(tp) + FOR_ALL_POPUPWINS_IN_TAB(tp, wp) + abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, + NULL, NULL); +#endif + + // tabpage-local variables + FOR_ALL_TABPAGES(tp) + abort = abort || set_ref_in_item(&tp->tp_winvar.di_tv, copyID, + NULL, NULL); + // global variables + abort = abort || garbage_collect_globvars(copyID); + + // function-local variables + abort = abort || set_ref_in_call_stack(copyID); + + // named functions (matters for closures) + abort = abort || set_ref_in_functions(copyID); + + // function call arguments, if v:testing is set. + abort = abort || set_ref_in_func_args(copyID); + + // v: vars + abort = abort || garbage_collect_vimvars(copyID); + + // callbacks in buffers + abort = abort || set_ref_in_buffers(copyID); + +#ifdef FEAT_LUA + abort = abort || set_ref_in_lua(copyID); +#endif + +#ifdef FEAT_PYTHON + abort = abort || set_ref_in_python(copyID); +#endif + +#ifdef FEAT_PYTHON3 + abort = abort || set_ref_in_python3(copyID); +#endif + +#ifdef FEAT_JOB_CHANNEL + abort = abort || set_ref_in_channel(copyID); + abort = abort || set_ref_in_job(copyID); +#endif +#ifdef FEAT_NETBEANS_INTG + abort = abort || set_ref_in_nb_channel(copyID); +#endif + +#ifdef FEAT_TIMERS + abort = abort || set_ref_in_timer(copyID); +#endif + +#ifdef FEAT_QUICKFIX + abort = abort || set_ref_in_quickfix(copyID); +#endif + +#ifdef FEAT_TERMINAL + abort = abort || set_ref_in_term(copyID); +#endif + +#ifdef FEAT_PROP_POPUP + abort = abort || set_ref_in_popups(copyID); +#endif + + if (!abort) + { + /* + * 2. Free lists and dictionaries that are not referenced. + */ + did_free = free_unref_items(copyID); + + /* + * 3. Check if any funccal can be freed now. + * This may call us back recursively. + */ + free_unref_funccal(copyID, testing); + } + else if (p_verbose > 0) + { + verb_msg(_("Not enough memory to set references, garbage collection aborted!")); + } + + return did_free; +} + +/* + * Free lists, dictionaries, channels and jobs that are no longer referenced. + */ + static int +free_unref_items(int copyID) +{ + int did_free = FALSE; + + // Let all "free" functions know that we are here. This means no + // dictionaries, lists, channels or jobs are to be freed, because we will + // do that here. + in_free_unref_items = TRUE; + + /* + * PASS 1: free the contents of the items. We don't free the items + * themselves yet, so that it is possible to decrement refcount counters + */ + + // Go through the list of dicts and free items without the copyID. + did_free |= dict_free_nonref(copyID); + + // Go through the list of lists and free items without the copyID. + did_free |= list_free_nonref(copyID); + +#ifdef FEAT_JOB_CHANNEL + // Go through the list of jobs and free items without the copyID. This + // must happen before doing channels, because jobs refer to channels, but + // the reference from the channel to the job isn't tracked. + did_free |= free_unused_jobs_contents(copyID, COPYID_MASK); + + // Go through the list of channels and free items without the copyID. + did_free |= free_unused_channels_contents(copyID, COPYID_MASK); +#endif + + /* + * PASS 2: free the items themselves. + */ + dict_free_items(copyID); + list_free_items(copyID); + +#ifdef FEAT_JOB_CHANNEL + // Go through the list of jobs and free items without the copyID. This + // must happen before doing channels, because jobs refer to channels, but + // the reference from the channel to the job isn't tracked. + free_unused_jobs(copyID, COPYID_MASK); + + // Go through the list of channels and free items without the copyID. + free_unused_channels(copyID, COPYID_MASK); +#endif + + in_free_unref_items = FALSE; + + return did_free; +} + +/* + * Mark all lists and dicts referenced through hashtab "ht" with "copyID". + * "list_stack" is used to add lists to be marked. Can be NULL. + * + * Returns TRUE if setting references failed somehow. + */ + int +set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack) +{ + int todo; + int abort = FALSE; + hashitem_T *hi; + hashtab_T *cur_ht; + ht_stack_T *ht_stack = NULL; + ht_stack_T *tempitem; + + cur_ht = ht; + for (;;) + { + if (!abort) + { + // Mark each item in the hashtab. If the item contains a hashtab + // it is added to ht_stack, if it contains a list it is added to + // list_stack. + todo = (int)cur_ht->ht_used; + for (hi = cur_ht->ht_array; todo > 0; ++hi) + if (!HASHITEM_EMPTY(hi)) + { + --todo; + abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID, + &ht_stack, list_stack); + } + } + + if (ht_stack == NULL) + break; + + // take an item from the stack + cur_ht = ht_stack->ht; + tempitem = ht_stack; + ht_stack = ht_stack->prev; + free(tempitem); + } + + return abort; +} + +/* + * Mark a dict and its items with "copyID". + * Returns TRUE if setting references failed somehow. + */ + int +set_ref_in_dict(dict_T *d, int copyID) +{ + if (d != NULL && d->dv_copyID != copyID) + { + d->dv_copyID = copyID; + return set_ref_in_ht(&d->dv_hashtab, copyID, NULL); + } + return FALSE; +} + +/* + * Mark a list and its items with "copyID". + * Returns TRUE if setting references failed somehow. + */ + int +set_ref_in_list(list_T *ll, int copyID) +{ + if (ll != NULL && ll->lv_copyID != copyID) + { + ll->lv_copyID = copyID; + return set_ref_in_list_items(ll, copyID, NULL); + } + return FALSE; +} + +/* + * Mark all lists and dicts referenced through list "l" with "copyID". + * "ht_stack" is used to add hashtabs to be marked. Can be NULL. + * + * Returns TRUE if setting references failed somehow. + */ + int +set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack) +{ + listitem_T *li; + int abort = FALSE; + list_T *cur_l; + list_stack_T *list_stack = NULL; + list_stack_T *tempitem; + + cur_l = l; + for (;;) + { + if (!abort && cur_l->lv_first != &range_list_item) + // Mark each item in the list. If the item contains a hashtab + // it is added to ht_stack, if it contains a list it is added to + // list_stack. + for (li = cur_l->lv_first; !abort && li != NULL; li = li->li_next) + abort = abort || set_ref_in_item(&li->li_tv, copyID, + ht_stack, &list_stack); + if (list_stack == NULL) + break; + + // take an item from the stack + cur_l = list_stack->list; + tempitem = list_stack; + list_stack = list_stack->prev; + free(tempitem); + } + + return abort; +} + +/* + * Mark all lists and dicts referenced through typval "tv" with "copyID". + * "list_stack" is used to add lists to be marked. Can be NULL. + * "ht_stack" is used to add hashtabs to be marked. Can be NULL. + * + * Returns TRUE if setting references failed somehow. + */ + int +set_ref_in_item( + typval_T *tv, + int copyID, + ht_stack_T **ht_stack, + list_stack_T **list_stack) +{ + int abort = FALSE; + + if (tv->v_type == VAR_DICT) + { + dict_T *dd = tv->vval.v_dict; + + if (dd != NULL && dd->dv_copyID != copyID) + { + // Didn't see this dict yet. + dd->dv_copyID = copyID; + if (ht_stack == NULL) + { + abort = set_ref_in_ht(&dd->dv_hashtab, copyID, list_stack); + } + else + { + ht_stack_T *newitem = ALLOC_ONE(ht_stack_T); + + if (newitem == NULL) + abort = TRUE; + else + { + newitem->ht = &dd->dv_hashtab; + newitem->prev = *ht_stack; + *ht_stack = newitem; + } + } + } + } + else if (tv->v_type == VAR_LIST) + { + list_T *ll = tv->vval.v_list; + + if (ll != NULL && ll->lv_copyID != copyID) + { + // Didn't see this list yet. + ll->lv_copyID = copyID; + if (list_stack == NULL) + { + abort = set_ref_in_list_items(ll, copyID, ht_stack); + } + else + { + list_stack_T *newitem = ALLOC_ONE(list_stack_T); + + if (newitem == NULL) + abort = TRUE; + else + { + newitem->list = ll; + newitem->prev = *list_stack; + *list_stack = newitem; + } + } + } + } + else if (tv->v_type == VAR_FUNC) + { + abort = set_ref_in_func(tv->vval.v_string, NULL, copyID); + } + else if (tv->v_type == VAR_PARTIAL) + { + partial_T *pt = tv->vval.v_partial; + int i; + + if (pt != NULL && pt->pt_copyID != copyID) + { + // Didn't see this partial yet. + pt->pt_copyID = copyID; + + abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID); + + if (pt->pt_dict != NULL) + { + typval_T dtv; + + dtv.v_type = VAR_DICT; + dtv.vval.v_dict = pt->pt_dict; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + + for (i = 0; i < pt->pt_argc; ++i) + abort = abort || set_ref_in_item(&pt->pt_argv[i], copyID, + ht_stack, list_stack); + if (pt->pt_funcstack != NULL) + { + typval_T *stack = pt->pt_funcstack->fs_ga.ga_data; + + for (i = 0; i < pt->pt_funcstack->fs_ga.ga_len; ++i) + abort = abort || set_ref_in_item(stack + i, copyID, + ht_stack, list_stack); + } + + } + } +#ifdef FEAT_JOB_CHANNEL + else if (tv->v_type == VAR_JOB) + { + job_T *job = tv->vval.v_job; + typval_T dtv; + + if (job != NULL && job->jv_copyID != copyID) + { + job->jv_copyID = copyID; + if (job->jv_channel != NULL) + { + dtv.v_type = VAR_CHANNEL; + dtv.vval.v_channel = job->jv_channel; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + if (job->jv_exit_cb.cb_partial != NULL) + { + dtv.v_type = VAR_PARTIAL; + dtv.vval.v_partial = job->jv_exit_cb.cb_partial; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + } + } + else if (tv->v_type == VAR_CHANNEL) + { + channel_T *ch =tv->vval.v_channel; + ch_part_T part; + typval_T dtv; + jsonq_T *jq; + cbq_T *cq; + + if (ch != NULL && ch->ch_copyID != copyID) + { + ch->ch_copyID = copyID; + for (part = PART_SOCK; part < PART_COUNT; ++part) + { + for (jq = ch->ch_part[part].ch_json_head.jq_next; jq != NULL; + jq = jq->jq_next) + set_ref_in_item(jq->jq_value, copyID, ht_stack, list_stack); + for (cq = ch->ch_part[part].ch_cb_head.cq_next; cq != NULL; + cq = cq->cq_next) + if (cq->cq_callback.cb_partial != NULL) + { + dtv.v_type = VAR_PARTIAL; + dtv.vval.v_partial = cq->cq_callback.cb_partial; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + if (ch->ch_part[part].ch_callback.cb_partial != NULL) + { + dtv.v_type = VAR_PARTIAL; + dtv.vval.v_partial = + ch->ch_part[part].ch_callback.cb_partial; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + } + if (ch->ch_callback.cb_partial != NULL) + { + dtv.v_type = VAR_PARTIAL; + dtv.vval.v_partial = ch->ch_callback.cb_partial; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + if (ch->ch_close_cb.cb_partial != NULL) + { + dtv.v_type = VAR_PARTIAL; + dtv.vval.v_partial = ch->ch_close_cb.cb_partial; + set_ref_in_item(&dtv, copyID, ht_stack, list_stack); + } + } + } +#endif + return abort; +} + +/* + * Return a string with the string representation of a variable. + * If the memory is allocated "tofree" is set to it, otherwise NULL. + * "numbuf" is used for a number. + * When "copyID" is not NULL replace recursive lists and dicts with "...". + * When both "echo_style" and "composite_val" are FALSE, put quotes around + * strings as "string()", otherwise does not put quotes around strings, as + * ":echo" displays values. + * When "restore_copyID" is FALSE, repeated items in dictionaries and lists + * are replaced with "...". + * May return NULL. + */ + char_u * +echo_string_core( + typval_T *tv, + char_u **tofree, + char_u *numbuf, + int copyID, + int echo_style, + int restore_copyID, + int composite_val) +{ + static int recurse = 0; + char_u *r = NULL; + + if (recurse >= DICT_MAXNEST) + { + if (!did_echo_string_emsg) + { + // Only give this message once for a recursive call to avoid + // flooding the user with errors. And stop iterating over lists + // and dicts. + did_echo_string_emsg = TRUE; + emsg(_("E724: variable nested too deep for displaying")); + } + *tofree = NULL; + return (char_u *)"{E724}"; + } + ++recurse; + + switch (tv->v_type) + { + case VAR_STRING: + if (echo_style && !composite_val) + { + *tofree = NULL; + r = tv->vval.v_string; + if (r == NULL) + r = (char_u *)""; + } + else + { + *tofree = string_quote(tv->vval.v_string, FALSE); + r = *tofree; + } + break; + + case VAR_FUNC: + if (echo_style) + { + *tofree = NULL; + r = tv->vval.v_string; + } + else + { + *tofree = string_quote(tv->vval.v_string, TRUE); + r = *tofree; + } + break; + + case VAR_PARTIAL: + { + partial_T *pt = tv->vval.v_partial; + char_u *fname = string_quote(pt == NULL ? NULL + : partial_name(pt), FALSE); + garray_T ga; + int i; + char_u *tf; + + ga_init2(&ga, 1, 100); + ga_concat(&ga, (char_u *)"function("); + if (fname != NULL) + { + ga_concat(&ga, fname); + vim_free(fname); + } + if (pt != NULL && pt->pt_argc > 0) + { + ga_concat(&ga, (char_u *)", ["); + for (i = 0; i < pt->pt_argc; ++i) + { + if (i > 0) + ga_concat(&ga, (char_u *)", "); + ga_concat(&ga, + tv2string(&pt->pt_argv[i], &tf, numbuf, copyID)); + vim_free(tf); + } + ga_concat(&ga, (char_u *)"]"); + } + if (pt != NULL && pt->pt_dict != NULL) + { + typval_T dtv; + + ga_concat(&ga, (char_u *)", "); + dtv.v_type = VAR_DICT; + dtv.vval.v_dict = pt->pt_dict; + ga_concat(&ga, tv2string(&dtv, &tf, numbuf, copyID)); + vim_free(tf); + } + ga_concat(&ga, (char_u *)")"); + + *tofree = ga.ga_data; + r = *tofree; + break; + } + + case VAR_BLOB: + r = blob2string(tv->vval.v_blob, tofree, numbuf); + break; + + case VAR_LIST: + if (tv->vval.v_list == NULL) + { + // NULL list is equivalent to empty list. + *tofree = NULL; + r = (char_u *)"[]"; + } + else if (copyID != 0 && tv->vval.v_list->lv_copyID == copyID + && tv->vval.v_list->lv_len > 0) + { + *tofree = NULL; + r = (char_u *)"[...]"; + } + else + { + int old_copyID = tv->vval.v_list->lv_copyID; + + tv->vval.v_list->lv_copyID = copyID; + *tofree = list2string(tv, copyID, restore_copyID); + if (restore_copyID) + tv->vval.v_list->lv_copyID = old_copyID; + r = *tofree; + } + break; + + case VAR_DICT: + if (tv->vval.v_dict == NULL) + { + // NULL dict is equivalent to empty dict. + *tofree = NULL; + r = (char_u *)"{}"; + } + else if (copyID != 0 && tv->vval.v_dict->dv_copyID == copyID + && tv->vval.v_dict->dv_hashtab.ht_used != 0) + { + *tofree = NULL; + r = (char_u *)"{...}"; + } + else + { + int old_copyID = tv->vval.v_dict->dv_copyID; + + tv->vval.v_dict->dv_copyID = copyID; + *tofree = dict2string(tv, copyID, restore_copyID); + if (restore_copyID) + tv->vval.v_dict->dv_copyID = old_copyID; + r = *tofree; + } + break; + + case VAR_NUMBER: + case VAR_UNKNOWN: + case VAR_ANY: + case VAR_VOID: + *tofree = NULL; + r = tv_get_string_buf(tv, numbuf); + break; + + case VAR_JOB: + case VAR_CHANNEL: + *tofree = NULL; + r = tv_get_string_buf(tv, numbuf); + if (composite_val) + { + *tofree = string_quote(r, FALSE); + r = *tofree; + } + break; + + case VAR_FLOAT: +#ifdef FEAT_FLOAT + *tofree = NULL; + vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float); + r = numbuf; + break; +#endif + + case VAR_BOOL: + case VAR_SPECIAL: + *tofree = NULL; + r = (char_u *)get_var_special_name(tv->vval.v_number); + break; + } + + if (--recurse == 0) + did_echo_string_emsg = FALSE; + return r; +} + +/* + * Return a string with the string representation of a variable. + * If the memory is allocated "tofree" is set to it, otherwise NULL. + * "numbuf" is used for a number. + * Does not put quotes around strings, as ":echo" displays values. + * When "copyID" is not NULL replace recursive lists and dicts with "...". + * May return NULL. + */ + char_u * +echo_string( + typval_T *tv, + char_u **tofree, + char_u *numbuf, + int copyID) +{ + return echo_string_core(tv, tofree, numbuf, copyID, TRUE, FALSE, FALSE); +} + +/* + * Return string "str" in ' quotes, doubling ' characters. + * If "str" is NULL an empty string is assumed. + * If "function" is TRUE make it function('string'). + */ + char_u * +string_quote(char_u *str, int function) +{ + unsigned len; + char_u *p, *r, *s; + + len = (function ? 13 : 3); + if (str != NULL) + { + len += (unsigned)STRLEN(str); + for (p = str; *p != NUL; MB_PTR_ADV(p)) + if (*p == '\'') + ++len; + } + s = r = alloc(len); + if (r != NULL) + { + if (function) + { + STRCPY(r, "function('"); + r += 10; + } + else + *r++ = '\''; + if (str != NULL) + for (p = str; *p != NUL; ) + { + if (*p == '\'') + *r++ = '\''; + MB_COPY_CHAR(p, r); + } + *r++ = '\''; + if (function) + *r++ = ')'; + *r++ = NUL; + } + return s; +} + +#if defined(FEAT_FLOAT) || defined(PROTO) +/* + * Convert the string "text" to a floating point number. + * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure + * this always uses a decimal point. + * Returns the length of the text that was consumed. + */ + int +string2float( + char_u *text, + float_T *value) // result stored here +{ + char *s = (char *)text; + float_T f; + + // MS-Windows does not deal with "inf" and "nan" properly. + if (STRNICMP(text, "inf", 3) == 0) + { + *value = INFINITY; + return 3; + } + if (STRNICMP(text, "-inf", 3) == 0) + { + *value = -INFINITY; + return 4; + } + if (STRNICMP(text, "nan", 3) == 0) + { + *value = NAN; + return 3; + } + f = strtod(s, &s); + *value = f; + return (int)((char_u *)s - text); +} +#endif + +/* + * Convert the specified byte index of line 'lnum' in buffer 'buf' to a + * character index. Works only for loaded buffers. Returns -1 on failure. + * The index of the first byte and the first character is zero. + */ + int +buf_byteidx_to_charidx(buf_T *buf, int lnum, int byteidx) +{ + char_u *str; + char_u *t; + int count; + + if (buf == NULL || buf->b_ml.ml_mfp == NULL) + return -1; + + if (lnum > buf->b_ml.ml_line_count) + lnum = buf->b_ml.ml_line_count; + + str = ml_get_buf(buf, lnum, FALSE); + if (str == NULL) + return -1; + + if (*str == NUL) + return 0; + + // count the number of characters + t = str; + for (count = 0; *t != NUL && t <= str + byteidx; count++) + t += mb_ptr2len(t); + + // In insert mode, when the cursor is at the end of a non-empty line, + // byteidx points to the NUL character immediately past the end of the + // string. In this case, add one to the character count. + if (*t == NUL && byteidx != 0 && t == str + byteidx) + count++; + + return count - 1; +} + +/* + * Convert the specified character index of line 'lnum' in buffer 'buf' to a + * byte index. Works only for loaded buffers. Returns -1 on failure. + * The index of the first byte and the first character is zero. + */ + int +buf_charidx_to_byteidx(buf_T *buf, int lnum, int charidx) +{ + char_u *str; + char_u *t; + + if (buf == NULL || buf->b_ml.ml_mfp == NULL) + return -1; + + if (lnum > buf->b_ml.ml_line_count) + lnum = buf->b_ml.ml_line_count; + + str = ml_get_buf(buf, lnum, FALSE); + if (str == NULL) + return -1; + + // Convert the character offset to a byte offset + t = str; + while (*t != NUL && --charidx > 0) + t += mb_ptr2len(t); + + return t - str; +} + +/* + * Translate a String variable into a position. + * Returns NULL when there is an error. + */ + pos_T * +var2fpos( + typval_T *varp, + int dollar_lnum, // TRUE when $ is last line + int *fnum, // set to fnum for '0, 'A, etc. + int charcol) // return character column +{ + char_u *name; + static pos_T pos; + pos_T *pp; + + // Argument can be [lnum, col, coladd]. + if (varp->v_type == VAR_LIST) + { + list_T *l; + int len; + int error = FALSE; + listitem_T *li; + + l = varp->vval.v_list; + if (l == NULL) + return NULL; + + // Get the line number + pos.lnum = list_find_nr(l, 0L, &error); + if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count) + return NULL; // invalid line number + if (charcol) + len = (long)mb_charlen(ml_get(pos.lnum)); + else + len = (long)STRLEN(ml_get(pos.lnum)); + + // Get the column number + // We accept "$" for the column number: last column. + li = list_find(l, 1L); + if (li != NULL && li->li_tv.v_type == VAR_STRING + && li->li_tv.vval.v_string != NULL + && STRCMP(li->li_tv.vval.v_string, "$") == 0) + { + pos.col = len + 1; + } + else + { + pos.col = list_find_nr(l, 1L, &error); + if (error) + return NULL; + } + + // Accept a position up to the NUL after the line. + if (pos.col == 0 || (int)pos.col > len + 1) + return NULL; // invalid column number + --pos.col; + + // Get the virtual offset. Defaults to zero. + pos.coladd = list_find_nr(l, 2L, &error); + if (error) + pos.coladd = 0; + + return &pos; + } + + name = tv_get_string_chk(varp); + if (name == NULL) + return NULL; + if (name[0] == '.') // cursor + { + pos = curwin->w_cursor; + if (charcol) + pos.col = buf_byteidx_to_charidx(curbuf, pos.lnum, pos.col); + return &pos; + } + if (name[0] == 'v' && name[1] == NUL) // Visual start + { + if (VIsual_active) + pos = VIsual; + else + pos = curwin->w_cursor; + if (charcol) + pos.col = buf_byteidx_to_charidx(curbuf, pos.lnum, pos.col); + return &pos; + } + if (name[0] == '\'') // mark + { + pp = getmark_buf_fnum(curbuf, name[1], FALSE, fnum); + if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0) + return NULL; + if (charcol) + pp->col = buf_byteidx_to_charidx(curbuf, pp->lnum, pp->col); + return pp; + } + + pos.coladd = 0; + + if (name[0] == 'w' && dollar_lnum) + { + pos.col = 0; + if (name[1] == '0') // "w0": first visible line + { + update_topline(); + // In silent Ex mode topline is zero, but that's not a valid line + // number; use one instead. + pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1; + return &pos; + } + else if (name[1] == '$') // "w$": last visible line + { + validate_botline(); + // In silent Ex mode botline is zero, return zero then. + pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0; + return &pos; + } + } + else if (name[0] == '$') // last column or line + { + if (dollar_lnum) + { + pos.lnum = curbuf->b_ml.ml_line_count; + pos.col = 0; + } + else + { + pos.lnum = curwin->w_cursor.lnum; + if (charcol) + pos.col = (colnr_T)mb_charlen(ml_get_curline()); + else + pos.col = (colnr_T)STRLEN(ml_get_curline()); + } + return &pos; + } + return NULL; +} + +/* + * Convert list in "arg" into a position and optional file number. + * When "fnump" is NULL there is no file number, only 3 items. + * Note that the column is passed on as-is, the caller may want to decrement + * it to use 1 for the first column. + * Return FAIL when conversion is not possible, doesn't check the position for + * validity. + */ + int +list2fpos( + typval_T *arg, + pos_T *posp, + int *fnump, + colnr_T *curswantp, + int charcol) +{ + list_T *l = arg->vval.v_list; + long i = 0; + long n; + + // List must be: [fnum, lnum, col, coladd, curswant], where "fnum" is only + // there when "fnump" isn't NULL; "coladd" and "curswant" are optional. + if (arg->v_type != VAR_LIST + || l == NULL + || l->lv_len < (fnump == NULL ? 2 : 3) + || l->lv_len > (fnump == NULL ? 4 : 5)) + return FAIL; + + if (fnump != NULL) + { + n = list_find_nr(l, i++, NULL); // fnum + if (n < 0) + return FAIL; + if (n == 0) + n = curbuf->b_fnum; // current buffer + *fnump = n; + } + + n = list_find_nr(l, i++, NULL); // lnum + if (n < 0) + return FAIL; + posp->lnum = n; + + n = list_find_nr(l, i++, NULL); // col + if (n < 0) + return FAIL; + // If character position is specified, then convert to byte position + if (charcol) + { + buf_T *buf; + + // Get the text for the specified line in a loaded buffer + buf = buflist_findnr(fnump == NULL ? curbuf->b_fnum : *fnump); + if (buf == NULL || buf->b_ml.ml_mfp == NULL) + return FAIL; + + n = buf_charidx_to_byteidx(buf, posp->lnum, n) + 1; + } + posp->col = n; + + n = list_find_nr(l, i, NULL); // off + if (n < 0) + posp->coladd = 0; + else + posp->coladd = n; + + if (curswantp != NULL) + *curswantp = list_find_nr(l, i + 1, NULL); // curswant + + return OK; +} + +/* + * Get the length of an environment variable name. + * Advance "arg" to the first character after the name. + * Return 0 for error. + */ + int +get_env_len(char_u **arg) +{ + char_u *p; + int len; + + for (p = *arg; vim_isIDc(*p); ++p) + ; + if (p == *arg) // no name found + return 0; + + len = (int)(p - *arg); + *arg = p; + return len; +} + +/* + * Get the length of the name of a function or internal variable. + * "arg" is advanced to after the name. + * Return 0 if something is wrong. + */ + int +get_id_len(char_u **arg) +{ + char_u *p; + int len; + + // Find the end of the name. + for (p = *arg; eval_isnamec(*p); ++p) + { + if (*p == ':') + { + // "s:" is start of "s:var", but "n:" is not and can be used in + // slice "[n:]". Also "xx:" is not a namespace. + len = (int)(p - *arg); + if ((len == 1 && vim_strchr(NAMESPACE_CHAR, **arg) == NULL) + || len > 1) + break; + } + } + if (p == *arg) // no name found + return 0; + + len = (int)(p - *arg); + *arg = p; + + return len; +} + +/* + * Get the length of the name of a variable or function. + * Only the name is recognized, does not handle ".key" or "[idx]". + * "arg" is advanced to the first non-white character after the name. + * Return -1 if curly braces expansion failed. + * Return 0 if something else is wrong. + * If the name contains 'magic' {}'s, expand them and return the + * expanded name in an allocated string via 'alias' - caller must free. + */ + int +get_name_len( + char_u **arg, + char_u **alias, + int evaluate, + int verbose) +{ + int len; + char_u *p; + char_u *expr_start; + char_u *expr_end; + + *alias = NULL; // default to no alias + + if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA + && (*arg)[2] == (int)KE_SNR) + { + // hard coded <SNR>, already translated + *arg += 3; + return get_id_len(arg) + 3; + } + len = eval_fname_script(*arg); + if (len > 0) + { + // literal "<SID>", "s:" or "<SNR>" + *arg += len; + } + + /* + * Find the end of the name; check for {} construction. + */ + p = find_name_end(*arg, &expr_start, &expr_end, + len > 0 ? 0 : FNE_CHECK_START); + if (expr_start != NULL) + { + char_u *temp_string; + + if (!evaluate) + { + len += (int)(p - *arg); + *arg = skipwhite(p); + return len; + } + + /* + * Include any <SID> etc in the expanded string: + * Thus the -len here. + */ + temp_string = make_expanded_name(*arg - len, expr_start, expr_end, p); + if (temp_string == NULL) + return -1; + *alias = temp_string; + *arg = skipwhite(p); + return (int)STRLEN(temp_string); + } + + len += get_id_len(arg); + // Only give an error when there is something, otherwise it will be + // reported at a higher level. + if (len == 0 && verbose && **arg != NUL) + semsg(_(e_invexpr2), *arg); + + return len; +} + +/* + * Find the end of a variable or function name, taking care of magic braces. + * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the + * start and end of the first magic braces item. + * "flags" can have FNE_INCL_BR and FNE_CHECK_START. + * Return a pointer to just after the name. Equal to "arg" if there is no + * valid name. + */ + char_u * +find_name_end( + char_u *arg, + char_u **expr_start, + char_u **expr_end, + int flags) +{ + int mb_nest = 0; + int br_nest = 0; + char_u *p; + int len; + int vim9script = in_vim9script(); + + if (expr_start != NULL) + { + *expr_start = NULL; + *expr_end = NULL; + } + + // Quick check for valid starting character. + if ((flags & FNE_CHECK_START) && !eval_isnamec1(*arg) + && (*arg != '{' || vim9script)) + return arg; + + for (p = arg; *p != NUL + && (eval_isnamec(*p) + || (*p == '{' && !vim9script) + || ((flags & FNE_INCL_BR) && (*p == '[' + || (*p == '.' && eval_isdictc(p[1])))) + || mb_nest != 0 + || br_nest != 0); MB_PTR_ADV(p)) + { + if (*p == '\'') + { + // skip over 'string' to avoid counting [ and ] inside it. + for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p)) + ; + if (*p == NUL) + break; + } + else if (*p == '"') + { + // skip over "str\"ing" to avoid counting [ and ] inside it. + for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p)) + if (*p == '\\' && p[1] != NUL) + ++p; + if (*p == NUL) + break; + } + else if (br_nest == 0 && mb_nest == 0 && *p == ':') + { + // "s:" is start of "s:var", but "n:" is not and can be used in + // slice "[n:]". Also "xx:" is not a namespace. But {ns}: is. + len = (int)(p - arg); + if ((len == 1 && vim_strchr(NAMESPACE_CHAR, *arg) == NULL) + || (len > 1 && p[-1] != '}')) + break; + } + + if (mb_nest == 0) + { + if (*p == '[') + ++br_nest; + else if (*p == ']') + --br_nest; + } + + if (br_nest == 0 && !vim9script) + { + if (*p == '{') + { + mb_nest++; + if (expr_start != NULL && *expr_start == NULL) + *expr_start = p; + } + else if (*p == '}') + { + mb_nest--; + if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL) + *expr_end = p; + } + } + } + + return p; +} + +/* + * Expands out the 'magic' {}'s in a variable/function name. + * Note that this can call itself recursively, to deal with + * constructs like foo{bar}{baz}{bam} + * The four pointer arguments point to "foo{expre}ss{ion}bar" + * "in_start" ^ + * "expr_start" ^ + * "expr_end" ^ + * "in_end" ^ + * + * Returns a new allocated string, which the caller must free. + * Returns NULL for failure. + */ + static char_u * +make_expanded_name( + char_u *in_start, + char_u *expr_start, + char_u *expr_end, + char_u *in_end) +{ + char_u c1; + char_u *retval = NULL; + char_u *temp_result; + + if (expr_end == NULL || in_end == NULL) + return NULL; + *expr_start = NUL; + *expr_end = NUL; + c1 = *in_end; + *in_end = NUL; + + temp_result = eval_to_string(expr_start + 1, FALSE); + if (temp_result != NULL) + { + retval = alloc(STRLEN(temp_result) + (expr_start - in_start) + + (in_end - expr_end) + 1); + if (retval != NULL) + { + STRCPY(retval, in_start); + STRCAT(retval, temp_result); + STRCAT(retval, expr_end + 1); + } + } + vim_free(temp_result); + + *in_end = c1; // put char back for error messages + *expr_start = '{'; + *expr_end = '}'; + + if (retval != NULL) + { + temp_result = find_name_end(retval, &expr_start, &expr_end, 0); + if (expr_start != NULL) + { + // Further expansion! + temp_result = make_expanded_name(retval, expr_start, + expr_end, temp_result); + vim_free(retval); + retval = temp_result; + } + } + + return retval; +} + +/* + * Return TRUE if character "c" can be used in a variable or function name. + * Does not include '{' or '}' for magic braces. + */ + int +eval_isnamec(int c) +{ + return ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR; +} + +/* + * Return TRUE if character "c" can be used as the first character in a + * variable or function name (excluding '{' and '}'). + */ + int +eval_isnamec1(int c) +{ + return ASCII_ISALPHA(c) || c == '_'; +} + +/* + * Return TRUE if character "c" can be used as the first character of a + * dictionary key. + */ + int +eval_isdictc(int c) +{ + return ASCII_ISALNUM(c) || c == '_'; +} + +/* + * Handle: + * - expr[expr], expr[expr:expr] subscript + * - ".name" lookup + * - function call with Funcref variable: func(expr) + * - method call: var->method() + * + * Can all be combined in any order: dict.func(expr)[idx]['func'](expr)->len() + */ + int +handle_subscript( + char_u **arg, + typval_T *rettv, + evalarg_T *evalarg, + int verbose) // give error messages +{ + int evaluate = evalarg != NULL + && (evalarg->eval_flags & EVAL_EVALUATE); + int ret = OK; + dict_T *selfdict = NULL; + int check_white = TRUE; + int getnext; + char_u *p; + + while (ret == OK) + { + // When at the end of the line and ".name" or "->{" or "->X" follows in + // the next line then consume the line break. + p = eval_next_non_blank(*arg, evalarg, &getnext); + if (getnext + && ((rettv->v_type == VAR_DICT && *p == '.' && eval_isdictc(p[1])) + || (p[0] == '-' && p[1] == '>' + && (p[2] == '{' || ASCII_ISALPHA(p[2]))))) + { + *arg = eval_next_line(evalarg); + p = *arg; + check_white = FALSE; + } + + if ((**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC + || rettv->v_type == VAR_PARTIAL)) + && (!check_white || !VIM_ISWHITE(*(*arg - 1)))) + { + ret = call_func_rettv(arg, evalarg, rettv, evaluate, + selfdict, NULL); + + // Stop the expression evaluation when immediately aborting on + // error, or when an interrupt occurred or an exception was thrown + // but not caught. + if (aborting()) + { + if (ret == OK) + clear_tv(rettv); + ret = FAIL; + } + dict_unref(selfdict); + selfdict = NULL; + } + else if (p[0] == '-' && p[1] == '>') + { + *arg = skipwhite(p + 2); + if (ret == OK) + { + if ((**arg == '{' && !in_vim9script()) || **arg == '(') + // expr->{lambda}() or expr->(lambda)() + ret = eval_lambda(arg, rettv, evalarg, verbose); + else + // expr->name() + ret = eval_method(arg, rettv, evalarg, verbose); + } + } + // "." is ".name" lookup when we found a dict or when evaluating and + // scriptversion is at least 2, where string concatenation is "..". + else if (**arg == '[' + || (**arg == '.' && (rettv->v_type == VAR_DICT + || (!evaluate + && (*arg)[1] != '.' + && current_sctx.sc_version >= 2)))) + { + dict_unref(selfdict); + if (rettv->v_type == VAR_DICT) + { + selfdict = rettv->vval.v_dict; + if (selfdict != NULL) + ++selfdict->dv_refcount; + } + else + selfdict = NULL; + if (eval_index(arg, rettv, evalarg, verbose) == FAIL) + { + clear_tv(rettv); + ret = FAIL; + } + } + else + break; + } + + // Turn "dict.Func" into a partial for "Func" bound to "dict". + // Don't do this when "Func" is already a partial that was bound + // explicitly (pt_auto is FALSE). + if (selfdict != NULL + && (rettv->v_type == VAR_FUNC + || (rettv->v_type == VAR_PARTIAL + && (rettv->vval.v_partial->pt_auto + || rettv->vval.v_partial->pt_dict == NULL)))) + selfdict = make_partial(selfdict, rettv); + + dict_unref(selfdict); + return ret; +} + +/* + * Make a copy of an item. + * Lists and Dictionaries are also copied. A deep copy if "deep" is set. + * For deepcopy() "copyID" is zero for a full copy or the ID for when a + * reference to an already copied list/dict can be used. + * Returns FAIL or OK. + */ + int +item_copy( + typval_T *from, + typval_T *to, + int deep, + int copyID) +{ + static int recurse = 0; + int ret = OK; + + if (recurse >= DICT_MAXNEST) + { + emsg(_("E698: variable nested too deep for making a copy")); + return FAIL; + } + ++recurse; + + switch (from->v_type) + { + case VAR_NUMBER: + case VAR_FLOAT: + case VAR_STRING: + case VAR_FUNC: + case VAR_PARTIAL: + case VAR_BOOL: + case VAR_SPECIAL: + case VAR_JOB: + case VAR_CHANNEL: + copy_tv(from, to); + break; + case VAR_LIST: + to->v_type = VAR_LIST; + to->v_lock = 0; + if (from->vval.v_list == NULL) + to->vval.v_list = NULL; + else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID) + { + // use the copy made earlier + to->vval.v_list = from->vval.v_list->lv_copylist; + ++to->vval.v_list->lv_refcount; + } + else + to->vval.v_list = list_copy(from->vval.v_list, deep, copyID); + if (to->vval.v_list == NULL) + ret = FAIL; + break; + case VAR_BLOB: + ret = blob_copy(from->vval.v_blob, to); + break; + case VAR_DICT: + to->v_type = VAR_DICT; + to->v_lock = 0; + if (from->vval.v_dict == NULL) + to->vval.v_dict = NULL; + else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID) + { + // use the copy made earlier + to->vval.v_dict = from->vval.v_dict->dv_copydict; + ++to->vval.v_dict->dv_refcount; + } + else + to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID); + if (to->vval.v_dict == NULL) + ret = FAIL; + break; + case VAR_UNKNOWN: + case VAR_ANY: + case VAR_VOID: + internal_error_no_abort("item_copy(UNKNOWN)"); + ret = FAIL; + } + --recurse; + return ret; +} + + void +echo_one(typval_T *rettv, int with_space, int *atstart, int *needclr) +{ + char_u *tofree; + char_u numbuf[NUMBUFLEN]; + char_u *p = echo_string(rettv, &tofree, numbuf, get_copyID()); + + if (*atstart) + { + *atstart = FALSE; + // Call msg_start() after eval1(), evaluating the expression + // may cause a message to appear. + if (with_space) + { + // Mark the saved text as finishing the line, so that what + // follows is displayed on a new line when scrolling back + // at the more prompt. + msg_sb_eol(); + msg_start(); + } + } + else if (with_space) + msg_puts_attr(" ", echo_attr); + + if (p != NULL) + for ( ; *p != NUL && !got_int; ++p) + { + if (*p == '\n' || *p == '\r' || *p == TAB) + { + if (*p != TAB && *needclr) + { + // remove any text still there from the command + msg_clr_eos(); + *needclr = FALSE; + } + msg_putchar_attr(*p, echo_attr); + } + else + { + if (has_mbyte) + { + int i = (*mb_ptr2len)(p); + + (void)msg_outtrans_len_attr(p, i, echo_attr); + p += i - 1; + } + else + (void)msg_outtrans_len_attr(p, 1, echo_attr); + } + } + vim_free(tofree); +} + +/* + * ":echo expr1 ..." print each argument separated with a space, add a + * newline at the end. + * ":echon expr1 ..." print each argument plain. + */ + void +ex_echo(exarg_T *eap) +{ + char_u *arg = eap->arg; + typval_T rettv; + char_u *p; + int needclr = TRUE; + int atstart = TRUE; + int did_emsg_before = did_emsg; + int called_emsg_before = called_emsg; + evalarg_T evalarg; + + fill_evalarg_from_eap(&evalarg, eap, eap->skip); + + if (eap->skip) + ++emsg_skip; + while ((!ends_excmd2(eap->cmd, arg) || *arg == '"') && !got_int) + { + // If eval1() causes an error message the text from the command may + // still need to be cleared. E.g., "echo 22,44". + need_clr_eos = needclr; + + p = arg; + if (eval1(&arg, &rettv, &evalarg) == FAIL) + { + /* + * Report the invalid expression unless the expression evaluation + * has been cancelled due to an aborting error, an interrupt, or an + * exception. + */ + if (!aborting() && did_emsg == did_emsg_before + && called_emsg == called_emsg_before) + semsg(_(e_invexpr2), p); + need_clr_eos = FALSE; + break; + } + need_clr_eos = FALSE; + + if (!eap->skip) + echo_one(&rettv, eap->cmdidx == CMD_echo, &atstart, &needclr); + + clear_tv(&rettv); + arg = skipwhite(arg); + } + eap->nextcmd = check_nextcmd(arg); + clear_evalarg(&evalarg, eap); + + if (eap->skip) + --emsg_skip; + else + { + // remove text that may still be there from the command + if (needclr) + msg_clr_eos(); + if (eap->cmdidx == CMD_echo) + msg_end(); + } +} + +/* + * ":echohl {name}". + */ + void +ex_echohl(exarg_T *eap) +{ + echo_attr = syn_name2attr(eap->arg); +} + +/* + * Returns the :echo attribute + */ + int +get_echo_attr(void) +{ + return echo_attr; +} + +/* + * ":execute expr1 ..." execute the result of an expression. + * ":echomsg expr1 ..." Print a message + * ":echoerr expr1 ..." Print an error + * Each gets spaces around each argument and a newline at the end for + * echo commands + */ + void +ex_execute(exarg_T *eap) +{ + char_u *arg = eap->arg; + typval_T rettv; + int ret = OK; + char_u *p; + garray_T ga; + int len; + + ga_init2(&ga, 1, 80); + + if (eap->skip) + ++emsg_skip; + while (!ends_excmd2(eap->cmd, arg) || *arg == '"') + { + ret = eval1_emsg(&arg, &rettv, eap); + if (ret == FAIL) + break; + + if (!eap->skip) + { + char_u buf[NUMBUFLEN]; + + if (eap->cmdidx == CMD_execute) + { + if (rettv.v_type == VAR_CHANNEL || rettv.v_type == VAR_JOB) + { + emsg(_(e_inval_string)); + p = NULL; + } + else + p = tv_get_string_buf(&rettv, buf); + } + else + p = tv_stringify(&rettv, buf); + if (p == NULL) + { + clear_tv(&rettv); + ret = FAIL; + break; + } + len = (int)STRLEN(p); + if (ga_grow(&ga, len + 2) == FAIL) + { + clear_tv(&rettv); + ret = FAIL; + break; + } + if (ga.ga_len) + ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; + STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); + ga.ga_len += len; + } + + clear_tv(&rettv); + arg = skipwhite(arg); + } + + if (ret != FAIL && ga.ga_data != NULL) + { + if (eap->cmdidx == CMD_echomsg || eap->cmdidx == CMD_echoerr) + { + // Mark the already saved text as finishing the line, so that what + // follows is displayed on a new line when scrolling back at the + // more prompt. + msg_sb_eol(); + } + + if (eap->cmdidx == CMD_echomsg) + { + msg_attr(ga.ga_data, echo_attr); + out_flush(); + } + else if (eap->cmdidx == CMD_echoerr) + { + int save_did_emsg = did_emsg; + + // We don't want to abort following commands, restore did_emsg. + emsg(ga.ga_data); + if (!force_abort) + did_emsg = save_did_emsg; + } + else if (eap->cmdidx == CMD_execute) + do_cmdline((char_u *)ga.ga_data, + eap->getline, eap->cookie, DOCMD_NOWAIT|DOCMD_VERBOSE); + } + + ga_clear(&ga); + + if (eap->skip) + --emsg_skip; + + eap->nextcmd = check_nextcmd(arg); +} + +/* + * Skip over the name of an option: "&option", "&g:option" or "&l:option". + * "arg" points to the "&" or '+' when called, to "option" when returning. + * Returns NULL when no option name found. Otherwise pointer to the char + * after the option name. + */ + char_u * +find_option_end(char_u **arg, int *opt_flags) +{ + char_u *p = *arg; + + ++p; + if (*p == 'g' && p[1] == ':') + { + *opt_flags = OPT_GLOBAL; + p += 2; + } + else if (*p == 'l' && p[1] == ':') + { + *opt_flags = OPT_LOCAL; + p += 2; + } + else + *opt_flags = 0; + + if (!ASCII_ISALPHA(*p)) + return NULL; + *arg = p; + + if (p[0] == 't' && p[1] == '_' && p[2] != NUL && p[3] != NUL) + p += 4; // termcap option + else + while (ASCII_ISALPHA(*p)) + ++p; + return p; +} + +/* + * Display script name where an item was last set. + * Should only be invoked when 'verbose' is non-zero. + */ + void +last_set_msg(sctx_T script_ctx) +{ + char_u *p; + + if (script_ctx.sc_sid != 0) + { + p = home_replace_save(NULL, get_scriptname(script_ctx.sc_sid)); + if (p != NULL) + { + verbose_enter(); + msg_puts(_("\n\tLast set from ")); + msg_puts((char *)p); + if (script_ctx.sc_lnum > 0) + { + msg_puts(_(line_msg)); + msg_outnum((long)script_ctx.sc_lnum); + } + verbose_leave(); + vim_free(p); + } + } +} + +#endif // FEAT_EVAL + +/* + * Perform a substitution on "str" with pattern "pat" and substitute "sub". + * When "sub" is NULL "expr" is used, must be a VAR_FUNC or VAR_PARTIAL. + * "flags" can be "g" to do a global substitute. + * Returns an allocated string, NULL for error. + */ + char_u * +do_string_sub( + char_u *str, + char_u *pat, + char_u *sub, + typval_T *expr, + char_u *flags) +{ + int sublen; + regmatch_T regmatch; + int i; + int do_all; + char_u *tail; + char_u *end; + garray_T ga; + char_u *ret; + char_u *save_cpo; + char_u *zero_width = NULL; + + // Make 'cpoptions' empty, so that the 'l' flag doesn't work here + save_cpo = p_cpo; + p_cpo = empty_option; + + ga_init2(&ga, 1, 200); + + do_all = (flags[0] == 'g'); + + regmatch.rm_ic = p_ic; + regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); + if (regmatch.regprog != NULL) + { + tail = str; + end = str + STRLEN(str); + while (vim_regexec_nl(®match, str, (colnr_T)(tail - str))) + { + // Skip empty match except for first match. + if (regmatch.startp[0] == regmatch.endp[0]) + { + if (zero_width == regmatch.startp[0]) + { + // avoid getting stuck on a match with an empty string + i = mb_ptr2len(tail); + mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, + (size_t)i); + ga.ga_len += i; + tail += i; + continue; + } + zero_width = regmatch.startp[0]; + } + + /* + * Get some space for a temporary buffer to do the substitution + * into. It will contain: + * - The text up to where the match is. + * - The substituted text. + * - The text after the match. + */ + sublen = vim_regsub(®match, sub, expr, tail, FALSE, TRUE, FALSE); + if (ga_grow(&ga, (int)((end - tail) + sublen - + (regmatch.endp[0] - regmatch.startp[0]))) == FAIL) + { + ga_clear(&ga); + break; + } + + // copy the text up to where the match is + i = (int)(regmatch.startp[0] - tail); + mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i); + // add the substituted text + (void)vim_regsub(®match, sub, expr, (char_u *)ga.ga_data + + ga.ga_len + i, TRUE, TRUE, FALSE); + ga.ga_len += i + sublen - 1; + tail = regmatch.endp[0]; + if (*tail == NUL) + break; + if (!do_all) + break; + } + + if (ga.ga_data != NULL) + STRCPY((char *)ga.ga_data + ga.ga_len, tail); + + vim_regfree(regmatch.regprog); + } + + ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data); + ga_clear(&ga); + if (p_cpo == empty_option) + p_cpo = save_cpo; + else + { + // Darn, evaluating {sub} expression or {expr} changed the value. + // If it's still empty it was changed and restored, need to restore in + // the complicated way. + if (*p_cpo == NUL) + set_option_value((char_u *)"cpo", 0L, save_cpo, 0); + free_string_option(save_cpo); + } + + return ret; +} |