blob: f20fdda13539bb2927d5fa02baa3019732ca5338 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * eval.c: Expression evaluation.
12 */
Bram Moolenaarfefecb02016-02-27 21:27:20 +010013#define USING_FLOAT_STUFF
Bram Moolenaar071d4272004-06-13 20:20:40 +000014
15#include "vim.h"
16
Bram Moolenaar8c8de832008-06-24 22:58:06 +000017#if defined(FEAT_EVAL) || defined(PROTO)
18
Bram Moolenaar314f11d2010-08-09 22:07:08 +020019#ifdef VMS
20# include <float.h>
21#endif
22
Bram Moolenaar33570922005-01-25 22:26:29 +000023#define DICT_MAXNEST 100 /* maximum nesting of lists and dicts */
Bram Moolenaar071d4272004-06-13 20:20:40 +000024
Bram Moolenaarc70646c2005-01-04 21:52:38 +000025static char *e_letunexp = N_("E18: Unexpected characters in :let");
Bram Moolenaarc70646c2005-01-04 21:52:38 +000026static char *e_undefvar = N_("E121: Undefined variable: %s");
27static char *e_missbrac = N_("E111: Missing ']'");
Bram Moolenaar9ef486d2005-01-17 22:23:00 +000028static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
29static char *e_letwrong = N_("E734: Wrong variable type for %s=");
Bram Moolenaar92124a32005-06-17 22:03:40 +000030static char *e_illvar = N_("E461: Illegal variable name: %s");
Bram Moolenaar8c0e3222013-06-16 17:32:40 +020031#ifdef FEAT_FLOAT
Bram Moolenaar2a876e42013-06-12 22:08:58 +020032static char *e_float_as_string = N_("E806: using Float as a String");
Bram Moolenaar8c0e3222013-06-16 17:32:40 +020033#endif
Bram Moolenaar8c8de832008-06-24 22:58:06 +000034
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +010035#define NAMESPACE_CHAR (char_u *)"abglstvw"
36
Bram Moolenaar230bb3f2013-04-24 14:07:45 +020037static dictitem_T globvars_var; /* variable used for g: */
Bram Moolenaar33570922005-01-25 22:26:29 +000038#define globvarht globvardict.dv_hashtab
Bram Moolenaar071d4272004-06-13 20:20:40 +000039
40/*
Bram Moolenaar532c7802005-01-27 14:44:31 +000041 * Old Vim variables such as "v:version" are also available without the "v:".
42 * Also in functions. We need a special hashtable for them.
43 */
Bram Moolenaar4debb442005-06-01 21:57:40 +000044static hashtab_T compat_hashtab;
Bram Moolenaar532c7802005-01-27 14:44:31 +000045
46/*
Bram Moolenaard9fba312005-06-26 22:34:35 +000047 * When recursively copying lists and dicts we need to remember which ones we
48 * have done to avoid endless recursiveness. This unique ID is used for that.
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +000049 * The last bit is used for previous_funccal, ignored when comparing.
Bram Moolenaard9fba312005-06-26 22:34:35 +000050 */
51static int current_copyID = 0;
Bram Moolenaar8502c702014-06-17 12:51:16 +020052
Bram Moolenaard9fba312005-06-26 22:34:35 +000053/*
Bram Moolenaar33570922005-01-25 22:26:29 +000054 * Array to hold the hashtab with variables local to each sourced script.
55 * Each item holds a variable (nameless) that points to the dict_T.
Bram Moolenaar071d4272004-06-13 20:20:40 +000056 */
Bram Moolenaar33570922005-01-25 22:26:29 +000057typedef struct
58{
59 dictitem_T sv_var;
60 dict_T sv_dict;
61} scriptvar_T;
62
Bram Moolenaar9577c3e2010-05-14 12:16:25 +020063static garray_T ga_scripts = {0, 0, sizeof(scriptvar_T *), 4, NULL};
64#define SCRIPT_SV(id) (((scriptvar_T **)ga_scripts.ga_data)[(id) - 1])
65#define SCRIPT_VARS(id) (SCRIPT_SV(id)->sv_dict.dv_hashtab)
Bram Moolenaar071d4272004-06-13 20:20:40 +000066
67static int echo_attr = 0; /* attributes used for ":echo" */
68
Bram Moolenaarc9b4b052006-04-30 18:54:39 +000069/* The names of packages that once were loaded are remembered. */
Bram Moolenaaraa35dd12006-04-29 22:03:41 +000070static garray_T ga_loaded = {0, 0, sizeof(char_u *), 4, NULL};
71
Bram Moolenaar071d4272004-06-13 20:20:40 +000072/*
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000073 * Info used by a ":for" loop.
74 */
Bram Moolenaar33570922005-01-25 22:26:29 +000075typedef struct
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000076{
77 int fi_semicolon; /* TRUE if ending in '; var]' */
78 int fi_varcount; /* nr of variables in the list */
Bram Moolenaar33570922005-01-25 22:26:29 +000079 listwatch_T fi_lw; /* keep an eye on the item used. */
80 list_T *fi_list; /* list being used */
81} forinfo_T;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +000082
Bram Moolenaara7043832005-01-21 11:56:39 +000083
84/*
Bram Moolenaar33570922005-01-25 22:26:29 +000085 * Array to hold the value of v: variables.
86 * The value is in a dictitem, so that it can also be used in the v: scope.
87 * The reason to use this table anyway is for very quick access to the
88 * variables with the VV_ defines.
89 */
Bram Moolenaar33570922005-01-25 22:26:29 +000090
91/* values for vv_flags: */
92#define VV_COMPAT 1 /* compatible, also used without "v:" */
93#define VV_RO 2 /* read-only */
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +000094#define VV_RO_SBX 4 /* read-only in the sandbox */
Bram Moolenaar33570922005-01-25 22:26:29 +000095
Bram Moolenaarbee6c0c2016-03-25 15:40:50 +010096#define VV_NAME(s, t) s, {{t, 0, {0}}, 0, {0}}
Bram Moolenaar33570922005-01-25 22:26:29 +000097
98static struct vimvar
99{
100 char *vv_name; /* name of variable, without v: */
Bram Moolenaarbee6c0c2016-03-25 15:40:50 +0100101 dictitem16_T vv_di; /* value and name for key (max 16 chars!) */
Bram Moolenaar33570922005-01-25 22:26:29 +0000102 char vv_flags; /* VV_COMPAT, VV_RO, VV_RO_SBX */
103} vimvars[VV_LEN] =
104{
105 /*
106 * The order here must match the VV_ defines in vim.h!
107 * Initializing a union does not work, leave tv.vval empty to get zero's.
108 */
109 {VV_NAME("count", VAR_NUMBER), VV_COMPAT+VV_RO},
110 {VV_NAME("count1", VAR_NUMBER), VV_RO},
111 {VV_NAME("prevcount", VAR_NUMBER), VV_RO},
112 {VV_NAME("errmsg", VAR_STRING), VV_COMPAT},
113 {VV_NAME("warningmsg", VAR_STRING), 0},
114 {VV_NAME("statusmsg", VAR_STRING), 0},
115 {VV_NAME("shell_error", VAR_NUMBER), VV_COMPAT+VV_RO},
116 {VV_NAME("this_session", VAR_STRING), VV_COMPAT},
117 {VV_NAME("version", VAR_NUMBER), VV_COMPAT+VV_RO},
118 {VV_NAME("lnum", VAR_NUMBER), VV_RO_SBX},
119 {VV_NAME("termresponse", VAR_STRING), VV_RO},
120 {VV_NAME("fname", VAR_STRING), VV_RO},
121 {VV_NAME("lang", VAR_STRING), VV_RO},
122 {VV_NAME("lc_time", VAR_STRING), VV_RO},
123 {VV_NAME("ctype", VAR_STRING), VV_RO},
124 {VV_NAME("charconvert_from", VAR_STRING), VV_RO},
125 {VV_NAME("charconvert_to", VAR_STRING), VV_RO},
126 {VV_NAME("fname_in", VAR_STRING), VV_RO},
127 {VV_NAME("fname_out", VAR_STRING), VV_RO},
128 {VV_NAME("fname_new", VAR_STRING), VV_RO},
129 {VV_NAME("fname_diff", VAR_STRING), VV_RO},
130 {VV_NAME("cmdarg", VAR_STRING), VV_RO},
131 {VV_NAME("foldstart", VAR_NUMBER), VV_RO_SBX},
132 {VV_NAME("foldend", VAR_NUMBER), VV_RO_SBX},
133 {VV_NAME("folddashes", VAR_STRING), VV_RO_SBX},
134 {VV_NAME("foldlevel", VAR_NUMBER), VV_RO_SBX},
135 {VV_NAME("progname", VAR_STRING), VV_RO},
136 {VV_NAME("servername", VAR_STRING), VV_RO},
137 {VV_NAME("dying", VAR_NUMBER), VV_RO},
138 {VV_NAME("exception", VAR_STRING), VV_RO},
139 {VV_NAME("throwpoint", VAR_STRING), VV_RO},
140 {VV_NAME("register", VAR_STRING), VV_RO},
141 {VV_NAME("cmdbang", VAR_NUMBER), VV_RO},
142 {VV_NAME("insertmode", VAR_STRING), VV_RO},
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +0000143 {VV_NAME("val", VAR_UNKNOWN), VV_RO},
144 {VV_NAME("key", VAR_UNKNOWN), VV_RO},
Bram Moolenaar05159a02005-02-26 23:04:13 +0000145 {VV_NAME("profiling", VAR_NUMBER), VV_RO},
Bram Moolenaar19a09a12005-03-04 23:39:37 +0000146 {VV_NAME("fcs_reason", VAR_STRING), VV_RO},
147 {VV_NAME("fcs_choice", VAR_STRING), 0},
Bram Moolenaare2ac10d2005-03-07 23:26:06 +0000148 {VV_NAME("beval_bufnr", VAR_NUMBER), VV_RO},
149 {VV_NAME("beval_winnr", VAR_NUMBER), VV_RO},
Bram Moolenaarc9721bd2016-06-04 17:41:03 +0200150 {VV_NAME("beval_winid", VAR_NUMBER), VV_RO},
Bram Moolenaare2ac10d2005-03-07 23:26:06 +0000151 {VV_NAME("beval_lnum", VAR_NUMBER), VV_RO},
152 {VV_NAME("beval_col", VAR_NUMBER), VV_RO},
153 {VV_NAME("beval_text", VAR_STRING), VV_RO},
Bram Moolenaar761b1132005-10-03 22:05:45 +0000154 {VV_NAME("scrollstart", VAR_STRING), 0},
Bram Moolenaard5bc83f2005-12-07 21:07:59 +0000155 {VV_NAME("swapname", VAR_STRING), VV_RO},
156 {VV_NAME("swapchoice", VAR_STRING), 0},
Bram Moolenaar63a121b2005-12-11 21:36:39 +0000157 {VV_NAME("swapcommand", VAR_STRING), VV_RO},
Bram Moolenaare659c952011-05-19 17:25:41 +0200158 {VV_NAME("char", VAR_STRING), 0},
Bram Moolenaar219b8702006-11-01 14:32:36 +0000159 {VV_NAME("mouse_win", VAR_NUMBER), 0},
Bram Moolenaar511972d2016-06-04 18:09:59 +0200160 {VV_NAME("mouse_winid", VAR_NUMBER), 0},
Bram Moolenaar219b8702006-11-01 14:32:36 +0000161 {VV_NAME("mouse_lnum", VAR_NUMBER), 0},
162 {VV_NAME("mouse_col", VAR_NUMBER), 0},
Bram Moolenaar8af1fbf2008-01-05 12:35:21 +0000163 {VV_NAME("operator", VAR_STRING), VV_RO},
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000164 {VV_NAME("searchforward", VAR_NUMBER), 0},
Bram Moolenaar8050efa2013-11-08 04:30:20 +0100165 {VV_NAME("hlsearch", VAR_NUMBER), 0},
Bram Moolenaard812df62008-11-09 12:46:09 +0000166 {VV_NAME("oldfiles", VAR_LIST), 0},
Bram Moolenaar727c8762010-10-20 19:17:48 +0200167 {VV_NAME("windowid", VAR_NUMBER), VV_RO},
Bram Moolenaara1706c92014-04-01 19:55:49 +0200168 {VV_NAME("progpath", VAR_STRING), VV_RO},
Bram Moolenaar42a45122015-07-10 17:56:23 +0200169 {VV_NAME("completed_item", VAR_DICT), VV_RO},
Bram Moolenaar53744302015-07-17 17:38:22 +0200170 {VV_NAME("option_new", VAR_STRING), VV_RO},
171 {VV_NAME("option_old", VAR_STRING), VV_RO},
172 {VV_NAME("option_type", VAR_STRING), VV_RO},
Bram Moolenaar43345542015-11-29 17:35:35 +0100173 {VV_NAME("errors", VAR_LIST), 0},
Bram Moolenaar520e1e42016-01-23 19:46:28 +0100174 {VV_NAME("false", VAR_SPECIAL), VV_RO},
175 {VV_NAME("true", VAR_SPECIAL), VV_RO},
176 {VV_NAME("null", VAR_SPECIAL), VV_RO},
177 {VV_NAME("none", VAR_SPECIAL), VV_RO},
Bram Moolenaar14735512016-03-26 21:00:08 +0100178 {VV_NAME("vim_did_enter", VAR_NUMBER), VV_RO},
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +0200179 {VV_NAME("testing", VAR_NUMBER), 0},
Bram Moolenaarf562e722016-07-19 17:25:25 +0200180 {VV_NAME("t_number", VAR_NUMBER), VV_RO},
181 {VV_NAME("t_string", VAR_NUMBER), VV_RO},
182 {VV_NAME("t_func", VAR_NUMBER), VV_RO},
183 {VV_NAME("t_list", VAR_NUMBER), VV_RO},
184 {VV_NAME("t_dict", VAR_NUMBER), VV_RO},
185 {VV_NAME("t_float", VAR_NUMBER), VV_RO},
186 {VV_NAME("t_bool", VAR_NUMBER), VV_RO},
187 {VV_NAME("t_none", VAR_NUMBER), VV_RO},
188 {VV_NAME("t_job", VAR_NUMBER), VV_RO},
189 {VV_NAME("t_channel", VAR_NUMBER), VV_RO},
Bram Moolenaar65e4c4f2017-10-14 23:24:25 +0200190 {VV_NAME("termrfgresp", VAR_STRING), VV_RO},
191 {VV_NAME("termrbgresp", VAR_STRING), VV_RO},
Bram Moolenaarf3af54e2017-08-30 14:53:06 +0200192 {VV_NAME("termu7resp", VAR_STRING), VV_RO},
193 {VV_NAME("termstyleresp", VAR_STRING), VV_RO},
194 {VV_NAME("termblinkresp", VAR_STRING), VV_RO},
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100195 {VV_NAME("event", VAR_DICT), VV_RO},
Bram Moolenaar33570922005-01-25 22:26:29 +0000196};
197
198/* shorthand */
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000199#define vv_type vv_di.di_tv.v_type
200#define vv_nr vv_di.di_tv.vval.v_number
201#define vv_float vv_di.di_tv.vval.v_float
202#define vv_str vv_di.di_tv.vval.v_string
Bram Moolenaard812df62008-11-09 12:46:09 +0000203#define vv_list vv_di.di_tv.vval.v_list
Bram Moolenaar42a45122015-07-10 17:56:23 +0200204#define vv_dict vv_di.di_tv.vval.v_dict
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000205#define vv_tv vv_di.di_tv
Bram Moolenaar33570922005-01-25 22:26:29 +0000206
Bram Moolenaar230bb3f2013-04-24 14:07:45 +0200207static dictitem_T vimvars_var; /* variable used for v: */
Bram Moolenaar33570922005-01-25 22:26:29 +0000208#define vimvarht vimvardict.dv_hashtab
209
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100210static int ex_let_vars(char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars);
211static char_u *skip_var_list(char_u *arg, int *var_count, int *semicolon);
212static char_u *skip_var_one(char_u *arg);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100213static void list_glob_vars(int *first);
214static void list_buf_vars(int *first);
215static void list_win_vars(int *first);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100216static void list_tab_vars(int *first);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100217static void list_vim_vars(int *first);
218static void list_script_vars(int *first);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100219static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first);
220static char_u *ex_let_one(char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100221static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op);
222static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100223static void ex_unletlock(exarg_T *eap, char_u *argstart, int deep);
224static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit);
225static int do_lock_var(lval_T *lp, char_u *name_end, int deep, int lock);
226static void item_lock(typval_T *tv, int deep, int lock);
Bram Moolenaara40058a2005-07-11 22:42:07 +0000227
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100228static int eval2(char_u **arg, typval_T *rettv, int evaluate);
229static int eval3(char_u **arg, typval_T *rettv, int evaluate);
230static int eval4(char_u **arg, typval_T *rettv, int evaluate);
231static int eval5(char_u **arg, typval_T *rettv, int evaluate);
232static int eval6(char_u **arg, typval_T *rettv, int evaluate, int want_string);
233static int eval7(char_u **arg, typval_T *rettv, int evaluate, int want_string);
Bram Moolenaara40058a2005-07-11 22:42:07 +0000234
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100235static int eval_index(char_u **arg, typval_T *rettv, int evaluate, int verbose);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100236static int get_string_tv(char_u **arg, typval_T *rettv, int evaluate);
237static int get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100238static int free_unref_items(int copyID);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100239static int get_env_tv(char_u **arg, typval_T *rettv, int evaluate);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100240static int get_env_len(char_u **arg);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100241static char_u * make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +0200242static void check_vars(char_u *name, int len);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100243static typval_T *alloc_string_tv(char_u *string);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100244static void delete_var(hashtab_T *ht, hashitem_T *hi);
245static void list_one_var(dictitem_T *v, char_u *prefix, int *first);
246static void list_one_var_a(char_u *prefix, char_u *name, int type, char_u *string, int *first);
Bram Moolenaar48e697e2016-01-23 22:17:30 +0100247static char_u *find_option_end(char_u **arg, int *opt_flags);
Bram Moolenaar2c704a72010-06-03 21:17:25 +0200248
Bram Moolenaar73dad1e2016-07-17 22:13:49 +0200249/* for VIM_VERSION_ defines */
250#include "version.h"
251
Bram Moolenaara1fa8922017-01-12 20:06:33 +0100252
253#if defined(EBCDIC) || defined(PROTO)
254/*
255 * Compare struct fst by function name.
256 */
257 static int
258compare_func_name(const void *s1, const void *s2)
259{
260 struct fst *p1 = (struct fst *)s1;
261 struct fst *p2 = (struct fst *)s2;
262
263 return STRCMP(p1->f_name, p2->f_name);
264}
265
266/*
267 * Sort the function table by function name.
268 * The sorting of the table above is ASCII dependant.
269 * On machines using EBCDIC we have to sort it.
270 */
271 static void
272sortFunctions(void)
273{
274 int funcCnt = (int)(sizeof(functions) / sizeof(struct fst)) - 1;
275
276 qsort(functions, (size_t)funcCnt, sizeof(struct fst), compare_func_name);
277}
278#endif
279
280
Bram Moolenaar33570922005-01-25 22:26:29 +0000281/*
282 * Initialize the global and v: variables.
Bram Moolenaara7043832005-01-21 11:56:39 +0000283 */
284 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100285eval_init(void)
Bram Moolenaara7043832005-01-21 11:56:39 +0000286{
Bram Moolenaar33570922005-01-25 22:26:29 +0000287 int i;
288 struct vimvar *p;
289
Bram Moolenaarbdb62052012-07-16 17:31:53 +0200290 init_var_dict(&globvardict, &globvars_var, VAR_DEF_SCOPE);
291 init_var_dict(&vimvardict, &vimvars_var, VAR_SCOPE);
Bram Moolenaar32f649e2011-04-11 13:46:13 +0200292 vimvardict.dv_lock = VAR_FIXED;
Bram Moolenaar532c7802005-01-27 14:44:31 +0000293 hash_init(&compat_hashtab);
Bram Moolenaara9b579f2016-07-17 18:29:19 +0200294 func_init();
Bram Moolenaar33570922005-01-25 22:26:29 +0000295
296 for (i = 0; i < VV_LEN; ++i)
297 {
298 p = &vimvars[i];
Bram Moolenaaref9d9b92016-03-28 22:44:50 +0200299 if (STRLEN(p->vv_name) > 16)
300 {
Bram Moolenaarde330112017-01-08 20:50:52 +0100301 IEMSG("INTERNAL: name too long, increase size of dictitem16_T");
Bram Moolenaaref9d9b92016-03-28 22:44:50 +0200302 getout(1);
303 }
Bram Moolenaar33570922005-01-25 22:26:29 +0000304 STRCPY(p->vv_di.di_key, p->vv_name);
305 if (p->vv_flags & VV_RO)
306 p->vv_di.di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
307 else if (p->vv_flags & VV_RO_SBX)
308 p->vv_di.di_flags = DI_FLAGS_RO_SBX | DI_FLAGS_FIX;
309 else
310 p->vv_di.di_flags = DI_FLAGS_FIX;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +0000311
312 /* add to v: scope dict, unless the value is not always available */
313 if (p->vv_type != VAR_UNKNOWN)
314 hash_add(&vimvarht, p->vv_di.di_key);
Bram Moolenaar33570922005-01-25 22:26:29 +0000315 if (p->vv_flags & VV_COMPAT)
Bram Moolenaar532c7802005-01-27 14:44:31 +0000316 /* add to compat scope dict */
317 hash_add(&compat_hashtab, p->vv_di.di_key);
Bram Moolenaar33570922005-01-25 22:26:29 +0000318 }
Bram Moolenaara542c682016-01-31 16:28:04 +0100319 vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
320
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000321 set_vim_var_nr(VV_SEARCHFORWARD, 1L);
Bram Moolenaar8050efa2013-11-08 04:30:20 +0100322 set_vim_var_nr(VV_HLSEARCH, 1L);
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100323 set_vim_var_dict(VV_COMPLETED_ITEM, dict_alloc_lock(VAR_FIXED));
Bram Moolenaar4649ded2015-12-03 14:55:55 +0100324 set_vim_var_list(VV_ERRORS, list_alloc());
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100325 set_vim_var_dict(VV_EVENT, dict_alloc_lock(VAR_FIXED));
Bram Moolenaar520e1e42016-01-23 19:46:28 +0100326
327 set_vim_var_nr(VV_FALSE, VVAL_FALSE);
328 set_vim_var_nr(VV_TRUE, VVAL_TRUE);
329 set_vim_var_nr(VV_NONE, VVAL_NONE);
330 set_vim_var_nr(VV_NULL, VVAL_NULL);
331
Bram Moolenaarf562e722016-07-19 17:25:25 +0200332 set_vim_var_nr(VV_TYPE_NUMBER, VAR_TYPE_NUMBER);
333 set_vim_var_nr(VV_TYPE_STRING, VAR_TYPE_STRING);
334 set_vim_var_nr(VV_TYPE_FUNC, VAR_TYPE_FUNC);
335 set_vim_var_nr(VV_TYPE_LIST, VAR_TYPE_LIST);
336 set_vim_var_nr(VV_TYPE_DICT, VAR_TYPE_DICT);
337 set_vim_var_nr(VV_TYPE_FLOAT, VAR_TYPE_FLOAT);
338 set_vim_var_nr(VV_TYPE_BOOL, VAR_TYPE_BOOL);
339 set_vim_var_nr(VV_TYPE_NONE, VAR_TYPE_NONE);
340 set_vim_var_nr(VV_TYPE_JOB, VAR_TYPE_JOB);
341 set_vim_var_nr(VV_TYPE_CHANNEL, VAR_TYPE_CHANNEL);
342
Bram Moolenaarb429cde2012-04-25 18:24:29 +0200343 set_reg_var(0); /* default for v:register is not 0 but '"' */
Bram Moolenaar2c704a72010-06-03 21:17:25 +0200344
345#ifdef EBCDIC
346 /*
Bram Moolenaar195ea0f2011-11-30 14:57:31 +0100347 * Sort the function table, to enable binary search.
Bram Moolenaar2c704a72010-06-03 21:17:25 +0200348 */
349 sortFunctions();
350#endif
Bram Moolenaara7043832005-01-21 11:56:39 +0000351}
352
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000353#if defined(EXITFREE) || defined(PROTO)
354 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100355eval_clear(void)
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000356{
357 int i;
358 struct vimvar *p;
359
360 for (i = 0; i < VV_LEN; ++i)
361 {
362 p = &vimvars[i];
363 if (p->vv_di.di_tv.v_type == VAR_STRING)
Bram Moolenaard23a8232018-02-10 18:45:26 +0100364 VIM_CLEAR(p->vv_str);
Bram Moolenaard812df62008-11-09 12:46:09 +0000365 else if (p->vv_di.di_tv.v_type == VAR_LIST)
366 {
367 list_unref(p->vv_list);
368 p->vv_list = NULL;
Bram Moolenaard9fba312005-06-26 22:34:35 +0000369 }
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000370 }
371 hash_clear(&vimvarht);
Bram Moolenaar0f71c6d2008-11-12 14:29:28 +0000372 hash_init(&vimvarht); /* garbage_collect() will access it */
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000373 hash_clear(&compat_hashtab);
374
Bram Moolenaard9fba312005-06-26 22:34:35 +0000375 free_scriptnames();
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100376# if defined(FEAT_CMDL_COMPL)
Bram Moolenaar9b486ca2011-05-19 18:26:40 +0200377 free_locales();
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +0100378# endif
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000379
380 /* global variables */
381 vars_clear(&globvarht);
Bram Moolenaard9fba312005-06-26 22:34:35 +0000382
Bram Moolenaaraa35dd12006-04-29 22:03:41 +0000383 /* autoloaded script names */
384 ga_clear_strings(&ga_loaded);
385
Bram Moolenaarcca74132013-09-25 21:00:28 +0200386 /* Script-local variables. First clear all the variables and in a second
387 * loop free the scriptvar_T, because a variable in one script might hold
388 * a reference to the whole scope of another script. */
Bram Moolenaar9577c3e2010-05-14 12:16:25 +0200389 for (i = 1; i <= ga_scripts.ga_len; ++i)
Bram Moolenaar9577c3e2010-05-14 12:16:25 +0200390 vars_clear(&SCRIPT_VARS(i));
Bram Moolenaarcca74132013-09-25 21:00:28 +0200391 for (i = 1; i <= ga_scripts.ga_len; ++i)
Bram Moolenaar9577c3e2010-05-14 12:16:25 +0200392 vim_free(SCRIPT_SV(i));
Bram Moolenaar9577c3e2010-05-14 12:16:25 +0200393 ga_clear(&ga_scripts);
394
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +0000395 /* unreferenced lists and dicts */
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +0200396 (void)garbage_collect(FALSE);
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000397
398 /* functions */
399 free_all_functions();
Bram Moolenaar29a1c1d2005-06-24 23:11:15 +0000400}
401#endif
402
Bram Moolenaar071d4272004-06-13 20:20:40 +0000403
404/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000405 * Set an internal variable to a string value. Creates the variable if it does
406 * not already exist.
407 */
408 void
Bram Moolenaarb7604cc2016-01-15 21:23:22 +0100409set_internal_string_var(char_u *name, char_u *value)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000410{
Bram Moolenaar49cd9572005-01-03 21:06:01 +0000411 char_u *val;
Bram Moolenaar33570922005-01-25 22:26:29 +0000412 typval_T *tvp;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000413
414 val = vim_strsave(value);
415 if (val != NULL)
416 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000417 tvp = alloc_string_tv(val);
Bram Moolenaar49cd9572005-01-03 21:06:01 +0000418 if (tvp != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000419 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +0000420 set_var(name, tvp, FALSE);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000421 free_tv(tvp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000422 }
423 }
424}
425
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000426static lval_T *redir_lval = NULL;
Bram Moolenaar1e5e1232016-07-07 17:33:02 +0200427#define EVALCMD_BUSY (redir_lval == (lval_T *)&redir_lval)
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000428static garray_T redir_ga; /* only valid when redir_lval is not NULL */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000429static char_u *redir_endp = NULL;
430static char_u *redir_varname = NULL;
431
432/*
433 * Start recording command output to a variable
Bram Moolenaarb7604cc2016-01-15 21:23:22 +0100434 * When "append" is TRUE append to an existing variable.
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000435 * Returns OK if successfully completed the setup. FAIL otherwise.
436 */
437 int
Bram Moolenaarb7604cc2016-01-15 21:23:22 +0100438var_redir_start(char_u *name, int append)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000439{
440 int save_emsg;
441 int err;
442 typval_T tv;
443
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000444 /* Catch a bad name early. */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +0000445 if (!eval_isnamec1(*name))
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000446 {
447 EMSG(_(e_invarg));
448 return FAIL;
449 }
450
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000451 /* Make a copy of the name, it is used in redir_lval until redir ends. */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000452 redir_varname = vim_strsave(name);
453 if (redir_varname == NULL)
454 return FAIL;
455
456 redir_lval = (lval_T *)alloc_clear((unsigned)sizeof(lval_T));
457 if (redir_lval == NULL)
458 {
459 var_redir_stop();
460 return FAIL;
461 }
462
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000463 /* The output is stored in growarray "redir_ga" until redirection ends. */
464 ga_init2(&redir_ga, (int)sizeof(char), 500);
465
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000466 /* Parse the variable name (can be a dict or list entry). */
Bram Moolenaar6d977d62014-01-14 15:24:39 +0100467 redir_endp = get_lval(redir_varname, NULL, redir_lval, FALSE, FALSE, 0,
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +0000468 FNE_CHECK_START);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000469 if (redir_endp == NULL || redir_lval->ll_name == NULL || *redir_endp != NUL)
470 {
Bram Moolenaar1dba0fb2010-07-28 18:55:02 +0200471 clear_lval(redir_lval);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000472 if (redir_endp != NULL && *redir_endp != NUL)
473 /* Trailing characters are present after the variable name */
474 EMSG(_(e_trailing));
475 else
476 EMSG(_(e_invarg));
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000477 redir_endp = NULL; /* don't store a value, only cleanup */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000478 var_redir_stop();
479 return FAIL;
480 }
481
482 /* check if we can write to the variable: set it to or append an empty
483 * string */
484 save_emsg = did_emsg;
485 did_emsg = FALSE;
486 tv.v_type = VAR_STRING;
487 tv.vval.v_string = (char_u *)"";
488 if (append)
489 set_var_lval(redir_lval, redir_endp, &tv, TRUE, (char_u *)".");
490 else
491 set_var_lval(redir_lval, redir_endp, &tv, TRUE, (char_u *)"=");
Bram Moolenaar1dba0fb2010-07-28 18:55:02 +0200492 clear_lval(redir_lval);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000493 err = did_emsg;
Bram Moolenaar1f35bf92006-03-07 22:38:47 +0000494 did_emsg |= save_emsg;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000495 if (err)
496 {
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000497 redir_endp = NULL; /* don't store a value, only cleanup */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000498 var_redir_stop();
499 return FAIL;
500 }
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000501
502 return OK;
503}
504
505/*
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000506 * Append "value[value_len]" to the variable set by var_redir_start().
507 * The actual appending is postponed until redirection ends, because the value
508 * appended may in fact be the string we write to, changing it may cause freed
509 * memory to be used:
510 * :redir => foo
511 * :let foo
512 * :redir END
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000513 */
514 void
Bram Moolenaarb7604cc2016-01-15 21:23:22 +0100515var_redir_str(char_u *value, int value_len)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000516{
Bram Moolenaar5fdec472007-07-24 08:45:13 +0000517 int len;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000518
519 if (redir_lval == NULL)
520 return;
521
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000522 if (value_len == -1)
Bram Moolenaar5fdec472007-07-24 08:45:13 +0000523 len = (int)STRLEN(value); /* Append the entire string */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000524 else
Bram Moolenaar5fdec472007-07-24 08:45:13 +0000525 len = value_len; /* Append only "value_len" characters */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000526
Bram Moolenaar5fdec472007-07-24 08:45:13 +0000527 if (ga_grow(&redir_ga, len) == OK)
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000528 {
529 mch_memmove((char *)redir_ga.ga_data + redir_ga.ga_len, value, len);
Bram Moolenaar5fdec472007-07-24 08:45:13 +0000530 redir_ga.ga_len += len;
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000531 }
532 else
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000533 var_redir_stop();
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000534}
535
536/*
537 * Stop redirecting command output to a variable.
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000538 * Frees the allocated memory.
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000539 */
540 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100541var_redir_stop(void)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000542{
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000543 typval_T tv;
544
Bram Moolenaar1e5e1232016-07-07 17:33:02 +0200545 if (EVALCMD_BUSY)
546 {
547 redir_lval = NULL;
548 return;
549 }
550
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000551 if (redir_lval != NULL)
552 {
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000553 /* If there was no error: assign the text to the variable. */
554 if (redir_endp != NULL)
555 {
556 ga_append(&redir_ga, NUL); /* Append the trailing NUL. */
557 tv.v_type = VAR_STRING;
558 tv.vval.v_string = redir_ga.ga_data;
Bram Moolenaar1dba0fb2010-07-28 18:55:02 +0200559 /* Call get_lval() again, if it's inside a Dict or List it may
560 * have changed. */
561 redir_endp = get_lval(redir_varname, NULL, redir_lval,
Bram Moolenaar6d977d62014-01-14 15:24:39 +0100562 FALSE, FALSE, 0, FNE_CHECK_START);
Bram Moolenaar1dba0fb2010-07-28 18:55:02 +0200563 if (redir_endp != NULL && redir_lval->ll_name != NULL)
564 set_var_lval(redir_lval, redir_endp, &tv, FALSE, (char_u *)".");
565 clear_lval(redir_lval);
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000566 }
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000567
Bram Moolenaar2f59b5c2009-11-03 13:26:55 +0000568 /* free the collected output */
Bram Moolenaard23a8232018-02-10 18:45:26 +0100569 VIM_CLEAR(redir_ga.ga_data);
Bram Moolenaar863b53b2007-01-14 14:28:34 +0000570
Bram Moolenaard23a8232018-02-10 18:45:26 +0100571 VIM_CLEAR(redir_lval);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000572 }
Bram Moolenaard23a8232018-02-10 18:45:26 +0100573 VIM_CLEAR(redir_varname);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +0000574}
575
Bram Moolenaar071d4272004-06-13 20:20:40 +0000576# if defined(FEAT_MBYTE) || defined(PROTO)
577 int
Bram Moolenaarb7604cc2016-01-15 21:23:22 +0100578eval_charconvert(
579 char_u *enc_from,
580 char_u *enc_to,
581 char_u *fname_from,
582 char_u *fname_to)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000583{
584 int err = FALSE;
585
586 set_vim_var_string(VV_CC_FROM, enc_from, -1);
587 set_vim_var_string(VV_CC_TO, enc_to, -1);
588 set_vim_var_string(VV_FNAME_IN, fname_from, -1);
589 set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
590 if (eval_to_bool(p_ccv, &err, NULL, FALSE))
591 err = TRUE;
592 set_vim_var_string(VV_CC_FROM, NULL, -1);
593 set_vim_var_string(VV_CC_TO, NULL, -1);
594 set_vim_var_string(VV_FNAME_IN, NULL, -1);
595 set_vim_var_string(VV_FNAME_OUT, NULL, -1);
596
597 if (err)
598 return FAIL;
599 return OK;
600}
601# endif
602
603# if defined(FEAT_POSTSCRIPT) || defined(PROTO)
604 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100605eval_printexpr(char_u *fname, char_u *args)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000606{
607 int err = FALSE;
608
609 set_vim_var_string(VV_FNAME_IN, fname, -1);
610 set_vim_var_string(VV_CMDARG, args, -1);
611 if (eval_to_bool(p_pexpr, &err, NULL, FALSE))
612 err = TRUE;
613 set_vim_var_string(VV_FNAME_IN, NULL, -1);
614 set_vim_var_string(VV_CMDARG, NULL, -1);
615
616 if (err)
617 {
618 mch_remove(fname);
619 return FAIL;
620 }
621 return OK;
622}
623# endif
624
625# if defined(FEAT_DIFF) || defined(PROTO)
626 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100627eval_diff(
628 char_u *origfile,
629 char_u *newfile,
630 char_u *outfile)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000631{
632 int err = FALSE;
633
634 set_vim_var_string(VV_FNAME_IN, origfile, -1);
635 set_vim_var_string(VV_FNAME_NEW, newfile, -1);
636 set_vim_var_string(VV_FNAME_OUT, outfile, -1);
637 (void)eval_to_bool(p_dex, &err, NULL, FALSE);
638 set_vim_var_string(VV_FNAME_IN, NULL, -1);
639 set_vim_var_string(VV_FNAME_NEW, NULL, -1);
640 set_vim_var_string(VV_FNAME_OUT, NULL, -1);
641}
642
643 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100644eval_patch(
645 char_u *origfile,
646 char_u *difffile,
647 char_u *outfile)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000648{
649 int err;
650
651 set_vim_var_string(VV_FNAME_IN, origfile, -1);
652 set_vim_var_string(VV_FNAME_DIFF, difffile, -1);
653 set_vim_var_string(VV_FNAME_OUT, outfile, -1);
654 (void)eval_to_bool(p_pex, &err, NULL, FALSE);
655 set_vim_var_string(VV_FNAME_IN, NULL, -1);
656 set_vim_var_string(VV_FNAME_DIFF, NULL, -1);
657 set_vim_var_string(VV_FNAME_OUT, NULL, -1);
658}
659# endif
660
661/*
662 * Top level evaluation function, returning a boolean.
663 * Sets "error" to TRUE if there was an error.
664 * Return TRUE or FALSE.
665 */
666 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100667eval_to_bool(
668 char_u *arg,
669 int *error,
670 char_u **nextcmd,
671 int skip) /* only parse, don't execute */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000672{
Bram Moolenaar33570922005-01-25 22:26:29 +0000673 typval_T tv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200674 varnumber_T retval = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000675
676 if (skip)
677 ++emsg_skip;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000678 if (eval0(arg, &tv, nextcmd, !skip) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000679 *error = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000680 else
681 {
682 *error = FALSE;
683 if (!skip)
684 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000685 retval = (get_tv_number_chk(&tv, error) != 0);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000686 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000687 }
688 }
689 if (skip)
690 --emsg_skip;
691
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200692 return (int)retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000693}
694
Bram Moolenaar48570482017-10-30 21:48:41 +0100695 static int
696eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv)
697{
698 char_u *s;
699 int dummy;
700 char_u buf[NUMBUFLEN];
701
702 if (expr->v_type == VAR_FUNC)
703 {
704 s = expr->vval.v_string;
705 if (s == NULL || *s == NUL)
706 return FAIL;
707 if (call_func(s, (int)STRLEN(s), rettv, argc, argv, NULL,
708 0L, 0L, &dummy, TRUE, NULL, NULL) == FAIL)
709 return FAIL;
710 }
711 else if (expr->v_type == VAR_PARTIAL)
712 {
713 partial_T *partial = expr->vval.v_partial;
714
715 s = partial_name(partial);
716 if (s == NULL || *s == NUL)
717 return FAIL;
718 if (call_func(s, (int)STRLEN(s), rettv, argc, argv, NULL,
719 0L, 0L, &dummy, TRUE, partial, NULL) == FAIL)
720 return FAIL;
721 }
722 else
723 {
724 s = get_tv_string_buf_chk(expr, buf);
725 if (s == NULL)
726 return FAIL;
727 s = skipwhite(s);
728 if (eval1(&s, rettv, TRUE) == FAIL)
729 return FAIL;
730 if (*s != NUL) /* check for trailing chars after expr */
731 {
732 EMSG2(_(e_invexpr2), s);
733 return FAIL;
734 }
735 }
736 return OK;
737}
738
739/*
740 * Like eval_to_bool() but using a typval_T instead of a string.
741 * Works for string, funcref and partial.
742 */
743 int
744eval_expr_to_bool(typval_T *expr, int *error)
745{
746 typval_T rettv;
747 int res;
748
749 if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL)
750 {
751 *error = TRUE;
752 return FALSE;
753 }
754 res = (get_tv_number_chk(&rettv, error) != 0);
755 clear_tv(&rettv);
756 return res;
757}
758
Bram Moolenaar071d4272004-06-13 20:20:40 +0000759/*
760 * Top level evaluation function, returning a string. If "skip" is TRUE,
761 * only parsing to "nextcmd" is done, without reporting errors. Return
762 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
763 */
764 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100765eval_to_string_skip(
766 char_u *arg,
767 char_u **nextcmd,
768 int skip) /* only parse, don't execute */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000769{
Bram Moolenaar33570922005-01-25 22:26:29 +0000770 typval_T tv;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000771 char_u *retval;
772
773 if (skip)
774 ++emsg_skip;
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000775 if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776 retval = NULL;
777 else
778 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000779 retval = vim_strsave(get_tv_string(&tv));
780 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000781 }
782 if (skip)
783 --emsg_skip;
784
785 return retval;
786}
787
788/*
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000789 * Skip over an expression at "*pp".
790 * Return FAIL for an error, OK otherwise.
791 */
792 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100793skip_expr(char_u **pp)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000794{
Bram Moolenaar33570922005-01-25 22:26:29 +0000795 typval_T rettv;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000796
797 *pp = skipwhite(*pp);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000798 return eval1(pp, &rettv, FALSE);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000799}
800
801/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000802 * Top level evaluation function, returning a string.
Bram Moolenaara85fb752008-09-07 11:55:43 +0000803 * When "convert" is TRUE convert a List into a sequence of lines and convert
804 * a Float to a String.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000805 * Return pointer to allocated memory, or NULL for failure.
806 */
807 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100808eval_to_string(
809 char_u *arg,
810 char_u **nextcmd,
811 int convert)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000812{
Bram Moolenaar33570922005-01-25 22:26:29 +0000813 typval_T tv;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000814 char_u *retval;
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000815 garray_T ga;
Bram Moolenaar798b30b2009-04-22 10:56:16 +0000816#ifdef FEAT_FLOAT
Bram Moolenaara85fb752008-09-07 11:55:43 +0000817 char_u numbuf[NUMBUFLEN];
Bram Moolenaar798b30b2009-04-22 10:56:16 +0000818#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000819
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000820 if (eval0(arg, &tv, nextcmd, TRUE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000821 retval = NULL;
822 else
823 {
Bram Moolenaara85fb752008-09-07 11:55:43 +0000824 if (convert && tv.v_type == VAR_LIST)
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000825 {
826 ga_init2(&ga, (int)sizeof(char), 80);
Bram Moolenaar9bf749b2008-07-27 13:57:29 +0000827 if (tv.vval.v_list != NULL)
Bram Moolenaar213b10a2011-08-10 12:38:08 +0200828 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +0200829 list_join(&ga, tv.vval.v_list, (char_u *)"\n", TRUE, FALSE, 0);
Bram Moolenaar213b10a2011-08-10 12:38:08 +0200830 if (tv.vval.v_list->lv_len > 0)
831 ga_append(&ga, NL);
832 }
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000833 ga_append(&ga, NUL);
834 retval = (char_u *)ga.ga_data;
835 }
Bram Moolenaara85fb752008-09-07 11:55:43 +0000836#ifdef FEAT_FLOAT
837 else if (convert && tv.v_type == VAR_FLOAT)
838 {
839 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float);
840 retval = vim_strsave(numbuf);
841 }
842#endif
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000843 else
844 retval = vim_strsave(get_tv_string(&tv));
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000845 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000846 }
847
848 return retval;
849}
850
851/*
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000852 * Call eval_to_string() without using current local variables and using
853 * textlock. When "use_sandbox" is TRUE use the sandbox.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000854 */
855 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100856eval_to_string_safe(
857 char_u *arg,
858 char_u **nextcmd,
859 int use_sandbox)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000860{
861 char_u *retval;
862 void *save_funccalp;
863
864 save_funccalp = save_funccal();
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000865 if (use_sandbox)
866 ++sandbox;
867 ++textlock;
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000868 retval = eval_to_string(arg, nextcmd, FALSE);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000869 if (use_sandbox)
870 --sandbox;
871 --textlock;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000872 restore_funccal(save_funccalp);
873 return retval;
874}
875
Bram Moolenaar071d4272004-06-13 20:20:40 +0000876/*
877 * Top level evaluation function, returning a number.
878 * Evaluates "expr" silently.
879 * Returns -1 for an error.
880 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200881 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +0100882eval_to_number(char_u *expr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000883{
Bram Moolenaar33570922005-01-25 22:26:29 +0000884 typval_T rettv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200885 varnumber_T retval;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +0000886 char_u *p = skipwhite(expr);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000887
888 ++emsg_off;
889
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000890 if (eval1(&p, &rettv, TRUE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000891 retval = -1;
892 else
893 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000894 retval = get_tv_number_chk(&rettv, NULL);
Bram Moolenaarc70646c2005-01-04 21:52:38 +0000895 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896 }
897 --emsg_off;
898
899 return retval;
900}
901
Bram Moolenaara40058a2005-07-11 22:42:07 +0000902/*
903 * Prepare v: variable "idx" to be used.
904 * Save the current typeval in "save_tv".
905 * When not used yet add the variable to the v: hashtable.
906 */
907 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100908prepare_vimvar(int idx, typval_T *save_tv)
Bram Moolenaara40058a2005-07-11 22:42:07 +0000909{
910 *save_tv = vimvars[idx].vv_tv;
911 if (vimvars[idx].vv_type == VAR_UNKNOWN)
912 hash_add(&vimvarht, vimvars[idx].vv_di.di_key);
913}
914
915/*
916 * Restore v: variable "idx" to typeval "save_tv".
917 * When no longer defined, remove the variable from the v: hashtable.
918 */
919 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100920restore_vimvar(int idx, typval_T *save_tv)
Bram Moolenaara40058a2005-07-11 22:42:07 +0000921{
922 hashitem_T *hi;
923
Bram Moolenaara40058a2005-07-11 22:42:07 +0000924 vimvars[idx].vv_tv = *save_tv;
925 if (vimvars[idx].vv_type == VAR_UNKNOWN)
926 {
927 hi = hash_find(&vimvarht, vimvars[idx].vv_di.di_key);
928 if (HASHITEM_EMPTY(hi))
Bram Moolenaar95f09602016-11-10 20:01:45 +0100929 internal_error("restore_vimvar()");
Bram Moolenaara40058a2005-07-11 22:42:07 +0000930 else
931 hash_remove(&vimvarht, hi);
932 }
933}
934
Bram Moolenaar3c56a962006-03-12 22:19:04 +0000935#if defined(FEAT_SPELL) || defined(PROTO)
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000936/*
937 * Evaluate an expression to a list with suggestions.
938 * For the "expr:" part of 'spellsuggest'.
Bram Moolenaar9bf749b2008-07-27 13:57:29 +0000939 * Returns NULL when there is an error.
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000940 */
941 list_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100942eval_spell_expr(char_u *badword, char_u *expr)
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000943{
944 typval_T save_val;
945 typval_T rettv;
946 list_T *list = NULL;
947 char_u *p = skipwhite(expr);
948
949 /* Set "v:val" to the bad word. */
950 prepare_vimvar(VV_VAL, &save_val);
951 vimvars[VV_VAL].vv_type = VAR_STRING;
952 vimvars[VV_VAL].vv_str = badword;
953 if (p_verbose == 0)
954 ++emsg_off;
955
956 if (eval1(&p, &rettv, TRUE) == OK)
957 {
958 if (rettv.v_type != VAR_LIST)
959 clear_tv(&rettv);
960 else
961 list = rettv.vval.v_list;
962 }
963
964 if (p_verbose == 0)
965 --emsg_off;
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000966 restore_vimvar(VV_VAL, &save_val);
967
968 return list;
969}
970
971/*
972 * "list" is supposed to contain two items: a word and a number. Return the
973 * word in "pp" and the number as the return value.
974 * Return -1 if anything isn't right.
975 * Used to get the good word and score from the eval_spell_expr() result.
976 */
977 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100978get_spellword(list_T *list, char_u **pp)
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000979{
980 listitem_T *li;
981
982 li = list->lv_first;
983 if (li == NULL)
984 return -1;
985 *pp = get_tv_string(&li->li_tv);
986
987 li = li->li_next;
988 if (li == NULL)
989 return -1;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +0200990 return (int)get_tv_number(&li->li_tv);
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +0000991}
992#endif
993
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000994/*
Bram Moolenaar4770d092006-01-12 23:22:24 +0000995 * Top level evaluation function.
996 * Returns an allocated typval_T with the result.
997 * Returns NULL when there is an error.
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000998 */
999 typval_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001000eval_expr(char_u *arg, char_u **nextcmd)
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00001001{
1002 typval_T *tv;
1003
1004 tv = (typval_T *)alloc(sizeof(typval_T));
Bram Moolenaar4770d092006-01-12 23:22:24 +00001005 if (tv != NULL && eval0(arg, tv, nextcmd, TRUE) == FAIL)
Bram Moolenaard23a8232018-02-10 18:45:26 +01001006 VIM_CLEAR(tv);
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00001007
1008 return tv;
1009}
1010
1011
Bram Moolenaar071d4272004-06-13 20:20:40 +00001012/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +01001013 * Call some Vim script function and return the result in "*rettv".
Bram Moolenaar8c8de832008-06-24 22:58:06 +00001014 * Uses argv[argc] for the function arguments. Only Number and String
1015 * arguments are currently supported.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001016 * Returns OK or FAIL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001017 */
Bram Moolenaar82139082011-09-14 16:52:09 +02001018 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001019call_vim_function(
1020 char_u *func,
1021 int argc,
1022 char_u **argv,
1023 int safe, /* use the sandbox */
1024 int str_arg_only, /* all arguments are strings */
1025 typval_T *rettv)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001026{
Bram Moolenaar33570922005-01-25 22:26:29 +00001027 typval_T *argvars;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001028 varnumber_T n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001029 int len;
1030 int i;
1031 int doesrange;
1032 void *save_funccalp = NULL;
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001033 int ret;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001034
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001035 argvars = (typval_T *)alloc((unsigned)((argc + 1) * sizeof(typval_T)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001036 if (argvars == NULL)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001037 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001038
1039 for (i = 0; i < argc; i++)
1040 {
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00001041 /* Pass a NULL or empty argument as an empty string */
1042 if (argv[i] == NULL || *argv[i] == NUL)
1043 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00001044 argvars[i].v_type = VAR_STRING;
1045 argvars[i].vval.v_string = (char_u *)"";
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00001046 continue;
1047 }
1048
Bram Moolenaar0cbba942012-07-25 16:47:03 +02001049 if (str_arg_only)
1050 len = 0;
1051 else
Bram Moolenaarffd99f72017-11-02 15:44:14 +01001052 {
1053 /* Recognize a number argument, the others must be strings. A dash
1054 * is a string too. */
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001055 vim_str2nr(argv[i], NULL, &len, STR2NR_ALL, &n, NULL, 0);
Bram Moolenaarffd99f72017-11-02 15:44:14 +01001056 if (len == 1 && *argv[i] == '-')
1057 len = 0;
1058 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001059 if (len != 0 && len == (int)STRLEN(argv[i]))
1060 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00001061 argvars[i].v_type = VAR_NUMBER;
1062 argvars[i].vval.v_number = n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001063 }
1064 else
1065 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00001066 argvars[i].v_type = VAR_STRING;
1067 argvars[i].vval.v_string = argv[i];
Bram Moolenaar071d4272004-06-13 20:20:40 +00001068 }
1069 }
1070
1071 if (safe)
1072 {
1073 save_funccalp = save_funccal();
1074 ++sandbox;
1075 }
1076
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001077 rettv->v_type = VAR_UNKNOWN; /* clear_tv() uses this */
Bram Moolenaardf48fb42016-07-22 21:50:18 +02001078 ret = call_func(func, (int)STRLEN(func), rettv, argc, argvars, NULL,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001079 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001080 &doesrange, TRUE, NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001081 if (safe)
1082 {
1083 --sandbox;
1084 restore_funccal(save_funccalp);
1085 }
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001086 vim_free(argvars);
1087
1088 if (ret == FAIL)
1089 clear_tv(rettv);
1090
1091 return ret;
1092}
1093
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001094/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +01001095 * Call Vim script function "func" and return the result as a number.
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001096 * Returns -1 when calling the function fails.
1097 * Uses argv[argc] for the function arguments.
1098 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001099 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01001100call_func_retnr(
1101 char_u *func,
1102 int argc,
1103 char_u **argv,
1104 int safe) /* use the sandbox */
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001105{
1106 typval_T rettv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001107 varnumber_T retval;
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001108
1109 /* All arguments are passed as strings, no conversion to number. */
1110 if (call_vim_function(func, argc, argv, safe, TRUE, &rettv) == FAIL)
1111 return -1;
1112
1113 retval = get_tv_number_chk(&rettv, NULL);
1114 clear_tv(&rettv);
1115 return retval;
1116}
1117
1118#if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1119 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1120
Bram Moolenaar4f688582007-07-24 12:34:30 +00001121# if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001122/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +01001123 * Call Vim script function "func" and return the result as a string.
Bram Moolenaar25ceb222005-07-30 22:45:36 +00001124 * Returns NULL when calling the function fails.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001125 * Uses argv[argc] for the function arguments.
1126 */
1127 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001128call_func_retstr(
1129 char_u *func,
1130 int argc,
1131 char_u **argv,
1132 int safe) /* use the sandbox */
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001133{
1134 typval_T rettv;
Bram Moolenaar25ceb222005-07-30 22:45:36 +00001135 char_u *retval;
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001136
Bram Moolenaar0cbba942012-07-25 16:47:03 +02001137 /* All arguments are passed as strings, no conversion to number. */
1138 if (call_vim_function(func, argc, argv, safe, TRUE, &rettv) == FAIL)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001139 return NULL;
1140
1141 retval = vim_strsave(get_tv_string(&rettv));
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001142 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001143 return retval;
1144}
Bram Moolenaar4f688582007-07-24 12:34:30 +00001145# endif
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001146
Bram Moolenaar25ceb222005-07-30 22:45:36 +00001147/*
Bram Moolenaarb544f3c2017-02-23 19:03:28 +01001148 * Call Vim script function "func" and return the result as a List.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001149 * Uses argv[argc] for the function arguments.
Bram Moolenaar9bf749b2008-07-27 13:57:29 +00001150 * Returns NULL when there is something wrong.
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001151 */
1152 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001153call_func_retlist(
1154 char_u *func,
1155 int argc,
1156 char_u **argv,
1157 int safe) /* use the sandbox */
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001158{
1159 typval_T rettv;
1160
Bram Moolenaar0cbba942012-07-25 16:47:03 +02001161 /* All arguments are passed as strings, no conversion to number. */
1162 if (call_vim_function(func, argc, argv, safe, TRUE, &rettv) == FAIL)
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001163 return NULL;
1164
1165 if (rettv.v_type != VAR_LIST)
1166 {
1167 clear_tv(&rettv);
1168 return NULL;
1169 }
1170
1171 return rettv.vval.v_list;
1172}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001173#endif
1174
Bram Moolenaar05159a02005-02-26 23:04:13 +00001175
Bram Moolenaar071d4272004-06-13 20:20:40 +00001176#ifdef FEAT_FOLDING
1177/*
1178 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1179 * it in "*cp". Doesn't give error messages.
1180 */
1181 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001182eval_foldexpr(char_u *arg, int *cp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001183{
Bram Moolenaar33570922005-01-25 22:26:29 +00001184 typval_T tv;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001185 varnumber_T retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001186 char_u *s;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00001187 int use_sandbox = was_set_insecurely((char_u *)"foldexpr",
1188 OPT_LOCAL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001189
1190 ++emsg_off;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00001191 if (use_sandbox)
1192 ++sandbox;
1193 ++textlock;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001194 *cp = NUL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001195 if (eval0(arg, &tv, NULL, TRUE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001196 retval = 0;
1197 else
1198 {
1199 /* If the result is a number, just return the number. */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001200 if (tv.v_type == VAR_NUMBER)
1201 retval = tv.vval.v_number;
Bram Moolenaar758711c2005-02-02 23:11:38 +00001202 else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001203 retval = 0;
1204 else
1205 {
1206 /* If the result is a string, check if there is a non-digit before
1207 * the number. */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001208 s = tv.vval.v_string;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001209 if (!VIM_ISDIGIT(*s) && *s != '-')
1210 *cp = *s++;
1211 retval = atol((char *)s);
1212 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001213 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001214 }
1215 --emsg_off;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00001216 if (use_sandbox)
1217 --sandbox;
1218 --textlock;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001219
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001220 return (int)retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001221}
1222#endif
1223
Bram Moolenaar071d4272004-06-13 20:20:40 +00001224/*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001225 * ":let" list all variable values
1226 * ":let var1 var2" list variable values
1227 * ":let var = expr" assignment command.
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001228 * ":let var += expr" assignment command.
1229 * ":let var -= expr" assignment command.
1230 * ":let var .= expr" assignment command.
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001231 * ":let [var1, var2] = expr" unpack list.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001232 */
1233 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001234ex_let(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001235{
1236 char_u *arg = eap->arg;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001237 char_u *expr = NULL;
Bram Moolenaar33570922005-01-25 22:26:29 +00001238 typval_T rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239 int i;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001240 int var_count = 0;
1241 int semicolon = 0;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001242 char_u op[2];
Bram Moolenaardb552d602006-03-23 22:59:57 +00001243 char_u *argend;
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001244 int first = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001245
Bram Moolenaardb552d602006-03-23 22:59:57 +00001246 argend = skip_var_list(arg, &var_count, &semicolon);
1247 if (argend == NULL)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001248 return;
Bram Moolenaar76b92b22006-03-24 22:46:53 +00001249 if (argend > arg && argend[-1] == '.') /* for var.='str' */
1250 --argend;
Bram Moolenaara3920382014-03-30 16:49:09 +02001251 expr = skipwhite(argend);
1252 if (*expr != '=' && !(vim_strchr((char_u *)"+-.", *expr) != NULL
1253 && expr[1] == '='))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001254 {
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00001255 /*
1256 * ":let" without "=": list variables
1257 */
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001258 if (*arg == '[')
1259 EMSG(_(e_invarg));
1260 else if (!ends_excmd(*arg))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001261 /* ":let var1 var2" */
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001262 arg = list_arg_vars(eap, arg, &first);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001263 else if (!eap->skip)
Bram Moolenaara7043832005-01-21 11:56:39 +00001264 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001265 /* ":let" */
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001266 list_glob_vars(&first);
1267 list_buf_vars(&first);
1268 list_win_vars(&first);
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001269 list_tab_vars(&first);
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001270 list_script_vars(&first);
1271 list_func_vars(&first);
1272 list_vim_vars(&first);
Bram Moolenaara7043832005-01-21 11:56:39 +00001273 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001274 eap->nextcmd = check_nextcmd(arg);
1275 }
1276 else
1277 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001278 op[0] = '=';
1279 op[1] = NUL;
Bram Moolenaara3920382014-03-30 16:49:09 +02001280 if (*expr != '=')
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001281 {
Bram Moolenaara3920382014-03-30 16:49:09 +02001282 if (vim_strchr((char_u *)"+-.", *expr) != NULL)
1283 op[0] = *expr; /* +=, -= or .= */
1284 expr = skipwhite(expr + 2);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001285 }
Bram Moolenaara3920382014-03-30 16:49:09 +02001286 else
1287 expr = skipwhite(expr + 1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001288
Bram Moolenaar071d4272004-06-13 20:20:40 +00001289 if (eap->skip)
1290 ++emsg_skip;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001291 i = eval0(expr, &rettv, &eap->nextcmd, !eap->skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001292 if (eap->skip)
1293 {
1294 if (i != FAIL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001295 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296 --emsg_skip;
1297 }
1298 else if (i != FAIL)
1299 {
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001300 (void)ex_let_vars(eap->arg, &rettv, FALSE, semicolon, var_count,
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001301 op);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001302 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001303 }
1304 }
1305}
1306
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001307/*
1308 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1309 * Handles both "var" with any type and "[var, var; var]" with a list type.
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001310 * When "nextchars" is not NULL it points to a string with characters that
1311 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1312 * or concatenate.
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001313 * Returns OK or FAIL;
1314 */
1315 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001316ex_let_vars(
1317 char_u *arg_start,
1318 typval_T *tv,
1319 int copy, /* copy values from "tv", don't move */
1320 int semicolon, /* from skip_var_list() */
1321 int var_count, /* from skip_var_list() */
1322 char_u *nextchars)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001323{
1324 char_u *arg = arg_start;
Bram Moolenaar33570922005-01-25 22:26:29 +00001325 list_T *l;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001326 int i;
Bram Moolenaar33570922005-01-25 22:26:29 +00001327 listitem_T *item;
1328 typval_T ltv;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001329
1330 if (*arg != '[')
1331 {
1332 /*
1333 * ":let var = expr" or ":for var in list"
1334 */
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001335 if (ex_let_one(arg, tv, copy, nextchars, nextchars) == NULL)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001336 return FAIL;
1337 return OK;
1338 }
1339
1340 /*
1341 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1342 */
Bram Moolenaar758711c2005-02-02 23:11:38 +00001343 if (tv->v_type != VAR_LIST || (l = tv->vval.v_list) == NULL)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001344 {
1345 EMSG(_(e_listreq));
1346 return FAIL;
1347 }
1348
1349 i = list_len(l);
1350 if (semicolon == 0 && var_count < i)
1351 {
Bram Moolenaare49b69a2005-01-08 16:11:57 +00001352 EMSG(_("E687: Less targets than List items"));
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001353 return FAIL;
1354 }
1355 if (var_count - semicolon > i)
1356 {
Bram Moolenaare49b69a2005-01-08 16:11:57 +00001357 EMSG(_("E688: More targets than List items"));
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001358 return FAIL;
1359 }
1360
1361 item = l->lv_first;
1362 while (*arg != ']')
1363 {
1364 arg = skipwhite(arg + 1);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001365 arg = ex_let_one(arg, &item->li_tv, TRUE, (char_u *)",;]", nextchars);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001366 item = item->li_next;
1367 if (arg == NULL)
1368 return FAIL;
1369
1370 arg = skipwhite(arg);
1371 if (*arg == ';')
1372 {
1373 /* Put the rest of the list (may be empty) in the var after ';'.
1374 * Create a new list for this. */
1375 l = list_alloc();
1376 if (l == NULL)
1377 return FAIL;
1378 while (item != NULL)
1379 {
1380 list_append_tv(l, &item->li_tv);
1381 item = item->li_next;
1382 }
1383
1384 ltv.v_type = VAR_LIST;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00001385 ltv.v_lock = 0;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001386 ltv.vval.v_list = l;
1387 l->lv_refcount = 1;
1388
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001389 arg = ex_let_one(skipwhite(arg + 1), &ltv, FALSE,
1390 (char_u *)"]", nextchars);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001391 clear_tv(&ltv);
1392 if (arg == NULL)
1393 return FAIL;
1394 break;
1395 }
1396 else if (*arg != ',' && *arg != ']')
1397 {
Bram Moolenaar95f09602016-11-10 20:01:45 +01001398 internal_error("ex_let_vars()");
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001399 return FAIL;
1400 }
1401 }
1402
1403 return OK;
1404}
1405
1406/*
1407 * Skip over assignable variable "var" or list of variables "[var, var]".
1408 * Used for ":let varvar = expr" and ":for varvar in expr".
1409 * For "[var, var]" increment "*var_count" for each variable.
1410 * for "[var, var; var]" set "semicolon".
1411 * Return NULL for an error.
1412 */
1413 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001414skip_var_list(
1415 char_u *arg,
1416 int *var_count,
1417 int *semicolon)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001418{
1419 char_u *p, *s;
1420
1421 if (*arg == '[')
1422 {
1423 /* "[var, var]": find the matching ']'. */
1424 p = arg;
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00001425 for (;;)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001426 {
1427 p = skipwhite(p + 1); /* skip whites after '[', ';' or ',' */
1428 s = skip_var_one(p);
1429 if (s == p)
1430 {
1431 EMSG2(_(e_invarg2), p);
1432 return NULL;
1433 }
1434 ++*var_count;
1435
1436 p = skipwhite(s);
1437 if (*p == ']')
1438 break;
1439 else if (*p == ';')
1440 {
1441 if (*semicolon == 1)
1442 {
1443 EMSG(_("Double ; in list of variables"));
1444 return NULL;
1445 }
1446 *semicolon = 1;
1447 }
1448 else if (*p != ',')
1449 {
1450 EMSG2(_(e_invarg2), p);
1451 return NULL;
1452 }
1453 }
1454 return p + 1;
1455 }
1456 else
1457 return skip_var_one(arg);
1458}
1459
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001460/*
Bram Moolenaarbae0c162007-05-10 19:30:25 +00001461 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
Bram Moolenaar92124a32005-06-17 22:03:40 +00001462 * l[idx].
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001463 */
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001464 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001465skip_var_one(char_u *arg)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001466{
Bram Moolenaar92124a32005-06-17 22:03:40 +00001467 if (*arg == '@' && arg[1] != NUL)
1468 return arg + 2;
1469 return find_name_end(*arg == '$' || *arg == '&' ? arg + 1 : arg,
1470 NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001471}
1472
Bram Moolenaara7043832005-01-21 11:56:39 +00001473/*
Bram Moolenaar33570922005-01-25 22:26:29 +00001474 * List variables for hashtab "ht" with prefix "prefix".
1475 * If "empty" is TRUE also list NULL strings as empty strings.
Bram Moolenaara7043832005-01-21 11:56:39 +00001476 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02001477 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001478list_hashtable_vars(
1479 hashtab_T *ht,
1480 char_u *prefix,
1481 int empty,
1482 int *first)
Bram Moolenaara7043832005-01-21 11:56:39 +00001483{
Bram Moolenaar33570922005-01-25 22:26:29 +00001484 hashitem_T *hi;
1485 dictitem_T *di;
Bram Moolenaara7043832005-01-21 11:56:39 +00001486 int todo;
1487
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00001488 todo = (int)ht->ht_used;
Bram Moolenaara7043832005-01-21 11:56:39 +00001489 for (hi = ht->ht_array; todo > 0 && !got_int; ++hi)
1490 {
1491 if (!HASHITEM_EMPTY(hi))
1492 {
1493 --todo;
Bram Moolenaar33570922005-01-25 22:26:29 +00001494 di = HI2DI(hi);
1495 if (empty || di->di_tv.v_type != VAR_STRING
1496 || di->di_tv.vval.v_string != NULL)
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001497 list_one_var(di, prefix, first);
Bram Moolenaara7043832005-01-21 11:56:39 +00001498 }
1499 }
1500}
1501
1502/*
1503 * List global variables.
1504 */
1505 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001506list_glob_vars(int *first)
Bram Moolenaara7043832005-01-21 11:56:39 +00001507{
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001508 list_hashtable_vars(&globvarht, (char_u *)"", TRUE, first);
Bram Moolenaara7043832005-01-21 11:56:39 +00001509}
1510
1511/*
1512 * List buffer variables.
1513 */
1514 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001515list_buf_vars(int *first)
Bram Moolenaara7043832005-01-21 11:56:39 +00001516{
Bram Moolenaar429fa852013-04-15 12:27:36 +02001517 list_hashtable_vars(&curbuf->b_vars->dv_hashtab, (char_u *)"b:",
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001518 TRUE, first);
Bram Moolenaara7043832005-01-21 11:56:39 +00001519}
1520
1521/*
1522 * List window variables.
1523 */
1524 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001525list_win_vars(int *first)
Bram Moolenaara7043832005-01-21 11:56:39 +00001526{
Bram Moolenaar429fa852013-04-15 12:27:36 +02001527 list_hashtable_vars(&curwin->w_vars->dv_hashtab,
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001528 (char_u *)"w:", TRUE, first);
Bram Moolenaara7043832005-01-21 11:56:39 +00001529}
1530
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001531/*
1532 * List tab page variables.
1533 */
1534 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001535list_tab_vars(int *first)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001536{
Bram Moolenaar429fa852013-04-15 12:27:36 +02001537 list_hashtable_vars(&curtab->tp_vars->dv_hashtab,
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001538 (char_u *)"t:", TRUE, first);
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001539}
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001540
Bram Moolenaara7043832005-01-21 11:56:39 +00001541/*
1542 * List Vim variables.
1543 */
1544 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001545list_vim_vars(int *first)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001546{
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001547 list_hashtable_vars(&vimvarht, (char_u *)"v:", FALSE, first);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001548}
1549
1550/*
Bram Moolenaarf0acfce2006-03-17 23:21:19 +00001551 * List script-local variables, if there is a script.
1552 */
1553 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001554list_script_vars(int *first)
Bram Moolenaarf0acfce2006-03-17 23:21:19 +00001555{
1556 if (current_SID > 0 && current_SID <= ga_scripts.ga_len)
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001557 list_hashtable_vars(&SCRIPT_VARS(current_SID),
1558 (char_u *)"s:", FALSE, first);
Bram Moolenaarf0acfce2006-03-17 23:21:19 +00001559}
1560
1561/*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001562 * List variables in "arg".
1563 */
1564 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001565list_arg_vars(exarg_T *eap, char_u *arg, int *first)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001566{
1567 int error = FALSE;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001568 int len;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001569 char_u *name;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001570 char_u *name_start;
1571 char_u *arg_subsc;
1572 char_u *tofree;
1573 typval_T tv;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001574
1575 while (!ends_excmd(*arg) && !got_int)
1576 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001577 if (error || eap->skip)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001578 {
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00001579 arg = find_name_end(arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
Bram Moolenaar1c465442017-03-12 20:10:05 +01001580 if (!VIM_ISWHITE(*arg) && !ends_excmd(*arg))
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001581 {
1582 emsg_severe = TRUE;
1583 EMSG(_(e_trailing));
1584 break;
1585 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001586 }
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001587 else
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001588 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001589 /* get_name_len() takes care of expanding curly braces */
1590 name_start = name = arg;
1591 len = get_name_len(&arg, &tofree, TRUE, TRUE);
1592 if (len <= 0)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001593 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001594 /* This is mainly to keep test 49 working: when expanding
1595 * curly braces fails overrule the exception error message. */
1596 if (len < 0 && !aborting())
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001597 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001598 emsg_severe = TRUE;
1599 EMSG2(_(e_invarg2), arg);
1600 break;
1601 }
1602 error = TRUE;
1603 }
1604 else
1605 {
1606 if (tofree != NULL)
1607 name = tofree;
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02001608 if (get_var_tv(name, len, &tv, NULL, TRUE, FALSE) == FAIL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001609 error = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001610 else
1611 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001612 /* handle d.key, l[idx], f(expr) */
1613 arg_subsc = arg;
1614 if (handle_subscript(&arg, &tv, TRUE, TRUE) == FAIL)
Bram Moolenaara7043832005-01-21 11:56:39 +00001615 error = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001616 else
Bram Moolenaara7043832005-01-21 11:56:39 +00001617 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001618 if (arg == arg_subsc && len == 2 && name[1] == ':')
Bram Moolenaara7043832005-01-21 11:56:39 +00001619 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001620 switch (*name)
Bram Moolenaara7043832005-01-21 11:56:39 +00001621 {
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001622 case 'g': list_glob_vars(first); break;
1623 case 'b': list_buf_vars(first); break;
1624 case 'w': list_win_vars(first); break;
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001625 case 't': list_tab_vars(first); break;
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001626 case 'v': list_vim_vars(first); break;
1627 case 's': list_script_vars(first); break;
1628 case 'l': list_func_vars(first); break;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001629 default:
1630 EMSG2(_("E738: Can't list variables for %s"), name);
Bram Moolenaara7043832005-01-21 11:56:39 +00001631 }
Bram Moolenaara7043832005-01-21 11:56:39 +00001632 }
1633 else
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001634 {
1635 char_u numbuf[NUMBUFLEN];
1636 char_u *tf;
1637 int c;
1638 char_u *s;
1639
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00001640 s = echo_string(&tv, &tf, numbuf, 0);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001641 c = *arg;
1642 *arg = NUL;
1643 list_one_var_a((char_u *)"",
1644 arg == arg_subsc ? name : name_start,
Bram Moolenaar7d61a922007-08-30 09:12:23 +00001645 tv.v_type,
1646 s == NULL ? (char_u *)"" : s,
1647 first);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001648 *arg = c;
1649 vim_free(tf);
1650 }
1651 clear_tv(&tv);
Bram Moolenaara7043832005-01-21 11:56:39 +00001652 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001653 }
1654 }
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001655
1656 vim_free(tofree);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001657 }
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00001658
1659 arg = skipwhite(arg);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001660 }
1661
1662 return arg;
1663}
1664
1665/*
1666 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
1667 * Returns a pointer to the char just after the var name.
1668 * Returns NULL if there is an error.
1669 */
1670 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001671ex_let_one(
1672 char_u *arg, /* points to variable name */
1673 typval_T *tv, /* value to assign to variable */
1674 int copy, /* copy value from "tv" */
1675 char_u *endchars, /* valid chars after variable name or NULL */
1676 char_u *op) /* "+", "-", "." or NULL*/
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001677{
1678 int c1;
1679 char_u *name;
1680 char_u *p;
1681 char_u *arg_end = NULL;
1682 int len;
1683 int opt_flags;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001684 char_u *tofree = NULL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001685
1686 /*
1687 * ":let $VAR = expr": Set environment variable.
1688 */
1689 if (*arg == '$')
1690 {
1691 /* Find the end of the name. */
1692 ++arg;
1693 name = arg;
1694 len = get_env_len(&arg);
1695 if (len == 0)
1696 EMSG2(_(e_invarg2), name - 1);
1697 else
1698 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001699 if (op != NULL && (*op == '+' || *op == '-'))
1700 EMSG2(_(e_letwrong), op);
1701 else if (endchars != NULL
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001702 && vim_strchr(endchars, *skipwhite(arg)) == NULL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001703 EMSG(_(e_letunexp));
Bram Moolenaard4ddfaf2010-12-02 14:48:14 +01001704 else if (!check_secure())
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001705 {
1706 c1 = name[len];
1707 name[len] = NUL;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001708 p = get_tv_string_chk(tv);
1709 if (p != NULL && op != NULL && *op == '.')
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001710 {
1711 int mustfree = FALSE;
1712 char_u *s = vim_getenv(name, &mustfree);
1713
1714 if (s != NULL)
1715 {
1716 p = tofree = concat_str(s, p);
1717 if (mustfree)
1718 vim_free(s);
1719 }
1720 }
1721 if (p != NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001722 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001723 vim_setenv(name, p);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001724 if (STRICMP(name, "HOME") == 0)
1725 init_homedir();
1726 else if (didset_vim && STRICMP(name, "VIM") == 0)
1727 didset_vim = FALSE;
1728 else if (didset_vimruntime
1729 && STRICMP(name, "VIMRUNTIME") == 0)
1730 didset_vimruntime = FALSE;
1731 arg_end = arg;
1732 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001733 name[len] = c1;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001734 vim_free(tofree);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001735 }
1736 }
1737 }
1738
1739 /*
1740 * ":let &option = expr": Set option value.
1741 * ":let &l:option = expr": Set local option value.
1742 * ":let &g:option = expr": Set global option value.
1743 */
1744 else if (*arg == '&')
1745 {
1746 /* Find the end of the name. */
1747 p = find_option_end(&arg, &opt_flags);
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001748 if (p == NULL || (endchars != NULL
1749 && vim_strchr(endchars, *skipwhite(p)) == NULL))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001750 EMSG(_(e_letunexp));
1751 else
1752 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001753 long n;
1754 int opt_type;
1755 long numval;
1756 char_u *stringval = NULL;
1757 char_u *s;
1758
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001759 c1 = *p;
1760 *p = NUL;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001761
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001762 n = (long)get_tv_number(tv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001763 s = get_tv_string_chk(tv); /* != NULL if number or string */
1764 if (s != NULL && op != NULL && *op != '=')
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001765 {
1766 opt_type = get_option_value(arg, &numval,
1767 &stringval, opt_flags);
1768 if ((opt_type == 1 && *op == '.')
1769 || (opt_type == 0 && *op != '.'))
Bram Moolenaar2a6a6c32017-10-02 19:29:48 +02001770 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001771 EMSG2(_(e_letwrong), op);
Bram Moolenaar2a6a6c32017-10-02 19:29:48 +02001772 s = NULL; /* don't set the value */
1773 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001774 else
1775 {
1776 if (opt_type == 1) /* number */
1777 {
1778 if (*op == '+')
1779 n = numval + n;
1780 else
1781 n = numval - n;
1782 }
1783 else if (opt_type == 0 && stringval != NULL) /* string */
1784 {
1785 s = concat_str(stringval, s);
1786 vim_free(stringval);
1787 stringval = s;
1788 }
1789 }
1790 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001791 if (s != NULL)
1792 {
1793 set_option_value(arg, n, s, opt_flags);
1794 arg_end = p;
1795 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001796 *p = c1;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001797 vim_free(stringval);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001798 }
1799 }
1800
1801 /*
1802 * ":let @r = expr": Set register contents.
1803 */
1804 else if (*arg == '@')
1805 {
1806 ++arg;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001807 if (op != NULL && (*op == '+' || *op == '-'))
1808 EMSG2(_(e_letwrong), op);
1809 else if (endchars != NULL
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00001810 && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001811 EMSG(_(e_letunexp));
1812 else
1813 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00001814 char_u *ptofree = NULL;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001815 char_u *s;
1816
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001817 p = get_tv_string_chk(tv);
1818 if (p != NULL && op != NULL && *op == '.')
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001819 {
Bram Moolenaarb7cb42b2014-04-02 19:55:10 +02001820 s = get_reg_contents(*arg == '@' ? '"' : *arg, GREG_EXPR_SRC);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001821 if (s != NULL)
1822 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00001823 p = ptofree = concat_str(s, p);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001824 vim_free(s);
1825 }
1826 }
1827 if (p != NULL)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001828 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001829 write_reg_contents(*arg == '@' ? '"' : *arg, p, -1, FALSE);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001830 arg_end = arg + 1;
1831 }
Bram Moolenaar89d40322006-08-29 15:30:07 +00001832 vim_free(ptofree);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001833 }
1834 }
1835
1836 /*
1837 * ":let var = expr": Set internal variable.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001838 * ":let {expr} = expr": Idem, name made with curly braces
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001839 */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00001840 else if (eval_isnamec1(*arg) || *arg == '{')
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001841 {
Bram Moolenaar33570922005-01-25 22:26:29 +00001842 lval_T lv;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001843
Bram Moolenaar6d977d62014-01-14 15:24:39 +01001844 p = get_lval(arg, tv, &lv, FALSE, FALSE, 0, FNE_CHECK_START);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001845 if (p != NULL && lv.ll_name != NULL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001846 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001847 if (endchars != NULL && vim_strchr(endchars, *skipwhite(p)) == NULL)
1848 EMSG(_(e_letunexp));
1849 else
1850 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00001851 set_var_lval(&lv, p, tv, copy, op);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001852 arg_end = p;
1853 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001854 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001855 clear_lval(&lv);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001856 }
1857
1858 else
1859 EMSG2(_(e_invarg2), arg);
1860
1861 return arg_end;
1862}
1863
1864/*
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001865 * Get an lval: variable, Dict item or List item that can be assigned a value
1866 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
1867 * "name.key", "name.key[expr]" etc.
1868 * Indexing only works if "name" is an existing List or Dictionary.
1869 * "name" points to the start of the name.
1870 * If "rettv" is not NULL it points to the value to be assigned.
1871 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
1872 * wrong; must end in space or cmd separator.
1873 *
Bram Moolenaar6d977d62014-01-14 15:24:39 +01001874 * flags:
1875 * GLV_QUIET: do not give error messages
Bram Moolenaar3a257732017-02-21 20:47:13 +01001876 * GLV_READ_ONLY: will not change the variable
Bram Moolenaar6d977d62014-01-14 15:24:39 +01001877 * GLV_NO_AUTOLOAD: do not use script autoloading
1878 *
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001879 * Returns a pointer to just after the name, including indexes.
Bram Moolenaara7043832005-01-21 11:56:39 +00001880 * When an evaluation error occurs "lp->ll_name" is NULL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001881 * Returns NULL for a parsing error. Still need to free items in "lp"!
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001882 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02001883 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001884get_lval(
1885 char_u *name,
1886 typval_T *rettv,
1887 lval_T *lp,
1888 int unlet,
1889 int skip,
1890 int flags, /* GLV_ values */
1891 int fne_flags) /* flags for find_name_end() */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001892{
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001893 char_u *p;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001894 char_u *expr_start, *expr_end;
1895 int cc;
Bram Moolenaar33570922005-01-25 22:26:29 +00001896 dictitem_T *v;
1897 typval_T var1;
1898 typval_T var2;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001899 int empty1 = FALSE;
Bram Moolenaar33570922005-01-25 22:26:29 +00001900 listitem_T *ni;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001901 char_u *key = NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001902 int len;
Bram Moolenaar33570922005-01-25 22:26:29 +00001903 hashtab_T *ht;
Bram Moolenaar6d977d62014-01-14 15:24:39 +01001904 int quiet = flags & GLV_QUIET;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001905
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001906 /* Clear everything in "lp". */
Bram Moolenaar33570922005-01-25 22:26:29 +00001907 vim_memset(lp, 0, sizeof(lval_T));
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001908
1909 if (skip)
1910 {
1911 /* When skipping just find the end of the name. */
1912 lp->ll_name = name;
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00001913 return find_name_end(name, NULL, NULL, FNE_INCL_BR | fne_flags);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001914 }
1915
1916 /* Find the end of the name. */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00001917 p = find_name_end(name, &expr_start, &expr_end, fne_flags);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001918 if (expr_start != NULL)
1919 {
1920 /* Don't expand the name when we already know there is an error. */
Bram Moolenaar1c465442017-03-12 20:10:05 +01001921 if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001922 && *p != '[' && *p != '.')
1923 {
1924 EMSG(_(e_trailing));
1925 return NULL;
1926 }
1927
1928 lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p);
1929 if (lp->ll_exp_name == NULL)
1930 {
1931 /* Report an invalid expression in braces, unless the
1932 * expression evaluation has been cancelled due to an
1933 * aborting error, an interrupt, or an exception. */
1934 if (!aborting() && !quiet)
1935 {
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00001936 emsg_severe = TRUE;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001937 EMSG2(_(e_invarg2), name);
1938 return NULL;
1939 }
1940 }
1941 lp->ll_name = lp->ll_exp_name;
1942 }
1943 else
1944 lp->ll_name = name;
1945
1946 /* Without [idx] or .key we are done. */
1947 if ((*p != '[' && *p != '.') || lp->ll_name == NULL)
1948 return p;
1949
1950 cc = *p;
1951 *p = NUL;
Bram Moolenaar6e65d592017-12-07 22:11:27 +01001952 /* Only pass &ht when we would write to the variable, it prevents autoload
1953 * as well. */
1954 v = find_var(lp->ll_name, (flags & GLV_READ_ONLY) ? NULL : &ht,
1955 flags & GLV_NO_AUTOLOAD);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001956 if (v == NULL && !quiet)
1957 EMSG2(_(e_undefvar), lp->ll_name);
1958 *p = cc;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001959 if (v == NULL)
1960 return NULL;
1961
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001962 /*
1963 * Loop until no more [idx] or .key is following.
1964 */
Bram Moolenaar33570922005-01-25 22:26:29 +00001965 lp->ll_tv = &v->di_tv;
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01001966 var1.v_type = VAR_UNKNOWN;
1967 var2.v_type = VAR_UNKNOWN;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001968 while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001969 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001970 if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL)
1971 && !(lp->ll_tv->v_type == VAR_DICT
1972 && lp->ll_tv->vval.v_dict != NULL))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001973 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001974 if (!quiet)
1975 EMSG(_("E689: Can only index a List or Dictionary"));
1976 return NULL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001977 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001978 if (lp->ll_range)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001979 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001980 if (!quiet)
1981 EMSG(_("E708: [:] must come last"));
1982 return NULL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00001983 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001984
Bram Moolenaar8c711452005-01-14 21:53:12 +00001985 len = -1;
1986 if (*p == '.')
1987 {
1988 key = p + 1;
1989 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len)
1990 ;
1991 if (len == 0)
1992 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00001993 if (!quiet)
1994 EMSG(_(e_emptykey));
1995 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00001996 }
1997 p = key + len;
1998 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00001999 else
2000 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00002001 /* Get the index [expr] or the first index [expr: ]. */
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002002 p = skipwhite(p + 1);
Bram Moolenaar8c711452005-01-14 21:53:12 +00002003 if (*p == ':')
2004 empty1 = TRUE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002005 else
2006 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00002007 empty1 = FALSE;
2008 if (eval1(&p, &var1, TRUE) == FAIL) /* recursive! */
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002009 return NULL;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002010 if (get_tv_string_chk(&var1) == NULL)
2011 {
2012 /* not a number or string */
2013 clear_tv(&var1);
2014 return NULL;
2015 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00002016 }
2017
2018 /* Optionally get the second index [ :expr]. */
2019 if (*p == ':')
2020 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002021 if (lp->ll_tv->v_type == VAR_DICT)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002022 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002023 if (!quiet)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002024 EMSG(_(e_dictrange));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002025 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002026 return NULL;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002027 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002028 if (rettv != NULL && (rettv->v_type != VAR_LIST
2029 || rettv->vval.v_list == NULL))
Bram Moolenaar8c711452005-01-14 21:53:12 +00002030 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002031 if (!quiet)
2032 EMSG(_("E709: [:] requires a List value"));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002033 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002034 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002035 }
2036 p = skipwhite(p + 1);
2037 if (*p == ']')
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002038 lp->ll_empty2 = TRUE;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002039 else
2040 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002041 lp->ll_empty2 = FALSE;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002042 if (eval1(&p, &var2, TRUE) == FAIL) /* recursive! */
2043 {
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002044 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002045 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002046 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002047 if (get_tv_string_chk(&var2) == NULL)
2048 {
2049 /* not a number or string */
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002050 clear_tv(&var1);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002051 clear_tv(&var2);
2052 return NULL;
2053 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00002054 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002055 lp->ll_range = TRUE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002056 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00002057 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002058 lp->ll_range = FALSE;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002059
Bram Moolenaar8c711452005-01-14 21:53:12 +00002060 if (*p != ']')
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002061 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002062 if (!quiet)
2063 EMSG(_(e_missbrac));
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002064 clear_tv(&var1);
2065 clear_tv(&var2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002066 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002067 }
2068
2069 /* Skip to past ']'. */
2070 ++p;
2071 }
2072
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002073 if (lp->ll_tv->v_type == VAR_DICT)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002074 {
2075 if (len == -1)
2076 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002077 /* "[key]": get key from "var1" */
Bram Moolenaar0921ecf2016-04-03 22:44:36 +02002078 key = get_tv_string_chk(&var1); /* is number or string */
2079 if (key == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002080 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00002081 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002082 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002083 }
2084 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002085 lp->ll_list = NULL;
2086 lp->ll_dict = lp->ll_tv->vval.v_dict;
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00002087 lp->ll_di = dict_find(lp->ll_dict, key, len);
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002088
Bram Moolenaarbdb62052012-07-16 17:31:53 +02002089 /* When assigning to a scope dictionary check that a function and
2090 * variable name is valid (only variable name unless it is l: or
2091 * g: dictionary). Disallow overwriting a builtin function. */
2092 if (rettv != NULL && lp->ll_dict->dv_scope != 0)
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002093 {
Bram Moolenaarbdb62052012-07-16 17:31:53 +02002094 int prevval;
2095 int wrong;
2096
2097 if (len != -1)
2098 {
2099 prevval = key[len];
2100 key[len] = NUL;
2101 }
Bram Moolenaar4380d1e2013-06-09 20:51:00 +02002102 else
2103 prevval = 0; /* avoid compiler warning */
Bram Moolenaarbdb62052012-07-16 17:31:53 +02002104 wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE
2105 && rettv->v_type == VAR_FUNC
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002106 && var_check_func_name(key, lp->ll_di == NULL))
Bram Moolenaarbdb62052012-07-16 17:31:53 +02002107 || !valid_varname(key);
2108 if (len != -1)
2109 key[len] = prevval;
2110 if (wrong)
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002111 return NULL;
2112 }
2113
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002114 if (lp->ll_di == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002115 {
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002116 /* Can't add "v:" variable. */
2117 if (lp->ll_dict == &vimvardict)
2118 {
2119 EMSG2(_(e_illvar), name);
2120 return NULL;
2121 }
2122
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00002123 /* Key does not exist in dict: may need to add it. */
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002124 if (*p == '[' || *p == '.' || unlet)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002125 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002126 if (!quiet)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002127 EMSG2(_(e_dictkey), key);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002128 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002129 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002130 }
2131 if (len == -1)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002132 lp->ll_newkey = vim_strsave(key);
Bram Moolenaar8c711452005-01-14 21:53:12 +00002133 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002134 lp->ll_newkey = vim_strnsave(key, len);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002135 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002136 if (lp->ll_newkey == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002137 p = NULL;
2138 break;
2139 }
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002140 /* existing variable, need to check if it can be changed */
Bram Moolenaar3a257732017-02-21 20:47:13 +01002141 else if ((flags & GLV_READ_ONLY) == 0
2142 && var_check_ro(lp->ll_di->di_flags, name, FALSE))
Bram Moolenaar49439c42017-02-20 23:07:05 +01002143 {
2144 clear_tv(&var1);
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002145 return NULL;
Bram Moolenaar49439c42017-02-20 23:07:05 +01002146 }
Bram Moolenaar4228bec2011-03-27 16:03:15 +02002147
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002148 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002149 lp->ll_tv = &lp->ll_di->di_tv;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002150 }
2151 else
2152 {
2153 /*
2154 * Get the number and item for the only or first index of the List.
2155 */
2156 if (empty1)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002157 lp->ll_n1 = 0;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002158 else
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002159 /* is number or string */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002160 lp->ll_n1 = (long)get_tv_number(&var1);
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002161 clear_tv(&var1);
2162
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002163 lp->ll_dict = NULL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002164 lp->ll_list = lp->ll_tv->vval.v_list;
2165 lp->ll_li = list_find(lp->ll_list, lp->ll_n1);
2166 if (lp->ll_li == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002167 {
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00002168 if (lp->ll_n1 < 0)
2169 {
2170 lp->ll_n1 = 0;
2171 lp->ll_li = list_find(lp->ll_list, lp->ll_n1);
2172 }
2173 }
2174 if (lp->ll_li == NULL)
2175 {
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002176 clear_tv(&var2);
Bram Moolenaare9623882011-04-21 14:27:28 +02002177 if (!quiet)
2178 EMSGN(_(e_listidx), lp->ll_n1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002179 return NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002180 }
2181
2182 /*
2183 * May need to find the item or absolute index for the second
2184 * index of a range.
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002185 * When no index given: "lp->ll_empty2" is TRUE.
2186 * Otherwise "lp->ll_n2" is set to the second index.
Bram Moolenaar8c711452005-01-14 21:53:12 +00002187 */
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002188 if (lp->ll_range && !lp->ll_empty2)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002189 {
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002190 lp->ll_n2 = (long)get_tv_number(&var2);
2191 /* is number or string */
Bram Moolenaar8c711452005-01-14 21:53:12 +00002192 clear_tv(&var2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002193 if (lp->ll_n2 < 0)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002194 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002195 ni = list_find(lp->ll_list, lp->ll_n2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00002196 if (ni == NULL)
Bram Moolenaare9623882011-04-21 14:27:28 +02002197 {
2198 if (!quiet)
2199 EMSGN(_(e_listidx), lp->ll_n2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002200 return NULL;
Bram Moolenaare9623882011-04-21 14:27:28 +02002201 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002202 lp->ll_n2 = list_idx_of_item(lp->ll_list, ni);
Bram Moolenaar8c711452005-01-14 21:53:12 +00002203 }
2204
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002205 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2206 if (lp->ll_n1 < 0)
2207 lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li);
2208 if (lp->ll_n2 < lp->ll_n1)
Bram Moolenaare9623882011-04-21 14:27:28 +02002209 {
2210 if (!quiet)
2211 EMSGN(_(e_listidx), lp->ll_n2);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002212 return NULL;
Bram Moolenaare9623882011-04-21 14:27:28 +02002213 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002214 }
2215
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002216 lp->ll_tv = &lp->ll_li->li_tv;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002217 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002218 }
2219
Bram Moolenaarf06e5a52017-02-23 14:25:17 +01002220 clear_tv(&var1);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002221 return p;
2222}
2223
2224/*
Bram Moolenaar33570922005-01-25 22:26:29 +00002225 * Clear lval "lp" that was filled by get_lval().
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002226 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02002227 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002228clear_lval(lval_T *lp)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002229{
2230 vim_free(lp->ll_exp_name);
2231 vim_free(lp->ll_newkey);
2232}
2233
2234/*
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002235 * Set a variable that was parsed by get_lval() to "rettv".
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002236 * "endp" points to just after the parsed name.
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002237 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002238 */
2239 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002240set_var_lval(
2241 lval_T *lp,
2242 char_u *endp,
2243 typval_T *rettv,
2244 int copy,
2245 char_u *op)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002246{
2247 int cc;
Bram Moolenaar33570922005-01-25 22:26:29 +00002248 listitem_T *ri;
2249 dictitem_T *di;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002250
2251 if (lp->ll_tv == NULL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002252 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01002253 cc = *endp;
2254 *endp = NUL;
2255 if (op != NULL && *op != '=')
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002256 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01002257 typval_T tv;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002258
Bram Moolenaar79518e22017-02-17 16:31:35 +01002259 /* handle +=, -= and .= */
2260 di = NULL;
2261 if (get_var_tv(lp->ll_name, (int)STRLEN(lp->ll_name),
2262 &tv, &di, TRUE, FALSE) == OK)
2263 {
2264 if ((di == NULL
2265 || (!var_check_ro(di->di_flags, lp->ll_name, FALSE)
2266 && !tv_check_lock(di->di_tv.v_lock, lp->ll_name,
2267 FALSE)))
2268 && tv_op(&tv, rettv, op) == OK)
2269 set_var(lp->ll_name, &tv, FALSE);
2270 clear_tv(&tv);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002271 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002272 }
Bram Moolenaar79518e22017-02-17 16:31:35 +01002273 else
2274 set_var(lp->ll_name, rettv, copy);
2275 *endp = cc;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002276 }
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002277 else if (tv_check_lock(lp->ll_newkey == NULL
2278 ? lp->ll_tv->v_lock
Bram Moolenaar77354e72015-04-21 16:49:05 +02002279 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE))
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002280 ;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002281 else if (lp->ll_range)
2282 {
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002283 listitem_T *ll_li = lp->ll_li;
2284 int ll_n1 = lp->ll_n1;
2285
2286 /*
2287 * Check whether any of the list items is locked
2288 */
Bram Moolenaarb2a851f2014-12-07 00:18:33 +01002289 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; )
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002290 {
Bram Moolenaar77354e72015-04-21 16:49:05 +02002291 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002292 return;
2293 ri = ri->li_next;
2294 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1))
2295 break;
2296 ll_li = ll_li->li_next;
2297 ++ll_n1;
2298 }
2299
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002300 /*
2301 * Assign the List values to the list items.
2302 */
2303 for (ri = rettv->vval.v_list->lv_first; ri != NULL; )
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002304 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002305 if (op != NULL && *op != '=')
2306 tv_op(&lp->ll_li->li_tv, &ri->li_tv, op);
2307 else
2308 {
2309 clear_tv(&lp->ll_li->li_tv);
2310 copy_tv(&ri->li_tv, &lp->ll_li->li_tv);
2311 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002312 ri = ri->li_next;
2313 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == lp->ll_n1))
2314 break;
2315 if (lp->ll_li->li_next == NULL)
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002316 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002317 /* Need to add an empty item. */
Bram Moolenaar4463f292005-09-25 22:20:24 +00002318 if (list_append_number(lp->ll_list, 0) == FAIL)
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002319 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002320 ri = NULL;
2321 break;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002322 }
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002323 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002324 lp->ll_li = lp->ll_li->li_next;
2325 ++lp->ll_n1;
2326 }
2327 if (ri != NULL)
2328 EMSG(_("E710: List value has more items than target"));
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002329 else if (lp->ll_empty2
2330 ? (lp->ll_li != NULL && lp->ll_li->li_next != NULL)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002331 : lp->ll_n1 != lp->ll_n2)
2332 EMSG(_("E711: List value has not enough items"));
2333 }
2334 else
2335 {
2336 /*
2337 * Assign to a List or Dictionary item.
2338 */
2339 if (lp->ll_newkey != NULL)
2340 {
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002341 if (op != NULL && *op != '=')
2342 {
2343 EMSG2(_(e_letwrong), op);
2344 return;
2345 }
2346
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002347 /* Need to add an item to the Dictionary. */
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00002348 di = dictitem_alloc(lp->ll_newkey);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002349 if (di == NULL)
2350 return;
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00002351 if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL)
2352 {
2353 vim_free(di);
2354 return;
2355 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002356 lp->ll_tv = &di->di_tv;
Bram Moolenaar6cc16192005-01-08 21:49:45 +00002357 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002358 else if (op != NULL && *op != '=')
2359 {
2360 tv_op(lp->ll_tv, rettv, op);
2361 return;
2362 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002363 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002364 clear_tv(lp->ll_tv);
Bram Moolenaar8c711452005-01-14 21:53:12 +00002365
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002366 /*
2367 * Assign the value to the variable or list item.
2368 */
2369 if (copy)
2370 copy_tv(rettv, lp->ll_tv);
2371 else
2372 {
2373 *lp->ll_tv = *rettv;
Bram Moolenaar758711c2005-02-02 23:11:38 +00002374 lp->ll_tv->v_lock = 0;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002375 init_tv(rettv);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002376 }
2377 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00002378}
2379
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002380/*
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002381 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2382 * Returns OK or FAIL.
2383 */
2384 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002385tv_op(typval_T *tv1, typval_T *tv2, char_u *op)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002386{
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002387 varnumber_T n;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002388 char_u numbuf[NUMBUFLEN];
2389 char_u *s;
2390
Bram Moolenaar520e1e42016-01-23 19:46:28 +01002391 /* Can't do anything with a Funcref, Dict, v:true on the right. */
2392 if (tv2->v_type != VAR_FUNC && tv2->v_type != VAR_DICT
2393 && tv2->v_type != VAR_SPECIAL)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002394 {
2395 switch (tv1->v_type)
2396 {
Bram Moolenaar835dc632016-02-07 14:27:38 +01002397 case VAR_UNKNOWN:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002398 case VAR_DICT:
2399 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002400 case VAR_PARTIAL:
Bram Moolenaar520e1e42016-01-23 19:46:28 +01002401 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01002402 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01002403 case VAR_CHANNEL:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002404 break;
2405
2406 case VAR_LIST:
2407 if (*op != '+' || tv2->v_type != VAR_LIST)
2408 break;
2409 /* List += List */
2410 if (tv1->vval.v_list != NULL && tv2->vval.v_list != NULL)
2411 list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL);
2412 return OK;
2413
2414 case VAR_NUMBER:
2415 case VAR_STRING:
2416 if (tv2->v_type == VAR_LIST)
2417 break;
2418 if (*op == '+' || *op == '-')
2419 {
2420 /* nr += nr or nr -= nr*/
2421 n = get_tv_number(tv1);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002422#ifdef FEAT_FLOAT
2423 if (tv2->v_type == VAR_FLOAT)
2424 {
2425 float_T f = n;
2426
2427 if (*op == '+')
2428 f += tv2->vval.v_float;
2429 else
2430 f -= tv2->vval.v_float;
2431 clear_tv(tv1);
2432 tv1->v_type = VAR_FLOAT;
2433 tv1->vval.v_float = f;
2434 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002435 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002436#endif
2437 {
2438 if (*op == '+')
2439 n += get_tv_number(tv2);
2440 else
2441 n -= get_tv_number(tv2);
2442 clear_tv(tv1);
2443 tv1->v_type = VAR_NUMBER;
2444 tv1->vval.v_number = n;
2445 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002446 }
2447 else
2448 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002449 if (tv2->v_type == VAR_FLOAT)
2450 break;
2451
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002452 /* str .= str */
2453 s = get_tv_string(tv1);
2454 s = concat_str(s, get_tv_string_buf(tv2, numbuf));
2455 clear_tv(tv1);
2456 tv1->v_type = VAR_STRING;
2457 tv1->vval.v_string = s;
2458 }
2459 return OK;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002460
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002461 case VAR_FLOAT:
Bram Moolenaar5fac4672016-03-02 22:16:32 +01002462#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002463 {
2464 float_T f;
2465
2466 if (*op == '.' || (tv2->v_type != VAR_FLOAT
2467 && tv2->v_type != VAR_NUMBER
2468 && tv2->v_type != VAR_STRING))
2469 break;
2470 if (tv2->v_type == VAR_FLOAT)
2471 f = tv2->vval.v_float;
2472 else
2473 f = get_tv_number(tv2);
2474 if (*op == '+')
2475 tv1->vval.v_float += f;
2476 else
2477 tv1->vval.v_float -= f;
2478 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00002479#endif
Bram Moolenaar5fac4672016-03-02 22:16:32 +01002480 return OK;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00002481 }
2482 }
2483
2484 EMSG2(_(e_letwrong), op);
2485 return FAIL;
2486}
2487
2488/*
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002489 * Evaluate the expression used in a ":for var in expr" command.
2490 * "arg" points to "var".
2491 * Set "*errp" to TRUE for an error, FALSE otherwise;
2492 * Return a pointer that holds the info. Null when there is an error.
2493 */
2494 void *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002495eval_for_line(
2496 char_u *arg,
2497 int *errp,
2498 char_u **nextcmdp,
2499 int skip)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002500{
Bram Moolenaar33570922005-01-25 22:26:29 +00002501 forinfo_T *fi;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002502 char_u *expr;
Bram Moolenaar33570922005-01-25 22:26:29 +00002503 typval_T tv;
2504 list_T *l;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002505
2506 *errp = TRUE; /* default: there is an error */
2507
Bram Moolenaar33570922005-01-25 22:26:29 +00002508 fi = (forinfo_T *)alloc_clear(sizeof(forinfo_T));
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002509 if (fi == NULL)
2510 return NULL;
2511
2512 expr = skip_var_list(arg, &fi->fi_varcount, &fi->fi_semicolon);
2513 if (expr == NULL)
2514 return fi;
2515
2516 expr = skipwhite(expr);
Bram Moolenaar1c465442017-03-12 20:10:05 +01002517 if (expr[0] != 'i' || expr[1] != 'n' || !VIM_ISWHITE(expr[2]))
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002518 {
Bram Moolenaare49b69a2005-01-08 16:11:57 +00002519 EMSG(_("E690: Missing \"in\" after :for"));
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002520 return fi;
2521 }
2522
2523 if (skip)
2524 ++emsg_skip;
2525 if (eval0(skipwhite(expr + 2), &tv, nextcmdp, !skip) == OK)
2526 {
2527 *errp = FALSE;
2528 if (!skip)
2529 {
2530 l = tv.vval.v_list;
Bram Moolenaard8585ed2016-05-01 23:05:53 +02002531 if (tv.v_type != VAR_LIST)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002532 {
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002533 EMSG(_(e_listreq));
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002534 clear_tv(&tv);
2535 }
Bram Moolenaard8585ed2016-05-01 23:05:53 +02002536 else if (l == NULL)
2537 {
2538 /* a null list is like an empty list: do nothing */
2539 clear_tv(&tv);
2540 }
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002541 else
2542 {
Bram Moolenaar7bb4c6e2005-09-07 21:22:27 +00002543 /* No need to increment the refcount, it's already set for the
2544 * list being used in "tv". */
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002545 fi->fi_list = l;
2546 list_add_watch(l, &fi->fi_lw);
2547 fi->fi_lw.lw_item = l->lv_first;
2548 }
2549 }
2550 }
2551 if (skip)
2552 --emsg_skip;
2553
2554 return fi;
2555}
2556
2557/*
2558 * Use the first item in a ":for" list. Advance to the next.
2559 * Assign the values to the variable (list). "arg" points to the first one.
2560 * Return TRUE when a valid item was found, FALSE when at end of list or
2561 * something wrong.
2562 */
2563 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002564next_for_item(void *fi_void, char_u *arg)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002565{
Bram Moolenaarc4b99e02013-06-23 14:30:47 +02002566 forinfo_T *fi = (forinfo_T *)fi_void;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002567 int result;
Bram Moolenaar33570922005-01-25 22:26:29 +00002568 listitem_T *item;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002569
2570 item = fi->fi_lw.lw_item;
2571 if (item == NULL)
2572 result = FALSE;
2573 else
2574 {
2575 fi->fi_lw.lw_item = item->li_next;
2576 result = (ex_let_vars(arg, &item->li_tv, TRUE,
2577 fi->fi_semicolon, fi->fi_varcount, NULL) == OK);
2578 }
2579 return result;
2580}
2581
2582/*
2583 * Free the structure used to store info used by ":for".
2584 */
2585 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002586free_for_info(void *fi_void)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002587{
Bram Moolenaar33570922005-01-25 22:26:29 +00002588 forinfo_T *fi = (forinfo_T *)fi_void;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002589
Bram Moolenaarab7013c2005-01-09 21:23:56 +00002590 if (fi != NULL && fi->fi_list != NULL)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002591 {
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002592 list_rem_watch(fi->fi_list, &fi->fi_lw);
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002593 list_unref(fi->fi_list);
2594 }
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002595 vim_free(fi);
2596}
2597
Bram Moolenaar071d4272004-06-13 20:20:40 +00002598#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
2599
2600 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002601set_context_for_expression(
2602 expand_T *xp,
2603 char_u *arg,
2604 cmdidx_T cmdidx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002605{
2606 int got_eq = FALSE;
2607 int c;
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002608 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002609
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002610 if (cmdidx == CMD_let)
2611 {
2612 xp->xp_context = EXPAND_USER_VARS;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00002613 if (vim_strpbrk(arg, (char_u *)"\"'+-*/%.=!?~|&$([<>,#") == NULL)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002614 {
2615 /* ":let var1 var2 ...": find last space. */
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00002616 for (p = arg + STRLEN(arg); p >= arg; )
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002617 {
2618 xp->xp_pattern = p;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01002619 MB_PTR_BACK(arg, p);
Bram Moolenaar1c465442017-03-12 20:10:05 +01002620 if (VIM_ISWHITE(*p))
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002621 break;
2622 }
2623 return;
2624 }
2625 }
2626 else
2627 xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS
2628 : EXPAND_EXPRESSION;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002629 while ((xp->xp_pattern = vim_strpbrk(arg,
2630 (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL)
2631 {
2632 c = *xp->xp_pattern;
2633 if (c == '&')
2634 {
2635 c = xp->xp_pattern[1];
2636 if (c == '&')
2637 {
2638 ++xp->xp_pattern;
2639 xp->xp_context = cmdidx != CMD_let || got_eq
2640 ? EXPAND_EXPRESSION : EXPAND_NOTHING;
2641 }
2642 else if (c != ' ')
Bram Moolenaar11cbeb12005-03-11 22:51:16 +00002643 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002644 xp->xp_context = EXPAND_SETTINGS;
Bram Moolenaar11cbeb12005-03-11 22:51:16 +00002645 if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':')
2646 xp->xp_pattern += 2;
2647
2648 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002649 }
2650 else if (c == '$')
2651 {
2652 /* environment variable */
2653 xp->xp_context = EXPAND_ENV_VARS;
2654 }
2655 else if (c == '=')
2656 {
2657 got_eq = TRUE;
2658 xp->xp_context = EXPAND_EXPRESSION;
2659 }
Bram Moolenaara32095f2016-03-28 19:27:13 +02002660 else if (c == '#'
2661 && xp->xp_context == EXPAND_EXPRESSION)
2662 {
2663 /* Autoload function/variable contains '#'. */
2664 break;
2665 }
Bram Moolenaar8a349ff2014-11-12 20:09:06 +01002666 else if ((c == '<' || c == '#')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002667 && xp->xp_context == EXPAND_FUNCTIONS
2668 && vim_strchr(xp->xp_pattern, '(') == NULL)
2669 {
Bram Moolenaar8a349ff2014-11-12 20:09:06 +01002670 /* Function name can start with "<SNR>" and contain '#'. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002671 break;
2672 }
2673 else if (cmdidx != CMD_let || got_eq)
2674 {
2675 if (c == '"') /* string */
2676 {
2677 while ((c = *++xp->xp_pattern) != NUL && c != '"')
2678 if (c == '\\' && xp->xp_pattern[1] != NUL)
2679 ++xp->xp_pattern;
2680 xp->xp_context = EXPAND_NOTHING;
2681 }
2682 else if (c == '\'') /* literal string */
2683 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00002684 /* Trick: '' is like stopping and starting a literal string. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002685 while ((c = *++xp->xp_pattern) != NUL && c != '\'')
2686 /* skip */ ;
2687 xp->xp_context = EXPAND_NOTHING;
2688 }
2689 else if (c == '|')
2690 {
2691 if (xp->xp_pattern[1] == '|')
2692 {
2693 ++xp->xp_pattern;
2694 xp->xp_context = EXPAND_EXPRESSION;
2695 }
2696 else
2697 xp->xp_context = EXPAND_COMMANDS;
2698 }
2699 else
2700 xp->xp_context = EXPAND_EXPRESSION;
2701 }
2702 else
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00002703 /* Doesn't look like something valid, expand as an expression
2704 * anyway. */
2705 xp->xp_context = EXPAND_EXPRESSION;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002706 arg = xp->xp_pattern;
2707 if (*arg != NUL)
2708 while ((c = *++arg) != NUL && (c == ' ' || c == '\t'))
2709 /* skip */ ;
2710 }
2711 xp->xp_pattern = arg;
2712}
2713
2714#endif /* FEAT_CMDL_COMPL */
2715
2716/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002717 * ":unlet[!] var1 ... " command.
2718 */
2719 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002720ex_unlet(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002721{
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002722 ex_unletlock(eap, eap->arg, 0);
2723}
2724
2725/*
2726 * ":lockvar" and ":unlockvar" commands
2727 */
2728 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002729ex_lockvar(exarg_T *eap)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002730{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002731 char_u *arg = eap->arg;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002732 int deep = 2;
2733
2734 if (eap->forceit)
2735 deep = -1;
2736 else if (vim_isdigit(*arg))
2737 {
2738 deep = getdigits(&arg);
2739 arg = skipwhite(arg);
2740 }
2741
2742 ex_unletlock(eap, arg, deep);
2743}
2744
2745/*
2746 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
2747 */
2748 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002749ex_unletlock(
2750 exarg_T *eap,
2751 char_u *argstart,
2752 int deep)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002753{
2754 char_u *arg = argstart;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002755 char_u *name_end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002756 int error = FALSE;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002757 lval_T lv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002758
2759 do
2760 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002761 /* Parse the name and find the end. */
Bram Moolenaar6d977d62014-01-14 15:24:39 +01002762 name_end = get_lval(arg, NULL, &lv, TRUE, eap->skip || error, 0,
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00002763 FNE_CHECK_START);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002764 if (lv.ll_name == NULL)
2765 error = TRUE; /* error but continue parsing */
Bram Moolenaar1c465442017-03-12 20:10:05 +01002766 if (name_end == NULL || (!VIM_ISWHITE(*name_end)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002767 && !ends_excmd(*name_end)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002768 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002769 if (name_end != NULL)
2770 {
2771 emsg_severe = TRUE;
2772 EMSG(_(e_trailing));
2773 }
2774 if (!(eap->skip || error))
2775 clear_lval(&lv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 break;
2777 }
2778
2779 if (!error && !eap->skip)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002780 {
2781 if (eap->cmdidx == CMD_unlet)
2782 {
2783 if (do_unlet_var(&lv, name_end, eap->forceit) == FAIL)
2784 error = TRUE;
2785 }
2786 else
2787 {
2788 if (do_lock_var(&lv, name_end, deep,
2789 eap->cmdidx == CMD_lockvar) == FAIL)
2790 error = TRUE;
2791 }
2792 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002793
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002794 if (!eap->skip)
2795 clear_lval(&lv);
2796
Bram Moolenaar071d4272004-06-13 20:20:40 +00002797 arg = skipwhite(name_end);
2798 } while (!ends_excmd(*arg));
2799
2800 eap->nextcmd = check_nextcmd(arg);
2801}
2802
Bram Moolenaar8c711452005-01-14 21:53:12 +00002803 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002804do_unlet_var(
2805 lval_T *lp,
2806 char_u *name_end,
2807 int forceit)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002808{
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002809 int ret = OK;
2810 int cc;
2811
2812 if (lp->ll_tv == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00002813 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002814 cc = *name_end;
2815 *name_end = NUL;
2816
2817 /* Normal name or expanded name. */
Bram Moolenaar79518e22017-02-17 16:31:35 +01002818 if (do_unlet(lp->ll_name, forceit) == FAIL)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002819 ret = FAIL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002820 *name_end = cc;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002821 }
Bram Moolenaar9bc174b2015-04-13 16:16:38 +02002822 else if ((lp->ll_list != NULL
Bram Moolenaar77354e72015-04-21 16:49:05 +02002823 && tv_check_lock(lp->ll_list->lv_lock, lp->ll_name, FALSE))
Bram Moolenaar9bc174b2015-04-13 16:16:38 +02002824 || (lp->ll_dict != NULL
Bram Moolenaar77354e72015-04-21 16:49:05 +02002825 && tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name, FALSE)))
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002826 return FAIL;
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002827 else if (lp->ll_range)
2828 {
Bram Moolenaar33570922005-01-25 22:26:29 +00002829 listitem_T *li;
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002830 listitem_T *ll_li = lp->ll_li;
Bram Moolenaarc9703302016-01-17 21:49:33 +01002831 int ll_n1 = lp->ll_n1;
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002832
2833 while (ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= ll_n1))
2834 {
2835 li = ll_li->li_next;
Bram Moolenaar77354e72015-04-21 16:49:05 +02002836 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
Bram Moolenaarf2d912e2014-08-29 09:46:10 +02002837 return FAIL;
2838 ll_li = li;
2839 ++ll_n1;
2840 }
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002841
2842 /* Delete a range of List items. */
2843 while (lp->ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= lp->ll_n1))
2844 {
2845 li = lp->ll_li->li_next;
2846 listitem_remove(lp->ll_list, lp->ll_li);
2847 lp->ll_li = li;
2848 ++lp->ll_n1;
2849 }
2850 }
2851 else
2852 {
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002853 if (lp->ll_list != NULL)
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002854 /* unlet a List item. */
2855 listitem_remove(lp->ll_list, lp->ll_li);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002856 else
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002857 /* unlet a Dictionary item. */
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00002858 dictitem_remove(lp->ll_dict, lp->ll_di);
Bram Moolenaar7480b5c2005-01-16 22:07:38 +00002859 }
2860
2861 return ret;
Bram Moolenaar8c711452005-01-14 21:53:12 +00002862}
2863
Bram Moolenaar071d4272004-06-13 20:20:40 +00002864/*
2865 * "unlet" a variable. Return OK if it existed, FAIL if not.
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002866 * When "forceit" is TRUE don't complain if the variable doesn't exist.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002867 */
2868 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002869do_unlet(char_u *name, int forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002870{
Bram Moolenaar33570922005-01-25 22:26:29 +00002871 hashtab_T *ht;
2872 hashitem_T *hi;
Bram Moolenaara7043832005-01-21 11:56:39 +00002873 char_u *varname;
Bram Moolenaar9bc174b2015-04-13 16:16:38 +02002874 dict_T *d;
Bram Moolenaarafbdeb82008-01-05 21:16:31 +00002875 dictitem_T *di;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002876
Bram Moolenaar33570922005-01-25 22:26:29 +00002877 ht = find_var_ht(name, &varname);
2878 if (ht != NULL && *varname != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002879 {
Bram Moolenaara9b579f2016-07-17 18:29:19 +02002880 d = get_current_funccal_dict(ht);
Bram Moolenaar71bcfdf2016-01-09 18:20:46 +01002881 if (d == NULL)
2882 {
Bram Moolenaara9b579f2016-07-17 18:29:19 +02002883 if (ht == &globvarht)
2884 d = &globvardict;
2885 else if (ht == &compat_hashtab)
2886 d = &vimvardict;
2887 else
2888 {
2889 di = find_var_in_ht(ht, *name, (char_u *)"", FALSE);
2890 d = di == NULL ? NULL : di->di_tv.vval.v_dict;
2891 }
2892 if (d == NULL)
2893 {
Bram Moolenaar95f09602016-11-10 20:01:45 +01002894 internal_error("do_unlet()");
Bram Moolenaara9b579f2016-07-17 18:29:19 +02002895 return FAIL;
2896 }
Bram Moolenaar71bcfdf2016-01-09 18:20:46 +01002897 }
Bram Moolenaar33570922005-01-25 22:26:29 +00002898 hi = hash_find(ht, varname);
Bram Moolenaar10ce39a2016-07-29 22:37:06 +02002899 if (HASHITEM_EMPTY(hi))
Bram Moolenaarba96e9a2016-08-01 17:10:20 +02002900 hi = find_hi_in_scoped_ht(name, &ht);
Bram Moolenaar10ce39a2016-07-29 22:37:06 +02002901 if (hi != NULL && !HASHITEM_EMPTY(hi))
Bram Moolenaara7043832005-01-21 11:56:39 +00002902 {
Bram Moolenaarafbdeb82008-01-05 21:16:31 +00002903 di = HI2DI(hi);
Bram Moolenaar77354e72015-04-21 16:49:05 +02002904 if (var_check_fixed(di->di_flags, name, FALSE)
Bram Moolenaar71bcfdf2016-01-09 18:20:46 +01002905 || var_check_ro(di->di_flags, name, FALSE)
2906 || tv_check_lock(d->dv_lock, name, FALSE))
Bram Moolenaaraf8af8b2016-01-04 22:05:24 +01002907 return FAIL;
2908
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002909 delete_var(ht, hi);
2910 return OK;
Bram Moolenaara7043832005-01-21 11:56:39 +00002911 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002912 }
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002913 if (forceit)
2914 return OK;
2915 EMSG2(_("E108: No such variable: \"%s\""), name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002916 return FAIL;
2917}
2918
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002919/*
2920 * Lock or unlock variable indicated by "lp".
2921 * "deep" is the levels to go (-1 for unlimited);
2922 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
2923 */
2924 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002925do_lock_var(
2926 lval_T *lp,
2927 char_u *name_end,
2928 int deep,
2929 int lock)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002930{
2931 int ret = OK;
2932 int cc;
2933 dictitem_T *di;
2934
2935 if (deep == 0) /* nothing to do */
2936 return OK;
2937
2938 if (lp->ll_tv == NULL)
2939 {
2940 cc = *name_end;
2941 *name_end = NUL;
2942
2943 /* Normal name or expanded name. */
Bram Moolenaar79518e22017-02-17 16:31:35 +01002944 di = find_var(lp->ll_name, NULL, TRUE);
2945 if (di == NULL)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002946 ret = FAIL;
Bram Moolenaare7877fe2017-02-20 22:35:33 +01002947 else if ((di->di_flags & DI_FLAGS_FIX)
2948 && di->di_tv.v_type != VAR_DICT
2949 && di->di_tv.v_type != VAR_LIST)
2950 /* For historic reasons this error is not given for a list or dict.
2951 * E.g., the b: dict could be locked/unlocked. */
2952 EMSG2(_("E940: Cannot lock or unlock variable %s"), lp->ll_name);
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002953 else
2954 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01002955 if (lock)
2956 di->di_flags |= DI_FLAGS_LOCK;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002957 else
Bram Moolenaar79518e22017-02-17 16:31:35 +01002958 di->di_flags &= ~DI_FLAGS_LOCK;
2959 item_lock(&di->di_tv, deep, lock);
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002960 }
2961 *name_end = cc;
2962 }
2963 else if (lp->ll_range)
2964 {
2965 listitem_T *li = lp->ll_li;
2966
2967 /* (un)lock a range of List items. */
2968 while (li != NULL && (lp->ll_empty2 || lp->ll_n2 >= lp->ll_n1))
2969 {
2970 item_lock(&li->li_tv, deep, lock);
2971 li = li->li_next;
2972 ++lp->ll_n1;
2973 }
2974 }
2975 else if (lp->ll_list != NULL)
2976 /* (un)lock a List item. */
2977 item_lock(&lp->ll_li->li_tv, deep, lock);
2978 else
Bram Moolenaar641e48c2015-06-25 16:09:26 +02002979 /* (un)lock a Dictionary item. */
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002980 item_lock(&lp->ll_di->di_tv, deep, lock);
2981
2982 return ret;
2983}
2984
2985/*
2986 * Lock or unlock an item. "deep" is nr of levels to go.
2987 */
2988 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002989item_lock(typval_T *tv, int deep, int lock)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00002990{
2991 static int recurse = 0;
2992 list_T *l;
2993 listitem_T *li;
2994 dict_T *d;
2995 hashitem_T *hi;
2996 int todo;
2997
2998 if (recurse >= DICT_MAXNEST)
2999 {
3000 EMSG(_("E743: variable nested too deep for (un)lock"));
3001 return;
3002 }
3003 if (deep == 0)
3004 return;
3005 ++recurse;
3006
3007 /* lock/unlock the item itself */
3008 if (lock)
3009 tv->v_lock |= VAR_LOCKED;
3010 else
3011 tv->v_lock &= ~VAR_LOCKED;
3012
3013 switch (tv->v_type)
3014 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01003015 case VAR_UNKNOWN:
3016 case VAR_NUMBER:
3017 case VAR_STRING:
3018 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003019 case VAR_PARTIAL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003020 case VAR_FLOAT:
3021 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01003022 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01003023 case VAR_CHANNEL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01003024 break;
3025
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00003026 case VAR_LIST:
3027 if ((l = tv->vval.v_list) != NULL)
3028 {
3029 if (lock)
3030 l->lv_lock |= VAR_LOCKED;
3031 else
3032 l->lv_lock &= ~VAR_LOCKED;
3033 if (deep < 0 || deep > 1)
3034 /* recursive: lock/unlock the items the List contains */
3035 for (li = l->lv_first; li != NULL; li = li->li_next)
3036 item_lock(&li->li_tv, deep - 1, lock);
3037 }
3038 break;
3039 case VAR_DICT:
3040 if ((d = tv->vval.v_dict) != NULL)
3041 {
3042 if (lock)
3043 d->dv_lock |= VAR_LOCKED;
3044 else
3045 d->dv_lock &= ~VAR_LOCKED;
3046 if (deep < 0 || deep > 1)
3047 {
3048 /* recursive: lock/unlock the items the List contains */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003049 todo = (int)d->dv_hashtab.ht_used;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00003050 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
3051 {
3052 if (!HASHITEM_EMPTY(hi))
3053 {
3054 --todo;
3055 item_lock(&HI2DI(hi)->di_tv, deep - 1, lock);
3056 }
3057 }
3058 }
3059 }
3060 }
3061 --recurse;
3062}
3063
Bram Moolenaar071d4272004-06-13 20:20:40 +00003064#if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3065/*
3066 * Delete all "menutrans_" variables.
3067 */
3068 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003069del_menutrans_vars(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003070{
Bram Moolenaar33570922005-01-25 22:26:29 +00003071 hashitem_T *hi;
Bram Moolenaara7043832005-01-21 11:56:39 +00003072 int todo;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003073
Bram Moolenaar33570922005-01-25 22:26:29 +00003074 hash_lock(&globvarht);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003075 todo = (int)globvarht.ht_used;
Bram Moolenaar33570922005-01-25 22:26:29 +00003076 for (hi = globvarht.ht_array; todo > 0 && !got_int; ++hi)
Bram Moolenaara7043832005-01-21 11:56:39 +00003077 {
3078 if (!HASHITEM_EMPTY(hi))
3079 {
3080 --todo;
Bram Moolenaar33570922005-01-25 22:26:29 +00003081 if (STRNCMP(HI2DI(hi)->di_key, "menutrans_", 10) == 0)
3082 delete_var(&globvarht, hi);
Bram Moolenaara7043832005-01-21 11:56:39 +00003083 }
3084 }
Bram Moolenaar33570922005-01-25 22:26:29 +00003085 hash_unlock(&globvarht);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003086}
3087#endif
3088
3089#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3090
3091/*
3092 * Local string buffer for the next two functions to store a variable name
3093 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3094 * get_user_var_name().
3095 */
3096
Bram Moolenaar48e697e2016-01-23 22:17:30 +01003097static char_u *cat_prefix_varname(int prefix, char_u *name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003098
3099static char_u *varnamebuf = NULL;
3100static int varnamebuflen = 0;
3101
3102/*
3103 * Function to concatenate a prefix and a variable name.
3104 */
3105 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01003106cat_prefix_varname(int prefix, char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003107{
3108 int len;
3109
3110 len = (int)STRLEN(name) + 3;
3111 if (len > varnamebuflen)
3112 {
3113 vim_free(varnamebuf);
3114 len += 10; /* some additional space */
3115 varnamebuf = alloc(len);
3116 if (varnamebuf == NULL)
3117 {
3118 varnamebuflen = 0;
3119 return NULL;
3120 }
3121 varnamebuflen = len;
3122 }
3123 *varnamebuf = prefix;
3124 varnamebuf[1] = ':';
3125 STRCPY(varnamebuf + 2, name);
3126 return varnamebuf;
3127}
3128
3129/*
3130 * Function given to ExpandGeneric() to obtain the list of user defined
3131 * (global/buffer/window/built-in) variable names.
3132 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003133 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01003134get_user_var_name(expand_T *xp, int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003135{
Bram Moolenaar532c7802005-01-27 14:44:31 +00003136 static long_u gdone;
3137 static long_u bdone;
3138 static long_u wdone;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003139 static long_u tdone;
Bram Moolenaar532c7802005-01-27 14:44:31 +00003140 static int vidx;
3141 static hashitem_T *hi;
3142 hashtab_T *ht;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003143
3144 if (idx == 0)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003145 {
Bram Moolenaara7043832005-01-21 11:56:39 +00003146 gdone = bdone = wdone = vidx = 0;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003147 tdone = 0;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003148 }
Bram Moolenaar33570922005-01-25 22:26:29 +00003149
3150 /* Global variables */
3151 if (gdone < globvarht.ht_used)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003152 {
Bram Moolenaara7043832005-01-21 11:56:39 +00003153 if (gdone++ == 0)
Bram Moolenaar33570922005-01-25 22:26:29 +00003154 hi = globvarht.ht_array;
Bram Moolenaar532c7802005-01-27 14:44:31 +00003155 else
3156 ++hi;
Bram Moolenaara7043832005-01-21 11:56:39 +00003157 while (HASHITEM_EMPTY(hi))
3158 ++hi;
3159 if (STRNCMP("g:", xp->xp_pattern, 2) == 0)
3160 return cat_prefix_varname('g', hi->hi_key);
3161 return hi->hi_key;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003162 }
Bram Moolenaar33570922005-01-25 22:26:29 +00003163
3164 /* b: variables */
Bram Moolenaar429fa852013-04-15 12:27:36 +02003165 ht = &curbuf->b_vars->dv_hashtab;
Bram Moolenaar33570922005-01-25 22:26:29 +00003166 if (bdone < ht->ht_used)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003167 {
Bram Moolenaara7043832005-01-21 11:56:39 +00003168 if (bdone++ == 0)
Bram Moolenaar33570922005-01-25 22:26:29 +00003169 hi = ht->ht_array;
Bram Moolenaar532c7802005-01-27 14:44:31 +00003170 else
3171 ++hi;
Bram Moolenaara7043832005-01-21 11:56:39 +00003172 while (HASHITEM_EMPTY(hi))
3173 ++hi;
3174 return cat_prefix_varname('b', hi->hi_key);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003175 }
Bram Moolenaar33570922005-01-25 22:26:29 +00003176
3177 /* w: variables */
Bram Moolenaar429fa852013-04-15 12:27:36 +02003178 ht = &curwin->w_vars->dv_hashtab;
Bram Moolenaar33570922005-01-25 22:26:29 +00003179 if (wdone < ht->ht_used)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003180 {
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00003181 if (wdone++ == 0)
Bram Moolenaar33570922005-01-25 22:26:29 +00003182 hi = ht->ht_array;
Bram Moolenaar532c7802005-01-27 14:44:31 +00003183 else
3184 ++hi;
Bram Moolenaara7043832005-01-21 11:56:39 +00003185 while (HASHITEM_EMPTY(hi))
3186 ++hi;
3187 return cat_prefix_varname('w', hi->hi_key);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003188 }
Bram Moolenaar33570922005-01-25 22:26:29 +00003189
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003190 /* t: variables */
Bram Moolenaar429fa852013-04-15 12:27:36 +02003191 ht = &curtab->tp_vars->dv_hashtab;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003192 if (tdone < ht->ht_used)
3193 {
3194 if (tdone++ == 0)
3195 hi = ht->ht_array;
3196 else
3197 ++hi;
3198 while (HASHITEM_EMPTY(hi))
3199 ++hi;
3200 return cat_prefix_varname('t', hi->hi_key);
3201 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003202
Bram Moolenaar33570922005-01-25 22:26:29 +00003203 /* v: variables */
3204 if (vidx < VV_LEN)
3205 return cat_prefix_varname('v', (char_u *)vimvars[vidx++].vv_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003206
Bram Moolenaard23a8232018-02-10 18:45:26 +01003207 VIM_CLEAR(varnamebuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003208 varnamebuflen = 0;
3209 return NULL;
3210}
3211
3212#endif /* FEAT_CMDL_COMPL */
3213
3214/*
Bram Moolenaarea6553b2016-03-27 15:13:38 +02003215 * Return TRUE if "pat" matches "text".
3216 * Does not use 'cpo' and always uses 'magic'.
3217 */
3218 static int
3219pattern_match(char_u *pat, char_u *text, int ic)
3220{
3221 int matches = FALSE;
3222 char_u *save_cpo;
3223 regmatch_T regmatch;
3224
3225 /* avoid 'l' flag in 'cpoptions' */
3226 save_cpo = p_cpo;
3227 p_cpo = (char_u *)"";
3228 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
3229 if (regmatch.regprog != NULL)
3230 {
3231 regmatch.rm_ic = ic;
3232 matches = vim_regexec_nl(&regmatch, text, (colnr_T)0);
3233 vim_regfree(regmatch.regprog);
3234 }
3235 p_cpo = save_cpo;
3236 return matches;
3237}
3238
3239/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003240 * types for expressions.
3241 */
3242typedef enum
3243{
3244 TYPE_UNKNOWN = 0
3245 , TYPE_EQUAL /* == */
3246 , TYPE_NEQUAL /* != */
3247 , TYPE_GREATER /* > */
3248 , TYPE_GEQUAL /* >= */
3249 , TYPE_SMALLER /* < */
3250 , TYPE_SEQUAL /* <= */
3251 , TYPE_MATCH /* =~ */
3252 , TYPE_NOMATCH /* !~ */
3253} exptype_T;
3254
3255/*
3256 * The "evaluate" argument: When FALSE, the argument is only parsed but not
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003257 * executed. The function may return OK, but the rettv will be of type
Bram Moolenaar071d4272004-06-13 20:20:40 +00003258 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3259 */
3260
3261/*
3262 * Handle zero level expression.
3263 * This calls eval1() and handles error message and nextcmd.
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003264 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
Bram Moolenaar4463f292005-09-25 22:20:24 +00003265 * Note: "rettv.v_lock" is not set.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003266 * Return OK or FAIL.
3267 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02003268 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003269eval0(
3270 char_u *arg,
3271 typval_T *rettv,
3272 char_u **nextcmd,
3273 int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003274{
3275 int ret;
3276 char_u *p;
3277
3278 p = skipwhite(arg);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003279 ret = eval1(&p, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003280 if (ret == FAIL || !ends_excmd(*p))
3281 {
3282 if (ret != FAIL)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003283 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003284 /*
3285 * Report the invalid expression unless the expression evaluation has
3286 * been cancelled due to an aborting error, an interrupt, or an
3287 * exception.
3288 */
3289 if (!aborting())
3290 EMSG2(_(e_invexpr2), arg);
3291 ret = FAIL;
3292 }
3293 if (nextcmd != NULL)
3294 *nextcmd = check_nextcmd(p);
3295
3296 return ret;
3297}
3298
3299/*
3300 * Handle top level expression:
Bram Moolenaarb67cc162009-02-04 15:27:06 +00003301 * expr2 ? expr1 : expr1
Bram Moolenaar071d4272004-06-13 20:20:40 +00003302 *
3303 * "arg" must point to the first non-white of the expression.
3304 * "arg" is advanced to the next non-white after the recognized expression.
3305 *
Bram Moolenaar4463f292005-09-25 22:20:24 +00003306 * Note: "rettv.v_lock" is not set.
3307 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00003308 * Return OK or FAIL.
3309 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02003310 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003311eval1(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003312{
3313 int result;
Bram Moolenaar33570922005-01-25 22:26:29 +00003314 typval_T var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003315
3316 /*
3317 * Get the first variable.
3318 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003319 if (eval2(arg, rettv, evaluate) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003320 return FAIL;
3321
3322 if ((*arg)[0] == '?')
3323 {
3324 result = FALSE;
3325 if (evaluate)
3326 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003327 int error = FALSE;
3328
3329 if (get_tv_number_chk(rettv, &error) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003330 result = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003331 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003332 if (error)
3333 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003334 }
3335
3336 /*
3337 * Get the second variable.
3338 */
3339 *arg = skipwhite(*arg + 1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003340 if (eval1(arg, rettv, evaluate && result) == FAIL) /* recursive! */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341 return FAIL;
3342
3343 /*
3344 * Check for the ":".
3345 */
3346 if ((*arg)[0] != ':')
3347 {
3348 EMSG(_("E109: Missing ':' after '?'"));
3349 if (evaluate && result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003350 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003351 return FAIL;
3352 }
3353
3354 /*
3355 * Get the third variable.
3356 */
3357 *arg = skipwhite(*arg + 1);
3358 if (eval1(arg, &var2, evaluate && !result) == FAIL) /* recursive! */
3359 {
3360 if (evaluate && result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003361 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003362 return FAIL;
3363 }
3364 if (evaluate && !result)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003365 *rettv = var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003366 }
3367
3368 return OK;
3369}
3370
3371/*
3372 * Handle first level expression:
3373 * expr2 || expr2 || expr2 logical OR
3374 *
3375 * "arg" must point to the first non-white of the expression.
3376 * "arg" is advanced to the next non-white after the recognized expression.
3377 *
3378 * Return OK or FAIL.
3379 */
3380 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003381eval2(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003382{
Bram Moolenaar33570922005-01-25 22:26:29 +00003383 typval_T var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003384 long result;
3385 int first;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003386 int error = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003387
3388 /*
3389 * Get the first variable.
3390 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003391 if (eval3(arg, rettv, evaluate) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003392 return FAIL;
3393
3394 /*
3395 * Repeat until there is no following "||".
3396 */
3397 first = TRUE;
3398 result = FALSE;
3399 while ((*arg)[0] == '|' && (*arg)[1] == '|')
3400 {
3401 if (evaluate && first)
3402 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003403 if (get_tv_number_chk(rettv, &error) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003404 result = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003405 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003406 if (error)
3407 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003408 first = FALSE;
3409 }
3410
3411 /*
3412 * Get the second variable.
3413 */
3414 *arg = skipwhite(*arg + 2);
3415 if (eval3(arg, &var2, evaluate && !result) == FAIL)
3416 return FAIL;
3417
3418 /*
3419 * Compute the result.
3420 */
3421 if (evaluate && !result)
3422 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003423 if (get_tv_number_chk(&var2, &error) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003424 result = TRUE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003425 clear_tv(&var2);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003426 if (error)
3427 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003428 }
3429 if (evaluate)
3430 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003431 rettv->v_type = VAR_NUMBER;
3432 rettv->vval.v_number = result;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003433 }
3434 }
3435
3436 return OK;
3437}
3438
3439/*
3440 * Handle second level expression:
3441 * expr3 && expr3 && expr3 logical AND
3442 *
3443 * "arg" must point to the first non-white of the expression.
3444 * "arg" is advanced to the next non-white after the recognized expression.
3445 *
3446 * Return OK or FAIL.
3447 */
3448 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003449eval3(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003450{
Bram Moolenaar33570922005-01-25 22:26:29 +00003451 typval_T var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003452 long result;
3453 int first;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003454 int error = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003455
3456 /*
3457 * Get the first variable.
3458 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003459 if (eval4(arg, rettv, evaluate) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003460 return FAIL;
3461
3462 /*
3463 * Repeat until there is no following "&&".
3464 */
3465 first = TRUE;
3466 result = TRUE;
3467 while ((*arg)[0] == '&' && (*arg)[1] == '&')
3468 {
3469 if (evaluate && first)
3470 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003471 if (get_tv_number_chk(rettv, &error) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003472 result = FALSE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003473 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003474 if (error)
3475 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003476 first = FALSE;
3477 }
3478
3479 /*
3480 * Get the second variable.
3481 */
3482 *arg = skipwhite(*arg + 2);
3483 if (eval4(arg, &var2, evaluate && result) == FAIL)
3484 return FAIL;
3485
3486 /*
3487 * Compute the result.
3488 */
3489 if (evaluate && result)
3490 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003491 if (get_tv_number_chk(&var2, &error) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003492 result = FALSE;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003493 clear_tv(&var2);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003494 if (error)
3495 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003496 }
3497 if (evaluate)
3498 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003499 rettv->v_type = VAR_NUMBER;
3500 rettv->vval.v_number = result;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003501 }
3502 }
3503
3504 return OK;
3505}
3506
3507/*
3508 * Handle third level expression:
3509 * var1 == var2
3510 * var1 =~ var2
3511 * var1 != var2
3512 * var1 !~ var2
3513 * var1 > var2
3514 * var1 >= var2
3515 * var1 < var2
3516 * var1 <= var2
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003517 * var1 is var2
3518 * var1 isnot var2
Bram Moolenaar071d4272004-06-13 20:20:40 +00003519 *
3520 * "arg" must point to the first non-white of the expression.
3521 * "arg" is advanced to the next non-white after the recognized expression.
3522 *
3523 * Return OK or FAIL.
3524 */
3525 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003526eval4(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003527{
Bram Moolenaar33570922005-01-25 22:26:29 +00003528 typval_T var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003529 char_u *p;
3530 int i;
3531 exptype_T type = TYPE_UNKNOWN;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003532 int type_is = FALSE; /* TRUE for "is" and "isnot" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533 int len = 2;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003534 varnumber_T n1, n2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003535 char_u *s1, *s2;
3536 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003537 int ic;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003538
3539 /*
3540 * Get the first variable.
3541 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003542 if (eval5(arg, rettv, evaluate) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003543 return FAIL;
3544
3545 p = *arg;
3546 switch (p[0])
3547 {
3548 case '=': if (p[1] == '=')
3549 type = TYPE_EQUAL;
3550 else if (p[1] == '~')
3551 type = TYPE_MATCH;
3552 break;
3553 case '!': if (p[1] == '=')
3554 type = TYPE_NEQUAL;
3555 else if (p[1] == '~')
3556 type = TYPE_NOMATCH;
3557 break;
3558 case '>': if (p[1] != '=')
3559 {
3560 type = TYPE_GREATER;
3561 len = 1;
3562 }
3563 else
3564 type = TYPE_GEQUAL;
3565 break;
3566 case '<': if (p[1] != '=')
3567 {
3568 type = TYPE_SMALLER;
3569 len = 1;
3570 }
3571 else
3572 type = TYPE_SEQUAL;
3573 break;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003574 case 'i': if (p[1] == 's')
3575 {
3576 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't')
3577 len = 5;
Bram Moolenaar37a8de12015-09-01 16:05:00 +02003578 i = p[len];
3579 if (!isalnum(i) && i != '_')
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003580 {
3581 type = len == 2 ? TYPE_EQUAL : TYPE_NEQUAL;
3582 type_is = TRUE;
3583 }
3584 }
3585 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003586 }
3587
3588 /*
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003589 * If there is a comparative operator, use it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003590 */
3591 if (type != TYPE_UNKNOWN)
3592 {
3593 /* extra question mark appended: ignore case */
3594 if (p[len] == '?')
3595 {
3596 ic = TRUE;
3597 ++len;
3598 }
3599 /* extra '#' appended: match case */
3600 else if (p[len] == '#')
3601 {
3602 ic = FALSE;
3603 ++len;
3604 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003605 /* nothing appended: use 'ignorecase' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003606 else
3607 ic = p_ic;
3608
3609 /*
3610 * Get the second variable.
3611 */
3612 *arg = skipwhite(p + len);
3613 if (eval5(arg, &var2, evaluate) == FAIL)
3614 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003615 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003616 return FAIL;
3617 }
3618
3619 if (evaluate)
3620 {
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003621 if (type_is && rettv->v_type != var2.v_type)
3622 {
3623 /* For "is" a different type always means FALSE, for "notis"
3624 * it means TRUE. */
3625 n1 = (type == TYPE_NEQUAL);
3626 }
3627 else if (rettv->v_type == VAR_LIST || var2.v_type == VAR_LIST)
3628 {
3629 if (type_is)
3630 {
3631 n1 = (rettv->v_type == var2.v_type
3632 && rettv->vval.v_list == var2.vval.v_list);
3633 if (type == TYPE_NEQUAL)
3634 n1 = !n1;
3635 }
3636 else if (rettv->v_type != var2.v_type
3637 || (type != TYPE_EQUAL && type != TYPE_NEQUAL))
3638 {
3639 if (rettv->v_type != var2.v_type)
Bram Moolenaare49b69a2005-01-08 16:11:57 +00003640 EMSG(_("E691: Can only compare List with List"));
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003641 else
Bram Moolenaar59838522014-05-13 13:46:33 +02003642 EMSG(_("E692: Invalid operation for List"));
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003643 clear_tv(rettv);
3644 clear_tv(&var2);
3645 return FAIL;
3646 }
3647 else
3648 {
3649 /* Compare two Lists for being equal or unequal. */
Bram Moolenaar67b3f992010-11-10 20:41:57 +01003650 n1 = list_equal(rettv->vval.v_list, var2.vval.v_list,
3651 ic, FALSE);
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003652 if (type == TYPE_NEQUAL)
3653 n1 = !n1;
3654 }
3655 }
3656
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00003657 else if (rettv->v_type == VAR_DICT || var2.v_type == VAR_DICT)
3658 {
3659 if (type_is)
3660 {
3661 n1 = (rettv->v_type == var2.v_type
3662 && rettv->vval.v_dict == var2.vval.v_dict);
3663 if (type == TYPE_NEQUAL)
3664 n1 = !n1;
3665 }
3666 else if (rettv->v_type != var2.v_type
3667 || (type != TYPE_EQUAL && type != TYPE_NEQUAL))
3668 {
3669 if (rettv->v_type != var2.v_type)
3670 EMSG(_("E735: Can only compare Dictionary with Dictionary"));
3671 else
3672 EMSG(_("E736: Invalid operation for Dictionary"));
3673 clear_tv(rettv);
3674 clear_tv(&var2);
3675 return FAIL;
3676 }
3677 else
3678 {
3679 /* Compare two Dictionaries for being equal or unequal. */
Bram Moolenaar67b3f992010-11-10 20:41:57 +01003680 n1 = dict_equal(rettv->vval.v_dict, var2.vval.v_dict,
3681 ic, FALSE);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00003682 if (type == TYPE_NEQUAL)
3683 n1 = !n1;
3684 }
3685 }
3686
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003687 else if (rettv->v_type == VAR_FUNC || var2.v_type == VAR_FUNC
3688 || rettv->v_type == VAR_PARTIAL || var2.v_type == VAR_PARTIAL)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003689 {
Bram Moolenaarf0e86a02016-03-19 19:38:12 +01003690 if (type != TYPE_EQUAL && type != TYPE_NEQUAL)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003691 {
Bram Moolenaarf0e86a02016-03-19 19:38:12 +01003692 EMSG(_("E694: Invalid operation for Funcrefs"));
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003693 clear_tv(rettv);
3694 clear_tv(&var2);
3695 return FAIL;
3696 }
Bram Moolenaar8e759ba2016-06-02 17:46:20 +02003697 if ((rettv->v_type == VAR_PARTIAL
3698 && rettv->vval.v_partial == NULL)
3699 || (var2.v_type == VAR_PARTIAL
3700 && var2.vval.v_partial == NULL))
3701 /* when a partial is NULL assume not equal */
3702 n1 = FALSE;
3703 else if (type_is)
3704 {
3705 if (rettv->v_type == VAR_FUNC && var2.v_type == VAR_FUNC)
3706 /* strings are considered the same if their value is
3707 * the same */
3708 n1 = tv_equal(rettv, &var2, ic, FALSE);
3709 else if (rettv->v_type == VAR_PARTIAL
3710 && var2.v_type == VAR_PARTIAL)
3711 n1 = (rettv->vval.v_partial == var2.vval.v_partial);
3712 else
3713 n1 = FALSE;
3714 }
3715 else
3716 n1 = tv_equal(rettv, &var2, ic, FALSE);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003717 if (type == TYPE_NEQUAL)
3718 n1 = !n1;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003719 }
3720
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003721#ifdef FEAT_FLOAT
3722 /*
3723 * If one of the two variables is a float, compare as a float.
3724 * When using "=~" or "!~", always compare as string.
3725 */
3726 else if ((rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT)
3727 && type != TYPE_MATCH && type != TYPE_NOMATCH)
3728 {
3729 float_T f1, f2;
3730
3731 if (rettv->v_type == VAR_FLOAT)
3732 f1 = rettv->vval.v_float;
3733 else
3734 f1 = get_tv_number(rettv);
3735 if (var2.v_type == VAR_FLOAT)
3736 f2 = var2.vval.v_float;
3737 else
3738 f2 = get_tv_number(&var2);
3739 n1 = FALSE;
3740 switch (type)
3741 {
3742 case TYPE_EQUAL: n1 = (f1 == f2); break;
3743 case TYPE_NEQUAL: n1 = (f1 != f2); break;
3744 case TYPE_GREATER: n1 = (f1 > f2); break;
3745 case TYPE_GEQUAL: n1 = (f1 >= f2); break;
3746 case TYPE_SMALLER: n1 = (f1 < f2); break;
3747 case TYPE_SEQUAL: n1 = (f1 <= f2); break;
3748 case TYPE_UNKNOWN:
3749 case TYPE_MATCH:
3750 case TYPE_NOMATCH: break; /* avoid gcc warning */
3751 }
3752 }
3753#endif
3754
Bram Moolenaar071d4272004-06-13 20:20:40 +00003755 /*
3756 * If one of the two variables is a number, compare as a number.
3757 * When using "=~" or "!~", always compare as string.
3758 */
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003759 else if ((rettv->v_type == VAR_NUMBER || var2.v_type == VAR_NUMBER)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003760 && type != TYPE_MATCH && type != TYPE_NOMATCH)
3761 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003762 n1 = get_tv_number(rettv);
3763 n2 = get_tv_number(&var2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003764 switch (type)
3765 {
3766 case TYPE_EQUAL: n1 = (n1 == n2); break;
3767 case TYPE_NEQUAL: n1 = (n1 != n2); break;
3768 case TYPE_GREATER: n1 = (n1 > n2); break;
3769 case TYPE_GEQUAL: n1 = (n1 >= n2); break;
3770 case TYPE_SMALLER: n1 = (n1 < n2); break;
3771 case TYPE_SEQUAL: n1 = (n1 <= n2); break;
3772 case TYPE_UNKNOWN:
3773 case TYPE_MATCH:
3774 case TYPE_NOMATCH: break; /* avoid gcc warning */
3775 }
3776 }
3777 else
3778 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003779 s1 = get_tv_string_buf(rettv, buf1);
3780 s2 = get_tv_string_buf(&var2, buf2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003781 if (type != TYPE_MATCH && type != TYPE_NOMATCH)
3782 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2);
3783 else
3784 i = 0;
3785 n1 = FALSE;
3786 switch (type)
3787 {
3788 case TYPE_EQUAL: n1 = (i == 0); break;
3789 case TYPE_NEQUAL: n1 = (i != 0); break;
3790 case TYPE_GREATER: n1 = (i > 0); break;
3791 case TYPE_GEQUAL: n1 = (i >= 0); break;
3792 case TYPE_SMALLER: n1 = (i < 0); break;
3793 case TYPE_SEQUAL: n1 = (i <= 0); break;
3794
3795 case TYPE_MATCH:
3796 case TYPE_NOMATCH:
Bram Moolenaarea6553b2016-03-27 15:13:38 +02003797 n1 = pattern_match(s2, s1, ic);
3798 if (type == TYPE_NOMATCH)
3799 n1 = !n1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003800 break;
3801
3802 case TYPE_UNKNOWN: break; /* avoid gcc warning */
3803 }
3804 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003805 clear_tv(rettv);
3806 clear_tv(&var2);
3807 rettv->v_type = VAR_NUMBER;
3808 rettv->vval.v_number = n1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003809 }
3810 }
3811
3812 return OK;
3813}
3814
3815/*
3816 * Handle fourth level expression:
3817 * + number addition
3818 * - number subtraction
3819 * . string concatenation
3820 *
3821 * "arg" must point to the first non-white of the expression.
3822 * "arg" is advanced to the next non-white after the recognized expression.
3823 *
3824 * Return OK or FAIL.
3825 */
3826 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003827eval5(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003828{
Bram Moolenaar33570922005-01-25 22:26:29 +00003829 typval_T var2;
3830 typval_T var3;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003831 int op;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003832 varnumber_T n1, n2;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003833#ifdef FEAT_FLOAT
3834 float_T f1 = 0, f2 = 0;
3835#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003836 char_u *s1, *s2;
3837 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
3838 char_u *p;
3839
3840 /*
3841 * Get the first variable.
3842 */
Bram Moolenaar8d00f9c2008-06-28 13:09:56 +00003843 if (eval6(arg, rettv, evaluate, FALSE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003844 return FAIL;
3845
3846 /*
3847 * Repeat computing, until no '+', '-' or '.' is following.
3848 */
3849 for (;;)
3850 {
3851 op = **arg;
3852 if (op != '+' && op != '-' && op != '.')
3853 break;
3854
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003855 if ((op != '+' || rettv->v_type != VAR_LIST)
3856#ifdef FEAT_FLOAT
3857 && (op == '.' || rettv->v_type != VAR_FLOAT)
3858#endif
3859 )
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003860 {
3861 /* For "list + ...", an illegal use of the first operand as
3862 * a number cannot be determined before evaluating the 2nd
3863 * operand: if this is also a list, all is ok.
3864 * For "something . ...", "something - ..." or "non-list + ...",
3865 * we know that the first operand needs to be a string or number
3866 * without evaluating the 2nd operand. So check before to avoid
3867 * side effects after an error. */
3868 if (evaluate && get_tv_string_chk(rettv) == NULL)
3869 {
3870 clear_tv(rettv);
3871 return FAIL;
3872 }
3873 }
3874
Bram Moolenaar071d4272004-06-13 20:20:40 +00003875 /*
3876 * Get the second variable.
3877 */
3878 *arg = skipwhite(*arg + 1);
Bram Moolenaar8d00f9c2008-06-28 13:09:56 +00003879 if (eval6(arg, &var2, evaluate, op == '.') == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003881 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003882 return FAIL;
3883 }
3884
3885 if (evaluate)
3886 {
3887 /*
3888 * Compute the result.
3889 */
3890 if (op == '.')
3891 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003892 s1 = get_tv_string_buf(rettv, buf1); /* already checked */
3893 s2 = get_tv_string_buf_chk(&var2, buf2);
3894 if (s2 == NULL) /* type error ? */
3895 {
3896 clear_tv(rettv);
3897 clear_tv(&var2);
3898 return FAIL;
3899 }
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00003900 p = concat_str(s1, s2);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003901 clear_tv(rettv);
3902 rettv->v_type = VAR_STRING;
3903 rettv->vval.v_string = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003904 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00003905 else if (op == '+' && rettv->v_type == VAR_LIST
3906 && var2.v_type == VAR_LIST)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00003907 {
3908 /* concatenate Lists */
3909 if (list_concat(rettv->vval.v_list, var2.vval.v_list,
3910 &var3) == FAIL)
3911 {
3912 clear_tv(rettv);
3913 clear_tv(&var2);
3914 return FAIL;
3915 }
3916 clear_tv(rettv);
3917 *rettv = var3;
3918 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003919 else
3920 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003921 int error = FALSE;
3922
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003923#ifdef FEAT_FLOAT
3924 if (rettv->v_type == VAR_FLOAT)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003925 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003926 f1 = rettv->vval.v_float;
3927 n1 = 0;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003928 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003929 else
3930#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003931 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003932 n1 = get_tv_number_chk(rettv, &error);
3933 if (error)
3934 {
3935 /* This can only happen for "list + non-list". For
3936 * "non-list + ..." or "something - ...", we returned
3937 * before evaluating the 2nd operand. */
3938 clear_tv(rettv);
3939 return FAIL;
3940 }
3941#ifdef FEAT_FLOAT
3942 if (var2.v_type == VAR_FLOAT)
3943 f1 = n1;
3944#endif
3945 }
3946#ifdef FEAT_FLOAT
3947 if (var2.v_type == VAR_FLOAT)
3948 {
3949 f2 = var2.vval.v_float;
3950 n2 = 0;
3951 }
3952 else
3953#endif
3954 {
3955 n2 = get_tv_number_chk(&var2, &error);
3956 if (error)
3957 {
3958 clear_tv(rettv);
3959 clear_tv(&var2);
3960 return FAIL;
3961 }
3962#ifdef FEAT_FLOAT
3963 if (rettv->v_type == VAR_FLOAT)
3964 f2 = n2;
3965#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003966 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003967 clear_tv(rettv);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003968
3969#ifdef FEAT_FLOAT
3970 /* If there is a float on either side the result is a float. */
3971 if (rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT)
3972 {
3973 if (op == '+')
3974 f1 = f1 + f2;
3975 else
3976 f1 = f1 - f2;
3977 rettv->v_type = VAR_FLOAT;
3978 rettv->vval.v_float = f1;
3979 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003980 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00003981#endif
3982 {
3983 if (op == '+')
3984 n1 = n1 + n2;
3985 else
3986 n1 = n1 - n2;
3987 rettv->v_type = VAR_NUMBER;
3988 rettv->vval.v_number = n1;
3989 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003990 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00003991 clear_tv(&var2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003992 }
3993 }
3994 return OK;
3995}
3996
3997/*
3998 * Handle fifth level expression:
3999 * * number multiplication
4000 * / number division
4001 * % number modulo
4002 *
4003 * "arg" must point to the first non-white of the expression.
4004 * "arg" is advanced to the next non-white after the recognized expression.
4005 *
4006 * Return OK or FAIL.
4007 */
4008 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004009eval6(
4010 char_u **arg,
4011 typval_T *rettv,
4012 int evaluate,
4013 int want_string) /* after "." operator */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004014{
Bram Moolenaar33570922005-01-25 22:26:29 +00004015 typval_T var2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004016 int op;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004017 varnumber_T n1, n2;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004018#ifdef FEAT_FLOAT
4019 int use_float = FALSE;
4020 float_T f1 = 0, f2;
4021#endif
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004022 int error = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004023
4024 /*
4025 * Get the first variable.
4026 */
Bram Moolenaar8d00f9c2008-06-28 13:09:56 +00004027 if (eval7(arg, rettv, evaluate, want_string) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004028 return FAIL;
4029
4030 /*
4031 * Repeat computing, until no '*', '/' or '%' is following.
4032 */
4033 for (;;)
4034 {
4035 op = **arg;
4036 if (op != '*' && op != '/' && op != '%')
4037 break;
4038
4039 if (evaluate)
4040 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004041#ifdef FEAT_FLOAT
4042 if (rettv->v_type == VAR_FLOAT)
4043 {
4044 f1 = rettv->vval.v_float;
4045 use_float = TRUE;
4046 n1 = 0;
4047 }
4048 else
4049#endif
4050 n1 = get_tv_number_chk(rettv, &error);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004051 clear_tv(rettv);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004052 if (error)
4053 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004054 }
4055 else
4056 n1 = 0;
4057
4058 /*
4059 * Get the second variable.
4060 */
4061 *arg = skipwhite(*arg + 1);
Bram Moolenaar8d00f9c2008-06-28 13:09:56 +00004062 if (eval7(arg, &var2, evaluate, FALSE) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004063 return FAIL;
4064
4065 if (evaluate)
4066 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004067#ifdef FEAT_FLOAT
4068 if (var2.v_type == VAR_FLOAT)
4069 {
4070 if (!use_float)
4071 {
4072 f1 = n1;
4073 use_float = TRUE;
4074 }
4075 f2 = var2.vval.v_float;
4076 n2 = 0;
4077 }
4078 else
4079#endif
4080 {
4081 n2 = get_tv_number_chk(&var2, &error);
4082 clear_tv(&var2);
4083 if (error)
4084 return FAIL;
4085#ifdef FEAT_FLOAT
4086 if (use_float)
4087 f2 = n2;
4088#endif
4089 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004090
4091 /*
4092 * Compute the result.
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004093 * When either side is a float the result is a float.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004094 */
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004095#ifdef FEAT_FLOAT
4096 if (use_float)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004097 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004098 if (op == '*')
4099 f1 = f1 * f2;
4100 else if (op == '/')
4101 {
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02004102# ifdef VMS
4103 /* VMS crashes on divide by zero, work around it */
4104 if (f2 == 0.0)
4105 {
4106 if (f1 == 0)
Bram Moolenaar314f11d2010-08-09 22:07:08 +02004107 f1 = -1 * __F_FLT_MAX - 1L; /* similar to NaN */
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02004108 else if (f1 < 0)
Bram Moolenaar314f11d2010-08-09 22:07:08 +02004109 f1 = -1 * __F_FLT_MAX;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02004110 else
Bram Moolenaar314f11d2010-08-09 22:07:08 +02004111 f1 = __F_FLT_MAX;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02004112 }
4113 else
4114 f1 = f1 / f2;
4115# else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004116 /* We rely on the floating point library to handle divide
4117 * by zero to result in "inf" and not a crash. */
4118 f1 = f1 / f2;
Bram Moolenaarf878bcf2010-07-30 22:29:41 +02004119# endif
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004120 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004121 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004122 {
Bram Moolenaar1378fca2008-07-04 16:51:55 +00004123 EMSG(_("E804: Cannot use '%' with Float"));
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004124 return FAIL;
4125 }
4126 rettv->v_type = VAR_FLOAT;
4127 rettv->vval.v_float = f1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004128 }
4129 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004130#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004131 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004132 if (op == '*')
4133 n1 = n1 * n2;
4134 else if (op == '/')
4135 {
4136 if (n2 == 0) /* give an error message? */
4137 {
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004138 if (n1 == 0)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01004139 n1 = VARNUM_MIN; /* similar to NaN */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004140 else if (n1 < 0)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01004141 n1 = -VARNUM_MAX;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004142 else
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01004143 n1 = VARNUM_MAX;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004144 }
4145 else
4146 n1 = n1 / n2;
4147 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004148 else
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004149 {
4150 if (n2 == 0) /* give an error message? */
4151 n1 = 0;
4152 else
4153 n1 = n1 % n2;
4154 }
4155 rettv->v_type = VAR_NUMBER;
4156 rettv->vval.v_number = n1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004157 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004158 }
4159 }
4160
4161 return OK;
4162}
4163
4164/*
4165 * Handle sixth level expression:
4166 * number number constant
Bram Moolenaarbae0c162007-05-10 19:30:25 +00004167 * "string" string constant
4168 * 'string' literal string constant
Bram Moolenaar071d4272004-06-13 20:20:40 +00004169 * &option-name option value
4170 * @r register contents
4171 * identifier variable value
4172 * function() function call
4173 * $VAR environment variable
4174 * (expression) nested expression
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00004175 * [expr, expr] List
4176 * {key: val, key: val} Dictionary
Bram Moolenaar071d4272004-06-13 20:20:40 +00004177 *
4178 * Also handle:
4179 * ! in front logical NOT
4180 * - in front unary minus
4181 * + in front unary plus (ignored)
Bram Moolenaar8c711452005-01-14 21:53:12 +00004182 * trailing [] subscript in String or List
4183 * trailing .name entry in Dictionary
Bram Moolenaar071d4272004-06-13 20:20:40 +00004184 *
4185 * "arg" must point to the first non-white of the expression.
4186 * "arg" is advanced to the next non-white after the recognized expression.
4187 *
4188 * Return OK or FAIL.
4189 */
4190 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004191eval7(
4192 char_u **arg,
4193 typval_T *rettv,
4194 int evaluate,
4195 int want_string UNUSED) /* after "." operator */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004196{
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004197 varnumber_T n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004198 int len;
4199 char_u *s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004200 char_u *start_leader, *end_leader;
4201 int ret = OK;
4202 char_u *alias;
4203
4204 /*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004205 * Initialise variable so that clear_tv() can't mistake this for a
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004206 * string and free a string that isn't there.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004207 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004208 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004209
4210 /*
Bram Moolenaaredf3f972016-08-29 22:49:24 +02004211 * Skip '!', '-' and '+' characters. They are handled later.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004212 */
4213 start_leader = *arg;
4214 while (**arg == '!' || **arg == '-' || **arg == '+')
4215 *arg = skipwhite(*arg + 1);
4216 end_leader = *arg;
4217
4218 switch (**arg)
4219 {
4220 /*
4221 * Number constant.
4222 */
4223 case '0':
4224 case '1':
4225 case '2':
4226 case '3':
4227 case '4':
4228 case '5':
4229 case '6':
4230 case '7':
4231 case '8':
4232 case '9':
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004233 {
4234#ifdef FEAT_FLOAT
4235 char_u *p = skipdigits(*arg + 1);
4236 int get_float = FALSE;
4237
4238 /* We accept a float when the format matches
4239 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
Bram Moolenaar8d00f9c2008-06-28 13:09:56 +00004240 * strict to avoid backwards compatibility problems.
4241 * Don't look for a float after the "." operator, so that
4242 * ":let vers = 1.2.3" doesn't fail. */
4243 if (!want_string && p[0] == '.' && vim_isdigit(p[1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004244 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004245 get_float = TRUE;
4246 p = skipdigits(p + 2);
4247 if (*p == 'e' || *p == 'E')
4248 {
4249 ++p;
4250 if (*p == '-' || *p == '+')
4251 ++p;
4252 if (!vim_isdigit(*p))
4253 get_float = FALSE;
4254 else
4255 p = skipdigits(p + 1);
4256 }
4257 if (ASCII_ISALPHA(*p) || *p == '.')
4258 get_float = FALSE;
4259 }
4260 if (get_float)
4261 {
4262 float_T f;
4263
4264 *arg += string2float(*arg, &f);
4265 if (evaluate)
4266 {
4267 rettv->v_type = VAR_FLOAT;
4268 rettv->vval.v_float = f;
4269 }
4270 }
4271 else
4272#endif
4273 {
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01004274 vim_str2nr(*arg, NULL, &len, STR2NR_ALL, &n, NULL, 0);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004275 *arg += len;
4276 if (evaluate)
4277 {
4278 rettv->v_type = VAR_NUMBER;
4279 rettv->vval.v_number = n;
4280 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004281 }
4282 break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004283 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004284
4285 /*
4286 * String constant: "string".
4287 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004288 case '"': ret = get_string_tv(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004289 break;
4290
4291 /*
Bram Moolenaar8c711452005-01-14 21:53:12 +00004292 * Literal string constant: 'str''ing'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004293 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004294 case '\'': ret = get_lit_string_tv(arg, rettv, evaluate);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004295 break;
4296
4297 /*
4298 * List: [expr, expr]
4299 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004300 case '[': ret = get_list_tv(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004301 break;
4302
4303 /*
Bram Moolenaar069c1e72016-07-15 21:25:08 +02004304 * Lambda: {arg, arg -> expr}
Bram Moolenaar8c711452005-01-14 21:53:12 +00004305 * Dictionary: {key: val, key: val}
4306 */
Bram Moolenaar069c1e72016-07-15 21:25:08 +02004307 case '{': ret = get_lambda_tv(arg, rettv, evaluate);
4308 if (ret == NOTDONE)
4309 ret = get_dict_tv(arg, rettv, evaluate);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004310 break;
4311
4312 /*
Bram Moolenaare9a41262005-01-15 22:18:47 +00004313 * Option value: &name
Bram Moolenaar071d4272004-06-13 20:20:40 +00004314 */
Bram Moolenaare9a41262005-01-15 22:18:47 +00004315 case '&': ret = get_option_tv(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004316 break;
4317
4318 /*
4319 * Environment variable: $VAR.
4320 */
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004321 case '$': ret = get_env_tv(arg, rettv, evaluate);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004322 break;
4323
4324 /*
4325 * Register contents: @r.
4326 */
4327 case '@': ++*arg;
4328 if (evaluate)
4329 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004330 rettv->v_type = VAR_STRING;
Bram Moolenaarb7cb42b2014-04-02 19:55:10 +02004331 rettv->vval.v_string = get_reg_contents(**arg,
4332 GREG_EXPR_SRC);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004333 }
4334 if (**arg != NUL)
4335 ++*arg;
4336 break;
4337
4338 /*
4339 * nested expression: (expression).
4340 */
4341 case '(': *arg = skipwhite(*arg + 1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004342 ret = eval1(arg, rettv, evaluate); /* recursive! */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004343 if (**arg == ')')
4344 ++*arg;
4345 else if (ret == OK)
4346 {
4347 EMSG(_("E110: Missing ')'"));
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004348 clear_tv(rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004349 ret = FAIL;
4350 }
4351 break;
4352
Bram Moolenaar8c711452005-01-14 21:53:12 +00004353 default: ret = NOTDONE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004354 break;
4355 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004356
4357 if (ret == NOTDONE)
4358 {
4359 /*
4360 * Must be a variable or function name.
4361 * Can also be a curly-braces kind of name: {expr}.
4362 */
4363 s = *arg;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004364 len = get_name_len(arg, &alias, evaluate, TRUE);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004365 if (alias != NULL)
4366 s = alias;
4367
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004368 if (len <= 0)
Bram Moolenaar8c711452005-01-14 21:53:12 +00004369 ret = FAIL;
4370 else
4371 {
4372 if (**arg == '(') /* recursive! */
4373 {
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004374 partial_T *partial;
4375
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004376 if (!evaluate)
4377 check_vars(s, len);
4378
Bram Moolenaar8c711452005-01-14 21:53:12 +00004379 /* If "s" is the name of a variable of type VAR_FUNC
4380 * use its contents. */
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004381 s = deref_func_name(s, &len, &partial, !evaluate);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004382
Bram Moolenaar8a01f962016-11-14 21:50:00 +01004383 /* Need to make a copy, in case evaluating the arguments makes
4384 * the name invalid. */
4385 s = vim_strsave(s);
4386 if (s == NULL)
4387 ret = FAIL;
4388 else
4389 /* Invoke the function. */
4390 ret = get_func_tv(s, len, rettv, arg,
4391 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
4392 &len, evaluate, partial, NULL);
4393 vim_free(s);
Bram Moolenaare17c2602013-02-26 19:36:15 +01004394
4395 /* If evaluate is FALSE rettv->v_type was not set in
4396 * get_func_tv, but it's needed in handle_subscript() to parse
4397 * what follows. So set it here. */
4398 if (rettv->v_type == VAR_UNKNOWN && !evaluate && **arg == '(')
4399 {
Bram Moolenaar9ad73232016-06-01 22:08:17 +02004400 rettv->vval.v_string = NULL;
Bram Moolenaare17c2602013-02-26 19:36:15 +01004401 rettv->v_type = VAR_FUNC;
4402 }
4403
Bram Moolenaar8c711452005-01-14 21:53:12 +00004404 /* Stop the expression evaluation when immediately
4405 * aborting on error, or when an interrupt occurred or
4406 * an exception was thrown but not caught. */
4407 if (aborting())
4408 {
4409 if (ret == OK)
4410 clear_tv(rettv);
4411 ret = FAIL;
4412 }
4413 }
4414 else if (evaluate)
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02004415 ret = get_var_tv(s, len, rettv, NULL, TRUE, FALSE);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00004416 else
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004417 {
4418 check_vars(s, len);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00004419 ret = OK;
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02004420 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004421 }
Bram Moolenaar3c2d6532011-02-01 13:48:53 +01004422 vim_free(alias);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004423 }
4424
Bram Moolenaar071d4272004-06-13 20:20:40 +00004425 *arg = skipwhite(*arg);
4426
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004427 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4428 * expr(expr). */
4429 if (ret == OK)
4430 ret = handle_subscript(arg, rettv, evaluate, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004431
4432 /*
4433 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4434 */
4435 if (ret == OK && evaluate && end_leader > start_leader)
4436 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004437 int error = FALSE;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02004438 varnumber_T val = 0;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004439#ifdef FEAT_FLOAT
4440 float_T f = 0.0;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004441
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004442 if (rettv->v_type == VAR_FLOAT)
4443 f = rettv->vval.v_float;
4444 else
4445#endif
4446 val = get_tv_number_chk(rettv, &error);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004447 if (error)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004448 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004449 clear_tv(rettv);
4450 ret = FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004451 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004452 else
4453 {
4454 while (end_leader > start_leader)
4455 {
4456 --end_leader;
4457 if (*end_leader == '!')
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004458 {
4459#ifdef FEAT_FLOAT
4460 if (rettv->v_type == VAR_FLOAT)
4461 f = !f;
4462 else
4463#endif
4464 val = !val;
4465 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004466 else if (*end_leader == '-')
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004467 {
4468#ifdef FEAT_FLOAT
4469 if (rettv->v_type == VAR_FLOAT)
4470 f = -f;
4471 else
4472#endif
4473 val = -val;
4474 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004475 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004476#ifdef FEAT_FLOAT
4477 if (rettv->v_type == VAR_FLOAT)
4478 {
4479 clear_tv(rettv);
4480 rettv->vval.v_float = f;
4481 }
4482 else
4483#endif
4484 {
4485 clear_tv(rettv);
4486 rettv->v_type = VAR_NUMBER;
4487 rettv->vval.v_number = val;
4488 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004489 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004490 }
4491
4492 return ret;
4493}
4494
4495/*
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00004496 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4497 * "*arg" points to the '[' or '.'.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004498 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4499 */
4500 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004501eval_index(
4502 char_u **arg,
4503 typval_T *rettv,
4504 int evaluate,
4505 int verbose) /* give error messages */
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004506{
4507 int empty1 = FALSE, empty2 = FALSE;
Bram Moolenaar33570922005-01-25 22:26:29 +00004508 typval_T var1, var2;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004509 long n1, n2 = 0;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004510 long len = -1;
4511 int range = FALSE;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004512 char_u *s;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004513 char_u *key = NULL;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004514
Bram Moolenaara03f2332016-02-06 18:09:59 +01004515 switch (rettv->v_type)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004516 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01004517 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004518 case VAR_PARTIAL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004519 if (verbose)
4520 EMSG(_("E695: Cannot index a Funcref"));
4521 return FAIL;
4522 case VAR_FLOAT:
Bram Moolenaar2a876e42013-06-12 22:08:58 +02004523#ifdef FEAT_FLOAT
Bram Moolenaara03f2332016-02-06 18:09:59 +01004524 if (verbose)
4525 EMSG(_(e_float_as_string));
4526 return FAIL;
Bram Moolenaar2a876e42013-06-12 22:08:58 +02004527#endif
Bram Moolenaara03f2332016-02-06 18:09:59 +01004528 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01004529 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01004530 case VAR_CHANNEL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004531 if (verbose)
4532 EMSG(_("E909: Cannot index a special variable"));
4533 return FAIL;
4534 case VAR_UNKNOWN:
4535 if (evaluate)
4536 return FAIL;
4537 /* FALLTHROUGH */
4538
4539 case VAR_STRING:
4540 case VAR_NUMBER:
4541 case VAR_LIST:
4542 case VAR_DICT:
4543 break;
Bram Moolenaar520e1e42016-01-23 19:46:28 +01004544 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004545
Bram Moolenaar0a38dd22015-08-25 16:49:01 +02004546 init_tv(&var1);
4547 init_tv(&var2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004548 if (**arg == '.')
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004549 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004550 /*
4551 * dict.name
4552 */
4553 key = *arg + 1;
4554 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len)
4555 ;
4556 if (len == 0)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004557 return FAIL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004558 *arg = skipwhite(key + len);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004559 }
4560 else
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004561 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004562 /*
4563 * something[idx]
4564 *
4565 * Get the (first) variable from inside the [].
4566 */
4567 *arg = skipwhite(*arg + 1);
4568 if (**arg == ':')
4569 empty1 = TRUE;
4570 else if (eval1(arg, &var1, evaluate) == FAIL) /* recursive! */
4571 return FAIL;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004572 else if (evaluate && get_tv_string_chk(&var1) == NULL)
4573 {
4574 /* not a number or string */
4575 clear_tv(&var1);
4576 return FAIL;
4577 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004578
4579 /*
4580 * Get the second variable from inside the [:].
4581 */
4582 if (**arg == ':')
4583 {
4584 range = TRUE;
4585 *arg = skipwhite(*arg + 1);
4586 if (**arg == ']')
4587 empty2 = TRUE;
4588 else if (eval1(arg, &var2, evaluate) == FAIL) /* recursive! */
4589 {
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004590 if (!empty1)
4591 clear_tv(&var1);
4592 return FAIL;
4593 }
4594 else if (evaluate && get_tv_string_chk(&var2) == NULL)
4595 {
4596 /* not a number or string */
4597 if (!empty1)
4598 clear_tv(&var1);
4599 clear_tv(&var2);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004600 return FAIL;
4601 }
4602 }
4603
4604 /* Check for the ']'. */
4605 if (**arg != ']')
4606 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004607 if (verbose)
4608 EMSG(_(e_missbrac));
Bram Moolenaar8c711452005-01-14 21:53:12 +00004609 clear_tv(&var1);
4610 if (range)
4611 clear_tv(&var2);
4612 return FAIL;
4613 }
4614 *arg = skipwhite(*arg + 1); /* skip the ']' */
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004615 }
4616
4617 if (evaluate)
4618 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004619 n1 = 0;
4620 if (!empty1 && rettv->v_type != VAR_DICT)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004621 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004622 n1 = get_tv_number(&var1);
4623 clear_tv(&var1);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004624 }
4625 if (range)
4626 {
4627 if (empty2)
4628 n2 = -1;
4629 else
4630 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004631 n2 = get_tv_number(&var2);
4632 clear_tv(&var2);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004633 }
4634 }
4635
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004636 switch (rettv->v_type)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004637 {
Bram Moolenaar835dc632016-02-07 14:27:38 +01004638 case VAR_UNKNOWN:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004639 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01004640 case VAR_PARTIAL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004641 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01004642 case VAR_SPECIAL:
4643 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01004644 case VAR_CHANNEL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01004645 break; /* not evaluating, skipping over subscript */
4646
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004647 case VAR_NUMBER:
4648 case VAR_STRING:
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004649 s = get_tv_string(rettv);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004650 len = (long)STRLEN(s);
4651 if (range)
4652 {
4653 /* The resulting variable is a substring. If the indexes
4654 * are out of range the result is empty. */
4655 if (n1 < 0)
4656 {
4657 n1 = len + n1;
4658 if (n1 < 0)
4659 n1 = 0;
4660 }
4661 if (n2 < 0)
4662 n2 = len + n2;
4663 else if (n2 >= len)
4664 n2 = len;
4665 if (n1 >= len || n2 < 0 || n1 > n2)
4666 s = NULL;
4667 else
4668 s = vim_strnsave(s + n1, (int)(n2 - n1 + 1));
4669 }
4670 else
4671 {
4672 /* The resulting variable is a string of a single
4673 * character. If the index is too big or negative the
4674 * result is empty. */
4675 if (n1 >= len || n1 < 0)
4676 s = NULL;
4677 else
4678 s = vim_strnsave(s + n1, 1);
4679 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004680 clear_tv(rettv);
4681 rettv->v_type = VAR_STRING;
4682 rettv->vval.v_string = s;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004683 break;
4684
4685 case VAR_LIST:
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004686 len = list_len(rettv->vval.v_list);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004687 if (n1 < 0)
4688 n1 = len + n1;
4689 if (!empty1 && (n1 < 0 || n1 >= len))
4690 {
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004691 /* For a range we allow invalid values and return an empty
4692 * list. A list index out of range is an error. */
4693 if (!range)
4694 {
4695 if (verbose)
4696 EMSGN(_(e_listidx), n1);
4697 return FAIL;
4698 }
4699 n1 = len;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004700 }
4701 if (range)
4702 {
Bram Moolenaar33570922005-01-25 22:26:29 +00004703 list_T *l;
4704 listitem_T *item;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004705
4706 if (n2 < 0)
4707 n2 = len + n2;
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00004708 else if (n2 >= len)
4709 n2 = len - 1;
4710 if (!empty2 && (n2 < 0 || n2 + 1 < n1))
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004711 n2 = -1;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004712 l = list_alloc();
4713 if (l == NULL)
4714 return FAIL;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004715 for (item = list_find(rettv->vval.v_list, n1);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004716 n1 <= n2; ++n1)
4717 {
4718 if (list_append_tv(l, &item->li_tv) == FAIL)
4719 {
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02004720 list_free(l);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004721 return FAIL;
4722 }
4723 item = item->li_next;
4724 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004725 clear_tv(rettv);
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02004726 rettv_list_set(rettv, l);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004727 }
4728 else
4729 {
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004730 copy_tv(&list_find(rettv->vval.v_list, n1)->li_tv, &var1);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004731 clear_tv(rettv);
4732 *rettv = var1;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004733 }
4734 break;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004735
4736 case VAR_DICT:
4737 if (range)
4738 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004739 if (verbose)
4740 EMSG(_(e_dictrange));
Bram Moolenaar8c711452005-01-14 21:53:12 +00004741 if (len == -1)
4742 clear_tv(&var1);
4743 return FAIL;
4744 }
4745 {
Bram Moolenaar33570922005-01-25 22:26:29 +00004746 dictitem_T *item;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004747
4748 if (len == -1)
4749 {
Bram Moolenaar0921ecf2016-04-03 22:44:36 +02004750 key = get_tv_string_chk(&var1);
4751 if (key == NULL)
Bram Moolenaar8c711452005-01-14 21:53:12 +00004752 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004753 clear_tv(&var1);
4754 return FAIL;
4755 }
4756 }
4757
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00004758 item = dict_find(rettv->vval.v_dict, key, (int)len);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004759
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004760 if (item == NULL && verbose)
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00004761 EMSG2(_(e_dictkey), key);
Bram Moolenaar8c711452005-01-14 21:53:12 +00004762 if (len == -1)
4763 clear_tv(&var1);
4764 if (item == NULL)
4765 return FAIL;
4766
4767 copy_tv(&item->di_tv, &var1);
4768 clear_tv(rettv);
4769 *rettv = var1;
4770 }
4771 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004772 }
4773 }
4774
Bram Moolenaar49cd9572005-01-03 21:06:01 +00004775 return OK;
4776}
4777
4778/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004779 * Get an option value.
4780 * "arg" points to the '&' or '+' before the option name.
4781 * "arg" is advanced to character after the option name.
4782 * Return OK or FAIL.
4783 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02004784 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004785get_option_tv(
4786 char_u **arg,
4787 typval_T *rettv, /* when NULL, only check if option exists */
4788 int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004789{
4790 char_u *option_end;
4791 long numval;
4792 char_u *stringval;
4793 int opt_type;
4794 int c;
4795 int working = (**arg == '+'); /* has("+option") */
4796 int ret = OK;
4797 int opt_flags;
4798
4799 /*
4800 * Isolate the option name and find its value.
4801 */
4802 option_end = find_option_end(arg, &opt_flags);
4803 if (option_end == NULL)
4804 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004805 if (rettv != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004806 EMSG2(_("E112: Option name missing: %s"), *arg);
4807 return FAIL;
4808 }
4809
4810 if (!evaluate)
4811 {
4812 *arg = option_end;
4813 return OK;
4814 }
4815
4816 c = *option_end;
4817 *option_end = NUL;
4818 opt_type = get_option_value(*arg, &numval,
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004819 rettv == NULL ? NULL : &stringval, opt_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004820
4821 if (opt_type == -3) /* invalid name */
4822 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004823 if (rettv != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004824 EMSG2(_("E113: Unknown option: %s"), *arg);
4825 ret = FAIL;
4826 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004827 else if (rettv != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004828 {
4829 if (opt_type == -2) /* hidden string option */
4830 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004831 rettv->v_type = VAR_STRING;
4832 rettv->vval.v_string = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833 }
4834 else if (opt_type == -1) /* hidden number option */
4835 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004836 rettv->v_type = VAR_NUMBER;
4837 rettv->vval.v_number = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004838 }
4839 else if (opt_type == 1) /* number option */
4840 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004841 rettv->v_type = VAR_NUMBER;
4842 rettv->vval.v_number = numval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004843 }
4844 else /* string option */
4845 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00004846 rettv->v_type = VAR_STRING;
4847 rettv->vval.v_string = stringval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004848 }
4849 }
4850 else if (working && (opt_type == -2 || opt_type == -1))
4851 ret = FAIL;
4852
4853 *option_end = c; /* put back for error messages */
4854 *arg = option_end;
4855
4856 return ret;
4857}
4858
4859/*
4860 * Allocate a variable for a string constant.
4861 * Return OK or FAIL.
4862 */
4863 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004864get_string_tv(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004865{
4866 char_u *p;
4867 char_u *name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004868 int extra = 0;
4869
4870 /*
4871 * Find the end of the string, skipping backslashed characters.
4872 */
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004873 for (p = *arg + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004874 {
4875 if (*p == '\\' && p[1] != NUL)
4876 {
4877 ++p;
4878 /* A "\<x>" form occupies at least 4 characters, and produces up
4879 * to 6 characters: reserve space for 2 extra */
4880 if (*p == '<')
4881 extra += 2;
4882 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004883 }
4884
4885 if (*p != '"')
4886 {
4887 EMSG2(_("E114: Missing quote: %s"), *arg);
4888 return FAIL;
4889 }
4890
4891 /* If only parsing, set *arg and return here */
4892 if (!evaluate)
4893 {
4894 *arg = p + 1;
4895 return OK;
4896 }
4897
4898 /*
4899 * Copy the string into allocated memory, handling backslashed
4900 * characters.
4901 */
4902 name = alloc((unsigned)(p - *arg + extra));
4903 if (name == NULL)
4904 return FAIL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00004905 rettv->v_type = VAR_STRING;
4906 rettv->vval.v_string = name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004907
Bram Moolenaar8c711452005-01-14 21:53:12 +00004908 for (p = *arg + 1; *p != NUL && *p != '"'; )
Bram Moolenaar071d4272004-06-13 20:20:40 +00004909 {
4910 if (*p == '\\')
4911 {
4912 switch (*++p)
4913 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004914 case 'b': *name++ = BS; ++p; break;
4915 case 'e': *name++ = ESC; ++p; break;
4916 case 'f': *name++ = FF; ++p; break;
4917 case 'n': *name++ = NL; ++p; break;
4918 case 'r': *name++ = CAR; ++p; break;
4919 case 't': *name++ = TAB; ++p; break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920
4921 case 'X': /* hex: "\x1", "\x12" */
4922 case 'x':
4923 case 'u': /* Unicode: "\u0023" */
4924 case 'U':
4925 if (vim_isxdigit(p[1]))
4926 {
4927 int n, nr;
4928 int c = toupper(*p);
4929
4930 if (c == 'X')
4931 n = 2;
Bram Moolenaaracc39882015-06-19 12:08:13 +02004932 else if (*p == 'u')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004933 n = 4;
Bram Moolenaaracc39882015-06-19 12:08:13 +02004934 else
4935 n = 8;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004936 nr = 0;
4937 while (--n >= 0 && vim_isxdigit(p[1]))
4938 {
4939 ++p;
4940 nr = (nr << 4) + hex2nr(*p);
4941 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004942 ++p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004943#ifdef FEAT_MBYTE
4944 /* For "\u" store the number according to
4945 * 'encoding'. */
4946 if (c != 'X')
Bram Moolenaar8c711452005-01-14 21:53:12 +00004947 name += (*mb_char2bytes)(nr, name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004948 else
4949#endif
Bram Moolenaar8c711452005-01-14 21:53:12 +00004950 *name++ = nr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004951 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004952 break;
4953
4954 /* octal: "\1", "\12", "\123" */
4955 case '0':
4956 case '1':
4957 case '2':
4958 case '3':
4959 case '4':
4960 case '5':
4961 case '6':
Bram Moolenaar8c711452005-01-14 21:53:12 +00004962 case '7': *name = *p++ - '0';
4963 if (*p >= '0' && *p <= '7')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004964 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004965 *name = (*name << 3) + *p++ - '0';
4966 if (*p >= '0' && *p <= '7')
4967 *name = (*name << 3) + *p++ - '0';
Bram Moolenaar071d4272004-06-13 20:20:40 +00004968 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004969 ++name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004970 break;
4971
4972 /* Special key, e.g.: "\<C-W>" */
Bram Moolenaar35a4cfa2016-08-14 16:07:48 +02004973 case '<': extra = trans_special(&p, name, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004974 if (extra != 0)
4975 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00004976 name += extra;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004977 break;
4978 }
4979 /* FALLTHROUGH */
4980
Bram Moolenaar8c711452005-01-14 21:53:12 +00004981 default: MB_COPY_CHAR(p, name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004982 break;
4983 }
4984 }
4985 else
Bram Moolenaar8c711452005-01-14 21:53:12 +00004986 MB_COPY_CHAR(p, name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004987
Bram Moolenaar071d4272004-06-13 20:20:40 +00004988 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00004989 *name = NUL;
Bram Moolenaardb249f22016-08-26 16:29:47 +02004990 if (*p != NUL) /* just in case */
4991 ++p;
4992 *arg = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004993
Bram Moolenaar071d4272004-06-13 20:20:40 +00004994 return OK;
4995}
4996
4997/*
Bram Moolenaar8c711452005-01-14 21:53:12 +00004998 * Allocate a variable for a 'str''ing' constant.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004999 * Return OK or FAIL.
5000 */
5001 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005002get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005003{
5004 char_u *p;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005005 char_u *str;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005006 int reduce = 0;
5007
5008 /*
Bram Moolenaar8c711452005-01-14 21:53:12 +00005009 * Find the end of the string, skipping ''.
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005010 */
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005011 for (p = *arg + 1; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005012 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005013 if (*p == '\'')
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005014 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005015 if (p[1] != '\'')
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005016 break;
5017 ++reduce;
5018 ++p;
5019 }
5020 }
5021
Bram Moolenaar8c711452005-01-14 21:53:12 +00005022 if (*p != '\'')
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005023 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005024 EMSG2(_("E115: Missing quote: %s"), *arg);
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005025 return FAIL;
5026 }
5027
Bram Moolenaar8c711452005-01-14 21:53:12 +00005028 /* If only parsing return after setting "*arg" */
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005029 if (!evaluate)
5030 {
5031 *arg = p + 1;
5032 return OK;
5033 }
5034
5035 /*
Bram Moolenaar8c711452005-01-14 21:53:12 +00005036 * Copy the string into allocated memory, handling '' to ' reduction.
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005037 */
5038 str = alloc((unsigned)((p - *arg) - reduce));
5039 if (str == NULL)
5040 return FAIL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00005041 rettv->v_type = VAR_STRING;
5042 rettv->vval.v_string = str;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005043
Bram Moolenaar8c711452005-01-14 21:53:12 +00005044 for (p = *arg + 1; *p != NUL; )
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005045 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005046 if (*p == '\'')
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005047 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005048 if (p[1] != '\'')
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005049 break;
5050 ++p;
5051 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00005052 MB_COPY_CHAR(p, str);
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005053 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00005054 *str = NUL;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005055 *arg = p + 1;
5056
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005057 return OK;
5058}
5059
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005060/*
5061 * Return the function name of the partial.
5062 */
5063 char_u *
5064partial_name(partial_T *pt)
5065{
5066 if (pt->pt_name != NULL)
5067 return pt->pt_name;
5068 return pt->pt_func->uf_name;
5069}
5070
Bram Moolenaarddecc252016-04-06 22:59:37 +02005071 static void
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005072partial_free(partial_T *pt)
Bram Moolenaarddecc252016-04-06 22:59:37 +02005073{
5074 int i;
5075
5076 for (i = 0; i < pt->pt_argc; ++i)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005077 clear_tv(&pt->pt_argv[i]);
Bram Moolenaarddecc252016-04-06 22:59:37 +02005078 vim_free(pt->pt_argv);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005079 dict_unref(pt->pt_dict);
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005080 if (pt->pt_name != NULL)
5081 {
5082 func_unref(pt->pt_name);
5083 vim_free(pt->pt_name);
5084 }
5085 else
5086 func_ptr_unref(pt->pt_func);
Bram Moolenaarddecc252016-04-06 22:59:37 +02005087 vim_free(pt);
5088}
5089
5090/*
5091 * Unreference a closure: decrement the reference count and free it when it
5092 * becomes zero.
5093 */
5094 void
5095partial_unref(partial_T *pt)
5096{
5097 if (pt != NULL && --pt->pt_refcount <= 0)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005098 partial_free(pt);
Bram Moolenaarddecc252016-04-06 22:59:37 +02005099}
5100
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005101static int tv_equal_recurse_limit;
5102
Bram Moolenaar8e759ba2016-06-02 17:46:20 +02005103 static int
5104func_equal(
5105 typval_T *tv1,
5106 typval_T *tv2,
5107 int ic) /* ignore case */
5108{
5109 char_u *s1, *s2;
5110 dict_T *d1, *d2;
5111 int a1, a2;
5112 int i;
5113
5114 /* empty and NULL function name considered the same */
5115 s1 = tv1->v_type == VAR_FUNC ? tv1->vval.v_string
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005116 : partial_name(tv1->vval.v_partial);
Bram Moolenaar8e759ba2016-06-02 17:46:20 +02005117 if (s1 != NULL && *s1 == NUL)
5118 s1 = NULL;
5119 s2 = tv2->v_type == VAR_FUNC ? tv2->vval.v_string
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005120 : partial_name(tv2->vval.v_partial);
Bram Moolenaar8e759ba2016-06-02 17:46:20 +02005121 if (s2 != NULL && *s2 == NUL)
5122 s2 = NULL;
5123 if (s1 == NULL || s2 == NULL)
5124 {
5125 if (s1 != s2)
5126 return FALSE;
5127 }
5128 else if (STRCMP(s1, s2) != 0)
5129 return FALSE;
5130
5131 /* empty dict and NULL dict is different */
5132 d1 = tv1->v_type == VAR_FUNC ? NULL : tv1->vval.v_partial->pt_dict;
5133 d2 = tv2->v_type == VAR_FUNC ? NULL : tv2->vval.v_partial->pt_dict;
5134 if (d1 == NULL || d2 == NULL)
5135 {
5136 if (d1 != d2)
5137 return FALSE;
5138 }
5139 else if (!dict_equal(d1, d2, ic, TRUE))
5140 return FALSE;
5141
5142 /* empty list and no list considered the same */
5143 a1 = tv1->v_type == VAR_FUNC ? 0 : tv1->vval.v_partial->pt_argc;
5144 a2 = tv2->v_type == VAR_FUNC ? 0 : tv2->vval.v_partial->pt_argc;
5145 if (a1 != a2)
5146 return FALSE;
5147 for (i = 0; i < a1; ++i)
5148 if (!tv_equal(tv1->vval.v_partial->pt_argv + i,
5149 tv2->vval.v_partial->pt_argv + i, ic, TRUE))
5150 return FALSE;
5151
5152 return TRUE;
5153}
5154
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00005155/*
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005156 * Return TRUE if "tv1" and "tv2" have the same value.
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005157 * Compares the items just like "==" would compare them, but strings and
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005158 * numbers are different. Floats and numbers are also different.
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005159 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02005160 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005161tv_equal(
5162 typval_T *tv1,
5163 typval_T *tv2,
5164 int ic, /* ignore case */
5165 int recursive) /* TRUE when used recursively */
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005166{
5167 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00005168 char_u *s1, *s2;
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005169 static int recursive_cnt = 0; /* catch recursive loops */
Bram Moolenaarb47a2402006-10-15 13:09:12 +00005170 int r;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005171
Bram Moolenaar8b402a02006-10-17 13:16:39 +00005172 /* Catch lists and dicts that have an endless loop by limiting
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005173 * recursiveness to a limit. We guess they are equal then.
5174 * A fixed limit has the problem of still taking an awful long time.
5175 * Reduce the limit every time running into it. That should work fine for
5176 * deeply linked structures that are not recursively linked and catch
5177 * recursiveness quickly. */
5178 if (!recursive)
5179 tv_equal_recurse_limit = 1000;
5180 if (recursive_cnt >= tv_equal_recurse_limit)
5181 {
5182 --tv_equal_recurse_limit;
Bram Moolenaar8b402a02006-10-17 13:16:39 +00005183 return TRUE;
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005184 }
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005185
Bram Moolenaarb33c7eb2016-07-04 22:29:49 +02005186 /* For VAR_FUNC and VAR_PARTIAL compare the function name, bound dict and
5187 * arguments. */
Bram Moolenaar8e759ba2016-06-02 17:46:20 +02005188 if ((tv1->v_type == VAR_FUNC
5189 || (tv1->v_type == VAR_PARTIAL && tv1->vval.v_partial != NULL))
5190 && (tv2->v_type == VAR_FUNC
5191 || (tv2->v_type == VAR_PARTIAL && tv2->vval.v_partial != NULL)))
5192 {
5193 ++recursive_cnt;
5194 r = func_equal(tv1, tv2, ic);
5195 --recursive_cnt;
5196 return r;
5197 }
5198
5199 if (tv1->v_type != tv2->v_type)
5200 return FALSE;
5201
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005202 switch (tv1->v_type)
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005203 {
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005204 case VAR_LIST:
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005205 ++recursive_cnt;
5206 r = list_equal(tv1->vval.v_list, tv2->vval.v_list, ic, TRUE);
5207 --recursive_cnt;
Bram Moolenaarb47a2402006-10-15 13:09:12 +00005208 return r;
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005209
5210 case VAR_DICT:
Bram Moolenaar67b3f992010-11-10 20:41:57 +01005211 ++recursive_cnt;
5212 r = dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic, TRUE);
5213 --recursive_cnt;
Bram Moolenaarb47a2402006-10-15 13:09:12 +00005214 return r;
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005215
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005216 case VAR_NUMBER:
5217 return tv1->vval.v_number == tv2->vval.v_number;
5218
5219 case VAR_STRING:
5220 s1 = get_tv_string_buf(tv1, buf1);
5221 s2 = get_tv_string_buf(tv2, buf2);
5222 return ((ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2)) == 0);
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005223
5224 case VAR_SPECIAL:
5225 return tv1->vval.v_number == tv2->vval.v_number;
Bram Moolenaar835dc632016-02-07 14:27:38 +01005226
5227 case VAR_FLOAT:
5228#ifdef FEAT_FLOAT
5229 return tv1->vval.v_float == tv2->vval.v_float;
5230#endif
5231 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01005232#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01005233 return tv1->vval.v_job == tv2->vval.v_job;
5234#endif
Bram Moolenaar77073442016-02-13 23:23:53 +01005235 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01005236#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01005237 return tv1->vval.v_channel == tv2->vval.v_channel;
5238#endif
Bram Moolenaarf0e86a02016-03-19 19:38:12 +01005239 case VAR_FUNC:
5240 case VAR_PARTIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01005241 case VAR_UNKNOWN:
5242 break;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005243 }
Bram Moolenaar7d1f5db2005-07-03 21:39:27 +00005244
Bram Moolenaara03f2332016-02-06 18:09:59 +01005245 /* VAR_UNKNOWN can be the result of a invalid expression, let's say it
5246 * does not equal anything, not even itself. */
5247 return FALSE;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005248}
5249
5250/*
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005251 * Return the next (unique) copy ID.
5252 * Used for serializing nested structures.
5253 */
5254 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005255get_copyID(void)
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005256{
5257 current_copyID += COPYID_INC;
5258 return current_copyID;
5259}
5260
5261/*
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005262 * Garbage collection for lists and dictionaries.
5263 *
5264 * We use reference counts to be able to free most items right away when they
5265 * are no longer used. But for composite items it's possible that it becomes
5266 * unused while the reference count is > 0: When there is a recursive
5267 * reference. Example:
5268 * :let l = [1, 2, 3]
5269 * :let d = {9: l}
5270 * :let l[1] = d
5271 *
5272 * Since this is quite unusual we handle this with garbage collection: every
5273 * once in a while find out which lists and dicts are not referenced from any
5274 * variable.
5275 *
5276 * Here is a good reference text about garbage collection (refers to Python
5277 * but it applies to all reference-counting mechanisms):
5278 * http://python.ca/nas/python/gc/
Bram Moolenaard9fba312005-06-26 22:34:35 +00005279 */
Bram Moolenaard9fba312005-06-26 22:34:35 +00005280
5281/*
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005282 * Do garbage collection for lists and dicts.
Bram Moolenaar574860b2016-05-24 17:33:34 +02005283 * When "testing" is TRUE this is called from test_garbagecollect_now().
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005284 * Return TRUE if some memory was freed.
Bram Moolenaard9fba312005-06-26 22:34:35 +00005285 */
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005286 int
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005287garbage_collect(int testing)
Bram Moolenaard9fba312005-06-26 22:34:35 +00005288{
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005289 int copyID;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005290 int abort = FALSE;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005291 buf_T *buf;
5292 win_T *wp;
5293 int i;
Bram Moolenaar934b1362015-02-04 23:06:45 +01005294 int did_free = FALSE;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005295 tabpage_T *tp;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005296
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005297 if (!testing)
5298 {
5299 /* Only do this once. */
5300 want_garbage_collect = FALSE;
5301 may_garbage_collect = FALSE;
5302 garbage_collect_at_exit = FALSE;
5303 }
Bram Moolenaar9fecb462006-09-05 10:59:47 +00005304
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005305 /* We advance by two because we add one for items referenced through
5306 * previous_funccal. */
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005307 copyID = get_copyID();
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005308
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005309 /*
5310 * 1. Go through all accessible variables and mark all lists and dicts
5311 * with copyID.
5312 */
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005313
5314 /* Don't free variables in the previous_funccal list unless they are only
5315 * referenced through previous_funccal. This must be first, because if
Bram Moolenaar2c2398c2009-06-03 11:22:45 +00005316 * the item is referenced elsewhere the funccal must not be freed. */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005317 abort = abort || set_ref_in_previous_funccal(copyID);
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005318
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005319 /* script-local variables */
5320 for (i = 1; i <= ga_scripts.ga_len; ++i)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005321 abort = abort || set_ref_in_ht(&SCRIPT_VARS(i), copyID, NULL);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005322
5323 /* buffer-local variables */
Bram Moolenaar29323592016-07-24 22:04:11 +02005324 FOR_ALL_BUFFERS(buf)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005325 abort = abort || set_ref_in_item(&buf->b_bufvar.di_tv, copyID,
5326 NULL, NULL);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005327
5328 /* window-local variables */
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005329 FOR_ALL_TAB_WINDOWS(tp, wp)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005330 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID,
5331 NULL, NULL);
Bram Moolenaar3bb28552013-04-15 18:25:59 +02005332#ifdef FEAT_AUTOCMD
5333 if (aucmd_win != NULL)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005334 abort = abort || set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID,
5335 NULL, NULL);
Bram Moolenaar3bb28552013-04-15 18:25:59 +02005336#endif
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005337
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005338 /* tabpage-local variables */
Bram Moolenaar29323592016-07-24 22:04:11 +02005339 FOR_ALL_TABPAGES(tp)
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005340 abort = abort || set_ref_in_item(&tp->tp_winvar.di_tv, copyID,
5341 NULL, NULL);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005342 /* global variables */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005343 abort = abort || set_ref_in_ht(&globvarht, copyID, NULL);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005344
5345 /* function-local variables */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005346 abort = abort || set_ref_in_call_stack(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005347
Bram Moolenaarbc7ce672016-08-01 22:49:22 +02005348 /* named functions (matters for closures) */
5349 abort = abort || set_ref_in_functions(copyID);
5350
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005351 /* function call arguments, if v:testing is set. */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005352 abort = abort || set_ref_in_func_args(copyID);
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005353
Bram Moolenaard812df62008-11-09 12:46:09 +00005354 /* v: vars */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005355 abort = abort || set_ref_in_ht(&vimvarht, copyID, NULL);
Bram Moolenaard812df62008-11-09 12:46:09 +00005356
Bram Moolenaar1dced572012-04-05 16:54:08 +02005357#ifdef FEAT_LUA
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005358 abort = abort || set_ref_in_lua(copyID);
Bram Moolenaar1dced572012-04-05 16:54:08 +02005359#endif
5360
Bram Moolenaardb913952012-06-29 12:54:53 +02005361#ifdef FEAT_PYTHON
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005362 abort = abort || set_ref_in_python(copyID);
Bram Moolenaardb913952012-06-29 12:54:53 +02005363#endif
5364
5365#ifdef FEAT_PYTHON3
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005366 abort = abort || set_ref_in_python3(copyID);
Bram Moolenaardb913952012-06-29 12:54:53 +02005367#endif
5368
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01005369#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar3780bb92016-04-12 22:18:53 +02005370 abort = abort || set_ref_in_channel(copyID);
Bram Moolenaarb8d49052016-05-01 14:22:16 +02005371 abort = abort || set_ref_in_job(copyID);
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01005372#endif
Bram Moolenaar3266c852016-04-30 18:07:05 +02005373#ifdef FEAT_NETBEANS_INTG
5374 abort = abort || set_ref_in_nb_channel(copyID);
5375#endif
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01005376
Bram Moolenaare3188e22016-05-31 21:13:04 +02005377#ifdef FEAT_TIMERS
5378 abort = abort || set_ref_in_timer(copyID);
5379#endif
5380
Bram Moolenaar8f77c5a2017-04-30 14:21:00 +02005381#ifdef FEAT_QUICKFIX
5382 abort = abort || set_ref_in_quickfix(copyID);
5383#endif
5384
Bram Moolenaara2c45a12017-07-27 22:14:59 +02005385#ifdef FEAT_TERMINAL
5386 abort = abort || set_ref_in_term(copyID);
5387#endif
5388
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005389 if (!abort)
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005390 {
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005391 /*
5392 * 2. Free lists and dictionaries that are not referenced.
5393 */
5394 did_free = free_unref_items(copyID);
5395
5396 /*
5397 * 3. Check if any funccal can be freed now.
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005398 * This may call us back recursively.
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005399 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005400 free_unref_funccal(copyID, testing);
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005401 }
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005402 else if (p_verbose > 0)
5403 {
5404 verb_msg((char_u *)_("Not enough memory to set references, garbage collection aborted!"));
5405 }
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005406
5407 return did_free;
5408}
5409
5410/*
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005411 * Free lists, dictionaries, channels and jobs that are no longer referenced.
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005412 */
5413 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005414free_unref_items(int copyID)
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005415{
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00005416 int did_free = FALSE;
5417
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005418 /* Let all "free" functions know that we are here. This means no
5419 * dictionaries, lists, channels or jobs are to be freed, because we will
5420 * do that here. */
5421 in_free_unref_items = TRUE;
5422
5423 /*
5424 * PASS 1: free the contents of the items. We don't free the items
5425 * themselves yet, so that it is possible to decrement refcount counters
5426 */
5427
Bram Moolenaarcd524592016-07-17 14:57:05 +02005428 /* Go through the list of dicts and free items without the copyID. */
5429 did_free |= dict_free_nonref(copyID);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005430
Bram Moolenaarda861d62016-07-17 15:46:27 +02005431 /* Go through the list of lists and free items without the copyID. */
5432 did_free |= list_free_nonref(copyID);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005433
5434#ifdef FEAT_JOB_CHANNEL
5435 /* Go through the list of jobs and free items without the copyID. This
5436 * must happen before doing channels, because jobs refer to channels, but
5437 * the reference from the channel to the job isn't tracked. */
5438 did_free |= free_unused_jobs_contents(copyID, COPYID_MASK);
5439
5440 /* Go through the list of channels and free items without the copyID. */
5441 did_free |= free_unused_channels_contents(copyID, COPYID_MASK);
5442#endif
5443
5444 /*
5445 * PASS 2: free the items themselves.
5446 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02005447 dict_free_items(copyID);
Bram Moolenaarda861d62016-07-17 15:46:27 +02005448 list_free_items(copyID);
Bram Moolenaar835dc632016-02-07 14:27:38 +01005449
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005450#ifdef FEAT_JOB_CHANNEL
5451 /* Go through the list of jobs and free items without the copyID. This
5452 * must happen before doing channels, because jobs refer to channels, but
5453 * the reference from the channel to the job isn't tracked. */
5454 free_unused_jobs(copyID, COPYID_MASK);
5455
5456 /* Go through the list of channels and free items without the copyID. */
5457 free_unused_channels(copyID, COPYID_MASK);
5458#endif
5459
5460 in_free_unref_items = FALSE;
5461
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005462 return did_free;
5463}
5464
5465/*
5466 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005467 * "list_stack" is used to add lists to be marked. Can be NULL.
5468 *
5469 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005470 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005471 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005472set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005473{
5474 int todo;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005475 int abort = FALSE;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005476 hashitem_T *hi;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005477 hashtab_T *cur_ht;
5478 ht_stack_T *ht_stack = NULL;
5479 ht_stack_T *tempitem;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005480
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005481 cur_ht = ht;
5482 for (;;)
5483 {
5484 if (!abort)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005485 {
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005486 /* Mark each item in the hashtab. If the item contains a hashtab
5487 * it is added to ht_stack, if it contains a list it is added to
5488 * list_stack. */
5489 todo = (int)cur_ht->ht_used;
5490 for (hi = cur_ht->ht_array; todo > 0; ++hi)
5491 if (!HASHITEM_EMPTY(hi))
5492 {
5493 --todo;
5494 abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID,
5495 &ht_stack, list_stack);
5496 }
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005497 }
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005498
5499 if (ht_stack == NULL)
5500 break;
5501
5502 /* take an item from the stack */
5503 cur_ht = ht_stack->ht;
5504 tempitem = ht_stack;
5505 ht_stack = ht_stack->prev;
5506 free(tempitem);
5507 }
5508
5509 return abort;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005510}
5511
5512/*
5513 * Mark all lists and dicts referenced through list "l" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005514 * "ht_stack" is used to add hashtabs to be marked. Can be NULL.
5515 *
5516 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005517 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005518 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005519set_ref_in_list(list_T *l, int copyID, ht_stack_T **ht_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005520{
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005521 listitem_T *li;
5522 int abort = FALSE;
5523 list_T *cur_l;
5524 list_stack_T *list_stack = NULL;
5525 list_stack_T *tempitem;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005526
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005527 cur_l = l;
5528 for (;;)
5529 {
5530 if (!abort)
5531 /* Mark each item in the list. If the item contains a hashtab
5532 * it is added to ht_stack, if it contains a list it is added to
5533 * list_stack. */
5534 for (li = cur_l->lv_first; !abort && li != NULL; li = li->li_next)
5535 abort = abort || set_ref_in_item(&li->li_tv, copyID,
5536 ht_stack, &list_stack);
5537 if (list_stack == NULL)
5538 break;
5539
5540 /* take an item from the stack */
5541 cur_l = list_stack->list;
5542 tempitem = list_stack;
5543 list_stack = list_stack->prev;
5544 free(tempitem);
5545 }
5546
5547 return abort;
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005548}
5549
5550/*
5551 * Mark all lists and dicts referenced through typval "tv" with "copyID".
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005552 * "list_stack" is used to add lists to be marked. Can be NULL.
5553 * "ht_stack" is used to add hashtabs to be marked. Can be NULL.
5554 *
5555 * Returns TRUE if setting references failed somehow.
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005556 */
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005557 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005558set_ref_in_item(
5559 typval_T *tv,
5560 int copyID,
5561 ht_stack_T **ht_stack,
5562 list_stack_T **list_stack)
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00005563{
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005564 int abort = FALSE;
Bram Moolenaard9fba312005-06-26 22:34:35 +00005565
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005566 if (tv->v_type == VAR_DICT)
Bram Moolenaard9fba312005-06-26 22:34:35 +00005567 {
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005568 dict_T *dd = tv->vval.v_dict;
5569
Bram Moolenaara03f2332016-02-06 18:09:59 +01005570 if (dd != NULL && dd->dv_copyID != copyID)
5571 {
5572 /* Didn't see this dict yet. */
5573 dd->dv_copyID = copyID;
5574 if (ht_stack == NULL)
Bram Moolenaard9fba312005-06-26 22:34:35 +00005575 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01005576 abort = set_ref_in_ht(&dd->dv_hashtab, copyID, list_stack);
5577 }
5578 else
5579 {
5580 ht_stack_T *newitem = (ht_stack_T*)malloc(sizeof(ht_stack_T));
5581 if (newitem == NULL)
5582 abort = TRUE;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005583 else
5584 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01005585 newitem->ht = &dd->dv_hashtab;
5586 newitem->prev = *ht_stack;
5587 *ht_stack = newitem;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005588 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00005589 }
Bram Moolenaara03f2332016-02-06 18:09:59 +01005590 }
5591 }
5592 else if (tv->v_type == VAR_LIST)
5593 {
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005594 list_T *ll = tv->vval.v_list;
5595
Bram Moolenaara03f2332016-02-06 18:09:59 +01005596 if (ll != NULL && ll->lv_copyID != copyID)
5597 {
5598 /* Didn't see this list yet. */
5599 ll->lv_copyID = copyID;
5600 if (list_stack == NULL)
Bram Moolenaard9fba312005-06-26 22:34:35 +00005601 {
Bram Moolenaara03f2332016-02-06 18:09:59 +01005602 abort = set_ref_in_list(ll, copyID, ht_stack);
5603 }
5604 else
5605 {
5606 list_stack_T *newitem = (list_stack_T*)malloc(
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005607 sizeof(list_stack_T));
Bram Moolenaara03f2332016-02-06 18:09:59 +01005608 if (newitem == NULL)
5609 abort = TRUE;
5610 else
5611 {
5612 newitem->list = ll;
5613 newitem->prev = *list_stack;
5614 *list_stack = newitem;
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005615 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00005616 }
Bram Moolenaara03f2332016-02-06 18:09:59 +01005617 }
Bram Moolenaard9fba312005-06-26 22:34:35 +00005618 }
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02005619 else if (tv->v_type == VAR_FUNC)
5620 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005621 abort = set_ref_in_func(tv->vval.v_string, NULL, copyID);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02005622 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005623 else if (tv->v_type == VAR_PARTIAL)
5624 {
5625 partial_T *pt = tv->vval.v_partial;
5626 int i;
5627
5628 /* A partial does not have a copyID, because it cannot contain itself.
5629 */
5630 if (pt != NULL)
5631 {
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005632 abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02005633
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005634 if (pt->pt_dict != NULL)
5635 {
5636 typval_T dtv;
5637
5638 dtv.v_type = VAR_DICT;
5639 dtv.vval.v_dict = pt->pt_dict;
5640 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5641 }
5642
5643 for (i = 0; i < pt->pt_argc; ++i)
5644 abort = abort || set_ref_in_item(&pt->pt_argv[i], copyID,
5645 ht_stack, list_stack);
5646 }
5647 }
5648#ifdef FEAT_JOB_CHANNEL
5649 else if (tv->v_type == VAR_JOB)
5650 {
5651 job_T *job = tv->vval.v_job;
5652 typval_T dtv;
5653
5654 if (job != NULL && job->jv_copyID != copyID)
5655 {
Bram Moolenaar0239acb2016-04-11 21:02:54 +02005656 job->jv_copyID = copyID;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005657 if (job->jv_channel != NULL)
5658 {
5659 dtv.v_type = VAR_CHANNEL;
5660 dtv.vval.v_channel = job->jv_channel;
5661 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5662 }
5663 if (job->jv_exit_partial != NULL)
5664 {
5665 dtv.v_type = VAR_PARTIAL;
5666 dtv.vval.v_partial = job->jv_exit_partial;
5667 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5668 }
5669 }
5670 }
5671 else if (tv->v_type == VAR_CHANNEL)
5672 {
5673 channel_T *ch =tv->vval.v_channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02005674 ch_part_T part;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005675 typval_T dtv;
5676 jsonq_T *jq;
5677 cbq_T *cq;
5678
5679 if (ch != NULL && ch->ch_copyID != copyID)
5680 {
Bram Moolenaar0239acb2016-04-11 21:02:54 +02005681 ch->ch_copyID = copyID;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02005682 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005683 {
5684 for (jq = ch->ch_part[part].ch_json_head.jq_next; jq != NULL;
5685 jq = jq->jq_next)
5686 set_ref_in_item(jq->jq_value, copyID, ht_stack, list_stack);
5687 for (cq = ch->ch_part[part].ch_cb_head.cq_next; cq != NULL;
5688 cq = cq->cq_next)
5689 if (cq->cq_partial != NULL)
5690 {
5691 dtv.v_type = VAR_PARTIAL;
5692 dtv.vval.v_partial = cq->cq_partial;
5693 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5694 }
5695 if (ch->ch_part[part].ch_partial != NULL)
5696 {
5697 dtv.v_type = VAR_PARTIAL;
5698 dtv.vval.v_partial = ch->ch_part[part].ch_partial;
5699 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5700 }
5701 }
5702 if (ch->ch_partial != NULL)
5703 {
5704 dtv.v_type = VAR_PARTIAL;
5705 dtv.vval.v_partial = ch->ch_partial;
5706 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5707 }
5708 if (ch->ch_close_partial != NULL)
5709 {
5710 dtv.v_type = VAR_PARTIAL;
5711 dtv.vval.v_partial = ch->ch_close_partial;
5712 set_ref_in_item(&dtv, copyID, ht_stack, list_stack);
5713 }
5714 }
5715 }
5716#endif
Bram Moolenaar2459a5e2015-02-03 12:55:18 +01005717 return abort;
Bram Moolenaard9fba312005-06-26 22:34:35 +00005718}
5719
Bram Moolenaar17a13432016-01-24 14:22:10 +01005720 static char *
5721get_var_special_name(int nr)
5722{
5723 switch (nr)
5724 {
Bram Moolenaarf48aa162016-01-24 17:54:24 +01005725 case VVAL_FALSE: return "v:false";
Bram Moolenaar65edff82016-02-21 16:40:11 +01005726 case VVAL_TRUE: return "v:true";
5727 case VVAL_NONE: return "v:none";
5728 case VVAL_NULL: return "v:null";
Bram Moolenaar17a13432016-01-24 14:22:10 +01005729 }
Bram Moolenaar95f09602016-11-10 20:01:45 +01005730 internal_error("get_var_special_name()");
Bram Moolenaar17a13432016-01-24 14:22:10 +01005731 return "42";
5732}
5733
Bram Moolenaar8c711452005-01-14 21:53:12 +00005734/*
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005735 * Return a string with the string representation of a variable.
5736 * If the memory is allocated "tofree" is set to it, otherwise NULL.
Bram Moolenaar8a283e52005-01-06 23:28:25 +00005737 * "numbuf" is used for a number.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005738 * When "copyID" is not NULL replace recursive lists and dicts with "...".
Bram Moolenaar35422f42017-08-05 16:33:56 +02005739 * When both "echo_style" and "composite_val" are FALSE, put quotes around
5740 * stings as "string()", otherwise does not put quotes around strings, as
5741 * ":echo" displays values.
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005742 * When "restore_copyID" is FALSE, repeated items in dictionaries and lists
5743 * are replaced with "...".
Bram Moolenaar92c5aba2007-08-14 20:29:31 +00005744 * May return NULL.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005745 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02005746 char_u *
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005747echo_string_core(
Bram Moolenaar7454a062016-01-30 15:14:10 +01005748 typval_T *tv,
5749 char_u **tofree,
5750 char_u *numbuf,
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005751 int copyID,
5752 int echo_style,
5753 int restore_copyID,
Bram Moolenaar35422f42017-08-05 16:33:56 +02005754 int composite_val)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005755{
Bram Moolenaare9a41262005-01-15 22:18:47 +00005756 static int recurse = 0;
5757 char_u *r = NULL;
5758
Bram Moolenaar33570922005-01-25 22:26:29 +00005759 if (recurse >= DICT_MAXNEST)
Bram Moolenaare9a41262005-01-15 22:18:47 +00005760 {
Bram Moolenaar8502c702014-06-17 12:51:16 +02005761 if (!did_echo_string_emsg)
5762 {
5763 /* Only give this message once for a recursive call to avoid
5764 * flooding the user with errors. And stop iterating over lists
5765 * and dicts. */
5766 did_echo_string_emsg = TRUE;
5767 EMSG(_("E724: variable nested too deep for displaying"));
5768 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00005769 *tofree = NULL;
Bram Moolenaar8502c702014-06-17 12:51:16 +02005770 return (char_u *)"{E724}";
Bram Moolenaare9a41262005-01-15 22:18:47 +00005771 }
5772 ++recurse;
5773
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005774 switch (tv->v_type)
5775 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005776 case VAR_STRING:
Bram Moolenaar35422f42017-08-05 16:33:56 +02005777 if (echo_style && !composite_val)
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005778 {
5779 *tofree = NULL;
Bram Moolenaar35422f42017-08-05 16:33:56 +02005780 r = tv->vval.v_string;
5781 if (r == NULL)
5782 r = (char_u *)"";
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005783 }
5784 else
5785 {
5786 *tofree = string_quote(tv->vval.v_string, FALSE);
5787 r = *tofree;
5788 }
5789 break;
5790
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005791 case VAR_FUNC:
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005792 if (echo_style)
5793 {
5794 *tofree = NULL;
5795 r = tv->vval.v_string;
5796 }
5797 else
5798 {
5799 *tofree = string_quote(tv->vval.v_string, TRUE);
5800 r = *tofree;
5801 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00005802 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005803
Bram Moolenaar1735bc92016-03-14 23:05:14 +01005804 case VAR_PARTIAL:
Bram Moolenaar24c77a12016-03-24 21:23:06 +01005805 {
5806 partial_T *pt = tv->vval.v_partial;
5807 char_u *fname = string_quote(pt == NULL ? NULL
Bram Moolenaar437bafe2016-08-01 15:40:54 +02005808 : partial_name(pt), FALSE);
Bram Moolenaar24c77a12016-03-24 21:23:06 +01005809 garray_T ga;
5810 int i;
5811 char_u *tf;
5812
5813 ga_init2(&ga, 1, 100);
5814 ga_concat(&ga, (char_u *)"function(");
5815 if (fname != NULL)
5816 {
5817 ga_concat(&ga, fname);
5818 vim_free(fname);
5819 }
5820 if (pt != NULL && pt->pt_argc > 0)
5821 {
5822 ga_concat(&ga, (char_u *)", [");
5823 for (i = 0; i < pt->pt_argc; ++i)
5824 {
5825 if (i > 0)
5826 ga_concat(&ga, (char_u *)", ");
5827 ga_concat(&ga,
5828 tv2string(&pt->pt_argv[i], &tf, numbuf, copyID));
5829 vim_free(tf);
5830 }
5831 ga_concat(&ga, (char_u *)"]");
5832 }
5833 if (pt != NULL && pt->pt_dict != NULL)
5834 {
5835 typval_T dtv;
5836
5837 ga_concat(&ga, (char_u *)", ");
5838 dtv.v_type = VAR_DICT;
5839 dtv.vval.v_dict = pt->pt_dict;
5840 ga_concat(&ga, tv2string(&dtv, &tf, numbuf, copyID));
5841 vim_free(tf);
5842 }
5843 ga_concat(&ga, (char_u *)")");
5844
5845 *tofree = ga.ga_data;
5846 r = *tofree;
5847 break;
5848 }
Bram Moolenaar1735bc92016-03-14 23:05:14 +01005849
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005850 case VAR_LIST:
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005851 if (tv->vval.v_list == NULL)
5852 {
5853 *tofree = NULL;
5854 r = NULL;
5855 }
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005856 else if (copyID != 0 && tv->vval.v_list->lv_copyID == copyID
5857 && tv->vval.v_list->lv_len > 0)
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005858 {
5859 *tofree = NULL;
5860 r = (char_u *)"[...]";
5861 }
5862 else
5863 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005864 int old_copyID = tv->vval.v_list->lv_copyID;
5865
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005866 tv->vval.v_list->lv_copyID = copyID;
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005867 *tofree = list2string(tv, copyID, restore_copyID);
5868 if (restore_copyID)
5869 tv->vval.v_list->lv_copyID = old_copyID;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005870 r = *tofree;
5871 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00005872 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005873
Bram Moolenaar8c711452005-01-14 21:53:12 +00005874 case VAR_DICT:
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005875 if (tv->vval.v_dict == NULL)
5876 {
5877 *tofree = NULL;
5878 r = NULL;
5879 }
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005880 else if (copyID != 0 && tv->vval.v_dict->dv_copyID == copyID
5881 && tv->vval.v_dict->dv_hashtab.ht_used != 0)
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005882 {
5883 *tofree = NULL;
5884 r = (char_u *)"{...}";
5885 }
5886 else
5887 {
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005888 int old_copyID = tv->vval.v_dict->dv_copyID;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005889 tv->vval.v_dict->dv_copyID = copyID;
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005890 *tofree = dict2string(tv, copyID, restore_copyID);
5891 if (restore_copyID)
5892 tv->vval.v_dict->dv_copyID = old_copyID;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005893 r = *tofree;
5894 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00005895 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005896
Bram Moolenaarc70646c2005-01-04 21:52:38 +00005897 case VAR_NUMBER:
Bram Moolenaara03f2332016-02-06 18:09:59 +01005898 case VAR_UNKNOWN:
Bram Moolenaar35422f42017-08-05 16:33:56 +02005899 *tofree = NULL;
5900 r = get_tv_string_buf(tv, numbuf);
5901 break;
5902
Bram Moolenaar835dc632016-02-07 14:27:38 +01005903 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01005904 case VAR_CHANNEL:
Bram Moolenaare9a41262005-01-15 22:18:47 +00005905 *tofree = NULL;
5906 r = get_tv_string_buf(tv, numbuf);
Bram Moolenaar35422f42017-08-05 16:33:56 +02005907 if (composite_val)
5908 {
5909 *tofree = string_quote(r, FALSE);
5910 r = *tofree;
5911 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005912 break;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00005913
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005914 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01005915#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00005916 *tofree = NULL;
5917 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float);
5918 r = numbuf;
5919 break;
5920#endif
5921
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005922 case VAR_SPECIAL:
5923 *tofree = NULL;
Bram Moolenaar17a13432016-01-24 14:22:10 +01005924 r = (char_u *)get_var_special_name(tv->vval.v_number);
Bram Moolenaar520e1e42016-01-23 19:46:28 +01005925 break;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005926 }
Bram Moolenaare9a41262005-01-15 22:18:47 +00005927
Bram Moolenaar8502c702014-06-17 12:51:16 +02005928 if (--recurse == 0)
5929 did_echo_string_emsg = FALSE;
Bram Moolenaare9a41262005-01-15 22:18:47 +00005930 return r;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005931}
5932
5933/*
5934 * Return a string with the string representation of a variable.
5935 * If the memory is allocated "tofree" is set to it, otherwise NULL.
5936 * "numbuf" is used for a number.
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005937 * Does not put quotes around strings, as ":echo" displays values.
5938 * When "copyID" is not NULL replace recursive lists and dicts with "...".
5939 * May return NULL.
5940 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02005941 char_u *
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005942echo_string(
5943 typval_T *tv,
5944 char_u **tofree,
5945 char_u *numbuf,
5946 int copyID)
5947{
5948 return echo_string_core(tv, tofree, numbuf, copyID, TRUE, FALSE, FALSE);
5949}
5950
5951/*
5952 * Return a string with the string representation of a variable.
5953 * If the memory is allocated "tofree" is set to it, otherwise NULL.
5954 * "numbuf" is used for a number.
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005955 * Puts quotes around strings, so that they can be parsed back by eval().
Bram Moolenaar92c5aba2007-08-14 20:29:31 +00005956 * May return NULL.
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005957 */
Bram Moolenaar8110a092016-04-14 15:56:09 +02005958 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005959tv2string(
5960 typval_T *tv,
5961 char_u **tofree,
5962 char_u *numbuf,
5963 int copyID)
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005964{
Bram Moolenaar18dfb442016-05-31 22:31:23 +02005965 return echo_string_core(tv, tofree, numbuf, copyID, FALSE, TRUE, FALSE);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00005966}
5967
5968/*
Bram Moolenaar33570922005-01-25 22:26:29 +00005969 * Return string "str" in ' quotes, doubling ' characters.
5970 * If "str" is NULL an empty string is assumed.
Bram Moolenaar8c711452005-01-14 21:53:12 +00005971 * If "function" is TRUE make it function('string').
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005972 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02005973 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005974string_quote(char_u *str, int function)
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005975{
Bram Moolenaar33570922005-01-25 22:26:29 +00005976 unsigned len;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005977 char_u *p, *r, *s;
5978
Bram Moolenaar33570922005-01-25 22:26:29 +00005979 len = (function ? 13 : 3);
5980 if (str != NULL)
5981 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005982 len += (unsigned)STRLEN(str);
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005983 for (p = str; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaar33570922005-01-25 22:26:29 +00005984 if (*p == '\'')
5985 ++len;
5986 }
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005987 s = r = alloc(len);
5988 if (r != NULL)
5989 {
5990 if (function)
5991 {
Bram Moolenaar8c711452005-01-14 21:53:12 +00005992 STRCPY(r, "function('");
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00005993 r += 10;
5994 }
5995 else
Bram Moolenaar8c711452005-01-14 21:53:12 +00005996 *r++ = '\'';
Bram Moolenaar33570922005-01-25 22:26:29 +00005997 if (str != NULL)
5998 for (p = str; *p != NUL; )
5999 {
6000 if (*p == '\'')
6001 *r++ = '\'';
6002 MB_COPY_CHAR(p, r);
6003 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00006004 *r++ = '\'';
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00006005 if (function)
6006 *r++ = ')';
6007 *r++ = NUL;
6008 }
6009 return s;
6010}
6011
Bram Moolenaar520e1e42016-01-23 19:46:28 +01006012#if defined(FEAT_FLOAT) || defined(PROTO)
Bram Moolenaar8c8de832008-06-24 22:58:06 +00006013/*
6014 * Convert the string "text" to a floating point number.
6015 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
6016 * this always uses a decimal point.
6017 * Returns the length of the text that was consumed.
6018 */
Bram Moolenaar520e1e42016-01-23 19:46:28 +01006019 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006020string2float(
6021 char_u *text,
6022 float_T *value) /* result stored here */
Bram Moolenaar8c8de832008-06-24 22:58:06 +00006023{
6024 char *s = (char *)text;
6025 float_T f;
6026
Bram Moolenaar62473612017-01-08 19:25:40 +01006027 /* MS-Windows does not deal with "inf" and "nan" properly. */
6028 if (STRNICMP(text, "inf", 3) == 0)
6029 {
6030 *value = INFINITY;
6031 return 3;
6032 }
6033 if (STRNICMP(text, "-inf", 3) == 0)
6034 {
6035 *value = -INFINITY;
6036 return 4;
6037 }
6038 if (STRNICMP(text, "nan", 3) == 0)
6039 {
6040 *value = NAN;
6041 return 3;
6042 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00006043 f = strtod(s, &s);
6044 *value = f;
6045 return (int)((char_u *)s - text);
6046}
6047#endif
6048
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00006049/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006050 * Get the value of an environment variable.
6051 * "arg" is pointing to the '$'. It is advanced to after the name.
6052 * If the environment variable was not set, silently assume it is empty.
Bram Moolenaare512c8c2014-04-29 17:41:22 +02006053 * Return FAIL if the name is invalid.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006054 */
6055 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006056get_env_tv(char_u **arg, typval_T *rettv, int evaluate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006057{
6058 char_u *string = NULL;
6059 int len;
6060 int cc;
6061 char_u *name;
Bram Moolenaar05159a02005-02-26 23:04:13 +00006062 int mustfree = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006063
6064 ++*arg;
6065 name = *arg;
6066 len = get_env_len(arg);
6067 if (evaluate)
6068 {
Bram Moolenaare512c8c2014-04-29 17:41:22 +02006069 if (len == 0)
Bram Moolenaar615b9972015-01-14 17:15:05 +01006070 return FAIL; /* invalid empty name */
Bram Moolenaar05159a02005-02-26 23:04:13 +00006071
Bram Moolenaare512c8c2014-04-29 17:41:22 +02006072 cc = name[len];
6073 name[len] = NUL;
6074 /* first try vim_getenv(), fast for normal environment vars */
6075 string = vim_getenv(name, &mustfree);
6076 if (string != NULL && *string != NUL)
6077 {
6078 if (!mustfree)
6079 string = vim_strsave(string);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006080 }
Bram Moolenaare512c8c2014-04-29 17:41:22 +02006081 else
6082 {
6083 if (mustfree)
6084 vim_free(string);
6085
6086 /* next try expanding things like $VIM and ${HOME} */
6087 string = expand_env_save(name - 1);
6088 if (string != NULL && *string == '$')
Bram Moolenaard23a8232018-02-10 18:45:26 +01006089 VIM_CLEAR(string);
Bram Moolenaare512c8c2014-04-29 17:41:22 +02006090 }
6091 name[len] = cc;
6092
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006093 rettv->v_type = VAR_STRING;
6094 rettv->vval.v_string = string;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006095 }
6096
6097 return OK;
6098}
6099
Bram Moolenaard6e256c2011-12-14 15:32:50 +01006100
6101
6102/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006103 * Translate a String variable into a position.
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006104 * Returns NULL when there is an error.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006105 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006106 pos_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006107var2fpos(
6108 typval_T *varp,
6109 int dollar_lnum, /* TRUE when $ is last line */
6110 int *fnum) /* set to fnum for '0, 'A, etc. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006111{
Bram Moolenaar261bfea2006-03-01 22:12:31 +00006112 char_u *name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006113 static pos_T pos;
Bram Moolenaar261bfea2006-03-01 22:12:31 +00006114 pos_T *pp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006115
Bram Moolenaara5525202006-03-02 22:52:09 +00006116 /* Argument can be [lnum, col, coladd]. */
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006117 if (varp->v_type == VAR_LIST)
6118 {
6119 list_T *l;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006120 int len;
Bram Moolenaara5525202006-03-02 22:52:09 +00006121 int error = FALSE;
Bram Moolenaar477933c2007-07-17 14:32:23 +00006122 listitem_T *li;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006123
6124 l = varp->vval.v_list;
6125 if (l == NULL)
6126 return NULL;
6127
6128 /* Get the line number */
Bram Moolenaara5525202006-03-02 22:52:09 +00006129 pos.lnum = list_find_nr(l, 0L, &error);
6130 if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006131 return NULL; /* invalid line number */
6132
6133 /* Get the column number */
Bram Moolenaara5525202006-03-02 22:52:09 +00006134 pos.col = list_find_nr(l, 1L, &error);
6135 if (error)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006136 return NULL;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006137 len = (long)STRLEN(ml_get(pos.lnum));
Bram Moolenaar477933c2007-07-17 14:32:23 +00006138
6139 /* We accept "$" for the column number: last column. */
6140 li = list_find(l, 1L);
6141 if (li != NULL && li->li_tv.v_type == VAR_STRING
6142 && li->li_tv.vval.v_string != NULL
6143 && STRCMP(li->li_tv.vval.v_string, "$") == 0)
6144 pos.col = len + 1;
6145
Bram Moolenaara5525202006-03-02 22:52:09 +00006146 /* Accept a position up to the NUL after the line. */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +00006147 if (pos.col == 0 || (int)pos.col > len + 1)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006148 return NULL; /* invalid column number */
Bram Moolenaara5525202006-03-02 22:52:09 +00006149 --pos.col;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006150
Bram Moolenaara5525202006-03-02 22:52:09 +00006151#ifdef FEAT_VIRTUALEDIT
6152 /* Get the virtual offset. Defaults to zero. */
6153 pos.coladd = list_find_nr(l, 2L, &error);
6154 if (error)
6155 pos.coladd = 0;
6156#endif
6157
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006158 return &pos;
6159 }
6160
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00006161 name = get_tv_string_chk(varp);
6162 if (name == NULL)
6163 return NULL;
Bram Moolenaar9ecd0232008-06-20 15:31:51 +00006164 if (name[0] == '.') /* cursor */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006165 return &curwin->w_cursor;
Bram Moolenaar9ecd0232008-06-20 15:31:51 +00006166 if (name[0] == 'v' && name[1] == NUL) /* Visual start */
6167 {
6168 if (VIsual_active)
6169 return &VIsual;
6170 return &curwin->w_cursor;
6171 }
Bram Moolenaar9ecd0232008-06-20 15:31:51 +00006172 if (name[0] == '\'') /* mark */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006173 {
Bram Moolenaar9d182dd2013-01-23 15:53:15 +01006174 pp = getmark_buf_fnum(curbuf, name[1], FALSE, fnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006175 if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0)
6176 return NULL;
6177 return pp;
6178 }
Bram Moolenaara5525202006-03-02 22:52:09 +00006179
6180#ifdef FEAT_VIRTUALEDIT
6181 pos.coladd = 0;
6182#endif
6183
Bram Moolenaar477933c2007-07-17 14:32:23 +00006184 if (name[0] == 'w' && dollar_lnum)
Bram Moolenaarf52c7252006-02-10 23:23:57 +00006185 {
6186 pos.col = 0;
6187 if (name[1] == '0') /* "w0": first visible line */
6188 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00006189 update_topline();
Bram Moolenaara1d5fa62017-04-03 22:02:55 +02006190 /* In silent Ex mode topline is zero, but that's not a valid line
6191 * number; use one instead. */
6192 pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1;
Bram Moolenaarf52c7252006-02-10 23:23:57 +00006193 return &pos;
6194 }
6195 else if (name[1] == '$') /* "w$": last visible line */
6196 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00006197 validate_botline();
Bram Moolenaara1d5fa62017-04-03 22:02:55 +02006198 /* In silent Ex mode botline is zero, return zero then. */
6199 pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0;
Bram Moolenaarf52c7252006-02-10 23:23:57 +00006200 return &pos;
6201 }
6202 }
6203 else if (name[0] == '$') /* last column or line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006204 {
Bram Moolenaar477933c2007-07-17 14:32:23 +00006205 if (dollar_lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006206 {
6207 pos.lnum = curbuf->b_ml.ml_line_count;
6208 pos.col = 0;
6209 }
6210 else
6211 {
6212 pos.lnum = curwin->w_cursor.lnum;
6213 pos.col = (colnr_T)STRLEN(ml_get_curline());
6214 }
6215 return &pos;
6216 }
6217 return NULL;
6218}
6219
6220/*
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006221 * Convert list in "arg" into a position and optional file number.
6222 * When "fnump" is NULL there is no file number, only 3 items.
6223 * Note that the column is passed on as-is, the caller may want to decrement
6224 * it to use 1 for the first column.
6225 * Return FAIL when conversion is not possible, doesn't check the position for
6226 * validity.
6227 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006228 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006229list2fpos(
6230 typval_T *arg,
6231 pos_T *posp,
6232 int *fnump,
6233 colnr_T *curswantp)
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006234{
6235 list_T *l = arg->vval.v_list;
6236 long i = 0;
6237 long n;
6238
Bram Moolenaar493c1782014-05-28 14:34:46 +02006239 /* List must be: [fnum, lnum, col, coladd, curswant], where "fnum" is only
6240 * there when "fnump" isn't NULL; "coladd" and "curswant" are optional. */
Bram Moolenaarbde35262006-07-23 20:12:24 +00006241 if (arg->v_type != VAR_LIST
6242 || l == NULL
6243 || l->lv_len < (fnump == NULL ? 2 : 3)
Bram Moolenaar493c1782014-05-28 14:34:46 +02006244 || l->lv_len > (fnump == NULL ? 4 : 5))
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006245 return FAIL;
6246
6247 if (fnump != NULL)
6248 {
6249 n = list_find_nr(l, i++, NULL); /* fnum */
6250 if (n < 0)
6251 return FAIL;
6252 if (n == 0)
6253 n = curbuf->b_fnum; /* current buffer */
6254 *fnump = n;
6255 }
6256
6257 n = list_find_nr(l, i++, NULL); /* lnum */
6258 if (n < 0)
6259 return FAIL;
6260 posp->lnum = n;
6261
6262 n = list_find_nr(l, i++, NULL); /* col */
6263 if (n < 0)
6264 return FAIL;
6265 posp->col = n;
6266
6267#ifdef FEAT_VIRTUALEDIT
Bram Moolenaar493c1782014-05-28 14:34:46 +02006268 n = list_find_nr(l, i, NULL); /* off */
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006269 if (n < 0)
Bram Moolenaarbde35262006-07-23 20:12:24 +00006270 posp->coladd = 0;
6271 else
6272 posp->coladd = n;
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006273#endif
6274
Bram Moolenaar493c1782014-05-28 14:34:46 +02006275 if (curswantp != NULL)
6276 *curswantp = list_find_nr(l, i + 1, NULL); /* curswant */
6277
Bram Moolenaar0e34f622006-03-03 23:00:03 +00006278 return OK;
6279}
6280
6281/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006282 * Get the length of an environment variable name.
6283 * Advance "arg" to the first character after the name.
6284 * Return 0 for error.
6285 */
6286 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006287get_env_len(char_u **arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006288{
6289 char_u *p;
6290 int len;
6291
6292 for (p = *arg; vim_isIDc(*p); ++p)
6293 ;
6294 if (p == *arg) /* no name found */
6295 return 0;
6296
6297 len = (int)(p - *arg);
6298 *arg = p;
6299 return len;
6300}
6301
6302/*
6303 * Get the length of the name of a function or internal variable.
6304 * "arg" is advanced to the first non-white character after the name.
6305 * Return 0 if something is wrong.
6306 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02006307 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006308get_id_len(char_u **arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006309{
6310 char_u *p;
6311 int len;
6312
6313 /* Find the end of the name. */
6314 for (p = *arg; eval_isnamec(*p); ++p)
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01006315 {
6316 if (*p == ':')
6317 {
6318 /* "s:" is start of "s:var", but "n:" is not and can be used in
6319 * slice "[n:]". Also "xx:" is not a namespace. */
6320 len = (int)(p - *arg);
6321 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, **arg) == NULL)
6322 || len > 1)
6323 break;
6324 }
6325 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006326 if (p == *arg) /* no name found */
6327 return 0;
6328
6329 len = (int)(p - *arg);
6330 *arg = skipwhite(p);
6331
6332 return len;
6333}
6334
6335/*
Bram Moolenaara7043832005-01-21 11:56:39 +00006336 * Get the length of the name of a variable or function.
6337 * Only the name is recognized, does not handle ".key" or "[idx]".
Bram Moolenaar071d4272004-06-13 20:20:40 +00006338 * "arg" is advanced to the first non-white character after the name.
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006339 * Return -1 if curly braces expansion failed.
6340 * Return 0 if something else is wrong.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006341 * If the name contains 'magic' {}'s, expand them and return the
6342 * expanded name in an allocated string via 'alias' - caller must free.
6343 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006344 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006345get_name_len(
6346 char_u **arg,
6347 char_u **alias,
6348 int evaluate,
6349 int verbose)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006350{
6351 int len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006352 char_u *p;
6353 char_u *expr_start;
6354 char_u *expr_end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006355
6356 *alias = NULL; /* default to no alias */
6357
6358 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA
6359 && (*arg)[2] == (int)KE_SNR)
6360 {
6361 /* hard coded <SNR>, already translated */
6362 *arg += 3;
6363 return get_id_len(arg) + 3;
6364 }
6365 len = eval_fname_script(*arg);
6366 if (len > 0)
6367 {
6368 /* literal "<SID>", "s:" or "<SNR>" */
6369 *arg += len;
6370 }
6371
Bram Moolenaar071d4272004-06-13 20:20:40 +00006372 /*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006373 * Find the end of the name; check for {} construction.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006374 */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006375 p = find_name_end(*arg, &expr_start, &expr_end,
6376 len > 0 ? 0 : FNE_CHECK_START);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006377 if (expr_start != NULL)
6378 {
6379 char_u *temp_string;
6380
6381 if (!evaluate)
6382 {
6383 len += (int)(p - *arg);
6384 *arg = skipwhite(p);
6385 return len;
6386 }
6387
6388 /*
6389 * Include any <SID> etc in the expanded string:
6390 * Thus the -len here.
6391 */
6392 temp_string = make_expanded_name(*arg - len, expr_start, expr_end, p);
6393 if (temp_string == NULL)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006394 return -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006395 *alias = temp_string;
6396 *arg = skipwhite(p);
6397 return (int)STRLEN(temp_string);
6398 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006399
6400 len += get_id_len(arg);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006401 if (len == 0 && verbose)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006402 EMSG2(_(e_invexpr2), *arg);
6403
6404 return len;
6405}
6406
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006407/*
6408 * Find the end of a variable or function name, taking care of magic braces.
6409 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
6410 * start and end of the first magic braces item.
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006411 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006412 * Return a pointer to just after the name. Equal to "arg" if there is no
6413 * valid name.
6414 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02006415 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006416find_name_end(
6417 char_u *arg,
6418 char_u **expr_start,
6419 char_u **expr_end,
6420 int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006421{
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006422 int mb_nest = 0;
6423 int br_nest = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006424 char_u *p;
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01006425 int len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006426
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006427 if (expr_start != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006428 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006429 *expr_start = NULL;
6430 *expr_end = NULL;
6431 }
6432
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006433 /* Quick check for valid starting character. */
6434 if ((flags & FNE_CHECK_START) && !eval_isnamec1(*arg) && *arg != '{')
6435 return arg;
6436
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006437 for (p = arg; *p != NUL
6438 && (eval_isnamec(*p)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006439 || *p == '{'
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006440 || ((flags & FNE_INCL_BR) && (*p == '[' || *p == '.'))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006441 || mb_nest != 0
Bram Moolenaar91acfff2017-03-12 19:22:36 +01006442 || br_nest != 0); MB_PTR_ADV(p))
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006443 {
Bram Moolenaar8af24422005-08-08 22:06:28 +00006444 if (*p == '\'')
6445 {
6446 /* skip over 'string' to avoid counting [ and ] inside it. */
Bram Moolenaar91acfff2017-03-12 19:22:36 +01006447 for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p))
Bram Moolenaar8af24422005-08-08 22:06:28 +00006448 ;
6449 if (*p == NUL)
6450 break;
6451 }
6452 else if (*p == '"')
6453 {
6454 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
Bram Moolenaar91acfff2017-03-12 19:22:36 +01006455 for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p))
Bram Moolenaar8af24422005-08-08 22:06:28 +00006456 if (*p == '\\' && p[1] != NUL)
6457 ++p;
6458 if (*p == NUL)
6459 break;
6460 }
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01006461 else if (br_nest == 0 && mb_nest == 0 && *p == ':')
6462 {
6463 /* "s:" is start of "s:var", but "n:" is not and can be used in
Bram Moolenaar4119cf82016-01-17 14:59:01 +01006464 * slice "[n:]". Also "xx:" is not a namespace. But {ns}: is. */
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01006465 len = (int)(p - arg);
6466 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, *arg) == NULL)
Bram Moolenaar4119cf82016-01-17 14:59:01 +01006467 || (len > 1 && p[-1] != '}'))
Bram Moolenaar9bbf63d2016-01-16 16:49:28 +01006468 break;
6469 }
Bram Moolenaar8af24422005-08-08 22:06:28 +00006470
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006471 if (mb_nest == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006472 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006473 if (*p == '[')
6474 ++br_nest;
6475 else if (*p == ']')
6476 --br_nest;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006477 }
Bram Moolenaar8af24422005-08-08 22:06:28 +00006478
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006479 if (br_nest == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006480 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006481 if (*p == '{')
6482 {
6483 mb_nest++;
6484 if (expr_start != NULL && *expr_start == NULL)
6485 *expr_start = p;
6486 }
6487 else if (*p == '}')
6488 {
6489 mb_nest--;
6490 if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL)
6491 *expr_end = p;
6492 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006493 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006494 }
6495
6496 return p;
6497}
6498
6499/*
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006500 * Expands out the 'magic' {}'s in a variable/function name.
6501 * Note that this can call itself recursively, to deal with
6502 * constructs like foo{bar}{baz}{bam}
6503 * The four pointer arguments point to "foo{expre}ss{ion}bar"
6504 * "in_start" ^
6505 * "expr_start" ^
6506 * "expr_end" ^
6507 * "in_end" ^
6508 *
6509 * Returns a new allocated string, which the caller must free.
6510 * Returns NULL for failure.
6511 */
6512 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006513make_expanded_name(
6514 char_u *in_start,
6515 char_u *expr_start,
6516 char_u *expr_end,
6517 char_u *in_end)
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006518{
6519 char_u c1;
6520 char_u *retval = NULL;
6521 char_u *temp_result;
6522 char_u *nextcmd = NULL;
6523
6524 if (expr_end == NULL || in_end == NULL)
6525 return NULL;
6526 *expr_start = NUL;
6527 *expr_end = NUL;
6528 c1 = *in_end;
6529 *in_end = NUL;
6530
Bram Moolenaar362e1a32006-03-06 23:29:24 +00006531 temp_result = eval_to_string(expr_start + 1, &nextcmd, FALSE);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006532 if (temp_result != NULL && nextcmd == NULL)
6533 {
6534 retval = alloc((unsigned)(STRLEN(temp_result) + (expr_start - in_start)
6535 + (in_end - expr_end) + 1));
6536 if (retval != NULL)
6537 {
6538 STRCPY(retval, in_start);
6539 STRCAT(retval, temp_result);
6540 STRCAT(retval, expr_end + 1);
6541 }
6542 }
6543 vim_free(temp_result);
6544
6545 *in_end = c1; /* put char back for error messages */
6546 *expr_start = '{';
6547 *expr_end = '}';
6548
6549 if (retval != NULL)
6550 {
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006551 temp_result = find_name_end(retval, &expr_start, &expr_end, 0);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006552 if (expr_start != NULL)
6553 {
6554 /* Further expansion! */
6555 temp_result = make_expanded_name(retval, expr_start,
6556 expr_end, temp_result);
6557 vim_free(retval);
6558 retval = temp_result;
6559 }
6560 }
6561
6562 return retval;
6563}
6564
6565/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006566 * Return TRUE if character "c" can be used in a variable or function name.
Bram Moolenaare9a41262005-01-15 22:18:47 +00006567 * Does not include '{' or '}' for magic braces.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006568 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02006569 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006570eval_isnamec(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006571{
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006572 return (ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR);
6573}
6574
6575/*
6576 * Return TRUE if character "c" can be used as the first character in a
6577 * variable or function name (excluding '{' and '}').
6578 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02006579 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006580eval_isnamec1(int c)
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00006581{
6582 return (ASCII_ISALPHA(c) || c == '_');
Bram Moolenaar071d4272004-06-13 20:20:40 +00006583}
6584
6585/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006586 * Set number v: variable to "val".
6587 */
6588 void
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02006589set_vim_var_nr(int idx, varnumber_T val)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006590{
Bram Moolenaare9a41262005-01-15 22:18:47 +00006591 vimvars[idx].vv_nr = val;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006592}
6593
6594/*
Bram Moolenaar19a09a12005-03-04 23:39:37 +00006595 * Get number v: variable value.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006596 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02006597 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01006598get_vim_var_nr(int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006599{
Bram Moolenaare9a41262005-01-15 22:18:47 +00006600 return vimvars[idx].vv_nr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006601}
6602
Bram Moolenaar19a09a12005-03-04 23:39:37 +00006603/*
6604 * Get string v: variable value. Uses a static buffer, can only be used once.
Bram Moolenaar6e65d592017-12-07 22:11:27 +01006605 * If the String variable has never been set, return an empty string.
6606 * Never returns NULL;
Bram Moolenaar19a09a12005-03-04 23:39:37 +00006607 */
6608 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006609get_vim_var_str(int idx)
Bram Moolenaar19a09a12005-03-04 23:39:37 +00006610{
6611 return get_tv_string(&vimvars[idx].vv_tv);
6612}
Bram Moolenaar19a09a12005-03-04 23:39:37 +00006613
Bram Moolenaar071d4272004-06-13 20:20:40 +00006614/*
Bram Moolenaard812df62008-11-09 12:46:09 +00006615 * Get List v: variable value. Caller must take care of reference count when
6616 * needed.
6617 */
6618 list_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006619get_vim_var_list(int idx)
Bram Moolenaard812df62008-11-09 12:46:09 +00006620{
6621 return vimvars[idx].vv_list;
6622}
6623
6624/*
Bram Moolenaar7e1652c2017-12-16 18:27:02 +01006625 * Get Dict v: variable value. Caller must take care of reference count when
6626 * needed.
6627 */
6628 dict_T *
6629get_vim_var_dict(int idx)
6630{
6631 return vimvars[idx].vv_dict;
6632}
6633
6634/*
Bram Moolenaarda9591e2009-09-30 13:17:02 +00006635 * Set v:char to character "c".
6636 */
6637 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006638set_vim_var_char(int c)
Bram Moolenaarda9591e2009-09-30 13:17:02 +00006639{
Bram Moolenaar9a920d82012-06-01 15:21:02 +02006640 char_u buf[MB_MAXBYTES + 1];
Bram Moolenaarda9591e2009-09-30 13:17:02 +00006641
6642#ifdef FEAT_MBYTE
6643 if (has_mbyte)
6644 buf[(*mb_char2bytes)(c, buf)] = NUL;
6645 else
6646#endif
6647 {
6648 buf[0] = c;
6649 buf[1] = NUL;
6650 }
6651 set_vim_var_string(VV_CHAR, buf, -1);
6652}
6653
6654/*
Bram Moolenaar8df74be2008-11-20 15:12:02 +00006655 * Set v:count to "count" and v:count1 to "count1".
6656 * When "set_prevcount" is TRUE first set v:prevcount from v:count.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006657 */
6658 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006659set_vcount(
6660 long count,
6661 long count1,
6662 int set_prevcount)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006663{
Bram Moolenaar8df74be2008-11-20 15:12:02 +00006664 if (set_prevcount)
6665 vimvars[VV_PREVCOUNT].vv_nr = vimvars[VV_COUNT].vv_nr;
Bram Moolenaare9a41262005-01-15 22:18:47 +00006666 vimvars[VV_COUNT].vv_nr = count;
6667 vimvars[VV_COUNT1].vv_nr = count1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006668}
6669
6670/*
6671 * Set string v: variable to a copy of "val".
6672 */
6673 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006674set_vim_var_string(
6675 int idx,
6676 char_u *val,
6677 int len) /* length of "val" to use or -1 (whole string) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006678{
Bram Moolenaara542c682016-01-31 16:28:04 +01006679 clear_tv(&vimvars[idx].vv_di.di_tv);
6680 vimvars[idx].vv_type = VAR_STRING;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006681 if (val == NULL)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006682 vimvars[idx].vv_str = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006683 else if (len == -1)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006684 vimvars[idx].vv_str = vim_strsave(val);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006685 else
Bram Moolenaare9a41262005-01-15 22:18:47 +00006686 vimvars[idx].vv_str = vim_strnsave(val, len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006687}
6688
6689/*
Bram Moolenaard812df62008-11-09 12:46:09 +00006690 * Set List v: variable to "val".
6691 */
6692 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006693set_vim_var_list(int idx, list_T *val)
Bram Moolenaard812df62008-11-09 12:46:09 +00006694{
Bram Moolenaara542c682016-01-31 16:28:04 +01006695 clear_tv(&vimvars[idx].vv_di.di_tv);
6696 vimvars[idx].vv_type = VAR_LIST;
Bram Moolenaard812df62008-11-09 12:46:09 +00006697 vimvars[idx].vv_list = val;
6698 if (val != NULL)
6699 ++val->lv_refcount;
6700}
6701
6702/*
Bram Moolenaar42a45122015-07-10 17:56:23 +02006703 * Set Dictionary v: variable to "val".
6704 */
6705 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006706set_vim_var_dict(int idx, dict_T *val)
Bram Moolenaar42a45122015-07-10 17:56:23 +02006707{
Bram Moolenaara542c682016-01-31 16:28:04 +01006708 clear_tv(&vimvars[idx].vv_di.di_tv);
6709 vimvars[idx].vv_type = VAR_DICT;
Bram Moolenaar42a45122015-07-10 17:56:23 +02006710 vimvars[idx].vv_dict = val;
6711 if (val != NULL)
6712 {
6713 ++val->dv_refcount;
Bram Moolenaar7e1652c2017-12-16 18:27:02 +01006714 dict_set_items_ro(val);
Bram Moolenaar42a45122015-07-10 17:56:23 +02006715 }
6716}
6717
6718/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006719 * Set v:register if needed.
6720 */
6721 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01006722set_reg_var(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006723{
6724 char_u regname;
6725
6726 if (c == 0 || c == ' ')
6727 regname = '"';
6728 else
6729 regname = c;
6730 /* Avoid free/alloc when the value is already right. */
Bram Moolenaare9a41262005-01-15 22:18:47 +00006731 if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006732 set_vim_var_string(VV_REG, &regname, 1);
6733}
6734
6735/*
6736 * Get or set v:exception. If "oldval" == NULL, return the current value.
6737 * Otherwise, restore the value to "oldval" and return NULL.
6738 * Must always be called in pairs to save and restore v:exception! Does not
6739 * take care of memory allocations.
6740 */
6741 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006742v_exception(char_u *oldval)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006743{
6744 if (oldval == NULL)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006745 return vimvars[VV_EXCEPTION].vv_str;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006746
Bram Moolenaare9a41262005-01-15 22:18:47 +00006747 vimvars[VV_EXCEPTION].vv_str = oldval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006748 return NULL;
6749}
6750
6751/*
6752 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
6753 * Otherwise, restore the value to "oldval" and return NULL.
6754 * Must always be called in pairs to save and restore v:throwpoint! Does not
6755 * take care of memory allocations.
6756 */
6757 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006758v_throwpoint(char_u *oldval)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006759{
6760 if (oldval == NULL)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006761 return vimvars[VV_THROWPOINT].vv_str;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006762
Bram Moolenaare9a41262005-01-15 22:18:47 +00006763 vimvars[VV_THROWPOINT].vv_str = oldval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006764 return NULL;
6765}
6766
6767#if defined(FEAT_AUTOCMD) || defined(PROTO)
6768/*
6769 * Set v:cmdarg.
6770 * If "eap" != NULL, use "eap" to generate the value and return the old value.
6771 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
6772 * Must always be called in pairs!
6773 */
6774 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01006775set_cmdarg(exarg_T *eap, char_u *oldarg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006776{
6777 char_u *oldval;
6778 char_u *newval;
6779 unsigned len;
6780
Bram Moolenaare9a41262005-01-15 22:18:47 +00006781 oldval = vimvars[VV_CMDARG].vv_str;
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006782 if (eap == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006783 {
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006784 vim_free(oldval);
Bram Moolenaare9a41262005-01-15 22:18:47 +00006785 vimvars[VV_CMDARG].vv_str = oldarg;
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006786 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006787 }
6788
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006789 if (eap->force_bin == FORCE_BIN)
6790 len = 6;
6791 else if (eap->force_bin == FORCE_NOBIN)
6792 len = 8;
6793 else
6794 len = 0;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006795
6796 if (eap->read_edit)
6797 len += 7;
6798
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006799 if (eap->force_ff != 0)
6800 len += (unsigned)STRLEN(eap->cmd + eap->force_ff) + 6;
6801# ifdef FEAT_MBYTE
6802 if (eap->force_enc != 0)
6803 len += (unsigned)STRLEN(eap->cmd + eap->force_enc) + 7;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02006804 if (eap->bad_char != 0)
6805 len += 7 + 4; /* " ++bad=" + "keep" or "drop" */
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006806# endif
6807
6808 newval = alloc(len + 1);
6809 if (newval == NULL)
6810 return NULL;
6811
6812 if (eap->force_bin == FORCE_BIN)
6813 sprintf((char *)newval, " ++bin");
6814 else if (eap->force_bin == FORCE_NOBIN)
6815 sprintf((char *)newval, " ++nobin");
6816 else
6817 *newval = NUL;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006818
6819 if (eap->read_edit)
6820 STRCAT(newval, " ++edit");
6821
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006822 if (eap->force_ff != 0)
6823 sprintf((char *)newval + STRLEN(newval), " ++ff=%s",
6824 eap->cmd + eap->force_ff);
6825# ifdef FEAT_MBYTE
6826 if (eap->force_enc != 0)
6827 sprintf((char *)newval + STRLEN(newval), " ++enc=%s",
6828 eap->cmd + eap->force_enc);
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02006829 if (eap->bad_char == BAD_KEEP)
6830 STRCPY(newval + STRLEN(newval), " ++bad=keep");
6831 else if (eap->bad_char == BAD_DROP)
6832 STRCPY(newval + STRLEN(newval), " ++bad=drop");
6833 else if (eap->bad_char != 0)
6834 sprintf((char *)newval + STRLEN(newval), " ++bad=%c", eap->bad_char);
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006835# endif
Bram Moolenaare9a41262005-01-15 22:18:47 +00006836 vimvars[VV_CMDARG].vv_str = newval;
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00006837 return oldval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006838}
6839#endif
6840
6841/*
6842 * Get the value of internal variable "name".
6843 * Return OK or FAIL.
6844 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02006845 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006846get_var_tv(
6847 char_u *name,
6848 int len, /* length of "name" */
6849 typval_T *rettv, /* NULL when only checking existence */
6850 dictitem_T **dip, /* non-NULL when typval's dict item is needed */
6851 int verbose, /* may give error message */
6852 int no_autoload) /* do not use script autoloading */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006853{
6854 int ret = OK;
Bram Moolenaar33570922005-01-25 22:26:29 +00006855 typval_T *tv = NULL;
Bram Moolenaar33570922005-01-25 22:26:29 +00006856 dictitem_T *v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006857 int cc;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006858
6859 /* truncate the name, so that we can use strcmp() */
6860 cc = name[len];
6861 name[len] = NUL;
6862
6863 /*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006864 * Check for user-defined variables.
6865 */
Bram Moolenaar79518e22017-02-17 16:31:35 +01006866 v = find_var(name, NULL, no_autoload);
6867 if (v != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006868 {
Bram Moolenaar79518e22017-02-17 16:31:35 +01006869 tv = &v->di_tv;
6870 if (dip != NULL)
6871 *dip = v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006872 }
6873
Bram Moolenaare9a41262005-01-15 22:18:47 +00006874 if (tv == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006875 {
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006876 if (rettv != NULL && verbose)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006877 EMSG2(_(e_undefvar), name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006878 ret = FAIL;
6879 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00006880 else if (rettv != NULL)
Bram Moolenaare9a41262005-01-15 22:18:47 +00006881 copy_tv(tv, rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006882
6883 name[len] = cc;
6884
6885 return ret;
6886}
6887
6888/*
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02006889 * Check if variable "name[len]" is a local variable or an argument.
6890 * If so, "*eval_lavars_used" is set to TRUE.
6891 */
6892 static void
6893check_vars(char_u *name, int len)
6894{
6895 int cc;
6896 char_u *varname;
6897 hashtab_T *ht;
6898
6899 if (eval_lavars_used == NULL)
6900 return;
6901
6902 /* truncate the name, so that we can use strcmp() */
6903 cc = name[len];
6904 name[len] = NUL;
6905
6906 ht = find_var_ht(name, &varname);
6907 if (ht == get_funccal_local_ht() || ht == get_funccal_args_ht())
6908 {
6909 if (find_var(name, NULL, TRUE) != NULL)
6910 *eval_lavars_used = TRUE;
6911 }
6912
6913 name[len] = cc;
6914}
6915
6916/*
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006917 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
6918 * Also handle function call with Funcref variable: func(expr)
6919 * Can all be combined: dict.func(expr)[idx]['func'](expr)
6920 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02006921 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01006922handle_subscript(
6923 char_u **arg,
6924 typval_T *rettv,
6925 int evaluate, /* do more than finding the end */
6926 int verbose) /* give error messages */
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006927{
6928 int ret = OK;
6929 dict_T *selfdict = NULL;
6930 char_u *s;
6931 int len;
Bram Moolenaard9fba312005-06-26 22:34:35 +00006932 typval_T functv;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006933
6934 while (ret == OK
6935 && (**arg == '['
6936 || (**arg == '.' && rettv->v_type == VAR_DICT)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01006937 || (**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC
6938 || rettv->v_type == VAR_PARTIAL)))
Bram Moolenaar1c465442017-03-12 20:10:05 +01006939 && !VIM_ISWHITE(*(*arg - 1)))
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006940 {
6941 if (**arg == '(')
6942 {
Bram Moolenaar3f242a82016-03-18 19:39:25 +01006943 partial_T *pt = NULL;
6944
Bram Moolenaard9fba312005-06-26 22:34:35 +00006945 /* need to copy the funcref so that we can clear rettv */
Bram Moolenaar0f8de8d2013-11-11 04:25:53 +01006946 if (evaluate)
6947 {
6948 functv = *rettv;
6949 rettv->v_type = VAR_UNKNOWN;
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006950
Bram Moolenaar0f8de8d2013-11-11 04:25:53 +01006951 /* Invoke the function. Recursive! */
Bram Moolenaarab1fa392016-03-15 19:33:34 +01006952 if (functv.v_type == VAR_PARTIAL)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01006953 {
6954 pt = functv.vval.v_partial;
Bram Moolenaar437bafe2016-08-01 15:40:54 +02006955 s = partial_name(pt);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01006956 }
6957 else
6958 s = functv.vval.v_string;
Bram Moolenaar0f8de8d2013-11-11 04:25:53 +01006959 }
6960 else
6961 s = (char_u *)"";
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006962 ret = get_func_tv(s, (int)STRLEN(s), rettv, arg,
Bram Moolenaard9fba312005-06-26 22:34:35 +00006963 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
Bram Moolenaar1735bc92016-03-14 23:05:14 +01006964 &len, evaluate, pt, selfdict);
Bram Moolenaard9fba312005-06-26 22:34:35 +00006965
6966 /* Clear the funcref afterwards, so that deleting it while
6967 * evaluating the arguments is possible (see test55). */
Bram Moolenaar0f8de8d2013-11-11 04:25:53 +01006968 if (evaluate)
6969 clear_tv(&functv);
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00006970
6971 /* Stop the expression evaluation when immediately aborting on
6972 * error, or when an interrupt occurred or an exception was thrown
6973 * but not caught. */
6974 if (aborting())
6975 {
6976 if (ret == OK)
6977 clear_tv(rettv);
6978 ret = FAIL;
6979 }
6980 dict_unref(selfdict);
6981 selfdict = NULL;
6982 }
6983 else /* **arg == '[' || **arg == '.' */
6984 {
6985 dict_unref(selfdict);
6986 if (rettv->v_type == VAR_DICT)
6987 {
6988 selfdict = rettv->vval.v_dict;
6989 if (selfdict != NULL)
6990 ++selfdict->dv_refcount;
6991 }
6992 else
6993 selfdict = NULL;
6994 if (eval_index(arg, rettv, evaluate, verbose) == FAIL)
6995 {
6996 clear_tv(rettv);
6997 ret = FAIL;
6998 }
6999 }
7000 }
Bram Moolenaarab1fa392016-03-15 19:33:34 +01007001
Bram Moolenaar1d429612016-05-24 15:44:17 +02007002 /* Turn "dict.Func" into a partial for "Func" bound to "dict".
7003 * Don't do this when "Func" is already a partial that was bound
7004 * explicitly (pt_auto is FALSE). */
7005 if (selfdict != NULL
7006 && (rettv->v_type == VAR_FUNC
7007 || (rettv->v_type == VAR_PARTIAL
7008 && (rettv->vval.v_partial->pt_auto
7009 || rettv->vval.v_partial->pt_dict == NULL))))
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007010 selfdict = make_partial(selfdict, rettv);
Bram Moolenaarab1fa392016-03-15 19:33:34 +01007011
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00007012 dict_unref(selfdict);
7013 return ret;
7014}
7015
7016/*
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007017 * Allocate memory for a variable type-value, and make it empty (0 or NULL
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007018 * value).
7019 */
Bram Moolenaar11e0afa2016-02-01 22:41:00 +01007020 typval_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007021alloc_tv(void)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007022{
Bram Moolenaar33570922005-01-25 22:26:29 +00007023 return (typval_T *)alloc_clear((unsigned)sizeof(typval_T));
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007024}
7025
7026/*
7027 * Allocate memory for a variable type-value, and assign a string to it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007028 * The string "s" must have been allocated, it is consumed.
7029 * Return NULL for out of memory, the variable otherwise.
7030 */
Bram Moolenaar33570922005-01-25 22:26:29 +00007031 static typval_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007032alloc_string_tv(char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007033{
Bram Moolenaar33570922005-01-25 22:26:29 +00007034 typval_T *rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007035
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007036 rettv = alloc_tv();
7037 if (rettv != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007038 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007039 rettv->v_type = VAR_STRING;
7040 rettv->vval.v_string = s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007041 }
7042 else
7043 vim_free(s);
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007044 return rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007045}
7046
7047/*
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007048 * Free the memory for a variable type-value.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007049 */
Bram Moolenaar4770d092006-01-12 23:22:24 +00007050 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007051free_tv(typval_T *varp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007052{
7053 if (varp != NULL)
7054 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007055 switch (varp->v_type)
7056 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007057 case VAR_FUNC:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007058 func_unref(varp->vval.v_string);
Bram Moolenaar2f40d122017-10-24 21:49:36 +02007059 /* FALLTHROUGH */
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007060 case VAR_STRING:
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007061 vim_free(varp->vval.v_string);
7062 break;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007063 case VAR_PARTIAL:
7064 partial_unref(varp->vval.v_partial);
7065 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007066 case VAR_LIST:
7067 list_unref(varp->vval.v_list);
7068 break;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007069 case VAR_DICT:
7070 dict_unref(varp->vval.v_dict);
7071 break;
Bram Moolenaar835dc632016-02-07 14:27:38 +01007072 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007073#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007074 job_unref(varp->vval.v_job);
7075 break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007076#endif
Bram Moolenaar77073442016-02-13 23:23:53 +01007077 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007078#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007079 channel_unref(varp->vval.v_channel);
7080 break;
7081#endif
Bram Moolenaar835dc632016-02-07 14:27:38 +01007082 case VAR_NUMBER:
7083 case VAR_FLOAT:
Bram Moolenaar758711c2005-02-02 23:11:38 +00007084 case VAR_UNKNOWN:
Bram Moolenaar6650a692016-01-26 19:59:10 +01007085 case VAR_SPECIAL:
Bram Moolenaar758711c2005-02-02 23:11:38 +00007086 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007087 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007088 vim_free(varp);
7089 }
7090}
7091
7092/*
7093 * Free the memory for a variable value and set the value to NULL or 0.
7094 */
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00007095 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007096clear_tv(typval_T *varp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007097{
7098 if (varp != NULL)
7099 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007100 switch (varp->v_type)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007101 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007102 case VAR_FUNC:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007103 func_unref(varp->vval.v_string);
Bram Moolenaar2f40d122017-10-24 21:49:36 +02007104 /* FALLTHROUGH */
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007105 case VAR_STRING:
Bram Moolenaard23a8232018-02-10 18:45:26 +01007106 VIM_CLEAR(varp->vval.v_string);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007107 break;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007108 case VAR_PARTIAL:
7109 partial_unref(varp->vval.v_partial);
7110 varp->vval.v_partial = NULL;
7111 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007112 case VAR_LIST:
7113 list_unref(varp->vval.v_list);
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00007114 varp->vval.v_list = NULL;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007115 break;
Bram Moolenaar8c711452005-01-14 21:53:12 +00007116 case VAR_DICT:
7117 dict_unref(varp->vval.v_dict);
Bram Moolenaarce5e58e2005-01-19 22:24:34 +00007118 varp->vval.v_dict = NULL;
Bram Moolenaar8c711452005-01-14 21:53:12 +00007119 break;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007120 case VAR_NUMBER:
Bram Moolenaar520e1e42016-01-23 19:46:28 +01007121 case VAR_SPECIAL:
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007122 varp->vval.v_number = 0;
7123 break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007124 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01007125#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007126 varp->vval.v_float = 0.0;
7127 break;
7128#endif
Bram Moolenaar835dc632016-02-07 14:27:38 +01007129 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007130#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007131 job_unref(varp->vval.v_job);
7132 varp->vval.v_job = NULL;
7133#endif
7134 break;
Bram Moolenaar77073442016-02-13 23:23:53 +01007135 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007136#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007137 channel_unref(varp->vval.v_channel);
7138 varp->vval.v_channel = NULL;
7139#endif
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007140 case VAR_UNKNOWN:
7141 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007142 }
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007143 varp->v_lock = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007144 }
7145}
7146
7147/*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007148 * Set the value of a variable to NULL without freeing items.
7149 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007150 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007151init_tv(typval_T *varp)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007152{
7153 if (varp != NULL)
Bram Moolenaar33570922005-01-25 22:26:29 +00007154 vim_memset(varp, 0, sizeof(typval_T));
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007155}
7156
7157/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00007158 * Get the number value of a variable.
7159 * If it is a String variable, uses vim_str2nr().
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007160 * For incompatible types, return 0.
7161 * get_tv_number_chk() is similar to get_tv_number(), but informs the
7162 * caller of incompatible types: it sets *denote to TRUE if "denote"
7163 * is not NULL or returns -1 otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007164 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02007165 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01007166get_tv_number(typval_T *varp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007167{
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007168 int error = FALSE;
7169
7170 return get_tv_number_chk(varp, &error); /* return 0L on error */
7171}
7172
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02007173 varnumber_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01007174get_tv_number_chk(typval_T *varp, int *denote)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007175{
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02007176 varnumber_T n = 0L;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007177
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007178 switch (varp->v_type)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007179 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007180 case VAR_NUMBER:
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02007181 return varp->vval.v_number;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007182 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01007183#ifdef FEAT_FLOAT
Bram Moolenaared0e7452008-06-27 19:17:34 +00007184 EMSG(_("E805: Using a Float as a Number"));
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007185 break;
7186#endif
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007187 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007188 case VAR_PARTIAL:
Bram Moolenaared0e7452008-06-27 19:17:34 +00007189 EMSG(_("E703: Using a Funcref as a Number"));
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007190 break;
7191 case VAR_STRING:
7192 if (varp->vval.v_string != NULL)
7193 vim_str2nr(varp->vval.v_string, NULL, NULL,
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01007194 STR2NR_ALL, &n, NULL, 0);
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007195 return n;
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00007196 case VAR_LIST:
Bram Moolenaared0e7452008-06-27 19:17:34 +00007197 EMSG(_("E745: Using a List as a Number"));
Bram Moolenaar31c67ef2005-01-11 21:34:41 +00007198 break;
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007199 case VAR_DICT:
Bram Moolenaared0e7452008-06-27 19:17:34 +00007200 EMSG(_("E728: Using a Dictionary as a Number"));
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007201 break;
Bram Moolenaar17a13432016-01-24 14:22:10 +01007202 case VAR_SPECIAL:
7203 return varp->vval.v_number == VVAL_TRUE ? 1 : 0;
7204 break;
Bram Moolenaar835dc632016-02-07 14:27:38 +01007205 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007206#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007207 EMSG(_("E910: Using a Job as a Number"));
7208 break;
7209#endif
Bram Moolenaar77073442016-02-13 23:23:53 +01007210 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007211#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007212 EMSG(_("E913: Using a Channel as a Number"));
7213 break;
7214#endif
Bram Moolenaara03f2332016-02-06 18:09:59 +01007215 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +01007216 internal_error("get_tv_number(UNKNOWN)");
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007217 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007218 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007219 if (denote == NULL) /* useful for values that must be unsigned */
7220 n = -1;
7221 else
7222 *denote = TRUE;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007223 return n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007224}
7225
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007226#ifdef FEAT_FLOAT
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007227 float_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01007228get_tv_float(typval_T *varp)
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007229{
7230 switch (varp->v_type)
7231 {
7232 case VAR_NUMBER:
7233 return (float_T)(varp->vval.v_number);
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007234 case VAR_FLOAT:
7235 return varp->vval.v_float;
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007236 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007237 case VAR_PARTIAL:
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007238 EMSG(_("E891: Using a Funcref as a Float"));
7239 break;
7240 case VAR_STRING:
7241 EMSG(_("E892: Using a String as a Float"));
7242 break;
7243 case VAR_LIST:
7244 EMSG(_("E893: Using a List as a Float"));
7245 break;
7246 case VAR_DICT:
7247 EMSG(_("E894: Using a Dictionary as a Float"));
7248 break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01007249 case VAR_SPECIAL:
7250 EMSG(_("E907: Using a special value as a Float"));
7251 break;
Bram Moolenaar835dc632016-02-07 14:27:38 +01007252 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007253# ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007254 EMSG(_("E911: Using a Job as a Float"));
7255 break;
7256# endif
Bram Moolenaar77073442016-02-13 23:23:53 +01007257 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007258# ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007259 EMSG(_("E914: Using a Channel as a Float"));
7260 break;
7261# endif
Bram Moolenaara03f2332016-02-06 18:09:59 +01007262 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +01007263 internal_error("get_tv_float(UNKNOWN)");
Bram Moolenaarf7edf402016-01-19 23:36:15 +01007264 break;
7265 }
7266 return 0;
7267}
7268#endif
7269
Bram Moolenaar071d4272004-06-13 20:20:40 +00007270/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00007271 * Get the string value of a variable.
7272 * If it is a Number variable, the number is converted into a string.
Bram Moolenaara7043832005-01-21 11:56:39 +00007273 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
7274 * get_tv_string_buf() uses a given buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007275 * If the String variable has never been set, return an empty string.
7276 * Never returns NULL;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007277 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
7278 * NULL on error.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007279 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01007280 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007281get_tv_string(typval_T *varp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007282{
7283 static char_u mybuf[NUMBUFLEN];
7284
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007285 return get_tv_string_buf(varp, mybuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007286}
7287
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01007288 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007289get_tv_string_buf(typval_T *varp, char_u *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007290{
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007291 char_u *res = get_tv_string_buf_chk(varp, buf);
7292
7293 return res != NULL ? res : (char_u *)"";
7294}
7295
Bram Moolenaar7d647822014-04-05 21:28:56 +02007296/*
7297 * Careful: This uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
7298 */
Bram Moolenaar4be06f92005-07-29 22:36:03 +00007299 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007300get_tv_string_chk(typval_T *varp)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007301{
7302 static char_u mybuf[NUMBUFLEN];
7303
7304 return get_tv_string_buf_chk(varp, mybuf);
7305}
7306
Bram Moolenaar520e1e42016-01-23 19:46:28 +01007307 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007308get_tv_string_buf_chk(typval_T *varp, char_u *buf)
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007309{
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007310 switch (varp->v_type)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007311 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007312 case VAR_NUMBER:
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02007313 vim_snprintf((char *)buf, NUMBUFLEN, "%lld",
7314 (varnumber_T)varp->vval.v_number);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007315 return buf;
7316 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007317 case VAR_PARTIAL:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007318 EMSG(_("E729: using Funcref as a String"));
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007319 break;
7320 case VAR_LIST:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007321 EMSG(_("E730: using List as a String"));
Bram Moolenaar8c711452005-01-14 21:53:12 +00007322 break;
7323 case VAR_DICT:
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007324 EMSG(_("E731: using Dictionary as a String"));
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007325 break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007326 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01007327#ifdef FEAT_FLOAT
Bram Moolenaar2a876e42013-06-12 22:08:58 +02007328 EMSG(_(e_float_as_string));
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007329 break;
7330#endif
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007331 case VAR_STRING:
7332 if (varp->vval.v_string != NULL)
7333 return varp->vval.v_string;
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007334 return (char_u *)"";
Bram Moolenaar17a13432016-01-24 14:22:10 +01007335 case VAR_SPECIAL:
7336 STRCPY(buf, get_var_special_name(varp->vval.v_number));
7337 return buf;
Bram Moolenaar835dc632016-02-07 14:27:38 +01007338 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007339#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007340 {
7341 job_T *job = varp->vval.v_job;
Bram Moolenaar839fd112016-03-06 21:34:03 +01007342 char *status;
7343
7344 if (job == NULL)
7345 return (char_u *)"no process";
7346 status = job->jv_status == JOB_FAILED ? "fail"
Bram Moolenaar7df915d2016-11-17 17:25:32 +01007347 : job->jv_status >= JOB_ENDED ? "dead"
Bram Moolenaar835dc632016-02-07 14:27:38 +01007348 : "run";
7349# ifdef UNIX
7350 vim_snprintf((char *)buf, NUMBUFLEN,
7351 "process %ld %s", (long)job->jv_pid, status);
Bram Moolenaar4d8747c2016-02-09 20:39:26 +01007352# elif defined(WIN32)
7353 vim_snprintf((char *)buf, NUMBUFLEN,
Bram Moolenaar76467df2016-02-12 19:30:26 +01007354 "process %ld %s",
7355 (long)job->jv_proc_info.dwProcessId,
Bram Moolenaar4d8747c2016-02-09 20:39:26 +01007356 status);
Bram Moolenaar835dc632016-02-07 14:27:38 +01007357# else
Bram Moolenaar4d8747c2016-02-09 20:39:26 +01007358 /* fall-back */
Bram Moolenaar835dc632016-02-07 14:27:38 +01007359 vim_snprintf((char *)buf, NUMBUFLEN, "process ? %s", status);
7360# endif
7361 return buf;
7362 }
7363#endif
7364 break;
Bram Moolenaar77073442016-02-13 23:23:53 +01007365 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007366#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007367 {
7368 channel_T *channel = varp->vval.v_channel;
Bram Moolenaar0e77b762016-09-26 22:58:58 +02007369 char *status = channel_status(channel, -1);
Bram Moolenaar77073442016-02-13 23:23:53 +01007370
Bram Moolenaar5cefd402016-02-16 12:44:26 +01007371 if (channel == NULL)
7372 vim_snprintf((char *)buf, NUMBUFLEN, "channel %s", status);
7373 else
7374 vim_snprintf((char *)buf, NUMBUFLEN,
Bram Moolenaar77073442016-02-13 23:23:53 +01007375 "channel %d %s", channel->ch_id, status);
7376 return buf;
7377 }
7378#endif
7379 break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01007380 case VAR_UNKNOWN:
7381 EMSG(_("E908: using an invalid value as a String"));
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007382 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007383 }
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00007384 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007385}
7386
7387/*
7388 * Find variable "name" in the list of variables.
7389 * Return a pointer to it if found, NULL if not found.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007390 * Careful: "a:0" variables don't have a name.
Bram Moolenaara7043832005-01-21 11:56:39 +00007391 * When "htp" is not NULL we are writing to the variable, set "htp" to the
Bram Moolenaar33570922005-01-25 22:26:29 +00007392 * hashtab_T used.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007393 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007394 dictitem_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007395find_var(char_u *name, hashtab_T **htp, int no_autoload)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007396{
Bram Moolenaar071d4272004-06-13 20:20:40 +00007397 char_u *varname;
Bram Moolenaar33570922005-01-25 22:26:29 +00007398 hashtab_T *ht;
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02007399 dictitem_T *ret = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007400
Bram Moolenaara7043832005-01-21 11:56:39 +00007401 ht = find_var_ht(name, &varname);
7402 if (htp != NULL)
7403 *htp = ht;
7404 if (ht == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007405 return NULL;
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02007406 ret = find_var_in_ht(ht, *name, varname, no_autoload || htp != NULL);
7407 if (ret != NULL)
7408 return ret;
7409
7410 /* Search in parent scope for lambda */
Bram Moolenaarba96e9a2016-08-01 17:10:20 +02007411 return find_var_in_scoped_ht(name, no_autoload || htp != NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007412}
7413
7414/*
Bram Moolenaar332ac062013-04-15 13:06:21 +02007415 * Find variable "varname" in hashtab "ht" with name "htname".
Bram Moolenaara7043832005-01-21 11:56:39 +00007416 * Returns NULL if not found.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007417 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007418 dictitem_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007419find_var_in_ht(
7420 hashtab_T *ht,
7421 int htname,
7422 char_u *varname,
7423 int no_autoload)
Bram Moolenaara7043832005-01-21 11:56:39 +00007424{
Bram Moolenaar33570922005-01-25 22:26:29 +00007425 hashitem_T *hi;
7426
7427 if (*varname == NUL)
7428 {
7429 /* Must be something like "s:", otherwise "ht" would be NULL. */
Bram Moolenaar332ac062013-04-15 13:06:21 +02007430 switch (htname)
Bram Moolenaar33570922005-01-25 22:26:29 +00007431 {
Bram Moolenaar9577c3e2010-05-14 12:16:25 +02007432 case 's': return &SCRIPT_SV(current_SID)->sv_var;
Bram Moolenaar33570922005-01-25 22:26:29 +00007433 case 'g': return &globvars_var;
7434 case 'v': return &vimvars_var;
7435 case 'b': return &curbuf->b_bufvar;
7436 case 'w': return &curwin->w_winvar;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00007437 case 't': return &curtab->tp_winvar;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007438 case 'l': return get_funccal_local_var();
7439 case 'a': return get_funccal_args_var();
Bram Moolenaar33570922005-01-25 22:26:29 +00007440 }
7441 return NULL;
7442 }
Bram Moolenaara7043832005-01-21 11:56:39 +00007443
7444 hi = hash_find(ht, varname);
7445 if (HASHITEM_EMPTY(hi))
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00007446 {
7447 /* For global variables we may try auto-loading the script. If it
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00007448 * worked find the variable again. Don't auto-load a script if it was
7449 * loaded already, otherwise it would be loaded every time when
7450 * checking if a function name is a Funcref variable. */
Bram Moolenaar6d977d62014-01-14 15:24:39 +01007451 if (ht == &globvarht && !no_autoload)
Bram Moolenaar8000baf2011-11-30 15:19:28 +01007452 {
7453 /* Note: script_autoload() may make "hi" invalid. It must either
7454 * be obtained again or not used. */
7455 if (!script_autoload(varname, FALSE) || aborting())
7456 return NULL;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00007457 hi = hash_find(ht, varname);
Bram Moolenaar8000baf2011-11-30 15:19:28 +01007458 }
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00007459 if (HASHITEM_EMPTY(hi))
7460 return NULL;
7461 }
Bram Moolenaar33570922005-01-25 22:26:29 +00007462 return HI2DI(hi);
Bram Moolenaara7043832005-01-21 11:56:39 +00007463}
7464
7465/*
Bram Moolenaar33570922005-01-25 22:26:29 +00007466 * Find the hashtab used for a variable name.
Bram Moolenaar73627d02015-08-11 15:46:09 +02007467 * Return NULL if the name is not valid.
Bram Moolenaara7043832005-01-21 11:56:39 +00007468 * Set "varname" to the start of name without ':'.
7469 */
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02007470 hashtab_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007471find_var_ht(char_u *name, char_u **varname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007472{
Bram Moolenaar75c50c42005-06-04 22:06:24 +00007473 hashitem_T *hi;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007474 hashtab_T *ht;
Bram Moolenaar75c50c42005-06-04 22:06:24 +00007475
Bram Moolenaar73627d02015-08-11 15:46:09 +02007476 if (name[0] == NUL)
7477 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007478 if (name[1] != ':')
7479 {
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00007480 /* The name must not start with a colon or #. */
7481 if (name[0] == ':' || name[0] == AUTOLOAD_CHAR)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007482 return NULL;
7483 *varname = name;
Bram Moolenaar532c7802005-01-27 14:44:31 +00007484
7485 /* "version" is "v:version" in all scopes */
Bram Moolenaar75c50c42005-06-04 22:06:24 +00007486 hi = hash_find(&compat_hashtab, name);
7487 if (!HASHITEM_EMPTY(hi))
Bram Moolenaar532c7802005-01-27 14:44:31 +00007488 return &compat_hashtab;
7489
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007490 ht = get_funccal_local_ht();
7491 if (ht == NULL)
Bram Moolenaar33570922005-01-25 22:26:29 +00007492 return &globvarht; /* global variable */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007493 return ht; /* local variable */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007494 }
7495 *varname = name + 2;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00007496 if (*name == 'g') /* global variable */
7497 return &globvarht;
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00007498 /* There must be no ':' or '#' in the rest of the name, unless g: is used
7499 */
7500 if (vim_strchr(name + 2, ':') != NULL
7501 || vim_strchr(name + 2, AUTOLOAD_CHAR) != NULL)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00007502 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007503 if (*name == 'b') /* buffer variable */
Bram Moolenaar429fa852013-04-15 12:27:36 +02007504 return &curbuf->b_vars->dv_hashtab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007505 if (*name == 'w') /* window variable */
Bram Moolenaar429fa852013-04-15 12:27:36 +02007506 return &curwin->w_vars->dv_hashtab;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00007507 if (*name == 't') /* tab page variable */
Bram Moolenaar429fa852013-04-15 12:27:36 +02007508 return &curtab->tp_vars->dv_hashtab;
Bram Moolenaar33570922005-01-25 22:26:29 +00007509 if (*name == 'v') /* v: variable */
7510 return &vimvarht;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007511 if (*name == 'a') /* a: function argument */
7512 return get_funccal_args_ht();
7513 if (*name == 'l') /* l: local function variable */
7514 return get_funccal_local_ht();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007515 if (*name == 's' /* script variable */
7516 && current_SID > 0 && current_SID <= ga_scripts.ga_len)
7517 return &SCRIPT_VARS(current_SID);
7518 return NULL;
7519}
7520
7521/*
7522 * Get the string value of a (global/local) variable.
Bram Moolenaar1950c352010-06-06 15:21:10 +02007523 * Note: see get_tv_string() for how long the pointer remains valid.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007524 * Returns NULL when it doesn't exist.
7525 */
7526 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01007527get_var_value(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007528{
Bram Moolenaar33570922005-01-25 22:26:29 +00007529 dictitem_T *v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007530
Bram Moolenaar6d977d62014-01-14 15:24:39 +01007531 v = find_var(name, NULL, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007532 if (v == NULL)
7533 return NULL;
Bram Moolenaar33570922005-01-25 22:26:29 +00007534 return get_tv_string(&v->di_tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007535}
7536
7537/*
Bram Moolenaar33570922005-01-25 22:26:29 +00007538 * Allocate a new hashtab for a sourced script. It will be used while
Bram Moolenaar071d4272004-06-13 20:20:40 +00007539 * sourcing this script and when executing functions defined in the script.
7540 */
7541 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007542new_script_vars(scid_T id)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007543{
Bram Moolenaara7043832005-01-21 11:56:39 +00007544 int i;
Bram Moolenaar33570922005-01-25 22:26:29 +00007545 hashtab_T *ht;
7546 scriptvar_T *sv;
Bram Moolenaara7043832005-01-21 11:56:39 +00007547
Bram Moolenaar071d4272004-06-13 20:20:40 +00007548 if (ga_grow(&ga_scripts, (int)(id - ga_scripts.ga_len)) == OK)
7549 {
Bram Moolenaara7043832005-01-21 11:56:39 +00007550 /* Re-allocating ga_data means that an ht_array pointing to
7551 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
Bram Moolenaar33570922005-01-25 22:26:29 +00007552 * at its init value. Also reset "v_dict", it's always the same. */
Bram Moolenaara7043832005-01-21 11:56:39 +00007553 for (i = 1; i <= ga_scripts.ga_len; ++i)
7554 {
7555 ht = &SCRIPT_VARS(i);
7556 if (ht->ht_mask == HT_INIT_SIZE - 1)
7557 ht->ht_array = ht->ht_smallarray;
Bram Moolenaar9577c3e2010-05-14 12:16:25 +02007558 sv = SCRIPT_SV(i);
Bram Moolenaar33570922005-01-25 22:26:29 +00007559 sv->sv_var.di_tv.vval.v_dict = &sv->sv_dict;
Bram Moolenaara7043832005-01-21 11:56:39 +00007560 }
7561
Bram Moolenaar071d4272004-06-13 20:20:40 +00007562 while (ga_scripts.ga_len < id)
7563 {
Bram Moolenaar2c704a72010-06-03 21:17:25 +02007564 sv = SCRIPT_SV(ga_scripts.ga_len + 1) =
Bram Moolenaar9577c3e2010-05-14 12:16:25 +02007565 (scriptvar_T *)alloc_clear(sizeof(scriptvar_T));
Bram Moolenaarbdb62052012-07-16 17:31:53 +02007566 init_var_dict(&sv->sv_dict, &sv->sv_var, VAR_SCOPE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007567 ++ga_scripts.ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007568 }
7569 }
7570}
7571
7572/*
Bram Moolenaar33570922005-01-25 22:26:29 +00007573 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
7574 * point to it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007575 */
7576 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007577init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007578{
Bram Moolenaar33570922005-01-25 22:26:29 +00007579 hash_init(&dict->dv_hashtab);
Bram Moolenaared465602012-06-20 14:13:06 +02007580 dict->dv_lock = 0;
Bram Moolenaarbdb62052012-07-16 17:31:53 +02007581 dict->dv_scope = scope;
Bram Moolenaar8ba1bd22008-12-23 22:52:58 +00007582 dict->dv_refcount = DO_NOT_FREE_CNT;
Bram Moolenaarc0a6fac2009-05-24 11:40:58 +00007583 dict->dv_copyID = 0;
Bram Moolenaar33570922005-01-25 22:26:29 +00007584 dict_var->di_tv.vval.v_dict = dict;
7585 dict_var->di_tv.v_type = VAR_DICT;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007586 dict_var->di_tv.v_lock = VAR_FIXED;
Bram Moolenaar33570922005-01-25 22:26:29 +00007587 dict_var->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
7588 dict_var->di_key[0] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007589}
7590
7591/*
Bram Moolenaar429fa852013-04-15 12:27:36 +02007592 * Unreference a dictionary initialized by init_var_dict().
7593 */
7594 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007595unref_var_dict(dict_T *dict)
Bram Moolenaar429fa852013-04-15 12:27:36 +02007596{
7597 /* Now the dict needs to be freed if no one else is using it, go back to
7598 * normal reference counting. */
7599 dict->dv_refcount -= DO_NOT_FREE_CNT - 1;
7600 dict_unref(dict);
7601}
7602
7603/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00007604 * Clean up a list of internal variables.
Bram Moolenaar33570922005-01-25 22:26:29 +00007605 * Frees all allocated variables and the value they contain.
7606 * Clears hashtab "ht", does not free it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007607 */
7608 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007609vars_clear(hashtab_T *ht)
Bram Moolenaar33570922005-01-25 22:26:29 +00007610{
7611 vars_clear_ext(ht, TRUE);
7612}
7613
7614/*
7615 * Like vars_clear(), but only free the value if "free_val" is TRUE.
7616 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02007617 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007618vars_clear_ext(hashtab_T *ht, int free_val)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007619{
Bram Moolenaara7043832005-01-21 11:56:39 +00007620 int todo;
Bram Moolenaar33570922005-01-25 22:26:29 +00007621 hashitem_T *hi;
7622 dictitem_T *v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007623
Bram Moolenaar33570922005-01-25 22:26:29 +00007624 hash_lock(ht);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00007625 todo = (int)ht->ht_used;
Bram Moolenaara7043832005-01-21 11:56:39 +00007626 for (hi = ht->ht_array; todo > 0; ++hi)
7627 {
7628 if (!HASHITEM_EMPTY(hi))
7629 {
7630 --todo;
7631
Bram Moolenaar33570922005-01-25 22:26:29 +00007632 /* Free the variable. Don't remove it from the hashtab,
Bram Moolenaara7043832005-01-21 11:56:39 +00007633 * ht_array might change then. hash_clear() takes care of it
7634 * later. */
Bram Moolenaar33570922005-01-25 22:26:29 +00007635 v = HI2DI(hi);
7636 if (free_val)
7637 clear_tv(&v->di_tv);
Bram Moolenaar9bc174b2015-04-13 16:16:38 +02007638 if (v->di_flags & DI_FLAGS_ALLOC)
Bram Moolenaar33570922005-01-25 22:26:29 +00007639 vim_free(v);
Bram Moolenaara7043832005-01-21 11:56:39 +00007640 }
7641 }
7642 hash_clear(ht);
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00007643 ht->ht_used = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007644}
7645
Bram Moolenaara7043832005-01-21 11:56:39 +00007646/*
Bram Moolenaar33570922005-01-25 22:26:29 +00007647 * Delete a variable from hashtab "ht" at item "hi".
7648 * Clear the variable value and free the dictitem.
Bram Moolenaara7043832005-01-21 11:56:39 +00007649 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007650 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007651delete_var(hashtab_T *ht, hashitem_T *hi)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007652{
Bram Moolenaar33570922005-01-25 22:26:29 +00007653 dictitem_T *di = HI2DI(hi);
Bram Moolenaara7043832005-01-21 11:56:39 +00007654
7655 hash_remove(ht, hi);
Bram Moolenaar33570922005-01-25 22:26:29 +00007656 clear_tv(&di->di_tv);
7657 vim_free(di);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007658}
7659
7660/*
7661 * List the value of one internal variable.
7662 */
7663 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007664list_one_var(dictitem_T *v, char_u *prefix, int *first)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007665{
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007666 char_u *tofree;
7667 char_u *s;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00007668 char_u numbuf[NUMBUFLEN];
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007669
Bram Moolenaar520e1e42016-01-23 19:46:28 +01007670 s = echo_string(&v->di_tv, &tofree, numbuf, get_copyID());
Bram Moolenaar33570922005-01-25 22:26:29 +00007671 list_one_var_a(prefix, v->di_key, v->di_tv.v_type,
Bram Moolenaar7d61a922007-08-30 09:12:23 +00007672 s == NULL ? (char_u *)"" : s, first);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007673 vim_free(tofree);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007674}
7675
Bram Moolenaar071d4272004-06-13 20:20:40 +00007676 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007677list_one_var_a(
7678 char_u *prefix,
7679 char_u *name,
7680 int type,
7681 char_u *string,
7682 int *first) /* when TRUE clear rest of screen and set to FALSE */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007683{
Bram Moolenaar31859182007-08-14 20:41:13 +00007684 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
7685 msg_start();
7686 msg_puts(prefix);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007687 if (name != NULL) /* "a:" vars don't have a name stored */
7688 msg_puts(name);
7689 msg_putchar(' ');
7690 msg_advance(22);
7691 if (type == VAR_NUMBER)
7692 msg_putchar('#');
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007693 else if (type == VAR_FUNC || type == VAR_PARTIAL)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007694 msg_putchar('*');
7695 else if (type == VAR_LIST)
7696 {
7697 msg_putchar('[');
7698 if (*string == '[')
7699 ++string;
7700 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00007701 else if (type == VAR_DICT)
7702 {
7703 msg_putchar('{');
7704 if (*string == '{')
7705 ++string;
7706 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007707 else
7708 msg_putchar(' ');
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007709
Bram Moolenaar071d4272004-06-13 20:20:40 +00007710 msg_outtrans(string);
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007711
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007712 if (type == VAR_FUNC || type == VAR_PARTIAL)
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007713 msg_puts((char_u *)"()");
Bram Moolenaar7d61a922007-08-30 09:12:23 +00007714 if (*first)
7715 {
7716 msg_clr_eos();
7717 *first = FALSE;
7718 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007719}
7720
7721/*
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007722 * Set variable "name" to value in "tv".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007723 * If the variable already exists, the value is updated.
7724 * Otherwise the variable is created.
7725 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007726 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007727set_var(
7728 char_u *name,
7729 typval_T *tv,
7730 int copy) /* make copy of value in "tv" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007731{
Bram Moolenaar33570922005-01-25 22:26:29 +00007732 dictitem_T *v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007733 char_u *varname;
Bram Moolenaar33570922005-01-25 22:26:29 +00007734 hashtab_T *ht;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007735
Bram Moolenaarbaff0fe2010-03-17 19:53:49 +01007736 ht = find_var_ht(name, &varname);
7737 if (ht == NULL || *varname == NUL)
7738 {
7739 EMSG2(_(e_illvar), name);
7740 return;
7741 }
Bram Moolenaar332ac062013-04-15 13:06:21 +02007742 v = find_var_in_ht(ht, 0, varname, TRUE);
Bram Moolenaarbaff0fe2010-03-17 19:53:49 +01007743
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02007744 /* Search in parent scope which is possible to reference from lambda */
7745 if (v == NULL)
Bram Moolenaarba96e9a2016-08-01 17:10:20 +02007746 v = find_var_in_scoped_ht(name, TRUE);
Bram Moolenaar1e96d9b2016-07-29 22:15:09 +02007747
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007748 if ((tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
7749 && var_check_func_name(name, v == NULL))
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007750 return;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007751
Bram Moolenaar33570922005-01-25 22:26:29 +00007752 if (v != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007753 {
Bram Moolenaar33570922005-01-25 22:26:29 +00007754 /* existing variable, need to clear the value */
Bram Moolenaar77354e72015-04-21 16:49:05 +02007755 if (var_check_ro(v->di_flags, name, FALSE)
7756 || tv_check_lock(v->di_tv.v_lock, name, FALSE))
Bram Moolenaar33570922005-01-25 22:26:29 +00007757 return;
Bram Moolenaar33570922005-01-25 22:26:29 +00007758
7759 /*
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02007760 * Handle setting internal v: variables separately where needed to
7761 * prevent changing the type.
Bram Moolenaar33570922005-01-25 22:26:29 +00007762 */
7763 if (ht == &vimvarht)
7764 {
7765 if (v->di_tv.v_type == VAR_STRING)
7766 {
7767 vim_free(v->di_tv.vval.v_string);
7768 if (copy || tv->v_type != VAR_STRING)
7769 v->di_tv.vval.v_string = vim_strsave(get_tv_string(tv));
7770 else
7771 {
7772 /* Take over the string to avoid an extra alloc/free. */
7773 v->di_tv.vval.v_string = tv->vval.v_string;
7774 tv->vval.v_string = NULL;
7775 }
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02007776 return;
Bram Moolenaar33570922005-01-25 22:26:29 +00007777 }
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02007778 else if (v->di_tv.v_type == VAR_NUMBER)
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007779 {
Bram Moolenaar33570922005-01-25 22:26:29 +00007780 v->di_tv.vval.v_number = get_tv_number(tv);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007781 if (STRCMP(varname, "searchforward") == 0)
7782 set_search_direction(v->di_tv.vval.v_number ? '/' : '?');
Bram Moolenaar8050efa2013-11-08 04:30:20 +01007783#ifdef FEAT_SEARCH_EXTRA
7784 else if (STRCMP(varname, "hlsearch") == 0)
7785 {
7786 no_hlsearch = !v->di_tv.vval.v_number;
7787 redraw_all_later(SOME_VALID);
7788 }
7789#endif
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02007790 return;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007791 }
Bram Moolenaar1cd5e612015-05-04 11:10:27 +02007792 else if (v->di_tv.v_type != tv->v_type)
Bram Moolenaar95f09602016-11-10 20:01:45 +01007793 internal_error("set_var()");
Bram Moolenaar33570922005-01-25 22:26:29 +00007794 }
7795
7796 clear_tv(&v->di_tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007797 }
7798 else /* add a new variable */
7799 {
Bram Moolenaar5fcc3fe2006-06-22 15:35:14 +00007800 /* Can't add "v:" variable. */
7801 if (ht == &vimvarht)
7802 {
7803 EMSG2(_(e_illvar), name);
7804 return;
7805 }
7806
Bram Moolenaar92124a32005-06-17 22:03:40 +00007807 /* Make sure the variable name is valid. */
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007808 if (!valid_varname(varname))
7809 return;
Bram Moolenaar92124a32005-06-17 22:03:40 +00007810
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007811 v = (dictitem_T *)alloc((unsigned)(sizeof(dictitem_T)
7812 + STRLEN(varname)));
Bram Moolenaara7043832005-01-21 11:56:39 +00007813 if (v == NULL)
7814 return;
Bram Moolenaar33570922005-01-25 22:26:29 +00007815 STRCPY(v->di_key, varname);
Bram Moolenaar33570922005-01-25 22:26:29 +00007816 if (hash_add(ht, DI2HIKEY(v)) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007817 {
Bram Moolenaara7043832005-01-21 11:56:39 +00007818 vim_free(v);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007819 return;
7820 }
Bram Moolenaar9bc174b2015-04-13 16:16:38 +02007821 v->di_flags = DI_FLAGS_ALLOC;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007822 }
Bram Moolenaara7043832005-01-21 11:56:39 +00007823
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007824 if (copy || tv->v_type == VAR_NUMBER || tv->v_type == VAR_FLOAT)
Bram Moolenaar33570922005-01-25 22:26:29 +00007825 copy_tv(tv, &v->di_tv);
Bram Moolenaar1c2fda22005-01-02 11:43:19 +00007826 else
7827 {
Bram Moolenaar33570922005-01-25 22:26:29 +00007828 v->di_tv = *tv;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007829 v->di_tv.v_lock = 0;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00007830 init_tv(tv);
Bram Moolenaar1c2fda22005-01-02 11:43:19 +00007831 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007832}
7833
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007834/*
Bram Moolenaar4e957af2006-09-02 11:41:07 +00007835 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
Bram Moolenaar33570922005-01-25 22:26:29 +00007836 * Also give an error message.
7837 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02007838 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01007839var_check_ro(int flags, char_u *name, int use_gettext)
Bram Moolenaar33570922005-01-25 22:26:29 +00007840{
7841 if (flags & DI_FLAGS_RO)
7842 {
Bram Moolenaar77354e72015-04-21 16:49:05 +02007843 EMSG2(_(e_readonlyvar), use_gettext ? (char_u *)_(name) : name);
Bram Moolenaar33570922005-01-25 22:26:29 +00007844 return TRUE;
7845 }
7846 if ((flags & DI_FLAGS_RO_SBX) && sandbox)
7847 {
Bram Moolenaar77354e72015-04-21 16:49:05 +02007848 EMSG2(_(e_readonlysbx), use_gettext ? (char_u *)_(name) : name);
Bram Moolenaar33570922005-01-25 22:26:29 +00007849 return TRUE;
7850 }
7851 return FALSE;
7852}
7853
7854/*
Bram Moolenaar4e957af2006-09-02 11:41:07 +00007855 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
7856 * Also give an error message.
7857 */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02007858 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01007859var_check_fixed(int flags, char_u *name, int use_gettext)
Bram Moolenaar4e957af2006-09-02 11:41:07 +00007860{
7861 if (flags & DI_FLAGS_FIX)
7862 {
Bram Moolenaar77354e72015-04-21 16:49:05 +02007863 EMSG2(_("E795: Cannot delete variable %s"),
7864 use_gettext ? (char_u *)_(name) : name);
Bram Moolenaar4e957af2006-09-02 11:41:07 +00007865 return TRUE;
7866 }
7867 return FALSE;
7868}
7869
7870/*
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007871 * Check if a funcref is assigned to a valid variable name.
7872 * Return TRUE and give an error if not.
7873 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02007874 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01007875var_check_func_name(
7876 char_u *name, /* points to start of variable name */
7877 int new_var) /* TRUE when creating the variable */
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007878{
Bram Moolenaarcbc67722014-05-22 14:19:56 +02007879 /* Allow for w: b: s: and t:. */
7880 if (!(vim_strchr((char_u *)"wbst", name[0]) != NULL && name[1] == ':')
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007881 && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':')
7882 ? name[2] : name[0]))
7883 {
7884 EMSG2(_("E704: Funcref variable name must start with a capital: %s"),
7885 name);
7886 return TRUE;
7887 }
7888 /* Don't allow hiding a function. When "v" is not NULL we might be
7889 * assigning another function to the same var, the type is checked
7890 * below. */
Bram Moolenaarb54c3ff2016-07-31 14:11:58 +02007891 if (new_var && function_exists(name, FALSE))
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007892 {
7893 EMSG2(_("E705: Variable name conflicts with existing function: %s"),
7894 name);
7895 return TRUE;
7896 }
7897 return FALSE;
7898}
7899
7900/*
7901 * Check if a variable name is valid.
7902 * Return FALSE and give an error if not.
7903 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02007904 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01007905valid_varname(char_u *varname)
Bram Moolenaar4228bec2011-03-27 16:03:15 +02007906{
7907 char_u *p;
7908
7909 for (p = varname; *p != NUL; ++p)
7910 if (!eval_isnamec1(*p) && (p == varname || !VIM_ISDIGIT(*p))
7911 && *p != AUTOLOAD_CHAR)
7912 {
7913 EMSG2(_(e_illvar), varname);
7914 return FALSE;
7915 }
7916 return TRUE;
7917}
7918
7919/*
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007920 * Return TRUE if typeval "tv" is set to be locked (immutable).
Bram Moolenaar77354e72015-04-21 16:49:05 +02007921 * Also give an error message, using "name" or _("name") when use_gettext is
7922 * TRUE.
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007923 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02007924 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01007925tv_check_lock(int lock, char_u *name, int use_gettext)
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007926{
7927 if (lock & VAR_LOCKED)
7928 {
7929 EMSG2(_("E741: Value is locked: %s"),
Bram Moolenaar77354e72015-04-21 16:49:05 +02007930 name == NULL ? (char_u *)_("Unknown")
7931 : use_gettext ? (char_u *)_(name)
7932 : name);
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007933 return TRUE;
7934 }
7935 if (lock & VAR_FIXED)
7936 {
7937 EMSG2(_("E742: Cannot change value of %s"),
Bram Moolenaar77354e72015-04-21 16:49:05 +02007938 name == NULL ? (char_u *)_("Unknown")
7939 : use_gettext ? (char_u *)_(name)
7940 : name);
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007941 return TRUE;
7942 }
7943 return FALSE;
7944}
7945
7946/*
Bram Moolenaar33570922005-01-25 22:26:29 +00007947 * Copy the values from typval_T "from" to typval_T "to".
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007948 * When needed allocates string or increases reference count.
Bram Moolenaare9a41262005-01-15 22:18:47 +00007949 * Does not make a copy of a list or dict but copies the reference!
Bram Moolenaar8ba1bd22008-12-23 22:52:58 +00007950 * It is OK for "from" and "to" to point to the same item. This is used to
7951 * make a copy later.
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007952 */
Bram Moolenaar7e506b62010-01-19 15:55:06 +01007953 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01007954copy_tv(typval_T *from, typval_T *to)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007955{
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007956 to->v_type = from->v_type;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00007957 to->v_lock = 0;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007958 switch (from->v_type)
7959 {
7960 case VAR_NUMBER:
Bram Moolenaar520e1e42016-01-23 19:46:28 +01007961 case VAR_SPECIAL:
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007962 to->vval.v_number = from->vval.v_number;
7963 break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007964 case VAR_FLOAT:
Bram Moolenaar835dc632016-02-07 14:27:38 +01007965#ifdef FEAT_FLOAT
Bram Moolenaar8c8de832008-06-24 22:58:06 +00007966 to->vval.v_float = from->vval.v_float;
7967 break;
7968#endif
Bram Moolenaar835dc632016-02-07 14:27:38 +01007969 case VAR_JOB:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007970#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar835dc632016-02-07 14:27:38 +01007971 to->vval.v_job = from->vval.v_job;
Bram Moolenaaree1cffc2016-02-21 19:14:41 +01007972 if (to->vval.v_job != NULL)
7973 ++to->vval.v_job->jv_refcount;
Bram Moolenaar835dc632016-02-07 14:27:38 +01007974 break;
7975#endif
Bram Moolenaar77073442016-02-13 23:23:53 +01007976 case VAR_CHANNEL:
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01007977#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar77073442016-02-13 23:23:53 +01007978 to->vval.v_channel = from->vval.v_channel;
Bram Moolenaar5cefd402016-02-16 12:44:26 +01007979 if (to->vval.v_channel != NULL)
7980 ++to->vval.v_channel->ch_refcount;
Bram Moolenaar77073442016-02-13 23:23:53 +01007981 break;
7982#endif
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007983 case VAR_STRING:
7984 case VAR_FUNC:
7985 if (from->vval.v_string == NULL)
7986 to->vval.v_string = NULL;
7987 else
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007988 {
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007989 to->vval.v_string = vim_strsave(from->vval.v_string);
Bram Moolenaar9ef486d2005-01-17 22:23:00 +00007990 if (from->v_type == VAR_FUNC)
7991 func_ref(to->vval.v_string);
7992 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00007993 break;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01007994 case VAR_PARTIAL:
7995 if (from->vval.v_partial == NULL)
7996 to->vval.v_partial = NULL;
7997 else
7998 {
7999 to->vval.v_partial = from->vval.v_partial;
8000 ++to->vval.v_partial->pt_refcount;
8001 }
8002 break;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00008003 case VAR_LIST:
8004 if (from->vval.v_list == NULL)
8005 to->vval.v_list = NULL;
8006 else
8007 {
8008 to->vval.v_list = from->vval.v_list;
8009 ++to->vval.v_list->lv_refcount;
8010 }
8011 break;
Bram Moolenaar8c711452005-01-14 21:53:12 +00008012 case VAR_DICT:
8013 if (from->vval.v_dict == NULL)
8014 to->vval.v_dict = NULL;
8015 else
8016 {
8017 to->vval.v_dict = from->vval.v_dict;
8018 ++to->vval.v_dict->dv_refcount;
8019 }
8020 break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01008021 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +01008022 internal_error("copy_tv(UNKNOWN)");
Bram Moolenaar49cd9572005-01-03 21:06:01 +00008023 break;
8024 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008025}
8026
8027/*
Bram Moolenaare9a41262005-01-15 22:18:47 +00008028 * Make a copy of an item.
8029 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008030 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
8031 * reference to an already copied list/dict can be used.
8032 * Returns FAIL or OK.
Bram Moolenaare9a41262005-01-15 22:18:47 +00008033 */
Bram Moolenaarcd524592016-07-17 14:57:05 +02008034 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01008035item_copy(
8036 typval_T *from,
8037 typval_T *to,
8038 int deep,
8039 int copyID)
Bram Moolenaare9a41262005-01-15 22:18:47 +00008040{
8041 static int recurse = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008042 int ret = OK;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008043
Bram Moolenaar33570922005-01-25 22:26:29 +00008044 if (recurse >= DICT_MAXNEST)
Bram Moolenaare9a41262005-01-15 22:18:47 +00008045 {
8046 EMSG(_("E698: variable nested too deep for making a copy"));
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008047 return FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008048 }
8049 ++recurse;
8050
8051 switch (from->v_type)
8052 {
8053 case VAR_NUMBER:
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008054 case VAR_FLOAT:
Bram Moolenaare9a41262005-01-15 22:18:47 +00008055 case VAR_STRING:
8056 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01008057 case VAR_PARTIAL:
Bram Moolenaar15550002016-01-31 18:45:24 +01008058 case VAR_SPECIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01008059 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01008060 case VAR_CHANNEL:
Bram Moolenaare9a41262005-01-15 22:18:47 +00008061 copy_tv(from, to);
8062 break;
8063 case VAR_LIST:
8064 to->v_type = VAR_LIST;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00008065 to->v_lock = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008066 if (from->vval.v_list == NULL)
8067 to->vval.v_list = NULL;
8068 else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID)
8069 {
8070 /* use the copy made earlier */
8071 to->vval.v_list = from->vval.v_list->lv_copylist;
8072 ++to->vval.v_list->lv_refcount;
8073 }
8074 else
8075 to->vval.v_list = list_copy(from->vval.v_list, deep, copyID);
8076 if (to->vval.v_list == NULL)
8077 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008078 break;
8079 case VAR_DICT:
8080 to->v_type = VAR_DICT;
Bram Moolenaar2e6aff32005-01-31 19:25:36 +00008081 to->v_lock = 0;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008082 if (from->vval.v_dict == NULL)
8083 to->vval.v_dict = NULL;
8084 else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID)
8085 {
8086 /* use the copy made earlier */
8087 to->vval.v_dict = from->vval.v_dict->dv_copydict;
8088 ++to->vval.v_dict->dv_refcount;
8089 }
8090 else
8091 to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID);
8092 if (to->vval.v_dict == NULL)
8093 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008094 break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01008095 case VAR_UNKNOWN:
Bram Moolenaar95f09602016-11-10 20:01:45 +01008096 internal_error("item_copy(UNKNOWN)");
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008097 ret = FAIL;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008098 }
8099 --recurse;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008100 return ret;
Bram Moolenaare9a41262005-01-15 22:18:47 +00008101}
8102
8103/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008104 * This function is used by f_input() and f_inputdialog() functions. The third
8105 * argument to f_input() specifies the type of completion to use at the
8106 * prompt. The third argument to f_inputdialog() specifies the value to return
8107 * when the user cancels the prompt.
8108 */
8109 void
8110get_user_input(
8111 typval_T *argvars,
8112 typval_T *rettv,
8113 int inputdialog,
8114 int secret)
8115{
8116 char_u *prompt = get_tv_string_chk(&argvars[0]);
8117 char_u *p = NULL;
8118 int c;
8119 char_u buf[NUMBUFLEN];
8120 int cmd_silent_save = cmd_silent;
8121 char_u *defstr = (char_u *)"";
8122 int xp_type = EXPAND_NOTHING;
8123 char_u *xp_arg = NULL;
8124
8125 rettv->v_type = VAR_STRING;
8126 rettv->vval.v_string = NULL;
8127
8128#ifdef NO_CONSOLE_INPUT
Bram Moolenaar91d348a2017-07-29 20:16:03 +02008129 /* While starting up, there is no place to enter text. When running tests
8130 * with --not-a-term we assume feedkeys() will be used. */
8131 if (no_console_input() && !is_not_a_term())
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008132 return;
8133#endif
8134
8135 cmd_silent = FALSE; /* Want to see the prompt. */
8136 if (prompt != NULL)
8137 {
8138 /* Only the part of the message after the last NL is considered as
8139 * prompt for the command line */
8140 p = vim_strrchr(prompt, '\n');
8141 if (p == NULL)
8142 p = prompt;
8143 else
8144 {
8145 ++p;
8146 c = *p;
8147 *p = NUL;
8148 msg_start();
8149 msg_clr_eos();
8150 msg_puts_attr(prompt, echo_attr);
8151 msg_didout = FALSE;
8152 msg_starthere();
8153 *p = c;
8154 }
8155 cmdline_row = msg_row;
8156
8157 if (argvars[1].v_type != VAR_UNKNOWN)
8158 {
8159 defstr = get_tv_string_buf_chk(&argvars[1], buf);
8160 if (defstr != NULL)
8161 stuffReadbuffSpec(defstr);
8162
8163 if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN)
8164 {
8165 char_u *xp_name;
8166 int xp_namelen;
8167 long argt;
8168
8169 /* input() with a third argument: completion */
8170 rettv->vval.v_string = NULL;
8171
8172 xp_name = get_tv_string_buf_chk(&argvars[2], buf);
8173 if (xp_name == NULL)
8174 return;
8175
8176 xp_namelen = (int)STRLEN(xp_name);
8177
8178 if (parse_compl_arg(xp_name, xp_namelen, &xp_type, &argt,
8179 &xp_arg) == FAIL)
8180 return;
8181 }
8182 }
8183
8184 if (defstr != NULL)
8185 {
8186 int save_ex_normal_busy = ex_normal_busy;
8187 ex_normal_busy = 0;
8188 rettv->vval.v_string =
8189 getcmdline_prompt(secret ? NUL : '@', p, echo_attr,
8190 xp_type, xp_arg);
8191 ex_normal_busy = save_ex_normal_busy;
8192 }
8193 if (inputdialog && rettv->vval.v_string == NULL
8194 && argvars[1].v_type != VAR_UNKNOWN
8195 && argvars[2].v_type != VAR_UNKNOWN)
8196 rettv->vval.v_string = vim_strsave(get_tv_string_buf(
8197 &argvars[2], buf));
8198
8199 vim_free(xp_arg);
8200
8201 /* since the user typed this, no need to wait for return */
8202 need_wait_return = FALSE;
8203 msg_didout = FALSE;
8204 }
8205 cmd_silent = cmd_silent_save;
8206}
8207
8208/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008209 * ":echo expr1 ..." print each argument separated with a space, add a
8210 * newline at the end.
8211 * ":echon expr1 ..." print each argument plain.
8212 */
8213 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008214ex_echo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008215{
8216 char_u *arg = eap->arg;
Bram Moolenaar33570922005-01-25 22:26:29 +00008217 typval_T rettv;
Bram Moolenaar49cd9572005-01-03 21:06:01 +00008218 char_u *tofree;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008219 char_u *p;
8220 int needclr = TRUE;
8221 int atstart = TRUE;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00008222 char_u numbuf[NUMBUFLEN];
Bram Moolenaar071d4272004-06-13 20:20:40 +00008223
8224 if (eap->skip)
8225 ++emsg_skip;
8226 while (*arg != NUL && *arg != '|' && *arg != '\n' && !got_int)
8227 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008228 /* If eval1() causes an error message the text from the command may
8229 * still need to be cleared. E.g., "echo 22,44". */
8230 need_clr_eos = needclr;
8231
Bram Moolenaar071d4272004-06-13 20:20:40 +00008232 p = arg;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008233 if (eval1(&arg, &rettv, !eap->skip) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008234 {
8235 /*
8236 * Report the invalid expression unless the expression evaluation
8237 * has been cancelled due to an aborting error, an interrupt, or an
8238 * exception.
8239 */
8240 if (!aborting())
8241 EMSG2(_(e_invexpr2), p);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008242 need_clr_eos = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008243 break;
8244 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008245 need_clr_eos = FALSE;
8246
Bram Moolenaar071d4272004-06-13 20:20:40 +00008247 if (!eap->skip)
8248 {
8249 if (atstart)
8250 {
8251 atstart = FALSE;
8252 /* Call msg_start() after eval1(), evaluating the expression
8253 * may cause a message to appear. */
8254 if (eap->cmdidx == CMD_echo)
Bram Moolenaar12b02902012-03-23 15:18:24 +01008255 {
Bram Moolenaar6df5e5a2012-03-28 16:49:29 +02008256 /* Mark the saved text as finishing the line, so that what
8257 * follows is displayed on a new line when scrolling back
8258 * at the more prompt. */
8259 msg_sb_eol();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008260 msg_start();
Bram Moolenaar12b02902012-03-23 15:18:24 +01008261 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008262 }
8263 else if (eap->cmdidx == CMD_echo)
8264 msg_puts_attr((char_u *)" ", echo_attr);
Bram Moolenaar520e1e42016-01-23 19:46:28 +01008265 p = echo_string(&rettv, &tofree, numbuf, get_copyID());
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008266 if (p != NULL)
8267 for ( ; *p != NUL && !got_int; ++p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008268 {
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008269 if (*p == '\n' || *p == '\r' || *p == TAB)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008270 {
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008271 if (*p != TAB && needclr)
8272 {
8273 /* remove any text still there from the command */
8274 msg_clr_eos();
8275 needclr = FALSE;
8276 }
8277 msg_putchar_attr(*p, echo_attr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008278 }
8279 else
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008280 {
8281#ifdef FEAT_MBYTE
8282 if (has_mbyte)
8283 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00008284 int i = (*mb_ptr2len)(p);
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008285
8286 (void)msg_outtrans_len_attr(p, i, echo_attr);
8287 p += i - 1;
8288 }
8289 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00008290#endif
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008291 (void)msg_outtrans_len_attr(p, 1, echo_attr);
8292 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008293 }
Bram Moolenaar49cd9572005-01-03 21:06:01 +00008294 vim_free(tofree);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008295 }
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008296 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008297 arg = skipwhite(arg);
8298 }
8299 eap->nextcmd = check_nextcmd(arg);
8300
8301 if (eap->skip)
8302 --emsg_skip;
8303 else
8304 {
8305 /* remove text that may still be there from the command */
8306 if (needclr)
8307 msg_clr_eos();
8308 if (eap->cmdidx == CMD_echo)
8309 msg_end();
8310 }
8311}
8312
8313/*
8314 * ":echohl {name}".
8315 */
8316 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008317ex_echohl(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008318{
Bram Moolenaar1b9645d2017-09-17 23:03:31 +02008319 echo_attr = syn_name2attr(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008320}
8321
8322/*
8323 * ":execute expr1 ..." execute the result of an expression.
8324 * ":echomsg expr1 ..." Print a message
8325 * ":echoerr expr1 ..." Print an error
8326 * Each gets spaces around each argument and a newline at the end for
8327 * echo commands
8328 */
8329 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008330ex_execute(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008331{
8332 char_u *arg = eap->arg;
Bram Moolenaar33570922005-01-25 22:26:29 +00008333 typval_T rettv;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008334 int ret = OK;
8335 char_u *p;
8336 garray_T ga;
8337 int len;
8338 int save_did_emsg;
8339
8340 ga_init2(&ga, 1, 80);
8341
8342 if (eap->skip)
8343 ++emsg_skip;
8344 while (*arg != NUL && *arg != '|' && *arg != '\n')
8345 {
8346 p = arg;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008347 if (eval1(&arg, &rettv, !eap->skip) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008348 {
8349 /*
8350 * Report the invalid expression unless the expression evaluation
8351 * has been cancelled due to an aborting error, an interrupt, or an
8352 * exception.
8353 */
8354 if (!aborting())
8355 EMSG2(_(e_invexpr2), p);
8356 ret = FAIL;
8357 break;
8358 }
8359
8360 if (!eap->skip)
8361 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008362 p = get_tv_string(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008363 len = (int)STRLEN(p);
8364 if (ga_grow(&ga, len + 2) == FAIL)
8365 {
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008366 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008367 ret = FAIL;
8368 break;
8369 }
8370 if (ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008371 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' ';
Bram Moolenaar071d4272004-06-13 20:20:40 +00008372 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008373 ga.ga_len += len;
8374 }
8375
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008376 clear_tv(&rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008377 arg = skipwhite(arg);
8378 }
8379
8380 if (ret != FAIL && ga.ga_data != NULL)
8381 {
Bram Moolenaar57002ad2017-03-16 19:04:19 +01008382 if (eap->cmdidx == CMD_echomsg || eap->cmdidx == CMD_echoerr)
8383 {
8384 /* Mark the already saved text as finishing the line, so that what
8385 * follows is displayed on a new line when scrolling back at the
8386 * more prompt. */
8387 msg_sb_eol();
Bram Moolenaar57002ad2017-03-16 19:04:19 +01008388 }
8389
Bram Moolenaar071d4272004-06-13 20:20:40 +00008390 if (eap->cmdidx == CMD_echomsg)
Bram Moolenaar4770d092006-01-12 23:22:24 +00008391 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00008392 MSG_ATTR(ga.ga_data, echo_attr);
Bram Moolenaar4770d092006-01-12 23:22:24 +00008393 out_flush();
8394 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008395 else if (eap->cmdidx == CMD_echoerr)
8396 {
8397 /* We don't want to abort following commands, restore did_emsg. */
8398 save_did_emsg = did_emsg;
8399 EMSG((char_u *)ga.ga_data);
8400 if (!force_abort)
8401 did_emsg = save_did_emsg;
8402 }
8403 else if (eap->cmdidx == CMD_execute)
8404 do_cmdline((char_u *)ga.ga_data,
8405 eap->getline, eap->cookie, DOCMD_NOWAIT|DOCMD_VERBOSE);
8406 }
8407
8408 ga_clear(&ga);
8409
8410 if (eap->skip)
8411 --emsg_skip;
8412
8413 eap->nextcmd = check_nextcmd(arg);
8414}
8415
8416/*
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008417 * Find window specified by "vp" in tabpage "tp".
8418 */
8419 win_T *
8420find_win_by_nr(
8421 typval_T *vp,
8422 tabpage_T *tp UNUSED) /* NULL for current tab page */
8423{
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008424 win_T *wp;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008425 int nr;
8426
8427 nr = (int)get_tv_number_chk(vp, NULL);
8428
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008429 if (nr < 0)
8430 return NULL;
8431 if (nr == 0)
8432 return curwin;
8433
Bram Moolenaar29323592016-07-24 22:04:11 +02008434 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
8435 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008436 if (nr >= LOWEST_WIN_ID)
8437 {
8438 if (wp->w_id == nr)
8439 return wp;
8440 }
8441 else if (--nr <= 0)
8442 break;
Bram Moolenaar29323592016-07-24 22:04:11 +02008443 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008444 if (nr >= LOWEST_WIN_ID)
8445 return NULL;
8446 return wp;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008447}
8448
8449/*
8450 * Find window specified by "wvp" in tabpage "tvp".
8451 */
8452 win_T *
8453find_tabwin(
8454 typval_T *wvp, /* VAR_UNKNOWN for current window */
8455 typval_T *tvp) /* VAR_UNKNOWN for current tab page */
8456{
8457 win_T *wp = NULL;
8458 tabpage_T *tp = NULL;
8459 long n;
8460
8461 if (wvp->v_type != VAR_UNKNOWN)
8462 {
8463 if (tvp->v_type != VAR_UNKNOWN)
8464 {
8465 n = (long)get_tv_number(tvp);
8466 if (n >= 0)
8467 tp = find_tabpage(n);
8468 }
8469 else
8470 tp = curtab;
8471
8472 if (tp != NULL)
8473 wp = find_win_by_nr(wvp, tp);
8474 }
8475 else
8476 wp = curwin;
8477
8478 return wp;
8479}
8480
8481/*
8482 * getwinvar() and gettabwinvar()
8483 */
8484 void
8485getwinvar(
8486 typval_T *argvars,
8487 typval_T *rettv,
8488 int off) /* 1 for gettabwinvar() */
8489{
8490 win_T *win;
8491 char_u *varname;
8492 dictitem_T *v;
8493 tabpage_T *tp = NULL;
8494 int done = FALSE;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008495 win_T *oldcurwin;
8496 tabpage_T *oldtabpage;
8497 int need_switch_win;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008498
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008499 if (off == 1)
8500 tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL));
8501 else
8502 tp = curtab;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008503 win = find_win_by_nr(&argvars[off], tp);
8504 varname = get_tv_string_chk(&argvars[off + 1]);
8505 ++emsg_off;
8506
8507 rettv->v_type = VAR_STRING;
8508 rettv->vval.v_string = NULL;
8509
8510 if (win != NULL && varname != NULL)
8511 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008512 /* Set curwin to be our win, temporarily. Also set the tabpage,
8513 * otherwise the window is not valid. Only do this when needed,
8514 * autocommands get blocked. */
8515 need_switch_win = !(tp == curtab && win == curwin);
8516 if (!need_switch_win
8517 || switch_win(&oldcurwin, &oldtabpage, win, tp, TRUE) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008518 {
Bram Moolenaar30567352016-08-27 21:25:44 +02008519 if (*varname == '&')
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008520 {
Bram Moolenaar30567352016-08-27 21:25:44 +02008521 if (varname[1] == NUL)
8522 {
8523 /* get all window-local options in a dict */
8524 dict_T *opts = get_winbuf_options(FALSE);
8525
8526 if (opts != NULL)
8527 {
Bram Moolenaar45cf6e92017-04-30 20:25:19 +02008528 rettv_dict_set(rettv, opts);
Bram Moolenaar30567352016-08-27 21:25:44 +02008529 done = TRUE;
8530 }
8531 }
8532 else if (get_option_tv(&varname, rettv, 1) == OK)
8533 /* window-local-option */
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008534 done = TRUE;
8535 }
8536 else
8537 {
8538 /* Look up the variable. */
8539 /* Let getwinvar({nr}, "") return the "w:" dictionary. */
8540 v = find_var_in_ht(&win->w_vars->dv_hashtab, 'w',
8541 varname, FALSE);
8542 if (v != NULL)
8543 {
8544 copy_tv(&v->di_tv, rettv);
8545 done = TRUE;
8546 }
8547 }
8548 }
8549
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008550 if (need_switch_win)
8551 /* restore previous notion of curwin */
8552 restore_win(oldcurwin, oldtabpage, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008553 }
8554
8555 if (!done && argvars[off + 2].v_type != VAR_UNKNOWN)
8556 /* use the default return value */
8557 copy_tv(&argvars[off + 2], rettv);
8558
8559 --emsg_off;
8560}
8561
8562/*
8563 * "setwinvar()" and "settabwinvar()" functions
8564 */
8565 void
8566setwinvar(typval_T *argvars, typval_T *rettv UNUSED, int off)
8567{
8568 win_T *win;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008569 win_T *save_curwin;
8570 tabpage_T *save_curtab;
8571 int need_switch_win;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008572 char_u *varname, *winvarname;
8573 typval_T *varp;
8574 char_u nbuf[NUMBUFLEN];
8575 tabpage_T *tp = NULL;
8576
8577 if (check_restricted() || check_secure())
8578 return;
8579
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008580 if (off == 1)
8581 tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL));
8582 else
8583 tp = curtab;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008584 win = find_win_by_nr(&argvars[off], tp);
8585 varname = get_tv_string_chk(&argvars[off + 1]);
8586 varp = &argvars[off + 2];
8587
8588 if (win != NULL && varname != NULL && varp != NULL)
8589 {
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008590 need_switch_win = !(tp == curtab && win == curwin);
8591 if (!need_switch_win
8592 || switch_win(&save_curwin, &save_curtab, win, tp, TRUE) == OK)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008593 {
8594 if (*varname == '&')
8595 {
8596 long numval;
8597 char_u *strval;
8598 int error = FALSE;
8599
8600 ++varname;
8601 numval = (long)get_tv_number_chk(varp, &error);
8602 strval = get_tv_string_buf_chk(varp, nbuf);
8603 if (!error && strval != NULL)
8604 set_option_value(varname, numval, strval, OPT_LOCAL);
8605 }
8606 else
8607 {
8608 winvarname = alloc((unsigned)STRLEN(varname) + 3);
8609 if (winvarname != NULL)
8610 {
8611 STRCPY(winvarname, "w:");
8612 STRCPY(winvarname + 2, varname);
8613 set_var(winvarname, varp, TRUE);
8614 vim_free(winvarname);
8615 }
8616 }
8617 }
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008618 if (need_switch_win)
8619 restore_win(save_curwin, save_curtab, TRUE);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008620 }
8621}
8622
8623/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008624 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
8625 * "arg" points to the "&" or '+' when called, to "option" when returning.
8626 * Returns NULL when no option name found. Otherwise pointer to the char
8627 * after the option name.
8628 */
8629 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01008630find_option_end(char_u **arg, int *opt_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008631{
8632 char_u *p = *arg;
8633
8634 ++p;
8635 if (*p == 'g' && p[1] == ':')
8636 {
8637 *opt_flags = OPT_GLOBAL;
8638 p += 2;
8639 }
8640 else if (*p == 'l' && p[1] == ':')
8641 {
8642 *opt_flags = OPT_LOCAL;
8643 p += 2;
8644 }
8645 else
8646 *opt_flags = 0;
8647
8648 if (!ASCII_ISALPHA(*p))
8649 return NULL;
8650 *arg = p;
8651
8652 if (p[0] == 't' && p[1] == '_' && p[2] != NUL && p[3] != NUL)
8653 p += 4; /* termcap option */
8654 else
8655 while (ASCII_ISALPHA(*p))
8656 ++p;
8657 return p;
8658}
8659
8660/*
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008661 * Return the autoload script name for a function or variable name.
8662 * Returns NULL when out of memory.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008663 */
Bram Moolenaara1544c02013-05-30 12:35:52 +02008664 char_u *
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008665autoload_name(char_u *name)
Bram Moolenaara1544c02013-05-30 12:35:52 +02008666{
Bram Moolenaara1544c02013-05-30 12:35:52 +02008667 char_u *p;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008668 char_u *scriptname;
Bram Moolenaara1544c02013-05-30 12:35:52 +02008669
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008670 /* Get the script file name: replace '#' with '/', append ".vim". */
8671 scriptname = alloc((unsigned)(STRLEN(name) + 14));
8672 if (scriptname == NULL)
Bram Moolenaar9bdfb002014-04-23 17:43:42 +02008673 return FALSE;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008674 STRCPY(scriptname, "autoload/");
8675 STRCAT(scriptname, name);
8676 *vim_strrchr(scriptname, AUTOLOAD_CHAR) = NUL;
8677 STRCAT(scriptname, ".vim");
8678 while ((p = vim_strchr(scriptname, AUTOLOAD_CHAR)) != NULL)
8679 *p = '/';
8680 return scriptname;
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008681}
8682
8683/*
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00008684 * If "name" has a package name try autoloading the script for it.
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008685 * Return TRUE if a package was loaded.
8686 */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008687 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01008688script_autoload(
8689 char_u *name,
8690 int reload) /* load script again when already loaded */
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008691{
8692 char_u *p;
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008693 char_u *scriptname, *tofree;
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008694 int ret = FALSE;
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008695 int i;
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008696
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008697 /* If there is no '#' after name[0] there is no package name. */
Bram Moolenaar34cdc3e2005-05-18 22:24:46 +00008698 p = vim_strchr(name, AUTOLOAD_CHAR);
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008699 if (p == NULL || p == name)
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00008700 return FALSE;
8701
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008702 tofree = scriptname = autoload_name(name);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00008703
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008704 /* Find the name in the list of previously loaded package names. Skip
8705 * "autoload/", it's always the same. */
8706 for (i = 0; i < ga_loaded.ga_len; ++i)
8707 if (STRCMP(((char_u **)ga_loaded.ga_data)[i] + 9, scriptname + 9) == 0)
8708 break;
8709 if (!reload && i < ga_loaded.ga_len)
8710 ret = FALSE; /* was loaded already */
8711 else
8712 {
8713 /* Remember the name if it wasn't loaded already. */
8714 if (i == ga_loaded.ga_len && ga_grow(&ga_loaded, 1) == OK)
8715 {
8716 ((char_u **)ga_loaded.ga_data)[ga_loaded.ga_len++] = scriptname;
8717 tofree = NULL;
8718 }
8719
8720 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01008721 if (source_runtime(scriptname, 0) == OK)
Bram Moolenaar87e25fd2005-07-27 21:13:01 +00008722 ret = TRUE;
8723 }
8724
8725 vim_free(tofree);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00008726 return ret;
8727}
8728
Bram Moolenaar071d4272004-06-13 20:20:40 +00008729#if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
8730typedef enum
8731{
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008732 VAR_FLAVOUR_DEFAULT, /* doesn't start with uppercase */
8733 VAR_FLAVOUR_SESSION, /* starts with uppercase, some lower */
8734 VAR_FLAVOUR_VIMINFO /* all uppercase */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008735} var_flavour_T;
8736
Bram Moolenaar48e697e2016-01-23 22:17:30 +01008737static var_flavour_T var_flavour(char_u *varname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008738
8739 static var_flavour_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01008740var_flavour(char_u *varname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008741{
8742 char_u *p = varname;
8743
8744 if (ASCII_ISUPPER(*p))
8745 {
8746 while (*(++p))
8747 if (ASCII_ISLOWER(*p))
8748 return VAR_FLAVOUR_SESSION;
8749 return VAR_FLAVOUR_VIMINFO;
8750 }
8751 else
8752 return VAR_FLAVOUR_DEFAULT;
8753}
8754#endif
8755
8756#if defined(FEAT_VIMINFO) || defined(PROTO)
8757/*
8758 * Restore global vars that start with a capital from the viminfo file
8759 */
8760 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01008761read_viminfo_varlist(vir_T *virp, int writing)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008762{
8763 char_u *tab;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008764 int type = VAR_NUMBER;
Bram Moolenaar33570922005-01-25 22:26:29 +00008765 typval_T tv;
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008766 void *save_funccal;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008767
8768 if (!writing && (find_viminfo_parameter('!') != NULL))
8769 {
8770 tab = vim_strchr(virp->vir_line + 1, '\t');
8771 if (tab != NULL)
8772 {
8773 *tab++ = '\0'; /* isolate the variable name */
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008774 switch (*tab)
8775 {
8776 case 'S': type = VAR_STRING; break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008777#ifdef FEAT_FLOAT
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008778 case 'F': type = VAR_FLOAT; break;
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008779#endif
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008780 case 'D': type = VAR_DICT; break;
8781 case 'L': type = VAR_LIST; break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01008782 case 'X': type = VAR_SPECIAL; break;
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008783 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008784
8785 tab = vim_strchr(tab, '\t');
8786 if (tab != NULL)
8787 {
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008788 tv.v_type = type;
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008789 if (type == VAR_STRING || type == VAR_DICT || type == VAR_LIST)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00008790 tv.vval.v_string = viminfo_readstring(virp,
Bram Moolenaar071d4272004-06-13 20:20:40 +00008791 (int)(tab - virp->vir_line + 1), TRUE);
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008792#ifdef FEAT_FLOAT
8793 else if (type == VAR_FLOAT)
8794 (void)string2float(tab + 1, &tv.vval.v_float);
8795#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008796 else
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00008797 tv.vval.v_number = atol((char *)tab + 1);
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008798 if (type == VAR_DICT || type == VAR_LIST)
8799 {
8800 typval_T *etv = eval_expr(tv.vval.v_string, NULL);
8801
8802 if (etv == NULL)
8803 /* Failed to parse back the dict or list, use it as a
8804 * string. */
8805 tv.v_type = VAR_STRING;
8806 else
8807 {
8808 vim_free(tv.vval.v_string);
8809 tv = *etv;
Bram Moolenaar507cc8a2012-03-23 15:37:02 +01008810 vim_free(etv);
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008811 }
8812 }
8813
Bram Moolenaarb20e3342016-01-18 23:29:01 +01008814 /* when in a function use global variables */
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008815 save_funccal = clear_current_funccal();
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00008816 set_var(virp->vir_line + 1, &tv, FALSE);
Bram Moolenaara9b579f2016-07-17 18:29:19 +02008817 restore_current_funccal(save_funccal);
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008818
8819 if (tv.v_type == VAR_STRING)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00008820 vim_free(tv.vval.v_string);
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008821 else if (tv.v_type == VAR_DICT || tv.v_type == VAR_LIST)
8822 clear_tv(&tv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008823 }
8824 }
8825 }
8826
8827 return viminfo_readline(virp);
8828}
8829
8830/*
8831 * Write global vars that start with a capital to the viminfo file
8832 */
8833 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008834write_viminfo_varlist(FILE *fp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008835{
Bram Moolenaar33570922005-01-25 22:26:29 +00008836 hashitem_T *hi;
8837 dictitem_T *this_var;
Bram Moolenaara7043832005-01-21 11:56:39 +00008838 int todo;
Bram Moolenaar2fc83fc2016-02-08 22:57:24 +01008839 char *s = "";
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008840 char_u *p;
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008841 char_u *tofree;
Bram Moolenaar8a283e52005-01-06 23:28:25 +00008842 char_u numbuf[NUMBUFLEN];
Bram Moolenaar071d4272004-06-13 20:20:40 +00008843
8844 if (find_viminfo_parameter('!') == NULL)
8845 return;
8846
Bram Moolenaar9577c3e2010-05-14 12:16:25 +02008847 fputs(_("\n# global variables:\n"), fp);
Bram Moolenaara7043832005-01-21 11:56:39 +00008848
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00008849 todo = (int)globvarht.ht_used;
Bram Moolenaar33570922005-01-25 22:26:29 +00008850 for (hi = globvarht.ht_array; todo > 0; ++hi)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008851 {
Bram Moolenaara7043832005-01-21 11:56:39 +00008852 if (!HASHITEM_EMPTY(hi))
Bram Moolenaar071d4272004-06-13 20:20:40 +00008853 {
Bram Moolenaara7043832005-01-21 11:56:39 +00008854 --todo;
Bram Moolenaar33570922005-01-25 22:26:29 +00008855 this_var = HI2DI(hi);
8856 if (var_flavour(this_var->di_key) == VAR_FLAVOUR_VIMINFO)
Bram Moolenaarc70646c2005-01-04 21:52:38 +00008857 {
Bram Moolenaar33570922005-01-25 22:26:29 +00008858 switch (this_var->di_tv.v_type)
Bram Moolenaara7043832005-01-21 11:56:39 +00008859 {
8860 case VAR_STRING: s = "STR"; break;
8861 case VAR_NUMBER: s = "NUM"; break;
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008862 case VAR_FLOAT: s = "FLO"; break;
Bram Moolenaar680eeca2010-10-20 17:44:42 +02008863 case VAR_DICT: s = "DIC"; break;
8864 case VAR_LIST: s = "LIS"; break;
Bram Moolenaara03f2332016-02-06 18:09:59 +01008865 case VAR_SPECIAL: s = "XPL"; break;
8866
8867 case VAR_UNKNOWN:
8868 case VAR_FUNC:
Bram Moolenaar1735bc92016-03-14 23:05:14 +01008869 case VAR_PARTIAL:
Bram Moolenaar835dc632016-02-07 14:27:38 +01008870 case VAR_JOB:
Bram Moolenaar77073442016-02-13 23:23:53 +01008871 case VAR_CHANNEL:
Bram Moolenaara03f2332016-02-06 18:09:59 +01008872 continue;
Bram Moolenaara7043832005-01-21 11:56:39 +00008873 }
Bram Moolenaar33570922005-01-25 22:26:29 +00008874 fprintf(fp, "!%s\t%s\t", this_var->di_key, s);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00008875 p = echo_string(&this_var->di_tv, &tofree, numbuf, 0);
Bram Moolenaar81bf7082005-02-12 14:31:42 +00008876 if (p != NULL)
8877 viminfo_writestring(fp, p);
Bram Moolenaara7043832005-01-21 11:56:39 +00008878 vim_free(tofree);
8879 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008880 }
8881 }
8882}
8883#endif
8884
8885#if defined(FEAT_SESSION) || defined(PROTO)
8886 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01008887store_session_globals(FILE *fd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008888{
Bram Moolenaar33570922005-01-25 22:26:29 +00008889 hashitem_T *hi;
8890 dictitem_T *this_var;
Bram Moolenaara7043832005-01-21 11:56:39 +00008891 int todo;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008892 char_u *p, *t;
8893
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00008894 todo = (int)globvarht.ht_used;
Bram Moolenaar33570922005-01-25 22:26:29 +00008895 for (hi = globvarht.ht_array; todo > 0; ++hi)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008896 {
Bram Moolenaara7043832005-01-21 11:56:39 +00008897 if (!HASHITEM_EMPTY(hi))
Bram Moolenaar071d4272004-06-13 20:20:40 +00008898 {
Bram Moolenaara7043832005-01-21 11:56:39 +00008899 --todo;
Bram Moolenaar33570922005-01-25 22:26:29 +00008900 this_var = HI2DI(hi);
8901 if ((this_var->di_tv.v_type == VAR_NUMBER
8902 || this_var->di_tv.v_type == VAR_STRING)
8903 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION)
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00008904 {
Bram Moolenaara7043832005-01-21 11:56:39 +00008905 /* Escape special characters with a backslash. Turn a LF and
8906 * CR into \n and \r. */
Bram Moolenaar33570922005-01-25 22:26:29 +00008907 p = vim_strsave_escaped(get_tv_string(&this_var->di_tv),
Bram Moolenaara7043832005-01-21 11:56:39 +00008908 (char_u *)"\\\"\n\r");
8909 if (p == NULL) /* out of memory */
8910 break;
8911 for (t = p; *t != NUL; ++t)
8912 if (*t == '\n')
8913 *t = 'n';
8914 else if (*t == '\r')
8915 *t = 'r';
8916 if ((fprintf(fd, "let %s = %c%s%c",
Bram Moolenaar33570922005-01-25 22:26:29 +00008917 this_var->di_key,
8918 (this_var->di_tv.v_type == VAR_STRING) ? '"'
8919 : ' ',
8920 p,
8921 (this_var->di_tv.v_type == VAR_STRING) ? '"'
8922 : ' ') < 0)
Bram Moolenaara7043832005-01-21 11:56:39 +00008923 || put_eol(fd) == FAIL)
8924 {
8925 vim_free(p);
8926 return FAIL;
8927 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008928 vim_free(p);
8929 }
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008930#ifdef FEAT_FLOAT
8931 else if (this_var->di_tv.v_type == VAR_FLOAT
8932 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION)
8933 {
8934 float_T f = this_var->di_tv.vval.v_float;
8935 int sign = ' ';
8936
8937 if (f < 0)
8938 {
8939 f = -f;
8940 sign = '-';
8941 }
Bram Moolenaar2b04b192012-01-26 11:45:30 +01008942 if ((fprintf(fd, "let %s = %c%f",
Bram Moolenaar8c8de832008-06-24 22:58:06 +00008943 this_var->di_key, sign, f) < 0)
8944 || put_eol(fd) == FAIL)
8945 return FAIL;
8946 }
8947#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008948 }
8949 }
8950 return OK;
8951}
8952#endif
8953
Bram Moolenaar661b1822005-07-28 22:36:45 +00008954/*
8955 * Display script name where an item was last set.
8956 * Should only be invoked when 'verbose' is non-zero.
8957 */
8958 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008959last_set_msg(scid_T scriptID)
Bram Moolenaar661b1822005-07-28 22:36:45 +00008960{
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00008961 char_u *p;
8962
Bram Moolenaar661b1822005-07-28 22:36:45 +00008963 if (scriptID != 0)
8964 {
Bram Moolenaarcafda4f2005-09-06 19:25:11 +00008965 p = home_replace_save(NULL, get_scriptname(scriptID));
8966 if (p != NULL)
8967 {
8968 verbose_enter();
8969 MSG_PUTS(_("\n\tLast set from "));
8970 MSG_PUTS(p);
8971 vim_free(p);
8972 verbose_leave();
8973 }
Bram Moolenaar661b1822005-07-28 22:36:45 +00008974 }
8975}
8976
Bram Moolenaar53744302015-07-17 17:38:22 +02008977/* reset v:option_new, v:option_old and v:option_type */
8978 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01008979reset_v_option_vars(void)
Bram Moolenaar53744302015-07-17 17:38:22 +02008980{
8981 set_vim_var_string(VV_OPTION_NEW, NULL, -1);
8982 set_vim_var_string(VV_OPTION_OLD, NULL, -1);
8983 set_vim_var_string(VV_OPTION_TYPE, NULL, -1);
8984}
8985
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02008986/*
8987 * Prepare "gap" for an assert error and add the sourcing position.
8988 */
8989 void
8990prepare_assert_error(garray_T *gap)
8991{
8992 char buf[NUMBUFLEN];
8993
8994 ga_init2(gap, 1, 100);
8995 if (sourcing_name != NULL)
8996 {
8997 ga_concat(gap, sourcing_name);
8998 if (sourcing_lnum > 0)
8999 ga_concat(gap, (char_u *)" ");
9000 }
9001 if (sourcing_lnum > 0)
9002 {
9003 sprintf(buf, "line %ld", (long)sourcing_lnum);
9004 ga_concat(gap, (char_u *)buf);
9005 }
9006 if (sourcing_name != NULL || sourcing_lnum > 0)
9007 ga_concat(gap, (char_u *)": ");
9008}
9009
9010/*
9011 * Add an assert error to v:errors.
9012 */
9013 void
9014assert_error(garray_T *gap)
9015{
9016 struct vimvar *vp = &vimvars[VV_ERRORS];
9017
9018 if (vp->vv_type != VAR_LIST || vimvars[VV_ERRORS].vv_list == NULL)
9019 /* Make sure v:errors is a list. */
9020 set_vim_var_list(VV_ERRORS, list_alloc());
9021 list_append_string(vimvars[VV_ERRORS].vv_list, gap->ga_data, gap->ga_len);
9022}
9023
9024 void
9025assert_equal_common(typval_T *argvars, assert_type_T atype)
9026{
9027 garray_T ga;
9028
9029 if (tv_equal(&argvars[0], &argvars[1], FALSE, FALSE)
9030 != (atype == ASSERT_EQUAL))
9031 {
9032 prepare_assert_error(&ga);
9033 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9034 atype);
9035 assert_error(&ga);
9036 ga_clear(&ga);
9037 }
9038}
9039
9040 void
9041assert_match_common(typval_T *argvars, assert_type_T atype)
9042{
9043 garray_T ga;
9044 char_u buf1[NUMBUFLEN];
9045 char_u buf2[NUMBUFLEN];
9046 char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1);
9047 char_u *text = get_tv_string_buf_chk(&argvars[1], buf2);
9048
9049 if (pat == NULL || text == NULL)
9050 EMSG(_(e_invarg));
9051 else if (pattern_match(pat, text, FALSE) != (atype == ASSERT_MATCH))
9052 {
9053 prepare_assert_error(&ga);
9054 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9055 atype);
9056 assert_error(&ga);
9057 ga_clear(&ga);
9058 }
9059}
9060
Bram Moolenaar61c04492016-07-23 15:35:35 +02009061 void
9062assert_inrange(typval_T *argvars)
9063{
9064 garray_T ga;
9065 int error = FALSE;
9066 varnumber_T lower = get_tv_number_chk(&argvars[0], &error);
9067 varnumber_T upper = get_tv_number_chk(&argvars[1], &error);
9068 varnumber_T actual = get_tv_number_chk(&argvars[2], &error);
9069 char_u *tofree;
9070 char msg[200];
9071 char_u numbuf[NUMBUFLEN];
9072
9073 if (error)
9074 return;
9075 if (actual < lower || actual > upper)
9076 {
9077 prepare_assert_error(&ga);
9078 if (argvars[3].v_type != VAR_UNKNOWN)
9079 {
9080 ga_concat(&ga, tv2string(&argvars[3], &tofree, numbuf, 0));
9081 vim_free(tofree);
9082 }
9083 else
9084 {
9085 vim_snprintf(msg, 200, "Expected range %ld - %ld, but got %ld",
9086 (long)lower, (long)upper, (long)actual);
9087 ga_concat(&ga, (char_u *)msg);
9088 }
9089 assert_error(&ga);
9090 ga_clear(&ga);
9091 }
9092}
9093
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009094/*
9095 * Common for assert_true() and assert_false().
9096 */
9097 void
9098assert_bool(typval_T *argvars, int isTrue)
9099{
9100 int error = FALSE;
9101 garray_T ga;
9102
9103 if (argvars[0].v_type == VAR_SPECIAL
9104 && argvars[0].vval.v_number == (isTrue ? VVAL_TRUE : VVAL_FALSE))
9105 return;
9106 if (argvars[0].v_type != VAR_NUMBER
9107 || (get_tv_number_chk(&argvars[0], &error) == 0) == isTrue
9108 || error)
9109 {
9110 prepare_assert_error(&ga);
9111 fill_assert_error(&ga, &argvars[1],
9112 (char_u *)(isTrue ? "True" : "False"),
9113 NULL, &argvars[0], ASSERT_OTHER);
9114 assert_error(&ga);
9115 ga_clear(&ga);
9116 }
9117}
9118
9119 void
Bram Moolenaar42205552017-03-18 19:42:22 +01009120assert_report(typval_T *argvars)
9121{
9122 garray_T ga;
9123
9124 prepare_assert_error(&ga);
9125 ga_concat(&ga, get_tv_string(&argvars[0]));
9126 assert_error(&ga);
9127 ga_clear(&ga);
9128}
9129
9130 void
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009131assert_exception(typval_T *argvars)
9132{
9133 garray_T ga;
9134 char_u *error = get_tv_string_chk(&argvars[0]);
9135
9136 if (vimvars[VV_EXCEPTION].vv_str == NULL)
9137 {
9138 prepare_assert_error(&ga);
9139 ga_concat(&ga, (char_u *)"v:exception is not set");
9140 assert_error(&ga);
9141 ga_clear(&ga);
9142 }
9143 else if (error != NULL
9144 && strstr((char *)vimvars[VV_EXCEPTION].vv_str, (char *)error) == NULL)
9145 {
9146 prepare_assert_error(&ga);
9147 fill_assert_error(&ga, &argvars[1], NULL, &argvars[0],
9148 &vimvars[VV_EXCEPTION].vv_tv, ASSERT_OTHER);
9149 assert_error(&ga);
9150 ga_clear(&ga);
9151 }
9152}
9153
9154 void
9155assert_fails(typval_T *argvars)
9156{
9157 char_u *cmd = get_tv_string_chk(&argvars[0]);
9158 garray_T ga;
9159
9160 called_emsg = FALSE;
9161 suppress_errthrow = TRUE;
9162 emsg_silent = TRUE;
9163 do_cmdline_cmd(cmd);
9164 if (!called_emsg)
9165 {
9166 prepare_assert_error(&ga);
9167 ga_concat(&ga, (char_u *)"command did not fail: ");
9168 ga_concat(&ga, cmd);
9169 assert_error(&ga);
9170 ga_clear(&ga);
9171 }
9172 else if (argvars[1].v_type != VAR_UNKNOWN)
9173 {
9174 char_u buf[NUMBUFLEN];
9175 char *error = (char *)get_tv_string_buf_chk(&argvars[1], buf);
9176
9177 if (error == NULL
9178 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL)
9179 {
9180 prepare_assert_error(&ga);
9181 fill_assert_error(&ga, &argvars[2], NULL, &argvars[1],
9182 &vimvars[VV_ERRMSG].vv_tv, ASSERT_OTHER);
9183 assert_error(&ga);
9184 ga_clear(&ga);
9185 }
9186 }
9187
9188 called_emsg = FALSE;
9189 suppress_errthrow = FALSE;
9190 emsg_silent = FALSE;
9191 emsg_on_display = FALSE;
9192 set_vim_var_string(VV_ERRMSG, NULL, 0);
9193}
9194
9195/*
9196 * Append "str" to "gap", escaping unprintable characters.
9197 * Changes NL to \n, CR to \r, etc.
9198 */
9199 static void
9200ga_concat_esc(garray_T *gap, char_u *str)
9201{
9202 char_u *p;
9203 char_u buf[NUMBUFLEN];
9204
9205 if (str == NULL)
9206 {
9207 ga_concat(gap, (char_u *)"NULL");
9208 return;
9209 }
9210
9211 for (p = str; *p != NUL; ++p)
9212 switch (*p)
9213 {
9214 case BS: ga_concat(gap, (char_u *)"\\b"); break;
9215 case ESC: ga_concat(gap, (char_u *)"\\e"); break;
9216 case FF: ga_concat(gap, (char_u *)"\\f"); break;
9217 case NL: ga_concat(gap, (char_u *)"\\n"); break;
9218 case TAB: ga_concat(gap, (char_u *)"\\t"); break;
9219 case CAR: ga_concat(gap, (char_u *)"\\r"); break;
9220 case '\\': ga_concat(gap, (char_u *)"\\\\"); break;
9221 default:
9222 if (*p < ' ')
9223 {
9224 vim_snprintf((char *)buf, NUMBUFLEN, "\\x%02x", *p);
9225 ga_concat(gap, buf);
9226 }
9227 else
9228 ga_append(gap, *p);
9229 break;
9230 }
9231}
9232
9233/*
9234 * Fill "gap" with information about an assert error.
9235 */
9236 void
9237fill_assert_error(
9238 garray_T *gap,
9239 typval_T *opt_msg_tv,
9240 char_u *exp_str,
9241 typval_T *exp_tv,
9242 typval_T *got_tv,
9243 assert_type_T atype)
9244{
9245 char_u numbuf[NUMBUFLEN];
9246 char_u *tofree;
9247
9248 if (opt_msg_tv->v_type != VAR_UNKNOWN)
9249 {
Bram Moolenaarc7b831c2017-01-28 18:08:12 +01009250 ga_concat(gap, echo_string(opt_msg_tv, &tofree, numbuf, 0));
9251 vim_free(tofree);
9252 ga_concat(gap, (char_u *)": ");
9253 }
9254
9255 if (atype == ASSERT_MATCH || atype == ASSERT_NOTMATCH)
9256 ga_concat(gap, (char_u *)"Pattern ");
9257 else if (atype == ASSERT_NOTEQUAL)
9258 ga_concat(gap, (char_u *)"Expected not equal to ");
9259 else
9260 ga_concat(gap, (char_u *)"Expected ");
9261 if (exp_str == NULL)
9262 {
9263 ga_concat_esc(gap, tv2string(exp_tv, &tofree, numbuf, 0));
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009264 vim_free(tofree);
9265 }
9266 else
Bram Moolenaarc7b831c2017-01-28 18:08:12 +01009267 ga_concat_esc(gap, exp_str);
9268 if (atype != ASSERT_NOTEQUAL)
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009269 {
Bram Moolenaarc7b831c2017-01-28 18:08:12 +01009270 if (atype == ASSERT_MATCH)
9271 ga_concat(gap, (char_u *)" does not match ");
9272 else if (atype == ASSERT_NOTMATCH)
9273 ga_concat(gap, (char_u *)" does match ");
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009274 else
Bram Moolenaarc7b831c2017-01-28 18:08:12 +01009275 ga_concat(gap, (char_u *)" but got ");
9276 ga_concat_esc(gap, tv2string(got_tv, &tofree, numbuf, 0));
9277 vim_free(tofree);
Bram Moolenaar73dad1e2016-07-17 22:13:49 +02009278 }
9279}
9280
Bram Moolenaar53744302015-07-17 17:38:22 +02009281
Bram Moolenaar071d4272004-06-13 20:20:40 +00009282#endif /* FEAT_EVAL */
9283
Bram Moolenaar071d4272004-06-13 20:20:40 +00009284
Bram Moolenaar8c8de832008-06-24 22:58:06 +00009285#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009286
9287#ifdef WIN3264
9288/*
9289 * Functions for ":8" filename modifier: get 8.3 version of a filename.
9290 */
Bram Moolenaar48e697e2016-01-23 22:17:30 +01009291static int get_short_pathname(char_u **fnamep, char_u **bufp, int *fnamelen);
9292static int shortpath_for_invalid_fname(char_u **fname, char_u **bufp, int *fnamelen);
9293static int shortpath_for_partial(char_u **fnamep, char_u **bufp, int *fnamelen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009294
9295/*
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009296 * Get the short path (8.3) for the filename in "fnamep".
9297 * Only works for a valid file name.
9298 * When the path gets longer "fnamep" is changed and the allocated buffer
9299 * is put in "bufp".
9300 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
9301 * Returns OK on success, FAIL on failure.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009302 */
9303 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01009304get_short_pathname(char_u **fnamep, char_u **bufp, int *fnamelen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009305{
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009306 int l, len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009307 char_u *newbuf;
9308
9309 len = *fnamelen;
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01009310 l = GetShortPathName((LPSTR)*fnamep, (LPSTR)*fnamep, len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009311 if (l > len - 1)
9312 {
9313 /* If that doesn't work (not enough space), then save the string
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009314 * and try again with a new buffer big enough. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009315 newbuf = vim_strnsave(*fnamep, l);
9316 if (newbuf == NULL)
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009317 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009318
9319 vim_free(*bufp);
9320 *fnamep = *bufp = newbuf;
9321
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009322 /* Really should always succeed, as the buffer is big enough. */
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01009323 l = GetShortPathName((LPSTR)*fnamep, (LPSTR)*fnamep, l+1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009324 }
9325
9326 *fnamelen = l;
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009327 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009328}
9329
9330/*
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009331 * Get the short path (8.3) for the filename in "fname". The converted
9332 * path is returned in "bufp".
9333 *
9334 * Some of the directories specified in "fname" may not exist. This function
9335 * will shorten the existing directories at the beginning of the path and then
9336 * append the remaining non-existing path.
9337 *
9338 * fname - Pointer to the filename to shorten. On return, contains the
Bram Moolenaar2c704a72010-06-03 21:17:25 +02009339 * pointer to the shortened pathname
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009340 * bufp - Pointer to an allocated buffer for the filename.
9341 * fnamelen - Length of the filename pointed to by fname
9342 *
9343 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
Bram Moolenaar071d4272004-06-13 20:20:40 +00009344 */
9345 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01009346shortpath_for_invalid_fname(
9347 char_u **fname,
9348 char_u **bufp,
9349 int *fnamelen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009350{
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009351 char_u *short_fname, *save_fname, *pbuf_unused;
9352 char_u *endp, *save_endp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009353 char_u ch;
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009354 int old_len, len;
9355 int new_len, sfx_len;
9356 int retval = OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009357
9358 /* Make a copy */
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009359 old_len = *fnamelen;
9360 save_fname = vim_strnsave(*fname, old_len);
9361 pbuf_unused = NULL;
9362 short_fname = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009363
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009364 endp = save_fname + old_len - 1; /* Find the end of the copy */
9365 save_endp = endp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009366
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009367 /*
9368 * Try shortening the supplied path till it succeeds by removing one
9369 * directory at a time from the tail of the path.
9370 */
9371 len = 0;
9372 for (;;)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009373 {
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009374 /* go back one path-separator */
9375 while (endp > save_fname && !after_pathsep(save_fname, endp + 1))
9376 --endp;
9377 if (endp <= save_fname)
9378 break; /* processed the complete path */
9379
9380 /*
9381 * Replace the path separator with a NUL and try to shorten the
9382 * resulting path.
9383 */
9384 ch = *endp;
9385 *endp = 0;
9386 short_fname = save_fname;
Bram Moolenaarc236c162008-07-13 17:41:49 +00009387 len = (int)STRLEN(short_fname) + 1;
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009388 if (get_short_pathname(&short_fname, &pbuf_unused, &len) == FAIL)
9389 {
9390 retval = FAIL;
9391 goto theend;
9392 }
9393 *endp = ch; /* preserve the string */
9394
9395 if (len > 0)
9396 break; /* successfully shortened the path */
9397
9398 /* failed to shorten the path. Skip the path separator */
9399 --endp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009400 }
9401
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009402 if (len > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009403 {
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009404 /*
9405 * Succeeded in shortening the path. Now concatenate the shortened
9406 * path with the remaining path at the tail.
9407 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009408
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009409 /* Compute the length of the new path. */
9410 sfx_len = (int)(save_endp - endp) + 1;
9411 new_len = len + sfx_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009412
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009413 *fnamelen = new_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009414 vim_free(*bufp);
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009415 if (new_len > old_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009416 {
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009417 /* There is not enough space in the currently allocated string,
9418 * copy it to a buffer big enough. */
9419 *fname = *bufp = vim_strnsave(short_fname, new_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009420 if (*fname == NULL)
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009421 {
9422 retval = FAIL;
9423 goto theend;
9424 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009425 }
9426 else
9427 {
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009428 /* Transfer short_fname to the main buffer (it's big enough),
9429 * unless get_short_pathname() did its work in-place. */
9430 *fname = *bufp = save_fname;
9431 if (short_fname != save_fname)
9432 vim_strncpy(save_fname, short_fname, len);
9433 save_fname = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009434 }
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009435
9436 /* concat the not-shortened part of the path */
9437 vim_strncpy(*fname + len, endp, sfx_len);
9438 (*fname)[new_len] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009439 }
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009440
9441theend:
9442 vim_free(pbuf_unused);
9443 vim_free(save_fname);
9444
9445 return retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009446}
9447
9448/*
9449 * Get a pathname for a partial path.
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009450 * Returns OK for success, FAIL for failure.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009451 */
9452 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01009453shortpath_for_partial(
9454 char_u **fnamep,
9455 char_u **bufp,
9456 int *fnamelen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009457{
9458 int sepcount, len, tflen;
9459 char_u *p;
9460 char_u *pbuf, *tfname;
9461 int hasTilde;
9462
Bram Moolenaar8c8de832008-06-24 22:58:06 +00009463 /* Count up the path separators from the RHS.. so we know which part
9464 * of the path to return. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009465 sepcount = 0;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01009466 for (p = *fnamep; p < *fnamep + *fnamelen; MB_PTR_ADV(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00009467 if (vim_ispathsep(*p))
9468 ++sepcount;
9469
9470 /* Need full path first (use expand_env() to remove a "~/") */
9471 hasTilde = (**fnamep == '~');
9472 if (hasTilde)
9473 pbuf = tfname = expand_env_save(*fnamep);
9474 else
9475 pbuf = tfname = FullName_save(*fnamep, FALSE);
9476
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00009477 len = tflen = (int)STRLEN(tfname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009478
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009479 if (get_short_pathname(&tfname, &pbuf, &len) == FAIL)
9480 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009481
9482 if (len == 0)
9483 {
9484 /* Don't have a valid filename, so shorten the rest of the
9485 * path if we can. This CAN give us invalid 8.3 filenames, but
9486 * there's not a lot of point in guessing what it might be.
9487 */
9488 len = tflen;
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009489 if (shortpath_for_invalid_fname(&tfname, &pbuf, &len) == FAIL)
9490 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009491 }
9492
9493 /* Count the paths backward to find the beginning of the desired string. */
9494 for (p = tfname + len - 1; p >= tfname; --p)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00009495 {
9496#ifdef FEAT_MBYTE
9497 if (has_mbyte)
9498 p -= mb_head_off(tfname, p);
9499#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009500 if (vim_ispathsep(*p))
9501 {
9502 if (sepcount == 0 || (hasTilde && sepcount == 1))
9503 break;
9504 else
9505 sepcount --;
9506 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00009507 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009508 if (hasTilde)
9509 {
9510 --p;
9511 if (p >= tfname)
9512 *p = '~';
9513 else
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009514 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009515 }
9516 else
9517 ++p;
9518
9519 /* Copy in the string - p indexes into tfname - allocated at pbuf */
9520 vim_free(*bufp);
9521 *fnamelen = (int)STRLEN(p);
9522 *bufp = pbuf;
9523 *fnamep = p;
9524
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009525 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009526}
9527#endif /* WIN3264 */
9528
9529/*
9530 * Adjust a filename, according to a string of modifiers.
9531 * *fnamep must be NUL terminated when called. When returning, the length is
9532 * determined by *fnamelen.
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009533 * Returns VALID_ flags or -1 for failure.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009534 * When there is an error, *fnamep is set to NULL.
9535 */
9536 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01009537modify_fname(
9538 char_u *src, /* string with modifiers */
9539 int *usedlen, /* characters after src that are used */
9540 char_u **fnamep, /* file name so far */
9541 char_u **bufp, /* buffer for allocated file name or NULL */
9542 int *fnamelen) /* length of fnamep */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009543{
9544 int valid = 0;
9545 char_u *tail;
9546 char_u *s, *p, *pbuf;
9547 char_u dirname[MAXPATHL];
9548 int c;
9549 int has_fullname = 0;
9550#ifdef WIN3264
Bram Moolenaardc935552011-08-17 15:23:23 +02009551 char_u *fname_start = *fnamep;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009552 int has_shortname = 0;
9553#endif
9554
9555repeat:
9556 /* ":p" - full path/file_name */
9557 if (src[*usedlen] == ':' && src[*usedlen + 1] == 'p')
9558 {
9559 has_fullname = 1;
9560
9561 valid |= VALID_PATH;
9562 *usedlen += 2;
9563
9564 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
9565 if ((*fnamep)[0] == '~'
9566#if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
9567 && ((*fnamep)[1] == '/'
9568# ifdef BACKSLASH_IN_FILENAME
9569 || (*fnamep)[1] == '\\'
9570# endif
9571 || (*fnamep)[1] == NUL)
9572
9573#endif
9574 )
9575 {
9576 *fnamep = expand_env_save(*fnamep);
9577 vim_free(*bufp); /* free any allocated file name */
9578 *bufp = *fnamep;
9579 if (*fnamep == NULL)
9580 return -1;
9581 }
9582
9583 /* When "/." or "/.." is used: force expansion to get rid of it. */
Bram Moolenaar91acfff2017-03-12 19:22:36 +01009584 for (p = *fnamep; *p != NUL; MB_PTR_ADV(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00009585 {
9586 if (vim_ispathsep(*p)
9587 && p[1] == '.'
9588 && (p[2] == NUL
9589 || vim_ispathsep(p[2])
9590 || (p[2] == '.'
9591 && (p[3] == NUL || vim_ispathsep(p[3])))))
9592 break;
9593 }
9594
9595 /* FullName_save() is slow, don't use it when not needed. */
9596 if (*p != NUL || !vim_isAbsName(*fnamep))
9597 {
9598 *fnamep = FullName_save(*fnamep, *p != NUL);
9599 vim_free(*bufp); /* free any allocated file name */
9600 *bufp = *fnamep;
9601 if (*fnamep == NULL)
9602 return -1;
9603 }
9604
Bram Moolenaar9158f9e2012-06-20 14:02:27 +02009605#ifdef WIN3264
9606# if _WIN32_WINNT >= 0x0500
9607 if (vim_strchr(*fnamep, '~') != NULL)
9608 {
9609 /* Expand 8.3 filename to full path. Needed to make sure the same
9610 * file does not have two different names.
9611 * Note: problem does not occur if _WIN32_WINNT < 0x0500. */
9612 p = alloc(_MAX_PATH + 1);
9613 if (p != NULL)
9614 {
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01009615 if (GetLongPathName((LPSTR)*fnamep, (LPSTR)p, _MAX_PATH))
Bram Moolenaar9158f9e2012-06-20 14:02:27 +02009616 {
9617 vim_free(*bufp);
9618 *bufp = *fnamep = p;
9619 }
9620 else
9621 vim_free(p);
9622 }
9623 }
9624# endif
9625#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009626 /* Append a path separator to a directory. */
9627 if (mch_isdir(*fnamep))
9628 {
9629 /* Make room for one or two extra characters. */
9630 *fnamep = vim_strnsave(*fnamep, (int)STRLEN(*fnamep) + 2);
9631 vim_free(*bufp); /* free any allocated file name */
9632 *bufp = *fnamep;
9633 if (*fnamep == NULL)
9634 return -1;
9635 add_pathsep(*fnamep);
9636 }
9637 }
9638
9639 /* ":." - path relative to the current directory */
9640 /* ":~" - path relative to the home directory */
9641 /* ":8" - shortname path - postponed till after */
9642 while (src[*usedlen] == ':'
9643 && ((c = src[*usedlen + 1]) == '.' || c == '~' || c == '8'))
9644 {
9645 *usedlen += 2;
9646 if (c == '8')
9647 {
9648#ifdef WIN3264
9649 has_shortname = 1; /* Postpone this. */
9650#endif
9651 continue;
9652 }
9653 pbuf = NULL;
9654 /* Need full path first (use expand_env() to remove a "~/") */
9655 if (!has_fullname)
9656 {
9657 if (c == '.' && **fnamep == '~')
9658 p = pbuf = expand_env_save(*fnamep);
9659 else
9660 p = pbuf = FullName_save(*fnamep, FALSE);
9661 }
9662 else
9663 p = *fnamep;
9664
9665 has_fullname = 0;
9666
9667 if (p != NULL)
9668 {
9669 if (c == '.')
9670 {
9671 mch_dirname(dirname, MAXPATHL);
9672 s = shorten_fname(p, dirname);
9673 if (s != NULL)
9674 {
9675 *fnamep = s;
9676 if (pbuf != NULL)
9677 {
9678 vim_free(*bufp); /* free any allocated file name */
9679 *bufp = pbuf;
9680 pbuf = NULL;
9681 }
9682 }
9683 }
9684 else
9685 {
9686 home_replace(NULL, p, dirname, MAXPATHL, TRUE);
9687 /* Only replace it when it starts with '~' */
9688 if (*dirname == '~')
9689 {
9690 s = vim_strsave(dirname);
9691 if (s != NULL)
9692 {
9693 *fnamep = s;
9694 vim_free(*bufp);
9695 *bufp = s;
9696 }
9697 }
9698 }
9699 vim_free(pbuf);
9700 }
9701 }
9702
9703 tail = gettail(*fnamep);
9704 *fnamelen = (int)STRLEN(*fnamep);
9705
9706 /* ":h" - head, remove "/file_name", can be repeated */
9707 /* Don't remove the first "/" or "c:\" */
9708 while (src[*usedlen] == ':' && src[*usedlen + 1] == 'h')
9709 {
9710 valid |= VALID_HEAD;
9711 *usedlen += 2;
9712 s = get_past_head(*fnamep);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00009713 while (tail > s && after_pathsep(s, tail))
Bram Moolenaar91acfff2017-03-12 19:22:36 +01009714 MB_PTR_BACK(*fnamep, tail);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009715 *fnamelen = (int)(tail - *fnamep);
9716#ifdef VMS
9717 if (*fnamelen > 0)
9718 *fnamelen += 1; /* the path separator is part of the path */
9719#endif
Bram Moolenaar5461cfe2007-09-25 18:40:14 +00009720 if (*fnamelen == 0)
9721 {
9722 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
9723 p = vim_strsave((char_u *)".");
9724 if (p == NULL)
9725 return -1;
9726 vim_free(*bufp);
9727 *bufp = *fnamep = tail = p;
9728 *fnamelen = 1;
9729 }
9730 else
9731 {
9732 while (tail > s && !after_pathsep(s, tail))
Bram Moolenaar91acfff2017-03-12 19:22:36 +01009733 MB_PTR_BACK(*fnamep, tail);
Bram Moolenaar5461cfe2007-09-25 18:40:14 +00009734 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009735 }
9736
9737 /* ":8" - shortname */
9738 if (src[*usedlen] == ':' && src[*usedlen + 1] == '8')
9739 {
9740 *usedlen += 2;
9741#ifdef WIN3264
9742 has_shortname = 1;
9743#endif
9744 }
9745
9746#ifdef WIN3264
Bram Moolenaardc935552011-08-17 15:23:23 +02009747 /*
9748 * Handle ":8" after we have done 'heads' and before we do 'tails'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009749 */
9750 if (has_shortname)
9751 {
Bram Moolenaardc935552011-08-17 15:23:23 +02009752 /* Copy the string if it is shortened by :h and when it wasn't copied
9753 * yet, because we are going to change it in place. Avoids changing
9754 * the buffer name for "%:8". */
9755 if (*fnamelen < (int)STRLEN(*fnamep) || *fnamep == fname_start)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009756 {
9757 p = vim_strnsave(*fnamep, *fnamelen);
Bram Moolenaardc935552011-08-17 15:23:23 +02009758 if (p == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009759 return -1;
9760 vim_free(*bufp);
9761 *bufp = *fnamep = p;
9762 }
9763
9764 /* Split into two implementations - makes it easier. First is where
Bram Moolenaardc935552011-08-17 15:23:23 +02009765 * there isn't a full name already, second is where there is. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009766 if (!has_fullname && !vim_isAbsName(*fnamep))
9767 {
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009768 if (shortpath_for_partial(fnamep, bufp, fnamelen) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009769 return -1;
9770 }
9771 else
9772 {
Bram Moolenaardc935552011-08-17 15:23:23 +02009773 int l = *fnamelen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009774
Bram Moolenaardc935552011-08-17 15:23:23 +02009775 /* Simple case, already have the full-name.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009776 * Nearly always shorter, so try first time. */
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009777 if (get_short_pathname(fnamep, bufp, &l) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009778 return -1;
9779
9780 if (l == 0)
9781 {
Bram Moolenaardc935552011-08-17 15:23:23 +02009782 /* Couldn't find the filename, search the paths. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009783 l = *fnamelen;
Bram Moolenaarbcebfb62008-05-29 19:47:13 +00009784 if (shortpath_for_invalid_fname(fnamep, bufp, &l) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009785 return -1;
9786 }
9787 *fnamelen = l;
9788 }
9789 }
9790#endif /* WIN3264 */
9791
9792 /* ":t" - tail, just the basename */
9793 if (src[*usedlen] == ':' && src[*usedlen + 1] == 't')
9794 {
9795 *usedlen += 2;
9796 *fnamelen -= (int)(tail - *fnamep);
9797 *fnamep = tail;
9798 }
9799
9800 /* ":e" - extension, can be repeated */
9801 /* ":r" - root, without extension, can be repeated */
9802 while (src[*usedlen] == ':'
9803 && (src[*usedlen + 1] == 'e' || src[*usedlen + 1] == 'r'))
9804 {
9805 /* find a '.' in the tail:
9806 * - for second :e: before the current fname
9807 * - otherwise: The last '.'
9808 */
9809 if (src[*usedlen + 1] == 'e' && *fnamep > tail)
9810 s = *fnamep - 2;
9811 else
9812 s = *fnamep + *fnamelen - 1;
9813 for ( ; s > tail; --s)
9814 if (s[0] == '.')
9815 break;
9816 if (src[*usedlen + 1] == 'e') /* :e */
9817 {
9818 if (s > tail)
9819 {
9820 *fnamelen += (int)(*fnamep - (s + 1));
9821 *fnamep = s + 1;
9822#ifdef VMS
9823 /* cut version from the extension */
9824 s = *fnamep + *fnamelen - 1;
9825 for ( ; s > *fnamep; --s)
9826 if (s[0] == ';')
9827 break;
9828 if (s > *fnamep)
9829 *fnamelen = s - *fnamep;
9830#endif
9831 }
9832 else if (*fnamep <= tail)
9833 *fnamelen = 0;
9834 }
9835 else /* :r */
9836 {
9837 if (s > tail) /* remove one extension */
9838 *fnamelen = (int)(s - *fnamep);
9839 }
9840 *usedlen += 2;
9841 }
9842
9843 /* ":s?pat?foo?" - substitute */
9844 /* ":gs?pat?foo?" - global substitute */
9845 if (src[*usedlen] == ':'
9846 && (src[*usedlen + 1] == 's'
9847 || (src[*usedlen + 1] == 'g' && src[*usedlen + 2] == 's')))
9848 {
9849 char_u *str;
9850 char_u *pat;
9851 char_u *sub;
9852 int sep;
9853 char_u *flags;
9854 int didit = FALSE;
9855
9856 flags = (char_u *)"";
9857 s = src + *usedlen + 2;
9858 if (src[*usedlen + 1] == 'g')
9859 {
9860 flags = (char_u *)"g";
9861 ++s;
9862 }
9863
9864 sep = *s++;
9865 if (sep)
9866 {
9867 /* find end of pattern */
9868 p = vim_strchr(s, sep);
9869 if (p != NULL)
9870 {
9871 pat = vim_strnsave(s, (int)(p - s));
9872 if (pat != NULL)
9873 {
9874 s = p + 1;
9875 /* find end of substitution */
9876 p = vim_strchr(s, sep);
9877 if (p != NULL)
9878 {
9879 sub = vim_strnsave(s, (int)(p - s));
9880 str = vim_strnsave(*fnamep, *fnamelen);
9881 if (sub != NULL && str != NULL)
9882 {
9883 *usedlen = (int)(p + 1 - src);
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009884 s = do_string_sub(str, pat, sub, NULL, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009885 if (s != NULL)
9886 {
9887 *fnamep = s;
9888 *fnamelen = (int)STRLEN(s);
9889 vim_free(*bufp);
9890 *bufp = s;
9891 didit = TRUE;
9892 }
9893 }
9894 vim_free(sub);
9895 vim_free(str);
9896 }
9897 vim_free(pat);
9898 }
9899 }
9900 /* after using ":s", repeat all the modifiers */
9901 if (didit)
9902 goto repeat;
9903 }
9904 }
9905
Bram Moolenaar26df0922014-02-23 23:39:13 +01009906 if (src[*usedlen] == ':' && src[*usedlen + 1] == 'S')
9907 {
Bram Moolenaar5ca84ce2016-03-23 22:28:25 +01009908 /* vim_strsave_shellescape() needs a NUL terminated string. */
Bram Moolenaard4caf5c2016-03-24 19:14:35 +01009909 c = (*fnamep)[*fnamelen];
Bram Moolenaar52c6eaf2016-03-25 18:42:46 +01009910 if (c != NUL)
9911 (*fnamep)[*fnamelen] = NUL;
Bram Moolenaar26df0922014-02-23 23:39:13 +01009912 p = vim_strsave_shellescape(*fnamep, FALSE, FALSE);
Bram Moolenaar52c6eaf2016-03-25 18:42:46 +01009913 if (c != NUL)
9914 (*fnamep)[*fnamelen] = c;
Bram Moolenaar26df0922014-02-23 23:39:13 +01009915 if (p == NULL)
9916 return -1;
9917 vim_free(*bufp);
9918 *bufp = *fnamep = p;
9919 *fnamelen = (int)STRLEN(p);
9920 *usedlen += 2;
9921 }
9922
Bram Moolenaar071d4272004-06-13 20:20:40 +00009923 return valid;
9924}
9925
9926/*
9927 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009928 * When "sub" is NULL "expr" is used, must be a VAR_FUNC or VAR_PARTIAL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009929 * "flags" can be "g" to do a global substitute.
9930 * Returns an allocated string, NULL for error.
9931 */
9932 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01009933do_string_sub(
9934 char_u *str,
9935 char_u *pat,
9936 char_u *sub,
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009937 typval_T *expr,
Bram Moolenaar7454a062016-01-30 15:14:10 +01009938 char_u *flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009939{
9940 int sublen;
9941 regmatch_T regmatch;
9942 int i;
9943 int do_all;
9944 char_u *tail;
Bram Moolenaare90c8532014-11-05 16:03:44 +01009945 char_u *end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009946 garray_T ga;
9947 char_u *ret;
9948 char_u *save_cpo;
Bram Moolenaar8af26912014-01-23 20:09:34 +01009949 char_u *zero_width = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009950
9951 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
9952 save_cpo = p_cpo;
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +00009953 p_cpo = empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009954
9955 ga_init2(&ga, 1, 200);
9956
9957 do_all = (flags[0] == 'g');
9958
9959 regmatch.rm_ic = p_ic;
9960 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
9961 if (regmatch.regprog != NULL)
9962 {
9963 tail = str;
Bram Moolenaare90c8532014-11-05 16:03:44 +01009964 end = str + STRLEN(str);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009965 while (vim_regexec_nl(&regmatch, str, (colnr_T)(tail - str)))
9966 {
Bram Moolenaar8af26912014-01-23 20:09:34 +01009967 /* Skip empty match except for first match. */
9968 if (regmatch.startp[0] == regmatch.endp[0])
9969 {
9970 if (zero_width == regmatch.startp[0])
9971 {
9972 /* avoid getting stuck on a match with an empty string */
Bram Moolenaar8e7048c2014-06-12 18:39:22 +02009973 i = MB_PTR2LEN(tail);
9974 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail,
9975 (size_t)i);
9976 ga.ga_len += i;
9977 tail += i;
Bram Moolenaar8af26912014-01-23 20:09:34 +01009978 continue;
9979 }
9980 zero_width = regmatch.startp[0];
9981 }
9982
Bram Moolenaar071d4272004-06-13 20:20:40 +00009983 /*
9984 * Get some space for a temporary buffer to do the substitution
9985 * into. It will contain:
9986 * - The text up to where the match is.
9987 * - The substituted text.
9988 * - The text after the match.
9989 */
Bram Moolenaar72ab7292016-07-19 19:10:51 +02009990 sublen = vim_regsub(&regmatch, sub, expr, tail, FALSE, TRUE, FALSE);
Bram Moolenaare90c8532014-11-05 16:03:44 +01009991 if (ga_grow(&ga, (int)((end - tail) + sublen -
Bram Moolenaar071d4272004-06-13 20:20:40 +00009992 (regmatch.endp[0] - regmatch.startp[0]))) == FAIL)
9993 {
9994 ga_clear(&ga);
9995 break;
9996 }
9997
9998 /* copy the text up to where the match is */
9999 i = (int)(regmatch.startp[0] - tail);
10000 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
10001 /* add the substituted text */
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010002 (void)vim_regsub(&regmatch, sub, expr, (char_u *)ga.ga_data
Bram Moolenaar071d4272004-06-13 20:20:40 +000010003 + ga.ga_len + i, TRUE, TRUE, FALSE);
10004 ga.ga_len += i + sublen - 1;
Bram Moolenaarceb84af2013-09-29 21:11:05 +020010005 tail = regmatch.endp[0];
10006 if (*tail == NUL)
10007 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010008 if (!do_all)
10009 break;
10010 }
10011
10012 if (ga.ga_data != NULL)
10013 STRCPY((char *)ga.ga_data + ga.ga_len, tail);
10014
Bram Moolenaar473de612013-06-08 18:19:48 +020010015 vim_regfree(regmatch.regprog);
Bram Moolenaar071d4272004-06-13 20:20:40 +000010016 }
10017
10018 ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data);
10019 ga_clear(&ga);
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +000010020 if (p_cpo == empty_option)
10021 p_cpo = save_cpo;
10022 else
Bram Moolenaar72ab7292016-07-19 19:10:51 +020010023 /* Darn, evaluating {sub} expression or {expr} changed the value. */
Bram Moolenaar9c24ccc2008-07-14 21:05:15 +000010024 free_string_option(save_cpo);
Bram Moolenaar071d4272004-06-13 20:20:40 +000010025
10026 return ret;
10027}
10028
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010029 static int
10030filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
10031{
10032 typval_T rettv;
10033 typval_T argv[3];
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010034 int retval = FAIL;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010035
10036 copy_tv(tv, &vimvars[VV_VAL].vv_tv);
10037 argv[0] = vimvars[VV_KEY].vv_tv;
10038 argv[1] = vimvars[VV_VAL].vv_tv;
Bram Moolenaar48570482017-10-30 21:48:41 +010010039 if (eval_expr_typval(expr, argv, 2, &rettv) == FAIL)
10040 goto theend;
Bram Moolenaar73dad1e2016-07-17 22:13:49 +020010041 if (map)
10042 {
10043 /* map(): replace the list item value */
10044 clear_tv(tv);
10045 rettv.v_lock = 0;
10046 *tv = rettv;
10047 }
10048 else
10049 {
10050 int error = FALSE;
10051
10052 /* filter(): when expr is zero remove the item */
10053 *remp = (get_tv_number_chk(&rettv, &error) == 0);
10054 clear_tv(&rettv);
10055 /* On type error, nothing has been removed; return FAIL to stop the
10056 * loop. The error message was given by get_tv_number_chk(). */
10057 if (error)
10058 goto theend;
10059 }
10060 retval = OK;
10061theend:
10062 clear_tv(&vimvars[VV_VAL].vv_tv);
10063 return retval;
10064}
10065
10066
10067/*
10068 * Implementation of map() and filter().
10069 */
10070 void
10071filter_map(typval_T *argvars, typval_T *rettv, int map)
10072{
10073 typval_T *expr;
10074 listitem_T *li, *nli;
10075 list_T *l = NULL;
10076 dictitem_T *di;
10077 hashtab_T *ht;
10078 hashitem_T *hi;
10079 dict_T *d = NULL;
10080 typval_T save_val;
10081 typval_T save_key;
10082 int rem;
10083 int todo;
10084 char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
10085 char_u *arg_errmsg = (char_u *)(map ? N_("map() argument")
10086 : N_("filter() argument"));
10087 int save_did_emsg;
10088 int idx = 0;
10089
10090 if (argvars[0].v_type == VAR_LIST)
10091 {
10092 if ((l = argvars[0].vval.v_list) == NULL
10093 || (!map && tv_check_lock(l->lv_lock, arg_errmsg, TRUE)))
10094 return;
10095 }
10096 else if (argvars[0].v_type == VAR_DICT)
10097 {
10098 if ((d = argvars[0].vval.v_dict) == NULL
10099 || (!map && tv_check_lock(d->dv_lock, arg_errmsg, TRUE)))
10100 return;
10101 }
10102 else
10103 {
10104 EMSG2(_(e_listdictarg), ermsg);
10105 return;
10106 }
10107
10108 expr = &argvars[1];
10109 /* On type errors, the preceding call has already displayed an error
10110 * message. Avoid a misleading error message for an empty string that
10111 * was not passed as argument. */
10112 if (expr->v_type != VAR_UNKNOWN)
10113 {
10114 prepare_vimvar(VV_VAL, &save_val);
10115
10116 /* We reset "did_emsg" to be able to detect whether an error
10117 * occurred during evaluation of the expression. */
10118 save_did_emsg = did_emsg;
10119 did_emsg = FALSE;
10120
10121 prepare_vimvar(VV_KEY, &save_key);
10122 if (argvars[0].v_type == VAR_DICT)
10123 {
10124 vimvars[VV_KEY].vv_type = VAR_STRING;
10125
10126 ht = &d->dv_hashtab;
10127 hash_lock(ht);
10128 todo = (int)ht->ht_used;
10129 for (hi = ht->ht_array; todo > 0; ++hi)
10130 {
10131 if (!HASHITEM_EMPTY(hi))
10132 {
10133 int r;
10134
10135 --todo;
10136 di = HI2DI(hi);
10137 if (map &&
10138 (tv_check_lock(di->di_tv.v_lock, arg_errmsg, TRUE)
10139 || var_check_ro(di->di_flags, arg_errmsg, TRUE)))
10140 break;
10141 vimvars[VV_KEY].vv_str = vim_strsave(di->di_key);
10142 r = filter_map_one(&di->di_tv, expr, map, &rem);
10143 clear_tv(&vimvars[VV_KEY].vv_tv);
10144 if (r == FAIL || did_emsg)
10145 break;
10146 if (!map && rem)
10147 {
10148 if (var_check_fixed(di->di_flags, arg_errmsg, TRUE)
10149 || var_check_ro(di->di_flags, arg_errmsg, TRUE))
10150 break;
10151 dictitem_remove(d, di);
10152 }
10153 }
10154 }
10155 hash_unlock(ht);
10156 }
10157 else
10158 {
10159 vimvars[VV_KEY].vv_type = VAR_NUMBER;
10160
10161 for (li = l->lv_first; li != NULL; li = nli)
10162 {
10163 if (map && tv_check_lock(li->li_tv.v_lock, arg_errmsg, TRUE))
10164 break;
10165 nli = li->li_next;
10166 vimvars[VV_KEY].vv_nr = idx;
10167 if (filter_map_one(&li->li_tv, expr, map, &rem) == FAIL
10168 || did_emsg)
10169 break;
10170 if (!map && rem)
10171 listitem_remove(l, li);
10172 ++idx;
10173 }
10174 }
10175
10176 restore_vimvar(VV_KEY, &save_key);
10177 restore_vimvar(VV_VAL, &save_val);
10178
10179 did_emsg |= save_did_emsg;
10180 }
10181
10182 copy_tv(&argvars[0], rettv);
10183}
10184
Bram Moolenaar071d4272004-06-13 20:20:40 +000010185#endif /* defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) */