thac0/vim
1
0
Fork 0
forked from aniani/vim
Code
vim/src/evalvars.c
Bram Moolenaar 204852ae2a patch 8.2.4510: Vim9: shortening commands leads to confusing script 
Problem:    Vim9: shortening commands leads to confusing script.
Solution:   In Vim9 script require at least ":cont" for ":continue", "const"
            instead of "cons", "break" instead of "brea", "catch" instead of
            "cat", "else" instead of "el" "elseif" instead of "elsei" "endfor"
            instead of "endfo" "endif" instead of "en" "endtry" instead of
            "endt", "finally" instead of "fina", "throw" instead of "th",
            "while" instead of "wh".
2022-03-05 12:56:44 +00:00

4752 lines
111 KiB
C
Raw Blame History

/* 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, VV_RO},
{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("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},
};
// 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("INTERNAL: 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);
if (p->vv_flags & VV_COMPAT)
// add to compat scope dict
hash_add(&compat_hashtab, p->vv_di.di_key);
}
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_ECHOSPACE, sc_col - 1);
set_vim_var_dict(VV_COLORNAMES, dict_alloc());
// 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)
{
tvp = alloc_string_tv(val);
if (tvp != NULL)
{
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))
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))
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(p_dex, NULL);
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(p_pex, NULL);
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;
// 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;
if (eval1(&p, &rettv, &EVALARG_EVALUATE) == 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);
}
/*
* 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)
{
hi = hash_find(&vimvarht, vimvars[idx].vv_di.di_key);
if (HASHITEM_EMPTY(hi))
internal_error("restore_vimvar()");
else
hash_remove(&vimvarht, hi);
}
}
/*
* 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);
}
/*
* 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.
*
* Returns a List with {lines} or NULL.
*/
list_T *
heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
{
char_u *theline;
char_u *marker;
list_T *l;
char_u *p;
int marker_indent_len = 0;
int text_indent_len = 0;
char_u *text_indent = NULL;
char_u dot[] = ".";
int comment_char = in_vim9script() ? '#' : '"';
if (eap->getline == NULL)
{
emsg(_(e_cannot_use_heredoc_here));
return NULL;
}
// Check for the optional 'trim' word before the marker
cmd = skipwhite(cmd);
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;
}
// 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;
theline = eap->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)
{
vim_free(theline);
break;
}
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;
if (list_append_string(l, theline + ti, -1) == FAIL)
break;
vim_free(theline);
}
vim_free(text_indent);
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 i;
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);
}
else if (expr[0] == '=' && expr[1] == '<' && expr[2] == '<')
{
list_T *l;
long cur_lnum = SOURCING_LNUM;
// HERE document
l = heredoc_get(eap, expr + 3, 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);
}
}
else
{
evalarg_T evalarg;
int len = 1;
CLEAR_FIELD(rettv);
i = FAIL;
if (has_assign || concat)
{
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), eap->arg);
i = FAIL;
}
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);
i = FAIL;
}
if (eap->skip)
++emsg_skip;
fill_evalarg_from_eap(&evalarg, eap, eap->skip);
expr = skipwhite_and_linebreak(expr, &evalarg);
cur_lnum = SOURCING_LNUM;
i = 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)
{
if (i != FAIL)
clear_tv(&rettv);
}
else if (i != FAIL)
{
(void)ex_let_vars(eap->arg, &rettv, FALSE, semicolon, var_count,
flags, op);
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 (*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), &ltv, FALSE,
flags | ASSIGN_UNPACK, (char_u *)"]", op, var_idx);
clear_tv(&ltv);
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;
}
else
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;
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 (*end == ':')
end = skip_type(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];
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);
}
}
}
/*
* 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));
else
{
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_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(tv);
else
// number, possibly hidden
n = (long)tv_get_number(tv);
}
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);
}
// 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 (op != NULL && *op != '=')
{
if (((opt_type == gov_bool || opt_type == gov_number) && *op == '.')
|| (opt_type == gov_string && *op != '.'))
{
semsg(_(e_wrong_variable_type_for_str_equal), op);
failed = TRUE; // don't set the value
}
else
{
// 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;
}
else if (opt_type == gov_string
&& stringval != NULL && s != NULL)
{
// string
s = concat_str(stringval, s);
vim_free(stringval);
stringval = s;
}
}
}
if (!failed)
{
if (opt_type != gov_string || s != NULL)
{
char *err = set_option_value(arg, n, s, scope);
arg_end = p;
if (err != NULL)
emsg(_(err));
}
else
emsg(_(e_string_required));
}
*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 (*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;
// ":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,
(flags & (ASSIGN_NO_DECL | ASSIGN_DECL))
? GLV_NO_DECL : 0, 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(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)
{
if (list_unlet_range(lp->ll_list, lp->ll_li, lp->ll_name, lp->ll_n1,
!lp->ll_empty2, lp->ll_n2) == FAIL)
return FAIL;
}
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);
}
return ret;
}
/*
* Unlet one item or a range of items from a list.
* Return OK or FAIL.
*/
int
list_unlet_range(
list_T *l,
listitem_T *li_first,
char_u *name,
long n1_arg,
int has_n2,
long n2)
{
listitem_T *li = li_first;
int n1 = n1_arg;
while (li != NULL && (!has_n2 || n2 >= n1))
{
if (value_check_lock(li->li_tv.v_lock, name, FALSE))
return FAIL;
li = li->li_next;
++n1;
}
// 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;
}
return OK;
}
/*
* "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;
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))
return FAIL;
delete_var(ht, hi);
return OK;
}
}
if (forceit)
return OK;
semsg(_(e_no_such_variable_str), name);
return FAIL;
}
/*
* 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;
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 (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)
{
// nothing to do
}
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
// (un)lock a Dictionary item.
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;
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:
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 (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
{
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)
{
++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(&regname);
#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, &regname, 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"
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;
type_T *type = NULL;
// truncate the name, so that we can use strcmp()
cc = name[len];
name[len] = NUL;
// Check for local variable when debugging.
if ((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)
{
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)
{
if (ht != NULL && ht == get_script_local_ht()
&& tv != &SCRIPT_SV(current_sctx.sc_sid)->sv_var.di_tv)
{
svar_T *sv = find_typval_in_script(tv, 0);
if (sv != NULL)
type = sv->sv_type;
}
// If a list or dict variable wasn't initialized, 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)
{
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);
}
}
else if (tv->v_type == VAR_LIST && tv->vval.v_list == NULL)
{
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);
}
}
else if (tv->v_type == VAR_BLOB && tv->vval.v_blob == NULL)
{
tv->vval.v_blob = blob_alloc();
if (tv->vval.v_blob != NULL)
++tv->vval.v_blob->bv_refcount;
}
}
copy_tv(tv, rettv);
}
}
name[len] = cc;
return ret;
}
/*
* 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)
&& name[0] == 's' && name[1] == ':')
{
scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
if (si->sn_autoload_prefix != NULL)
{
char_u *auto_name = concat_str(si->sn_autoload_prefix, name + 2);
if (auto_name != NULL)
{
ht = &globvarht;
ret = find_var_in_ht(ht, *name, 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()->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 (hi = ht->ht_array; todo > 0; ++hi)
{
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);
hash_remove(ht, hi);
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;
}
}
/*
* 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) && name[1] == ':'
&& vim_strchr((char_u *)"gwbt", name[0]) != NULL)
// 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 (var_in_vim9script && (flags & ASSIGN_FOR_LOOP) == 0)
{
where_T where = WHERE_INIT;
svar_T *sv = find_typval_in_script(&di->di_tv, sid);
if (sv != NULL)
{
// check the type and adjust to bool if needed
where.wt_index = var_idx;
where.wt_variable = TRUE;
if (check_script_var_type(sv, tv, name, where) == FAIL)
goto failed;
if (type == NULL)
type = sv->sv_type;
}
}
if ((flags & ASSIGN_FOR_LOOP) == 0
&& var_check_permission(di, name) == FAIL)
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 di: variables separately where needed to
// prevent changing the type.
if (ht == &vimvarht)
{
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;
}
goto failed;
}
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(SOME_VALID);
}
#endif
goto failed;
}
else if (di->di_tv.v_type != tv->v_type)
{
semsg(_(e_setting_str_to_value_with_wrong_type), name);
goto failed;
}
}
clear_tv(&di->di_tv);
}
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;
}
// 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(sizeof(dictitem_T) + STRLEN(varname));
if (di == NULL)
goto failed;
STRCPY(di->di_key, varname);
if (hash_add(ht, DI2HIKEY(di)) == 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.
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]))
{
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;
}
/*
* getwinvar() and gettabwinvar()
*/
static void
getwinvar(
typval_T *argvars,
typval_T *rettv,
int off) // 1 for gettabwinvar()
{
win_T *win;
char_u *varname;
dictitem_T *v;
tabpage_T *tp = NULL;
int done = FALSE;
switchwin_T switchwin;
int need_switch_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]);
++emsg_off;
rettv->v_type = VAR_STRING;
rettv->vval.v_string = NULL;
if (win != NULL && varname != 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.
need_switch_win = !(tp == curtab && win == curwin);
if (!need_switch_win
|| switch_win(&switchwin, win, tp, TRUE) == OK)
{
if (*varname == '&')
{
if (varname[1] == NUL)
{
// get all window-local options in a dict
dict_T *opts = get_winbuf_options(FALSE);
if (opts != NULL)
{
rettv_dict_set(rettv, opts);
done = TRUE;
}
}
else if (eval_option(&varname, rettv, 1) == OK)
// window-local-option
done = TRUE;
}
else
{
// Look up the variable.
// Let getwinvar({nr}, "") return the "w:" dictionary.
v = find_var_in_ht(&win->w_vars->dv_hashtab, 'w',
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 && argvars[off + 2].v_type != VAR_UNKNOWN)
// use the default return value
copy_tv(&argvars[off + 2], rettv);
--emsg_off;
}
/*
* 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;
if (varp->v_type == VAR_BOOL)
{
numval = (long)varp->vval.v_number;
strval = (char_u *)"0"; // avoid using "false"
}
else
{
if (!in_vim9script() || varp->v_type != VAR_STRING)
numval = (long)tv_get_number_chk(varp, &error);
strval = tv_get_string_buf_chk(varp, nbuf);
}
if (!error && strval != NULL)
set_option_value(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 && varp != NULL)
{
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)
{
switchwin_T switchwin;
tabpage_T *tp;
dictitem_T *v;
char_u *varname;
int done = FALSE;
rettv->v_type = VAR_STRING;
rettv->vval.v_string = 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 && varname != NULL)
{
// Set tp to be our tabpage, temporarily. Also set the window to the
// first window in the tabpage, otherwise the window is not valid.
if (switch_win(&switchwin,
tp == curtab || tp->tp_firstwin == NULL ? firstwin
: tp->tp_firstwin, tp, TRUE) == OK)
{
// look up the variable
// Let gettabvar({nr}, "") return the "t:" dictionary.
v = find_var_in_ht(&tp->tp_vars->dv_hashtab, 't', varname, FALSE);
if (v != NULL)
{
copy_tv(&v->di_tv, rettv);
done = TRUE;
}
}
// restore previous notion of curwin
restore_win(&switchwin, TRUE);
}
if (!done && argvars[2].v_type != VAR_UNKNOWN)
copy_tv(&argvars[2], rettv);
}
/*
* "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)
{
buf_T *buf;
char_u *varname;
dictitem_T *v;
int done = FALSE;
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]);
rettv->v_type = VAR_STRING;
rettv->vval.v_string = NULL;
if (buf != NULL && varname != NULL)
{
if (*varname == '&')
{
buf_T *save_curbuf = curbuf;
// set curbuf to be our buf, temporarily
curbuf = buf;
if (varname[1] == NUL)
{
// get all buffer-local options in a dict
dict_T *opts = get_winbuf_options(TRUE);
if (opts != NULL)
{
rettv_dict_set(rettv, opts);
done = TRUE;
}
}
else if (eval_option(&varname, rettv, TRUE) == OK)
// buffer-local-option
done = TRUE;
// restore previous notion of curbuf
curbuf = save_curbuf;
}
else
{
// Look up the variable.
if (*varname == NUL)
// Let getbufvar({nr}, "") return the "b:" dictionary.
v = &buf->b_bufvar;
else
v = find_var_in_ht(&buf->b_vars->dv_hashtab, 'b',
varname, FALSE);
if (v != NULL)
{
copy_tv(&v->di_tv, rettv);
done = TRUE;
}
}
}
if (!done && argvars[2].v_type != VAR_UNKNOWN)
// use the default value
copy_tv(&argvars[2], rettv);
}
/*
* "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 && varp != NULL && tp != NULL)
{
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 && varp != NULL)
{
if (*varname == '&')
{
aco_save_T aco;
// set curbuf to be our buf, temporarily
aucmd_prepbuf(&aco, buf);
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 return an empty string.
* "cb_name" is not allocated.
* "cb_name" is set to NULL for an invalid argument.
*/
callback_T
get_callback(typval_T *arg)
{
callback_T res;
int r = OK;
res.cb_free_name = FALSE;
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
{
res.cb_partial = NULL;
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)
{
if (arg->v_type == VAR_STRING)
{
char_u *name;
name = get_scriptlocal_funcname(arg->vval.v_string);
if (name != NULL)
{
vim_free(arg->vval.v_string);
arg->vval.v_string = name;
}
}
res.cb_name = arg->vval.v_string;
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))
{
scriptitem_T *si = SCRIPT_ITEM(import->imp_sid);
if (si->sn_autoload_prefix != NULL)
{
char_u *newname = concat_str(si->sn_autoload_prefix, p + 1);
if (newname != NULL)
{
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
View Git Blame Copy Permalink