Mercurial > vim
view src/evalvars.c @ 34021:46ebf4ffad49 v9.0.2186
patch 9.0.2186: LTCG compile error ARM64 for write_chars
Commit: https://github.com/vim/vim/commit/38bea30f53da8e4a8847407404597b255b20334e
Author: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Wed Dec 27 18:57:12 2023 +0100
patch 9.0.2186: LTCG compile error ARM64 for write_chars
Problem: LTCG compile error on Win/ARM64 for `write_chars()`
Solution: Explicitly initialise the storage to use data rather than BSS
(Saleem Abdulrasool)
win32: add a workaround for a LTCG issue on Windows ARM64
It appears that the implicit initialisation which would push `g_coords`
into BSS causes an aliasing issue with LTCG on ARM64. By explicitly
initialising the value, we use usual data storage but prevent the
aliasing. This allows the console version of VIM to run on Windows
ARM64 again.
fixes: #13453
closes: #13775
Signed-off-by: Saleem Abdulrasool <compnerd@compnerd.org>
Signed-off-by: Christian Brabandt <cb@256bit.org>
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Wed, 27 Dec 2023 19:15:03 +0100 |
| parents | ab6a70fad5b5 |
| children | 1629cc65d78d |
line wrap: on
line source
/* 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. */ /* * evalvars.c: functions for dealing with variables */ #include "vim.h" #if defined(FEAT_EVAL) || defined(PROTO) static dictitem_T globvars_var; // variable used for g: static dict_T globvardict; // Dictionary with g: variables #define globvarht globvardict.dv_hashtab /* * Old Vim variables such as "v:version" are also available without the "v:". * Also in functions. We need a special hashtable for them. */ static hashtab_T compat_hashtab; /* * Array to hold the value of v: variables. * The value is in a dictitem, so that it can also be used in the v: scope. * The reason to use this table anyway is for very quick access to the * variables with the VV_ defines. */ // values for vv_flags: #define VV_COMPAT 1 // compatible, also used without "v:" #define VV_RO 2 // read-only #define VV_RO_SBX 4 // read-only in the sandbox #define VV_NAME(s, t) s, {{t, 0, {0}}, 0, {0}} typedef struct vimvar vimvar_T; static struct vimvar { char *vv_name; // name of variable, without v: dictitem16_T vv_di; // value and name for key (max 16 chars!) type_T *vv_type; // type or NULL char vv_flags; // VV_COMPAT, VV_RO, VV_RO_SBX } vimvars[VV_LEN] = { // The order here must match the VV_ defines in vim.h! // Initializing a union does not work, leave tv.vval empty to get zero's. {VV_NAME("count", VAR_NUMBER), NULL, VV_COMPAT+VV_RO}, {VV_NAME("count1", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("prevcount", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("errmsg", VAR_STRING), NULL, VV_COMPAT}, {VV_NAME("warningmsg", VAR_STRING), NULL, 0}, {VV_NAME("statusmsg", VAR_STRING), NULL, 0}, {VV_NAME("shell_error", VAR_NUMBER), NULL, VV_COMPAT+VV_RO}, {VV_NAME("this_session", VAR_STRING), NULL, VV_COMPAT}, {VV_NAME("version", VAR_NUMBER), NULL, VV_COMPAT+VV_RO}, {VV_NAME("lnum", VAR_NUMBER), NULL, VV_RO_SBX}, {VV_NAME("termresponse", VAR_STRING), NULL, VV_RO}, {VV_NAME("fname", VAR_STRING), NULL, VV_RO}, {VV_NAME("lang", VAR_STRING), NULL, VV_RO}, {VV_NAME("lc_time", VAR_STRING), NULL, VV_RO}, {VV_NAME("ctype", VAR_STRING), NULL, VV_RO}, {VV_NAME("charconvert_from", VAR_STRING), NULL, VV_RO}, {VV_NAME("charconvert_to", VAR_STRING), NULL, VV_RO}, {VV_NAME("fname_in", VAR_STRING), NULL, VV_RO}, {VV_NAME("fname_out", VAR_STRING), NULL, VV_RO}, {VV_NAME("fname_new", VAR_STRING), NULL, VV_RO}, {VV_NAME("fname_diff", VAR_STRING), NULL, VV_RO}, {VV_NAME("cmdarg", VAR_STRING), NULL, VV_RO}, {VV_NAME("foldstart", VAR_NUMBER), NULL, VV_RO_SBX}, {VV_NAME("foldend", VAR_NUMBER), NULL, VV_RO_SBX}, {VV_NAME("folddashes", VAR_STRING), NULL, VV_RO_SBX}, {VV_NAME("foldlevel", VAR_NUMBER), NULL, VV_RO_SBX}, {VV_NAME("progname", VAR_STRING), NULL, VV_RO}, {VV_NAME("servername", VAR_STRING), NULL, VV_RO}, {VV_NAME("dying", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("exception", VAR_STRING), NULL, VV_RO}, {VV_NAME("throwpoint", VAR_STRING), NULL, VV_RO}, {VV_NAME("register", VAR_STRING), NULL, VV_RO}, {VV_NAME("cmdbang", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("insertmode", VAR_STRING), NULL, VV_RO}, {VV_NAME("val", VAR_UNKNOWN), NULL, VV_RO}, {VV_NAME("key", VAR_UNKNOWN), NULL, VV_RO}, {VV_NAME("profiling", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("fcs_reason", VAR_STRING), NULL, VV_RO}, {VV_NAME("fcs_choice", VAR_STRING), NULL, 0}, {VV_NAME("beval_bufnr", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("beval_winnr", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("beval_winid", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("beval_lnum", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("beval_col", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("beval_text", VAR_STRING), NULL, VV_RO}, {VV_NAME("scrollstart", VAR_STRING), NULL, 0}, {VV_NAME("swapname", VAR_STRING), NULL, VV_RO}, {VV_NAME("swapchoice", VAR_STRING), NULL, 0}, {VV_NAME("swapcommand", VAR_STRING), NULL, VV_RO}, {VV_NAME("char", VAR_STRING), NULL, 0}, {VV_NAME("mouse_win", VAR_NUMBER), NULL, 0}, {VV_NAME("mouse_winid", VAR_NUMBER), NULL, 0}, {VV_NAME("mouse_lnum", VAR_NUMBER), NULL, 0}, {VV_NAME("mouse_col", VAR_NUMBER), NULL, 0}, {VV_NAME("operator", VAR_STRING), NULL, VV_RO}, {VV_NAME("searchforward", VAR_NUMBER), NULL, 0}, {VV_NAME("hlsearch", VAR_NUMBER), NULL, 0}, {VV_NAME("oldfiles", VAR_LIST), &t_list_string, 0}, {VV_NAME("windowid", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("progpath", VAR_STRING), NULL, VV_RO}, {VV_NAME("completed_item", VAR_DICT), &t_dict_string, 0}, {VV_NAME("option_new", VAR_STRING), NULL, VV_RO}, {VV_NAME("option_old", VAR_STRING), NULL, VV_RO}, {VV_NAME("option_oldlocal", VAR_STRING), NULL, VV_RO}, {VV_NAME("option_oldglobal", VAR_STRING), NULL, VV_RO}, {VV_NAME("option_command", VAR_STRING), NULL, VV_RO}, {VV_NAME("option_type", VAR_STRING), NULL, VV_RO}, {VV_NAME("errors", VAR_LIST), &t_list_string, 0}, {VV_NAME("false", VAR_BOOL), NULL, VV_RO}, {VV_NAME("true", VAR_BOOL), NULL, VV_RO}, {VV_NAME("none", VAR_SPECIAL), NULL, VV_RO}, {VV_NAME("null", VAR_SPECIAL), NULL, VV_RO}, {VV_NAME("numbermax", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("numbermin", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("numbersize", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("vim_did_enter", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("testing", VAR_NUMBER), NULL, 0}, {VV_NAME("t_number", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_string", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_func", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_list", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_dict", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_float", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_bool", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_none", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_job", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_channel", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_blob", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_class", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_object", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("termrfgresp", VAR_STRING), NULL, VV_RO}, {VV_NAME("termrbgresp", VAR_STRING), NULL, VV_RO}, {VV_NAME("termu7resp", VAR_STRING), NULL, VV_RO}, {VV_NAME("termstyleresp", VAR_STRING), NULL, VV_RO}, {VV_NAME("termblinkresp", VAR_STRING), NULL, VV_RO}, {VV_NAME("event", VAR_DICT), NULL, VV_RO}, {VV_NAME("versionlong", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("echospace", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("argv", VAR_LIST), &t_list_string, VV_RO}, {VV_NAME("collate", VAR_STRING), NULL, VV_RO}, {VV_NAME("exiting", VAR_SPECIAL), NULL, VV_RO}, {VV_NAME("colornames", VAR_DICT), &t_dict_string, VV_RO}, {VV_NAME("sizeofint", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("sizeoflong", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("sizeofpointer", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("maxcol", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("python3_version", VAR_NUMBER), NULL, VV_RO}, {VV_NAME("t_typealias", VAR_NUMBER), NULL, VV_RO}, }; // shorthand #define vv_tv_type vv_di.di_tv.v_type #define vv_nr vv_di.di_tv.vval.v_number #define vv_float vv_di.di_tv.vval.v_float #define vv_str vv_di.di_tv.vval.v_string #define vv_list vv_di.di_tv.vval.v_list #define vv_dict vv_di.di_tv.vval.v_dict #define vv_blob vv_di.di_tv.vval.v_blob #define vv_tv vv_di.di_tv static dictitem_T vimvars_var; // variable used for v: static dict_T vimvardict; // Dictionary with v: variables #define vimvarht vimvardict.dv_hashtab // for VIM_VERSION_ defines #include "version.h" static void list_glob_vars(int *first); static void list_buf_vars(int *first); static void list_win_vars(int *first); static void list_tab_vars(int *first); static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first); static char_u *ex_let_one(char_u *arg, typval_T *tv, int copy, int flags, char_u *endchars, char_u *op, int var_idx); static int do_unlet_var(lval_T *lp, char_u *name_end, exarg_T *eap, int deep, void *cookie); static int do_lock_var(lval_T *lp, char_u *name_end, exarg_T *eap, int deep, void *cookie); static void list_one_var(dictitem_T *v, char *prefix, int *first); static void list_one_var_a(char *prefix, char_u *name, int type, char_u *string, int *first); /* * Initialize global and vim special variables */ void evalvars_init(void) { int i; struct vimvar *p; init_var_dict(&globvardict, &globvars_var, VAR_DEF_SCOPE); init_var_dict(&vimvardict, &vimvars_var, VAR_SCOPE); vimvardict.dv_lock = VAR_FIXED; hash_init(&compat_hashtab); for (i = 0; i < VV_LEN; ++i) { p = &vimvars[i]; if (STRLEN(p->vv_name) > DICTITEM16_KEY_LEN) { iemsg("Name too long, increase size of dictitem16_T"); getout(1); } STRCPY(p->vv_di.di_key, p->vv_name); if (p->vv_flags & VV_RO) p->vv_di.di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; else if (p->vv_flags & VV_RO_SBX) p->vv_di.di_flags = DI_FLAGS_RO_SBX | DI_FLAGS_FIX; else p->vv_di.di_flags = DI_FLAGS_FIX; // add to v: scope dict, unless the value is not always available if (p->vv_tv_type != VAR_UNKNOWN) hash_add(&vimvarht, p->vv_di.di_key, "initialization"); if (p->vv_flags & VV_COMPAT) // add to compat scope dict hash_add(&compat_hashtab, p->vv_di.di_key, "initialization"); } set_vim_var_nr(VV_VERSION, VIM_VERSION_100); set_vim_var_nr(VV_VERSIONLONG, VIM_VERSION_100 * 10000 + highest_patch()); set_vim_var_nr(VV_SEARCHFORWARD, 1L); set_vim_var_nr(VV_HLSEARCH, 1L); set_vim_var_nr(VV_EXITING, VVAL_NULL); set_vim_var_dict(VV_COMPLETED_ITEM, dict_alloc_lock(VAR_FIXED)); set_vim_var_list(VV_ERRORS, list_alloc()); set_vim_var_dict(VV_EVENT, dict_alloc_lock(VAR_FIXED)); set_vim_var_nr(VV_FALSE, VVAL_FALSE); set_vim_var_nr(VV_TRUE, VVAL_TRUE); set_vim_var_nr(VV_NONE, VVAL_NONE); set_vim_var_nr(VV_NULL, VVAL_NULL); set_vim_var_nr(VV_NUMBERMAX, VARNUM_MAX); set_vim_var_nr(VV_NUMBERMIN, VARNUM_MIN); set_vim_var_nr(VV_NUMBERSIZE, sizeof(varnumber_T) * 8); set_vim_var_nr(VV_SIZEOFINT, sizeof(int)); set_vim_var_nr(VV_SIZEOFLONG, sizeof(long)); set_vim_var_nr(VV_SIZEOFPOINTER, sizeof(char *)); set_vim_var_nr(VV_MAXCOL, MAXCOL); set_vim_var_nr(VV_TYPE_NUMBER, VAR_TYPE_NUMBER); set_vim_var_nr(VV_TYPE_STRING, VAR_TYPE_STRING); set_vim_var_nr(VV_TYPE_FUNC, VAR_TYPE_FUNC); set_vim_var_nr(VV_TYPE_LIST, VAR_TYPE_LIST); set_vim_var_nr(VV_TYPE_DICT, VAR_TYPE_DICT); set_vim_var_nr(VV_TYPE_FLOAT, VAR_TYPE_FLOAT); set_vim_var_nr(VV_TYPE_BOOL, VAR_TYPE_BOOL); set_vim_var_nr(VV_TYPE_NONE, VAR_TYPE_NONE); set_vim_var_nr(VV_TYPE_JOB, VAR_TYPE_JOB); set_vim_var_nr(VV_TYPE_CHANNEL, VAR_TYPE_CHANNEL); set_vim_var_nr(VV_TYPE_BLOB, VAR_TYPE_BLOB); set_vim_var_nr(VV_TYPE_CLASS, VAR_TYPE_CLASS); set_vim_var_nr(VV_TYPE_OBJECT, VAR_TYPE_OBJECT); set_vim_var_nr(VV_TYPE_TYPEALIAS, VAR_TYPE_TYPEALIAS); set_vim_var_nr(VV_ECHOSPACE, sc_col - 1); set_vim_var_dict(VV_COLORNAMES, dict_alloc()); #ifdef FEAT_PYTHON3 set_vim_var_nr(VV_PYTHON3_VERSION, python3_version()); #endif // Default for v:register is not 0 but '"'. This is adjusted once the // clipboard has been setup by calling reset_reg_var(). set_reg_var(0); } #if defined(EXITFREE) || defined(PROTO) /* * Free all vim variables information on exit */ void evalvars_clear(void) { int i; struct vimvar *p; for (i = 0; i < VV_LEN; ++i) { p = &vimvars[i]; if (p->vv_di.di_tv.v_type == VAR_STRING) VIM_CLEAR(p->vv_str); else if (p->vv_di.di_tv.v_type == VAR_LIST) { list_unref(p->vv_list); p->vv_list = NULL; } } hash_clear(&vimvarht); hash_init(&vimvarht); // garbage_collect() will access it hash_clear(&compat_hashtab); // global variables vars_clear(&globvarht); // Script-local variables. Clear all the variables here. // The scriptvar_T is cleared later in free_scriptnames(), because a // variable in one script might hold a reference to the whole scope of // another script. for (i = 1; i <= script_items.ga_len; ++i) vars_clear(&SCRIPT_VARS(i)); } #endif int garbage_collect_globvars(int copyID) { return set_ref_in_ht(&globvarht, copyID, NULL); } int garbage_collect_vimvars(int copyID) { return set_ref_in_ht(&vimvarht, copyID, NULL); } int garbage_collect_scriptvars(int copyID) { int i; int idx; int abort = FALSE; scriptitem_T *si; for (i = 1; i <= script_items.ga_len; ++i) { abort = abort || set_ref_in_ht(&SCRIPT_VARS(i), copyID, NULL); si = SCRIPT_ITEM(i); for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx) { svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; if (sv->sv_name != NULL) abort = abort || set_ref_in_item(sv->sv_tv, copyID, NULL, NULL); } } return abort; } /* * Set an internal variable to a string value. Creates the variable if it does * not already exist. */ void set_internal_string_var(char_u *name, char_u *value) { char_u *val; typval_T *tvp; val = vim_strsave(value); if (val == NULL) return; tvp = alloc_string_tv(val); if (tvp == NULL) return; set_var(name, tvp, FALSE); free_tv(tvp); } int eval_charconvert( char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to) { int err = FALSE; sctx_T saved_sctx = current_sctx; sctx_T *ctx; set_vim_var_string(VV_CC_FROM, enc_from, -1); set_vim_var_string(VV_CC_TO, enc_to, -1); set_vim_var_string(VV_FNAME_IN, fname_from, -1); set_vim_var_string(VV_FNAME_OUT, fname_to, -1); ctx = get_option_sctx("charconvert"); if (ctx != NULL) current_sctx = *ctx; if (eval_to_bool(p_ccv, &err, NULL, FALSE, TRUE)) err = TRUE; set_vim_var_string(VV_CC_FROM, NULL, -1); set_vim_var_string(VV_CC_TO, NULL, -1); set_vim_var_string(VV_FNAME_IN, NULL, -1); set_vim_var_string(VV_FNAME_OUT, NULL, -1); current_sctx = saved_sctx; if (err) return FAIL; return OK; } # if defined(FEAT_POSTSCRIPT) || defined(PROTO) int eval_printexpr(char_u *fname, char_u *args) { int err = FALSE; sctx_T saved_sctx = current_sctx; sctx_T *ctx; set_vim_var_string(VV_FNAME_IN, fname, -1); set_vim_var_string(VV_CMDARG, args, -1); ctx = get_option_sctx("printexpr"); if (ctx != NULL) current_sctx = *ctx; if (eval_to_bool(p_pexpr, &err, NULL, FALSE, TRUE)) err = TRUE; set_vim_var_string(VV_FNAME_IN, NULL, -1); set_vim_var_string(VV_CMDARG, NULL, -1); current_sctx = saved_sctx; if (err) { mch_remove(fname); return FAIL; } return OK; } # endif # if defined(FEAT_DIFF) || defined(PROTO) void eval_diff( char_u *origfile, char_u *newfile, char_u *outfile) { sctx_T saved_sctx = current_sctx; sctx_T *ctx; typval_T *tv; set_vim_var_string(VV_FNAME_IN, origfile, -1); set_vim_var_string(VV_FNAME_NEW, newfile, -1); set_vim_var_string(VV_FNAME_OUT, outfile, -1); ctx = get_option_sctx("diffexpr"); if (ctx != NULL) current_sctx = *ctx; // errors are ignored tv = eval_expr_ext(p_dex, NULL, TRUE); free_tv(tv); set_vim_var_string(VV_FNAME_IN, NULL, -1); set_vim_var_string(VV_FNAME_NEW, NULL, -1); set_vim_var_string(VV_FNAME_OUT, NULL, -1); current_sctx = saved_sctx; } void eval_patch( char_u *origfile, char_u *difffile, char_u *outfile) { sctx_T saved_sctx = current_sctx; sctx_T *ctx; typval_T *tv; set_vim_var_string(VV_FNAME_IN, origfile, -1); set_vim_var_string(VV_FNAME_DIFF, difffile, -1); set_vim_var_string(VV_FNAME_OUT, outfile, -1); ctx = get_option_sctx("patchexpr"); if (ctx != NULL) current_sctx = *ctx; // errors are ignored tv = eval_expr_ext(p_pex, NULL, TRUE); free_tv(tv); set_vim_var_string(VV_FNAME_IN, NULL, -1); set_vim_var_string(VV_FNAME_DIFF, NULL, -1); set_vim_var_string(VV_FNAME_OUT, NULL, -1); current_sctx = saved_sctx; } # endif #if defined(FEAT_SPELL) || defined(PROTO) /* * Evaluate an expression to a list with suggestions. * For the "expr:" part of 'spellsuggest'. * Returns NULL when there is an error. */ list_T * eval_spell_expr(char_u *badword, char_u *expr) { typval_T save_val; typval_T rettv; list_T *list = NULL; char_u *p = skipwhite(expr); sctx_T saved_sctx = current_sctx; sctx_T *ctx; int r; // Set "v:val" to the bad word. prepare_vimvar(VV_VAL, &save_val); set_vim_var_string(VV_VAL, badword, -1); if (p_verbose == 0) ++emsg_off; ctx = get_option_sctx("spellsuggest"); if (ctx != NULL) current_sctx = *ctx; r = may_call_simple_func(p, &rettv); if (r == NOTDONE) r = eval1(&p, &rettv, &EVALARG_EVALUATE); if (r == OK) { if (rettv.v_type != VAR_LIST) clear_tv(&rettv); else list = rettv.vval.v_list; } if (p_verbose == 0) --emsg_off; clear_tv(get_vim_var_tv(VV_VAL)); restore_vimvar(VV_VAL, &save_val); current_sctx = saved_sctx; return list; } /* * "list" is supposed to contain two items: a word and a number. Return the * word in "pp" and the number as the return value. * Return -1 if anything isn't right. * Used to get the good word and score from the eval_spell_expr() result. */ int get_spellword(list_T *list, char_u **pp) { listitem_T *li; li = list->lv_first; if (li == NULL) return -1; *pp = tv_get_string(&li->li_tv); li = li->li_next; if (li == NULL) return -1; return (int)tv_get_number(&li->li_tv); } #endif /* * Prepare v: variable "idx" to be used. * Save the current typeval in "save_tv" and clear it. * When not used yet add the variable to the v: hashtable. */ void prepare_vimvar(int idx, typval_T *save_tv) { *save_tv = vimvars[idx].vv_tv; vimvars[idx].vv_str = NULL; // don't free it now if (vimvars[idx].vv_tv_type == VAR_UNKNOWN) hash_add(&vimvarht, vimvars[idx].vv_di.di_key, "prepare vimvar"); } /* * Restore v: variable "idx" to typeval "save_tv". * Note that the v: variable must have been cleared already. * When no longer defined, remove the variable from the v: hashtable. */ void restore_vimvar(int idx, typval_T *save_tv) { hashitem_T *hi; vimvars[idx].vv_tv = *save_tv; if (vimvars[idx].vv_tv_type != VAR_UNKNOWN) return; hi = hash_find(&vimvarht, vimvars[idx].vv_di.di_key); if (HASHITEM_EMPTY(hi)) internal_error("restore_vimvar()"); else hash_remove(&vimvarht, hi, "restore vimvar"); } /* * List Vim variables. */ static void list_vim_vars(int *first) { list_hashtable_vars(&vimvarht, "v:", FALSE, first); } /* * List script-local variables, if there is a script. */ static void list_script_vars(int *first) { if (SCRIPT_ID_VALID(current_sctx.sc_sid)) list_hashtable_vars(&SCRIPT_VARS(current_sctx.sc_sid), "s:", FALSE, first); } /* * Return TRUE if "name" starts with "g:", "w:", "t:" or "b:". * But only when an identifier character follows. */ int is_scoped_variable(char_u *name) { return vim_strchr((char_u *)"gwbt", name[0]) != NULL && name[1] == ':' && eval_isnamec(name[2]); } /* * Evaluate one Vim expression {expr} in string "p" and append the * resulting string to "gap". "p" points to the opening "{". * When "evaluate" is FALSE only skip over the expression. * Return a pointer to the character after "}", NULL for an error. */ char_u * eval_one_expr_in_str(char_u *p, garray_T *gap, int evaluate) { char_u *block_start = skipwhite(p + 1); // skip the opening { char_u *block_end = block_start; char_u *expr_val; if (*block_start == NUL) { semsg(_(e_missing_close_curly_str), p); return NULL; } if (skip_expr(&block_end, NULL) == FAIL) return NULL; block_end = skipwhite(block_end); if (*block_end != '}') { semsg(_(e_missing_close_curly_str), p); return NULL; } if (evaluate) { *block_end = NUL; expr_val = eval_to_string(block_start, TRUE, FALSE); *block_end = '}'; if (expr_val == NULL) return NULL; ga_concat(gap, expr_val); vim_free(expr_val); } return block_end + 1; } /* * Evaluate all the Vim expressions {expr} in "str" and return the resulting * string in allocated memory. "{{" is reduced to "{" and "}}" to "}". * Used for a heredoc assignment. * Returns NULL for an error. */ static char_u * eval_all_expr_in_str(char_u *str) { garray_T ga; char_u *p; ga_init2(&ga, 1, 80); p = str; while (*p != NUL) { char_u *lit_start; int escaped_brace = FALSE; // Look for a block start. lit_start = p; while (*p != '{' && *p != '}' && *p != NUL) ++p; if (*p != NUL && *p == p[1]) { // Escaped brace, unescape and continue. // Include the brace in the literal string. ++p; escaped_brace = TRUE; } else if (*p == '}') { semsg(_(e_stray_closing_curly_str), str); ga_clear(&ga); return NULL; } // Append the literal part. ga_concat_len(&ga, lit_start, (size_t)(p - lit_start)); if (*p == NUL) break; if (escaped_brace) { // Skip the second brace. ++p; continue; } // Evaluate the expression and append the result. p = eval_one_expr_in_str(p, &ga, TRUE); if (p == NULL) { ga_clear(&ga); return NULL; } } ga_append(&ga, NUL); return ga.ga_data; } /* * Get a list of lines from a HERE document. The here document is a list of * lines surrounded by a marker. * cmd << {marker} * {line1} * {line2} * .... * {marker} * * The {marker} is a string. If the optional 'trim' word is supplied before the * marker, then the leading indentation before the lines (matching the * indentation in the "cmd" line) is stripped. * * When getting lines for an embedded script (e.g. python, lua, perl, ruby, * tcl, mzscheme), "script_get" is set to TRUE. In this case, if the marker is * missing, then '.' is accepted as a marker. * * When compiling a heredoc assignment to a variable in a Vim9 def function, * "vim9compile" is set to TRUE. In this case, instead of generating a list of * string values from the heredoc, vim9 instructions are generated. On success * the returned list will be empty. * * Returns a List with {lines} or NULL on failure. */ list_T * heredoc_get(exarg_T *eap, char_u *cmd, int script_get, int vim9compile) { char_u *theline = NULL; char_u *marker; list_T *l; char_u *p; char_u *str; int marker_indent_len = 0; int text_indent_len = 0; char_u *text_indent = NULL; char_u dot[] = "."; int comment_char = in_vim9script() ? '#' : '"'; int evalstr = FALSE; int eval_failed = FALSE; cctx_T *cctx = vim9compile ? eap->cookie : NULL; int count = 0; if (eap->ea_getline == NULL) { emsg(_(e_cannot_use_heredoc_here)); return NULL; } // Check for the optional 'trim' word before the marker cmd = skipwhite(cmd); while (TRUE) { if (STRNCMP(cmd, "trim", 4) == 0 && (cmd[4] == NUL || VIM_ISWHITE(cmd[4]))) { cmd = skipwhite(cmd + 4); // Trim the indentation from all the lines in the here document. // The amount of indentation trimmed is the same as the indentation // of the first line after the :let command line. To find the end // marker the indent of the :let command line is trimmed. p = *eap->cmdlinep; while (VIM_ISWHITE(*p)) { p++; marker_indent_len++; } text_indent_len = -1; continue; } if (STRNCMP(cmd, "eval", 4) == 0 && (cmd[4] == NUL || VIM_ISWHITE(cmd[4]))) { cmd = skipwhite(cmd + 4); evalstr = TRUE; continue; } break; } // The marker is the next word. if (*cmd != NUL && *cmd != comment_char) { marker = skipwhite(cmd); p = skiptowhite(marker); if (*skipwhite(p) != NUL && *skipwhite(p) != comment_char) { semsg(_(e_trailing_characters_str), p); return NULL; } *p = NUL; if (!script_get && vim_islower(*marker)) { emsg(_(e_marker_cannot_start_with_lower_case_letter)); return NULL; } } else { // When getting lines for an embedded script, if the marker is missing, // accept '.' as the marker. if (script_get) marker = dot; else { emsg(_(e_missing_marker)); return NULL; } } l = list_alloc(); if (l == NULL) return NULL; for (;;) { int mi = 0; int ti = 0; vim_free(theline); theline = eap->ea_getline(NUL, eap->cookie, 0, FALSE); if (theline == NULL) { semsg(_(e_missing_end_marker_str), marker); break; } // with "trim": skip the indent matching the :let line to find the // marker if (marker_indent_len > 0 && STRNCMP(theline, *eap->cmdlinep, marker_indent_len) == 0) mi = marker_indent_len; if (STRCMP(marker, theline + mi) == 0) break; // If expression evaluation failed in the heredoc, then skip till the // end marker. if (eval_failed) continue; if (text_indent_len == -1 && *theline != NUL) { // set the text indent from the first line. p = theline; text_indent_len = 0; while (VIM_ISWHITE(*p)) { p++; text_indent_len++; } text_indent = vim_strnsave(theline, text_indent_len); } // with "trim": skip the indent matching the first line if (text_indent != NULL) for (ti = 0; ti < text_indent_len; ++ti) if (theline[ti] != text_indent[ti]) break; str = theline + ti; if (vim9compile) { if (compile_all_expr_in_str(str, evalstr, cctx) == FAIL) { vim_free(theline); vim_free(text_indent); return FAIL; } count++; } else { if (evalstr && !eap->skip) { str = eval_all_expr_in_str(str); if (str == NULL) { // expression evaluation failed eval_failed = TRUE; continue; } vim_free(theline); theline = str; } if (list_append_string(l, str, -1) == FAIL) break; } } vim_free(theline); vim_free(text_indent); if (vim9compile && cctx->ctx_skip != SKIP_YES && !eval_failed) generate_NEWLIST(cctx, count, FALSE); if (eval_failed) { // expression evaluation in the heredoc failed list_free(l); return NULL; } return l; } /* * Vim9 variable declaration: * ":var name" * ":var name: type" * ":var name = expr" * ":var name: type = expr" * etc. */ void ex_var(exarg_T *eap) { char_u *p = eap->cmd; int has_var; if (!in_vim9script()) { semsg(_(e_str_cannot_be_used_in_legacy_vim_script), ":var"); return; } has_var = checkforcmd_noparen(&p, "var", 3); if (current_sctx.sc_sid == 0 && has_var) { emsg(_(e_cannot_declare_variable_on_command_line)); return; } ex_let(eap); } /* * ":let" list all variable values * ":let var1 var2" list variable values * ":let var = expr" assignment command. * ":let var += expr" assignment command. * ":let var -= expr" assignment command. * ":let var *= expr" assignment command. * ":let var /= expr" assignment command. * ":let var %= expr" assignment command. * ":let var .= expr" assignment command. * ":let var ..= expr" assignment command. * ":let [var1, var2] = expr" unpack list. * ":let var =<< ..." heredoc * ":let var: string" Vim9 declaration * * ":final var = expr" assignment command. * ":final [var1, var2] = expr" unpack list. * * ":const" list all variable values * ":const var1 var2" list variable values * ":const var = expr" assignment command. * ":const [var1, var2] = expr" unpack list. */ void ex_let(exarg_T *eap) { char_u *arg = eap->arg; char_u *expr = NULL; typval_T rettv; int var_count = 0; int semicolon = 0; char_u op[4]; char_u *argend; int first = TRUE; int concat; int has_assign; int flags = 0; int vim9script = in_vim9script(); if (eap->cmdidx == CMD_final && !vim9script) { // In legacy Vim script ":final" is short for ":finally". ex_finally(eap); return; } if (eap->cmdidx == CMD_let && vim9script) { emsg(_(e_cannot_use_let_in_vim9_script)); return; } if (eap->cmdidx == CMD_const) flags |= ASSIGN_CONST; else if (eap->cmdidx == CMD_final) flags |= ASSIGN_FINAL; // Vim9 assignment without ":let", ":const" or ":final" if (eap->arg == eap->cmd) flags |= ASSIGN_NO_DECL; argend = skip_var_list(arg, TRUE, &var_count, &semicolon, FALSE); if (argend == NULL) return; if (argend > arg && argend[-1] == '.') // for var.='str' --argend; expr = skipwhite(argend); concat = expr[0] == '.' && ((expr[1] == '=' && in_old_script(2)) || (expr[1] == '.' && expr[2] == '=')); has_assign = *expr == '=' || (vim_strchr((char_u *)"+-*/%", *expr) != NULL && expr[1] == '='); if (!has_assign && !concat) { // ":let" without "=": list variables if (*arg == '[') emsg(_(e_invalid_argument)); else if (expr[0] == '.' && expr[1] == '=') emsg(_(e_dot_equal_not_supported_with_script_version_two)); else if (!ends_excmd2(eap->cmd, arg)) { if (vim9script) { if (!ends_excmd2(eap->cmd, skipwhite(argend))) semsg(_(e_trailing_characters_str), argend); else // Vim9 declaration ":var name: type" arg = vim9_declare_scriptvar(eap, arg); } else { // ":let var1 var2" - list values arg = list_arg_vars(eap, arg, &first); } } else if (!eap->skip) { // ":let" list_glob_vars(&first); list_buf_vars(&first); list_win_vars(&first); list_tab_vars(&first); list_script_vars(&first); list_func_vars(&first); list_vim_vars(&first); } set_nextcmd(eap, arg); return; } if (expr[0] == '=' && expr[1] == '<' && expr[2] == '<') { list_T *l = NULL; long cur_lnum = SOURCING_LNUM; // :let text =<< [trim] [eval] END // :var text =<< [trim] [eval] END if (vim9script && !eap->skip && (!VIM_ISWHITE(expr[-1]) || !IS_WHITE_OR_NUL(expr[3]))) semsg(_(e_white_space_required_before_and_after_str_at_str), "=<<", expr); else l = heredoc_get(eap, expr + 3, FALSE, FALSE); if (l != NULL) { rettv_list_set(&rettv, l); if (!eap->skip) { // errors are for the assignment, not the end marker SOURCING_LNUM = cur_lnum; op[0] = '='; op[1] = NUL; (void)ex_let_vars(eap->arg, &rettv, FALSE, semicolon, var_count, flags, op); } clear_tv(&rettv); } return; } evalarg_T evalarg; int len = 1; CLEAR_FIELD(rettv); int cur_lnum; op[0] = '='; op[1] = NUL; if (*expr != '=') { if (vim9script && (flags & ASSIGN_NO_DECL) == 0) { // +=, /=, etc. require an existing variable semsg(_(e_cannot_use_operator_on_new_variable_str), eap->arg); } else if (vim_strchr((char_u *)"+-*/%.", *expr) != NULL) { op[0] = *expr; // +=, -=, *=, /=, %= or .= ++len; if (expr[0] == '.' && expr[1] == '.') // ..= { ++expr; ++len; } } expr += 2; } else ++expr; if (vim9script && !eap->skip && (!VIM_ISWHITE(*argend) || !IS_WHITE_OR_NUL(*expr))) { vim_strncpy(op, expr - len, len); semsg(_(e_white_space_required_before_and_after_str_at_str), op, argend); } if (eap->skip) ++emsg_skip; fill_evalarg_from_eap(&evalarg, eap, eap->skip); expr = skipwhite_and_linebreak(expr, &evalarg); cur_lnum = SOURCING_LNUM; int eval_res = eval0(expr, &rettv, eap, &evalarg); if (eap->skip) --emsg_skip; clear_evalarg(&evalarg, eap); // Restore the line number so that any type error is given for the // declaration, not the expression. SOURCING_LNUM = cur_lnum; if (!eap->skip && eval_res != FAIL) (void)ex_let_vars(eap->arg, &rettv, FALSE, semicolon, var_count, flags, op); if (eval_res != FAIL) clear_tv(&rettv); } /* * Assign the typeval "tv" to the variable or variables at "arg_start". * Handles both "var" with any type and "[var, var; var]" with a list type. * When "op" is not NULL it points to a string with characters that * must appear after the variable(s). Use "+", "-" or "." for add, subtract * or concatenate. * Returns OK or FAIL; */ int ex_let_vars( char_u *arg_start, typval_T *tv, int copy, // copy values from "tv", don't move int semicolon, // from skip_var_list() int var_count, // from skip_var_list() int flags, // ASSIGN_FINAL, ASSIGN_CONST, etc. char_u *op) { char_u *arg = arg_start; list_T *l; int i; int var_idx = 0; listitem_T *item; typval_T ltv; if (tv->v_type == VAR_VOID) { emsg(_(e_cannot_use_void_value)); return FAIL; } if (*arg != '[') { // ":let var = expr" or ":for var in list" if (ex_let_one(arg, tv, copy, flags, op, op, var_idx) == NULL) return FAIL; return OK; } // ":let [v1, v2] = list" or ":for [v1, v2] in listlist" if (tv->v_type != VAR_LIST || (l = tv->vval.v_list) == NULL) { emsg(_(e_list_required)); return FAIL; } i = list_len(l); if (semicolon == 0 && var_count < i) { emsg(_(e_less_targets_than_list_items)); return FAIL; } if (var_count - semicolon > i) { emsg(_(e_more_targets_than_list_items)); return FAIL; } CHECK_LIST_MATERIALIZE(l); item = l->lv_first; while (*arg != ']') { arg = skipwhite(arg + 1); ++var_idx; arg = ex_let_one(arg, &item->li_tv, TRUE, flags | ASSIGN_UNPACK, (char_u *)",;]", op, var_idx); item = item->li_next; if (arg == NULL) return FAIL; arg = skipwhite(arg); if (*arg == ';') { // Put the rest of the list (may be empty) in the var after ';'. // Create a new list for this. l = list_alloc(); if (l == NULL) return FAIL; while (item != NULL) { list_append_tv(l, &item->li_tv); item = item->li_next; } ltv.v_type = VAR_LIST; ltv.v_lock = 0; ltv.vval.v_list = l; l->lv_refcount = 1; ++var_idx; arg = ex_let_one(skipwhite(arg + 1), <v, FALSE, flags | ASSIGN_UNPACK, (char_u *)"]", op, var_idx); clear_tv(<v); if (arg == NULL) return FAIL; break; } else if (*arg != ',' && *arg != ']') { internal_error("ex_let_vars()"); return FAIL; } } return OK; } /* * Skip over assignable variable "var" or list of variables "[var, var]". * Used for ":let varvar = expr" and ":for varvar in expr". * For "[var, var]" increment "*var_count" for each variable. * for "[var, var; var]" set "semicolon" to 1. * If "silent" is TRUE do not give an "invalid argument" error message. * Return NULL for an error. */ char_u * skip_var_list( char_u *arg, int include_type, int *var_count, int *semicolon, int silent) { char_u *p, *s; if (*arg == '[') { // "[var, var]": find the matching ']'. p = arg; for (;;) { p = skipwhite(p + 1); // skip whites after '[', ';' or ',' s = skip_var_one(p, include_type); if (s == p) { if (!silent) semsg(_(e_invalid_argument_str), p); return NULL; } ++*var_count; p = skipwhite(s); if (*p == ']') break; else if (*p == ';') { if (*semicolon == 1) { if (!silent) emsg(_(e_double_semicolon_in_list_of_variables)); return NULL; } *semicolon = 1; } else if (*p != ',') { if (!silent) semsg(_(e_invalid_argument_str), p); return NULL; } } return p + 1; } return skip_var_one(arg, include_type); } /* * Skip one (assignable) variable name, including @r, $VAR, &option, d.key, * l[idx]. * In Vim9 script also skip over ": type" if "include_type" is TRUE. */ char_u * skip_var_one(char_u *arg, int include_type) { char_u *end; int vim9 = in_vim9script(); if (*arg == '@' && arg[1] != NUL) return arg + 2; // termcap option name may have non-alpha characters if (STRNCMP(arg, "&t_", 3) == 0 && arg[3] != NUL && arg[4] != NUL) return arg + 5; end = find_name_end(*arg == '$' || *arg == '&' ? arg + 1 : arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START); // "a: type" is declaring variable "a" with a type, not "a:". // Same for "s: type". if (vim9 && end == arg + 2 && end[-1] == ':') --end; if (include_type && vim9) { if (*skipwhite(end) == ':') end = skip_type(skipwhite(skipwhite(end) + 1), FALSE); } return end; } /* * List variables for hashtab "ht" with prefix "prefix". * If "empty" is TRUE also list NULL strings as empty strings. */ void list_hashtable_vars( hashtab_T *ht, char *prefix, int empty, int *first) { hashitem_T *hi; dictitem_T *di; int todo; char_u buf[IOSIZE]; int save_ht_flags = ht->ht_flags; ht->ht_flags |= HTFLAGS_FROZEN; todo = (int)ht->ht_used; for (hi = ht->ht_array; todo > 0 && !got_int; ++hi) { if (!HASHITEM_EMPTY(hi)) { --todo; di = HI2DI(hi); // apply :filter /pat/ to variable name vim_strncpy((char_u *)buf, (char_u *)prefix, IOSIZE - 1); vim_strcat((char_u *)buf, di->di_key, IOSIZE); if (message_filtered(buf)) continue; if (empty || di->di_tv.v_type != VAR_STRING || di->di_tv.vval.v_string != NULL) list_one_var(di, prefix, first); } } ht->ht_flags = save_ht_flags; } /* * List global variables. */ static void list_glob_vars(int *first) { list_hashtable_vars(&globvarht, "", TRUE, first); } /* * List buffer variables. */ static void list_buf_vars(int *first) { list_hashtable_vars(&curbuf->b_vars->dv_hashtab, "b:", TRUE, first); } /* * List window variables. */ static void list_win_vars(int *first) { list_hashtable_vars(&curwin->w_vars->dv_hashtab, "w:", TRUE, first); } /* * List tab page variables. */ static void list_tab_vars(int *first) { list_hashtable_vars(&curtab->tp_vars->dv_hashtab, "t:", TRUE, first); } /* * List variables in "arg". */ static char_u * list_arg_vars(exarg_T *eap, char_u *arg, int *first) { int error = FALSE; int len; char_u *name; char_u *name_start; char_u *arg_subsc; char_u *tofree; typval_T tv; while (!ends_excmd2(eap->cmd, arg) && !got_int) { if (error || eap->skip) { arg = find_name_end(arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START); if (!VIM_ISWHITE(*arg) && !ends_excmd(*arg)) { emsg_severe = TRUE; if (!did_emsg) semsg(_(e_trailing_characters_str), arg); break; } } else { // get_name_len() takes care of expanding curly braces name_start = name = arg; len = get_name_len(&arg, &tofree, TRUE, TRUE); if (len <= 0) { // This is mainly to keep test 49 working: when expanding // curly braces fails overrule the exception error message. if (len < 0 && !aborting()) { emsg_severe = TRUE; semsg(_(e_invalid_argument_str), arg); break; } error = TRUE; } else { arg = skipwhite(arg); if (tofree != NULL) name = tofree; if (eval_variable(name, len, 0, &tv, NULL, EVAL_VAR_VERBOSE) == FAIL) error = TRUE; else { // handle d.key, l[idx], f(expr) arg_subsc = arg; if (handle_subscript(&arg, name_start, &tv, &EVALARG_EVALUATE, TRUE) == FAIL) error = TRUE; else { if (arg == arg_subsc && len == 2 && name[1] == ':') { switch (*name) { case 'g': list_glob_vars(first); break; case 'b': list_buf_vars(first); break; case 'w': list_win_vars(first); break; case 't': list_tab_vars(first); break; case 'v': list_vim_vars(first); break; case 's': list_script_vars(first); break; case 'l': list_func_vars(first); break; default: semsg(_(e_cant_list_variables_for_str), name); } } else { char_u numbuf[NUMBUFLEN]; char_u *tf; int c; char_u *s; s = echo_string(&tv, &tf, numbuf, 0); c = *arg; *arg = NUL; list_one_var_a("", arg == arg_subsc ? name : name_start, tv.v_type, s == NULL ? (char_u *)"" : s, first); *arg = c; vim_free(tf); } clear_tv(&tv); } } } vim_free(tofree); } arg = skipwhite(arg); } return arg; } /* * Set an environment variable, part of ex_let_one(). */ static char_u * ex_let_env( char_u *arg, typval_T *tv, int flags, char_u *endchars, char_u *op) { char_u *arg_end = NULL; char_u *name; int len; if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) && (flags & ASSIGN_FOR_LOOP) == 0) { emsg(_(e_cannot_lock_environment_variable)); return NULL; } // Find the end of the name. ++arg; name = arg; len = get_env_len(&arg); if (len == 0) semsg(_(e_invalid_argument_str), name - 1); else { if (op != NULL && vim_strchr((char_u *)"+-*/%", *op) != NULL) semsg(_(e_wrong_variable_type_for_str_equal), op); else if (endchars != NULL && vim_strchr(endchars, *skipwhite(arg)) == NULL) emsg(_(e_unexpected_characters_in_let)); else if (!check_secure()) { char_u *tofree = NULL; int c1 = name[len]; char_u *p; name[len] = NUL; p = tv_get_string_chk(tv); if (p != NULL && op != NULL && *op == '.') { int mustfree = FALSE; char_u *s = vim_getenv(name, &mustfree); if (s != NULL) { p = tofree = concat_str(s, p); if (mustfree) vim_free(s); } } if (p != NULL) { vim_setenv_ext(name, p); arg_end = arg; } name[len] = c1; vim_free(tofree); } } return arg_end; } /* * Set an option, part of ex_let_one(). */ static char_u * ex_let_option( char_u *arg, typval_T *tv, int flags, char_u *endchars, char_u *op) { char_u *p; int scope; char_u *arg_end = NULL; if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) && (flags & ASSIGN_FOR_LOOP) == 0) { emsg(_(e_cannot_lock_option)); return NULL; } // Find the end of the name. p = find_option_end(&arg, &scope); if (p == NULL || (endchars != NULL && vim_strchr(endchars, *skipwhite(p)) == NULL)) { emsg(_(e_unexpected_characters_in_let)); return NULL; } int c1; long n = 0; getoption_T opt_type; long numval; char_u *stringval = NULL; char_u *s = NULL; int failed = FALSE; int opt_p_flags; char_u *tofree = NULL; char_u numbuf[NUMBUFLEN]; c1 = *p; *p = NUL; opt_type = get_option_value(arg, &numval, &stringval, &opt_p_flags, scope); if (opt_type == gov_unknown && arg[0] != 't' && arg[1] != '_') { semsg(_(e_unknown_option_str_2), arg); goto theend; } if (op != NULL && *op != '=' && (((opt_type == gov_bool || opt_type == gov_number) && *op == '.') || (opt_type == gov_string && *op != '.'))) { semsg(_(e_wrong_variable_type_for_str_equal), op); goto theend; } if ((opt_type == gov_bool || opt_type == gov_number || opt_type == gov_hidden_bool || opt_type == gov_hidden_number) && (tv->v_type != VAR_STRING || !in_vim9script())) { if (opt_type == gov_bool || opt_type == gov_hidden_bool) // bool, possibly hidden n = (long)tv_get_bool_chk(tv, &failed); else // number, possibly hidden n = (long)tv_get_number_chk(tv, &failed); if (failed) goto theend; } if ((opt_p_flags & P_FUNC) && (tv->v_type == VAR_PARTIAL || tv->v_type == VAR_FUNC)) { // If the option can be set to a function reference or a lambda // and the passed value is a function reference, then convert it to // the name (string) of the function reference. s = tv2string(tv, &tofree, numbuf, 0); if (s == NULL) goto theend; } // Avoid setting a string option to the text "v:false" or similar. // In Vim9 script also don't convert a number to string. else if (tv->v_type != VAR_BOOL && tv->v_type != VAR_SPECIAL && (!in_vim9script() || tv->v_type != VAR_NUMBER)) { s = tv_get_string_chk(tv); if (s == NULL) goto theend; } else if (opt_type == gov_string || opt_type == gov_hidden_string) { emsg(_(e_string_required)); goto theend; } if (op != NULL && *op != '=') { // number, in legacy script also bool if (opt_type == gov_number || (opt_type == gov_bool && !in_vim9script())) { switch (*op) { case '+': n = numval + n; break; case '-': n = numval - n; break; case '*': n = numval * n; break; case '/': n = (long)num_divide(numval, n, &failed); break; case '%': n = (long)num_modulus(numval, n, &failed); break; } s = NULL; if (failed) goto theend; } else if (opt_type == gov_string && stringval != NULL && s != NULL) { // string s = concat_str(stringval, s); vim_free(stringval); stringval = s; } } char *err = set_option_value(arg, n, s, scope); arg_end = p; if (err != NULL) emsg(_(err)); theend: *p = c1; vim_free(stringval); vim_free(tofree); return arg_end; } /* * Set a register, part of ex_let_one(). */ static char_u * ex_let_register( char_u *arg, typval_T *tv, int flags, char_u *endchars, char_u *op) { char_u *arg_end = NULL; if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) && (flags & ASSIGN_FOR_LOOP) == 0) { emsg(_(e_cannot_lock_register)); return NULL; } ++arg; if (op != NULL && vim_strchr((char_u *)"+-*/%", *op) != NULL) semsg(_(e_wrong_variable_type_for_str_equal), op); else if (endchars != NULL && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) emsg(_(e_unexpected_characters_in_let)); else { char_u *ptofree = NULL; char_u *p; p = tv_get_string_chk(tv); if (p != NULL && op != NULL && *op == '.') { char_u *s = get_reg_contents(*arg == '@' ? '"' : *arg, GREG_EXPR_SRC); if (s != NULL) { p = ptofree = concat_str(s, p); vim_free(s); } } if (p != NULL) { write_reg_contents(*arg == '@' ? '"' : *arg, p, -1, FALSE); arg_end = arg + 1; } vim_free(ptofree); } return arg_end; } /* * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value. * Returns a pointer to the char just after the var name. * Returns NULL if there is an error. */ static char_u * ex_let_one( char_u *arg, // points to variable name typval_T *tv, // value to assign to variable int copy, // copy value from "tv" int flags, // ASSIGN_CONST, ASSIGN_FINAL, etc. char_u *endchars, // valid chars after variable name or NULL char_u *op, // "+", "-", "." or NULL int var_idx) // variable index for "let [a, b] = list" { char_u *arg_end = NULL; if (in_vim9script() && (flags & (ASSIGN_NO_DECL | ASSIGN_DECL)) == 0 && (flags & (ASSIGN_CONST | ASSIGN_FINAL)) == 0 && vim_strchr((char_u *)"$@&", *arg) != NULL) { vim9_declare_error(arg); return NULL; } if (check_typval_is_value(tv) == FAIL) return NULL; if (*arg == '$') { // ":let $VAR = expr": Set environment variable. return ex_let_env(arg, tv, flags, endchars, op); } else if (*arg == '&') { // ":let &option = expr": Set option value. // ":let &l:option = expr": Set local option value. // ":let &g:option = expr": Set global option value. // ":for &ts in range(8)": Set option value for for loop return ex_let_option(arg, tv, flags, endchars, op); } else if (*arg == '@') { // ":let @r = expr": Set register contents. return ex_let_register(arg, tv, flags, endchars, op); } else if (eval_isnamec1(*arg) || *arg == '{') { lval_T lv; char_u *p; int lval_flags = (flags & (ASSIGN_NO_DECL | ASSIGN_DECL)) ? GLV_NO_DECL : 0; lval_flags |= (flags & ASSIGN_FOR_LOOP) ? GLV_FOR_LOOP : 0; if (op != NULL && *op != '=') lval_flags |= GLV_ASSIGN_WITH_OP; // ":let var = expr": Set internal variable. // ":let var: type = expr": Set internal variable with type. // ":let {expr} = expr": Idem, name made with curly braces p = get_lval(arg, tv, &lv, FALSE, FALSE, lval_flags, FNE_CHECK_START); if (p != NULL && lv.ll_name != NULL) { if (endchars != NULL && vim_strchr(endchars, *skipwhite(lv.ll_name_end)) == NULL) { emsg(_(e_unexpected_characters_in_let)); } else { set_var_lval(&lv, p, tv, copy, flags, op, var_idx); arg_end = lv.ll_name_end; } } clear_lval(&lv); } else semsg(_(e_invalid_argument_str), arg); return arg_end; } /* * ":unlet[!] var1 ... " command. */ void ex_unlet(exarg_T *eap) { ex_unletlock(eap, eap->arg, 0, 0, do_unlet_var, NULL); } /* * ":lockvar" and ":unlockvar" commands */ void ex_lockvar(exarg_T *eap) { char_u *arg = eap->arg; int deep = 2; if (eap->forceit) deep = -1; else if (vim_isdigit(*arg)) { deep = getdigits(&arg); arg = skipwhite(arg); } ex_unletlock(eap, arg, deep, 0, do_lock_var, NULL); } /* * ":unlet", ":lockvar" and ":unlockvar" are quite similar. * Also used for Vim9 script. "callback" is invoked as: * callback(&lv, name_end, eap, deep, cookie) */ void ex_unletlock( exarg_T *eap, char_u *argstart, int deep, int glv_flags, int (*callback)(lval_T *, char_u *, exarg_T *, int, void *), void *cookie) { char_u *arg = argstart; char_u *name_end; int error = FALSE; lval_T lv; do { if (*arg == '$') { lv.ll_name = arg; lv.ll_tv = NULL; ++arg; if (get_env_len(&arg) == 0) { semsg(_(e_invalid_argument_str), arg - 1); return; } if (!error && !eap->skip && callback(&lv, arg, eap, deep, cookie) == FAIL) error = TRUE; name_end = arg; } else { // Parse the name and find the end. name_end = get_lval(arg, NULL, &lv, TRUE, eap->skip || error, glv_flags | GLV_NO_DECL, FNE_CHECK_START); if (lv.ll_name == NULL) error = TRUE; // error but continue parsing if (name_end == NULL || (!VIM_ISWHITE(*name_end) && !ends_excmd(*name_end))) { if (name_end != NULL) { emsg_severe = TRUE; semsg(_(e_trailing_characters_str), name_end); } if (!(eap->skip || error)) clear_lval(&lv); break; } if (!error && !eap->skip && callback(&lv, name_end, eap, deep, cookie) == FAIL) error = TRUE; if (!eap->skip) clear_lval(&lv); } arg = skipwhite(name_end); } while (!ends_excmd2(name_end, arg)); set_nextcmd(eap, arg); } static int do_unlet_var( lval_T *lp, char_u *name_end, exarg_T *eap, int deep UNUSED, void *cookie UNUSED) { int forceit = eap->forceit; int ret = OK; int cc; if (lp->ll_tv == NULL) { cc = *name_end; *name_end = NUL; // Environment variable, normal name or expanded name. if (*lp->ll_name == '$') vim_unsetenv_ext(lp->ll_name + 1); else if (do_unlet(lp->ll_name, forceit) == FAIL) ret = FAIL; *name_end = cc; } else if ((lp->ll_list != NULL && value_check_lock(lp->ll_list->lv_lock, lp->ll_name, FALSE)) || (lp->ll_dict != NULL && value_check_lock(lp->ll_dict->dv_lock, lp->ll_name, FALSE))) return FAIL; else if (lp->ll_range) list_unlet_range(lp->ll_list, lp->ll_li, lp->ll_n1, !lp->ll_empty2, lp->ll_n2); else if (lp->ll_list != NULL) // unlet a List item. listitem_remove(lp->ll_list, lp->ll_li); else // unlet a Dictionary item. dictitem_remove(lp->ll_dict, lp->ll_di, "unlet"); return ret; } /* * Unlet one item or a range of items from a list. * Return OK or FAIL. */ void list_unlet_range( list_T *l, listitem_T *li_first, long n1_arg, int has_n2, long n2) { listitem_T *li = li_first; int n1 = n1_arg; // Delete a range of List items. li = li_first; n1 = n1_arg; while (li != NULL && (!has_n2 || n2 >= n1)) { listitem_T *next = li->li_next; listitem_remove(l, li); li = next; ++n1; } } /* * "unlet" a variable. Return OK if it existed, FAIL if not. * When "forceit" is TRUE don't complain if the variable doesn't exist. */ int do_unlet(char_u *name, int forceit) { hashtab_T *ht; hashitem_T *hi; char_u *varname = NULL; // init to shut up gcc dict_T *d; dictitem_T *di; // can't :unlet a script variable in Vim9 script if (in_vim9script() && check_vim9_unlet(name) == FAIL) return FAIL; ht = find_var_ht(name, &varname); // can't :unlet a script variable in Vim9 script from a function if (ht == get_script_local_ht() && SCRIPT_ID_VALID(current_sctx.sc_sid) && SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9 && check_vim9_unlet(name) == FAIL) return FAIL; if (ht != NULL && *varname != NUL) { d = get_current_funccal_dict(ht); if (d == NULL) { if (ht == &globvarht) d = &globvardict; else if (ht == &compat_hashtab) d = &vimvardict; else { di = find_var_in_ht(ht, *name, (char_u *)"", FALSE); d = di == NULL ? NULL : di->di_tv.vval.v_dict; } if (d == NULL) { internal_error("do_unlet()"); return FAIL; } } hi = hash_find(ht, varname); if (HASHITEM_EMPTY(hi)) hi = find_hi_in_scoped_ht(name, &ht); if (hi != NULL && !HASHITEM_EMPTY(hi)) { di = HI2DI(hi); if (var_check_fixed(di->di_flags, name, FALSE) || var_check_ro(di->di_flags, name, FALSE) || value_check_lock(d->dv_lock, name, FALSE) || check_hashtab_frozen(ht, "unlet")) return FAIL; delete_var(ht, hi); return OK; } } if (forceit) return OK; semsg(_(e_no_such_variable_str), name); return FAIL; } static void report_lockvar_member(char *msg, lval_T *lp) { int did_alloc = FALSE; char_u *vname = (char_u *)""; char_u *class_name = lp->ll_class != NULL ? lp->ll_class->class_name : (char_u *)""; if (lp->ll_name != NULL) { if (lp->ll_name_end == NULL) vname = lp->ll_name; else { vname = vim_strnsave(lp->ll_name, lp->ll_name_end - lp->ll_name); if (vname == NULL) return; did_alloc = TRUE; } } semsg(_(msg), vname, class_name); if (did_alloc) vim_free(vname); } /* * Lock or unlock variable indicated by "lp". * "deep" is the levels to go (-1 for unlimited); * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar". */ static int do_lock_var( lval_T *lp, char_u *name_end, exarg_T *eap, int deep, void *cookie UNUSED) { int lock = eap->cmdidx == CMD_lockvar; int ret = OK; int cc; dictitem_T *di; #ifdef LOG_LOCKVAR ch_log(NULL, "LKVAR: do_lock_var(): name %s, is_root %d", lp->ll_name, lp->ll_is_root); #endif if (lp->ll_tv == NULL) { cc = *name_end; *name_end = NUL; if (*lp->ll_name == '$') { semsg(_(e_cannot_lock_or_unlock_variable_str), lp->ll_name); ret = FAIL; } else { // Normal name or expanded name. di = find_var(lp->ll_name, NULL, TRUE); if (di == NULL) { if (in_vim9script()) semsg(_(e_cannot_find_variable_to_unlock_str), lp->ll_name); ret = FAIL; } else { if ((di->di_flags & DI_FLAGS_FIX) && di->di_tv.v_type != VAR_DICT && di->di_tv.v_type != VAR_LIST) { // For historic reasons this error is not given for a list // or dict. E.g., the b: dict could be locked/unlocked. semsg(_(e_cannot_lock_or_unlock_variable_str), lp->ll_name); ret = FAIL; } else { if (in_vim9script()) { svar_T *sv = find_typval_in_script(&di->di_tv, 0, FALSE); if (sv != NULL && sv->sv_const != 0) { semsg(_(e_cannot_change_readonly_variable_str), lp->ll_name); ret = FAIL; } } if (ret == OK) { if (lock) di->di_flags |= DI_FLAGS_LOCK; else di->di_flags &= ~DI_FLAGS_LOCK; if (deep != 0) item_lock(&di->di_tv, deep, lock, FALSE); } } } } *name_end = cc; } else if (deep == 0 && lp->ll_object == NULL && lp->ll_class == NULL) { // nothing to do } else if (lp->ll_is_root) // (un)lock the item. item_lock(lp->ll_tv, deep, lock, FALSE); else if (lp->ll_range) { listitem_T *li = lp->ll_li; // (un)lock a range of List items. while (li != NULL && (lp->ll_empty2 || lp->ll_n2 >= lp->ll_n1)) { item_lock(&li->li_tv, deep, lock, FALSE); li = li->li_next; ++lp->ll_n1; } } else if (lp->ll_list != NULL) // (un)lock a List item. item_lock(&lp->ll_li->li_tv, deep, lock, FALSE); else if (lp->ll_object != NULL) // This check must be before ll_class. { // (un)lock an object variable. report_lockvar_member(e_cannot_lock_object_variable_str, lp); ret = FAIL; } else if (lp->ll_class != NULL) { // (un)lock a class variable. report_lockvar_member(e_cannot_lock_class_variable_str, lp); ret = FAIL; } else { // (un)lock a Dictionary item. if (lp->ll_di == NULL) { emsg(_(e_dictionary_required)); ret = FAIL; } else item_lock(&lp->ll_di->di_tv, deep, lock, FALSE); } return ret; } /* * Lock or unlock an item. "deep" is nr of levels to go. * When "check_refcount" is TRUE do not lock a list or dict with a reference * count larger than 1. */ void item_lock(typval_T *tv, int deep, int lock, int check_refcount) { static int recurse = 0; list_T *l; listitem_T *li; dict_T *d; blob_T *b; hashitem_T *hi; int todo; #ifdef LOG_LOCKVAR ch_log(NULL, "LKVAR: item_lock(): type %s", vartype_name(tv->v_type)); #endif if (recurse >= DICT_MAXNEST) { emsg(_(e_variable_nested_too_deep_for_unlock)); return; } if (deep == 0) return; ++recurse; // lock/unlock the item itself if (lock) tv->v_lock |= VAR_LOCKED; else tv->v_lock &= ~VAR_LOCKED; switch (tv->v_type) { case VAR_UNKNOWN: case VAR_ANY: case VAR_VOID: case VAR_NUMBER: case VAR_BOOL: case VAR_STRING: case VAR_FUNC: case VAR_PARTIAL: case VAR_FLOAT: case VAR_SPECIAL: case VAR_JOB: case VAR_CHANNEL: case VAR_INSTR: case VAR_CLASS: case VAR_OBJECT: case VAR_TYPEALIAS: break; case VAR_BLOB: if ((b = tv->vval.v_blob) != NULL && !(check_refcount && b->bv_refcount > 1)) { if (lock) b->bv_lock |= VAR_LOCKED; else b->bv_lock &= ~VAR_LOCKED; } break; case VAR_LIST: if ((l = tv->vval.v_list) != NULL && !(check_refcount && l->lv_refcount > 1)) { if (lock) l->lv_lock |= VAR_LOCKED; else l->lv_lock &= ~VAR_LOCKED; if (deep < 0 || deep > 1) { if (l->lv_first == &range_list_item) l->lv_lock |= VAR_ITEMS_LOCKED; else { // recursive: lock/unlock the items the List contains CHECK_LIST_MATERIALIZE(l); FOR_ALL_LIST_ITEMS(l, li) item_lock(&li->li_tv, deep - 1, lock, check_refcount); } } } break; case VAR_DICT: if ((d = tv->vval.v_dict) != NULL && !(check_refcount && d->dv_refcount > 1)) { if (lock) d->dv_lock |= VAR_LOCKED; else d->dv_lock &= ~VAR_LOCKED; if (deep < 0 || deep > 1) { // recursive: lock/unlock the items the List contains todo = (int)d->dv_hashtab.ht_used; FOR_ALL_HASHTAB_ITEMS(&d->dv_hashtab, hi, todo) { if (!HASHITEM_EMPTY(hi)) { --todo; item_lock(&HI2DI(hi)->di_tv, deep - 1, lock, check_refcount); } } } } } --recurse; } #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO) /* * Delete all "menutrans_" variables. */ void del_menutrans_vars(void) { hashitem_T *hi; int todo; hash_lock(&globvarht); todo = (int)globvarht.ht_used; for (hi = globvarht.ht_array; todo > 0 && !got_int; ++hi) { if (!HASHITEM_EMPTY(hi)) { --todo; if (STRNCMP(HI2DI(hi)->di_key, "menutrans_", 10) == 0) delete_var(&globvarht, hi); } } hash_unlock(&globvarht); } #endif /* * Local string buffer for the next two functions to store a variable name * with its prefix. Allocated in cat_prefix_varname(), freed later in * get_user_var_name(). */ static char_u *varnamebuf = NULL; static int varnamebuflen = 0; /* * Function to concatenate a prefix and a variable name. */ char_u * cat_prefix_varname(int prefix, char_u *name) { int len; len = (int)STRLEN(name) + 3; if (len > varnamebuflen) { vim_free(varnamebuf); len += 10; // some additional space varnamebuf = alloc(len); if (varnamebuf == NULL) { varnamebuflen = 0; return NULL; } varnamebuflen = len; } *varnamebuf = prefix; varnamebuf[1] = ':'; STRCPY(varnamebuf + 2, name); return varnamebuf; } /* * Function given to ExpandGeneric() to obtain the list of user defined * (global/buffer/window/built-in) variable names. */ char_u * get_user_var_name(expand_T *xp, int idx) { static long_u gdone; static long_u bdone; static long_u wdone; static long_u tdone; static int vidx; static hashitem_T *hi; hashtab_T *ht; if (idx == 0) { gdone = bdone = wdone = vidx = 0; tdone = 0; } // Global variables if (gdone < globvarht.ht_used) { if (gdone++ == 0) hi = globvarht.ht_array; else ++hi; while (HASHITEM_EMPTY(hi)) ++hi; if (STRNCMP("g:", xp->xp_pattern, 2) == 0) return cat_prefix_varname('g', hi->hi_key); return hi->hi_key; } // b: variables ht = &prevwin_curwin()->w_buffer->b_vars->dv_hashtab; if (bdone < ht->ht_used) { if (bdone++ == 0) hi = ht->ht_array; else ++hi; while (HASHITEM_EMPTY(hi)) ++hi; return cat_prefix_varname('b', hi->hi_key); } // w: variables ht = &prevwin_curwin()->w_vars->dv_hashtab; if (wdone < ht->ht_used) { if (wdone++ == 0) hi = ht->ht_array; else ++hi; while (HASHITEM_EMPTY(hi)) ++hi; return cat_prefix_varname('w', hi->hi_key); } // t: variables ht = &curtab->tp_vars->dv_hashtab; if (tdone < ht->ht_used) { if (tdone++ == 0) hi = ht->ht_array; else ++hi; while (HASHITEM_EMPTY(hi)) ++hi; return cat_prefix_varname('t', hi->hi_key); } // v: variables if (vidx < VV_LEN) return cat_prefix_varname('v', (char_u *)vimvars[vidx++].vv_name); VIM_CLEAR(varnamebuf); varnamebuflen = 0; return NULL; } char * get_var_special_name(int nr) { switch (nr) { case VVAL_FALSE: return in_vim9script() ? "false" : "v:false"; case VVAL_TRUE: return in_vim9script() ? "true" : "v:true"; case VVAL_NULL: return in_vim9script() ? "null" : "v:null"; case VVAL_NONE: return "v:none"; } internal_error("get_var_special_name()"); return "42"; } /* * Returns the global variable dictionary */ dict_T * get_globvar_dict(void) { return &globvardict; } /* * Returns the global variable hash table */ hashtab_T * get_globvar_ht(void) { return &globvarht; } /* * Returns the v: variable dictionary */ dict_T * get_vimvar_dict(void) { return &vimvardict; } /* * Returns the index of a v:variable. Negative if not found. * Returns DI_ flags in "di_flags". */ int find_vim_var(char_u *name, int *di_flags) { dictitem_T *di = find_var_in_ht(&vimvarht, 0, name, TRUE); struct vimvar *vv; if (di == NULL) return -1; *di_flags = di->di_flags; vv = (struct vimvar *)((char *)di - offsetof(vimvar_T, vv_di)); return (int)(vv - vimvars); } /* * Set type of v: variable to "type". */ void set_vim_var_type(int idx, vartype_T type) { vimvars[idx].vv_tv_type = type; } /* * Set number v: variable to "val". * Note that this does not set the type, use set_vim_var_type() for that. */ void set_vim_var_nr(int idx, varnumber_T val) { vimvars[idx].vv_nr = val; } char * get_vim_var_name(int idx) { return vimvars[idx].vv_name; } /* * Get typval_T v: variable value. */ typval_T * get_vim_var_tv(int idx) { return &vimvars[idx].vv_tv; } type_T * get_vim_var_type(int idx, garray_T *type_list) { if (vimvars[idx].vv_type != NULL) return vimvars[idx].vv_type; return typval2type_vimvar(&vimvars[idx].vv_tv, type_list); } /* * Set v: variable to "tv". Only accepts the same type. * Takes over the value of "tv". */ int set_vim_var_tv(int idx, typval_T *tv) { if (vimvars[idx].vv_tv_type != tv->v_type) { emsg(_(e_type_mismatch_for_v_variable)); clear_tv(tv); return FAIL; } // VV_RO is also checked when compiling, but let's check here as well. if (vimvars[idx].vv_flags & VV_RO) { semsg(_(e_cannot_change_readonly_variable_str), vimvars[idx].vv_name); return FAIL; } if (sandbox && (vimvars[idx].vv_flags & VV_RO_SBX)) { semsg(_(e_cannot_set_variable_in_sandbox_str), vimvars[idx].vv_name); return FAIL; } clear_tv(&vimvars[idx].vv_di.di_tv); vimvars[idx].vv_di.di_tv = *tv; return OK; } /* * Get number v: variable value. */ varnumber_T get_vim_var_nr(int idx) { return vimvars[idx].vv_nr; } /* * Get string v: variable value. Uses a static buffer, can only be used once. * If the String variable has never been set, return an empty string. * Never returns NULL; */ char_u * get_vim_var_str(int idx) { return tv_get_string(&vimvars[idx].vv_tv); } /* * Get List v: variable value. Caller must take care of reference count when * needed. */ list_T * get_vim_var_list(int idx) { return vimvars[idx].vv_list; } /* * Get Dict v: variable value. Caller must take care of reference count when * needed. */ dict_T * get_vim_var_dict(int idx) { return vimvars[idx].vv_dict; } /* * Set v:char to character "c". */ void set_vim_var_char(int c) { char_u buf[MB_MAXBYTES + 1]; if (has_mbyte) buf[(*mb_char2bytes)(c, buf)] = NUL; else { buf[0] = c; buf[1] = NUL; } set_vim_var_string(VV_CHAR, buf, -1); } /* * Set v:count to "count" and v:count1 to "count1". * When "set_prevcount" is TRUE first set v:prevcount from v:count. */ void set_vcount( long count, long count1, int set_prevcount) { if (set_prevcount) vimvars[VV_PREVCOUNT].vv_nr = vimvars[VV_COUNT].vv_nr; vimvars[VV_COUNT].vv_nr = count; vimvars[VV_COUNT1].vv_nr = count1; } /* * Save variables that might be changed as a side effect. Used when executing * a timer callback. */ void save_vimvars(vimvars_save_T *vvsave) { vvsave->vv_prevcount = vimvars[VV_PREVCOUNT].vv_nr; vvsave->vv_count = vimvars[VV_COUNT].vv_nr; vvsave->vv_count1 = vimvars[VV_COUNT1].vv_nr; } /* * Restore variables saved by save_vimvars(). */ void restore_vimvars(vimvars_save_T *vvsave) { vimvars[VV_PREVCOUNT].vv_nr = vvsave->vv_prevcount; vimvars[VV_COUNT].vv_nr = vvsave->vv_count; vimvars[VV_COUNT1].vv_nr = vvsave->vv_count1; } /* * Set string v: variable to a copy of "val". If 'copy' is FALSE, then set the * value. */ void set_vim_var_string( int idx, char_u *val, int len) // length of "val" to use or -1 (whole string) { clear_tv(&vimvars[idx].vv_di.di_tv); vimvars[idx].vv_tv_type = VAR_STRING; if (val == NULL) vimvars[idx].vv_str = NULL; else if (len == -1) vimvars[idx].vv_str = vim_strsave(val); else vimvars[idx].vv_str = vim_strnsave(val, len); } /* * Set List v: variable to "val". */ void set_vim_var_list(int idx, list_T *val) { clear_tv(&vimvars[idx].vv_di.di_tv); vimvars[idx].vv_tv_type = VAR_LIST; vimvars[idx].vv_list = val; if (val != NULL) ++val->lv_refcount; } /* * Set Dictionary v: variable to "val". */ void set_vim_var_dict(int idx, dict_T *val) { clear_tv(&vimvars[idx].vv_di.di_tv); vimvars[idx].vv_tv_type = VAR_DICT; vimvars[idx].vv_dict = val; if (val == NULL) return; ++val->dv_refcount; dict_set_items_ro(val); } /* * Set the v:argv list. */ void set_argv_var(char **argv, int argc) { list_T *l = list_alloc(); int i; if (l == NULL) getout(1); l->lv_lock = VAR_FIXED; for (i = 0; i < argc; ++i) { if (list_append_string(l, (char_u *)argv[i], -1) == FAIL) getout(1); l->lv_u.mat.lv_last->li_tv.v_lock = VAR_FIXED; } set_vim_var_list(VV_ARGV, l); } /* * Reset v:register, taking the 'clipboard' setting into account. */ void reset_reg_var(void) { int regname = 0; // Adjust the register according to 'clipboard', so that when // "unnamed" is present it becomes '*' or '+' instead of '"'. #ifdef FEAT_CLIPBOARD adjust_clip_reg(®name); #endif set_reg_var(regname); } /* * Set v:register if needed. */ void set_reg_var(int c) { char_u regname; if (c == 0 || c == ' ') regname = '"'; else regname = c; // Avoid free/alloc when the value is already right. if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c) set_vim_var_string(VV_REG, ®name, 1); } /* * Get or set v:exception. If "oldval" == NULL, return the current value. * Otherwise, restore the value to "oldval" and return NULL. * Must always be called in pairs to save and restore v:exception! Does not * take care of memory allocations. */ char_u * v_exception(char_u *oldval) { if (oldval == NULL) return vimvars[VV_EXCEPTION].vv_str; vimvars[VV_EXCEPTION].vv_str = oldval; return NULL; } /* * Get or set v:throwpoint. If "oldval" == NULL, return the current value. * Otherwise, restore the value to "oldval" and return NULL. * Must always be called in pairs to save and restore v:throwpoint! Does not * take care of memory allocations. */ char_u * v_throwpoint(char_u *oldval) { if (oldval == NULL) return vimvars[VV_THROWPOINT].vv_str; vimvars[VV_THROWPOINT].vv_str = oldval; return NULL; } /* * Set v:cmdarg. * If "eap" != NULL, use "eap" to generate the value and return the old value. * If "oldarg" != NULL, restore the value to "oldarg" and return NULL. * Must always be called in pairs! */ char_u * set_cmdarg(exarg_T *eap, char_u *oldarg) { char_u *oldval; char_u *newval; unsigned len; oldval = vimvars[VV_CMDARG].vv_str; if (eap == NULL) { vim_free(oldval); vimvars[VV_CMDARG].vv_str = oldarg; return NULL; } if (eap->force_bin == FORCE_BIN) len = 6; else if (eap->force_bin == FORCE_NOBIN) len = 8; else len = 0; if (eap->read_edit) len += 7; if (eap->force_ff != 0) len += 10; // " ++ff=unix" if (eap->force_enc != 0) len += (unsigned)STRLEN(eap->cmd + eap->force_enc) + 7; if (eap->bad_char != 0) len += 7 + 4; // " ++bad=" + "keep" or "drop" newval = alloc(len + 1); if (newval == NULL) return NULL; if (eap->force_bin == FORCE_BIN) sprintf((char *)newval, " ++bin"); else if (eap->force_bin == FORCE_NOBIN) sprintf((char *)newval, " ++nobin"); else *newval = NUL; if (eap->read_edit) STRCAT(newval, " ++edit"); if (eap->force_ff != 0) sprintf((char *)newval + STRLEN(newval), " ++ff=%s", eap->force_ff == 'u' ? "unix" : eap->force_ff == 'd' ? "dos" : "mac"); if (eap->force_enc != 0) sprintf((char *)newval + STRLEN(newval), " ++enc=%s", eap->cmd + eap->force_enc); if (eap->bad_char == BAD_KEEP) STRCPY(newval + STRLEN(newval), " ++bad=keep"); else if (eap->bad_char == BAD_DROP) STRCPY(newval + STRLEN(newval), " ++bad=drop"); else if (eap->bad_char != 0) sprintf((char *)newval + STRLEN(newval), " ++bad=%c", eap->bad_char); vimvars[VV_CMDARG].vv_str = newval; return oldval; } /* * Get the value of internal variable "name". * If "flags" has EVAL_VAR_IMPORT may return a VAR_ANY with v_number set to the * imported script ID. * Return OK or FAIL. If OK is returned "rettv" must be cleared. */ int eval_variable( char_u *name, int len, // length of "name" or zero scid_T sid, // script ID for imported item or zero typval_T *rettv, // NULL when only checking existence dictitem_T **dip, // non-NULL when typval's dict item is needed int flags) // EVAL_VAR_ flags { int ret = OK; typval_T *tv = NULL; int found = FALSE; hashtab_T *ht = NULL; int cc = 0; type_T *type = NULL; if (len > 0) { // truncate the name, so that we can use strcmp() cc = name[len]; name[len] = NUL; } // Check for local variable when debugging. if ((sid == 0) && (tv = lookup_debug_var(name)) == NULL) { // Check for user-defined variables. dictitem_T *v = find_var(name, &ht, flags & EVAL_VAR_NOAUTOLOAD); if (v != NULL) { tv = &v->di_tv; if (dip != NULL) *dip = v; } else ht = NULL; } if (tv == NULL && (in_vim9script() || STRNCMP(name, "s:", 2) == 0)) { imported_T *import = NULL; char_u *p = STRNCMP(name, "s:", 2) == 0 ? name + 2 : name; if (sid == 0) import = find_imported(p, 0, TRUE); // imported variable from another script if (import != NULL || sid != 0) { if ((flags & EVAL_VAR_IMPORT) == 0) { if (SCRIPT_ID_VALID(sid)) { ht = &SCRIPT_VARS(sid); if (ht != NULL) { dictitem_T *v = find_var_in_ht(ht, 0, name, flags & EVAL_VAR_NOAUTOLOAD); if (v != NULL) { tv = &v->di_tv; if (dip != NULL) *dip = v; } else ht = NULL; } } else { if (flags & EVAL_VAR_VERBOSE) semsg(_(e_expected_dot_after_name_str), name); ret = FAIL; } } else { if (rettv != NULL) { // special value that is used in handle_subscript() rettv->v_type = VAR_ANY; rettv->vval.v_number = sid != 0 ? sid : import->imp_sid; } found = TRUE; } } else if (in_vim9script() && (flags & EVAL_VAR_NO_FUNC) == 0) { int has_g_prefix = STRNCMP(name, "g:", 2) == 0; ufunc_T *ufunc = find_func(name, FALSE); // In Vim9 script we can get a function reference by using the // function name. For a global non-autoload function "g:" is // required. if (ufunc != NULL && (has_g_prefix || !func_requires_g_prefix(ufunc))) { found = TRUE; if (rettv != NULL) { rettv->v_type = VAR_FUNC; if (has_g_prefix) // Keep the "g:", otherwise script-local may be // assumed. rettv->vval.v_string = vim_strsave(name); else rettv->vval.v_string = vim_strsave(ufunc->uf_name); if (rettv->vval.v_string != NULL) func_ref(ufunc->uf_name); } } } } if (!found) { if (tv == NULL) { if (rettv != NULL && (flags & EVAL_VAR_VERBOSE)) semsg(_(e_undefined_variable_str), name); ret = FAIL; } else if (rettv != NULL) { svar_T *sv = NULL; int was_assigned = FALSE; if (ht != NULL && ht == get_script_local_ht() && tv != &SCRIPT_SV(current_sctx.sc_sid)->sv_var.di_tv) { sv = find_typval_in_script(tv, 0, TRUE); if (sv != NULL) { type = sv->sv_type; was_assigned = sv->sv_flags & SVFLAG_ASSIGNED; } } if ((tv->v_type == VAR_TYPEALIAS || tv->v_type == VAR_CLASS) && sid != 0) { // type alias or class imported from another script. Check // whether it is exported from the other script. sv = find_typval_in_script(tv, sid, TRUE); if (sv == NULL) { ret = FAIL; goto done; } if ((sv->sv_flags & SVFLAG_EXPORTED) == 0) { semsg(_(e_item_not_exported_in_script_str), name); ret = FAIL; goto done; } } // If a list or dict variable wasn't initialized and has meaningful // type, do it now. Not for global variables, they are not // declared. if (ht != &globvarht) { if (tv->v_type == VAR_DICT && tv->vval.v_dict == NULL && ((type != NULL && !was_assigned) || !in_vim9script())) { tv->vval.v_dict = dict_alloc(); if (tv->vval.v_dict != NULL) { ++tv->vval.v_dict->dv_refcount; tv->vval.v_dict->dv_type = alloc_type(type); if (sv != NULL) sv->sv_flags |= SVFLAG_ASSIGNED; } } else if (tv->v_type == VAR_LIST && tv->vval.v_list == NULL && ((type != NULL && !was_assigned) || !in_vim9script())) { tv->vval.v_list = list_alloc(); if (tv->vval.v_list != NULL) { ++tv->vval.v_list->lv_refcount; tv->vval.v_list->lv_type = alloc_type(type); if (sv != NULL) sv->sv_flags |= SVFLAG_ASSIGNED; } } else if (tv->v_type == VAR_BLOB && tv->vval.v_blob == NULL && ((type != NULL && !was_assigned) || !in_vim9script())) { tv->vval.v_blob = blob_alloc(); if (tv->vval.v_blob != NULL) { ++tv->vval.v_blob->bv_refcount; if (sv != NULL) sv->sv_flags |= SVFLAG_ASSIGNED; } } } copy_tv(tv, rettv); } } done: if (len > 0) name[len] = cc; return ret; } /* * Get the value of internal variable "name", also handling "import.name". * Return OK or FAIL. If OK is returned "rettv" must be cleared. */ int eval_variable_import( char_u *name, typval_T *rettv) { char_u *s = name; while (ASCII_ISALNUM(*s) || *s == '_') ++s; int len = (int)(s - name); if (eval_variable(name, len, 0, rettv, NULL, EVAL_VAR_IMPORT) == FAIL) return FAIL; if (rettv->v_type == VAR_ANY && *s == '.') { char_u *ns = s + 1; s = ns; while (ASCII_ISALNUM(*s) || *s == '_') ++s; int sid = rettv->vval.v_number; return eval_variable(ns, (int)(s - ns), sid, rettv, NULL, 0); } return OK; } /* * Check if variable "name[len]" is a local variable or an argument. * If so, "*eval_lavars_used" is set to TRUE. */ void check_vars(char_u *name, int len) { int cc; char_u *varname; hashtab_T *ht; if (eval_lavars_used == NULL) return; // truncate the name, so that we can use strcmp() cc = name[len]; name[len] = NUL; ht = find_var_ht(name, &varname); if (ht == get_funccal_local_ht() || ht == get_funccal_args_ht()) { if (find_var(name, NULL, TRUE) != NULL) *eval_lavars_used = TRUE; } name[len] = cc; } /* * Find variable "name" in the list of variables. * Return a pointer to it if found, NULL if not found. * Careful: "a:0" variables don't have a name. * When "htp" is not NULL set "htp" to the hashtab_T used. */ dictitem_T * find_var(char_u *name, hashtab_T **htp, int no_autoload) { char_u *varname; hashtab_T *ht; dictitem_T *ret = NULL; ht = find_var_ht(name, &varname); if (htp != NULL) *htp = ht; if (ht == NULL) return NULL; ret = find_var_in_ht(ht, *name, varname, no_autoload); if (ret != NULL) return ret; // Search in parent scope for lambda ret = find_var_in_scoped_ht(name, no_autoload); if (ret != NULL) return ret; // in Vim9 script items without a scope can be script-local if (in_vim9script() && name[0] != NUL && name[1] != ':') { ht = get_script_local_ht(); if (ht != NULL) { ret = find_var_in_ht(ht, *name, varname, no_autoload); if (ret != NULL) { if (htp != NULL) *htp = ht; return ret; } } } // When using "vim9script autoload" script-local items are prefixed but can // be used with s:name. if (SCRIPT_ID_VALID(current_sctx.sc_sid) && (in_vim9script() || (name[0] == 's' && name[1] == ':'))) { scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); if (si->sn_autoload_prefix != NULL) { char_u *base_name = (name[0] == 's' && name[1] == ':') ? name + 2 : name; char_u *auto_name = concat_str(si->sn_autoload_prefix, base_name); if (auto_name != NULL) { ht = &globvarht; ret = find_var_in_ht(ht, 'g', auto_name, TRUE); vim_free(auto_name); if (ret != NULL) { if (htp != NULL) *htp = ht; return ret; } } } } return NULL; } /* * Like find_var() but if the name starts with <SNR>99_ then look in the * referenced script (used for a funcref). */ dictitem_T * find_var_also_in_script(char_u *name, hashtab_T **htp, int no_autoload) { if (STRNCMP(name, "<SNR>", 5) == 0 && isdigit(name[5])) { char_u *p = name + 5; int sid = getdigits(&p); if (SCRIPT_ID_VALID(sid) && *p == '_') { hashtab_T *ht = &SCRIPT_VARS(sid); if (ht != NULL) { dictitem_T *di = find_var_in_ht(ht, 0, p + 1, no_autoload); if (di != NULL) { if (htp != NULL) *htp = ht; return di; } } } } return find_var(name, htp, no_autoload); } /* * Find variable "varname" in hashtab "ht" with name "htname". * When "varname" is empty returns curwin/curtab/etc vars dictionary. * Returns NULL if not found. */ dictitem_T * find_var_in_ht( hashtab_T *ht, int htname, char_u *varname, int no_autoload) { hashitem_T *hi; if (*varname == NUL) { // Must be something like "s:", otherwise "ht" would be NULL. switch (htname) { case 's': return &SCRIPT_SV(current_sctx.sc_sid)->sv_var; case 'g': return &globvars_var; case 'v': return &vimvars_var; case 'b': return &curbuf->b_bufvar; case 'w': return &curwin->w_winvar; case 't': return &curtab->tp_winvar; case 'l': return get_funccal_local_var(); case 'a': return get_funccal_args_var(); } return NULL; } hi = hash_find(ht, varname); if (HASHITEM_EMPTY(hi)) { // For global variables we may try auto-loading the script. If it // worked find the variable again. Don't auto-load a script if it was // loaded already, otherwise it would be loaded every time when // checking if a function name is a Funcref variable. if (ht == &globvarht && !no_autoload) { // Note: script_autoload() may make "hi" invalid. It must either // be obtained again or not used. if (!script_autoload(varname, FALSE) || aborting()) return NULL; hi = hash_find(ht, varname); } if (HASHITEM_EMPTY(hi)) return NULL; } return HI2DI(hi); } /* * Get the script-local hashtab. NULL if not in a script context. */ hashtab_T * get_script_local_ht(void) { scid_T sid = current_sctx.sc_sid; if (SCRIPT_ID_VALID(sid)) return &SCRIPT_VARS(sid); return NULL; } /* * Look for "name[len]" in script-local variables and functions. * When "cmd" is TRUE it must look like a command, a function must be followed * by "(" or "->". * Return OK when found, FAIL when not found. */ int lookup_scriptitem( char_u *name, size_t len, int cmd, cctx_T *dummy UNUSED) { hashtab_T *ht = get_script_local_ht(); char_u buffer[30]; char_u *p; int res; hashitem_T *hi; int is_global = FALSE; char_u *fname = name; if (ht == NULL) return FAIL; if (len < sizeof(buffer) - 1) { // avoid an alloc/free for short names vim_strncpy(buffer, name, len); p = buffer; } else { p = vim_strnsave(name, len); if (p == NULL) return FAIL; } hi = hash_find(ht, p); res = HASHITEM_EMPTY(hi) ? FAIL : OK; // if not script-local, then perhaps imported if (res == FAIL && find_imported(p, 0, FALSE) != NULL) res = OK; if (p != buffer) vim_free(p); // Find a function, so that a following "->" works. // When used as a command require "(" or "->" to follow, "Cmd" is a user // command while "Cmd()" is a function call. if (res != OK) { p = skipwhite(name + len); if (!cmd || name[len] == '(' || (p[0] == '-' && p[1] == '>')) { // Do not check for an internal function, since it might also be a // valid command, such as ":split" versus "split()". // Skip "g:" before a function name. if (name[0] == 'g' && name[1] == ':') { is_global = TRUE; fname = name + 2; } if (find_func(fname, is_global) != NULL) res = OK; } } return res; } /* * Find the hashtab used for a variable name. * Return NULL if the name is not valid. * Set "varname" to the start of name without ':'. */ hashtab_T * find_var_ht(char_u *name, char_u **varname) { hashitem_T *hi; hashtab_T *ht; if (name[0] == NUL) return NULL; if (name[1] != ':') { // The name must not start with a colon or #. if (name[0] == ':' || name[0] == AUTOLOAD_CHAR) return NULL; *varname = name; // "version" is "v:version" in all scopes if scriptversion < 3. // Same for a few other variables marked with VV_COMPAT. if (in_old_script(3)) { hi = hash_find(&compat_hashtab, name); if (!HASHITEM_EMPTY(hi)) return &compat_hashtab; } ht = get_funccal_local_ht(); if (ht != NULL) return ht; // local variable // In Vim9 script items at the script level are script-local, except // for autoload names. if (in_vim9script() && vim_strchr(name, AUTOLOAD_CHAR) == NULL) { ht = get_script_local_ht(); if (ht != NULL) return ht; } return &globvarht; // global variable } *varname = name + 2; if (*name == 'g') // global variable return &globvarht; // There must be no ':' or '#' in the rest of the name, unless g: is used if (vim_strchr(name + 2, ':') != NULL || vim_strchr(name + 2, AUTOLOAD_CHAR) != NULL) return NULL; if (*name == 'b') // buffer variable return &curbuf->b_vars->dv_hashtab; if (*name == 'w') // window variable return &curwin->w_vars->dv_hashtab; if (*name == 't') // tab page variable return &curtab->tp_vars->dv_hashtab; if (*name == 'v') // v: variable return &vimvarht; if (get_current_funccal() != NULL && get_current_funccal()->fc_func->uf_def_status == UF_NOT_COMPILED) { // a: and l: are only used in functions defined with ":function" if (*name == 'a') // a: function argument return get_funccal_args_ht(); if (*name == 'l') // l: local function variable return get_funccal_local_ht(); } if (*name == 's') // script variable { ht = get_script_local_ht(); if (ht != NULL) return ht; } return NULL; } /* * Get the string value of a (global/local) variable. * Note: see tv_get_string() for how long the pointer remains valid. * Returns NULL when it doesn't exist. */ char_u * get_var_value(char_u *name) { dictitem_T *v; v = find_var(name, NULL, FALSE); if (v == NULL) return NULL; return tv_get_string(&v->di_tv); } /* * Allocate a new hashtab for a sourced script. It will be used while * sourcing this script and when executing functions defined in the script. */ void new_script_vars(scid_T id) { scriptvar_T *sv; sv = ALLOC_CLEAR_ONE(scriptvar_T); if (sv == NULL) return; init_var_dict(&sv->sv_dict, &sv->sv_var, VAR_SCOPE); SCRIPT_ITEM(id)->sn_vars = sv; } /* * Initialize dictionary "dict" as a scope and set variable "dict_var" to * point to it. */ void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope) { hash_init(&dict->dv_hashtab); dict->dv_lock = 0; dict->dv_scope = scope; dict->dv_refcount = DO_NOT_FREE_CNT; dict->dv_copyID = 0; dict_var->di_tv.vval.v_dict = dict; dict_var->di_tv.v_type = VAR_DICT; dict_var->di_tv.v_lock = VAR_FIXED; dict_var->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; dict_var->di_key[0] = NUL; } /* * Unreference a dictionary initialized by init_var_dict(). */ void unref_var_dict(dict_T *dict) { // Now the dict needs to be freed if no one else is using it, go back to // normal reference counting. dict->dv_refcount -= DO_NOT_FREE_CNT - 1; dict_unref(dict); } /* * Clean up a list of internal variables. * Frees all allocated variables and the value they contain. * Clears hashtab "ht", does not free it. */ void vars_clear(hashtab_T *ht) { vars_clear_ext(ht, TRUE); } /* * Like vars_clear(), but only free the value if "free_val" is TRUE. */ void vars_clear_ext(hashtab_T *ht, int free_val) { int todo; hashitem_T *hi; dictitem_T *v; hash_lock(ht); todo = (int)ht->ht_used; FOR_ALL_HASHTAB_ITEMS(ht, hi, todo) { if (!HASHITEM_EMPTY(hi)) { --todo; // Free the variable. Don't remove it from the hashtab, // ht_array might change then. hash_clear() takes care of it // later. v = HI2DI(hi); if (free_val) clear_tv(&v->di_tv); if (v->di_flags & DI_FLAGS_ALLOC) vim_free(v); } } hash_clear(ht); hash_init(ht); } /* * Delete a variable from hashtab "ht" at item "hi". * Clear the variable value and free the dictitem. */ void delete_var(hashtab_T *ht, hashitem_T *hi) { dictitem_T *di = HI2DI(hi); if (hash_remove(ht, hi, "delete variable") != OK) return; clear_tv(&di->di_tv); vim_free(di); } /* * List the value of one internal variable. */ static void list_one_var(dictitem_T *v, char *prefix, int *first) { char_u *tofree; char_u *s; char_u numbuf[NUMBUFLEN]; s = echo_string(&v->di_tv, &tofree, numbuf, get_copyID()); list_one_var_a(prefix, v->di_key, v->di_tv.v_type, s == NULL ? (char_u *)"" : s, first); vim_free(tofree); } static void list_one_var_a( char *prefix, char_u *name, int type, char_u *string, int *first) // when TRUE clear rest of screen and set to FALSE { // don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" msg_start(); msg_puts(prefix); if (name != NULL) // "a:" vars don't have a name stored msg_puts((char *)name); msg_putchar(' '); msg_advance(22); if (type == VAR_NUMBER) msg_putchar('#'); else if (type == VAR_FUNC || type == VAR_PARTIAL) msg_putchar('*'); else if (type == VAR_LIST) { msg_putchar('['); if (*string == '[') ++string; } else if (type == VAR_DICT) { msg_putchar('{'); if (*string == '{') ++string; } else msg_putchar(' '); msg_outtrans(string); if (type == VAR_FUNC || type == VAR_PARTIAL) msg_puts("()"); if (*first) { msg_clr_eos(); *first = FALSE; } } /* * Addition handling for setting a v: variable. * Return TRUE if the variable should be set normally, * FALSE if nothing else needs to be done. */ int before_set_vvar( char_u *varname, dictitem_T *di, typval_T *tv, int copy, int *type_error) { if (di->di_tv.v_type == VAR_STRING) { VIM_CLEAR(di->di_tv.vval.v_string); if (copy || tv->v_type != VAR_STRING) { char_u *val = tv_get_string(tv); // Careful: when assigning to v:errmsg and // tv_get_string() causes an error message the variable // will already be set. if (di->di_tv.vval.v_string == NULL) di->di_tv.vval.v_string = vim_strsave(val); } else { // Take over the string to avoid an extra alloc/free. di->di_tv.vval.v_string = tv->vval.v_string; tv->vval.v_string = NULL; } return FALSE; } else if (di->di_tv.v_type == VAR_NUMBER) { di->di_tv.vval.v_number = tv_get_number(tv); if (STRCMP(varname, "searchforward") == 0) set_search_direction(di->di_tv.vval.v_number ? '/' : '?'); #ifdef FEAT_SEARCH_EXTRA else if (STRCMP(varname, "hlsearch") == 0) { no_hlsearch = !di->di_tv.vval.v_number; redraw_all_later(UPD_SOME_VALID); } #endif return FALSE; } else if (di->di_tv.v_type != tv->v_type) { *type_error = TRUE; return FALSE; } return TRUE; } /* * Set variable "name" to value in "tv". * If the variable already exists, the value is updated. * Otherwise the variable is created. */ void set_var( char_u *name, typval_T *tv, int copy) // make copy of value in "tv" { set_var_const(name, 0, NULL, tv, copy, ASSIGN_DECL, 0); } /* * Set variable "name" to value in "tv_arg". * When "sid" is non-zero "name" is in the script with this ID. * If the variable already exists and "is_const" is FALSE the value is updated. * Otherwise the variable is created. */ void set_var_const( char_u *name, scid_T sid, type_T *type_arg, typval_T *tv_arg, int copy, // make copy of value in "tv" int flags_arg, // ASSIGN_CONST, ASSIGN_FINAL, etc. int var_idx) // index for ":let [a, b] = list" { typval_T *tv = tv_arg; type_T *type = type_arg; typval_T bool_tv; dictitem_T *di; typval_T *dest_tv; char_u *varname; char_u *name_tofree = NULL; hashtab_T *ht = NULL; int is_script_local; int vim9script = in_vim9script(); int var_in_vim9script; int var_in_autoload = FALSE; int flags = flags_arg; int free_tv_arg = !copy; // free tv_arg if not used if (sid != 0) { if (SCRIPT_ID_VALID(sid)) ht = &SCRIPT_VARS(sid); varname = name; } else { scriptitem_T *si; if (in_vim9script() && is_export && SCRIPT_ID_VALID(current_sctx.sc_sid) && (si = SCRIPT_ITEM(current_sctx.sc_sid)) ->sn_autoload_prefix != NULL) { // In a vim9 autoload script an exported variable is put in the // global namespace with the autoload prefix. var_in_autoload = TRUE; varname = concat_str(si->sn_autoload_prefix, name); if (varname == NULL) goto failed; name_tofree = varname; ht = &globvarht; } else ht = find_var_ht(name, &varname); } if (ht == NULL || *varname == NUL) { semsg(_(e_illegal_variable_name_str), name); goto failed; } is_script_local = ht == get_script_local_ht() || sid != 0 || var_in_autoload; if (vim9script && !is_script_local && (flags & (ASSIGN_NO_DECL | ASSIGN_DECL)) == 0 && (flags & (ASSIGN_CONST | ASSIGN_FINAL)) == 0 && name[1] == ':') { vim9_declare_error(name); goto failed; } if ((flags & ASSIGN_FOR_LOOP) && is_scoped_variable(name)) // Do not make g:var, w:var, b:var or t:var final. flags &= ~ASSIGN_FINAL; var_in_vim9script = is_script_local && current_script_is_vim9(); if (var_in_vim9script && name[0] == '_' && name[1] == NUL) { // For "[a, _] = list" the underscore is ignored. if ((flags & ASSIGN_UNPACK) == 0) emsg(_(e_cannot_use_underscore_here)); goto failed; } di = find_var_in_ht(ht, 0, varname, TRUE); if (di == NULL && var_in_vim9script) { imported_T *import = find_imported(varname, 0, FALSE); if (import != NULL) { // imported name space cannot be used if ((flags & ASSIGN_NO_DECL) == 0) { semsg(_(e_redefining_imported_item_str), name); goto failed; } semsg(_(e_cannot_use_str_itself_it_is_imported), name); goto failed; } if (!in_vim9script()) { semsg(_(e_cannot_create_vim9_script_variable_in_function_str), name); goto failed; } } // Search in parent scope which is possible to reference from lambda if (di == NULL) di = find_var_in_scoped_ht(name, TRUE); if ((tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL) && var_wrong_func_name(name, di == NULL)) goto failed; if (need_convert_to_bool(type, tv)) { // Destination is a bool and the value is not, but it can be // converted. CLEAR_FIELD(bool_tv); bool_tv.v_type = VAR_BOOL; bool_tv.vval.v_number = tv2bool(tv) ? VVAL_TRUE : VVAL_FALSE; tv = &bool_tv; } if (di != NULL) { // Item already exists. Allowed to replace when reloading. if ((di->di_flags & DI_FLAGS_RELOAD) == 0) { if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) && (flags & ASSIGN_FOR_LOOP) == 0) { emsg(_(e_cannot_modify_existing_variable)); goto failed; } if (is_script_local && vim9script && (flags & (ASSIGN_NO_DECL | ASSIGN_DECL)) == 0) { semsg(_(e_redefining_script_item_str), name); goto failed; } if (check_typval_is_value(&di->di_tv) == FAIL) goto failed; if (var_in_vim9script && (flags & ASSIGN_FOR_LOOP) == 0) { where_T where = WHERE_INIT; svar_T *sv = find_typval_in_script(&di->di_tv, sid, TRUE); if (sv != NULL) { // check the type and adjust to bool if needed if (var_idx > 0) { where.wt_index = var_idx; where.wt_kind = WT_VARIABLE; } if (check_script_var_type(sv, tv, name, where) == FAIL) goto failed; if (type == NULL) type = sv->sv_type; sv->sv_flags |= SVFLAG_ASSIGNED; } } if ((flags & ASSIGN_FOR_LOOP) == 0 ? var_check_permission(di, name) == FAIL : var_check_ro(di->di_flags, name, FALSE)) goto failed; } else { // can only redefine once di->di_flags &= ~DI_FLAGS_RELOAD; // A Vim9 script-local variable is also present in sn_all_vars // and sn_var_vals. It may set "type" from "tv". if (var_in_vim9script || var_in_autoload) update_vim9_script_var(FALSE, di, var_in_autoload ? name : di->di_key, flags, tv, &type, (flags & ASSIGN_NO_MEMBER_TYPE) == 0); } // existing variable, need to clear the value // Handle setting internal v: variables separately where needed to // prevent changing the type. int type_error = FALSE; if (ht == &vimvarht && !before_set_vvar(varname, di, tv, copy, &type_error)) { if (type_error) semsg(_(e_setting_v_str_to_value_with_wrong_type), varname); goto failed; } clear_tv(&di->di_tv); if ((flags & ASSIGN_UPDATE_BLOCK_ID) && SCRIPT_ID_VALID(current_sctx.sc_sid)) { scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); update_script_var_block_id(name, si->sn_current_block_id); } } else { // Item not found, check if a function already exists. if (is_script_local && (flags & (ASSIGN_NO_DECL | ASSIGN_DECL)) == 0 && lookup_scriptitem(name, STRLEN(name), FALSE, NULL) == OK) { semsg(_(e_redefining_script_item_str), name); goto failed; } // add a new variable if (var_in_vim9script && (flags & ASSIGN_NO_DECL)) { semsg(_(e_unknown_variable_str), name); goto failed; } if (check_hashtab_frozen(ht, "add variable")) goto failed; // Can't add "v:" or "a:" variable. if (ht == &vimvarht || ht == get_funccal_args_ht()) { semsg(_(e_illegal_variable_name_str), name); goto failed; } // Make sure the variable name is valid. In Vim9 script an // autoload variable must be prefixed with "g:" unless in an // autoload script. if (!valid_varname(varname, -1, !vim9script || STRNCMP(name, "g:", 2) == 0 || var_in_autoload)) goto failed; di = alloc(offsetof(dictitem_T, di_key) + STRLEN(varname) + 1); if (di == NULL) goto failed; STRCPY(di->di_key, varname); if (hash_add(ht, DI2HIKEY(di), "add variable") == FAIL) { vim_free(di); goto failed; } di->di_flags = DI_FLAGS_ALLOC; if (flags & (ASSIGN_CONST | ASSIGN_FINAL)) di->di_flags |= DI_FLAGS_LOCK; // A Vim9 script-local variable is also added to sn_all_vars and // sn_var_vals. It may set "type" from "tv". if (var_in_vim9script || var_in_autoload) update_vim9_script_var(TRUE, di, var_in_autoload ? name : di->di_key, flags, tv, &type, (flags & ASSIGN_NO_MEMBER_TYPE) == 0); } dest_tv = &di->di_tv; if (copy || tv->v_type == VAR_NUMBER || tv->v_type == VAR_FLOAT) copy_tv(tv, dest_tv); else { *dest_tv = *tv; dest_tv->v_lock = 0; init_tv(tv); } free_tv_arg = FALSE; if (vim9script && type != NULL) set_tv_type(dest_tv, type); // ":const var = value" locks the value // ":final var = value" locks "var" if (flags & ASSIGN_CONST) // Like :lockvar! name: lock the value and what it contains, but only // if the reference count is up to one. That locks only literal // values. item_lock(dest_tv, DICT_MAXNEST, TRUE, TRUE); failed: vim_free(name_tofree); if (free_tv_arg) clear_tv(tv_arg); } /* * Check in this order for backwards compatibility: * - Whether the variable is read-only * - Whether the variable value is locked * - Whether the variable is locked */ int var_check_permission(dictitem_T *di, char_u *name) { if (var_check_ro(di->di_flags, name, FALSE) || value_check_lock(di->di_tv.v_lock, name, FALSE) || var_check_lock(di->di_flags, name, FALSE)) return FAIL; return OK; } /* * Return TRUE if di_flags "flags" indicates variable "name" is read-only. * Also give an error message. */ int var_check_ro(int flags, char_u *name, int use_gettext) { if (flags & DI_FLAGS_RO) { if (name == NULL) emsg(_(e_cannot_change_readonly_variable)); else semsg(_(e_cannot_change_readonly_variable_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } if ((flags & DI_FLAGS_RO_SBX) && sandbox) { if (name == NULL) emsg(_(e_cannot_set_variable_in_sandbox)); else semsg(_(e_cannot_set_variable_in_sandbox_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } return FALSE; } /* * Return TRUE if di_flags "flags" indicates variable "name" is locked. * Also give an error message. */ int var_check_lock(int flags, char_u *name, int use_gettext) { if (flags & DI_FLAGS_LOCK) { semsg(_(e_variable_is_locked_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } return FALSE; } /* * Return TRUE if di_flags "flags" indicates variable "name" is fixed. * Also give an error message. */ int var_check_fixed(int flags, char_u *name, int use_gettext) { if (flags & DI_FLAGS_FIX) { if (name == NULL) emsg(_(e_cannot_delete_variable)); else semsg(_(e_cannot_delete_variable_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } return FALSE; } /* * Check if a funcref is assigned to a valid variable name. * Return TRUE and give an error if not. */ int var_wrong_func_name( char_u *name, // points to start of variable name int new_var) // TRUE when creating the variable { // Allow for w: b: s: and t:. In Vim9 script s: is not allowed, because // the name can be used without the s: prefix. // Allow autoload variable. if (!((vim_strchr((char_u *)"wbt", name[0]) != NULL || (!in_vim9script() && name[0] == 's')) && name[1] == ':') && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':') ? name[2] : name[0]) && vim_strchr(name, '#') == NULL) { semsg(_(e_funcref_variable_name_must_start_with_capital_str), name); return TRUE; } // Don't allow hiding a function. When "v" is not NULL we might be // assigning another function to the same var, the type is checked // below. if (new_var && function_exists(name, FALSE)) { semsg(_(e_variable_name_conflicts_with_existing_function_str), name); return TRUE; } return FALSE; } /* * Return TRUE if "flags" indicates variable "name" has a locked (immutable) * value. Also give an error message, using "name" or _("name") when * "use_gettext" is TRUE. */ int value_check_lock(int lock, char_u *name, int use_gettext) { if (lock & VAR_LOCKED) { if (name == NULL) emsg(_(e_value_is_locked)); else semsg(_(e_value_is_locked_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } if (lock & VAR_FIXED) { if (name == NULL) emsg(_(e_cannot_change_value)); else semsg(_(e_cannot_change_value_of_str), use_gettext ? (char_u *)_(name) : name); return TRUE; } return FALSE; } /* * Check if a variable name is valid. When "autoload" is true "#" is allowed. * If "len" is -1 use all of "varname", otherwise up to "varname[len]". * Return FALSE and give an error if not. */ int valid_varname(char_u *varname, int len, int autoload) { char_u *p; for (p = varname; len < 0 ? *p != NUL : p < varname + len; ++p) if (!eval_isnamec1(*p) && (p == varname || !VIM_ISDIGIT(*p)) && !(autoload && *p == AUTOLOAD_CHAR)) { semsg(_(e_illegal_variable_name_str), varname); return FALSE; } return TRUE; } /* * Implements the logic to retrieve local variable and option values. * Used by "getwinvar()" "gettabvar()" "gettabwinvar()" "getbufvar()". */ static void get_var_from( char_u *varname, typval_T *rettv, typval_T *deftv, // Default value if not found. int htname, // 't'ab, 'w'indow or 'b'uffer local. tabpage_T *tp, // can be NULL win_T *win, buf_T *buf) // Ignored if htname is not 'b'. { dictitem_T *v; int done = FALSE; switchwin_T switchwin; int need_switch_win; int do_change_curbuf = buf != NULL && htname == 'b'; ++emsg_off; rettv->v_type = VAR_STRING; rettv->vval.v_string = NULL; if (varname != NULL && tp != NULL && win != NULL && (htname != 'b' || buf != NULL)) { // Set curwin to be our win, temporarily. Also set the tabpage, // otherwise the window is not valid. Only do this when needed, // autocommands get blocked. // If we have a buffer reference avoid the switching, we're saving and // restoring curbuf directly. need_switch_win = !(tp == curtab && win == curwin) && !do_change_curbuf; if (!need_switch_win || switch_win(&switchwin, win, tp, TRUE) == OK) { // Handle options. There are no tab-local options. if (*varname == '&' && htname != 't') { buf_T *save_curbuf = curbuf; // Change curbuf so the option is read from the correct buffer. if (do_change_curbuf) curbuf = buf; if (varname[1] == NUL) { // get all window-local or buffer-local options in a dict dict_T *opts = get_winbuf_options(htname == 'b'); if (opts != NULL) { rettv_dict_set(rettv, opts); done = TRUE; } } else if (eval_option(&varname, rettv, TRUE) == OK) // Local option done = TRUE; curbuf = save_curbuf; } else if (*varname == NUL) { // Empty string: return a dict with all the local variables. if (htname == 'b') v = &buf->b_bufvar; else if (htname == 'w') v = &win->w_winvar; else v = &tp->tp_winvar; copy_tv(&v->di_tv, rettv); done = TRUE; } else { hashtab_T *ht; if (htname == 'b') ht = &buf->b_vars->dv_hashtab; else if (htname == 'w') ht = &win->w_vars->dv_hashtab; else ht = &tp->tp_vars->dv_hashtab; // Look up the variable. v = find_var_in_ht(ht, htname, varname, FALSE); if (v != NULL) { copy_tv(&v->di_tv, rettv); done = TRUE; } } } if (need_switch_win) // restore previous notion of curwin restore_win(&switchwin, TRUE); } if (!done && deftv->v_type != VAR_UNKNOWN) // use the default value copy_tv(deftv, rettv); --emsg_off; } /* * getwinvar() and gettabwinvar() */ static void getwinvar( typval_T *argvars, typval_T *rettv, int off) // 1 for gettabwinvar() { char_u *varname; tabpage_T *tp; win_T *win; if (off == 1) tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL)); else tp = curtab; win = find_win_by_nr(&argvars[off], tp); varname = tv_get_string_chk(&argvars[off + 1]); get_var_from(varname, rettv, &argvars[off + 2], 'w', tp, win, NULL); } /* * Set option "varname" to the value of "varp" for the current buffer/window. */ static void set_option_from_tv(char_u *varname, typval_T *varp) { long numval = 0; char_u *strval; char_u nbuf[NUMBUFLEN]; int error = FALSE; int opt_idx = findoption(varname); if (opt_idx < 0) { semsg(_(e_unknown_option_str_2), varname); return; } int opt_p_flags = get_option_flags(opt_idx); if (varp->v_type == VAR_BOOL) { if (opt_p_flags & P_STRING) { emsg(_(e_string_required)); return; } numval = (long)varp->vval.v_number; strval = (char_u *)"0"; // avoid using "false" } else { if ((opt_p_flags & (P_NUM|P_BOOL)) && (!in_vim9script() || varp->v_type != VAR_STRING)) numval = (long)tv_get_number_chk(varp, &error); if (!error) strval = tv_get_string_buf_chk(varp, nbuf); } if (!error && strval != NULL) set_option_value_give_err(varname, numval, strval, OPT_LOCAL); } /* * "setwinvar()" and "settabwinvar()" functions */ static void setwinvar(typval_T *argvars, int off) { win_T *win; switchwin_T switchwin; int need_switch_win; char_u *varname, *winvarname; typval_T *varp; tabpage_T *tp = NULL; if (check_secure()) return; if (off == 1) tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL)); else tp = curtab; win = find_win_by_nr(&argvars[off], tp); varname = tv_get_string_chk(&argvars[off + 1]); varp = &argvars[off + 2]; if (win == NULL || varname == NULL) return; need_switch_win = !(tp == curtab && win == curwin); if (!need_switch_win || switch_win(&switchwin, win, tp, TRUE) == OK) { if (*varname == '&') set_option_from_tv(varname + 1, varp); else { winvarname = alloc(STRLEN(varname) + 3); if (winvarname != NULL) { STRCPY(winvarname, "w:"); STRCPY(winvarname + 2, varname); set_var(winvarname, varp, TRUE); vim_free(winvarname); } } } if (need_switch_win) restore_win(&switchwin, TRUE); } /* * reset v:option_new, v:option_old, v:option_oldlocal, v:option_oldglobal, * v:option_type, and v:option_command. */ void reset_v_option_vars(void) { set_vim_var_string(VV_OPTION_NEW, NULL, -1); set_vim_var_string(VV_OPTION_OLD, NULL, -1); set_vim_var_string(VV_OPTION_OLDLOCAL, NULL, -1); set_vim_var_string(VV_OPTION_OLDGLOBAL, NULL, -1); set_vim_var_string(VV_OPTION_TYPE, NULL, -1); set_vim_var_string(VV_OPTION_COMMAND, NULL, -1); } /* * Add an assert error to v:errors. */ void assert_error(garray_T *gap) { struct vimvar *vp = &vimvars[VV_ERRORS]; if (vp->vv_tv_type != VAR_LIST || vimvars[VV_ERRORS].vv_list == NULL) // Make sure v:errors is a list. set_vim_var_list(VV_ERRORS, list_alloc()); list_append_string(vimvars[VV_ERRORS].vv_list, gap->ga_data, gap->ga_len); } int var_exists(char_u *var) { char_u *arg = var; char_u *name; char_u *tofree; typval_T tv; int len = 0; int n = FALSE; // get_name_len() takes care of expanding curly braces name = var; len = get_name_len(&arg, &tofree, TRUE, FALSE); if (len > 0) { if (tofree != NULL) name = tofree; n = (eval_variable(name, len, 0, &tv, NULL, EVAL_VAR_NOAUTOLOAD + EVAL_VAR_IMPORT) == OK); if (n) { // handle d.key, l[idx], f(expr) arg = skipwhite(arg); n = (handle_subscript(&arg, name, &tv, &EVALARG_EVALUATE, FALSE) == OK); if (n) clear_tv(&tv); } } if (*arg != NUL) n = FALSE; vim_free(tofree); return n; } static lval_T *redir_lval = NULL; #define EVALCMD_BUSY (redir_lval == (lval_T *)&redir_lval) static garray_T redir_ga; // only valid when redir_lval is not NULL static char_u *redir_endp = NULL; static char_u *redir_varname = NULL; int alloc_redir_lval(void) { redir_lval = ALLOC_CLEAR_ONE(lval_T); if (redir_lval == NULL) return FAIL; return OK; } void clear_redir_lval(void) { VIM_CLEAR(redir_lval); } void init_redir_ga(void) { ga_init2(&redir_ga, sizeof(char), 500); } /* * Start recording command output to a variable * When "append" is TRUE append to an existing variable. * Returns OK if successfully completed the setup. FAIL otherwise. */ int var_redir_start(char_u *name, int append) { int called_emsg_before; typval_T tv; // Catch a bad name early. if (!eval_isnamec1(*name)) { emsg(_(e_invalid_argument)); return FAIL; } // Make a copy of the name, it is used in redir_lval until redir ends. redir_varname = vim_strsave(name); if (redir_varname == NULL) return FAIL; if (alloc_redir_lval() == FAIL) { var_redir_stop(); return FAIL; } // The output is stored in growarray "redir_ga" until redirection ends. init_redir_ga(); // Parse the variable name (can be a dict or list entry). redir_endp = get_lval(redir_varname, NULL, redir_lval, FALSE, FALSE, 0, FNE_CHECK_START); if (redir_endp == NULL || redir_lval->ll_name == NULL || *redir_endp != NUL) { clear_lval(redir_lval); if (redir_endp != NULL && *redir_endp != NUL) // Trailing characters are present after the variable name semsg(_(e_trailing_characters_str), redir_endp); else semsg(_(e_invalid_argument_str), name); redir_endp = NULL; // don't store a value, only cleanup var_redir_stop(); return FAIL; } // check if we can write to the variable: set it to or append an empty // string called_emsg_before = called_emsg; tv.v_type = VAR_STRING; tv.vval.v_string = (char_u *)""; if (append) set_var_lval(redir_lval, redir_endp, &tv, TRUE, ASSIGN_NO_DECL, (char_u *)".", 0); else set_var_lval(redir_lval, redir_endp, &tv, TRUE, ASSIGN_NO_DECL, (char_u *)"=", 0); clear_lval(redir_lval); if (called_emsg > called_emsg_before) { redir_endp = NULL; // don't store a value, only cleanup var_redir_stop(); return FAIL; } return OK; } /* * Append "value[value_len]" to the variable set by var_redir_start(). * The actual appending is postponed until redirection ends, because the value * appended may in fact be the string we write to, changing it may cause freed * memory to be used: * :redir => foo * :let foo * :redir END */ void var_redir_str(char_u *value, int value_len) { int len; if (redir_lval == NULL) return; if (value_len == -1) len = (int)STRLEN(value); // Append the entire string else len = value_len; // Append only "value_len" characters if (ga_grow(&redir_ga, len) == OK) { mch_memmove((char *)redir_ga.ga_data + redir_ga.ga_len, value, len); redir_ga.ga_len += len; } else var_redir_stop(); } /* * Stop redirecting command output to a variable. * Frees the allocated memory. */ void var_redir_stop(void) { typval_T tv; if (EVALCMD_BUSY) { redir_lval = NULL; return; } if (redir_lval != NULL) { // If there was no error: assign the text to the variable. if (redir_endp != NULL) { ga_append(&redir_ga, NUL); // Append the trailing NUL. tv.v_type = VAR_STRING; tv.vval.v_string = redir_ga.ga_data; // Call get_lval() again, if it's inside a Dict or List it may // have changed. redir_endp = get_lval(redir_varname, NULL, redir_lval, FALSE, FALSE, 0, FNE_CHECK_START); if (redir_endp != NULL && redir_lval->ll_name != NULL) set_var_lval(redir_lval, redir_endp, &tv, FALSE, 0, (char_u *)".", 0); clear_lval(redir_lval); } // free the collected output VIM_CLEAR(redir_ga.ga_data); VIM_CLEAR(redir_lval); } VIM_CLEAR(redir_varname); } /* * Get the collected redirected text and clear redir_ga. */ char_u * get_clear_redir_ga(void) { char_u *res; ga_append(&redir_ga, NUL); // Append the trailing NUL. res = redir_ga.ga_data; redir_ga.ga_data = NULL; return res; } /* * "gettabvar()" function */ void f_gettabvar(typval_T *argvars, typval_T *rettv) { char_u *varname; tabpage_T *tp; win_T *win = NULL; if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; varname = tv_get_string_chk(&argvars[1]); tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL)); if (tp != NULL) win = tp == curtab || tp->tp_firstwin == NULL ? firstwin : tp->tp_firstwin; get_var_from(varname, rettv, &argvars[2], 't', tp, win, NULL); } /* * "gettabwinvar()" function */ void f_gettabwinvar(typval_T *argvars, typval_T *rettv) { if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_number_arg(argvars, 1) == FAIL || check_for_string_arg(argvars, 2) == FAIL)) return; getwinvar(argvars, rettv, 1); } /* * "getwinvar()" function */ void f_getwinvar(typval_T *argvars, typval_T *rettv) { if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; getwinvar(argvars, rettv, 0); } /* * "getbufvar()" function */ void f_getbufvar(typval_T *argvars, typval_T *rettv) { char_u *varname; buf_T *buf; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; varname = tv_get_string_chk(&argvars[1]); buf = tv_get_buf_from_arg(&argvars[0]); get_var_from(varname, rettv, &argvars[2], 'b', curtab, curwin, buf); } /* * "settabvar()" function */ void f_settabvar(typval_T *argvars, typval_T *rettv UNUSED) { tabpage_T *save_curtab; tabpage_T *tp; char_u *varname, *tabvarname; typval_T *varp; if (check_secure()) return; if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL)); varname = tv_get_string_chk(&argvars[1]); varp = &argvars[2]; if (varname == NULL || tp == NULL) return; save_curtab = curtab; goto_tabpage_tp(tp, FALSE, FALSE); tabvarname = alloc(STRLEN(varname) + 3); if (tabvarname != NULL) { STRCPY(tabvarname, "t:"); STRCPY(tabvarname + 2, varname); set_var(tabvarname, varp, TRUE); vim_free(tabvarname); } // Restore current tabpage if (valid_tabpage(save_curtab)) goto_tabpage_tp(save_curtab, FALSE, FALSE); } /* * "settabwinvar()" function */ void f_settabwinvar(typval_T *argvars, typval_T *rettv UNUSED) { if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_number_arg(argvars, 1) == FAIL || check_for_string_arg(argvars, 2) == FAIL)) return; setwinvar(argvars, 1); } /* * "setwinvar()" function */ void f_setwinvar(typval_T *argvars, typval_T *rettv UNUSED) { if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; setwinvar(argvars, 0); } /* * "setbufvar()" function */ void f_setbufvar(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; char_u *varname, *bufvarname; typval_T *varp; if (check_secure()) return; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; varname = tv_get_string_chk(&argvars[1]); buf = tv_get_buf_from_arg(&argvars[0]); varp = &argvars[2]; if (buf == NULL || varname == NULL) return; if (*varname == '&') { aco_save_T aco; // Set curbuf to be our buf, temporarily. aucmd_prepbuf(&aco, buf); if (curbuf == buf) { // Only when it worked to set "curbuf". set_option_from_tv(varname + 1, varp); // reset notion of buffer aucmd_restbuf(&aco); } } else { bufvarname = alloc(STRLEN(varname) + 3); if (bufvarname != NULL) { buf_T *save_curbuf = curbuf; curbuf = buf; STRCPY(bufvarname, "b:"); STRCPY(bufvarname + 2, varname); set_var(bufvarname, varp, TRUE); vim_free(bufvarname); curbuf = save_curbuf; } } } /* * Get a callback from "arg". It can be a Funcref or a function name. * When "arg" is zero "res.cb_name" is set to an empty string. * If "res.cb_name" is allocated then "res.cb_free_name" is set to TRUE. * "res.cb_name" is set to NULL for an invalid argument. */ callback_T get_callback(typval_T *arg) { callback_T res; int r = OK; CLEAR_FIELD(res); if (arg->v_type == VAR_PARTIAL && arg->vval.v_partial != NULL) { res.cb_partial = arg->vval.v_partial; ++res.cb_partial->pt_refcount; res.cb_name = partial_name(res.cb_partial); } else { if (arg->v_type == VAR_STRING && arg->vval.v_string != NULL && isdigit(*arg->vval.v_string)) r = FAIL; else if (arg->v_type == VAR_FUNC || arg->v_type == VAR_STRING) { res.cb_name = arg->vval.v_string; if (arg->v_type == VAR_STRING) { char_u *name = get_scriptlocal_funcname(arg->vval.v_string); if (name != NULL) { res.cb_name = name; res.cb_free_name = TRUE; } } func_ref(res.cb_name); } else if (arg->v_type == VAR_NUMBER && arg->vval.v_number == 0) res.cb_name = (char_u *)""; else r = FAIL; if (r == FAIL) { emsg(_(e_invalid_callback_argument)); res.cb_name = NULL; } } return res; } /* * Copy a callback into a typval_T. */ void put_callback(callback_T *cb, typval_T *tv) { if (cb->cb_partial != NULL) { tv->v_type = VAR_PARTIAL; tv->vval.v_partial = cb->cb_partial; ++tv->vval.v_partial->pt_refcount; } else { tv->v_type = VAR_FUNC; tv->vval.v_string = vim_strsave(cb->cb_name); func_ref(cb->cb_name); } } /* * Make a copy of "src" into "dest", allocating the function name if needed, * without incrementing the refcount. */ void set_callback(callback_T *dest, callback_T *src) { if (src->cb_partial == NULL) { // just a function name, make a copy dest->cb_name = vim_strsave(src->cb_name); dest->cb_free_name = TRUE; } else { // cb_name is a pointer into cb_partial dest->cb_name = src->cb_name; dest->cb_free_name = FALSE; } dest->cb_partial = src->cb_partial; } /* * Copy callback from "src" to "dest", incrementing the refcounts. */ void copy_callback(callback_T *dest, callback_T *src) { dest->cb_partial = src->cb_partial; if (dest->cb_partial != NULL) { dest->cb_name = src->cb_name; dest->cb_free_name = FALSE; ++dest->cb_partial->pt_refcount; } else { dest->cb_name = vim_strsave(src->cb_name); dest->cb_free_name = TRUE; func_ref(src->cb_name); } } /* * When a callback refers to an autoload import, change the function name to * the "path#name" form. Uses the current script context. * Only works when the name is allocated. */ void expand_autload_callback(callback_T *cb) { char_u *name; char_u *p; imported_T *import; if (!in_vim9script() || cb->cb_name == NULL || (!cb->cb_free_name && (cb->cb_partial == NULL || cb->cb_partial->pt_name == NULL))) return; if (cb->cb_partial != NULL) name = cb->cb_partial->pt_name; else name = cb->cb_name; p = vim_strchr(name, '.'); if (p == NULL) return; import = find_imported(name, p - name, FALSE); if (import == NULL || !SCRIPT_ID_VALID(import->imp_sid)) return; scriptitem_T *si = SCRIPT_ITEM(import->imp_sid); if (si->sn_autoload_prefix == NULL) return; char_u *newname = concat_str(si->sn_autoload_prefix, p + 1); if (newname == NULL) return; if (cb->cb_partial != NULL) { if (cb->cb_name == cb->cb_partial->pt_name) cb->cb_name = newname; vim_free(cb->cb_partial->pt_name); cb->cb_partial->pt_name = newname; } else { vim_free(cb->cb_name); cb->cb_name = newname; } } /* * Unref/free "callback" returned by get_callback() or set_callback(). */ void free_callback(callback_T *callback) { if (callback->cb_partial != NULL) { partial_unref(callback->cb_partial); callback->cb_partial = NULL; } else if (callback->cb_name != NULL) func_unref(callback->cb_name); if (callback->cb_free_name) { vim_free(callback->cb_name); callback->cb_free_name = FALSE; } callback->cb_name = NULL; } #endif // FEAT_EVAL