Mercurial > vim

comparison src/eval.c @ 56:dbf53ece2e23 v7.0029

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.0029
author vimboss
date Mon, 03 Jan 2005 21:06:01 +0000
parents 8c25f10d49e7
children 7557b6ea0fb1
comparison
equal deleted inserted replaced
55:225cc00b2eda 56:dbf53ece2e23
35 #else 35 #else
36 typedef int varnumber_T; 36 typedef int varnumber_T;
37 #endif 37 #endif
38 38
39 /* 39 /*
40 * Structure to hold an internal variable. 40 * Structure to hold an internal variable without a name.
41 */ 41 */
42 typedef struct 42 typedef struct
43 { 43 {
44 char_u *var_name; /* name of variable */ 44 char v_type; /* see below: VAR_NUMBER, VAR_STRING, etc. */
45 char var_type; /* VAR_NUMBER or VAR_STRING */
46 union 45 union
47 { 46 {
48 varnumber_T var_number; /* number value */ 47 varnumber_T v_number; /* number value */
49 char_u *var_string; /* string value (Careful: can be NULL!) */ 48 char_u *v_string; /* string value (can be NULL!) */
50 } var_val; 49 struct listvar_S *v_list; /* list value (can be NULL!) */
50 } vval;
51 } typeval;
52
53 /* Values for "v_type". */
54 #define VAR_UNKNOWN 0
55 #define VAR_NUMBER 1 /* "v_number" is used */
56 #define VAR_STRING 2 /* "v_string" is used */
57 #define VAR_FUNC 3 /* "v_string" is function name */
58 #define VAR_LIST 4 /* "v_list" is used */
59
60 /*
61 * Structure to hold an internal variable with a name.
62 * The "tv" must come first, so that this can be used as a "typeval" as well.
63 */
64 typedef struct
65 {
66 typeval tv; /* type and value of the variable */
67 char_u *v_name; /* name of variable */
51 } var; 68 } var;
52 69
53 #define VAR_UNKNOWN 0
54 #define VAR_NUMBER 1
55 #define VAR_STRING 2
56
57 typedef var * VAR; 70 typedef var * VAR;
71
72 /*
73 * Structure to hold an item of a list: an internal variable without a name.
74 */
75 struct listitem_S
76 {
77 struct listitem_S *li_next; /* next item in list */
78 struct listitem_S *li_prev; /* previous item in list */
79 typeval li_tv; /* type and value of the variable */
80 };
81
82 typedef struct listitem_S listitem;
83
84 /*
85 * Structure to hold the info about a list.
86 */
87 struct listvar_S
88 {
89 int lv_refcount; /* reference count */
90 listitem *lv_first; /* first item, NULL if none */
91 listitem *lv_last; /* last item, NULL if none */
92 };
93
94 typedef struct listvar_S listvar;
95
96 #define VAR_LIST_MAXNEST 100 /* maximum nesting of lists */
97 static char_u *e_listidx = (char_u *)N_("E999: list index out of range: %ld");
58 98
59 /* 99 /*
60 * All user-defined global variables are stored in "variables". 100 * All user-defined global variables are stored in "variables".
61 */ 101 */
62 garray_T variables = {0, 0, sizeof(var), 4, NULL}; 102 garray_T variables = {0, 0, sizeof(var), 4, NULL};
112 { 152 {
113 ufunc_T *func; /* function being called */ 153 ufunc_T *func; /* function being called */
114 int linenr; /* next line to be executed */ 154 int linenr; /* next line to be executed */
115 int returned; /* ":return" used */ 155 int returned; /* ":return" used */
116 int argcount; /* nr of arguments */ 156 int argcount; /* nr of arguments */
117 VAR argvars; /* arguments */ 157 typeval *argvars; /* arguments */
118 var a0_var; /* "a:0" variable */ 158 var a0_var; /* "a:0" variable */
119 var firstline; /* "a:firstline" variable */ 159 var firstline; /* "a:firstline" variable */
120 var lastline; /* "a:lastline" variable */ 160 var lastline; /* "a:lastline" variable */
121 garray_T l_vars; /* local function variables */ 161 garray_T l_vars; /* local function variables */
122 VAR retvar; /* return value variable */ 162 typeval *retvar; /* return value variable */
123 linenr_T breakpoint; /* next line with breakpoint or zero */ 163 linenr_T breakpoint; /* next line with breakpoint or zero */
124 int dbg_tick; /* debug_tick when breakpoint was set */ 164 int dbg_tick; /* debug_tick when breakpoint was set */
125 int level; /* top nesting level of executed function */ 165 int level; /* top nesting level of executed function */
126 }; 166 };
127 167
234 {"cmdbang", sizeof("cmdbang") - 1, NULL, VAR_NUMBER, VV_RO}, 274 {"cmdbang", sizeof("cmdbang") - 1, NULL, VAR_NUMBER, VV_RO},
235 {"insertmode", sizeof("insertmode") - 1, NULL, VAR_STRING, VV_RO}, 275 {"insertmode", sizeof("insertmode") - 1, NULL, VAR_STRING, VV_RO},
236 }; 276 };
237 277
238 static int eval0 __ARGS((char_u *arg, VAR retvar, char_u **nextcmd, int evaluate)); 278 static int eval0 __ARGS((char_u *arg, VAR retvar, char_u **nextcmd, int evaluate));
239 static int eval1 __ARGS((char_u **arg, VAR retvar, int evaluate)); 279 static int eval1 __ARGS((char_u **arg, typeval *retvar, int evaluate));
240 static int eval2 __ARGS((char_u **arg, VAR retvar, int evaluate)); 280 static int eval2 __ARGS((char_u **arg, typeval *retvar, int evaluate));
241 static int eval3 __ARGS((char_u **arg, VAR retvar, int evaluate)); 281 static int eval3 __ARGS((char_u **arg, typeval *retvar, int evaluate));
242 static int eval4 __ARGS((char_u **arg, VAR retvar, int evaluate)); 282 static int eval4 __ARGS((char_u **arg, typeval *retvar, int evaluate));
243 static int eval5 __ARGS((char_u **arg, VAR retvar, int evaluate)); 283 static int eval5 __ARGS((char_u **arg, typeval *retvar, int evaluate));
244 static int eval6 __ARGS((char_u **arg, VAR retvar, int evaluate)); 284 static int eval6 __ARGS((char_u **arg, typeval *retvar, int evaluate));
245 static int eval7 __ARGS((char_u **arg, VAR retvar, int evaluate)); 285 static int eval7 __ARGS((char_u **arg, typeval *retvar, int evaluate));
246 static int get_option_var __ARGS((char_u **arg, VAR retvar, int evaluate)); 286 static int eval_index __ARGS((char_u **arg, typeval *retvar, int evaluate));
247 static int get_string_var __ARGS((char_u **arg, VAR retvar, int evaluate)); 287 static int get_option_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate));
248 static int get_lit_string_var __ARGS((char_u **arg, VAR retvar, int evaluate)); 288 static int get_string_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate));
249 static int get_env_var __ARGS((char_u **arg, VAR retvar, int evaluate)); 289 static int get_lit_string_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate));
290 static int get_list_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate));
291 static listvar *list_alloc __ARGS((void));
292 static void list_unref __ARGS((listvar *l));
293 static void list_free __ARGS((listvar *l));
294 static listitem *listitem_alloc __ARGS((void));
295 static void listitem_free __ARGS((listitem *item));
296 static long list_len __ARGS((listvar *l));
297 static listitem *list_find __ARGS((listvar *l, long n));
298 static void list_append __ARGS((listvar *l, listitem *item));
299 static int list_append_tv __ARGS((listvar *l, typeval *tv));
300 static listvar *list_copy __ARGS((listvar *orig, int deep));
301 static listitem *list_getrem __ARGS((listvar *l, long n));
302 static char_u *list2string __ARGS((typeval *tv));
303 static char_u *tv2string __ARGS((typeval *tv, char_u **tofree));
304 static int get_env_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate));
250 static int find_internal_func __ARGS((char_u *name)); 305 static int find_internal_func __ARGS((char_u *name));
251 static int get_func_var __ARGS((char_u *name, int len, VAR retvar, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate)); 306 static char_u *deref_func_name __ARGS((char_u *name, int *lenp));
252 static int call_func __ARGS((char_u *name, int len, VAR retvar, int argcount, VAR argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate)); 307 static int get_func_vartv __ARGS((char_u *name, int len, typeval *retvar, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate));
253 static void f_append __ARGS((VAR argvars, VAR retvar)); 308 static int call_func __ARGS((char_u *name, int len, typeval *retvar, int argcount, typeval *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate));
254 static void f_argc __ARGS((VAR argvars, VAR retvar)); 309 static void f_append __ARGS((typeval *argvars, typeval *retvar));
255 static void f_argidx __ARGS((VAR argvars, VAR retvar)); 310 static void f_argc __ARGS((typeval *argvars, typeval *retvar));
256 static void f_argv __ARGS((VAR argvars, VAR retvar)); 311 static void f_argidx __ARGS((typeval *argvars, typeval *retvar));
257 static void f_browse __ARGS((VAR argvars, VAR retvar)); 312 static void f_argv __ARGS((typeval *argvars, typeval *retvar));
258 static void f_browsedir __ARGS((VAR argvars, VAR retvar)); 313 static void f_browse __ARGS((typeval *argvars, typeval *retvar));
259 static buf_T *find_buffer __ARGS((VAR avar)); 314 static void f_browsedir __ARGS((typeval *argvars, typeval *retvar));
260 static void f_bufexists __ARGS((VAR argvars, VAR retvar)); 315 static buf_T *find_buffer __ARGS((typeval *avar));
261 static void f_buflisted __ARGS((VAR argvars, VAR retvar)); 316 static void f_bufexists __ARGS((typeval *argvars, typeval *retvar));
262 static void f_bufloaded __ARGS((VAR argvars, VAR retvar)); 317 static void f_buflisted __ARGS((typeval *argvars, typeval *retvar));
263 static buf_T *get_buf_var __ARGS((VAR avar)); 318 static void f_bufloaded __ARGS((typeval *argvars, typeval *retvar));
264 static void f_bufname __ARGS((VAR argvars, VAR retvar)); 319 static buf_T *get_buf_vartv __ARGS((typeval *avar));
265 static void f_bufnr __ARGS((VAR argvars, VAR retvar)); 320 static void f_bufname __ARGS((typeval *argvars, typeval *retvar));
266 static void f_bufwinnr __ARGS((VAR argvars, VAR retvar)); 321 static void f_bufnr __ARGS((typeval *argvars, typeval *retvar));
267 static void f_byte2line __ARGS((VAR argvars, VAR retvar)); 322 static void f_bufwinnr __ARGS((typeval *argvars, typeval *retvar));
268 static void f_byteidx __ARGS((VAR argvars, VAR retvar)); 323 static void f_byte2line __ARGS((typeval *argvars, typeval *retvar));
269 static void f_char2nr __ARGS((VAR argvars, VAR retvar)); 324 static void f_byteidx __ARGS((typeval *argvars, typeval *retvar));
270 static void f_cindent __ARGS((VAR argvars, VAR retvar)); 325 static void f_char2nr __ARGS((typeval *argvars, typeval *retvar));
271 static void f_col __ARGS((VAR argvars, VAR retvar)); 326 static void f_cindent __ARGS((typeval *argvars, typeval *retvar));
272 static void f_confirm __ARGS((VAR argvars, VAR retvar)); 327 static void f_col __ARGS((typeval *argvars, typeval *retvar));
273 static void f_cscope_connection __ARGS((VAR argvars, VAR retvar)); 328 static void f_confirm __ARGS((typeval *argvars, typeval *retvar));
274 static void f_cursor __ARGS((VAR argsvars, VAR retvar)); 329 static void f_copy __ARGS((typeval *argvars, typeval *retvar));
275 static void f_delete __ARGS((VAR argvars, VAR retvar)); 330 static void f_cscope_connection __ARGS((typeval *argvars, typeval *retvar));
276 static void f_did_filetype __ARGS((VAR argvars, VAR retvar)); 331 static void f_cursor __ARGS((typeval *argsvars, typeval *retvar));
277 static void f_diff_filler __ARGS((VAR argvars, VAR retvar)); 332 static void f_deepcopy __ARGS((typeval *argvars, typeval *retvar));
278 static void f_diff_hlID __ARGS((VAR argvars, VAR retvar)); 333 static void f_delete __ARGS((typeval *argvars, typeval *retvar));
279 static void f_escape __ARGS((VAR argvars, VAR retvar)); 334 static void f_did_filetype __ARGS((typeval *argvars, typeval *retvar));
280 static void f_eventhandler __ARGS((VAR argvars, VAR retvar)); 335 static void f_diff_filler __ARGS((typeval *argvars, typeval *retvar));
281 static void f_executable __ARGS((VAR argvars, VAR retvar)); 336 static void f_diff_hlID __ARGS((typeval *argvars, typeval *retvar));
282 static void f_exists __ARGS((VAR argvars, VAR retvar)); 337 static void f_escape __ARGS((typeval *argvars, typeval *retvar));
283 static void f_expand __ARGS((VAR argvars, VAR retvar)); 338 static void f_eventhandler __ARGS((typeval *argvars, typeval *retvar));
284 static void f_filereadable __ARGS((VAR argvars, VAR retvar)); 339 static void f_executable __ARGS((typeval *argvars, typeval *retvar));
285 static void f_filewritable __ARGS((VAR argvars, VAR retvar)); 340 static void f_exists __ARGS((typeval *argvars, typeval *retvar));
286 static void f_finddir __ARGS((VAR argvars, VAR retvar)); 341 static void f_expand __ARGS((typeval *argvars, typeval *retvar));
287 static void f_findfile __ARGS((VAR argvars, VAR retvar)); 342 static void f_filereadable __ARGS((typeval *argvars, typeval *retvar));
288 static void f_findfilendir __ARGS((VAR argvars, VAR retvar, int dir)); 343 static void f_filewritable __ARGS((typeval *argvars, typeval *retvar));
289 static void f_fnamemodify __ARGS((VAR argvars, VAR retvar)); 344 static void f_finddir __ARGS((typeval *argvars, typeval *retvar));
290 static void f_foldclosed __ARGS((VAR argvars, VAR retvar)); 345 static void f_findfile __ARGS((typeval *argvars, typeval *retvar));
291 static void f_foldclosedend __ARGS((VAR argvars, VAR retvar)); 346 static void f_findfilendir __ARGS((typeval *argvars, typeval *retvar, int dir));
292 static void foldclosed_both __ARGS((VAR argvars, VAR retvar, int end)); 347 static void f_fnamemodify __ARGS((typeval *argvars, typeval *retvar));
293 static void f_foldlevel __ARGS((VAR argvars, VAR retvar)); 348 static void f_foldclosed __ARGS((typeval *argvars, typeval *retvar));
294 static void f_foldtext __ARGS((VAR argvars, VAR retvar)); 349 static void f_foldclosedend __ARGS((typeval *argvars, typeval *retvar));
295 static void f_foldtextresult __ARGS((VAR argvars, VAR retvar)); 350 static void foldclosed_both __ARGS((typeval *argvars, typeval *retvar, int end));
296 static void f_foreground __ARGS((VAR argvars, VAR retvar)); 351 static void f_foldlevel __ARGS((typeval *argvars, typeval *retvar));
297 static void f_getbufvar __ARGS((VAR argvars, VAR retvar)); 352 static void f_foldtext __ARGS((typeval *argvars, typeval *retvar));
298 static void f_getchar __ARGS((VAR argvars, VAR retvar)); 353 static void f_foldtextresult __ARGS((typeval *argvars, typeval *retvar));
299 static void f_getcharmod __ARGS((VAR argvars, VAR retvar)); 354 static void f_foreground __ARGS((typeval *argvars, typeval *retvar));
300 static void f_getcmdline __ARGS((VAR argvars, VAR retvar)); 355 static void f_function __ARGS((typeval *argvars, typeval *retvar));
301 static void f_getcmdpos __ARGS((VAR argvars, VAR retvar)); 356 static void f_getbufvar __ARGS((typeval *argvars, typeval *retvar));
302 static void f_getcwd __ARGS((VAR argvars, VAR retvar)); 357 static void f_getchar __ARGS((typeval *argvars, typeval *retvar));
303 static void f_getfontname __ARGS((VAR argvars, VAR retvar)); 358 static void f_getcharmod __ARGS((typeval *argvars, typeval *retvar));
304 static void f_getfperm __ARGS((VAR argvars, VAR retvar)); 359 static void f_getcmdline __ARGS((typeval *argvars, typeval *retvar));
305 static void f_getfsize __ARGS((VAR argvars, VAR retvar)); 360 static void f_getcmdpos __ARGS((typeval *argvars, typeval *retvar));
306 static void f_getftime __ARGS((VAR argvars, VAR retvar)); 361 static void f_getcwd __ARGS((typeval *argvars, typeval *retvar));
307 static void f_getftype __ARGS((VAR argvars, VAR retvar)); 362 static void f_getfontname __ARGS((typeval *argvars, typeval *retvar));
308 static void f_getline __ARGS((VAR argvars, VAR retvar)); 363 static void f_getfperm __ARGS((typeval *argvars, typeval *retvar));
309 static void f_getreg __ARGS((VAR argvars, VAR retvar)); 364 static void f_getfsize __ARGS((typeval *argvars, typeval *retvar));
310 static void f_getregtype __ARGS((VAR argvars, VAR retvar)); 365 static void f_getftime __ARGS((typeval *argvars, typeval *retvar));
311 static void f_getwinposx __ARGS((VAR argvars, VAR retvar)); 366 static void f_getftype __ARGS((typeval *argvars, typeval *retvar));
312 static void f_getwinposy __ARGS((VAR argvars, VAR retvar)); 367 static void f_getline __ARGS((typeval *argvars, typeval *retvar));
313 static void f_getwinvar __ARGS((VAR argvars, VAR retvar)); 368 static void f_getreg __ARGS((typeval *argvars, typeval *retvar));
314 static void f_glob __ARGS((VAR argvars, VAR retvar)); 369 static void f_getregtype __ARGS((typeval *argvars, typeval *retvar));
315 static void f_globpath __ARGS((VAR argvars, VAR retvar)); 370 static void f_getwinposx __ARGS((typeval *argvars, typeval *retvar));
316 static void f_has __ARGS((VAR argvars, VAR retvar)); 371 static void f_getwinposy __ARGS((typeval *argvars, typeval *retvar));
317 static void f_hasmapto __ARGS((VAR argvars, VAR retvar)); 372 static void f_getwinvar __ARGS((typeval *argvars, typeval *retvar));
318 static void f_histadd __ARGS((VAR argvars, VAR retvar)); 373 static void f_glob __ARGS((typeval *argvars, typeval *retvar));
319 static void f_histdel __ARGS((VAR argvars, VAR retvar)); 374 static void f_globpath __ARGS((typeval *argvars, typeval *retvar));
320 static void f_histget __ARGS((VAR argvars, VAR retvar)); 375 static void f_has __ARGS((typeval *argvars, typeval *retvar));
321 static void f_histnr __ARGS((VAR argvars, VAR retvar)); 376 static void f_hasmapto __ARGS((typeval *argvars, typeval *retvar));
322 static void f_hlexists __ARGS((VAR argvars, VAR retvar)); 377 static void f_histadd __ARGS((typeval *argvars, typeval *retvar));
323 static void f_hlID __ARGS((VAR argvars, VAR retvar)); 378 static void f_histdel __ARGS((typeval *argvars, typeval *retvar));
324 static void f_hostname __ARGS((VAR argvars, VAR retvar)); 379 static void f_histget __ARGS((typeval *argvars, typeval *retvar));
325 static void f_iconv __ARGS((VAR argvars, VAR retvar)); 380 static void f_histnr __ARGS((typeval *argvars, typeval *retvar));
326 static void f_indent __ARGS((VAR argvars, VAR retvar)); 381 static void f_hlexists __ARGS((typeval *argvars, typeval *retvar));
327 static void f_isdirectory __ARGS((VAR argvars, VAR retvar)); 382 static void f_hlID __ARGS((typeval *argvars, typeval *retvar));
328 static void f_input __ARGS((VAR argvars, VAR retvar)); 383 static void f_hostname __ARGS((typeval *argvars, typeval *retvar));
329 static void f_inputdialog __ARGS((VAR argvars, VAR retvar)); 384 static void f_iconv __ARGS((typeval *argvars, typeval *retvar));
330 static void f_inputrestore __ARGS((VAR argvars, VAR retvar)); 385 static void f_indent __ARGS((typeval *argvars, typeval *retvar));
331 static void f_inputsave __ARGS((VAR argvars, VAR retvar)); 386 static void f_insert __ARGS((typeval *argvars, typeval *retvar));
332 static void f_inputsecret __ARGS((VAR argvars, VAR retvar)); 387 static void f_isdirectory __ARGS((typeval *argvars, typeval *retvar));
333 static void f_last_buffer_nr __ARGS((VAR argvars, VAR retvar)); 388 static void f_input __ARGS((typeval *argvars, typeval *retvar));
334 static void f_libcall __ARGS((VAR argvars, VAR retvar)); 389 static void f_inputdialog __ARGS((typeval *argvars, typeval *retvar));
335 static void f_libcallnr __ARGS((VAR argvars, VAR retvar)); 390 static void f_inputrestore __ARGS((typeval *argvars, typeval *retvar));
336 static void libcall_common __ARGS((VAR argvars, VAR retvar, int type)); 391 static void f_inputsave __ARGS((typeval *argvars, typeval *retvar));
337 static void f_line __ARGS((VAR argvars, VAR retvar)); 392 static void f_inputsecret __ARGS((typeval *argvars, typeval *retvar));
338 static void f_line2byte __ARGS((VAR argvars, VAR retvar)); 393 static void f_last_buffer_nr __ARGS((typeval *argvars, typeval *retvar));
339 static void f_lispindent __ARGS((VAR argvars, VAR retvar)); 394 static void f_len __ARGS((typeval *argvars, typeval *retvar));
340 static void f_localtime __ARGS((VAR argvars, VAR retvar)); 395 static void f_libcall __ARGS((typeval *argvars, typeval *retvar));
341 static void f_maparg __ARGS((VAR argvars, VAR retvar)); 396 static void f_libcallnr __ARGS((typeval *argvars, typeval *retvar));
342 static void f_mapcheck __ARGS((VAR argvars, VAR retvar)); 397 static void libcall_common __ARGS((typeval *argvars, typeval *retvar, int type));
343 static void get_maparg __ARGS((VAR argvars, VAR retvar, int exact)); 398 static void f_line __ARGS((typeval *argvars, typeval *retvar));
344 static void f_match __ARGS((VAR argvars, VAR retvar)); 399 static void f_line2byte __ARGS((typeval *argvars, typeval *retvar));
345 static void f_matchend __ARGS((VAR argvars, VAR retvar)); 400 static void f_lispindent __ARGS((typeval *argvars, typeval *retvar));
346 static void f_matchstr __ARGS((VAR argvars, VAR retvar)); 401 static void f_localtime __ARGS((typeval *argvars, typeval *retvar));
347 static void f_mode __ARGS((VAR argvars, VAR retvar)); 402 static void f_maparg __ARGS((typeval *argvars, typeval *retvar));
348 static void f_nextnonblank __ARGS((VAR argvars, VAR retvar)); 403 static void f_mapcheck __ARGS((typeval *argvars, typeval *retvar));
349 static void f_nr2char __ARGS((VAR argvars, VAR retvar)); 404 static void get_maparg __ARGS((typeval *argvars, typeval *retvar, int exact));
350 static void f_prevnonblank __ARGS((VAR argvars, VAR retvar)); 405 static void f_match __ARGS((typeval *argvars, typeval *retvar));
351 static void f_setbufvar __ARGS((VAR argvars, VAR retvar)); 406 static void f_matchend __ARGS((typeval *argvars, typeval *retvar));
352 static void f_setcmdpos __ARGS((VAR argvars, VAR retvar)); 407 static void f_matchstr __ARGS((typeval *argvars, typeval *retvar));
353 static void f_setwinvar __ARGS((VAR argvars, VAR retvar)); 408 static void f_mode __ARGS((typeval *argvars, typeval *retvar));
354 static void f_rename __ARGS((VAR argvars, VAR retvar)); 409 static void f_nextnonblank __ARGS((typeval *argvars, typeval *retvar));
355 static void f_resolve __ARGS((VAR argvars, VAR retvar)); 410 static void f_nr2char __ARGS((typeval *argvars, typeval *retvar));
356 static void f_search __ARGS((VAR argvars, VAR retvar)); 411 static void f_prevnonblank __ARGS((typeval *argvars, typeval *retvar));
357 static void f_searchpair __ARGS((VAR argvars, VAR retvar)); 412 static void f_setbufvar __ARGS((typeval *argvars, typeval *retvar));
358 static int get_search_arg __ARGS((VAR varp, int *flagsp)); 413 static void f_setcmdpos __ARGS((typeval *argvars, typeval *retvar));
359 static void f_remote_expr __ARGS((VAR argvars, VAR retvar)); 414 static void f_setwinvar __ARGS((typeval *argvars, typeval *retvar));
360 static void f_remote_foreground __ARGS((VAR argvars, VAR retvar)); 415 static void f_remove __ARGS((typeval *argvars, typeval *retvar));
361 static void f_remote_peek __ARGS((VAR argvars, VAR retvar)); 416 static void f_rename __ARGS((typeval *argvars, typeval *retvar));
362 static void f_remote_read __ARGS((VAR argvars, VAR retvar)); 417 static void f_resolve __ARGS((typeval *argvars, typeval *retvar));
363 static void f_remote_send __ARGS((VAR argvars, VAR retvar)); 418 static void f_search __ARGS((typeval *argvars, typeval *retvar));
364 static void f_repeat __ARGS((VAR argvars, VAR retvar)); 419 static void f_searchpair __ARGS((typeval *argvars, typeval *retvar));
365 static void f_server2client __ARGS((VAR argvars, VAR retvar)); 420 static int get_search_arg __ARGS((typeval *varp, int *flagsp));
366 static void f_serverlist __ARGS((VAR argvars, VAR retvar)); 421 static void f_remote_expr __ARGS((typeval *argvars, typeval *retvar));
367 static void f_setline __ARGS((VAR argvars, VAR retvar)); 422 static void f_remote_foreground __ARGS((typeval *argvars, typeval *retvar));
368 static void f_setreg __ARGS((VAR argvars, VAR retvar)); 423 static void f_remote_peek __ARGS((typeval *argvars, typeval *retvar));
369 static void f_simplify __ARGS((VAR argvars, VAR retvar)); 424 static void f_remote_read __ARGS((typeval *argvars, typeval *retvar));
370 static void find_some_match __ARGS((VAR argvars, VAR retvar, int start)); 425 static void f_remote_send __ARGS((typeval *argvars, typeval *retvar));
371 static void f_strftime __ARGS((VAR argvars, VAR retvar)); 426 static void f_repeat __ARGS((typeval *argvars, typeval *retvar));
372 static void f_stridx __ARGS((VAR argvars, VAR retvar)); 427 static void f_server2client __ARGS((typeval *argvars, typeval *retvar));
373 static void f_strlen __ARGS((VAR argvars, VAR retvar)); 428 static void f_serverlist __ARGS((typeval *argvars, typeval *retvar));
374 static void f_strpart __ARGS((VAR argvars, VAR retvar)); 429 static void f_setline __ARGS((typeval *argvars, typeval *retvar));
375 static void f_strridx __ARGS((VAR argvars, VAR retvar)); 430 static void f_setreg __ARGS((typeval *argvars, typeval *retvar));
376 static void f_strtrans __ARGS((VAR argvars, VAR retvar)); 431 static void f_simplify __ARGS((typeval *argvars, typeval *retvar));
377 static void f_synID __ARGS((VAR argvars, VAR retvar)); 432 static void find_some_match __ARGS((typeval *argvars, typeval *retvar, int start));
378 static void f_synIDattr __ARGS((VAR argvars, VAR retvar)); 433 static void f_strftime __ARGS((typeval *argvars, typeval *retvar));
379 static void f_synIDtrans __ARGS((VAR argvars, VAR retvar)); 434 static void f_stridx __ARGS((typeval *argvars, typeval *retvar));
380 static void f_system __ARGS((VAR argvars, VAR retvar)); 435 static void f_string __ARGS((typeval *argvars, typeval *retvar));
381 static void f_submatch __ARGS((VAR argvars, VAR retvar)); 436 static void f_strlen __ARGS((typeval *argvars, typeval *retvar));
382 static void f_substitute __ARGS((VAR argvars, VAR retvar)); 437 static void f_strpart __ARGS((typeval *argvars, typeval *retvar));
383 static void f_tempname __ARGS((VAR argvars, VAR retvar)); 438 static void f_strridx __ARGS((typeval *argvars, typeval *retvar));
384 static void f_tolower __ARGS((VAR argvars, VAR retvar)); 439 static void f_strtrans __ARGS((typeval *argvars, typeval *retvar));
385 static void f_toupper __ARGS((VAR argvars, VAR retvar)); 440 static void f_synID __ARGS((typeval *argvars, typeval *retvar));
386 static void f_tr __ARGS((VAR argvars, VAR retvar)); 441 static void f_synIDattr __ARGS((typeval *argvars, typeval *retvar));
387 static void f_type __ARGS((VAR argvars, VAR retvar)); 442 static void f_synIDtrans __ARGS((typeval *argvars, typeval *retvar));
388 static void f_virtcol __ARGS((VAR argvars, VAR retvar)); 443 static void f_system __ARGS((typeval *argvars, typeval *retvar));
389 static void f_visualmode __ARGS((VAR argvars, VAR retvar)); 444 static void f_submatch __ARGS((typeval *argvars, typeval *retvar));
390 static void f_winbufnr __ARGS((VAR argvars, VAR retvar)); 445 static void f_substitute __ARGS((typeval *argvars, typeval *retvar));
391 static void f_wincol __ARGS((VAR argvars, VAR retvar)); 446 static void f_tempname __ARGS((typeval *argvars, typeval *retvar));
392 static void f_winheight __ARGS((VAR argvars, VAR retvar)); 447 static void f_tolower __ARGS((typeval *argvars, typeval *retvar));
393 static void f_winline __ARGS((VAR argvars, VAR retvar)); 448 static void f_toupper __ARGS((typeval *argvars, typeval *retvar));
394 static void f_winnr __ARGS((VAR argvars, VAR retvar)); 449 static void f_tr __ARGS((typeval *argvars, typeval *retvar));
395 static void f_winrestcmd __ARGS((VAR argvars, VAR retvar)); 450 static void f_type __ARGS((typeval *argvars, typeval *retvar));
396 static void f_winwidth __ARGS((VAR argvars, VAR retvar)); 451 static void f_virtcol __ARGS((typeval *argvars, typeval *retvar));
397 static win_T *find_win_by_nr __ARGS((VAR vp)); 452 static void f_visualmode __ARGS((typeval *argvars, typeval *retvar));
398 static pos_T *var2fpos __ARGS((VAR varp, int lnum)); 453 static void f_winbufnr __ARGS((typeval *argvars, typeval *retvar));
454 static void f_wincol __ARGS((typeval *argvars, typeval *retvar));
455 static void f_winheight __ARGS((typeval *argvars, typeval *retvar));
456 static void f_winline __ARGS((typeval *argvars, typeval *retvar));
457 static void f_winnr __ARGS((typeval *argvars, typeval *retvar));
458 static void f_winrestcmd __ARGS((typeval *argvars, typeval *retvar));
459 static void f_winwidth __ARGS((typeval *argvars, typeval *retvar));
460 static win_T *find_win_by_nr __ARGS((typeval *vp));
461 static pos_T *var2fpos __ARGS((typeval *varp, int lnum));
399 static int get_env_len __ARGS((char_u **arg)); 462 static int get_env_len __ARGS((char_u **arg));
400 static int get_id_len __ARGS((char_u **arg)); 463 static int get_id_len __ARGS((char_u **arg));
401 static int get_func_len __ARGS((char_u **arg, char_u **alias, int evaluate)); 464 static int get_func_len __ARGS((char_u **arg, char_u **alias, int evaluate));
402 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end)); 465 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end));
403 static int eval_isnamec __ARGS((int c)); 466 static int eval_isnamec __ARGS((int c));
404 static int find_vim_var __ARGS((char_u *name, int len)); 467 static int find_vim_var __ARGS((char_u *name, int len));
405 static int get_var_var __ARGS((char_u *name, int len, VAR retvar)); 468 static int get_var_vartv __ARGS((char_u *name, int len, typeval *retvar));
406 static VAR alloc_var __ARGS((void)); 469 static VAR alloc_var __ARGS((void));
407 static VAR alloc_string_var __ARGS((char_u *string)); 470 static typeval *alloc_vartv __ARGS((void));
408 static void free_var __ARGS((VAR varp)); 471 static typeval *alloc_string_vartv __ARGS((char_u *string));
409 static void clear_var __ARGS((VAR varp)); 472 static void free_vartv __ARGS((typeval *varp));
410 static long get_var_number __ARGS((VAR varp)); 473 static void clear_vartv __ARGS((typeval *varp));
411 static linenr_T get_var_lnum __ARGS((VAR argvars)); 474 static long get_vartv_number __ARGS((typeval *varp));
412 static char_u *get_var_string __ARGS((VAR varp)); 475 static linenr_T get_vartv_lnum __ARGS((typeval *argvars));
413 static char_u *get_var_string_buf __ARGS((VAR varp, char_u *buf)); 476 static char_u *get_vartv_string __ARGS((typeval *varp));
477 static char_u *get_vartv_string_buf __ARGS((typeval *varp, char_u *buf));
414 static VAR find_var __ARGS((char_u *name, int writing)); 478 static VAR find_var __ARGS((char_u *name, int writing));
415 static VAR find_var_in_ga __ARGS((garray_T *gap, char_u *varname)); 479 static VAR find_var_in_ga __ARGS((garray_T *gap, char_u *varname));
416 static garray_T *find_var_ga __ARGS((char_u *name, char_u **varname)); 480 static garray_T *find_var_ga __ARGS((char_u *name, char_u **varname));
417 static void var_free_one __ARGS((VAR v)); 481 static void clear_var __ARGS((VAR v));
418 static void list_one_var __ARGS((VAR v, char_u *prefix)); 482 static void list_one_var __ARGS((VAR v, char_u *prefix));
419 static void list_vim_var __ARGS((int i)); 483 static void list_vim_var __ARGS((int i));
420 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string)); 484 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string));
421 static void set_var __ARGS((char_u *name, VAR varp, int copy)); 485 static void set_var __ARGS((char_u *name, typeval *varp, int copy));
422 static void copy_var __ARGS((VAR from, VAR to)); 486 static void copy_vartv __ARGS((typeval *from, typeval *to));
423 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags)); 487 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags));
424 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int internal)); 488 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int internal));
425 static int eval_fname_script __ARGS((char_u *p)); 489 static int eval_fname_script __ARGS((char_u *p));
426 static int eval_fname_sid __ARGS((char_u *p)); 490 static int eval_fname_sid __ARGS((char_u *p));
427 static void list_func_head __ARGS((ufunc_T *fp, int indent)); 491 static void list_func_head __ARGS((ufunc_T *fp, int indent));
428 static void cat_func_name __ARGS((char_u *buf, ufunc_T *fp)); 492 static void cat_func_name __ARGS((char_u *buf, ufunc_T *fp));
429 static ufunc_T *find_func __ARGS((char_u *name)); 493 static ufunc_T *find_func __ARGS((char_u *name));
430 static void call_user_func __ARGS((ufunc_T *fp, int argcount, VAR argvars, VAR retvar, linenr_T firstline, linenr_T lastline)); 494 static int function_exists __ARGS((char_u *name));
495 static void call_user_func __ARGS((ufunc_T *fp, int argcount, typeval *argvars, typeval *retvar, linenr_T firstline, linenr_T lastline));
496
497 #define get_var_string(p) get_vartv_string(&(p)->tv)
498 #define get_var_string_buf(p, b) get_vartv_string_buf(&(p)->tv, (b))
499 #define get_var_number(p) get_vartv_number(&((p)->tv))
431 500
432 /* Magic braces are always enabled, otherwise Vim scripts would not be 501 /* Magic braces are always enabled, otherwise Vim scripts would not be
433 * portable. */ 502 * portable. */
434 #define FEAT_MAGIC_BRACES 503 #define FEAT_MAGIC_BRACES
435 504
444 void 513 void
445 set_internal_string_var(name, value) 514 set_internal_string_var(name, value)
446 char_u *name; 515 char_u *name;
447 char_u *value; 516 char_u *value;
448 { 517 {
449 char_u *val; 518 char_u *val;
450 VAR varp; 519 typeval *tvp;
451 520
452 val = vim_strsave(value); 521 val = vim_strsave(value);
453 if (val != NULL) 522 if (val != NULL)
454 { 523 {
455 varp = alloc_string_var(val); 524 tvp = alloc_string_vartv(val);
456 if (varp != NULL) 525 if (tvp != NULL)
457 { 526 {
458 set_var(name, varp, FALSE); 527 set_var(name, tvp, FALSE);
459 free_var(varp); 528 free_vartv(tvp);
460 } 529 }
461 } 530 }
462 } 531 }
463 532
464 # if defined(FEAT_MBYTE) || defined(PROTO) 533 # if defined(FEAT_MBYTE) || defined(PROTO)
573 { 642 {
574 *error = FALSE; 643 *error = FALSE;
575 if (!skip) 644 if (!skip)
576 { 645 {
577 retval = (get_var_number(&retvar) != 0); 646 retval = (get_var_number(&retvar) != 0);
578 clear_var(&retvar); 647 clear_vartv(&retvar.tv);
579 } 648 }
580 } 649 }
581 if (skip) 650 if (skip)
582 --emsg_skip; 651 --emsg_skip;
583 652
603 if (eval0(arg, &retvar, nextcmd, !skip) == FAIL || skip) 672 if (eval0(arg, &retvar, nextcmd, !skip) == FAIL || skip)
604 retval = NULL; 673 retval = NULL;
605 else 674 else
606 { 675 {
607 retval = vim_strsave(get_var_string(&retvar)); 676 retval = vim_strsave(get_var_string(&retvar));
608 clear_var(&retvar); 677 clear_vartv(&retvar.tv);
609 } 678 }
610 if (skip) 679 if (skip)
611 --emsg_skip; 680 --emsg_skip;
612 681
613 return retval; 682 return retval;
619 */ 688 */
620 int 689 int
621 skip_expr(pp) 690 skip_expr(pp)
622 char_u **pp; 691 char_u **pp;
623 { 692 {
624 var retvar; 693 typeval retvar;
625 694
626 *pp = skipwhite(*pp); 695 *pp = skipwhite(*pp);
627 return eval1(pp, &retvar, FALSE); 696 return eval1(pp, &retvar, FALSE);
628 } 697 }
629 698
642 if (eval0(arg, &retvar, nextcmd, TRUE) == FAIL) 711 if (eval0(arg, &retvar, nextcmd, TRUE) == FAIL)
643 retval = NULL; 712 retval = NULL;
644 else 713 else
645 { 714 {
646 retval = vim_strsave(get_var_string(&retvar)); 715 retval = vim_strsave(get_var_string(&retvar));
647 clear_var(&retvar); 716 clear_vartv(&retvar.tv);
648 } 717 }
649 718
650 return retval; 719 return retval;
651 } 720 }
652 721
678 */ 747 */
679 char_u * 748 char_u *
680 eval_arg_to_string(arg) 749 eval_arg_to_string(arg)
681 char_u **arg; 750 char_u **arg;
682 { 751 {
683 var retvar; 752 typeval retvar;
684 char_u *retval; 753 char_u *retval;
685 int ret; 754 int ret;
686 755
687 ++emsg_off; 756 ++emsg_off;
688 757
689 ret = eval1(arg, &retvar, TRUE); 758 ret = eval1(arg, &retvar, TRUE);
690 if (ret == FAIL) 759 if (ret == FAIL)
691 retval = NULL; 760 retval = NULL;
692 else 761 else
693 { 762 {
694 retval = vim_strsave(get_var_string(&retvar)); 763 retval = vim_strsave(get_vartv_string(&retvar));
695 clear_var(&retvar); 764 clear_vartv(&retvar);
696 } 765 }
697 766
698 --emsg_off; 767 --emsg_off;
699 768
700 return retval; 769 return retval;
708 */ 777 */
709 int 778 int
710 eval_to_number(expr) 779 eval_to_number(expr)
711 char_u *expr; 780 char_u *expr;
712 { 781 {
713 var retvar; 782 typeval retvar;
714 int retval; 783 int retval;
715 char_u *p = expr; 784 char_u *p = expr;
716 785
717 ++emsg_off; 786 ++emsg_off;
718 787
719 if (eval1(&p, &retvar, TRUE) == FAIL) 788 if (eval1(&p, &retvar, TRUE) == FAIL)
720 retval = -1; 789 retval = -1;
721 else 790 else
722 { 791 {
723 retval = get_var_number(&retvar); 792 retval = get_vartv_number(&retvar);
724 clear_var(&retvar); 793 clear_vartv(&retvar);
725 } 794 }
726 --emsg_off; 795 --emsg_off;
727 796
728 return retval; 797 return retval;
729 } 798 }
740 char_u **argv; 809 char_u **argv;
741 int safe; /* use the sandbox */ 810 int safe; /* use the sandbox */
742 { 811 {
743 char_u *retval = NULL; 812 char_u *retval = NULL;
744 var retvar; 813 var retvar;
745 VAR argvars; 814 typeval *argvars;
746 long n; 815 long n;
747 int len; 816 int len;
748 int i; 817 int i;
749 int doesrange; 818 int doesrange;
750 void *save_funccalp = NULL; 819 void *save_funccalp = NULL;
751 820
752 argvars = (VAR)alloc((unsigned)(argc * sizeof(var))); 821 argvars = (typeval *)alloc((unsigned)(argc * sizeof(typeval)));
753 if (argvars == NULL) 822 if (argvars == NULL)
754 return NULL; 823 return NULL;
755 824
756 for (i = 0; i < argc; i++) 825 for (i = 0; i < argc; i++)
757 { 826 {
758 /* Pass a NULL or empty argument as an empty string */ 827 /* Pass a NULL or empty argument as an empty string */
759 if (argv[i] == NULL || *argv[i] == NUL) 828 if (argv[i] == NULL || *argv[i] == NUL)
760 { 829 {
761 argvars[i].var_type = VAR_STRING; 830 argvars[i].v_type = VAR_STRING;
762 argvars[i].var_val.var_string = (char_u *)""; 831 argvars[i].vval.v_string = (char_u *)"";
763 continue; 832 continue;
764 } 833 }
765 834
766 /* Recognize a number argument, the others must be strings. */ 835 /* Recognize a number argument, the others must be strings. */
767 vim_str2nr(argv[i], NULL, &len, TRUE, TRUE, &n, NULL); 836 vim_str2nr(argv[i], NULL, &len, TRUE, TRUE, &n, NULL);
768 if (len != 0 && len == (int)STRLEN(argv[i])) 837 if (len != 0 && len == (int)STRLEN(argv[i]))
769 { 838 {
770 argvars[i].var_type = VAR_NUMBER; 839 argvars[i].v_type = VAR_NUMBER;
771 argvars[i].var_val.var_number = n; 840 argvars[i].vval.v_number = n;
772 } 841 }
773 else 842 else
774 { 843 {
775 argvars[i].var_type = VAR_STRING; 844 argvars[i].v_type = VAR_STRING;
776 argvars[i].var_val.var_string = argv[i]; 845 argvars[i].vval.v_string = argv[i];
777 } 846 }
778 } 847 }
779 848
780 if (safe) 849 if (safe)
781 { 850 {
782 save_funccalp = save_funccal(); 851 save_funccalp = save_funccal();
783 ++sandbox; 852 ++sandbox;
784 } 853 }
785 854
786 retvar.var_type = VAR_UNKNOWN; /* clear_var() uses this */ 855 retvar.tv.v_type = VAR_UNKNOWN; /* clear_vartv() uses this */
787 if (call_func(func, (int)STRLEN(func), &retvar, argc, argvars, 856 if (call_func(func, (int)STRLEN(func), &retvar.tv, argc, argvars,
788 curwin->w_cursor.lnum, curwin->w_cursor.lnum, 857 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
789 &doesrange, TRUE) == OK) 858 &doesrange, TRUE) == OK)
790 retval = vim_strsave(get_var_string(&retvar)); 859 retval = vim_strsave(get_var_string(&retvar));
791 860
792 clear_var(&retvar); 861 clear_vartv(&retvar.tv);
793 vim_free(argvars); 862 vim_free(argvars);
794 863
795 if (safe) 864 if (safe)
796 { 865 {
797 --sandbox; 866 --sandbox;
842 if (eval0(arg, &retvar, NULL, TRUE) == FAIL) 911 if (eval0(arg, &retvar, NULL, TRUE) == FAIL)
843 retval = 0; 912 retval = 0;
844 else 913 else
845 { 914 {
846 /* If the result is a number, just return the number. */ 915 /* If the result is a number, just return the number. */
847 if (retvar.var_type == VAR_NUMBER) 916 if (retvar.tv.v_type == VAR_NUMBER)
848 retval = retvar.var_val.var_number; 917 retval = retvar.tv.vval.v_number;
849 else if (retvar.var_type == VAR_UNKNOWN 918 else if (retvar.tv.v_type == VAR_UNKNOWN
850 || retvar.var_val.var_string == NULL) 919 || retvar.tv.vval.v_string == NULL)
851 retval = 0; 920 retval = 0;
852 else 921 else
853 { 922 {
854 /* If the result is a string, check if there is a non-digit before 923 /* If the result is a string, check if there is a non-digit before
855 * the number. */ 924 * the number. */
856 s = retvar.var_val.var_string; 925 s = retvar.tv.vval.v_string;
857 if (!VIM_ISDIGIT(*s) && *s != '-') 926 if (!VIM_ISDIGIT(*s) && *s != '-')
858 *cp = *s++; 927 *cp = *s++;
859 retval = atol((char *)s); 928 retval = atol((char *)s);
860 } 929 }
861 clear_var(&retvar); 930 clear_vartv(&retvar.tv);
862 } 931 }
863 --emsg_off; 932 --emsg_off;
864 --sandbox; 933 --sandbox;
865 934
866 return retval; 935 return retval;
968 { 1037 {
969 /* 1038 /*
970 * List all variables. 1039 * List all variables.
971 */ 1040 */
972 for (i = 0; i < variables.ga_len && !got_int; ++i) 1041 for (i = 0; i < variables.ga_len && !got_int; ++i)
973 if (VAR_ENTRY(i).var_name != NULL) 1042 if (VAR_ENTRY(i).v_name != NULL)
974 list_one_var(&VAR_ENTRY(i), (char_u *)""); 1043 list_one_var(&VAR_ENTRY(i), (char_u *)"");
975 for (i = 0; i < curbuf->b_vars.ga_len && !got_int; ++i) 1044 for (i = 0; i < curbuf->b_vars.ga_len && !got_int; ++i)
976 if (BVAR_ENTRY(i).var_name != NULL) 1045 if (BVAR_ENTRY(i).v_name != NULL)
977 list_one_var(&BVAR_ENTRY(i), (char_u *)"b:"); 1046 list_one_var(&BVAR_ENTRY(i), (char_u *)"b:");
978 for (i = 0; i < curwin->w_vars.ga_len && !got_int; ++i) 1047 for (i = 0; i < curwin->w_vars.ga_len && !got_int; ++i)
979 if (WVAR_ENTRY(i).var_name != NULL) 1048 if (WVAR_ENTRY(i).v_name != NULL)
980 list_one_var(&WVAR_ENTRY(i), (char_u *)"w:"); 1049 list_one_var(&WVAR_ENTRY(i), (char_u *)"w:");
981 for (i = 0; i < VV_LEN && !got_int; ++i) 1050 for (i = 0; i < VV_LEN && !got_int; ++i)
982 if (vimvars[i].type == VAR_NUMBER || vimvars[i].val != NULL) 1051 if (vimvars[i].type == VAR_NUMBER || vimvars[i].val != NULL)
983 list_vim_var(i); 1052 list_vim_var(i);
984 } 1053 }
1101 ++emsg_skip; 1170 ++emsg_skip;
1102 i = eval0(expr + 1, &retvar, &eap->nextcmd, !eap->skip); 1171 i = eval0(expr + 1, &retvar, &eap->nextcmd, !eap->skip);
1103 if (eap->skip) 1172 if (eap->skip)
1104 { 1173 {
1105 if (i != FAIL) 1174 if (i != FAIL)
1106 clear_var(&retvar); 1175 clear_vartv(&retvar.tv);
1107 --emsg_skip; 1176 --emsg_skip;
1108 } 1177 }
1109 else if (i != FAIL) 1178 else if (i != FAIL)
1110 { 1179 {
1111 /* 1180 /*
1212 if (!aborting()) 1281 if (!aborting())
1213 EMSG2(_(e_invarg2), arg); 1282 EMSG2(_(e_invarg2), arg);
1214 } 1283 }
1215 else 1284 else
1216 { 1285 {
1217 set_var(temp_string, &retvar, TRUE); 1286 set_var(temp_string, &retvar.tv, TRUE);
1218 vim_free(temp_string); 1287 vim_free(temp_string);
1219 } 1288 }
1220 } 1289 }
1221 #endif 1290 #endif
1222 else 1291 else
1223 { 1292 {
1224 c1 = *p; 1293 c1 = *p;
1225 *p = NUL; 1294 *p = NUL;
1226 set_var(arg, &retvar, TRUE); 1295 set_var(arg, &retvar.tv, TRUE);
1227 *p = c1; /* put char back for error messages */ 1296 *p = c1; /* put char back for error messages */
1228 } 1297 }
1229 } 1298 }
1230 1299
1231 else 1300 else
1232 { 1301 {
1233 EMSG2(_(e_invarg2), arg); 1302 EMSG2(_(e_invarg2), arg);
1234 } 1303 }
1235 1304
1236 clear_var(&retvar); 1305 clear_vartv(&retvar.tv);
1237 } 1306 }
1238 } 1307 }
1239 } 1308 }
1240 1309
1241 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 1310 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
1348 goto end; 1417 goto end;
1349 if (alias != NULL) 1418 if (alias != NULL)
1350 name = alias; 1419 name = alias;
1351 1420
1352 startarg = arg; 1421 startarg = arg;
1353 retvar.var_type = VAR_UNKNOWN; /* clear_var() uses this */ 1422 retvar.tv.v_type = VAR_UNKNOWN; /* clear_vartv() uses this */
1354 1423
1355 if (*startarg != '(') 1424 if (*startarg != '(')
1356 { 1425 {
1357 EMSG2(_("E107: Missing braces: %s"), name); 1426 EMSG2(_("E107: Missing braces: %s"), name);
1358 goto end; 1427 goto end;
1377 { 1446 {
1378 curwin->w_cursor.lnum = lnum; 1447 curwin->w_cursor.lnum = lnum;
1379 curwin->w_cursor.col = 0; 1448 curwin->w_cursor.col = 0;
1380 } 1449 }
1381 arg = startarg; 1450 arg = startarg;
1382 if (get_func_var(name, len, &retvar, &arg, 1451 if (get_func_vartv(name, len, &retvar.tv, &arg,
1383 eap->line1, eap->line2, &doesrange, !eap->skip) == FAIL) 1452 eap->line1, eap->line2, &doesrange, !eap->skip) == FAIL)
1384 { 1453 {
1385 failed = TRUE; 1454 failed = TRUE;
1386 break; 1455 break;
1387 } 1456 }
1388 clear_var(&retvar); 1457 clear_vartv(&retvar.tv);
1389 if (doesrange || eap->skip) 1458 if (doesrange || eap->skip)
1390 break; 1459 break;
1391 /* Stop when immediately aborting on error, or when an interrupt 1460 /* Stop when immediately aborting on error, or when an interrupt
1392 * occurred or an exception was thrown but not caught. get_func_var() 1461 * occurred or an exception was thrown but not caught.
1393 * returned OK, so that the check for trailing characters below is 1462 * get_func_vartv() returned OK, so that the check for trailing
1394 * executed. */ 1463 * characters below is executed. */
1395 if (aborting()) 1464 if (aborting())
1396 break; 1465 break;
1397 } 1466 }
1398 if (eap->skip) 1467 if (eap->skip)
1399 --emsg_skip; 1468 --emsg_skip;
1506 VAR v; 1575 VAR v;
1507 1576
1508 v = find_var(name, TRUE); 1577 v = find_var(name, TRUE);
1509 if (v != NULL) 1578 if (v != NULL)
1510 { 1579 {
1511 var_free_one(v); 1580 clear_var(v);
1512 return OK; 1581 return OK;
1513 } 1582 }
1514 return FAIL; 1583 return FAIL;
1515 } 1584 }
1516 1585
1522 del_menutrans_vars() 1591 del_menutrans_vars()
1523 { 1592 {
1524 int i; 1593 int i;
1525 1594
1526 for (i = 0; i < variables.ga_len; ++i) 1595 for (i = 0; i < variables.ga_len; ++i)
1527 if (VAR_ENTRY(i).var_name != NULL 1596 if (VAR_ENTRY(i).v_name != NULL
1528 && STRNCMP(VAR_ENTRY(i).var_name, "menutrans_", 10) == 0) 1597 && STRNCMP(VAR_ENTRY(i).v_name, "menutrans_", 10) == 0)
1529 var_free_one(&VAR_ENTRY(i)); 1598 clear_var(&VAR_ENTRY(i));
1530 } 1599 }
1531 #endif 1600 #endif
1532 1601
1533 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 1602 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
1534 1603
1590 1659
1591 if (idx == 0) 1660 if (idx == 0)
1592 gidx = bidx = widx = vidx = 0; 1661 gidx = bidx = widx = vidx = 0;
1593 if (gidx < variables.ga_len) /* Global variables */ 1662 if (gidx < variables.ga_len) /* Global variables */
1594 { 1663 {
1595 while ((name = VAR_ENTRY(gidx++).var_name) == NULL 1664 while ((name = VAR_ENTRY(gidx++).v_name) == NULL
1596 && gidx < variables.ga_len) 1665 && gidx < variables.ga_len)
1597 /* skip */; 1666 /* skip */;
1598 if (name != NULL) 1667 if (name != NULL)
1599 { 1668 {
1600 if (STRNCMP("g:", xp->xp_pattern, 2) == 0) 1669 if (STRNCMP("g:", xp->xp_pattern, 2) == 0)
1603 return name; 1672 return name;
1604 } 1673 }
1605 } 1674 }
1606 if (bidx < curbuf->b_vars.ga_len) /* Current buffer variables */ 1675 if (bidx < curbuf->b_vars.ga_len) /* Current buffer variables */
1607 { 1676 {
1608 while ((name = BVAR_ENTRY(bidx++).var_name) == NULL 1677 while ((name = BVAR_ENTRY(bidx++).v_name) == NULL
1609 && bidx < curbuf->b_vars.ga_len) 1678 && bidx < curbuf->b_vars.ga_len)
1610 /* skip */; 1679 /* skip */;
1611 if (name != NULL) 1680 if (name != NULL)
1612 return cat_prefix_varname('b', name); 1681 return cat_prefix_varname('b', name);
1613 } 1682 }
1616 ++bidx; 1685 ++bidx;
1617 return (char_u *)"b:changedtick"; 1686 return (char_u *)"b:changedtick";
1618 } 1687 }
1619 if (widx < curwin->w_vars.ga_len) /* Current window variables */ 1688 if (widx < curwin->w_vars.ga_len) /* Current window variables */
1620 { 1689 {
1621 while ((name = WVAR_ENTRY(widx++).var_name) == NULL 1690 while ((name = WVAR_ENTRY(widx++).v_name) == NULL
1622 && widx < curwin->w_vars.ga_len) 1691 && widx < curwin->w_vars.ga_len)
1623 /* skip */; 1692 /* skip */;
1624 if (name != NULL) 1693 if (name != NULL)
1625 return cat_prefix_varname('w', name); 1694 return cat_prefix_varname('w', name);
1626 } 1695 }
1671 { 1740 {
1672 int ret; 1741 int ret;
1673 char_u *p; 1742 char_u *p;
1674 1743
1675 p = skipwhite(arg); 1744 p = skipwhite(arg);
1676 ret = eval1(&p, retvar, evaluate); 1745 ret = eval1(&p, &retvar->tv, evaluate);
1677 if (ret == FAIL || !ends_excmd(*p)) 1746 if (ret == FAIL || !ends_excmd(*p))
1678 { 1747 {
1679 if (ret != FAIL) 1748 if (ret != FAIL)
1680 clear_var(retvar); 1749 clear_vartv(&retvar->tv);
1681 /* 1750 /*
1682 * Report the invalid expression unless the expression evaluation has 1751 * Report the invalid expression unless the expression evaluation has
1683 * been cancelled due to an aborting error, an interrupt, or an 1752 * been cancelled due to an aborting error, an interrupt, or an
1684 * exception. 1753 * exception.
1685 */ 1754 */
1703 * Return OK or FAIL. 1772 * Return OK or FAIL.
1704 */ 1773 */
1705 static int 1774 static int
1706 eval1(arg, retvar, evaluate) 1775 eval1(arg, retvar, evaluate)
1707 char_u **arg; 1776 char_u **arg;
1708 VAR retvar; 1777 typeval *retvar;
1709 int evaluate; 1778 int evaluate;
1710 { 1779 {
1711 int result; 1780 int result;
1712 var var2; 1781 typeval var2;
1713 1782
1714 /* 1783 /*
1715 * Get the first variable. 1784 * Get the first variable.
1716 */ 1785 */
1717 if (eval2(arg, retvar, evaluate) == FAIL) 1786 if (eval2(arg, retvar, evaluate) == FAIL)
1720 if ((*arg)[0] == '?') 1789 if ((*arg)[0] == '?')
1721 { 1790 {
1722 result = FALSE; 1791 result = FALSE;
1723 if (evaluate) 1792 if (evaluate)
1724 { 1793 {
1725 if (get_var_number(retvar) != 0) 1794 if (get_vartv_number(retvar) != 0)
1726 result = TRUE; 1795 result = TRUE;
1727 clear_var(retvar); 1796 clear_vartv(retvar);
1728 } 1797 }
1729 1798
1730 /* 1799 /*
1731 * Get the second variable. 1800 * Get the second variable.
1732 */ 1801 */
1739 */ 1808 */
1740 if ((*arg)[0] != ':') 1809 if ((*arg)[0] != ':')
1741 { 1810 {
1742 EMSG(_("E109: Missing ':' after '?'")); 1811 EMSG(_("E109: Missing ':' after '?'"));
1743 if (evaluate && result) 1812 if (evaluate && result)
1744 clear_var(retvar); 1813 clear_vartv(retvar);
1745 return FAIL; 1814 return FAIL;
1746 } 1815 }
1747 1816
1748 /* 1817 /*
1749 * Get the third variable. 1818 * Get the third variable.
1750 */ 1819 */
1751 *arg = skipwhite(*arg + 1); 1820 *arg = skipwhite(*arg + 1);
1752 if (eval1(arg, &var2, evaluate && !result) == FAIL) /* recursive! */ 1821 if (eval1(arg, &var2, evaluate && !result) == FAIL) /* recursive! */
1753 { 1822 {
1754 if (evaluate && result) 1823 if (evaluate && result)
1755 clear_var(retvar); 1824 clear_vartv(retvar);
1756 return FAIL; 1825 return FAIL;
1757 } 1826 }
1758 if (evaluate && !result) 1827 if (evaluate && !result)
1759 *retvar = var2; 1828 *retvar = var2;
1760 } 1829 }
1772 * Return OK or FAIL. 1841 * Return OK or FAIL.
1773 */ 1842 */
1774 static int 1843 static int
1775 eval2(arg, retvar, evaluate) 1844 eval2(arg, retvar, evaluate)
1776 char_u **arg; 1845 char_u **arg;
1777 VAR retvar; 1846 typeval *retvar;
1778 int evaluate; 1847 int evaluate;
1779 { 1848 {
1780 var var2; 1849 typeval var2;
1781 long result; 1850 long result;
1782 int first; 1851 int first;
1783 1852
1784 /* 1853 /*
1785 * Get the first variable. 1854 * Get the first variable.
1794 result = FALSE; 1863 result = FALSE;
1795 while ((*arg)[0] == '|' && (*arg)[1] == '|') 1864 while ((*arg)[0] == '|' && (*arg)[1] == '|')
1796 { 1865 {
1797 if (evaluate && first) 1866 if (evaluate && first)
1798 { 1867 {
1799 if (get_var_number(retvar) != 0) 1868 if (get_vartv_number(retvar) != 0)
1800 result = TRUE; 1869 result = TRUE;
1801 clear_var(retvar); 1870 clear_vartv(retvar);
1802 first = FALSE; 1871 first = FALSE;
1803 } 1872 }
1804 1873
1805 /* 1874 /*
1806 * Get the second variable. 1875 * Get the second variable.
1812 /* 1881 /*
1813 * Compute the result. 1882 * Compute the result.
1814 */ 1883 */
1815 if (evaluate && !result) 1884 if (evaluate && !result)
1816 { 1885 {
1817 if (get_var_number(&var2) != 0) 1886 if (get_vartv_number(&var2) != 0)
1818 result = TRUE; 1887 result = TRUE;
1819 clear_var(&var2); 1888 clear_vartv(&var2);
1820 } 1889 }
1821 if (evaluate) 1890 if (evaluate)
1822 { 1891 {
1823 retvar->var_type = VAR_NUMBER; 1892 retvar->v_type = VAR_NUMBER;
1824 retvar->var_val.var_number = result; 1893 retvar->vval.v_number = result;
1825 } 1894 }
1826 } 1895 }
1827 1896
1828 return OK; 1897 return OK;
1829 } 1898 }
1838 * Return OK or FAIL. 1907 * Return OK or FAIL.
1839 */ 1908 */
1840 static int 1909 static int
1841 eval3(arg, retvar, evaluate) 1910 eval3(arg, retvar, evaluate)
1842 char_u **arg; 1911 char_u **arg;
1843 VAR retvar; 1912 typeval *retvar;
1844 int evaluate; 1913 int evaluate;
1845 { 1914 {
1846 var var2; 1915 typeval var2;
1847 long result; 1916 long result;
1848 int first; 1917 int first;
1849 1918
1850 /* 1919 /*
1851 * Get the first variable. 1920 * Get the first variable.
1860 result = TRUE; 1929 result = TRUE;
1861 while ((*arg)[0] == '&' && (*arg)[1] == '&') 1930 while ((*arg)[0] == '&' && (*arg)[1] == '&')
1862 { 1931 {
1863 if (evaluate && first) 1932 if (evaluate && first)
1864 { 1933 {
1865 if (get_var_number(retvar) == 0) 1934 if (get_vartv_number(retvar) == 0)
1866 result = FALSE; 1935 result = FALSE;
1867 clear_var(retvar); 1936 clear_vartv(retvar);
1868 first = FALSE; 1937 first = FALSE;
1869 } 1938 }
1870 1939
1871 /* 1940 /*
1872 * Get the second variable. 1941 * Get the second variable.
1878 /* 1947 /*
1879 * Compute the result. 1948 * Compute the result.
1880 */ 1949 */
1881 if (evaluate && result) 1950 if (evaluate && result)
1882 { 1951 {
1883 if (get_var_number(&var2) == 0) 1952 if (get_vartv_number(&var2) == 0)
1884 result = FALSE; 1953 result = FALSE;
1885 clear_var(&var2); 1954 clear_vartv(&var2);
1886 } 1955 }
1887 if (evaluate) 1956 if (evaluate)
1888 { 1957 {
1889 retvar->var_type = VAR_NUMBER; 1958 retvar->v_type = VAR_NUMBER;
1890 retvar->var_val.var_number = result; 1959 retvar->vval.v_number = result;
1891 } 1960 }
1892 } 1961 }
1893 1962
1894 return OK; 1963 return OK;
1895 } 1964 }
1911 * Return OK or FAIL. 1980 * Return OK or FAIL.
1912 */ 1981 */
1913 static int 1982 static int
1914 eval4(arg, retvar, evaluate) 1983 eval4(arg, retvar, evaluate)
1915 char_u **arg; 1984 char_u **arg;
1916 VAR retvar; 1985 typeval *retvar;
1917 int evaluate; 1986 int evaluate;
1918 { 1987 {
1919 var var2; 1988 typeval var2;
1920 char_u *p; 1989 char_u *p;
1921 int i; 1990 int i;
1922 exptype_T type = TYPE_UNKNOWN; 1991 exptype_T type = TYPE_UNKNOWN;
1923 int len = 2; 1992 int len = 2;
1924 long n1, n2; 1993 long n1, n2;
1990 * Get the second variable. 2059 * Get the second variable.
1991 */ 2060 */
1992 *arg = skipwhite(p + len); 2061 *arg = skipwhite(p + len);
1993 if (eval5(arg, &var2, evaluate) == FAIL) 2062 if (eval5(arg, &var2, evaluate) == FAIL)
1994 { 2063 {
1995 clear_var(retvar); 2064 clear_vartv(retvar);
1996 return FAIL; 2065 return FAIL;
1997 } 2066 }
1998 2067
1999 if (evaluate) 2068 if (evaluate)
2000 { 2069 {
2001 /* 2070 /*
2002 * If one of the two variables is a number, compare as a number. 2071 * If one of the two variables is a number, compare as a number.
2003 * When using "=~" or "!~", always compare as string. 2072 * When using "=~" or "!~", always compare as string.
2004 */ 2073 */
2005 if ((retvar->var_type == VAR_NUMBER || var2.var_type == VAR_NUMBER) 2074 if ((retvar->v_type == VAR_NUMBER || var2.v_type == VAR_NUMBER)
2006 && type != TYPE_MATCH && type != TYPE_NOMATCH) 2075 && type != TYPE_MATCH && type != TYPE_NOMATCH)
2007 { 2076 {
2008 n1 = get_var_number(retvar); 2077 n1 = get_vartv_number(retvar);
2009 n2 = get_var_number(&var2); 2078 n2 = get_vartv_number(&var2);
2010 switch (type) 2079 switch (type)
2011 { 2080 {
2012 case TYPE_EQUAL: n1 = (n1 == n2); break; 2081 case TYPE_EQUAL: n1 = (n1 == n2); break;
2013 case TYPE_NEQUAL: n1 = (n1 != n2); break; 2082 case TYPE_NEQUAL: n1 = (n1 != n2); break;
2014 case TYPE_GREATER: n1 = (n1 > n2); break; 2083 case TYPE_GREATER: n1 = (n1 > n2); break;
2020 case TYPE_NOMATCH: break; /* avoid gcc warning */ 2089 case TYPE_NOMATCH: break; /* avoid gcc warning */
2021 } 2090 }
2022 } 2091 }
2023 else 2092 else
2024 { 2093 {
2025 s1 = get_var_string_buf(retvar, buf1); 2094 s1 = get_vartv_string_buf(retvar, buf1);
2026 s2 = get_var_string_buf(&var2, buf2); 2095 s2 = get_vartv_string_buf(&var2, buf2);
2027 if (type != TYPE_MATCH && type != TYPE_NOMATCH) 2096 if (type != TYPE_MATCH && type != TYPE_NOMATCH)
2028 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); 2097 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2);
2029 else 2098 else
2030 i = 0; 2099 i = 0;
2031 n1 = FALSE; 2100 n1 = FALSE;
2057 break; 2126 break;
2058 2127
2059 case TYPE_UNKNOWN: break; /* avoid gcc warning */ 2128 case TYPE_UNKNOWN: break; /* avoid gcc warning */
2060 } 2129 }
2061 } 2130 }
2062 clear_var(retvar); 2131 clear_vartv(retvar);
2063 clear_var(&var2); 2132 clear_vartv(&var2);
2064 retvar->var_type = VAR_NUMBER; 2133 retvar->v_type = VAR_NUMBER;
2065 retvar->var_val.var_number = n1; 2134 retvar->vval.v_number = n1;
2066 } 2135 }
2067 } 2136 }
2068 2137
2069 return OK; 2138 return OK;
2070 } 2139 }
2081 * Return OK or FAIL. 2150 * Return OK or FAIL.
2082 */ 2151 */
2083 static int 2152 static int
2084 eval5(arg, retvar, evaluate) 2153 eval5(arg, retvar, evaluate)
2085 char_u **arg; 2154 char_u **arg;
2086 VAR retvar; 2155 typeval *retvar;
2087 int evaluate; 2156 int evaluate;
2088 { 2157 {
2089 var var2; 2158 typeval var2;
2090 int op; 2159 int op;
2091 long n1, n2; 2160 long n1, n2;
2092 char_u *s1, *s2; 2161 char_u *s1, *s2;
2093 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; 2162 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
2094 char_u *p; 2163 char_u *p;
2112 * Get the second variable. 2181 * Get the second variable.
2113 */ 2182 */
2114 *arg = skipwhite(*arg + 1); 2183 *arg = skipwhite(*arg + 1);
2115 if (eval6(arg, &var2, evaluate) == FAIL) 2184 if (eval6(arg, &var2, evaluate) == FAIL)
2116 { 2185 {
2117 clear_var(retvar); 2186 clear_vartv(retvar);
2118 return FAIL; 2187 return FAIL;
2119 } 2188 }
2120 2189
2121 if (evaluate) 2190 if (evaluate)
2122 { 2191 {
2123 /* 2192 /*
2124 * Compute the result. 2193 * Compute the result.
2125 */ 2194 */
2126 if (op == '.') 2195 if (op == '.')
2127 { 2196 {
2128 s1 = get_var_string_buf(retvar, buf1); 2197 s1 = get_vartv_string_buf(retvar, buf1);
2129 s2 = get_var_string_buf(&var2, buf2); 2198 s2 = get_vartv_string_buf(&var2, buf2);
2130 op = (int)STRLEN(s1); 2199 op = (int)STRLEN(s1);
2131 p = alloc((unsigned)(op + STRLEN(s2) + 1)); 2200 p = alloc((unsigned)(op + STRLEN(s2) + 1));
2132 if (p != NULL) 2201 if (p != NULL)
2133 { 2202 {
2134 STRCPY(p, s1); 2203 STRCPY(p, s1);
2135 STRCPY(p + op, s2); 2204 STRCPY(p + op, s2);
2136 } 2205 }
2137 clear_var(retvar); 2206 clear_vartv(retvar);
2138 retvar->var_type = VAR_STRING; 2207 retvar->v_type = VAR_STRING;
2139 retvar->var_val.var_string = p; 2208 retvar->vval.v_string = p;
2140 } 2209 }
2141 else 2210 else
2142 { 2211 {
2143 n1 = get_var_number(retvar); 2212 n1 = get_vartv_number(retvar);
2144 n2 = get_var_number(&var2); 2213 n2 = get_vartv_number(&var2);
2145 clear_var(retvar); 2214 clear_vartv(retvar);
2146 if (op == '+') 2215 if (op == '+')
2147 n1 = n1 + n2; 2216 n1 = n1 + n2;
2148 else 2217 else
2149 n1 = n1 - n2; 2218 n1 = n1 - n2;
2150 retvar->var_type = VAR_NUMBER; 2219 retvar->v_type = VAR_NUMBER;
2151 retvar->var_val.var_number = n1; 2220 retvar->vval.v_number = n1;
2152 } 2221 }
2153 clear_var(&var2); 2222 clear_vartv(&var2);
2154 } 2223 }
2155 } 2224 }
2156 return OK; 2225 return OK;
2157 } 2226 }
2158 2227
2168 * Return OK or FAIL. 2237 * Return OK or FAIL.
2169 */ 2238 */
2170 static int 2239 static int
2171 eval6(arg, retvar, evaluate) 2240 eval6(arg, retvar, evaluate)
2172 char_u **arg; 2241 char_u **arg;
2173 VAR retvar; 2242 typeval *retvar;
2174 int evaluate; 2243 int evaluate;
2175 { 2244 {
2176 var var2; 2245 typeval var2;
2177 int op; 2246 int op;
2178 long n1, n2; 2247 long n1, n2;
2179 2248
2180 /* 2249 /*
2181 * Get the first variable. 2250 * Get the first variable.
2192 if (op != '*' && op != '/' && op != '%') 2261 if (op != '*' && op != '/' && op != '%')
2193 break; 2262 break;
2194 2263
2195 if (evaluate) 2264 if (evaluate)
2196 { 2265 {
2197 n1 = get_var_number(retvar); 2266 n1 = get_vartv_number(retvar);
2198 clear_var(retvar); 2267 clear_vartv(retvar);
2199 } 2268 }
2200 else 2269 else
2201 n1 = 0; 2270 n1 = 0;
2202 2271
2203 /* 2272 /*
2207 if (eval7(arg, &var2, evaluate) == FAIL) 2276 if (eval7(arg, &var2, evaluate) == FAIL)
2208 return FAIL; 2277 return FAIL;
2209 2278
2210 if (evaluate) 2279 if (evaluate)
2211 { 2280 {
2212 n2 = get_var_number(&var2); 2281 n2 = get_vartv_number(&var2);
2213 clear_var(&var2); 2282 clear_vartv(&var2);
2214 2283
2215 /* 2284 /*
2216 * Compute the result. 2285 * Compute the result.
2217 */ 2286 */
2218 if (op == '*') 2287 if (op == '*')
2229 if (n2 == 0) /* give an error message? */ 2298 if (n2 == 0) /* give an error message? */
2230 n1 = 0; 2299 n1 = 0;
2231 else 2300 else
2232 n1 = n1 % n2; 2301 n1 = n1 % n2;
2233 } 2302 }
2234 retvar->var_type = VAR_NUMBER; 2303 retvar->v_type = VAR_NUMBER;
2235 retvar->var_val.var_number = n1; 2304 retvar->vval.v_number = n1;
2236 } 2305 }
2237 } 2306 }
2238 2307
2239 return OK; 2308 return OK;
2240 } 2309 }
2263 * Return OK or FAIL. 2332 * Return OK or FAIL.
2264 */ 2333 */
2265 static int 2334 static int
2266 eval7(arg, retvar, evaluate) 2335 eval7(arg, retvar, evaluate)
2267 char_u **arg; 2336 char_u **arg;
2268 VAR retvar; 2337 typeval *retvar;
2269 int evaluate; 2338 int evaluate;
2270 { 2339 {
2271 var var2;
2272 long n; 2340 long n;
2273 int len; 2341 int len;
2274 char_u *s; 2342 char_u *s;
2275 int val; 2343 int val;
2276 char_u *start_leader, *end_leader; 2344 char_u *start_leader, *end_leader;
2277 int ret = OK; 2345 int ret = OK;
2278 char_u *alias; 2346 char_u *alias;
2279 2347
2280 /* 2348 /*
2281 * Initialise variable so that clear_var() can't mistake this for a string 2349 * Initialise variable so that clear_vartv() can't mistake this for a
2282 * and free a string that isn't there. 2350 * string and free a string that isn't there.
2283 */ 2351 */
2284 retvar->var_type = VAR_UNKNOWN; 2352 retvar->v_type = VAR_UNKNOWN;
2285 2353
2286 /* 2354 /*
2287 * Skip '!' and '-' characters. They are handled later. 2355 * Skip '!' and '-' characters. They are handled later.
2288 */ 2356 */
2289 start_leader = *arg; 2357 start_leader = *arg;
2308 case '9': 2376 case '9':
2309 vim_str2nr(*arg, NULL, &len, TRUE, TRUE, &n, NULL); 2377 vim_str2nr(*arg, NULL, &len, TRUE, TRUE, &n, NULL);
2310 *arg += len; 2378 *arg += len;
2311 if (evaluate) 2379 if (evaluate)
2312 { 2380 {
2313 retvar->var_type = VAR_NUMBER; 2381 retvar->v_type = VAR_NUMBER;
2314 retvar->var_val.var_number = n; 2382 retvar->vval.v_number = n;
2315 } 2383 }
2316 break; 2384 break;
2317 2385
2318 /* 2386 /*
2319 * String constant: "string". 2387 * String constant: "string".
2320 */ 2388 */
2321 case '"': ret = get_string_var(arg, retvar, evaluate); 2389 case '"': ret = get_string_vartv(arg, retvar, evaluate);
2322 break; 2390 break;
2323 2391
2324 /* 2392 /*
2325 * Literal string constant: 'string'. 2393 * Literal string constant: 'string'.
2326 */ 2394 */
2327 case '\'': ret = get_lit_string_var(arg, retvar, evaluate); 2395 case '\'': ret = get_lit_string_vartv(arg, retvar, evaluate);
2396 break;
2397
2398 /*
2399 * List: [expr, expr]
2400 */
2401 case '[': ret = get_list_vartv(arg, retvar, evaluate);
2328 break; 2402 break;
2329 2403
2330 /* 2404 /*
2331 * Option value: &name 2405 * Option value: &name
2332 */ 2406 */
2333 case '&': ret = get_option_var(arg, retvar, evaluate); 2407 case '&': ret = get_option_vartv(arg, retvar, evaluate);
2334 break; 2408 break;
2335 2409
2336 /* 2410 /*
2337 * Environment variable: $VAR. 2411 * Environment variable: $VAR.
2338 */ 2412 */
2339 case '$': ret = get_env_var(arg, retvar, evaluate); 2413 case '$': ret = get_env_vartv(arg, retvar, evaluate);
2340 break; 2414 break;
2341 2415
2342 /* 2416 /*
2343 * Register contents: @r. 2417 * Register contents: @r.
2344 */ 2418 */
2345 case '@': ++*arg; 2419 case '@': ++*arg;
2346 if (evaluate) 2420 if (evaluate)
2347 { 2421 {
2348 retvar->var_type = VAR_STRING; 2422 retvar->v_type = VAR_STRING;
2349 retvar->var_val.var_string = get_reg_contents(**arg, FALSE); 2423 retvar->vval.v_string = get_reg_contents(**arg, FALSE);
2350 } 2424 }
2351 if (**arg != NUL) 2425 if (**arg != NUL)
2352 ++*arg; 2426 ++*arg;
2353 break; 2427 break;
2354 2428
2360 if (**arg == ')') 2434 if (**arg == ')')
2361 ++*arg; 2435 ++*arg;
2362 else if (ret == OK) 2436 else if (ret == OK)
2363 { 2437 {
2364 EMSG(_("E110: Missing ')'")); 2438 EMSG(_("E110: Missing ')'"));
2365 clear_var(retvar); 2439 clear_vartv(retvar);
2366 ret = FAIL; 2440 ret = FAIL;
2367 } 2441 }
2368 break; 2442 break;
2369 2443
2370 /* 2444 /*
2379 ret = FAIL; 2453 ret = FAIL;
2380 else 2454 else
2381 { 2455 {
2382 if (**arg == '(') /* recursive! */ 2456 if (**arg == '(') /* recursive! */
2383 { 2457 {
2384 ret = get_func_var(s, len, retvar, arg, 2458 /* If "s" is the name of a variable of type VAR_FUNC
2459 * use its contents. */
2460 s = deref_func_name(s, &len);
2461
2462 /* Invoke the function. */
2463 ret = get_func_vartv(s, len, retvar, arg,
2385 curwin->w_cursor.lnum, curwin->w_cursor.lnum, 2464 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
2386 &len, evaluate); 2465 &len, evaluate);
2387 /* Stop the expression evaluation when immediately 2466 /* Stop the expression evaluation when immediately
2388 * aborting on error, or when an interrupt occurred or 2467 * aborting on error, or when an interrupt occurred or
2389 * an exception was thrown but not caught. */ 2468 * an exception was thrown but not caught. */
2390 if (aborting()) 2469 if (aborting())
2391 { 2470 {
2392 if (ret == OK) 2471 if (ret == OK)
2393 clear_var(retvar); 2472 clear_vartv(retvar);
2394 ret = FAIL; 2473 ret = FAIL;
2395 } 2474 }
2396 } 2475 }
2397 else if (evaluate) 2476 else if (evaluate)
2398 ret = get_var_var(s, len, retvar); 2477 ret = get_var_vartv(s, len, retvar);
2399 } 2478 }
2400 2479
2401 if (alias != NULL) 2480 if (alias != NULL)
2402 vim_free(alias); 2481 vim_free(alias);
2403 2482
2404 break; 2483 break;
2405 } 2484 }
2406 *arg = skipwhite(*arg); 2485 *arg = skipwhite(*arg);
2407 2486
2408 /* 2487 /*
2409 * Handle expr[expr] subscript. 2488 * Handle expr[expr] and expr[expr:expr] subscript.
2410 */ 2489 */
2411 if (**arg == '[' && ret == OK) 2490 while (**arg == '[' && ret == OK)
2412 { 2491 {
2413 /* 2492 if (eval_index(arg, retvar, evaluate) == FAIL)
2414 * Get the variable from inside the []. 2493 {
2415 */ 2494 clear_vartv(retvar);
2416 *arg = skipwhite(*arg + 1);
2417 if (eval1(arg, &var2, evaluate) == FAIL) /* recursive! */
2418 {
2419 clear_var(retvar);
2420 return FAIL; 2495 return FAIL;
2421 } 2496 }
2422
2423 /* Check for the ']'. */
2424 if (**arg != ']')
2425 {
2426 EMSG(_("E111: Missing ']'"));
2427 clear_var(retvar);
2428 clear_var(&var2);
2429 return FAIL;
2430 }
2431
2432 if (evaluate)
2433 {
2434 n = get_var_number(&var2);
2435 clear_var(&var2);
2436
2437 /*
2438 * The resulting variable is a string of a single character.
2439 * If the index is too big or negative, the result is empty.
2440 */
2441 s = get_var_string(retvar);
2442 if (n >= (long)STRLEN(s) || n < 0)
2443 s = NULL;
2444 else
2445 s = vim_strnsave(s + n, 1);
2446 clear_var(retvar);
2447 retvar->var_type = VAR_STRING;
2448 retvar->var_val.var_string = s;
2449 }
2450 *arg = skipwhite(*arg + 1); /* skip the ']' */
2451 } 2497 }
2452 2498
2453 /* 2499 /*
2454 * Apply logical NOT and unary '-', from right to left, ignore '+'. 2500 * Apply logical NOT and unary '-', from right to left, ignore '+'.
2455 */ 2501 */
2456 if (ret == OK && evaluate && end_leader > start_leader) 2502 if (ret == OK && evaluate && end_leader > start_leader)
2457 { 2503 {
2458 val = get_var_number(retvar); 2504 val = get_vartv_number(retvar);
2459 while (end_leader > start_leader) 2505 while (end_leader > start_leader)
2460 { 2506 {
2461 --end_leader; 2507 --end_leader;
2462 if (*end_leader == '!') 2508 if (*end_leader == '!')
2463 val = !val; 2509 val = !val;
2464 else if (*end_leader == '-') 2510 else if (*end_leader == '-')
2465 val = -val; 2511 val = -val;
2466 } 2512 }
2467 clear_var(retvar); 2513 clear_vartv(retvar);
2468 retvar->var_type = VAR_NUMBER; 2514 retvar->v_type = VAR_NUMBER;
2469 retvar->var_val.var_number = val; 2515 retvar->vval.v_number = val;
2470 } 2516 }
2471 2517
2472 return ret; 2518 return ret;
2519 }
2520
2521 /*
2522 * Evaluate an "[expr]" or "[expr:expr]" index.
2523 * "*arg" points to the '['.
2524 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
2525 */
2526 static int
2527 eval_index(arg, retvar, evaluate)
2528 char_u **arg;
2529 typeval *retvar;
2530 int evaluate;
2531 {
2532 int empty1 = FALSE, empty2 = FALSE;
2533 typeval var1, var2;
2534 long n1, n2 = 0;
2535 long len;
2536 int range;
2537 char_u *s;
2538
2539 if (retvar->v_type == VAR_FUNC)
2540 {
2541 EMSG(_("E999: Cannot index a Funcref"));
2542 return FAIL;
2543 }
2544
2545 /*
2546 * Get the (first) variable from inside the [].
2547 */
2548 *arg = skipwhite(*arg + 1);
2549 if (**arg == ':')
2550 empty1 = TRUE;
2551 else if (eval1(arg, &var1, evaluate) == FAIL) /* recursive! */
2552 return FAIL;
2553
2554 /*
2555 * Get the second variable from inside the [:].
2556 */
2557 if (**arg == ':')
2558 {
2559 range = TRUE;
2560 *arg = skipwhite(*arg + 1);
2561 if (**arg == ']')
2562 empty2 = TRUE;
2563 else if (eval1(arg, &var2, evaluate) == FAIL) /* recursive! */
2564 {
2565 clear_vartv(&var1);
2566 return FAIL;
2567 }
2568 }
2569 else
2570 range = FALSE;
2571
2572 /* Check for the ']'. */
2573 if (**arg != ']')
2574 {
2575 EMSG(_("E111: Missing ']'"));
2576 clear_vartv(&var1);
2577 if (range)
2578 clear_vartv(&var2);
2579 return FAIL;
2580 }
2581
2582 if (evaluate)
2583 {
2584 if (empty1)
2585 n1 = 0;
2586 else
2587 {
2588 n1 = get_vartv_number(&var1);
2589 clear_vartv(&var1);
2590 }
2591 if (range)
2592 {
2593 if (empty2)
2594 n2 = -1;
2595 else
2596 {
2597 n2 = get_vartv_number(&var2);
2598 clear_vartv(&var2);
2599 }
2600 }
2601
2602 switch (retvar->v_type)
2603 {
2604 case VAR_NUMBER:
2605 case VAR_STRING:
2606 s = get_vartv_string(retvar);
2607 len = (long)STRLEN(s);
2608 if (range)
2609 {
2610 /* The resulting variable is a substring. If the indexes
2611 * are out of range the result is empty. */
2612 if (n1 < 0)
2613 {
2614 n1 = len + n1;
2615 if (n1 < 0)
2616 n1 = 0;
2617 }
2618 if (n2 < 0)
2619 n2 = len + n2;
2620 else if (n2 >= len)
2621 n2 = len;
2622 if (n1 >= len || n2 < 0 || n1 > n2)
2623 s = NULL;
2624 else
2625 s = vim_strnsave(s + n1, (int)(n2 - n1 + 1));
2626 }
2627 else
2628 {
2629 /* The resulting variable is a string of a single
2630 * character. If the index is too big or negative the
2631 * result is empty. */
2632 if (n1 >= len || n1 < 0)
2633 s = NULL;
2634 else
2635 s = vim_strnsave(s + n1, 1);
2636 }
2637 clear_vartv(retvar);
2638 retvar->v_type = VAR_STRING;
2639 retvar->vval.v_string = s;
2640 break;
2641
2642 case VAR_LIST:
2643 len = list_len(retvar->vval.v_list);
2644 if (n1 < 0)
2645 n1 = len + n1;
2646 if (!empty1 && (n1 < 0 || n1 >= len))
2647 {
2648 EMSGN(_(e_listidx), n1);
2649 return FAIL;
2650 }
2651 if (range)
2652 {
2653 listvar *l;
2654 listitem *item;
2655
2656 if (n2 < 0)
2657 n2 = len + n2;
2658 if (!empty2 && (n2 < 0 || n2 >= len || n2 < n1))
2659 {
2660 EMSGN(_(e_listidx), n2);
2661 return FAIL;
2662 }
2663 l = list_alloc();
2664 if (l == NULL)
2665 return FAIL;
2666 for (item = list_find(retvar->vval.v_list, n1);
2667 n1 <= n2; ++n1)
2668 {
2669 if (list_append_tv(l, &item->li_tv) == FAIL)
2670 {
2671 list_free(l);
2672 return FAIL;
2673 }
2674 item = item->li_next;
2675 }
2676 clear_vartv(retvar);
2677 retvar->v_type = VAR_LIST;
2678 retvar->vval.v_list = l;
2679 }
2680 else
2681 {
2682 copy_vartv(&list_find(retvar->vval.v_list, n1)->li_tv,
2683 &var1);
2684 clear_vartv(retvar);
2685 *retvar = var1;
2686 }
2687 break;
2688 }
2689 }
2690
2691 *arg = skipwhite(*arg + 1); /* skip the ']' */
2692 return OK;
2473 } 2693 }
2474 2694
2475 /* 2695 /*
2476 * Get an option value. 2696 * Get an option value.
2477 * "arg" points to the '&' or '+' before the option name. 2697 * "arg" points to the '&' or '+' before the option name.
2478 * "arg" is advanced to character after the option name. 2698 * "arg" is advanced to character after the option name.
2479 * Return OK or FAIL. 2699 * Return OK or FAIL.
2480 */ 2700 */
2481 static int 2701 static int
2482 get_option_var(arg, retvar, evaluate) 2702 get_option_vartv(arg, retvar, evaluate)
2483 char_u **arg; 2703 char_u **arg;
2484 VAR retvar; /* when NULL, only check if option exists */ 2704 typeval *retvar; /* when NULL, only check if option exists */
2485 int evaluate; 2705 int evaluate;
2486 { 2706 {
2487 char_u *option_end; 2707 char_u *option_end;
2488 long numval; 2708 long numval;
2489 char_u *stringval; 2709 char_u *stringval;
2523 } 2743 }
2524 else if (retvar != NULL) 2744 else if (retvar != NULL)
2525 { 2745 {
2526 if (opt_type == -2) /* hidden string option */ 2746 if (opt_type == -2) /* hidden string option */
2527 { 2747 {
2528 retvar->var_type = VAR_STRING; 2748 retvar->v_type = VAR_STRING;
2529 retvar->var_val.var_string = NULL; 2749 retvar->vval.v_string = NULL;
2530 } 2750 }
2531 else if (opt_type == -1) /* hidden number option */ 2751 else if (opt_type == -1) /* hidden number option */
2532 { 2752 {
2533 retvar->var_type = VAR_NUMBER; 2753 retvar->v_type = VAR_NUMBER;
2534 retvar->var_val.var_number = 0; 2754 retvar->vval.v_number = 0;
2535 } 2755 }
2536 else if (opt_type == 1) /* number option */ 2756 else if (opt_type == 1) /* number option */
2537 { 2757 {
2538 retvar->var_type = VAR_NUMBER; 2758 retvar->v_type = VAR_NUMBER;
2539 retvar->var_val.var_number = numval; 2759 retvar->vval.v_number = numval;
2540 } 2760 }
2541 else /* string option */ 2761 else /* string option */
2542 { 2762 {
2543 retvar->var_type = VAR_STRING; 2763 retvar->v_type = VAR_STRING;
2544 retvar->var_val.var_string = stringval; 2764 retvar->vval.v_string = stringval;
2545 } 2765 }
2546 } 2766 }
2547 else if (working && (opt_type == -2 || opt_type == -1)) 2767 else if (working && (opt_type == -2 || opt_type == -1))
2548 ret = FAIL; 2768 ret = FAIL;
2549 2769
2556 /* 2776 /*
2557 * Allocate a variable for a string constant. 2777 * Allocate a variable for a string constant.
2558 * Return OK or FAIL. 2778 * Return OK or FAIL.
2559 */ 2779 */
2560 static int 2780 static int
2561 get_string_var(arg, retvar, evaluate) 2781 get_string_vartv(arg, retvar, evaluate)
2562 char_u **arg; 2782 char_u **arg;
2563 VAR retvar; 2783 typeval *retvar;
2564 int evaluate; 2784 int evaluate;
2565 { 2785 {
2566 char_u *p; 2786 char_u *p;
2567 char_u *name; 2787 char_u *name;
2568 int i; 2788 int i;
2701 #endif 2921 #endif
2702 } 2922 }
2703 name[i] = NUL; 2923 name[i] = NUL;
2704 *arg = p + 1; 2924 *arg = p + 1;
2705 2925
2706 retvar->var_type = VAR_STRING; 2926 retvar->v_type = VAR_STRING;
2707 retvar->var_val.var_string = name; 2927 retvar->vval.v_string = name;
2708 2928
2709 return OK; 2929 return OK;
2710 } 2930 }
2711 2931
2712 /* 2932 /*
2713 * Allocate a variable for an backtick-string constant. 2933 * Allocate a variable for an backtick-string constant.
2714 * Return OK or FAIL. 2934 * Return OK or FAIL.
2715 */ 2935 */
2716 static int 2936 static int
2717 get_lit_string_var(arg, retvar, evaluate) 2937 get_lit_string_vartv(arg, retvar, evaluate)
2718 char_u **arg; 2938 char_u **arg;
2719 VAR retvar; 2939 typeval *retvar;
2720 int evaluate; 2940 int evaluate;
2721 { 2941 {
2722 char_u *p; 2942 char_u *p;
2723 char_u *name; 2943 char_u *name;
2724 2944
2739 */ 2959 */
2740 name = vim_strnsave(*arg + 1, (int)(p - (*arg + 1))); 2960 name = vim_strnsave(*arg + 1, (int)(p - (*arg + 1)));
2741 if (name == NULL) 2961 if (name == NULL)
2742 return FAIL; 2962 return FAIL;
2743 2963
2744 retvar->var_type = VAR_STRING; 2964 retvar->v_type = VAR_STRING;
2745 retvar->var_val.var_string = name; 2965 retvar->vval.v_string = name;
2746 } 2966 }
2747 2967
2748 *arg = p + 1; 2968 *arg = p + 1;
2749 2969
2750 return OK; 2970 return OK;
2971 }
2972
2973 /*
2974 * Allocate a variable for a List and fill it from "*arg".
2975 * Return OK or FAIL.
2976 */
2977 static int
2978 get_list_vartv(arg, retvar, evaluate)
2979 char_u **arg;
2980 typeval *retvar;
2981 int evaluate;
2982 {
2983 listvar *l = NULL;
2984 typeval tv;
2985 listitem *item;
2986
2987 if (evaluate)
2988 {
2989 l = list_alloc();
2990 if (l == NULL)
2991 return FAIL;
2992 }
2993
2994 *arg = skipwhite(*arg + 1);
2995 while (**arg != ']' && **arg != NUL)
2996 {
2997 if (eval1(arg, &tv, evaluate) == FAIL) /* recursive! */
2998 goto failret;
2999 if (evaluate)
3000 {
3001 item = listitem_alloc();
3002 if (item != NULL)
3003 {
3004 item->li_tv = tv;
3005 list_append(l, item);
3006 }
3007 }
3008
3009 if (**arg == ']')
3010 break;
3011 if (**arg != ',')
3012 {
3013 EMSG2(_("E999: Missing comma in list: %s"), *arg);
3014 goto failret;
3015 }
3016 *arg = skipwhite(*arg + 1);
3017 }
3018
3019 if (**arg != ']')
3020 {
3021 EMSG2(_("E999: Missing end of list ']': %s"), *arg);
3022 failret:
3023 if (evaluate)
3024 list_free(l);
3025 return FAIL;
3026 }
3027
3028 *arg = skipwhite(*arg + 1);
3029 if (evaluate)
3030 {
3031 retvar->v_type = VAR_LIST;
3032 retvar->vval.v_list = l;
3033 ++l->lv_refcount;
3034 }
3035
3036 return OK;
3037 }
3038
3039 /*
3040 * Allocate an empty header for a list.
3041 */
3042 static listvar *
3043 list_alloc()
3044 {
3045 return (listvar *)alloc_clear(sizeof(listvar));
3046 }
3047
3048 /*
3049 * Unreference a list: decrement the reference count and free it when it
3050 * becomes zero.
3051 */
3052 static void
3053 list_unref(l)
3054 listvar *l;
3055 {
3056 if (l != NULL && --l->lv_refcount <= 0)
3057 list_free(l);
3058 }
3059
3060 /*
3061 * Free a list, including all items it points to.
3062 * Ignores the reference count.
3063 */
3064 static void
3065 list_free(l)
3066 listvar *l;
3067 {
3068 listitem *item;
3069 listitem *next;
3070
3071 for (item = l->lv_first; item != NULL; item = next)
3072 {
3073 next = item->li_next;
3074 listitem_free(item);
3075 }
3076 vim_free(l);
3077 }
3078
3079 /*
3080 * Allocate a list item.
3081 */
3082 static listitem *
3083 listitem_alloc()
3084 {
3085 return (listitem *)alloc(sizeof(listitem));
3086 }
3087
3088 /*
3089 * Free a list item. Also clears the value;
3090 */
3091 static void
3092 listitem_free(item)
3093 listitem *item;
3094 {
3095 clear_vartv(&item->li_tv);
3096 vim_free(item);
3097 }
3098
3099 /*
3100 * Get the number of items in a list.
3101 */
3102 static long
3103 list_len(l)
3104 listvar *l;
3105 {
3106 listitem *item;
3107 long len = 0;
3108
3109 if (l == NULL)
3110 return 0L;
3111 for (item = l->lv_first; item != NULL; item = item->li_next)
3112 ++len;
3113 return len;
3114 }
3115
3116 /*
3117 * Locate item with index "n" in list "l" and return it.
3118 * A negative index is counted from the end; -1 is the last item.
3119 * Returns NULL when "n" is out of range.
3120 */
3121 static listitem *
3122 list_find(l, n)
3123 listvar *l;
3124 long n;
3125 {
3126 listitem *item;
3127 long idx;
3128
3129 if (l == NULL)
3130 return NULL;
3131 if (n < 0)
3132 {
3133 idx = -1; /* search from the end */
3134 for (item = l->lv_last; item != NULL && idx > n; item = item->li_prev)
3135 --idx;
3136 }
3137 else
3138 {
3139 idx = 0; /* search from the start */
3140 for (item = l->lv_first; item != NULL && idx < n; item = item->li_next)
3141 ++idx;
3142 }
3143 if (idx != n)
3144 return NULL;
3145 return item;
3146 }
3147
3148 /*
3149 * Append item "item" to the end of list "l".
3150 */
3151 static void
3152 list_append(l, item)
3153 listvar *l;
3154 listitem *item;
3155 {
3156 if (l->lv_last == NULL)
3157 {
3158 /* empty list */
3159 l->lv_first = item;
3160 l->lv_last = item;
3161 item->li_prev = NULL;
3162 }
3163 else
3164 {
3165 l->lv_last->li_next = item;
3166 item->li_prev = l->lv_last;
3167 l->lv_last = item;
3168 }
3169 item->li_next = NULL;
3170 }
3171
3172 /*
3173 * Append typeval "tv" to the end of list "l".
3174 */
3175 static int
3176 list_append_tv(l, tv)
3177 listvar *l;
3178 typeval *tv;
3179 {
3180 listitem *ni = listitem_alloc();
3181
3182 if (ni == NULL)
3183 return FAIL;
3184 copy_vartv(tv, &ni->li_tv);
3185 list_append(l, ni);
3186 return OK;
3187 }
3188
3189 /*
3190 * Make a copy of list "l". Shallow if "deep" is FALSE.
3191 * The refcount of the new list is set to 1.
3192 * Returns NULL when out of memory.
3193 */
3194 static listvar *
3195 list_copy(orig, deep)
3196 listvar *orig;
3197 int deep;
3198 {
3199 listvar *copy;
3200 listitem *item;
3201 listitem *ni;
3202 static int recurse = 0;
3203
3204 if (orig == NULL)
3205 return NULL;
3206 if (recurse >= VAR_LIST_MAXNEST)
3207 {
3208 EMSG(_("E999: List nested too deep for making a copy"));
3209 return NULL;
3210 }
3211 ++recurse;
3212
3213 copy = list_alloc();
3214 if (copy != NULL)
3215 {
3216 for (item = orig->lv_first; item != NULL; item = item->li_next)
3217 {
3218 ni = listitem_alloc();
3219 if (ni == NULL)
3220 break;
3221 if (deep && item->li_tv.v_type == VAR_LIST)
3222 {
3223 ni->li_tv.v_type = VAR_LIST;
3224 ni->li_tv.vval.v_list = list_copy(item->li_tv.vval.v_list,
3225 TRUE);
3226 if (ni->li_tv.vval.v_list == NULL)
3227 {
3228 vim_free(ni);
3229 break;
3230 }
3231 }
3232 else
3233 copy_vartv(&item->li_tv, &ni->li_tv);
3234 list_append(copy, ni);
3235 }
3236 ++copy->lv_refcount;
3237 }
3238
3239 --recurse;
3240 return copy;
3241 }
3242
3243 /*
3244 * Remove item with index "n" from list "l" and return it.
3245 * Returns NULL when "n" is out of range.
3246 */
3247 static listitem *
3248 list_getrem(l, n)
3249 listvar *l;
3250 long n;
3251 {
3252 listitem *item;
3253
3254 item = list_find(l, n);
3255 if (item != NULL)
3256 {
3257 if (item->li_next == NULL)
3258 l->lv_last = item->li_prev;
3259 else
3260 item->li_next->li_prev = item->li_prev;
3261 if (item->li_prev == NULL)
3262 l->lv_first = item->li_next;
3263 else
3264 item->li_prev->li_next = item->li_next;
3265 }
3266 return item;
3267 }
3268
3269 /*
3270 * Return an allocated string with the string representation of a list.
3271 * May return NULL.
3272 */
3273 static char_u *
3274 list2string(tv)
3275 typeval *tv;
3276 {
3277 garray_T ga;
3278 listitem *item;
3279 int first = TRUE;
3280 char_u *tofree;
3281 char_u *s;
3282
3283 if (tv->vval.v_list == NULL)
3284 return NULL;
3285 ga_init2(&ga, (int)sizeof(char), 80);
3286 ga_append(&ga, '[');
3287
3288 for (item = tv->vval.v_list->lv_first; item != NULL; item = item->li_next)
3289 {
3290 if (first)
3291 first = FALSE;
3292 else
3293 ga_concat(&ga, (char_u *)", ");
3294
3295 s = tv2string(&item->li_tv, &tofree);
3296 if (s != NULL)
3297 ga_concat(&ga, s);
3298 vim_free(tofree);
3299 }
3300
3301 ga_append(&ga, ']');
3302 ga_append(&ga, NUL);
3303 return (char_u *)ga.ga_data;
3304 }
3305
3306 /*
3307 * Return a string with the string representation of a variable.
3308 * If the memory is allocated "tofree" is set to it, otherwise NULL.
3309 * Can only be used once before the value is used, it may call
3310 * get_var_string().
3311 * May return NULL;
3312 */
3313 static char_u *
3314 tv2string(tv, tofree)
3315 typeval *tv;
3316 char_u **tofree;
3317 {
3318 switch (tv->v_type)
3319 {
3320 case VAR_FUNC:
3321 *tofree = NULL;
3322 return tv->vval.v_string;
3323 case VAR_LIST:
3324 *tofree = list2string(tv);
3325 return *tofree;
3326 default:
3327 break;
3328 }
3329 *tofree = NULL;
3330 return get_vartv_string(tv);
2751 } 3331 }
2752 3332
2753 /* 3333 /*
2754 * Get the value of an environment variable. 3334 * Get the value of an environment variable.
2755 * "arg" is pointing to the '$'. It is advanced to after the name. 3335 * "arg" is pointing to the '$'. It is advanced to after the name.
2756 * If the environment variable was not set, silently assume it is empty. 3336 * If the environment variable was not set, silently assume it is empty.
2757 * Always return OK. 3337 * Always return OK.
2758 */ 3338 */
2759 static int 3339 static int
2760 get_env_var(arg, retvar, evaluate) 3340 get_env_vartv(arg, retvar, evaluate)
2761 char_u **arg; 3341 char_u **arg;
2762 VAR retvar; 3342 typeval *retvar;
2763 int evaluate; 3343 int evaluate;
2764 { 3344 {
2765 char_u *string = NULL; 3345 char_u *string = NULL;
2766 int len; 3346 int len;
2767 int cc; 3347 int cc;
2790 string = NULL; 3370 string = NULL;
2791 } 3371 }
2792 } 3372 }
2793 name[len] = cc; 3373 name[len] = cc;
2794 } 3374 }
2795 retvar->var_type = VAR_STRING; 3375 retvar->v_type = VAR_STRING;
2796 retvar->var_val.var_string = string; 3376 retvar->vval.v_string = string;
2797 } 3377 }
2798 3378
2799 return OK; 3379 return OK;
2800 } 3380 }
2801 3381
2806 static struct fst 3386 static struct fst
2807 { 3387 {
2808 char *f_name; /* function name */ 3388 char *f_name; /* function name */
2809 char f_min_argc; /* minimal number of arguments */ 3389 char f_min_argc; /* minimal number of arguments */
2810 char f_max_argc; /* maximal number of arguments */ 3390 char f_max_argc; /* maximal number of arguments */
2811 void (*f_func) __ARGS((VAR args, VAR rvar)); /* impl. function */ 3391 void (*f_func) __ARGS((typeval *args, typeval *rvar));
3392 /* implemenation of function */
2812 } functions[] = 3393 } functions[] =
2813 { 3394 {
2814 {"append", 2, 2, f_append}, 3395 {"append", 2, 2, f_append},
2815 {"argc", 0, 0, f_argc}, 3396 {"argc", 0, 0, f_argc},
2816 {"argidx", 0, 0, f_argidx}, 3397 {"argidx", 0, 0, f_argidx},
2830 {"byteidx", 2, 2, f_byteidx}, 3411 {"byteidx", 2, 2, f_byteidx},
2831 {"char2nr", 1, 1, f_char2nr}, 3412 {"char2nr", 1, 1, f_char2nr},
2832 {"cindent", 1, 1, f_cindent}, 3413 {"cindent", 1, 1, f_cindent},
2833 {"col", 1, 1, f_col}, 3414 {"col", 1, 1, f_col},
2834 {"confirm", 1, 4, f_confirm}, 3415 {"confirm", 1, 4, f_confirm},
3416 {"copy", 1, 1, f_copy},
2835 {"cscope_connection",0,3, f_cscope_connection}, 3417 {"cscope_connection",0,3, f_cscope_connection},
2836 {"cursor", 2, 2, f_cursor}, 3418 {"cursor", 2, 2, f_cursor},
3419 {"deepcopy", 1, 1, f_deepcopy},
2837 {"delete", 1, 1, f_delete}, 3420 {"delete", 1, 1, f_delete},
2838 {"did_filetype", 0, 0, f_did_filetype}, 3421 {"did_filetype", 0, 0, f_did_filetype},
2839 {"diff_filler", 1, 1, f_diff_filler}, 3422 {"diff_filler", 1, 1, f_diff_filler},
2840 {"diff_hlID", 2, 2, f_diff_hlID}, 3423 {"diff_hlID", 2, 2, f_diff_hlID},
2841 {"escape", 2, 2, f_escape}, 3424 {"escape", 2, 2, f_escape},
2853 {"foldclosedend", 1, 1, f_foldclosedend}, 3436 {"foldclosedend", 1, 1, f_foldclosedend},
2854 {"foldlevel", 1, 1, f_foldlevel}, 3437 {"foldlevel", 1, 1, f_foldlevel},
2855 {"foldtext", 0, 0, f_foldtext}, 3438 {"foldtext", 0, 0, f_foldtext},
2856 {"foldtextresult", 1, 1, f_foldtextresult}, 3439 {"foldtextresult", 1, 1, f_foldtextresult},
2857 {"foreground", 0, 0, f_foreground}, 3440 {"foreground", 0, 0, f_foreground},
3441 {"function", 1, 1, f_function},
2858 {"getbufvar", 2, 2, f_getbufvar}, 3442 {"getbufvar", 2, 2, f_getbufvar},
2859 {"getchar", 0, 1, f_getchar}, 3443 {"getchar", 0, 1, f_getchar},
2860 {"getcharmod", 0, 0, f_getcharmod}, 3444 {"getcharmod", 0, 0, f_getcharmod},
2861 {"getcmdline", 0, 0, f_getcmdline}, 3445 {"getcmdline", 0, 0, f_getcmdline},
2862 {"getcmdpos", 0, 0, f_getcmdpos}, 3446 {"getcmdpos", 0, 0, f_getcmdpos},
2890 {"input", 1, 2, f_input}, 3474 {"input", 1, 2, f_input},
2891 {"inputdialog", 1, 3, f_inputdialog}, 3475 {"inputdialog", 1, 3, f_inputdialog},
2892 {"inputrestore", 0, 0, f_inputrestore}, 3476 {"inputrestore", 0, 0, f_inputrestore},
2893 {"inputsave", 0, 0, f_inputsave}, 3477 {"inputsave", 0, 0, f_inputsave},
2894 {"inputsecret", 1, 2, f_inputsecret}, 3478 {"inputsecret", 1, 2, f_inputsecret},
3479 {"insert", 2, 3, f_insert},
2895 {"isdirectory", 1, 1, f_isdirectory}, 3480 {"isdirectory", 1, 1, f_isdirectory},
2896 {"last_buffer_nr", 0, 0, f_last_buffer_nr},/* obsolete */ 3481 {"last_buffer_nr", 0, 0, f_last_buffer_nr},/* obsolete */
3482 {"len", 1, 1, f_len},
2897 {"libcall", 3, 3, f_libcall}, 3483 {"libcall", 3, 3, f_libcall},
2898 {"libcallnr", 3, 3, f_libcallnr}, 3484 {"libcallnr", 3, 3, f_libcallnr},
2899 {"line", 1, 1, f_line}, 3485 {"line", 1, 1, f_line},
2900 {"line2byte", 1, 1, f_line2byte}, 3486 {"line2byte", 1, 1, f_line2byte},
2901 {"lispindent", 1, 1, f_lispindent}, 3487 {"lispindent", 1, 1, f_lispindent},
2912 {"remote_expr", 2, 3, f_remote_expr}, 3498 {"remote_expr", 2, 3, f_remote_expr},
2913 {"remote_foreground", 1, 1, f_remote_foreground}, 3499 {"remote_foreground", 1, 1, f_remote_foreground},
2914 {"remote_peek", 1, 2, f_remote_peek}, 3500 {"remote_peek", 1, 2, f_remote_peek},
2915 {"remote_read", 1, 1, f_remote_read}, 3501 {"remote_read", 1, 1, f_remote_read},
2916 {"remote_send", 2, 3, f_remote_send}, 3502 {"remote_send", 2, 3, f_remote_send},
3503 {"remove", 2, 2, f_remove},
2917 {"rename", 2, 2, f_rename}, 3504 {"rename", 2, 2, f_rename},
2918 {"repeat", 2, 2, f_repeat}, 3505 {"repeat", 2, 2, f_repeat},
2919 {"resolve", 1, 1, f_resolve}, 3506 {"resolve", 1, 1, f_resolve},
2920 {"search", 1, 2, f_search}, 3507 {"search", 1, 2, f_search},
2921 {"searchpair", 3, 5, f_searchpair}, 3508 {"searchpair", 3, 5, f_searchpair},
2929 {"simplify", 1, 1, f_simplify}, 3516 {"simplify", 1, 1, f_simplify},
2930 #ifdef HAVE_STRFTIME 3517 #ifdef HAVE_STRFTIME
2931 {"strftime", 1, 2, f_strftime}, 3518 {"strftime", 1, 2, f_strftime},
2932 #endif 3519 #endif
2933 {"stridx", 2, 2, f_stridx}, 3520 {"stridx", 2, 2, f_stridx},
3521 {"string", 1, 1, f_string},
2934 {"strlen", 1, 1, f_strlen}, 3522 {"strlen", 1, 1, f_strlen},
2935 {"strpart", 2, 3, f_strpart}, 3523 {"strpart", 2, 3, f_strpart},
2936 {"strridx", 2, 2, f_strridx}, 3524 {"strridx", 2, 2, f_strridx},
2937 {"strtrans", 1, 1, f_strtrans}, 3525 {"strtrans", 1, 1, f_strtrans},
2938 {"submatch", 1, 1, f_submatch}, 3526 {"submatch", 1, 1, f_submatch},
3046 } 3634 }
3047 return -1; 3635 return -1;
3048 } 3636 }
3049 3637
3050 /* 3638 /*
3639 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
3640 * name it contains, otherwise return "name".
3641 */
3642 static char_u *
3643 deref_func_name(name, lenp)
3644 char_u *name;
3645 int *lenp;
3646 {
3647 VAR v;
3648 int cc;
3649
3650 cc = name[*lenp];
3651 name[*lenp] = NUL;
3652 v = find_var(name, FALSE);
3653 name[*lenp] = cc;
3654 if (v != NULL && v->tv.v_type == VAR_FUNC)
3655 {
3656 if (v->tv.vval.v_string == NULL)
3657 {
3658 *lenp = 0;
3659 return (char_u *)""; /* just in case */
3660 }
3661 *lenp = STRLEN(v->tv.vval.v_string);
3662 return v->tv.vval.v_string;
3663 }
3664
3665 return name;
3666 }
3667
3668 /*
3051 * Allocate a variable for the result of a function. 3669 * Allocate a variable for the result of a function.
3052 * Return OK or FAIL. 3670 * Return OK or FAIL.
3053 */ 3671 */
3054 static int 3672 static int
3055 get_func_var(name, len, retvar, arg, firstline, lastline, doesrange, evaluate) 3673 get_func_vartv(name, len, retvar, arg, firstline, lastline, doesrange, evaluate)
3056 char_u *name; /* name of the function */ 3674 char_u *name; /* name of the function */
3057 int len; /* length of "name" */ 3675 int len; /* length of "name" */
3058 VAR retvar; 3676 typeval *retvar;
3059 char_u **arg; /* argument, pointing to the '(' */ 3677 char_u **arg; /* argument, pointing to the '(' */
3060 linenr_T firstline; /* first line of range */ 3678 linenr_T firstline; /* first line of range */
3061 linenr_T lastline; /* last line of range */ 3679 linenr_T lastline; /* last line of range */
3062 int *doesrange; /* return: function handled range */ 3680 int *doesrange; /* return: function handled range */
3063 int evaluate; 3681 int evaluate;
3064 { 3682 {
3065 char_u *argp; 3683 char_u *argp;
3066 int ret = OK; 3684 int ret = OK;
3067 #define MAX_FUNC_ARGS 20 3685 #define MAX_FUNC_ARGS 20
3068 var argvars[MAX_FUNC_ARGS]; /* vars for arguments */ 3686 typeval argvars[MAX_FUNC_ARGS]; /* vars for arguments */
3069 int argcount = 0; /* number of arguments found */ 3687 int argcount = 0; /* number of arguments found */
3070 3688
3071 /* 3689 /*
3072 * Get the arguments. 3690 * Get the arguments.
3073 */ 3691 */
3075 while (argcount < MAX_FUNC_ARGS) 3693 while (argcount < MAX_FUNC_ARGS)
3076 { 3694 {
3077 argp = skipwhite(argp + 1); /* skip the '(' or ',' */ 3695 argp = skipwhite(argp + 1); /* skip the '(' or ',' */
3078 if (*argp == ')' || *argp == ',' || *argp == NUL) 3696 if (*argp == ')' || *argp == ',' || *argp == NUL)
3079 break; 3697 break;
3080 argvars[argcount].var_name = NULL; /* the name is not stored */
3081 if (eval1(&argp, &argvars[argcount], evaluate) == FAIL) 3698 if (eval1(&argp, &argvars[argcount], evaluate) == FAIL)
3082 { 3699 {
3083 ret = FAIL; 3700 ret = FAIL;
3084 break; 3701 break;
3085 } 3702 }
3097 firstline, lastline, doesrange, evaluate); 3714 firstline, lastline, doesrange, evaluate);
3098 else if (!aborting()) 3715 else if (!aborting())
3099 EMSG2(_("E116: Invalid arguments for function %s"), name); 3716 EMSG2(_("E116: Invalid arguments for function %s"), name);
3100 3717
3101 while (--argcount >= 0) 3718 while (--argcount >= 0)
3102 clear_var(&argvars[argcount]); 3719 clear_vartv(&argvars[argcount]);
3103 3720
3104 *arg = skipwhite(argp); 3721 *arg = skipwhite(argp);
3105 return ret; 3722 return ret;
3106 } 3723 }
3107 3724
3113 static int 3730 static int
3114 call_func(name, len, retvar, argcount, argvars, firstline, lastline, 3731 call_func(name, len, retvar, argcount, argvars, firstline, lastline,
3115 doesrange, evaluate) 3732 doesrange, evaluate)
3116 char_u *name; /* name of the function */ 3733 char_u *name; /* name of the function */
3117 int len; /* length of "name" */ 3734 int len; /* length of "name" */
3118 VAR retvar; /* return value goes here */ 3735 typeval *retvar; /* return value goes here */
3119 int argcount; /* number of "argvars" */ 3736 int argcount; /* number of "argvars" */
3120 VAR argvars; /* vars for arguments */ 3737 typeval *argvars; /* vars for arguments */
3121 linenr_T firstline; /* first line of range */ 3738 linenr_T firstline; /* first line of range */
3122 linenr_T lastline; /* last line of range */ 3739 linenr_T lastline; /* last line of range */
3123 int *doesrange; /* return: function handled range */ 3740 int *doesrange; /* return: function handled range */
3124 int evaluate; 3741 int evaluate;
3125 { 3742 {
3193 3810
3194 3811
3195 /* execute the function if no errors detected and executing */ 3812 /* execute the function if no errors detected and executing */
3196 if (evaluate && error == ERROR_NONE) 3813 if (evaluate && error == ERROR_NONE)
3197 { 3814 {
3198 retvar->var_type = VAR_NUMBER; /* default is number retvar */ 3815 retvar->v_type = VAR_NUMBER; /* default is number retvar */
3199 error = ERROR_UNKNOWN; 3816 error = ERROR_UNKNOWN;
3200 3817
3201 if (!ASCII_ISLOWER(fname[0])) 3818 if (!ASCII_ISLOWER(fname[0]))
3202 { 3819 {
3203 /* 3820 /*
3255 error = ERROR_TOOFEW; 3872 error = ERROR_TOOFEW;
3256 else if (argcount > functions[i].f_max_argc) 3873 else if (argcount > functions[i].f_max_argc)
3257 error = ERROR_TOOMANY; 3874 error = ERROR_TOOMANY;
3258 else 3875 else
3259 { 3876 {
3260 argvars[argcount].var_type = VAR_UNKNOWN; 3877 argvars[argcount].v_type = VAR_UNKNOWN;
3261 functions[i].f_func(argvars, retvar); 3878 functions[i].f_func(argvars, retvar);
3262 error = ERROR_NONE; 3879 error = ERROR_NONE;
3263 } 3880 }
3264 } 3881 }
3265 } 3882 }
3296 * Implementation of the built-in functions 3913 * Implementation of the built-in functions
3297 */ 3914 */
3298 3915
3299 /* 3916 /*
3300 * "append(lnum, string)" function 3917 * "append(lnum, string)" function
3918 * or "append(list, item)" function
3301 */ 3919 */
3302 static void 3920 static void
3303 f_append(argvars, retvar) 3921 f_append(argvars, retvar)
3304 VAR argvars; 3922 typeval *argvars;
3305 VAR retvar; 3923 typeval *retvar;
3306 { 3924 {
3307 long lnum; 3925 long lnum;
3308 3926
3309 lnum = get_var_lnum(argvars); 3927 retvar->vval.v_number = 1; /* Default: Failed */
3310 retvar->var_val.var_number = 1; /* Default: Failed */ 3928 if (argvars[0].v_type == VAR_LIST)
3311 3929 {
3312 if (lnum >= 0 3930 if (argvars[0].vval.v_list != NULL
3313 && lnum <= curbuf->b_ml.ml_line_count 3931 && list_append_tv(argvars[0].vval.v_list, &argvars[1]) == OK)
3314 && u_save(lnum, lnum + 1) == OK) 3932 copy_vartv(&argvars[0], retvar);
3315 { 3933 }
3316 ml_append(lnum, get_var_string(&argvars[1]), (colnr_T)0, FALSE); 3934 else
3317 if (curwin->w_cursor.lnum > lnum) 3935 {
3318 ++curwin->w_cursor.lnum; 3936 lnum = get_vartv_lnum(argvars);
3319 appended_lines_mark(lnum, 1L); 3937 if (lnum >= 0
3320 retvar->var_val.var_number = 0; 3938 && lnum <= curbuf->b_ml.ml_line_count
3939 && u_save(lnum, lnum + 1) == OK)
3940 {
3941 ml_append(lnum, get_vartv_string(&argvars[1]), (colnr_T)0, FALSE);
3942 if (curwin->w_cursor.lnum > lnum)
3943 ++curwin->w_cursor.lnum;
3944 appended_lines_mark(lnum, 1L);
3945 retvar->vval.v_number = 0;
3946 }
3321 } 3947 }
3322 } 3948 }
3323 3949
3324 /* 3950 /*
3325 * "argc()" function 3951 * "argc()" function
3326 */ 3952 */
3327 /* ARGSUSED */ 3953 /* ARGSUSED */
3328 static void 3954 static void
3329 f_argc(argvars, retvar) 3955 f_argc(argvars, retvar)
3330 VAR argvars; 3956 typeval *argvars;
3331 VAR retvar; 3957 typeval *retvar;
3332 { 3958 {
3333 retvar->var_val.var_number = ARGCOUNT; 3959 retvar->vval.v_number = ARGCOUNT;
3334 } 3960 }
3335 3961
3336 /* 3962 /*
3337 * "argidx()" function 3963 * "argidx()" function
3338 */ 3964 */
3339 /* ARGSUSED */ 3965 /* ARGSUSED */
3340 static void 3966 static void
3341 f_argidx(argvars, retvar) 3967 f_argidx(argvars, retvar)
3342 VAR argvars; 3968 typeval *argvars;
3343 VAR retvar; 3969 typeval *retvar;
3344 { 3970 {
3345 retvar->var_val.var_number = curwin->w_arg_idx; 3971 retvar->vval.v_number = curwin->w_arg_idx;
3346 } 3972 }
3347 3973
3348 /* 3974 /*
3349 * "argv(nr)" function 3975 * "argv(nr)" function
3350 */ 3976 */
3351 static void 3977 static void
3352 f_argv(argvars, retvar) 3978 f_argv(argvars, retvar)
3353 VAR argvars; 3979 typeval *argvars;
3354 VAR retvar; 3980 typeval *retvar;
3355 { 3981 {
3356 int idx; 3982 int idx;
3357 3983
3358 idx = get_var_number(&argvars[0]); 3984 idx = get_vartv_number(&argvars[0]);
3359 if (idx >= 0 && idx < ARGCOUNT) 3985 if (idx >= 0 && idx < ARGCOUNT)
3360 retvar->var_val.var_string = vim_strsave(alist_name(&ARGLIST[idx])); 3986 retvar->vval.v_string = vim_strsave(alist_name(&ARGLIST[idx]));
3361 else 3987 else
3362 retvar->var_val.var_string = NULL; 3988 retvar->vval.v_string = NULL;
3363 retvar->var_type = VAR_STRING; 3989 retvar->v_type = VAR_STRING;
3364 } 3990 }
3365 3991
3366 /* 3992 /*
3367 * "browse(save, title, initdir, default)" function 3993 * "browse(save, title, initdir, default)" function
3368 */ 3994 */
3369 /* ARGSUSED */ 3995 /* ARGSUSED */
3370 static void 3996 static void
3371 f_browse(argvars, retvar) 3997 f_browse(argvars, retvar)
3372 VAR argvars; 3998 typeval *argvars;
3373 VAR retvar; 3999 typeval *retvar;
3374 { 4000 {
3375 #ifdef FEAT_BROWSE 4001 #ifdef FEAT_BROWSE
3376 int save; 4002 int save;
3377 char_u *title; 4003 char_u *title;
3378 char_u *initdir; 4004 char_u *initdir;
3379 char_u *defname; 4005 char_u *defname;
3380 char_u buf[NUMBUFLEN]; 4006 char_u buf[NUMBUFLEN];
3381 char_u buf2[NUMBUFLEN]; 4007 char_u buf2[NUMBUFLEN];
3382 4008
3383 save = get_var_number(&argvars[0]); 4009 save = get_vartv_number(&argvars[0]);
3384 title = get_var_string(&argvars[1]); 4010 title = get_vartv_string(&argvars[1]);
3385 initdir = get_var_string_buf(&argvars[2], buf); 4011 initdir = get_vartv_string_buf(&argvars[2], buf);
3386 defname = get_var_string_buf(&argvars[3], buf2); 4012 defname = get_vartv_string_buf(&argvars[3], buf2);
3387 4013
3388 retvar->var_val.var_string = 4014 retvar->vval.v_string =
3389 do_browse(save ? BROWSE_SAVE : 0, 4015 do_browse(save ? BROWSE_SAVE : 0,
3390 title, defname, NULL, initdir, NULL, curbuf); 4016 title, defname, NULL, initdir, NULL, curbuf);
3391 #else 4017 #else
3392 retvar->var_val.var_string = NULL; 4018 retvar->vval.v_string = NULL;
3393 #endif 4019 #endif
3394 retvar->var_type = VAR_STRING; 4020 retvar->v_type = VAR_STRING;
3395 } 4021 }
3396 4022
3397 /* 4023 /*
3398 * "browsedir(title, initdir)" function 4024 * "browsedir(title, initdir)" function
3399 */ 4025 */
3400 /* ARGSUSED */ 4026 /* ARGSUSED */
3401 static void 4027 static void
3402 f_browsedir(argvars, retvar) 4028 f_browsedir(argvars, retvar)
3403 VAR argvars; 4029 typeval *argvars;
3404 VAR retvar; 4030 typeval *retvar;
3405 { 4031 {
3406 #ifdef FEAT_BROWSE 4032 #ifdef FEAT_BROWSE
3407 char_u *title; 4033 char_u *title;
3408 char_u *initdir; 4034 char_u *initdir;
3409 char_u buf[NUMBUFLEN]; 4035 char_u buf[NUMBUFLEN];
3410 4036
3411 title = get_var_string(&argvars[0]); 4037 title = get_vartv_string(&argvars[0]);
3412 initdir = get_var_string_buf(&argvars[1], buf); 4038 initdir = get_vartv_string_buf(&argvars[1], buf);
3413 4039
3414 retvar->var_val.var_string = do_browse(BROWSE_DIR, 4040 retvar->vval.v_string = do_browse(BROWSE_DIR,
3415 title, NULL, NULL, initdir, NULL, curbuf); 4041 title, NULL, NULL, initdir, NULL, curbuf);
3416 #else 4042 #else
3417 retvar->var_val.var_string = NULL; 4043 retvar->vval.v_string = NULL;
3418 #endif 4044 #endif
3419 retvar->var_type = VAR_STRING; 4045 retvar->v_type = VAR_STRING;
3420 } 4046 }
3421 4047
3422 /* 4048 /*
3423 * Find a buffer by number or exact name. 4049 * Find a buffer by number or exact name.
3424 */ 4050 */
3425 static buf_T * 4051 static buf_T *
3426 find_buffer(avar) 4052 find_buffer(avar)
3427 VAR avar; 4053 typeval *avar;
3428 { 4054 {
3429 buf_T *buf = NULL; 4055 buf_T *buf = NULL;
3430 4056
3431 if (avar->var_type == VAR_NUMBER) 4057 if (avar->v_type == VAR_NUMBER)
3432 buf = buflist_findnr((int)avar->var_val.var_number); 4058 buf = buflist_findnr((int)avar->vval.v_number);
3433 else if (avar->var_val.var_string != NULL) 4059 else if (avar->vval.v_string != NULL)
3434 { 4060 {
3435 buf = buflist_findname_exp(avar->var_val.var_string); 4061 buf = buflist_findname_exp(avar->vval.v_string);
3436 if (buf == NULL) 4062 if (buf == NULL)
3437 { 4063 {
3438 /* No full path name match, try a match with a URL or a "nofile" 4064 /* No full path name match, try a match with a URL or a "nofile"
3439 * buffer, these don't use the full path. */ 4065 * buffer, these don't use the full path. */
3440 for (buf = firstbuf; buf != NULL; buf = buf->b_next) 4066 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
3442 && (path_with_url(buf->b_fname) 4068 && (path_with_url(buf->b_fname)
3443 #ifdef FEAT_QUICKFIX 4069 #ifdef FEAT_QUICKFIX
3444 || bt_nofile(buf) 4070 || bt_nofile(buf)
3445 #endif 4071 #endif
3446 ) 4072 )
3447 && STRCMP(buf->b_fname, avar->var_val.var_string) == 0) 4073 && STRCMP(buf->b_fname, avar->vval.v_string) == 0)
3448 break; 4074 break;
3449 } 4075 }
3450 } 4076 }
3451 return buf; 4077 return buf;
3452 } 4078 }
3454 /* 4080 /*
3455 * "bufexists(expr)" function 4081 * "bufexists(expr)" function
3456 */ 4082 */
3457 static void 4083 static void
3458 f_bufexists(argvars, retvar) 4084 f_bufexists(argvars, retvar)
3459 VAR argvars; 4085 typeval *argvars;
3460 VAR retvar; 4086 typeval *retvar;
3461 { 4087 {
3462 retvar->var_val.var_number = (find_buffer(&argvars[0]) != NULL); 4088 retvar->vval.v_number = (find_buffer(&argvars[0]) != NULL);
3463 } 4089 }
3464 4090
3465 /* 4091 /*
3466 * "buflisted(expr)" function 4092 * "buflisted(expr)" function
3467 */ 4093 */
3468 static void 4094 static void
3469 f_buflisted(argvars, retvar) 4095 f_buflisted(argvars, retvar)
3470 VAR argvars; 4096 typeval *argvars;
3471 VAR retvar; 4097 typeval *retvar;
3472 { 4098 {
3473 buf_T *buf; 4099 buf_T *buf;
3474 4100
3475 buf = find_buffer(&argvars[0]); 4101 buf = find_buffer(&argvars[0]);
3476 retvar->var_val.var_number = (buf != NULL && buf->b_p_bl); 4102 retvar->vval.v_number = (buf != NULL && buf->b_p_bl);
3477 } 4103 }
3478 4104
3479 /* 4105 /*
3480 * "bufloaded(expr)" function 4106 * "bufloaded(expr)" function
3481 */ 4107 */
3482 static void 4108 static void
3483 f_bufloaded(argvars, retvar) 4109 f_bufloaded(argvars, retvar)
3484 VAR argvars; 4110 typeval *argvars;
3485 VAR retvar; 4111 typeval *retvar;
3486 { 4112 {
3487 buf_T *buf; 4113 buf_T *buf;
3488 4114
3489 buf = find_buffer(&argvars[0]); 4115 buf = find_buffer(&argvars[0]);
3490 retvar->var_val.var_number = (buf != NULL && buf->b_ml.ml_mfp != NULL); 4116 retvar->vval.v_number = (buf != NULL && buf->b_ml.ml_mfp != NULL);
3491 } 4117 }
3492 4118
3493 /* 4119 /*
3494 * Get buffer by number or pattern. 4120 * Get buffer by number or pattern.
3495 */ 4121 */
3496 static buf_T * 4122 static buf_T *
3497 get_buf_var(avar) 4123 get_buf_vartv(avar)
3498 VAR avar; 4124 typeval *avar;
3499 { 4125 {
3500 char_u *name = avar->var_val.var_string; 4126 char_u *name = avar->vval.v_string;
3501 int save_magic; 4127 int save_magic;
3502 char_u *save_cpo; 4128 char_u *save_cpo;
3503 buf_T *buf; 4129 buf_T *buf;
3504 4130
3505 if (avar->var_type == VAR_NUMBER) 4131 if (avar->v_type == VAR_NUMBER)
3506 return buflist_findnr((int)avar->var_val.var_number); 4132 return buflist_findnr((int)avar->vval.v_number);
3507 if (name == NULL || *name == NUL) 4133 if (name == NULL || *name == NUL)
3508 return curbuf; 4134 return curbuf;
3509 if (name[0] == '$' && name[1] == NUL) 4135 if (name[0] == '$' && name[1] == NUL)
3510 return lastbuf; 4136 return lastbuf;
3511 4137
3531 /* 4157 /*
3532 * "bufname(expr)" function 4158 * "bufname(expr)" function
3533 */ 4159 */
3534 static void 4160 static void
3535 f_bufname(argvars, retvar) 4161 f_bufname(argvars, retvar)
3536 VAR argvars; 4162 typeval *argvars;
3537 VAR retvar; 4163 typeval *retvar;
3538 { 4164 {
3539 buf_T *buf; 4165 buf_T *buf;
3540 4166
3541 ++emsg_off; 4167 ++emsg_off;
3542 buf = get_buf_var(&argvars[0]); 4168 buf = get_buf_vartv(&argvars[0]);
3543 retvar->var_type = VAR_STRING; 4169 retvar->v_type = VAR_STRING;
3544 if (buf != NULL && buf->b_fname != NULL) 4170 if (buf != NULL && buf->b_fname != NULL)
3545 retvar->var_val.var_string = vim_strsave(buf->b_fname); 4171 retvar->vval.v_string = vim_strsave(buf->b_fname);
3546 else 4172 else
3547 retvar->var_val.var_string = NULL; 4173 retvar->vval.v_string = NULL;
3548 --emsg_off; 4174 --emsg_off;
3549 } 4175 }
3550 4176
3551 /* 4177 /*
3552 * "bufnr(expr)" function 4178 * "bufnr(expr)" function
3553 */ 4179 */
3554 static void 4180 static void
3555 f_bufnr(argvars, retvar) 4181 f_bufnr(argvars, retvar)
3556 VAR argvars; 4182 typeval *argvars;
3557 VAR retvar; 4183 typeval *retvar;
3558 { 4184 {
3559 buf_T *buf; 4185 buf_T *buf;
3560 4186
3561 ++emsg_off; 4187 ++emsg_off;
3562 buf = get_buf_var(&argvars[0]); 4188 buf = get_buf_vartv(&argvars[0]);
3563 if (buf != NULL) 4189 if (buf != NULL)
3564 retvar->var_val.var_number = buf->b_fnum; 4190 retvar->vval.v_number = buf->b_fnum;
3565 else 4191 else
3566 retvar->var_val.var_number = -1; 4192 retvar->vval.v_number = -1;
3567 --emsg_off; 4193 --emsg_off;
3568 } 4194 }
3569 4195
3570 /* 4196 /*
3571 * "bufwinnr(nr)" function 4197 * "bufwinnr(nr)" function
3572 */ 4198 */
3573 static void 4199 static void
3574 f_bufwinnr(argvars, retvar) 4200 f_bufwinnr(argvars, retvar)
3575 VAR argvars; 4201 typeval *argvars;
3576 VAR retvar; 4202 typeval *retvar;
3577 { 4203 {
3578 #ifdef FEAT_WINDOWS 4204 #ifdef FEAT_WINDOWS
3579 win_T *wp; 4205 win_T *wp;
3580 int winnr = 0; 4206 int winnr = 0;
3581 #endif 4207 #endif
3582 buf_T *buf; 4208 buf_T *buf;
3583 4209
3584 ++emsg_off; 4210 ++emsg_off;
3585 buf = get_buf_var(&argvars[0]); 4211 buf = get_buf_vartv(&argvars[0]);
3586 #ifdef FEAT_WINDOWS 4212 #ifdef FEAT_WINDOWS
3587 for (wp = firstwin; wp; wp = wp->w_next) 4213 for (wp = firstwin; wp; wp = wp->w_next)
3588 { 4214 {
3589 ++winnr; 4215 ++winnr;
3590 if (wp->w_buffer == buf) 4216 if (wp->w_buffer == buf)
3591 break; 4217 break;
3592 } 4218 }
3593 retvar->var_val.var_number = (wp != NULL ? winnr : -1); 4219 retvar->vval.v_number = (wp != NULL ? winnr : -1);
3594 #else 4220 #else
3595 retvar->var_val.var_number = (curwin->w_buffer == buf ? 1 : -1); 4221 retvar->vval.v_number = (curwin->w_buffer == buf ? 1 : -1);
3596 #endif 4222 #endif
3597 --emsg_off; 4223 --emsg_off;
3598 } 4224 }
3599 4225
3600 /* 4226 /*
3601 * "byte2line(byte)" function 4227 * "byte2line(byte)" function
3602 */ 4228 */
3603 /*ARGSUSED*/ 4229 /*ARGSUSED*/
3604 static void 4230 static void
3605 f_byte2line(argvars, retvar) 4231 f_byte2line(argvars, retvar)
3606 VAR argvars; 4232 typeval *argvars;
3607 VAR retvar; 4233 typeval *retvar;
3608 { 4234 {
3609 #ifndef FEAT_BYTEOFF 4235 #ifndef FEAT_BYTEOFF
3610 retvar->var_val.var_number = -1; 4236 retvar->vval.v_number = -1;
3611 #else 4237 #else
3612 long boff = 0; 4238 long boff = 0;
3613 4239
3614 boff = get_var_number(&argvars[0]) - 1; 4240 boff = get_vartv_number(&argvars[0]) - 1;
3615 if (boff < 0) 4241 if (boff < 0)
3616 retvar->var_val.var_number = -1; 4242 retvar->vval.v_number = -1;
3617 else 4243 else
3618 retvar->var_val.var_number = ml_find_line_or_offset(curbuf, 4244 retvar->vval.v_number = ml_find_line_or_offset(curbuf,
3619 (linenr_T)0, &boff); 4245 (linenr_T)0, &boff);
3620 #endif 4246 #endif
3621 } 4247 }
3622 4248
3623 /* 4249 /*
3624 * "byteidx()" function 4250 * "byteidx()" function
3625 */ 4251 */
3626 /*ARGSUSED*/ 4252 /*ARGSUSED*/
3627 static void 4253 static void
3628 f_byteidx(argvars, retvar) 4254 f_byteidx(argvars, retvar)
3629 VAR argvars; 4255 typeval *argvars;
3630 VAR retvar; 4256 typeval *retvar;
3631 { 4257 {
3632 #ifdef FEAT_MBYTE 4258 #ifdef FEAT_MBYTE
3633 char_u *t; 4259 char_u *t;
3634 #endif 4260 #endif
3635 char_u *str; 4261 char_u *str;
3636 long idx; 4262 long idx;
3637 4263
3638 str = get_var_string(&argvars[0]); 4264 str = get_vartv_string(&argvars[0]);
3639 idx = get_var_number(&argvars[1]); 4265 idx = get_vartv_number(&argvars[1]);
3640 retvar->var_val.var_number = -1; 4266 retvar->vval.v_number = -1;
3641 if (idx < 0) 4267 if (idx < 0)
3642 return; 4268 return;
3643 4269
3644 #ifdef FEAT_MBYTE 4270 #ifdef FEAT_MBYTE
3645 t = str; 4271 t = str;
3647 { 4273 {
3648 if (*t == NUL) /* EOL reached */ 4274 if (*t == NUL) /* EOL reached */
3649 return; 4275 return;
3650 t += mb_ptr2len_check(t); 4276 t += mb_ptr2len_check(t);
3651 } 4277 }
3652 retvar->var_val.var_number = t - str; 4278 retvar->vval.v_number = t - str;
3653 #else 4279 #else
3654 if (idx <= STRLEN(str)) 4280 if (idx <= STRLEN(str))
3655 retvar->var_val.var_number = idx; 4281 retvar->vval.v_number = idx;
3656 #endif 4282 #endif
3657 } 4283 }
3658 4284
3659 /* 4285 /*
3660 * "char2nr(string)" function 4286 * "char2nr(string)" function
3661 */ 4287 */
3662 static void 4288 static void
3663 f_char2nr(argvars, retvar) 4289 f_char2nr(argvars, retvar)
3664 VAR argvars; 4290 typeval *argvars;
3665 VAR retvar; 4291 typeval *retvar;
3666 { 4292 {
3667 #ifdef FEAT_MBYTE 4293 #ifdef FEAT_MBYTE
3668 if (has_mbyte) 4294 if (has_mbyte)
3669 retvar->var_val.var_number = 4295 retvar->vval.v_number =
3670 (*mb_ptr2char)(get_var_string(&argvars[0])); 4296 (*mb_ptr2char)(get_vartv_string(&argvars[0]));
3671 else 4297 else
3672 #endif 4298 #endif
3673 retvar->var_val.var_number = get_var_string(&argvars[0])[0]; 4299 retvar->vval.v_number = get_vartv_string(&argvars[0])[0];
3674 } 4300 }
3675 4301
3676 /* 4302 /*
3677 * "cindent(lnum)" function 4303 * "cindent(lnum)" function
3678 */ 4304 */
3679 static void 4305 static void
3680 f_cindent(argvars, retvar) 4306 f_cindent(argvars, retvar)
3681 VAR argvars; 4307 typeval *argvars;
3682 VAR retvar; 4308 typeval *retvar;
3683 { 4309 {
3684 #ifdef FEAT_CINDENT 4310 #ifdef FEAT_CINDENT
3685 pos_T pos; 4311 pos_T pos;
3686 linenr_T lnum; 4312 linenr_T lnum;
3687 4313
3688 pos = curwin->w_cursor; 4314 pos = curwin->w_cursor;
3689 lnum = get_var_lnum(argvars); 4315 lnum = get_vartv_lnum(argvars);
3690 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 4316 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
3691 { 4317 {
3692 curwin->w_cursor.lnum = lnum; 4318 curwin->w_cursor.lnum = lnum;
3693 retvar->var_val.var_number = get_c_indent(); 4319 retvar->vval.v_number = get_c_indent();
3694 curwin->w_cursor = pos; 4320 curwin->w_cursor = pos;
3695 } 4321 }
3696 else 4322 else
3697 #endif 4323 #endif
3698 retvar->var_val.var_number = -1; 4324 retvar->vval.v_number = -1;
3699 } 4325 }
3700 4326
3701 /* 4327 /*
3702 * "col(string)" function 4328 * "col(string)" function
3703 */ 4329 */
3704 static void 4330 static void
3705 f_col(argvars, retvar) 4331 f_col(argvars, retvar)
3706 VAR argvars; 4332 typeval *argvars;
3707 VAR retvar; 4333 typeval *retvar;
3708 { 4334 {
3709 colnr_T col = 0; 4335 colnr_T col = 0;
3710 pos_T *fp; 4336 pos_T *fp;
3711 4337
3712 fp = var2fpos(&argvars[0], FALSE); 4338 fp = var2fpos(&argvars[0], FALSE);
3745 } 4371 }
3746 } 4372 }
3747 #endif 4373 #endif
3748 } 4374 }
3749 } 4375 }
3750 retvar->var_val.var_number = col; 4376 retvar->vval.v_number = col;
3751 } 4377 }
3752 4378
3753 /* 4379 /*
3754 * "confirm(message, buttons[, default [, type]])" function 4380 * "confirm(message, buttons[, default [, type]])" function
3755 */ 4381 */
3756 /*ARGSUSED*/ 4382 /*ARGSUSED*/
3757 static void 4383 static void
3758 f_confirm(argvars, retvar) 4384 f_confirm(argvars, retvar)
3759 VAR argvars; 4385 typeval *argvars;
3760 VAR retvar; 4386 typeval *retvar;
3761 { 4387 {
3762 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 4388 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3763 char_u *message; 4389 char_u *message;
3764 char_u *buttons = NULL; 4390 char_u *buttons = NULL;
3765 char_u buf[NUMBUFLEN]; 4391 char_u buf[NUMBUFLEN];
3766 char_u buf2[NUMBUFLEN]; 4392 char_u buf2[NUMBUFLEN];
3767 int def = 1; 4393 int def = 1;
3768 int type = VIM_GENERIC; 4394 int type = VIM_GENERIC;
3769 int c; 4395 int c;
3770 4396
3771 message = get_var_string(&argvars[0]); 4397 message = get_vartv_string(&argvars[0]);
3772 if (argvars[1].var_type != VAR_UNKNOWN) 4398 if (argvars[1].v_type != VAR_UNKNOWN)
3773 { 4399 {
3774 buttons = get_var_string_buf(&argvars[1], buf); 4400 buttons = get_vartv_string_buf(&argvars[1], buf);
3775 if (argvars[2].var_type != VAR_UNKNOWN) 4401 if (argvars[2].v_type != VAR_UNKNOWN)
3776 { 4402 {
3777 def = get_var_number(&argvars[2]); 4403 def = get_vartv_number(&argvars[2]);
3778 if (argvars[3].var_type != VAR_UNKNOWN) 4404 if (argvars[3].v_type != VAR_UNKNOWN)
3779 { 4405 {
3780 /* avoid that TOUPPER_ASC calls get_var_string_buf() twice */ 4406 /* avoid that TOUPPER_ASC calls get_var_string_buf() twice */
3781 c = *get_var_string_buf(&argvars[3], buf2); 4407 c = *get_vartv_string_buf(&argvars[3], buf2);
3782 switch (TOUPPER_ASC(c)) 4408 switch (TOUPPER_ASC(c))
3783 { 4409 {
3784 case 'E': type = VIM_ERROR; break; 4410 case 'E': type = VIM_ERROR; break;
3785 case 'Q': type = VIM_QUESTION; break; 4411 case 'Q': type = VIM_QUESTION; break;
3786 case 'I': type = VIM_INFO; break; 4412 case 'I': type = VIM_INFO; break;
3792 } 4418 }
3793 4419
3794 if (buttons == NULL || *buttons == NUL) 4420 if (buttons == NULL || *buttons == NUL)
3795 buttons = (char_u *)_("&Ok"); 4421 buttons = (char_u *)_("&Ok");
3796 4422
3797 retvar->var_val.var_number = do_dialog(type, NULL, message, buttons, 4423 retvar->vval.v_number = do_dialog(type, NULL, message, buttons,
3798 def, NULL); 4424 def, NULL);
3799 #else 4425 #else
3800 retvar->var_val.var_number = 0; 4426 retvar->vval.v_number = 0;
3801 #endif 4427 #endif
3802 } 4428 }
3803 4429
4430 /*
4431 * "copy()" function
4432 */
4433 static void
4434 f_copy(argvars, retvar)
4435 typeval *argvars;
4436 typeval *retvar;
4437 {
4438 if (argvars[0].v_type == VAR_LIST)
4439 {
4440 retvar->v_type = VAR_LIST;
4441 retvar->vval.v_list = list_copy(argvars[0].vval.v_list, FALSE);
4442 }
4443 else
4444 copy_vartv(&argvars[0], retvar);
4445 }
3804 4446
3805 /* 4447 /*
3806 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function 4448 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
3807 * 4449 *
3808 * Checks the existence of a cscope connection. 4450 * Checks the existence of a cscope connection.
3809 */ 4451 */
3810 /*ARGSUSED*/ 4452 /*ARGSUSED*/
3811 static void 4453 static void
3812 f_cscope_connection(argvars, retvar) 4454 f_cscope_connection(argvars, retvar)
3813 VAR argvars; 4455 typeval *argvars;
3814 VAR retvar; 4456 typeval *retvar;
3815 { 4457 {
3816 #ifdef FEAT_CSCOPE 4458 #ifdef FEAT_CSCOPE
3817 int num = 0; 4459 int num = 0;
3818 char_u *dbpath = NULL; 4460 char_u *dbpath = NULL;
3819 char_u *prepend = NULL; 4461 char_u *prepend = NULL;
3820 char_u buf[NUMBUFLEN]; 4462 char_u buf[NUMBUFLEN];
3821 4463
3822 if (argvars[0].var_type != VAR_UNKNOWN 4464 if (argvars[0].v_type != VAR_UNKNOWN
3823 && argvars[1].var_type != VAR_UNKNOWN) 4465 && argvars[1].v_type != VAR_UNKNOWN)
3824 { 4466 {
3825 num = (int)get_var_number(&argvars[0]); 4467 num = (int)get_vartv_number(&argvars[0]);
3826 dbpath = get_var_string(&argvars[1]); 4468 dbpath = get_vartv_string(&argvars[1]);
3827 if (argvars[2].var_type != VAR_UNKNOWN) 4469 if (argvars[2].v_type != VAR_UNKNOWN)
3828 prepend = get_var_string_buf(&argvars[2], buf); 4470 prepend = get_vartv_string_buf(&argvars[2], buf);
3829 } 4471 }
3830 4472
3831 retvar->var_val.var_number = cs_connection(num, dbpath, prepend); 4473 retvar->vval.v_number = cs_connection(num, dbpath, prepend);
3832 #else 4474 #else
3833 retvar->var_val.var_number = 0; 4475 retvar->vval.v_number = 0;
3834 #endif 4476 #endif
3835 } 4477 }
3836 4478
3837 /* 4479 /*
3838 * "cursor(lnum, col)" function 4480 * "cursor(lnum, col)" function
3840 * Moves the cursor to the specified line and column 4482 * Moves the cursor to the specified line and column
3841 */ 4483 */
3842 /*ARGSUSED*/ 4484 /*ARGSUSED*/
3843 static void 4485 static void
3844 f_cursor(argvars, retvar) 4486 f_cursor(argvars, retvar)
3845 VAR argvars; 4487 typeval *argvars;
3846 VAR retvar; 4488 typeval *retvar;
3847 { 4489 {
3848 long line, col; 4490 long line, col;
3849 4491
3850 line = get_var_lnum(argvars); 4492 line = get_vartv_lnum(argvars);
3851 if (line > 0) 4493 if (line > 0)
3852 curwin->w_cursor.lnum = line; 4494 curwin->w_cursor.lnum = line;
3853 col = get_var_number(&argvars[1]); 4495 col = get_vartv_number(&argvars[1]);
3854 if (col > 0) 4496 if (col > 0)
3855 curwin->w_cursor.col = col - 1; 4497 curwin->w_cursor.col = col - 1;
3856 #ifdef FEAT_VIRTUALEDIT 4498 #ifdef FEAT_VIRTUALEDIT
3857 curwin->w_cursor.coladd = 0; 4499 curwin->w_cursor.coladd = 0;
3858 #endif 4500 #endif
3867 4509
3868 curwin->w_set_curswant = TRUE; 4510 curwin->w_set_curswant = TRUE;
3869 } 4511 }
3870 4512
3871 /* 4513 /*
3872 * "libcall()" function 4514 * "deepcopy()" function
3873 */ 4515 */
3874 static void 4516 static void
3875 f_libcall(argvars, retvar) 4517 f_deepcopy(argvars, retvar)
3876 VAR argvars; 4518 typeval *argvars;
3877 VAR retvar; 4519 typeval *retvar;
3878 { 4520 {
3879 libcall_common(argvars, retvar, VAR_STRING); 4521 if (argvars[0].v_type == VAR_LIST)
3880 } 4522 {
3881 4523 retvar->v_type = VAR_LIST;
3882 /* 4524 retvar->vval.v_list = list_copy(argvars[0].vval.v_list, TRUE);
3883 * "libcallnr()" function 4525 }
3884 */
3885 static void
3886 f_libcallnr(argvars, retvar)
3887 VAR argvars;
3888 VAR retvar;
3889 {
3890 libcall_common(argvars, retvar, VAR_NUMBER);
3891 }
3892
3893 static void
3894 libcall_common(argvars, retvar, type)
3895 VAR argvars;
3896 VAR retvar;
3897 int type;
3898 {
3899 #ifdef FEAT_LIBCALL
3900 char_u *string_in;
3901 char_u **string_result;
3902 int nr_result;
3903 #endif
3904
3905 retvar->var_type = type;
3906 if (type == VAR_NUMBER)
3907 retvar->var_val.var_number = 0;
3908 else 4526 else
3909 retvar->var_val.var_string = NULL; 4527 copy_vartv(&argvars[0], retvar);
3910 4528 }
4529
4530 /*
4531 * "delete()" function
4532 */
4533 static void
4534 f_delete(argvars, retvar)
4535 typeval *argvars;
4536 typeval *retvar;
4537 {
3911 if (check_restricted() || check_secure()) 4538 if (check_restricted() || check_secure())
3912 return; 4539 retvar->vval.v_number = -1;
3913
3914 #ifdef FEAT_LIBCALL
3915 /* The first two args must be strings, otherwise its meaningless */
3916 if (argvars[0].var_type == VAR_STRING && argvars[1].var_type == VAR_STRING)
3917 {
3918 if (argvars[2].var_type == VAR_NUMBER)
3919 string_in = NULL;
3920 else
3921 string_in = argvars[2].var_val.var_string;
3922 if (type == VAR_NUMBER)
3923 string_result = NULL;
3924 else
3925 string_result = &retvar->var_val.var_string;
3926 if (mch_libcall(argvars[0].var_val.var_string,
3927 argvars[1].var_val.var_string,
3928 string_in,
3929 argvars[2].var_val.var_number,
3930 string_result,
3931 &nr_result) == OK
3932 && type == VAR_NUMBER)
3933 retvar->var_val.var_number = nr_result;
3934 }
3935 #endif
3936 }
3937
3938 /*
3939 * "delete()" function
3940 */
3941 static void
3942 f_delete(argvars, retvar)
3943 VAR argvars;
3944 VAR retvar;
3945 {
3946 if (check_restricted() || check_secure())
3947 retvar->var_val.var_number = -1;
3948 else 4540 else
3949 retvar->var_val.var_number = mch_remove(get_var_string(&argvars[0])); 4541 retvar->vval.v_number = mch_remove(get_vartv_string(&argvars[0]));
3950 } 4542 }
3951 4543
3952 /* 4544 /*
3953 * "did_filetype()" function 4545 * "did_filetype()" function
3954 */ 4546 */
3955 /*ARGSUSED*/ 4547 /*ARGSUSED*/
3956 static void 4548 static void
3957 f_did_filetype(argvars, retvar) 4549 f_did_filetype(argvars, retvar)
3958 VAR argvars; 4550 typeval *argvars;
3959 VAR retvar; 4551 typeval *retvar;
3960 { 4552 {
3961 #ifdef FEAT_AUTOCMD 4553 #ifdef FEAT_AUTOCMD
3962 retvar->var_val.var_number = did_filetype; 4554 retvar->vval.v_number = did_filetype;
3963 #else 4555 #else
3964 retvar->var_val.var_number = 0; 4556 retvar->vval.v_number = 0;
3965 #endif 4557 #endif
3966 } 4558 }
3967 4559
3968 /* 4560 /*
3969 * "diff_filler()" function 4561 * "diff_filler()" function
3970 */ 4562 */
3971 /*ARGSUSED*/ 4563 /*ARGSUSED*/
3972 static void 4564 static void
3973 f_diff_filler(argvars, retvar) 4565 f_diff_filler(argvars, retvar)
3974 VAR argvars; 4566 typeval *argvars;
3975 VAR retvar; 4567 typeval *retvar;
3976 { 4568 {
3977 #ifdef FEAT_DIFF 4569 #ifdef FEAT_DIFF
3978 retvar->var_val.var_number = diff_check_fill(curwin, get_var_lnum(argvars)); 4570 retvar->vval.v_number = diff_check_fill(curwin, get_vartv_lnum(argvars));
3979 #endif 4571 #endif
3980 } 4572 }
3981 4573
3982 /* 4574 /*
3983 * "diff_hlID()" function 4575 * "diff_hlID()" function
3984 */ 4576 */
3985 /*ARGSUSED*/ 4577 /*ARGSUSED*/
3986 static void 4578 static void
3987 f_diff_hlID(argvars, retvar) 4579 f_diff_hlID(argvars, retvar)
3988 VAR argvars; 4580 typeval *argvars;
3989 VAR retvar; 4581 typeval *retvar;
3990 { 4582 {
3991 #ifdef FEAT_DIFF 4583 #ifdef FEAT_DIFF
3992 linenr_T lnum = get_var_lnum(argvars); 4584 linenr_T lnum = get_vartv_lnum(argvars);
3993 static linenr_T prev_lnum = 0; 4585 static linenr_T prev_lnum = 0;
3994 static int changedtick = 0; 4586 static int changedtick = 0;
3995 static int fnum = 0; 4587 static int fnum = 0;
3996 static int change_start = 0; 4588 static int change_start = 0;
3997 static int change_end = 0; 4589 static int change_end = 0;
4026 fnum = curbuf->b_fnum; 4618 fnum = curbuf->b_fnum;
4027 } 4619 }
4028 4620
4029 if (hlID == HLF_CHD || hlID == HLF_TXD) 4621 if (hlID == HLF_CHD || hlID == HLF_TXD)
4030 { 4622 {
4031 col = get_var_number(&argvars[1]) - 1; 4623 col = get_vartv_number(&argvars[1]) - 1;
4032 if (col >= change_start && col <= change_end) 4624 if (col >= change_start && col <= change_end)
4033 hlID = HLF_TXD; /* changed text */ 4625 hlID = HLF_TXD; /* changed text */
4034 else 4626 else
4035 hlID = HLF_CHD; /* changed line */ 4627 hlID = HLF_CHD; /* changed line */
4036 } 4628 }
4037 retvar->var_val.var_number = hlID == (enum hlf_value)0 ? 0 : (int)hlID; 4629 retvar->vval.v_number = hlID == (enum hlf_value)0 ? 0 : (int)hlID;
4038 #endif 4630 #endif
4039 } 4631 }
4040 4632
4041 /* 4633 /*
4042 * "escape({string}, {chars})" function 4634 * "escape({string}, {chars})" function
4043 */ 4635 */
4044 static void 4636 static void
4045 f_escape(argvars, retvar) 4637 f_escape(argvars, retvar)
4046 VAR argvars; 4638 typeval *argvars;
4047 VAR retvar; 4639 typeval *retvar;
4048 { 4640 {
4049 char_u buf[NUMBUFLEN]; 4641 char_u buf[NUMBUFLEN];
4050 4642
4051 retvar->var_val.var_string = 4643 retvar->vval.v_string =
4052 vim_strsave_escaped(get_var_string(&argvars[0]), 4644 vim_strsave_escaped(get_vartv_string(&argvars[0]),
4053 get_var_string_buf(&argvars[1], buf)); 4645 get_vartv_string_buf(&argvars[1], buf));
4054 retvar->var_type = VAR_STRING; 4646 retvar->v_type = VAR_STRING;
4055 } 4647 }
4056 4648
4057 /* 4649 /*
4058 * "eventhandler()" function 4650 * "eventhandler()" function
4059 */ 4651 */
4060 /*ARGSUSED*/ 4652 /*ARGSUSED*/
4061 static void 4653 static void
4062 f_eventhandler(argvars, retvar) 4654 f_eventhandler(argvars, retvar)
4063 VAR argvars; 4655 typeval *argvars;
4064 VAR retvar; 4656 typeval *retvar;
4065 { 4657 {
4066 retvar->var_val.var_number = vgetc_busy; 4658 retvar->vval.v_number = vgetc_busy;
4067 } 4659 }
4068 4660
4069 /* 4661 /*
4070 * "executable()" function 4662 * "executable()" function
4071 */ 4663 */
4072 static void 4664 static void
4073 f_executable(argvars, retvar) 4665 f_executable(argvars, retvar)
4074 VAR argvars; 4666 typeval *argvars;
4075 VAR retvar; 4667 typeval *retvar;
4076 { 4668 {
4077 retvar->var_val.var_number = mch_can_exe(get_var_string(&argvars[0])); 4669 retvar->vval.v_number = mch_can_exe(get_vartv_string(&argvars[0]));
4078 } 4670 }
4079 4671
4080 /* 4672 /*
4081 * "exists()" function 4673 * "exists()" function
4082 */ 4674 */
4083 static void 4675 static void
4084 f_exists(argvars, retvar) 4676 f_exists(argvars, retvar)
4085 VAR argvars; 4677 typeval *argvars;
4086 VAR retvar; 4678 typeval *retvar;
4087 { 4679 {
4088 char_u *p; 4680 char_u *p;
4089 char_u *name; 4681 char_u *name;
4090 int n = FALSE; 4682 int n = FALSE;
4091 int len = 0; 4683 int len = 0;
4092 4684
4093 p = get_var_string(&argvars[0]); 4685 p = get_vartv_string(&argvars[0]);
4094 if (*p == '$') /* environment variable */ 4686 if (*p == '$') /* environment variable */
4095 { 4687 {
4096 /* first try "normal" environment variables (fast) */ 4688 /* first try "normal" environment variables (fast) */
4097 if (mch_getenv(p + 1) != NULL) 4689 if (mch_getenv(p + 1) != NULL)
4098 n = TRUE; 4690 n = TRUE;
4104 n = TRUE; 4696 n = TRUE;
4105 vim_free(p); 4697 vim_free(p);
4106 } 4698 }
4107 } 4699 }
4108 else if (*p == '&' || *p == '+') /* option */ 4700 else if (*p == '&' || *p == '+') /* option */
4109 n = (get_option_var(&p, NULL, TRUE) == OK); 4701 n = (get_option_vartv(&p, NULL, TRUE) == OK);
4110 else if (*p == '*') /* internal or user defined function */ 4702 else if (*p == '*') /* internal or user defined function */
4111 { 4703 {
4112 ++p; 4704 n = function_exists(p + 1);
4113 p = trans_function_name(&p, FALSE, TRUE);
4114 if (p != NULL)
4115 {
4116 if (ASCII_ISUPPER(*p) || p[0] == K_SPECIAL)
4117 n = (find_func(p) != NULL);
4118 else if (ASCII_ISLOWER(*p))
4119 n = (find_internal_func(p) >= 0);
4120 vim_free(p);
4121 }
4122 } 4705 }
4123 else if (*p == ':') 4706 else if (*p == ':')
4124 { 4707 {
4125 n = cmd_exists(p + 1); 4708 n = cmd_exists(p + 1);
4126 } 4709 }
4159 } 4742 }
4160 #endif 4743 #endif
4161 if (len == 0) 4744 if (len == 0)
4162 len = get_id_len(&p); 4745 len = get_id_len(&p);
4163 if (len != 0) 4746 if (len != 0)
4164 n = (get_var_var(name, len, NULL) == OK); 4747 n = (get_var_vartv(name, len, NULL) == OK);
4165 4748
4166 #ifdef FEAT_MAGIC_BRACES 4749 #ifdef FEAT_MAGIC_BRACES
4167 vim_free(temp_string); 4750 vim_free(temp_string);
4168 #endif 4751 #endif
4169 } 4752 }
4170 4753
4171 retvar->var_val.var_number = n; 4754 retvar->vval.v_number = n;
4172 } 4755 }
4173 4756
4174 /* 4757 /*
4175 * "expand()" function 4758 * "expand()" function
4176 */ 4759 */
4177 static void 4760 static void
4178 f_expand(argvars, retvar) 4761 f_expand(argvars, retvar)
4179 VAR argvars; 4762 typeval *argvars;
4180 VAR retvar; 4763 typeval *retvar;
4181 { 4764 {
4182 char_u *s; 4765 char_u *s;
4183 int len; 4766 int len;
4184 char_u *errormsg; 4767 char_u *errormsg;
4185 int flags = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND; 4768 int flags = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4186 expand_T xpc; 4769 expand_T xpc;
4187 4770
4188 retvar->var_type = VAR_STRING; 4771 retvar->v_type = VAR_STRING;
4189 s = get_var_string(&argvars[0]); 4772 s = get_vartv_string(&argvars[0]);
4190 if (*s == '%' || *s == '#' || *s == '<') 4773 if (*s == '%' || *s == '#' || *s == '<')
4191 { 4774 {
4192 ++emsg_off; 4775 ++emsg_off;
4193 retvar->var_val.var_string = eval_vars(s, &len, NULL, &errormsg, s); 4776 retvar->vval.v_string = eval_vars(s, &len, NULL, &errormsg, s);
4194 --emsg_off; 4777 --emsg_off;
4195 } 4778 }
4196 else 4779 else
4197 { 4780 {
4198 /* When the optional second argument is non-zero, don't remove matches 4781 /* When the optional second argument is non-zero, don't remove matches
4199 * for 'suffixes' and 'wildignore' */ 4782 * for 'suffixes' and 'wildignore' */
4200 if (argvars[1].var_type != VAR_UNKNOWN && get_var_number(&argvars[1])) 4783 if (argvars[1].v_type != VAR_UNKNOWN && get_vartv_number(&argvars[1]))
4201 flags |= WILD_KEEP_ALL; 4784 flags |= WILD_KEEP_ALL;
4202 ExpandInit(&xpc); 4785 ExpandInit(&xpc);
4203 xpc.xp_context = EXPAND_FILES; 4786 xpc.xp_context = EXPAND_FILES;
4204 retvar->var_val.var_string = ExpandOne(&xpc, s, NULL, flags, WILD_ALL); 4787 retvar->vval.v_string = ExpandOne(&xpc, s, NULL, flags, WILD_ALL);
4205 ExpandCleanup(&xpc); 4788 ExpandCleanup(&xpc);
4206 } 4789 }
4207 } 4790 }
4208 4791
4209 /* 4792 /*
4210 * "filereadable()" function 4793 * "filereadable()" function
4211 */ 4794 */
4212 static void 4795 static void
4213 f_filereadable(argvars, retvar) 4796 f_filereadable(argvars, retvar)
4214 VAR argvars; 4797 typeval *argvars;
4215 VAR retvar; 4798 typeval *retvar;
4216 { 4799 {
4217 FILE *fd; 4800 FILE *fd;
4218 char_u *p; 4801 char_u *p;
4219 int n; 4802 int n;
4220 4803
4221 p = get_var_string(&argvars[0]); 4804 p = get_vartv_string(&argvars[0]);
4222 if (*p && !mch_isdir(p) && (fd = mch_fopen((char *)p, "r")) != NULL) 4805 if (*p && !mch_isdir(p) && (fd = mch_fopen((char *)p, "r")) != NULL)
4223 { 4806 {
4224 n = TRUE; 4807 n = TRUE;
4225 fclose(fd); 4808 fclose(fd);
4226 } 4809 }
4227 else 4810 else
4228 n = FALSE; 4811 n = FALSE;
4229 4812
4230 retvar->var_val.var_number = n; 4813 retvar->vval.v_number = n;
4231 } 4814 }
4232 4815
4233 /* 4816 /*
4234 * return 0 for not writable, 1 for writable file, 2 for a dir which we have 4817 * return 0 for not writable, 1 for writable file, 2 for a dir which we have
4235 * rights to write into. 4818 * rights to write into.
4236 */ 4819 */
4237 static void 4820 static void
4238 f_filewritable(argvars, retvar) 4821 f_filewritable(argvars, retvar)
4239 VAR argvars; 4822 typeval *argvars;
4240 VAR retvar; 4823 typeval *retvar;
4241 { 4824 {
4242 char_u *p; 4825 char_u *p;
4243 int retval = 0; 4826 int retval = 0;
4244 #if defined(UNIX) || defined(VMS) 4827 #if defined(UNIX) || defined(VMS)
4245 int perm = 0; 4828 int perm = 0;
4246 #endif 4829 #endif
4247 4830
4248 p = get_var_string(&argvars[0]); 4831 p = get_vartv_string(&argvars[0]);
4249 #if defined(UNIX) || defined(VMS) 4832 #if defined(UNIX) || defined(VMS)
4250 perm = mch_getperm(p); 4833 perm = mch_getperm(p);
4251 #endif 4834 #endif
4252 #ifndef MACOS_CLASSIC /* TODO: get either mch_writable or mch_access */ 4835 #ifndef MACOS_CLASSIC /* TODO: get either mch_writable or mch_access */
4253 if ( 4836 if (
4264 { 4847 {
4265 ++retval; 4848 ++retval;
4266 if (mch_isdir(p)) 4849 if (mch_isdir(p))
4267 ++retval; 4850 ++retval;
4268 } 4851 }
4269 retvar->var_val.var_number = retval; 4852 retvar->vval.v_number = retval;
4270 } 4853 }
4271 4854
4272 /* 4855 /*
4273 * "finddir({fname}[, {path}[, {count}]])" function 4856 * "finddir({fname}[, {path}[, {count}]])" function
4274 */ 4857 */
4275 static void 4858 static void
4276 f_finddir(argvars, retvar) 4859 f_finddir(argvars, retvar)
4277 VAR argvars; 4860 typeval *argvars;
4278 VAR retvar; 4861 typeval *retvar;
4279 { 4862 {
4280 f_findfilendir(argvars, retvar, TRUE); 4863 f_findfilendir(argvars, retvar, TRUE);
4281 } 4864 }
4282 4865
4283 /* 4866 /*
4284 * "findfile({fname}[, {path}[, {count}]])" function 4867 * "findfile({fname}[, {path}[, {count}]])" function
4285 */ 4868 */
4286 static void 4869 static void
4287 f_findfile(argvars, retvar) 4870 f_findfile(argvars, retvar)
4288 VAR argvars; 4871 typeval *argvars;
4289 VAR retvar; 4872 typeval *retvar;
4290 { 4873 {
4291 f_findfilendir(argvars, retvar, FALSE); 4874 f_findfilendir(argvars, retvar, FALSE);
4292 } 4875 }
4293 4876
4294 static void 4877 static void
4295 f_findfilendir(argvars, retvar, dir) 4878 f_findfilendir(argvars, retvar, dir)
4296 VAR argvars; 4879 typeval *argvars;
4297 VAR retvar; 4880 typeval *retvar;
4298 int dir; 4881 int dir;
4299 { 4882 {
4300 #ifdef FEAT_SEARCHPATH 4883 #ifdef FEAT_SEARCHPATH
4301 char_u *fname; 4884 char_u *fname;
4302 char_u *fresult = NULL; 4885 char_u *fresult = NULL;
4304 char_u *p; 4887 char_u *p;
4305 char_u pathbuf[NUMBUFLEN]; 4888 char_u pathbuf[NUMBUFLEN];
4306 int count = 1; 4889 int count = 1;
4307 int first = TRUE; 4890 int first = TRUE;
4308 4891
4309 fname = get_var_string(&argvars[0]); 4892 fname = get_vartv_string(&argvars[0]);
4310 4893
4311 if (argvars[1].var_type != VAR_UNKNOWN) 4894 if (argvars[1].v_type != VAR_UNKNOWN)
4312 { 4895 {
4313 p = get_var_string_buf(&argvars[1], pathbuf); 4896 p = get_vartv_string_buf(&argvars[1], pathbuf);
4314 if (*p != NUL) 4897 if (*p != NUL)
4315 path = p; 4898 path = p;
4316 4899
4317 if (argvars[2].var_type != VAR_UNKNOWN) 4900 if (argvars[2].v_type != VAR_UNKNOWN)
4318 count = get_var_number(&argvars[2]); 4901 count = get_vartv_number(&argvars[2]);
4319 } 4902 }
4320 4903
4321 do 4904 do
4322 { 4905 {
4323 vim_free(fresult); 4906 vim_free(fresult);
4325 first ? (int)STRLEN(fname) : 0, 4908 first ? (int)STRLEN(fname) : 0,
4326 0, first, path, dir, NULL); 4909 0, first, path, dir, NULL);
4327 first = FALSE; 4910 first = FALSE;
4328 } while (--count > 0 && fresult != NULL); 4911 } while (--count > 0 && fresult != NULL);
4329 4912
4330 retvar->var_val.var_string = fresult; 4913 retvar->vval.v_string = fresult;
4331 #else 4914 #else
4332 retvar->var_val.var_string = NULL; 4915 retvar->vval.v_string = NULL;
4333 #endif 4916 #endif
4334 retvar->var_type = VAR_STRING; 4917 retvar->v_type = VAR_STRING;
4335 } 4918 }
4336 4919
4337 /* 4920 /*
4338 * "fnamemodify({fname}, {mods})" function 4921 * "fnamemodify({fname}, {mods})" function
4339 */ 4922 */
4340 static void 4923 static void
4341 f_fnamemodify(argvars, retvar) 4924 f_fnamemodify(argvars, retvar)
4342 VAR argvars; 4925 typeval *argvars;
4343 VAR retvar; 4926 typeval *retvar;
4344 { 4927 {
4345 char_u *fname; 4928 char_u *fname;
4346 char_u *mods; 4929 char_u *mods;
4347 int usedlen = 0; 4930 int usedlen = 0;
4348 int len; 4931 int len;
4349 char_u *fbuf = NULL; 4932 char_u *fbuf = NULL;
4350 char_u buf[NUMBUFLEN]; 4933 char_u buf[NUMBUFLEN];
4351 4934
4352 fname = get_var_string(&argvars[0]); 4935 fname = get_vartv_string(&argvars[0]);
4353 mods = get_var_string_buf(&argvars[1], buf); 4936 mods = get_vartv_string_buf(&argvars[1], buf);
4354 len = (int)STRLEN(fname); 4937 len = (int)STRLEN(fname);
4355 4938
4356 (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len); 4939 (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len);
4357 4940
4358 retvar->var_type = VAR_STRING; 4941 retvar->v_type = VAR_STRING;
4359 if (fname == NULL) 4942 if (fname == NULL)
4360 retvar->var_val.var_string = NULL; 4943 retvar->vval.v_string = NULL;
4361 else 4944 else
4362 retvar->var_val.var_string = vim_strnsave(fname, len); 4945 retvar->vval.v_string = vim_strnsave(fname, len);
4363 vim_free(fbuf); 4946 vim_free(fbuf);
4364 } 4947 }
4365 4948
4366 /* 4949 /*
4367 * "foldclosed()" function 4950 * "foldclosed()" function
4368 */ 4951 */
4369 static void 4952 static void
4370 f_foldclosed(argvars, retvar) 4953 f_foldclosed(argvars, retvar)
4371 VAR argvars; 4954 typeval *argvars;
4372 VAR retvar; 4955 typeval *retvar;
4373 { 4956 {
4374 foldclosed_both(argvars, retvar, FALSE); 4957 foldclosed_both(argvars, retvar, FALSE);
4375 } 4958 }
4376 4959
4377 /* 4960 /*
4378 * "foldclosedend()" function 4961 * "foldclosedend()" function
4379 */ 4962 */
4380 static void 4963 static void
4381 f_foldclosedend(argvars, retvar) 4964 f_foldclosedend(argvars, retvar)
4382 VAR argvars; 4965 typeval *argvars;
4383 VAR retvar; 4966 typeval *retvar;
4384 { 4967 {
4385 foldclosed_both(argvars, retvar, TRUE); 4968 foldclosed_both(argvars, retvar, TRUE);
4386 } 4969 }
4387 4970
4388 /* 4971 /*
4389 * "foldclosed()" function 4972 * "foldclosed()" function
4390 */ 4973 */
4391 static void 4974 static void
4392 foldclosed_both(argvars, retvar, end) 4975 foldclosed_both(argvars, retvar, end)
4393 VAR argvars; 4976 typeval *argvars;
4394 VAR retvar; 4977 typeval *retvar;
4395 int end; 4978 int end;
4396 { 4979 {
4397 #ifdef FEAT_FOLDING 4980 #ifdef FEAT_FOLDING
4398 linenr_T lnum; 4981 linenr_T lnum;
4399 linenr_T first, last; 4982 linenr_T first, last;
4400 4983
4401 lnum = get_var_lnum(argvars); 4984 lnum = get_vartv_lnum(argvars);
4402 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 4985 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4403 { 4986 {
4404 if (hasFoldingWin(curwin, lnum, &first, &last, FALSE, NULL)) 4987 if (hasFoldingWin(curwin, lnum, &first, &last, FALSE, NULL))
4405 { 4988 {
4406 if (end) 4989 if (end)
4407 retvar->var_val.var_number = (varnumber_T)last; 4990 retvar->vval.v_number = (varnumber_T)last;
4408 else 4991 else
4409 retvar->var_val.var_number = (varnumber_T)first; 4992 retvar->vval.v_number = (varnumber_T)first;
4410 return; 4993 return;
4411 } 4994 }
4412 } 4995 }
4413 #endif 4996 #endif
4414 retvar->var_val.var_number = -1; 4997 retvar->vval.v_number = -1;
4415 } 4998 }
4416 4999
4417 /* 5000 /*
4418 * "foldlevel()" function 5001 * "foldlevel()" function
4419 */ 5002 */
4420 static void 5003 static void
4421 f_foldlevel(argvars, retvar) 5004 f_foldlevel(argvars, retvar)
4422 VAR argvars; 5005 typeval *argvars;
4423 VAR retvar; 5006 typeval *retvar;
4424 { 5007 {
4425 #ifdef FEAT_FOLDING 5008 #ifdef FEAT_FOLDING
4426 linenr_T lnum; 5009 linenr_T lnum;
4427 5010
4428 lnum = get_var_lnum(argvars); 5011 lnum = get_vartv_lnum(argvars);
4429 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 5012 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4430 retvar->var_val.var_number = foldLevel(lnum); 5013 retvar->vval.v_number = foldLevel(lnum);
4431 else 5014 else
4432 #endif 5015 #endif
4433 retvar->var_val.var_number = 0; 5016 retvar->vval.v_number = 0;
4434 } 5017 }
4435 5018
4436 /* 5019 /*
4437 * "foldtext()" function 5020 * "foldtext()" function
4438 */ 5021 */
4439 /*ARGSUSED*/ 5022 /*ARGSUSED*/
4440 static void 5023 static void
4441 f_foldtext(argvars, retvar) 5024 f_foldtext(argvars, retvar)
4442 VAR argvars; 5025 typeval *argvars;
4443 VAR retvar; 5026 typeval *retvar;
4444 { 5027 {
4445 #ifdef FEAT_FOLDING 5028 #ifdef FEAT_FOLDING
4446 linenr_T lnum; 5029 linenr_T lnum;
4447 char_u *s; 5030 char_u *s;
4448 char_u *r; 5031 char_u *r;
4449 int len; 5032 int len;
4450 char *txt; 5033 char *txt;
4451 #endif 5034 #endif
4452 5035
4453 retvar->var_type = VAR_STRING; 5036 retvar->v_type = VAR_STRING;
4454 retvar->var_val.var_string = NULL; 5037 retvar->vval.v_string = NULL;
4455 #ifdef FEAT_FOLDING 5038 #ifdef FEAT_FOLDING
4456 if ((linenr_T)vimvars[VV_FOLDSTART].val > 0 5039 if ((linenr_T)vimvars[VV_FOLDSTART].val > 0
4457 && (linenr_T)vimvars[VV_FOLDEND].val <= curbuf->b_ml.ml_line_count 5040 && (linenr_T)vimvars[VV_FOLDEND].val <= curbuf->b_ml.ml_line_count
4458 && vimvars[VV_FOLDDASHES].val != NULL) 5041 && vimvars[VV_FOLDDASHES].val != NULL)
4459 { 5042 {
4492 - (linenr_T)vimvars[VV_FOLDSTART].val + 1)); 5075 - (linenr_T)vimvars[VV_FOLDSTART].val + 1));
4493 len = (int)STRLEN(r); 5076 len = (int)STRLEN(r);
4494 STRCAT(r, s); 5077 STRCAT(r, s);
4495 /* remove 'foldmarker' and 'commentstring' */ 5078 /* remove 'foldmarker' and 'commentstring' */
4496 foldtext_cleanup(r + len); 5079 foldtext_cleanup(r + len);
4497 retvar->var_val.var_string = r; 5080 retvar->vval.v_string = r;
4498 } 5081 }
4499 } 5082 }
4500 #endif 5083 #endif
4501 } 5084 }
4502 5085
4504 * "foldtextresult(lnum)" function 5087 * "foldtextresult(lnum)" function
4505 */ 5088 */
4506 /*ARGSUSED*/ 5089 /*ARGSUSED*/
4507 static void 5090 static void
4508 f_foldtextresult(argvars, retvar) 5091 f_foldtextresult(argvars, retvar)
4509 VAR argvars; 5092 typeval *argvars;
4510 VAR retvar; 5093 typeval *retvar;
4511 { 5094 {
4512 #ifdef FEAT_FOLDING 5095 #ifdef FEAT_FOLDING
4513 linenr_T lnum; 5096 linenr_T lnum;
4514 char_u *text; 5097 char_u *text;
4515 char_u buf[51]; 5098 char_u buf[51];
4516 foldinfo_T foldinfo; 5099 foldinfo_T foldinfo;
4517 int fold_count; 5100 int fold_count;
4518 #endif 5101 #endif
4519 5102
4520 retvar->var_type = VAR_STRING; 5103 retvar->v_type = VAR_STRING;
4521 retvar->var_val.var_string = NULL; 5104 retvar->vval.v_string = NULL;
4522 #ifdef FEAT_FOLDING 5105 #ifdef FEAT_FOLDING
4523 lnum = get_var_lnum(argvars); 5106 lnum = get_vartv_lnum(argvars);
4524 fold_count = foldedCount(curwin, lnum, &foldinfo); 5107 fold_count = foldedCount(curwin, lnum, &foldinfo);
4525 if (fold_count > 0) 5108 if (fold_count > 0)
4526 { 5109 {
4527 text = get_foldtext(curwin, lnum, lnum + fold_count - 1, 5110 text = get_foldtext(curwin, lnum, lnum + fold_count - 1,
4528 &foldinfo, buf); 5111 &foldinfo, buf);
4529 if (text == buf) 5112 if (text == buf)
4530 text = vim_strsave(text); 5113 text = vim_strsave(text);
4531 retvar->var_val.var_string = text; 5114 retvar->vval.v_string = text;
4532 } 5115 }
4533 #endif 5116 #endif
4534 } 5117 }
4535 5118
4536 /* 5119 /*
4537 * "foreground()" function 5120 * "foreground()" function
4538 */ 5121 */
4539 /*ARGSUSED*/ 5122 /*ARGSUSED*/
4540 static void 5123 static void
4541 f_foreground(argvars, retvar) 5124 f_foreground(argvars, retvar)
4542 VAR argvars; 5125 typeval *argvars;
4543 VAR retvar; 5126 typeval *retvar;
4544 { 5127 {
4545 retvar->var_val.var_number = 0; 5128 retvar->vval.v_number = 0;
4546 #ifdef FEAT_GUI 5129 #ifdef FEAT_GUI
4547 if (gui.in_use) 5130 if (gui.in_use)
4548 gui_mch_set_foreground(); 5131 gui_mch_set_foreground();
4549 #else 5132 #else
4550 # ifdef WIN32 5133 # ifdef WIN32
4552 # endif 5135 # endif
4553 #endif 5136 #endif
4554 } 5137 }
4555 5138
4556 /* 5139 /*
5140 * "function()" function
5141 */
5142 /*ARGSUSED*/
5143 static void
5144 f_function(argvars, retvar)
5145 typeval *argvars;
5146 typeval *retvar;
5147 {
5148 char_u *s;
5149
5150 s = get_vartv_string(&argvars[0]);
5151 if (s == NULL || *s == NUL || isdigit(*s))
5152 EMSG2(_(e_invarg2), s);
5153 else if (!function_exists(s))
5154 EMSG2(_("E999: Unknown function: %s"), s);
5155 else
5156 {
5157 retvar->vval.v_string = vim_strsave(s);
5158 retvar->v_type = VAR_FUNC;
5159 }
5160 }
5161
5162 /*
4557 * "getchar()" function 5163 * "getchar()" function
4558 */ 5164 */
4559 static void 5165 static void
4560 f_getchar(argvars, retvar) 5166 f_getchar(argvars, retvar)
4561 VAR argvars; 5167 typeval *argvars;
4562 VAR retvar; 5168 typeval *retvar;
4563 { 5169 {
4564 varnumber_T n; 5170 varnumber_T n;
4565 5171
4566 ++no_mapping; 5172 ++no_mapping;
4567 ++allow_keys; 5173 ++allow_keys;
4568 if (argvars[0].var_type == VAR_UNKNOWN) 5174 if (argvars[0].v_type == VAR_UNKNOWN)
4569 /* getchar(): blocking wait. */ 5175 /* getchar(): blocking wait. */
4570 n = safe_vgetc(); 5176 n = safe_vgetc();
4571 else if (get_var_number(&argvars[0]) == 1) 5177 else if (get_vartv_number(&argvars[0]) == 1)
4572 /* getchar(1): only check if char avail */ 5178 /* getchar(1): only check if char avail */
4573 n = vpeekc(); 5179 n = vpeekc();
4574 else if (vpeekc() == NUL) 5180 else if (vpeekc() == NUL)
4575 /* getchar(0) and no char avail: return zero */ 5181 /* getchar(0) and no char avail: return zero */
4576 n = 0; 5182 n = 0;
4578 /* getchar(0) and char avail: return char */ 5184 /* getchar(0) and char avail: return char */
4579 n = safe_vgetc(); 5185 n = safe_vgetc();
4580 --no_mapping; 5186 --no_mapping;
4581 --allow_keys; 5187 --allow_keys;
4582 5188
4583 retvar->var_val.var_number = n; 5189 retvar->vval.v_number = n;
4584 if (IS_SPECIAL(n) || mod_mask != 0) 5190 if (IS_SPECIAL(n) || mod_mask != 0)
4585 { 5191 {
4586 char_u temp[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */ 5192 char_u temp[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */
4587 int i = 0; 5193 int i = 0;
4588 5194
4604 i += (*mb_char2bytes)(n, temp + i); 5210 i += (*mb_char2bytes)(n, temp + i);
4605 #endif 5211 #endif
4606 else 5212 else
4607 temp[i++] = n; 5213 temp[i++] = n;
4608 temp[i++] = NUL; 5214 temp[i++] = NUL;
4609 retvar->var_type = VAR_STRING; 5215 retvar->v_type = VAR_STRING;
4610 retvar->var_val.var_string = vim_strsave(temp); 5216 retvar->vval.v_string = vim_strsave(temp);
4611 } 5217 }
4612 } 5218 }
4613 5219
4614 /* 5220 /*
4615 * "getcharmod()" function 5221 * "getcharmod()" function
4616 */ 5222 */
4617 /*ARGSUSED*/ 5223 /*ARGSUSED*/
4618 static void 5224 static void
4619 f_getcharmod(argvars, retvar) 5225 f_getcharmod(argvars, retvar)
4620 VAR argvars; 5226 typeval *argvars;
4621 VAR retvar; 5227 typeval *retvar;
4622 { 5228 {
4623 retvar->var_val.var_number = mod_mask; 5229 retvar->vval.v_number = mod_mask;
4624 } 5230 }
4625 5231
4626 /* 5232 /*
4627 * "getcmdline()" function 5233 * "getcmdline()" function
4628 */ 5234 */
4629 /*ARGSUSED*/ 5235 /*ARGSUSED*/
4630 static void 5236 static void
4631 f_getcmdline(argvars, retvar) 5237 f_getcmdline(argvars, retvar)
4632 VAR argvars; 5238 typeval *argvars;
4633 VAR retvar; 5239 typeval *retvar;
4634 { 5240 {
4635 retvar->var_type = VAR_STRING; 5241 retvar->v_type = VAR_STRING;
4636 retvar->var_val.var_string = get_cmdline_str(); 5242 retvar->vval.v_string = get_cmdline_str();
4637 } 5243 }
4638 5244
4639 /* 5245 /*
4640 * "getcmdpos()" function 5246 * "getcmdpos()" function
4641 */ 5247 */
4642 /*ARGSUSED*/ 5248 /*ARGSUSED*/
4643 static void 5249 static void
4644 f_getcmdpos(argvars, retvar) 5250 f_getcmdpos(argvars, retvar)
4645 VAR argvars; 5251 typeval *argvars;
4646 VAR retvar; 5252 typeval *retvar;
4647 { 5253 {
4648 retvar->var_val.var_number = get_cmdline_pos() + 1; 5254 retvar->vval.v_number = get_cmdline_pos() + 1;
4649 } 5255 }
4650 5256
4651 /* 5257 /*
4652 * "getbufvar()" function 5258 * "getbufvar()" function
4653 */ 5259 */
4654 static void 5260 static void
4655 f_getbufvar(argvars, retvar) 5261 f_getbufvar(argvars, retvar)
4656 VAR argvars; 5262 typeval *argvars;
4657 VAR retvar; 5263 typeval *retvar;
4658 { 5264 {
4659 buf_T *buf; 5265 buf_T *buf;
4660 buf_T *save_curbuf; 5266 buf_T *save_curbuf;
4661 char_u *varname; 5267 char_u *varname;
4662 VAR v; 5268 VAR v;
4663 5269
4664 ++emsg_off; 5270 ++emsg_off;
4665 buf = get_buf_var(&argvars[0]); 5271 buf = get_buf_vartv(&argvars[0]);
4666 varname = get_var_string(&argvars[1]); 5272 varname = get_vartv_string(&argvars[1]);
4667 5273
4668 retvar->var_type = VAR_STRING; 5274 retvar->v_type = VAR_STRING;
4669 retvar->var_val.var_string = NULL; 5275 retvar->vval.v_string = NULL;
4670 5276
4671 if (buf != NULL && varname != NULL) 5277 if (buf != NULL && varname != NULL)
4672 { 5278 {
4673 if (*varname == '&') /* buffer-local-option */ 5279 if (*varname == '&') /* buffer-local-option */
4674 { 5280 {
4675 /* set curbuf to be our buf, temporarily */ 5281 /* set curbuf to be our buf, temporarily */
4676 save_curbuf = curbuf; 5282 save_curbuf = curbuf;
4677 curbuf = buf; 5283 curbuf = buf;
4678 5284
4679 get_option_var(&varname, retvar, TRUE); 5285 get_option_vartv(&varname, retvar, TRUE);
4680 5286
4681 /* restore previous notion of curbuf */ 5287 /* restore previous notion of curbuf */
4682 curbuf = save_curbuf; 5288 curbuf = save_curbuf;
4683 } 5289 }
4684 else 5290 else
4685 { 5291 {
4686 /* look up the variable */ 5292 /* look up the variable */
4687 v = find_var_in_ga(&buf->b_vars, varname); 5293 v = find_var_in_ga(&buf->b_vars, varname);
4688 if (v != NULL) 5294 if (v != NULL)
4689 copy_var(v, retvar); 5295 copy_vartv(&v->tv, retvar);
4690 } 5296 }
4691 } 5297 }
4692 5298
4693 --emsg_off; 5299 --emsg_off;
4694 } 5300 }
4697 * "getcwd()" function 5303 * "getcwd()" function
4698 */ 5304 */
4699 /*ARGSUSED*/ 5305 /*ARGSUSED*/
4700 static void 5306 static void
4701 f_getcwd(argvars, retvar) 5307 f_getcwd(argvars, retvar)
4702 VAR argvars; 5308 typeval *argvars;
4703 VAR retvar; 5309 typeval *retvar;
4704 { 5310 {
4705 char_u cwd[MAXPATHL]; 5311 char_u cwd[MAXPATHL];
4706 5312
4707 retvar->var_type = VAR_STRING; 5313 retvar->v_type = VAR_STRING;
4708 if (mch_dirname(cwd, MAXPATHL) == FAIL) 5314 if (mch_dirname(cwd, MAXPATHL) == FAIL)
4709 retvar->var_val.var_string = NULL; 5315 retvar->vval.v_string = NULL;
4710 else 5316 else
4711 { 5317 {
4712 retvar->var_val.var_string = vim_strsave(cwd); 5318 retvar->vval.v_string = vim_strsave(cwd);
4713 #ifdef BACKSLASH_IN_FILENAME 5319 #ifdef BACKSLASH_IN_FILENAME
4714 slash_adjust(retvar->var_val.var_string); 5320 slash_adjust(retvar->vval.v_string);
4715 #endif 5321 #endif
4716 } 5322 }
4717 } 5323 }
4718 5324
4719 /* 5325 /*
4720 * "getfontname()" function 5326 * "getfontname()" function
4721 */ 5327 */
4722 /*ARGSUSED*/ 5328 /*ARGSUSED*/
4723 static void 5329 static void
4724 f_getfontname(argvars, retvar) 5330 f_getfontname(argvars, retvar)
4725 VAR argvars; 5331 typeval *argvars;
4726 VAR retvar; 5332 typeval *retvar;
4727 { 5333 {
4728 retvar->var_type = VAR_STRING; 5334 retvar->v_type = VAR_STRING;
4729 retvar->var_val.var_string = NULL; 5335 retvar->vval.v_string = NULL;
4730 #ifdef FEAT_GUI 5336 #ifdef FEAT_GUI
4731 if (gui.in_use) 5337 if (gui.in_use)
4732 { 5338 {
4733 GuiFont font; 5339 GuiFont font;
4734 char_u *name = NULL; 5340 char_u *name = NULL;
4735 5341
4736 if (argvars[0].var_type == VAR_UNKNOWN) 5342 if (argvars[0].v_type == VAR_UNKNOWN)
4737 { 5343 {
4738 /* Get the "Normal" font. Either the name saved by 5344 /* Get the "Normal" font. Either the name saved by
4739 * hl_set_font_name() or from the font ID. */ 5345 * hl_set_font_name() or from the font ID. */
4740 font = gui.norm_font; 5346 font = gui.norm_font;
4741 name = hl_get_font_name(); 5347 name = hl_get_font_name();
4742 } 5348 }
4743 else 5349 else
4744 { 5350 {
4745 name = get_var_string(&argvars[0]); 5351 name = get_vartv_string(&argvars[0]);
4746 if (STRCMP(name, "*") == 0) /* don't use font dialog */ 5352 if (STRCMP(name, "*") == 0) /* don't use font dialog */
4747 return; 5353 return;
4748 font = gui_mch_get_font(name, FALSE); 5354 font = gui_mch_get_font(name, FALSE);
4749 if (font == NOFONT) 5355 if (font == NOFONT)
4750 return; /* Invalid font name, return empty string. */ 5356 return; /* Invalid font name, return empty string. */
4751 } 5357 }
4752 retvar->var_val.var_string = gui_mch_get_fontname(font, name); 5358 retvar->vval.v_string = gui_mch_get_fontname(font, name);
4753 if (argvars[0].var_type != VAR_UNKNOWN) 5359 if (argvars[0].v_type != VAR_UNKNOWN)
4754 gui_mch_free_font(font); 5360 gui_mch_free_font(font);
4755 } 5361 }
4756 #endif 5362 #endif
4757 } 5363 }
4758 5364
4759 /* 5365 /*
4760 * "getfperm({fname})" function 5366 * "getfperm({fname})" function
4761 */ 5367 */
4762 static void 5368 static void
4763 f_getfperm(argvars, retvar) 5369 f_getfperm(argvars, retvar)
4764 VAR argvars; 5370 typeval *argvars;
4765 VAR retvar; 5371 typeval *retvar;
4766 { 5372 {
4767 char_u *fname; 5373 char_u *fname;
4768 struct stat st; 5374 struct stat st;
4769 char_u *perm = NULL; 5375 char_u *perm = NULL;
4770 char_u flags[] = "rwx"; 5376 char_u flags[] = "rwx";
4771 int i; 5377 int i;
4772 5378
4773 fname = get_var_string(&argvars[0]); 5379 fname = get_vartv_string(&argvars[0]);
4774 5380
4775 retvar->var_type = VAR_STRING; 5381 retvar->v_type = VAR_STRING;
4776 if (mch_stat((char *)fname, &st) >= 0) 5382 if (mch_stat((char *)fname, &st) >= 0)
4777 { 5383 {
4778 perm = vim_strsave((char_u *)"---------"); 5384 perm = vim_strsave((char_u *)"---------");
4779 if (perm != NULL) 5385 if (perm != NULL)
4780 { 5386 {
4783 if (st.st_mode & (1 << (8 - i))) 5389 if (st.st_mode & (1 << (8 - i)))
4784 perm[i] = flags[i % 3]; 5390 perm[i] = flags[i % 3];
4785 } 5391 }
4786 } 5392 }
4787 } 5393 }
4788 retvar->var_val.var_string = perm; 5394 retvar->vval.v_string = perm;
4789 } 5395 }
4790 5396
4791 /* 5397 /*
4792 * "getfsize({fname})" function 5398 * "getfsize({fname})" function
4793 */ 5399 */
4794 static void 5400 static void
4795 f_getfsize(argvars, retvar) 5401 f_getfsize(argvars, retvar)
4796 VAR argvars; 5402 typeval *argvars;
4797 VAR retvar; 5403 typeval *retvar;
4798 { 5404 {
4799 char_u *fname; 5405 char_u *fname;
4800 struct stat st; 5406 struct stat st;
4801 5407
4802 fname = get_var_string(&argvars[0]); 5408 fname = get_vartv_string(&argvars[0]);
4803 5409
4804 retvar->var_type = VAR_NUMBER; 5410 retvar->v_type = VAR_NUMBER;
4805 5411
4806 if (mch_stat((char *)fname, &st) >= 0) 5412 if (mch_stat((char *)fname, &st) >= 0)
4807 { 5413 {
4808 if (mch_isdir(fname)) 5414 if (mch_isdir(fname))
4809 retvar->var_val.var_number = 0; 5415 retvar->vval.v_number = 0;
4810 else 5416 else
4811 retvar->var_val.var_number = (varnumber_T)st.st_size; 5417 retvar->vval.v_number = (varnumber_T)st.st_size;
4812 } 5418 }
4813 else 5419 else
4814 retvar->var_val.var_number = -1; 5420 retvar->vval.v_number = -1;
4815 } 5421 }
4816 5422
4817 /* 5423 /*
4818 * "getftime({fname})" function 5424 * "getftime({fname})" function
4819 */ 5425 */
4820 static void 5426 static void
4821 f_getftime(argvars, retvar) 5427 f_getftime(argvars, retvar)
4822 VAR argvars; 5428 typeval *argvars;
4823 VAR retvar; 5429 typeval *retvar;
4824 { 5430 {
4825 char_u *fname; 5431 char_u *fname;
4826 struct stat st; 5432 struct stat st;
4827 5433
4828 fname = get_var_string(&argvars[0]); 5434 fname = get_vartv_string(&argvars[0]);
4829 5435
4830 if (mch_stat((char *)fname, &st) >= 0) 5436 if (mch_stat((char *)fname, &st) >= 0)
4831 retvar->var_val.var_number = (varnumber_T)st.st_mtime; 5437 retvar->vval.v_number = (varnumber_T)st.st_mtime;
4832 else 5438 else
4833 retvar->var_val.var_number = -1; 5439 retvar->vval.v_number = -1;
4834 } 5440 }
4835 5441
4836 /* 5442 /*
4837 * "getftype({fname})" function 5443 * "getftype({fname})" function
4838 */ 5444 */
4839 static void 5445 static void
4840 f_getftype(argvars, retvar) 5446 f_getftype(argvars, retvar)
4841 VAR argvars; 5447 typeval *argvars;
4842 VAR retvar; 5448 typeval *retvar;
4843 { 5449 {
4844 char_u *fname; 5450 char_u *fname;
4845 struct stat st; 5451 struct stat st;
4846 char_u *type = NULL; 5452 char_u *type = NULL;
4847 char *t; 5453 char *t;
4848 5454
4849 fname = get_var_string(&argvars[0]); 5455 fname = get_vartv_string(&argvars[0]);
4850 5456
4851 retvar->var_type = VAR_STRING; 5457 retvar->v_type = VAR_STRING;
4852 if (mch_lstat((char *)fname, &st) >= 0) 5458 if (mch_lstat((char *)fname, &st) >= 0)
4853 { 5459 {
4854 #ifdef S_ISREG 5460 #ifdef S_ISREG
4855 if (S_ISREG(st.st_mode)) 5461 if (S_ISREG(st.st_mode))
4856 t = "file"; 5462 t = "file";
4908 t = "file"; 5514 t = "file";
4909 # endif 5515 # endif
4910 #endif 5516 #endif
4911 type = vim_strsave((char_u *)t); 5517 type = vim_strsave((char_u *)t);
4912 } 5518 }
4913 retvar->var_val.var_string = type; 5519 retvar->vval.v_string = type;
4914 } 5520 }
4915 5521
4916 /* 5522 /*
4917 * "getreg()" function 5523 * "getreg()" function
4918 */ 5524 */
4919 static void 5525 static void
4920 f_getreg(argvars, retvar) 5526 f_getreg(argvars, retvar)
4921 VAR argvars; 5527 typeval *argvars;
4922 VAR retvar; 5528 typeval *retvar;
4923 { 5529 {
4924 char_u *strregname; 5530 char_u *strregname;
4925 int regname; 5531 int regname;
4926 5532
4927 if (argvars[0].var_type != VAR_UNKNOWN) 5533 if (argvars[0].v_type != VAR_UNKNOWN)
4928 strregname = get_var_string(&argvars[0]); 5534 strregname = get_vartv_string(&argvars[0]);
4929 else 5535 else
4930 strregname = vimvars[VV_REG].val; 5536 strregname = vimvars[VV_REG].val;
4931 regname = (strregname == NULL ? '"' : *strregname); 5537 regname = (strregname == NULL ? '"' : *strregname);
4932 if (regname == 0) 5538 if (regname == 0)
4933 regname = '"'; 5539 regname = '"';
4934 5540
4935 retvar->var_type = VAR_STRING; 5541 retvar->v_type = VAR_STRING;
4936 retvar->var_val.var_string = get_reg_contents(regname, TRUE); 5542 retvar->vval.v_string = get_reg_contents(regname, TRUE);
4937 } 5543 }
4938 5544
4939 /* 5545 /*
4940 * "getregtype()" function 5546 * "getregtype()" function
4941 */ 5547 */
4942 static void 5548 static void
4943 f_getregtype(argvars, retvar) 5549 f_getregtype(argvars, retvar)
4944 VAR argvars; 5550 typeval *argvars;
4945 VAR retvar; 5551 typeval *retvar;
4946 { 5552 {
4947 char_u *strregname; 5553 char_u *strregname;
4948 int regname; 5554 int regname;
4949 char_u buf[NUMBUFLEN + 2]; 5555 char_u buf[NUMBUFLEN + 2];
4950 long reglen = 0; 5556 long reglen = 0;
4951 5557
4952 if (argvars[0].var_type != VAR_UNKNOWN) 5558 if (argvars[0].v_type != VAR_UNKNOWN)
4953 strregname = get_var_string(&argvars[0]); 5559 strregname = get_vartv_string(&argvars[0]);
4954 else 5560 else
4955 /* Default to v:register */ 5561 /* Default to v:register */
4956 strregname = vimvars[VV_REG].val; 5562 strregname = vimvars[VV_REG].val;
4957 5563
4958 regname = (strregname == NULL ? '"' : *strregname); 5564 regname = (strregname == NULL ? '"' : *strregname);
4970 buf[0] = Ctrl_V; 5576 buf[0] = Ctrl_V;
4971 sprintf((char *)buf + 1, "%ld", reglen + 1); 5577 sprintf((char *)buf + 1, "%ld", reglen + 1);
4972 break; 5578 break;
4973 #endif 5579 #endif
4974 } 5580 }
4975 retvar->var_type = VAR_STRING; 5581 retvar->v_type = VAR_STRING;
4976 retvar->var_val.var_string = vim_strsave(buf); 5582 retvar->vval.v_string = vim_strsave(buf);
4977 } 5583 }
4978 5584
4979 /* 5585 /*
4980 * "getline(lnum)" function 5586 * "getline(lnum)" function
4981 */ 5587 */
4982 static void 5588 static void
4983 f_getline(argvars, retvar) 5589 f_getline(argvars, retvar)
4984 VAR argvars; 5590 typeval *argvars;
4985 VAR retvar; 5591 typeval *retvar;
4986 { 5592 {
4987 linenr_T lnum; 5593 linenr_T lnum;
4988 char_u *p; 5594 char_u *p;
4989 5595
4990 lnum = get_var_lnum(argvars); 5596 lnum = get_vartv_lnum(argvars);
4991 5597
4992 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 5598 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4993 p = ml_get(lnum); 5599 p = ml_get(lnum);
4994 else 5600 else
4995 p = (char_u *)""; 5601 p = (char_u *)"";
4996 5602
4997 retvar->var_type = VAR_STRING; 5603 retvar->v_type = VAR_STRING;
4998 retvar->var_val.var_string = vim_strsave(p); 5604 retvar->vval.v_string = vim_strsave(p);
4999 } 5605 }
5000 5606
5001 /* 5607 /*
5002 * "getwinposx()" function 5608 * "getwinposx()" function
5003 */ 5609 */
5004 /*ARGSUSED*/ 5610 /*ARGSUSED*/
5005 static void 5611 static void
5006 f_getwinposx(argvars, retvar) 5612 f_getwinposx(argvars, retvar)
5007 VAR argvars; 5613 typeval *argvars;
5008 VAR retvar; 5614 typeval *retvar;
5009 { 5615 {
5010 retvar->var_val.var_number = -1; 5616 retvar->vval.v_number = -1;
5011 #ifdef FEAT_GUI 5617 #ifdef FEAT_GUI
5012 if (gui.in_use) 5618 if (gui.in_use)
5013 { 5619 {
5014 int x, y; 5620 int x, y;
5015 5621
5016 if (gui_mch_get_winpos(&x, &y) == OK) 5622 if (gui_mch_get_winpos(&x, &y) == OK)
5017 retvar->var_val.var_number = x; 5623 retvar->vval.v_number = x;
5018 } 5624 }
5019 #endif 5625 #endif
5020 } 5626 }
5021 5627
5022 /* 5628 /*
5023 * "getwinposy()" function 5629 * "getwinposy()" function
5024 */ 5630 */
5025 /*ARGSUSED*/ 5631 /*ARGSUSED*/
5026 static void 5632 static void
5027 f_getwinposy(argvars, retvar) 5633 f_getwinposy(argvars, retvar)
5028 VAR argvars; 5634 typeval *argvars;
5029 VAR retvar; 5635 typeval *retvar;
5030 { 5636 {
5031 retvar->var_val.var_number = -1; 5637 retvar->vval.v_number = -1;
5032 #ifdef FEAT_GUI 5638 #ifdef FEAT_GUI
5033 if (gui.in_use) 5639 if (gui.in_use)
5034 { 5640 {
5035 int x, y; 5641 int x, y;
5036 5642
5037 if (gui_mch_get_winpos(&x, &y) == OK) 5643 if (gui_mch_get_winpos(&x, &y) == OK)
5038 retvar->var_val.var_number = y; 5644 retvar->vval.v_number = y;
5039 } 5645 }
5040 #endif 5646 #endif
5041 } 5647 }
5042 5648
5043 /* 5649 /*
5044 * "getwinvar()" function 5650 * "getwinvar()" function
5045 */ 5651 */
5046 static void 5652 static void
5047 f_getwinvar(argvars, retvar) 5653 f_getwinvar(argvars, retvar)
5048 VAR argvars; 5654 typeval *argvars;
5049 VAR retvar; 5655 typeval *retvar;
5050 { 5656 {
5051 win_T *win, *oldcurwin; 5657 win_T *win, *oldcurwin;
5052 char_u *varname; 5658 char_u *varname;
5053 VAR v; 5659 VAR v;
5054 5660
5055 ++emsg_off; 5661 ++emsg_off;
5056 win = find_win_by_nr(&argvars[0]); 5662 win = find_win_by_nr(&argvars[0]);
5057 varname = get_var_string(&argvars[1]); 5663 varname = get_vartv_string(&argvars[1]);
5058 5664
5059 retvar->var_type = VAR_STRING; 5665 retvar->v_type = VAR_STRING;
5060 retvar->var_val.var_string = NULL; 5666 retvar->vval.v_string = NULL;
5061 5667
5062 if (win != NULL && varname != NULL) 5668 if (win != NULL && varname != NULL)
5063 { 5669 {
5064 if (*varname == '&') /* window-local-option */ 5670 if (*varname == '&') /* window-local-option */
5065 { 5671 {
5066 /* set curwin to be our win, temporarily */ 5672 /* set curwin to be our win, temporarily */
5067 oldcurwin = curwin; 5673 oldcurwin = curwin;
5068 curwin = win; 5674 curwin = win;
5069 5675
5070 get_option_var(&varname, retvar , 1); 5676 get_option_vartv(&varname, retvar, 1);
5071 5677
5072 /* restore previous notion of curwin */ 5678 /* restore previous notion of curwin */
5073 curwin = oldcurwin; 5679 curwin = oldcurwin;
5074 } 5680 }
5075 else 5681 else
5076 { 5682 {
5077 /* look up the variable */ 5683 /* look up the variable */
5078 v = find_var_in_ga(&win->w_vars, varname); 5684 v = find_var_in_ga(&win->w_vars, varname);
5079 if (v != NULL) 5685 if (v != NULL)
5080 copy_var(v, retvar); 5686 copy_vartv(&v->tv, retvar);
5081 } 5687 }
5082 } 5688 }
5083 5689
5084 --emsg_off; 5690 --emsg_off;
5085 } 5691 }
5087 /* 5693 /*
5088 * "glob()" function 5694 * "glob()" function
5089 */ 5695 */
5090 static void 5696 static void
5091 f_glob(argvars, retvar) 5697 f_glob(argvars, retvar)
5092 VAR argvars; 5698 typeval *argvars;
5093 VAR retvar; 5699 typeval *retvar;
5094 { 5700 {
5095 expand_T xpc; 5701 expand_T xpc;
5096 5702
5097 ExpandInit(&xpc); 5703 ExpandInit(&xpc);
5098 xpc.xp_context = EXPAND_FILES; 5704 xpc.xp_context = EXPAND_FILES;
5099 retvar->var_type = VAR_STRING; 5705 retvar->v_type = VAR_STRING;
5100 retvar->var_val.var_string = ExpandOne(&xpc, get_var_string(&argvars[0]), 5706 retvar->vval.v_string = ExpandOne(&xpc, get_vartv_string(&argvars[0]),
5101 NULL, WILD_USE_NL|WILD_SILENT, WILD_ALL); 5707 NULL, WILD_USE_NL|WILD_SILENT, WILD_ALL);
5102 ExpandCleanup(&xpc); 5708 ExpandCleanup(&xpc);
5103 } 5709 }
5104 5710
5105 /* 5711 /*
5106 * "globpath()" function 5712 * "globpath()" function
5107 */ 5713 */
5108 static void 5714 static void
5109 f_globpath(argvars, retvar) 5715 f_globpath(argvars, retvar)
5110 VAR argvars; 5716 typeval *argvars;
5111 VAR retvar; 5717 typeval *retvar;
5112 { 5718 {
5113 char_u buf1[NUMBUFLEN]; 5719 char_u buf1[NUMBUFLEN];
5114 5720
5115 retvar->var_type = VAR_STRING; 5721 retvar->v_type = VAR_STRING;
5116 retvar->var_val.var_string = globpath(get_var_string(&argvars[0]), 5722 retvar->vval.v_string = globpath(get_vartv_string(&argvars[0]),
5117 get_var_string_buf(&argvars[1], buf1)); 5723 get_vartv_string_buf(&argvars[1], buf1));
5118 } 5724 }
5119 5725
5120 /* 5726 /*
5121 * "has()" function 5727 * "has()" function
5122 */ 5728 */
5123 static void 5729 static void
5124 f_has(argvars, retvar) 5730 f_has(argvars, retvar)
5125 VAR argvars; 5731 typeval *argvars;
5126 VAR retvar; 5732 typeval *retvar;
5127 { 5733 {
5128 int i; 5734 int i;
5129 char_u *name; 5735 char_u *name;
5130 int n = FALSE; 5736 int n = FALSE;
5131 static char *(has_list[]) = 5737 static char *(has_list[]) =
5549 "X11", 6155 "X11",
5550 #endif 6156 #endif
5551 NULL 6157 NULL
5552 }; 6158 };
5553 6159
5554 name = get_var_string(&argvars[0]); 6160 name = get_vartv_string(&argvars[0]);
5555 for (i = 0; has_list[i] != NULL; ++i) 6161 for (i = 0; has_list[i] != NULL; ++i)
5556 if (STRICMP(name, has_list[i]) == 0) 6162 if (STRICMP(name, has_list[i]) == 0)
5557 { 6163 {
5558 n = TRUE; 6164 n = TRUE;
5559 break; 6165 break;
5609 else if (STRICMP(name, "netbeans_enabled") == 0) 6215 else if (STRICMP(name, "netbeans_enabled") == 0)
5610 n = usingNetbeans; 6216 n = usingNetbeans;
5611 #endif 6217 #endif
5612 } 6218 }
5613 6219
5614 retvar->var_val.var_number = n; 6220 retvar->vval.v_number = n;
5615 } 6221 }
5616 6222
5617 /* 6223 /*
5618 * "hasmapto()" function 6224 * "hasmapto()" function
5619 */ 6225 */
5620 static void 6226 static void
5621 f_hasmapto(argvars, retvar) 6227 f_hasmapto(argvars, retvar)
5622 VAR argvars; 6228 typeval *argvars;
5623 VAR retvar; 6229 typeval *retvar;
5624 { 6230 {
5625 char_u *name; 6231 char_u *name;
5626 char_u *mode; 6232 char_u *mode;
5627 char_u buf[NUMBUFLEN]; 6233 char_u buf[NUMBUFLEN];
5628 6234
5629 name = get_var_string(&argvars[0]); 6235 name = get_vartv_string(&argvars[0]);
5630 if (argvars[1].var_type == VAR_UNKNOWN) 6236 if (argvars[1].v_type == VAR_UNKNOWN)
5631 mode = (char_u *)"nvo"; 6237 mode = (char_u *)"nvo";
5632 else 6238 else
5633 mode = get_var_string_buf(&argvars[1], buf); 6239 mode = get_vartv_string_buf(&argvars[1], buf);
5634 6240
5635 if (map_to_exists(name, mode)) 6241 if (map_to_exists(name, mode))
5636 retvar->var_val.var_number = TRUE; 6242 retvar->vval.v_number = TRUE;
5637 else 6243 else
5638 retvar->var_val.var_number = FALSE; 6244 retvar->vval.v_number = FALSE;
5639 } 6245 }
5640 6246
5641 /* 6247 /*
5642 * "histadd()" function 6248 * "histadd()" function
5643 */ 6249 */
5644 /*ARGSUSED*/ 6250 /*ARGSUSED*/
5645 static void 6251 static void
5646 f_histadd(argvars, retvar) 6252 f_histadd(argvars, retvar)
5647 VAR argvars; 6253 typeval *argvars;
5648 VAR retvar; 6254 typeval *retvar;
5649 { 6255 {
5650 #ifdef FEAT_CMDHIST 6256 #ifdef FEAT_CMDHIST
5651 int histype; 6257 int histype;
5652 char_u *str; 6258 char_u *str;
5653 char_u buf[NUMBUFLEN]; 6259 char_u buf[NUMBUFLEN];
5654 #endif 6260 #endif
5655 6261
5656 retvar->var_val.var_number = FALSE; 6262 retvar->vval.v_number = FALSE;
5657 if (check_restricted() || check_secure()) 6263 if (check_restricted() || check_secure())
5658 return; 6264 return;
5659 #ifdef FEAT_CMDHIST 6265 #ifdef FEAT_CMDHIST
5660 histype = get_histtype(get_var_string(&argvars[0])); 6266 histype = get_histtype(get_vartv_string(&argvars[0]));
5661 if (histype >= 0) 6267 if (histype >= 0)
5662 { 6268 {
5663 str = get_var_string_buf(&argvars[1], buf); 6269 str = get_vartv_string_buf(&argvars[1], buf);
5664 if (*str != NUL) 6270 if (*str != NUL)
5665 { 6271 {
5666 add_to_history(histype, str, FALSE, NUL); 6272 add_to_history(histype, str, FALSE, NUL);
5667 retvar->var_val.var_number = TRUE; 6273 retvar->vval.v_number = TRUE;
5668 return; 6274 return;
5669 } 6275 }
5670 } 6276 }
5671 #endif 6277 #endif
5672 } 6278 }
5675 * "histdel()" function 6281 * "histdel()" function
5676 */ 6282 */
5677 /*ARGSUSED*/ 6283 /*ARGSUSED*/
5678 static void 6284 static void
5679 f_histdel(argvars, retvar) 6285 f_histdel(argvars, retvar)
5680 VAR argvars; 6286 typeval *argvars;
5681 VAR retvar; 6287 typeval *retvar;
5682 { 6288 {
5683 #ifdef FEAT_CMDHIST 6289 #ifdef FEAT_CMDHIST
5684 int n; 6290 int n;
5685 char_u buf[NUMBUFLEN]; 6291 char_u buf[NUMBUFLEN];
5686 6292
5687 if (argvars[1].var_type == VAR_UNKNOWN) 6293 if (argvars[1].v_type == VAR_UNKNOWN)
5688 /* only one argument: clear entire history */ 6294 /* only one argument: clear entire history */
5689 n = clr_history(get_histtype(get_var_string(&argvars[0]))); 6295 n = clr_history(get_histtype(get_vartv_string(&argvars[0])));
5690 else if (argvars[1].var_type == VAR_NUMBER) 6296 else if (argvars[1].v_type == VAR_NUMBER)
5691 /* index given: remove that entry */ 6297 /* index given: remove that entry */
5692 n = del_history_idx(get_histtype(get_var_string(&argvars[0])), 6298 n = del_history_idx(get_histtype(get_vartv_string(&argvars[0])),
5693 (int)get_var_number(&argvars[1])); 6299 (int)get_vartv_number(&argvars[1]));
5694 else 6300 else
5695 /* string given: remove all matching entries */ 6301 /* string given: remove all matching entries */
5696 n = del_history_entry(get_histtype(get_var_string(&argvars[0])), 6302 n = del_history_entry(get_histtype(get_vartv_string(&argvars[0])),
5697 get_var_string_buf(&argvars[1], buf)); 6303 get_vartv_string_buf(&argvars[1], buf));
5698 retvar->var_val.var_number = n; 6304 retvar->vval.v_number = n;
5699 #else 6305 #else
5700 retvar->var_val.var_number = 0; 6306 retvar->vval.v_number = 0;
5701 #endif 6307 #endif
5702 } 6308 }
5703 6309
5704 /* 6310 /*
5705 * "histget()" function 6311 * "histget()" function
5706 */ 6312 */
5707 /*ARGSUSED*/ 6313 /*ARGSUSED*/
5708 static void 6314 static void
5709 f_histget(argvars, retvar) 6315 f_histget(argvars, retvar)
5710 VAR argvars; 6316 typeval *argvars;
5711 VAR retvar; 6317 typeval *retvar;
5712 { 6318 {
5713 #ifdef FEAT_CMDHIST 6319 #ifdef FEAT_CMDHIST
5714 int type; 6320 int type;
5715 int idx; 6321 int idx;
5716 6322
5717 type = get_histtype(get_var_string(&argvars[0])); 6323 type = get_histtype(get_vartv_string(&argvars[0]));
5718 if (argvars[1].var_type == VAR_UNKNOWN) 6324 if (argvars[1].v_type == VAR_UNKNOWN)
5719 idx = get_history_idx(type); 6325 idx = get_history_idx(type);
5720 else 6326 else
5721 idx = (int)get_var_number(&argvars[1]); 6327 idx = (int)get_vartv_number(&argvars[1]);
5722 retvar->var_val.var_string = vim_strsave(get_history_entry(type, idx)); 6328 retvar->vval.v_string = vim_strsave(get_history_entry(type, idx));
5723 #else 6329 #else
5724 retvar->var_val.var_string = NULL; 6330 retvar->vval.v_string = NULL;
5725 #endif 6331 #endif
5726 retvar->var_type = VAR_STRING; 6332 retvar->v_type = VAR_STRING;
5727 } 6333 }
5728 6334
5729 /* 6335 /*
5730 * "histnr()" function 6336 * "histnr()" function
5731 */ 6337 */
5732 /*ARGSUSED*/ 6338 /*ARGSUSED*/
5733 static void 6339 static void
5734 f_histnr(argvars, retvar) 6340 f_histnr(argvars, retvar)
5735 VAR argvars; 6341 typeval *argvars;
5736 VAR retvar; 6342 typeval *retvar;
5737 { 6343 {
5738 int i; 6344 int i;
5739 6345
5740 #ifdef FEAT_CMDHIST 6346 #ifdef FEAT_CMDHIST
5741 i = get_histtype(get_var_string(&argvars[0])); 6347 i = get_histtype(get_vartv_string(&argvars[0]));
5742 if (i >= HIST_CMD && i < HIST_COUNT) 6348 if (i >= HIST_CMD && i < HIST_COUNT)
5743 i = get_history_idx(i); 6349 i = get_history_idx(i);
5744 else 6350 else
5745 #endif 6351 #endif
5746 i = -1; 6352 i = -1;
5747 retvar->var_val.var_number = i; 6353 retvar->vval.v_number = i;
5748 } 6354 }
5749 6355
5750 /* 6356 /*
5751 * "highlight_exists()" function 6357 * "highlight_exists()" function
5752 */ 6358 */
5753 static void 6359 static void
5754 f_hlexists(argvars, retvar) 6360 f_hlexists(argvars, retvar)
5755 VAR argvars; 6361 typeval *argvars;
5756 VAR retvar; 6362 typeval *retvar;
5757 { 6363 {
5758 retvar->var_val.var_number = highlight_exists(get_var_string(&argvars[0])); 6364 retvar->vval.v_number = highlight_exists(get_vartv_string(&argvars[0]));
5759 } 6365 }
5760 6366
5761 /* 6367 /*
5762 * "highlightID(name)" function 6368 * "highlightID(name)" function
5763 */ 6369 */
5764 static void 6370 static void
5765 f_hlID(argvars, retvar) 6371 f_hlID(argvars, retvar)
5766 VAR argvars; 6372 typeval *argvars;
5767 VAR retvar; 6373 typeval *retvar;
5768 { 6374 {
5769 retvar->var_val.var_number = syn_name2id(get_var_string(&argvars[0])); 6375 retvar->vval.v_number = syn_name2id(get_vartv_string(&argvars[0]));
5770 } 6376 }
5771 6377
5772 /* 6378 /*
5773 * "hostname()" function 6379 * "hostname()" function
5774 */ 6380 */
5775 /*ARGSUSED*/ 6381 /*ARGSUSED*/
5776 static void 6382 static void
5777 f_hostname(argvars, retvar) 6383 f_hostname(argvars, retvar)
5778 VAR argvars; 6384 typeval *argvars;
5779 VAR retvar; 6385 typeval *retvar;
5780 { 6386 {
5781 char_u hostname[256]; 6387 char_u hostname[256];
5782 6388
5783 mch_get_host_name(hostname, 256); 6389 mch_get_host_name(hostname, 256);
5784 retvar->var_type = VAR_STRING; 6390 retvar->v_type = VAR_STRING;
5785 retvar->var_val.var_string = vim_strsave(hostname); 6391 retvar->vval.v_string = vim_strsave(hostname);
5786 } 6392 }
5787 6393
5788 /* 6394 /*
5789 * iconv() function 6395 * iconv() function
5790 */ 6396 */
5791 /*ARGSUSED*/ 6397 /*ARGSUSED*/
5792 static void 6398 static void
5793 f_iconv(argvars, retvar) 6399 f_iconv(argvars, retvar)
5794 VAR argvars; 6400 typeval *argvars;
5795 VAR retvar; 6401 typeval *retvar;
5796 { 6402 {
5797 #ifdef FEAT_MBYTE 6403 #ifdef FEAT_MBYTE
5798 char_u buf1[NUMBUFLEN]; 6404 char_u buf1[NUMBUFLEN];
5799 char_u buf2[NUMBUFLEN]; 6405 char_u buf2[NUMBUFLEN];
5800 char_u *from, *to, *str; 6406 char_u *from, *to, *str;
5801 vimconv_T vimconv; 6407 vimconv_T vimconv;
5802 #endif 6408 #endif
5803 6409
5804 retvar->var_type = VAR_STRING; 6410 retvar->v_type = VAR_STRING;
5805 retvar->var_val.var_string = NULL; 6411 retvar->vval.v_string = NULL;
5806 6412
5807 #ifdef FEAT_MBYTE 6413 #ifdef FEAT_MBYTE
5808 str = get_var_string(&argvars[0]); 6414 str = get_vartv_string(&argvars[0]);
5809 from = enc_canonize(enc_skip(get_var_string_buf(&argvars[1], buf1))); 6415 from = enc_canonize(enc_skip(get_vartv_string_buf(&argvars[1], buf1)));
5810 to = enc_canonize(enc_skip(get_var_string_buf(&argvars[2], buf2))); 6416 to = enc_canonize(enc_skip(get_vartv_string_buf(&argvars[2], buf2)));
5811 vimconv.vc_type = CONV_NONE; 6417 vimconv.vc_type = CONV_NONE;
5812 convert_setup(&vimconv, from, to); 6418 convert_setup(&vimconv, from, to);
5813 6419
5814 /* If the encodings are equal, no conversion needed. */ 6420 /* If the encodings are equal, no conversion needed. */
5815 if (vimconv.vc_type == CONV_NONE) 6421 if (vimconv.vc_type == CONV_NONE)
5816 retvar->var_val.var_string = vim_strsave(str); 6422 retvar->vval.v_string = vim_strsave(str);
5817 else 6423 else
5818 retvar->var_val.var_string = string_convert(&vimconv, str, NULL); 6424 retvar->vval.v_string = string_convert(&vimconv, str, NULL);
5819 6425
5820 convert_setup(&vimconv, NULL, NULL); 6426 convert_setup(&vimconv, NULL, NULL);
5821 vim_free(from); 6427 vim_free(from);
5822 vim_free(to); 6428 vim_free(to);
5823 #endif 6429 #endif
5826 /* 6432 /*
5827 * "indent()" function 6433 * "indent()" function
5828 */ 6434 */
5829 static void 6435 static void
5830 f_indent(argvars, retvar) 6436 f_indent(argvars, retvar)
5831 VAR argvars; 6437 typeval *argvars;
5832 VAR retvar; 6438 typeval *retvar;
5833 { 6439 {
5834 linenr_T lnum; 6440 linenr_T lnum;
5835 6441
5836 lnum = get_var_lnum(argvars); 6442 lnum = get_vartv_lnum(argvars);
5837 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 6443 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
5838 retvar->var_val.var_number = get_indent_lnum(lnum); 6444 retvar->vval.v_number = get_indent_lnum(lnum);
5839 else 6445 else
5840 retvar->var_val.var_number = -1; 6446 retvar->vval.v_number = -1;
5841 } 6447 }
5842 6448
5843 static int inputsecret_flag = 0; 6449 static int inputsecret_flag = 0;
5844 6450
5845 /* 6451 /*
5846 * "input()" function 6452 * "input()" function
5847 * Also handles inputsecret() when inputsecret is set. 6453 * Also handles inputsecret() when inputsecret is set.
5848 */ 6454 */
5849 static void 6455 static void
5850 f_input(argvars, retvar) 6456 f_input(argvars, retvar)
5851 VAR argvars; 6457 typeval *argvars;
5852 VAR retvar; 6458 typeval *retvar;
5853 { 6459 {
5854 char_u *prompt = get_var_string(&argvars[0]); 6460 char_u *prompt = get_vartv_string(&argvars[0]);
5855 char_u *p = NULL; 6461 char_u *p = NULL;
5856 int c; 6462 int c;
5857 char_u buf[NUMBUFLEN]; 6463 char_u buf[NUMBUFLEN];
5858 int cmd_silent_save = cmd_silent; 6464 int cmd_silent_save = cmd_silent;
5859 6465
5860 retvar->var_type = VAR_STRING; 6466 retvar->v_type = VAR_STRING;
5861 6467
5862 #ifdef NO_CONSOLE_INPUT 6468 #ifdef NO_CONSOLE_INPUT
5863 /* While starting up, there is no place to enter text. */ 6469 /* While starting up, there is no place to enter text. */
5864 if (no_console_input()) 6470 if (no_console_input())
5865 { 6471 {
5866 retvar->var_val.var_string = NULL; 6472 retvar->vval.v_string = NULL;
5867 return; 6473 return;
5868 } 6474 }
5869 #endif 6475 #endif
5870 6476
5871 cmd_silent = FALSE; /* Want to see the prompt. */ 6477 cmd_silent = FALSE; /* Want to see the prompt. */
5889 *p = c; 6495 *p = c;
5890 } 6496 }
5891 cmdline_row = msg_row; 6497 cmdline_row = msg_row;
5892 } 6498 }
5893 6499
5894 if (argvars[1].var_type != VAR_UNKNOWN) 6500 if (argvars[1].v_type != VAR_UNKNOWN)
5895 stuffReadbuffSpec(get_var_string_buf(&argvars[1], buf)); 6501 stuffReadbuffSpec(get_vartv_string_buf(&argvars[1], buf));
5896 6502
5897 retvar->var_val.var_string = 6503 retvar->vval.v_string =
5898 getcmdline_prompt(inputsecret_flag ? NUL : '@', p, echo_attr); 6504 getcmdline_prompt(inputsecret_flag ? NUL : '@', p, echo_attr);
5899 6505
5900 /* since the user typed this, no need to wait for return */ 6506 /* since the user typed this, no need to wait for return */
5901 need_wait_return = FALSE; 6507 need_wait_return = FALSE;
5902 msg_didout = FALSE; 6508 msg_didout = FALSE;
5906 /* 6512 /*
5907 * "inputdialog()" function 6513 * "inputdialog()" function
5908 */ 6514 */
5909 static void 6515 static void
5910 f_inputdialog(argvars, retvar) 6516 f_inputdialog(argvars, retvar)
5911 VAR argvars; 6517 typeval *argvars;
5912 VAR retvar; 6518 typeval *retvar;
5913 { 6519 {
5914 #if defined(FEAT_GUI_TEXTDIALOG) 6520 #if defined(FEAT_GUI_TEXTDIALOG)
5915 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */ 6521 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
5916 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL) 6522 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
5917 { 6523 {
5918 char_u *message; 6524 char_u *message;
5919 char_u buf[NUMBUFLEN]; 6525 char_u buf[NUMBUFLEN];
5920 6526
5921 message = get_var_string(&argvars[0]); 6527 message = get_vartv_string(&argvars[0]);
5922 if (argvars[1].var_type != VAR_UNKNOWN) 6528 if (argvars[1].v_type != VAR_UNKNOWN)
5923 { 6529 {
5924 STRNCPY(IObuff, get_var_string_buf(&argvars[1], buf), IOSIZE); 6530 STRNCPY(IObuff, get_vartv_string_buf(&argvars[1], buf), IOSIZE);
5925 IObuff[IOSIZE - 1] = NUL; 6531 IObuff[IOSIZE - 1] = NUL;
5926 } 6532 }
5927 else 6533 else
5928 IObuff[0] = NUL; 6534 IObuff[0] = NUL;
5929 if (do_dialog(VIM_QUESTION, NULL, message, (char_u *)_("&OK\n&Cancel"), 6535 if (do_dialog(VIM_QUESTION, NULL, message, (char_u *)_("&OK\n&Cancel"),
5930 1, IObuff) == 1) 6536 1, IObuff) == 1)
5931 retvar->var_val.var_string = vim_strsave(IObuff); 6537 retvar->vval.v_string = vim_strsave(IObuff);
5932 else 6538 else
5933 { 6539 {
5934 if (argvars[1].var_type != VAR_UNKNOWN 6540 if (argvars[1].v_type != VAR_UNKNOWN
5935 && argvars[2].var_type != VAR_UNKNOWN) 6541 && argvars[2].v_type != VAR_UNKNOWN)
5936 retvar->var_val.var_string = vim_strsave( 6542 retvar->vval.v_string = vim_strsave(
5937 get_var_string_buf(&argvars[2], buf)); 6543 get_vartv_string_buf(&argvars[2], buf));
5938 else 6544 else
5939 retvar->var_val.var_string = NULL; 6545 retvar->vval.v_string = NULL;
5940 } 6546 }
5941 retvar->var_type = VAR_STRING; 6547 retvar->v_type = VAR_STRING;
5942 } 6548 }
5943 else 6549 else
5944 #endif 6550 #endif
5945 f_input(argvars, retvar); 6551 f_input(argvars, retvar);
5946 } 6552 }
5951 * "inputrestore()" function 6557 * "inputrestore()" function
5952 */ 6558 */
5953 /*ARGSUSED*/ 6559 /*ARGSUSED*/
5954 static void 6560 static void
5955 f_inputrestore(argvars, retvar) 6561 f_inputrestore(argvars, retvar)
5956 VAR argvars; 6562 typeval *argvars;
5957 VAR retvar; 6563 typeval *retvar;
5958 { 6564 {
5959 if (ga_userinput.ga_len > 0) 6565 if (ga_userinput.ga_len > 0)
5960 { 6566 {
5961 --ga_userinput.ga_len; 6567 --ga_userinput.ga_len;
5962 restore_typeahead((tasave_T *)(ga_userinput.ga_data) 6568 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
5963 + ga_userinput.ga_len); 6569 + ga_userinput.ga_len);
5964 retvar->var_val.var_number = 0; /* OK */ 6570 retvar->vval.v_number = 0; /* OK */
5965 } 6571 }
5966 else if (p_verbose > 1) 6572 else if (p_verbose > 1)
5967 { 6573 {
5968 msg((char_u *)_("called inputrestore() more often than inputsave()")); 6574 msg((char_u *)_("called inputrestore() more often than inputsave()"));
5969 retvar->var_val.var_number = 1; /* Failed */ 6575 retvar->vval.v_number = 1; /* Failed */
5970 } 6576 }
5971 } 6577 }
5972 6578
5973 /* 6579 /*
5974 * "inputsave()" function 6580 * "inputsave()" function
5975 */ 6581 */
5976 /*ARGSUSED*/ 6582 /*ARGSUSED*/
5977 static void 6583 static void
5978 f_inputsave(argvars, retvar) 6584 f_inputsave(argvars, retvar)
5979 VAR argvars; 6585 typeval *argvars;
5980 VAR retvar; 6586 typeval *retvar;
5981 { 6587 {
5982 /* Add an entry to the stack of typehead storage. */ 6588 /* Add an entry to the stack of typehead storage. */
5983 if (ga_grow(&ga_userinput, 1) == OK) 6589 if (ga_grow(&ga_userinput, 1) == OK)
5984 { 6590 {
5985 save_typeahead((tasave_T *)(ga_userinput.ga_data) 6591 save_typeahead((tasave_T *)(ga_userinput.ga_data)
5986 + ga_userinput.ga_len); 6592 + ga_userinput.ga_len);
5987 ++ga_userinput.ga_len; 6593 ++ga_userinput.ga_len;
5988 retvar->var_val.var_number = 0; /* OK */ 6594 retvar->vval.v_number = 0; /* OK */
5989 } 6595 }
5990 else 6596 else
5991 retvar->var_val.var_number = 1; /* Failed */ 6597 retvar->vval.v_number = 1; /* Failed */
5992 } 6598 }
5993 6599
5994 /* 6600 /*
5995 * "inputsecret()" function 6601 * "inputsecret()" function
5996 */ 6602 */
5997 static void 6603 static void
5998 f_inputsecret(argvars, retvar) 6604 f_inputsecret(argvars, retvar)
5999 VAR argvars; 6605 typeval *argvars;
6000 VAR retvar; 6606 typeval *retvar;
6001 { 6607 {
6002 ++cmdline_star; 6608 ++cmdline_star;
6003 ++inputsecret_flag; 6609 ++inputsecret_flag;
6004 f_input(argvars, retvar); 6610 f_input(argvars, retvar);
6005 --cmdline_star; 6611 --cmdline_star;
6006 --inputsecret_flag; 6612 --inputsecret_flag;
6007 } 6613 }
6008 6614
6009 /* 6615 /*
6616 * "insert()" function
6617 */
6618 static void
6619 f_insert(argvars, retvar)
6620 typeval *argvars;
6621 typeval *retvar;
6622 {
6623 long before = 0;
6624 long n;
6625 listitem *item;
6626 listitem *ni;
6627 listvar *l;
6628
6629 if (argvars[0].v_type != VAR_LIST)
6630 EMSG(_("E999: First argument of insert() must be a list"));
6631 else if ((l = argvars[0].vval.v_list) != NULL)
6632 {
6633 if (argvars[2].v_type != VAR_UNKNOWN)
6634 before = get_vartv_number(&argvars[2]);
6635
6636 if (before < 0)
6637 {
6638 /* Count from the end: -1 is before last item. */
6639 item = l->lv_last;
6640 for (n = before + 1; n < 0 && item != NULL; ++n)
6641 item = item->li_prev;
6642 if (item == NULL)
6643 n = 1; /* report an error, don't append */
6644 }
6645 else
6646 {
6647 /* Can't use list_find() here, we allow one past the end. */
6648 item = l->lv_first;
6649 for (n = before; n > 0 && item != NULL; --n)
6650 item = item->li_next;
6651 }
6652 if (n > 0)
6653 EMSGN(_(e_listidx), before);
6654 else
6655 {
6656 ni = listitem_alloc();
6657 if (ni != NULL)
6658 {
6659 copy_vartv(&argvars[1], &ni->li_tv);
6660 if (item == NULL)
6661 /* Append new item at end of list. */
6662 list_append(l, ni);
6663 else
6664 {
6665 /* Insert new item before existing item. */
6666 ni->li_prev = item->li_prev;
6667 ni->li_next = item;
6668 if (item->li_prev == NULL)
6669 l->lv_first = ni;
6670 else
6671 item->li_prev->li_next = ni;
6672 item->li_prev = ni;
6673 }
6674 copy_vartv(&argvars[0], retvar);
6675 }
6676 }
6677 }
6678 }
6679
6680 /*
6010 * "isdirectory()" function 6681 * "isdirectory()" function
6011 */ 6682 */
6012 static void 6683 static void
6013 f_isdirectory(argvars, retvar) 6684 f_isdirectory(argvars, retvar)
6014 VAR argvars; 6685 typeval *argvars;
6015 VAR retvar; 6686 typeval *retvar;
6016 { 6687 {
6017 retvar->var_val.var_number = mch_isdir(get_var_string(&argvars[0])); 6688 retvar->vval.v_number = mch_isdir(get_vartv_string(&argvars[0]));
6018 } 6689 }
6019 6690
6020 /* 6691 /*
6021 * "last_buffer_nr()" function. 6692 * "last_buffer_nr()" function.
6022 */ 6693 */
6023 /*ARGSUSED*/ 6694 /*ARGSUSED*/
6024 static void 6695 static void
6025 f_last_buffer_nr(argvars, retvar) 6696 f_last_buffer_nr(argvars, retvar)
6026 VAR argvars; 6697 typeval *argvars;
6027 VAR retvar; 6698 typeval *retvar;
6028 { 6699 {
6029 int n = 0; 6700 int n = 0;
6030 buf_T *buf; 6701 buf_T *buf;
6031 6702
6032 for (buf = firstbuf; buf != NULL; buf = buf->b_next) 6703 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
6033 if (n < buf->b_fnum) 6704 if (n < buf->b_fnum)
6034 n = buf->b_fnum; 6705 n = buf->b_fnum;
6035 6706
6036 retvar->var_val.var_number = n; 6707 retvar->vval.v_number = n;
6708 }
6709
6710 /*
6711 * "len()" function
6712 */
6713 static void
6714 f_len(argvars, retvar)
6715 typeval *argvars;
6716 typeval *retvar;
6717 {
6718 switch (argvars[0].v_type)
6719 {
6720 case VAR_STRING:
6721 case VAR_NUMBER:
6722 retvar->vval.v_number = (varnumber_T)STRLEN(
6723 get_vartv_string(&argvars[0]));
6724 break;
6725 case VAR_LIST:
6726 retvar->vval.v_number = list_len(argvars[0].vval.v_list);
6727 break;
6728 default:
6729 EMSG(_("E999: Invalid type for len()"));
6730 break;
6731 }
6732 }
6733
6734 /*
6735 * "libcall()" function
6736 */
6737 static void
6738 f_libcall(argvars, retvar)
6739 typeval *argvars;
6740 typeval *retvar;
6741 {
6742 libcall_common(argvars, retvar, VAR_STRING);
6743 }
6744
6745 /*
6746 * "libcallnr()" function
6747 */
6748 static void
6749 f_libcallnr(argvars, retvar)
6750 typeval *argvars;
6751 typeval *retvar;
6752 {
6753 libcall_common(argvars, retvar, VAR_NUMBER);
6754 }
6755
6756 static void
6757 libcall_common(argvars, retvar, type)
6758 typeval *argvars;
6759 typeval *retvar;
6760 int type;
6761 {
6762 #ifdef FEAT_LIBCALL
6763 char_u *string_in;
6764 char_u **string_result;
6765 int nr_result;
6766 #endif
6767
6768 retvar->v_type = type;
6769 if (type == VAR_NUMBER)
6770 retvar->vval.v_number = 0;
6771 else
6772 retvar->vval.v_string = NULL;
6773
6774 if (check_restricted() || check_secure())
6775 return;
6776
6777 #ifdef FEAT_LIBCALL
6778 /* The first two args must be strings, otherwise its meaningless */
6779 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
6780 {
6781 if (argvars[2].v_type == VAR_NUMBER)
6782 string_in = NULL;
6783 else
6784 string_in = argvars[2].vval.v_string;
6785 if (type == VAR_NUMBER)
6786 string_result = NULL;
6787 else
6788 string_result = &retvar->vval.v_string;
6789 if (mch_libcall(argvars[0].vval.v_string,
6790 argvars[1].vval.v_string,
6791 string_in,
6792 argvars[2].vval.v_number,
6793 string_result,
6794 &nr_result) == OK
6795 && type == VAR_NUMBER)
6796 retvar->vval.v_number = nr_result;
6797 }
6798 #endif
6037 } 6799 }
6038 6800
6039 /* 6801 /*
6040 * "line(string)" function 6802 * "line(string)" function
6041 */ 6803 */
6042 static void 6804 static void
6043 f_line(argvars, retvar) 6805 f_line(argvars, retvar)
6044 VAR argvars; 6806 typeval *argvars;
6045 VAR retvar; 6807 typeval *retvar;
6046 { 6808 {
6047 linenr_T lnum = 0; 6809 linenr_T lnum = 0;
6048 pos_T *fp; 6810 pos_T *fp;
6049 6811
6050 fp = var2fpos(&argvars[0], TRUE); 6812 fp = var2fpos(&argvars[0], TRUE);
6051 if (fp != NULL) 6813 if (fp != NULL)
6052 lnum = fp->lnum; 6814 lnum = fp->lnum;
6053 retvar->var_val.var_number = lnum; 6815 retvar->vval.v_number = lnum;
6054 } 6816 }
6055 6817
6056 /* 6818 /*
6057 * "line2byte(lnum)" function 6819 * "line2byte(lnum)" function
6058 */ 6820 */
6059 /*ARGSUSED*/ 6821 /*ARGSUSED*/
6060 static void 6822 static void
6061 f_line2byte(argvars, retvar) 6823 f_line2byte(argvars, retvar)
6062 VAR argvars; 6824 typeval *argvars;
6063 VAR retvar; 6825 typeval *retvar;
6064 { 6826 {
6065 #ifndef FEAT_BYTEOFF 6827 #ifndef FEAT_BYTEOFF
6066 retvar->var_val.var_number = -1; 6828 retvar->vval.v_number = -1;
6067 #else 6829 #else
6068 linenr_T lnum; 6830 linenr_T lnum;
6069 6831
6070 lnum = get_var_lnum(argvars); 6832 lnum = get_vartv_lnum(argvars);
6071 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1) 6833 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
6072 retvar->var_val.var_number = -1; 6834 retvar->vval.v_number = -1;
6073 else 6835 else
6074 retvar->var_val.var_number = ml_find_line_or_offset(curbuf, lnum, NULL); 6836 retvar->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
6075 if (retvar->var_val.var_number >= 0) 6837 if (retvar->vval.v_number >= 0)
6076 ++retvar->var_val.var_number; 6838 ++retvar->vval.v_number;
6077 #endif 6839 #endif
6078 } 6840 }
6079 6841
6080 /* 6842 /*
6081 * "lispindent(lnum)" function 6843 * "lispindent(lnum)" function
6082 */ 6844 */
6083 static void 6845 static void
6084 f_lispindent(argvars, retvar) 6846 f_lispindent(argvars, retvar)
6085 VAR argvars; 6847 typeval *argvars;
6086 VAR retvar; 6848 typeval *retvar;
6087 { 6849 {
6088 #ifdef FEAT_LISP 6850 #ifdef FEAT_LISP
6089 pos_T pos; 6851 pos_T pos;
6090 linenr_T lnum; 6852 linenr_T lnum;
6091 6853
6092 pos = curwin->w_cursor; 6854 pos = curwin->w_cursor;
6093 lnum = get_var_lnum(argvars); 6855 lnum = get_vartv_lnum(argvars);
6094 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 6856 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
6095 { 6857 {
6096 curwin->w_cursor.lnum = lnum; 6858 curwin->w_cursor.lnum = lnum;
6097 retvar->var_val.var_number = get_lisp_indent(); 6859 retvar->vval.v_number = get_lisp_indent();
6098 curwin->w_cursor = pos; 6860 curwin->w_cursor = pos;
6099 } 6861 }
6100 else 6862 else
6101 #endif 6863 #endif
6102 retvar->var_val.var_number = -1; 6864 retvar->vval.v_number = -1;
6103 } 6865 }
6104 6866
6105 /* 6867 /*
6106 * "localtime()" function 6868 * "localtime()" function
6107 */ 6869 */
6108 /*ARGSUSED*/ 6870 /*ARGSUSED*/
6109 static void 6871 static void
6110 f_localtime(argvars, retvar) 6872 f_localtime(argvars, retvar)
6111 VAR argvars; 6873 typeval *argvars;
6112 VAR retvar; 6874 typeval *retvar;
6113 { 6875 {
6114 retvar->var_val.var_number = (varnumber_T)time(NULL); 6876 retvar->vval.v_number = (varnumber_T)time(NULL);
6115 } 6877 }
6116 6878
6117 /* 6879 /*
6118 * "maparg()" function 6880 * "maparg()" function
6119 */ 6881 */
6120 static void 6882 static void
6121 f_maparg(argvars, retvar) 6883 f_maparg(argvars, retvar)
6122 VAR argvars; 6884 typeval *argvars;
6123 VAR retvar; 6885 typeval *retvar;
6124 { 6886 {
6125 get_maparg(argvars, retvar, TRUE); 6887 get_maparg(argvars, retvar, TRUE);
6126 } 6888 }
6127 6889
6128 /* 6890 /*
6129 * "mapcheck()" function 6891 * "mapcheck()" function
6130 */ 6892 */
6131 static void 6893 static void
6132 f_mapcheck(argvars, retvar) 6894 f_mapcheck(argvars, retvar)
6133 VAR argvars; 6895 typeval *argvars;
6134 VAR retvar; 6896 typeval *retvar;
6135 { 6897 {
6136 get_maparg(argvars, retvar, FALSE); 6898 get_maparg(argvars, retvar, FALSE);
6137 } 6899 }
6138 6900
6139 static void 6901 static void
6140 get_maparg(argvars, retvar, exact) 6902 get_maparg(argvars, retvar, exact)
6141 VAR argvars; 6903 typeval *argvars;
6142 VAR retvar; 6904 typeval *retvar;
6143 int exact; 6905 int exact;
6144 { 6906 {
6145 char_u *keys; 6907 char_u *keys;
6146 char_u *which; 6908 char_u *which;
6147 char_u buf[NUMBUFLEN]; 6909 char_u buf[NUMBUFLEN];
6149 char_u *rhs; 6911 char_u *rhs;
6150 int mode; 6912 int mode;
6151 garray_T ga; 6913 garray_T ga;
6152 6914
6153 /* return empty string for failure */ 6915 /* return empty string for failure */
6154 retvar->var_type = VAR_STRING; 6916 retvar->v_type = VAR_STRING;
6155 retvar->var_val.var_string = NULL; 6917 retvar->vval.v_string = NULL;
6156 6918
6157 keys = get_var_string(&argvars[0]); 6919 keys = get_vartv_string(&argvars[0]);
6158 if (*keys == NUL) 6920 if (*keys == NUL)
6159 return; 6921 return;
6160 6922
6161 if (argvars[1].var_type != VAR_UNKNOWN) 6923 if (argvars[1].v_type != VAR_UNKNOWN)
6162 which = get_var_string_buf(&argvars[1], buf); 6924 which = get_vartv_string_buf(&argvars[1], buf);
6163 else 6925 else
6164 which = (char_u *)""; 6926 which = (char_u *)"";
6165 mode = get_map_mode(&which, 0); 6927 mode = get_map_mode(&which, 0);
6166 6928
6167 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE); 6929 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE);
6175 6937
6176 while (*rhs != NUL) 6938 while (*rhs != NUL)
6177 ga_concat(&ga, str2special(&rhs, FALSE)); 6939 ga_concat(&ga, str2special(&rhs, FALSE));
6178 6940
6179 ga_append(&ga, NUL); 6941 ga_append(&ga, NUL);
6180 retvar->var_val.var_string = (char_u *)ga.ga_data; 6942 retvar->vval.v_string = (char_u *)ga.ga_data;
6181 } 6943 }
6182 } 6944 }
6183 6945
6184 /* 6946 /*
6185 * "match()" function 6947 * "match()" function
6186 */ 6948 */
6187 static void 6949 static void
6188 f_match(argvars, retvar) 6950 f_match(argvars, retvar)
6189 VAR argvars; 6951 typeval *argvars;
6190 VAR retvar; 6952 typeval *retvar;
6191 { 6953 {
6192 find_some_match(argvars, retvar, 1); 6954 find_some_match(argvars, retvar, 1);
6193 } 6955 }
6194 6956
6195 /* 6957 /*
6196 * "matchend()" function 6958 * "matchend()" function
6197 */ 6959 */
6198 static void 6960 static void
6199 f_matchend(argvars, retvar) 6961 f_matchend(argvars, retvar)
6200 VAR argvars; 6962 typeval *argvars;
6201 VAR retvar; 6963 typeval *retvar;
6202 { 6964 {
6203 find_some_match(argvars, retvar, 0); 6965 find_some_match(argvars, retvar, 0);
6204 } 6966 }
6205 6967
6206 /* 6968 /*
6207 * "matchstr()" function 6969 * "matchstr()" function
6208 */ 6970 */
6209 static void 6971 static void
6210 f_matchstr(argvars, retvar) 6972 f_matchstr(argvars, retvar)
6211 VAR argvars; 6973 typeval *argvars;
6212 VAR retvar; 6974 typeval *retvar;
6213 { 6975 {
6214 find_some_match(argvars, retvar, 2); 6976 find_some_match(argvars, retvar, 2);
6215 } 6977 }
6216 6978
6217 static void 6979 static void
6218 find_some_match(argvars, retvar, type) 6980 find_some_match(argvars, retvar, type)
6219 VAR argvars; 6981 typeval *argvars;
6220 VAR retvar; 6982 typeval *retvar;
6221 int type; 6983 int type;
6222 { 6984 {
6223 char_u *str; 6985 char_u *str;
6224 char_u *expr; 6986 char_u *expr;
6225 char_u *pat; 6987 char_u *pat;
6232 6994
6233 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */ 6995 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
6234 save_cpo = p_cpo; 6996 save_cpo = p_cpo;
6235 p_cpo = (char_u *)""; 6997 p_cpo = (char_u *)"";
6236 6998
6237 expr = str = get_var_string(&argvars[0]); 6999 expr = str = get_vartv_string(&argvars[0]);
6238 pat = get_var_string_buf(&argvars[1], patbuf); 7000 pat = get_vartv_string_buf(&argvars[1], patbuf);
6239 7001
6240 if (type == 2) 7002 if (type == 2)
6241 { 7003 {
6242 retvar->var_type = VAR_STRING; 7004 retvar->v_type = VAR_STRING;
6243 retvar->var_val.var_string = NULL; 7005 retvar->vval.v_string = NULL;
6244 } 7006 }
6245 else 7007 else
6246 retvar->var_val.var_number = -1; 7008 retvar->vval.v_number = -1;
6247 7009
6248 if (argvars[2].var_type != VAR_UNKNOWN) 7010 if (argvars[2].v_type != VAR_UNKNOWN)
6249 { 7011 {
6250 start = get_var_number(&argvars[2]); 7012 start = get_vartv_number(&argvars[2]);
6251 if (start < 0) 7013 if (start < 0)
6252 start = 0; 7014 start = 0;
6253 if (start > (long)STRLEN(str)) 7015 if (start > (long)STRLEN(str))
6254 goto theend; 7016 goto theend;
6255 str += start; 7017 str += start;
6256 7018
6257 if (argvars[3].var_type != VAR_UNKNOWN) 7019 if (argvars[3].v_type != VAR_UNKNOWN)
6258 nth = get_var_number(&argvars[3]); 7020 nth = get_vartv_number(&argvars[3]);
6259 } 7021 }
6260 7022
6261 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); 7023 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
6262 if (regmatch.regprog != NULL) 7024 if (regmatch.regprog != NULL)
6263 { 7025 {
6277 } 7039 }
6278 7040
6279 if (match) 7041 if (match)
6280 { 7042 {
6281 if (type == 2) 7043 if (type == 2)
6282 retvar->var_val.var_string = vim_strnsave(regmatch.startp[0], 7044 retvar->vval.v_string = vim_strnsave(regmatch.startp[0],
6283 (int)(regmatch.endp[0] - regmatch.startp[0])); 7045 (int)(regmatch.endp[0] - regmatch.startp[0]));
6284 else 7046 else
6285 { 7047 {
6286 if (type != 0) 7048 if (type != 0)
6287 retvar->var_val.var_number = 7049 retvar->vval.v_number =
6288 (varnumber_T)(regmatch.startp[0] - str); 7050 (varnumber_T)(regmatch.startp[0] - str);
6289 else 7051 else
6290 retvar->var_val.var_number = 7052 retvar->vval.v_number =
6291 (varnumber_T)(regmatch.endp[0] - str); 7053 (varnumber_T)(regmatch.endp[0] - str);
6292 retvar->var_val.var_number += str - expr; 7054 retvar->vval.v_number += str - expr;
6293 } 7055 }
6294 } 7056 }
6295 vim_free(regmatch.regprog); 7057 vim_free(regmatch.regprog);
6296 } 7058 }
6297 7059
6303 * "mode()" function 7065 * "mode()" function
6304 */ 7066 */
6305 /*ARGSUSED*/ 7067 /*ARGSUSED*/
6306 static void 7068 static void
6307 f_mode(argvars, retvar) 7069 f_mode(argvars, retvar)
6308 VAR argvars; 7070 typeval *argvars;
6309 VAR retvar; 7071 typeval *retvar;
6310 { 7072 {
6311 char_u buf[2]; 7073 char_u buf[2];
6312 7074
6313 #ifdef FEAT_VISUAL 7075 #ifdef FEAT_VISUAL
6314 if (VIsual_active) 7076 if (VIsual_active)
6333 buf[0] = 'c'; 7095 buf[0] = 'c';
6334 else 7096 else
6335 buf[0] = 'n'; 7097 buf[0] = 'n';
6336 7098
6337 buf[1] = NUL; 7099 buf[1] = NUL;
6338 retvar->var_val.var_string = vim_strsave(buf); 7100 retvar->vval.v_string = vim_strsave(buf);
6339 retvar->var_type = VAR_STRING; 7101 retvar->v_type = VAR_STRING;
6340 } 7102 }
6341 7103
6342 /* 7104 /*
6343 * "nr2char()" function 7105 * "nr2char()" function
6344 */ 7106 */
6345 static void 7107 static void
6346 f_nr2char(argvars, retvar) 7108 f_nr2char(argvars, retvar)
6347 VAR argvars; 7109 typeval *argvars;
6348 VAR retvar; 7110 typeval *retvar;
6349 { 7111 {
6350 char_u buf[NUMBUFLEN]; 7112 char_u buf[NUMBUFLEN];
6351 7113
6352 #ifdef FEAT_MBYTE 7114 #ifdef FEAT_MBYTE
6353 if (has_mbyte) 7115 if (has_mbyte)
6354 buf[(*mb_char2bytes)((int)get_var_number(&argvars[0]), buf)] = NUL; 7116 buf[(*mb_char2bytes)((int)get_vartv_number(&argvars[0]), buf)] = NUL;
6355 else 7117 else
6356 #endif 7118 #endif
6357 { 7119 {
6358 buf[0] = (char_u)get_var_number(&argvars[0]); 7120 buf[0] = (char_u)get_vartv_number(&argvars[0]);
6359 buf[1] = NUL; 7121 buf[1] = NUL;
6360 } 7122 }
6361 retvar->var_type = VAR_STRING; 7123 retvar->v_type = VAR_STRING;
6362 retvar->var_val.var_string = vim_strsave(buf); 7124 retvar->vval.v_string = vim_strsave(buf);
7125 }
7126
7127 /*
7128 * "remove({list}, {idx})" function
7129 */
7130 static void
7131 f_remove(argvars, retvar)
7132 typeval *argvars;
7133 typeval *retvar;
7134 {
7135 listvar *l;
7136 listitem *item;
7137 long idx;
7138
7139 if (argvars[0].v_type != VAR_LIST)
7140 EMSG(_("E999: First argument of remove() must be a list"));
7141 else if ((l = argvars[0].vval.v_list) != NULL)
7142 {
7143 idx = get_vartv_number(&argvars[1]);
7144 item = list_getrem(l, idx);
7145 if (item == NULL)
7146 EMSGN(_(e_listidx), idx);
7147 else
7148 {
7149 *retvar = item->li_tv;
7150 vim_free(item);
7151 }
7152 }
6363 } 7153 }
6364 7154
6365 /* 7155 /*
6366 * "rename({from}, {to})" function 7156 * "rename({from}, {to})" function
6367 */ 7157 */
6368 static void 7158 static void
6369 f_rename(argvars, retvar) 7159 f_rename(argvars, retvar)
6370 VAR argvars; 7160 typeval *argvars;
6371 VAR retvar; 7161 typeval *retvar;
6372 { 7162 {
6373 char_u buf[NUMBUFLEN]; 7163 char_u buf[NUMBUFLEN];
6374 7164
6375 if (check_restricted() || check_secure()) 7165 if (check_restricted() || check_secure())
6376 retvar->var_val.var_number = -1; 7166 retvar->vval.v_number = -1;
6377 else 7167 else
6378 retvar->var_val.var_number = vim_rename(get_var_string(&argvars[0]), 7168 retvar->vval.v_number = vim_rename(get_vartv_string(&argvars[0]),
6379 get_var_string_buf(&argvars[1], buf)); 7169 get_vartv_string_buf(&argvars[1], buf));
6380 } 7170 }
6381 7171
6382 /* 7172 /*
6383 * "resolve()" function 7173 * "resolve()" function
6384 */ 7174 */
6385 static void 7175 static void
6386 f_resolve(argvars, retvar) 7176 f_resolve(argvars, retvar)
6387 VAR argvars; 7177 typeval *argvars;
6388 VAR retvar; 7178 typeval *retvar;
6389 { 7179 {
6390 char_u *p; 7180 char_u *p;
6391 7181
6392 p = get_var_string(&argvars[0]); 7182 p = get_vartv_string(&argvars[0]);
6393 #ifdef FEAT_SHORTCUT 7183 #ifdef FEAT_SHORTCUT
6394 { 7184 {
6395 char_u *v = NULL; 7185 char_u *v = NULL;
6396 7186
6397 v = mch_resolve_shortcut(p); 7187 v = mch_resolve_shortcut(p);
6398 if (v != NULL) 7188 if (v != NULL)
6399 retvar->var_val.var_string = v; 7189 retvar->vval.v_string = v;
6400 else 7190 else
6401 retvar->var_val.var_string = vim_strsave(p); 7191 retvar->vval.v_string = vim_strsave(p);
6402 } 7192 }
6403 #else 7193 #else
6404 # ifdef HAVE_READLINK 7194 # ifdef HAVE_READLINK
6405 { 7195 {
6406 char_u buf[MAXPATHL + 1]; 7196 char_u buf[MAXPATHL + 1];
6443 if (limit-- == 0) 7233 if (limit-- == 0)
6444 { 7234 {
6445 vim_free(p); 7235 vim_free(p);
6446 vim_free(remain); 7236 vim_free(remain);
6447 EMSG(_("E655: Too many symbolic links (cycle?)")); 7237 EMSG(_("E655: Too many symbolic links (cycle?)"));
6448 retvar->var_val.var_string = NULL; 7238 retvar->vval.v_string = NULL;
6449 goto fail; 7239 goto fail;
6450 } 7240 }
6451 7241
6452 /* Ensure that the result will have a trailing path separator 7242 /* Ensure that the result will have a trailing path separator
6453 * if the argument has one. */ 7243 * if the argument has one. */
6563 q = p + STRLEN(p); 7353 q = p + STRLEN(p);
6564 if (after_pathsep(p, q)) 7354 if (after_pathsep(p, q))
6565 *gettail_sep(p) = NUL; 7355 *gettail_sep(p) = NUL;
6566 } 7356 }
6567 7357
6568 retvar->var_val.var_string = p; 7358 retvar->vval.v_string = p;
6569 } 7359 }
6570 # else 7360 # else
6571 retvar->var_val.var_string = vim_strsave(p); 7361 retvar->vval.v_string = vim_strsave(p);
6572 # endif 7362 # endif
6573 #endif 7363 #endif
6574 7364
6575 simplify_filename(retvar->var_val.var_string); 7365 simplify_filename(retvar->vval.v_string);
6576 7366
6577 #ifdef HAVE_READLINK 7367 #ifdef HAVE_READLINK
6578 fail: 7368 fail:
6579 #endif 7369 #endif
6580 retvar->var_type = VAR_STRING; 7370 retvar->v_type = VAR_STRING;
6581 } 7371 }
6582 7372
6583 /* 7373 /*
6584 * "simplify()" function 7374 * "simplify()" function
6585 */ 7375 */
6586 static void 7376 static void
6587 f_simplify(argvars, retvar) 7377 f_simplify(argvars, retvar)
6588 VAR argvars; 7378 typeval *argvars;
6589 VAR retvar; 7379 typeval *retvar;
6590 { 7380 {
6591 char_u *p; 7381 char_u *p;
6592 7382
6593 p = get_var_string(&argvars[0]); 7383 p = get_vartv_string(&argvars[0]);
6594 retvar->var_val.var_string = vim_strsave(p); 7384 retvar->vval.v_string = vim_strsave(p);
6595 simplify_filename(retvar->var_val.var_string); /* simplify in place */ 7385 simplify_filename(retvar->vval.v_string); /* simplify in place */
6596 retvar->var_type = VAR_STRING; 7386 retvar->v_type = VAR_STRING;
6597 } 7387 }
6598 7388
6599 #define SP_NOMOVE 1 /* don't move cursor */ 7389 #define SP_NOMOVE 1 /* don't move cursor */
6600 #define SP_REPEAT 2 /* repeat to find outer pair */ 7390 #define SP_REPEAT 2 /* repeat to find outer pair */
6601 #define SP_RETCOUNT 4 /* return matchcount */ 7391 #define SP_RETCOUNT 4 /* return matchcount */
6603 /* 7393 /*
6604 * "search()" function 7394 * "search()" function
6605 */ 7395 */
6606 static void 7396 static void
6607 f_search(argvars, retvar) 7397 f_search(argvars, retvar)
6608 VAR argvars; 7398 typeval *argvars;
6609 VAR retvar; 7399 typeval *retvar;
6610 { 7400 {
6611 char_u *pat; 7401 char_u *pat;
6612 pos_T pos; 7402 pos_T pos;
6613 pos_T save_cursor; 7403 pos_T save_cursor;
6614 int save_p_ws = p_ws; 7404 int save_p_ws = p_ws;
6615 int dir; 7405 int dir;
6616 int flags = 0; 7406 int flags = 0;
6617 7407
6618 retvar->var_val.var_number = 0; /* default: FAIL */ 7408 retvar->vval.v_number = 0; /* default: FAIL */
6619 7409
6620 pat = get_var_string(&argvars[0]); 7410 pat = get_vartv_string(&argvars[0]);
6621 dir = get_search_arg(&argvars[1], &flags); /* may set p_ws */ 7411 dir = get_search_arg(&argvars[1], &flags); /* may set p_ws */
6622 if (dir == 0) 7412 if (dir == 0)
6623 goto theend; 7413 goto theend;
6624 if ((flags & ~SP_NOMOVE) != 0) 7414 if ((flags & ~SP_NOMOVE) != 0)
6625 { 7415 {
6626 EMSG2(_(e_invarg2), get_var_string(&argvars[1])); 7416 EMSG2(_(e_invarg2), get_vartv_string(&argvars[1]));
6627 goto theend; 7417 goto theend;
6628 } 7418 }
6629 7419
6630 pos = save_cursor = curwin->w_cursor; 7420 pos = save_cursor = curwin->w_cursor;
6631 if (searchit(curwin, curbuf, &pos, dir, pat, 1L, 7421 if (searchit(curwin, curbuf, &pos, dir, pat, 1L,
6632 SEARCH_KEEP, RE_SEARCH) != FAIL) 7422 SEARCH_KEEP, RE_SEARCH) != FAIL)
6633 { 7423 {
6634 retvar->var_val.var_number = pos.lnum; 7424 retvar->vval.v_number = pos.lnum;
6635 curwin->w_cursor = pos; 7425 curwin->w_cursor = pos;
6636 /* "/$" will put the cursor after the end of the line, may need to 7426 /* "/$" will put the cursor after the end of the line, may need to
6637 * correct that here */ 7427 * correct that here */
6638 check_cursor(); 7428 check_cursor();
6639 } 7429 }
6648 /* 7438 /*
6649 * "searchpair()" function 7439 * "searchpair()" function
6650 */ 7440 */
6651 static void 7441 static void
6652 f_searchpair(argvars, retvar) 7442 f_searchpair(argvars, retvar)
6653 VAR argvars; 7443 typeval *argvars;
6654 VAR retvar; 7444 typeval *retvar;
6655 { 7445 {
6656 char_u *spat, *mpat, *epat; 7446 char_u *spat, *mpat, *epat;
6657 char_u *skip; 7447 char_u *skip;
6658 char_u *pat, *pat2, *pat3; 7448 char_u *pat, *pat2, *pat3;
6659 pos_T pos; 7449 pos_T pos;
6670 int n; 7460 int n;
6671 int r; 7461 int r;
6672 int nest = 1; 7462 int nest = 1;
6673 int err; 7463 int err;
6674 7464
6675 retvar->var_val.var_number = 0; /* default: FAIL */ 7465 retvar->vval.v_number = 0; /* default: FAIL */
6676 7466
6677 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */ 7467 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
6678 save_cpo = p_cpo; 7468 save_cpo = p_cpo;
6679 p_cpo = (char_u *)""; 7469 p_cpo = (char_u *)"";
6680 7470
6681 /* Get the three pattern arguments: start, middle, end. */ 7471 /* Get the three pattern arguments: start, middle, end. */
6682 spat = get_var_string(&argvars[0]); 7472 spat = get_vartv_string(&argvars[0]);
6683 mpat = get_var_string_buf(&argvars[1], nbuf1); 7473 mpat = get_vartv_string_buf(&argvars[1], nbuf1);
6684 epat = get_var_string_buf(&argvars[2], nbuf2); 7474 epat = get_vartv_string_buf(&argvars[2], nbuf2);
6685 7475
6686 /* Make two search patterns: start/end (pat2, for in nested pairs) and 7476 /* Make two search patterns: start/end (pat2, for in nested pairs) and
6687 * start/middle/end (pat3, for the top pair). */ 7477 * start/middle/end (pat3, for the top pair). */
6688 pat2 = alloc((unsigned)(STRLEN(spat) + STRLEN(epat) + 15)); 7478 pat2 = alloc((unsigned)(STRLEN(spat) + STRLEN(epat) + 15));
6689 pat3 = alloc((unsigned)(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 23)); 7479 pat3 = alloc((unsigned)(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 23));
6700 dir = get_search_arg(&argvars[3], &flags); /* may set p_ws */ 7490 dir = get_search_arg(&argvars[3], &flags); /* may set p_ws */
6701 if (dir == 0) 7491 if (dir == 0)
6702 goto theend; 7492 goto theend;
6703 7493
6704 /* Optional fifth argument: skip expresion */ 7494 /* Optional fifth argument: skip expresion */
6705 if (argvars[3].var_type == VAR_UNKNOWN 7495 if (argvars[3].v_type == VAR_UNKNOWN
6706 || argvars[4].var_type == VAR_UNKNOWN) 7496 || argvars[4].v_type == VAR_UNKNOWN)
6707 skip = (char_u *)""; 7497 skip = (char_u *)"";
6708 else 7498 else
6709 skip = get_var_string_buf(&argvars[4], nbuf3); 7499 skip = get_vartv_string_buf(&argvars[4], nbuf3);
6710 7500
6711 save_cursor = curwin->w_cursor; 7501 save_cursor = curwin->w_cursor;
6712 pos = curwin->w_cursor; 7502 pos = curwin->w_cursor;
6713 firstpos.lnum = 0; 7503 firstpos.lnum = 0;
6714 pat = pat3; 7504 pat = pat3;
6732 curwin->w_cursor = save_pos; 7522 curwin->w_cursor = save_pos;
6733 if (err) 7523 if (err)
6734 { 7524 {
6735 /* Evaluating {skip} caused an error, break here. */ 7525 /* Evaluating {skip} caused an error, break here. */
6736 curwin->w_cursor = save_cursor; 7526 curwin->w_cursor = save_cursor;
6737 retvar->var_val.var_number = -1; 7527 retvar->vval.v_number = -1;
6738 break; 7528 break;
6739 } 7529 }
6740 if (r) 7530 if (r)
6741 continue; 7531 continue;
6742 } 7532 }
6758 7548
6759 if (nest == 0) 7549 if (nest == 0)
6760 { 7550 {
6761 /* Found the match: return matchcount or line number. */ 7551 /* Found the match: return matchcount or line number. */
6762 if (flags & SP_RETCOUNT) 7552 if (flags & SP_RETCOUNT)
6763 ++retvar->var_val.var_number; 7553 ++retvar->vval.v_number;
6764 else 7554 else
6765 retvar->var_val.var_number = pos.lnum; 7555 retvar->vval.v_number = pos.lnum;
6766 curwin->w_cursor = pos; 7556 curwin->w_cursor = pos;
6767 if (!(flags & SP_REPEAT)) 7557 if (!(flags & SP_REPEAT))
6768 break; 7558 break;
6769 nest = 1; /* search for next unmatched */ 7559 nest = 1; /* search for next unmatched */
6770 } 7560 }
6771 } 7561 }
6772 7562
6773 /* If 'n' flag is used or search failed: restore cursor position. */ 7563 /* If 'n' flag is used or search failed: restore cursor position. */
6774 if ((flags & SP_NOMOVE) || retvar->var_val.var_number == 0) 7564 if ((flags & SP_NOMOVE) || retvar->vval.v_number == 0)
6775 curwin->w_cursor = save_cursor; 7565 curwin->w_cursor = save_cursor;
6776 7566
6777 theend: 7567 theend:
6778 vim_free(pat2); 7568 vim_free(pat2);
6779 vim_free(pat3); 7569 vim_free(pat3);
6786 * Possibly sets "p_ws". 7576 * Possibly sets "p_ws".
6787 * Returns BACKWARD, FORWARD or zero (for an error). 7577 * Returns BACKWARD, FORWARD or zero (for an error).
6788 */ 7578 */
6789 static int 7579 static int
6790 get_search_arg(varp, flagsp) 7580 get_search_arg(varp, flagsp)
6791 VAR varp; 7581 typeval *varp;
6792 int *flagsp; 7582 int *flagsp;
6793 { 7583 {
6794 int dir = FORWARD; 7584 int dir = FORWARD;
6795 char_u *flags; 7585 char_u *flags;
6796 char_u nbuf[NUMBUFLEN]; 7586 char_u nbuf[NUMBUFLEN];
6797 int mask; 7587 int mask;
6798 7588
6799 if (varp->var_type != VAR_UNKNOWN) 7589 if (varp->v_type != VAR_UNKNOWN)
6800 { 7590 {
6801 flags = get_var_string_buf(varp, nbuf); 7591 flags = get_vartv_string_buf(varp, nbuf);
6802 while (*flags != NUL) 7592 while (*flags != NUL)
6803 { 7593 {
6804 switch (*flags) 7594 switch (*flags)
6805 { 7595 {
6806 case 'b': dir = BACKWARD; break; 7596 case 'b': dir = BACKWARD; break;
6834 * "setbufvar()" function 7624 * "setbufvar()" function
6835 */ 7625 */
6836 /*ARGSUSED*/ 7626 /*ARGSUSED*/
6837 static void 7627 static void
6838 f_setbufvar(argvars, retvar) 7628 f_setbufvar(argvars, retvar)
6839 VAR argvars; 7629 typeval *argvars;
6840 VAR retvar; 7630 typeval *retvar;
6841 { 7631 {
6842 buf_T *buf; 7632 buf_T *buf;
6843 #ifdef FEAT_AUTOCMD 7633 #ifdef FEAT_AUTOCMD
6844 aco_save_T aco; 7634 aco_save_T aco;
6845 #else 7635 #else
6846 buf_T *save_curbuf; 7636 buf_T *save_curbuf;
6847 #endif 7637 #endif
6848 char_u *varname, *bufvarname; 7638 char_u *varname, *bufvarname;
6849 VAR varp; 7639 typeval *varp;
6850 char_u nbuf[NUMBUFLEN]; 7640 char_u nbuf[NUMBUFLEN];
6851 7641
6852 if (check_restricted() || check_secure()) 7642 if (check_restricted() || check_secure())
6853 return; 7643 return;
6854 ++emsg_off; 7644 ++emsg_off;
6855 buf = get_buf_var(&argvars[0]); 7645 buf = get_buf_vartv(&argvars[0]);
6856 varname = get_var_string(&argvars[1]); 7646 varname = get_vartv_string(&argvars[1]);
6857 varp = &argvars[2]; 7647 varp = &argvars[2];
6858 7648
6859 if (buf != NULL && varname != NULL && varp != NULL) 7649 if (buf != NULL && varname != NULL && varp != NULL)
6860 { 7650 {
6861 /* set curbuf to be our buf, temporarily */ 7651 /* set curbuf to be our buf, temporarily */
6867 #endif 7657 #endif
6868 7658
6869 if (*varname == '&') 7659 if (*varname == '&')
6870 { 7660 {
6871 ++varname; 7661 ++varname;
6872 set_option_value(varname, get_var_number(varp), 7662 set_option_value(varname, get_vartv_number(varp),
6873 get_var_string_buf(varp, nbuf), OPT_LOCAL); 7663 get_vartv_string_buf(varp, nbuf), OPT_LOCAL);
6874 } 7664 }
6875 else 7665 else
6876 { 7666 {
6877 bufvarname = alloc((unsigned)STRLEN(varname) + 3); 7667 bufvarname = alloc((unsigned)STRLEN(varname) + 3);
6878 if (bufvarname != NULL) 7668 if (bufvarname != NULL)
6897 /* 7687 /*
6898 * "setcmdpos()" function 7688 * "setcmdpos()" function
6899 */ 7689 */
6900 static void 7690 static void
6901 f_setcmdpos(argvars, retvar) 7691 f_setcmdpos(argvars, retvar)
6902 VAR argvars; 7692 typeval *argvars;
6903 VAR retvar; 7693 typeval *retvar;
6904 { 7694 {
6905 retvar->var_val.var_number = set_cmdline_pos( 7695 retvar->vval.v_number = set_cmdline_pos(
6906 (int)get_var_number(&argvars[0]) - 1); 7696 (int)get_vartv_number(&argvars[0]) - 1);
6907 } 7697 }
6908 7698
6909 /* 7699 /*
6910 * "setline()" function 7700 * "setline()" function
6911 */ 7701 */
6912 static void 7702 static void
6913 f_setline(argvars, retvar) 7703 f_setline(argvars, retvar)
6914 VAR argvars; 7704 typeval *argvars;
6915 VAR retvar; 7705 typeval *retvar;
6916 { 7706 {
6917 linenr_T lnum; 7707 linenr_T lnum;
6918 char_u *line; 7708 char_u *line;
6919 7709
6920 lnum = get_var_lnum(argvars); 7710 lnum = get_vartv_lnum(argvars);
6921 line = get_var_string(&argvars[1]); 7711 line = get_vartv_string(&argvars[1]);
6922 retvar->var_val.var_number = 1; /* FAIL is default */ 7712 retvar->vval.v_number = 1; /* FAIL is default */
6923 7713
6924 if (lnum >= 1 7714 if (lnum >= 1
6925 && lnum <= curbuf->b_ml.ml_line_count 7715 && lnum <= curbuf->b_ml.ml_line_count
6926 && u_savesub(lnum) == OK 7716 && u_savesub(lnum) == OK
6927 && ml_replace(lnum, line, TRUE) == OK) 7717 && ml_replace(lnum, line, TRUE) == OK)
6928 { 7718 {
6929 changed_bytes(lnum, 0); 7719 changed_bytes(lnum, 0);
6930 check_cursor_col(); 7720 check_cursor_col();
6931 retvar->var_val.var_number = 0; 7721 retvar->vval.v_number = 0;
6932 } 7722 }
6933 } 7723 }
6934 7724
6935 /* 7725 /*
6936 * "setreg()" function 7726 * "setreg()" function
6937 */ 7727 */
6938 static void 7728 static void
6939 f_setreg(argvars, retvar) 7729 f_setreg(argvars, retvar)
6940 VAR argvars; 7730 typeval *argvars;
6941 VAR retvar; 7731 typeval *retvar;
6942 { 7732 {
6943 int regname; 7733 int regname;
6944 char_u *strregname; 7734 char_u *strregname;
6945 char_u *stropt; 7735 char_u *stropt;
6946 int append; 7736 int append;
6949 7739
6950 block_len = -1; 7740 block_len = -1;
6951 yank_type = MAUTO; 7741 yank_type = MAUTO;
6952 append = FALSE; 7742 append = FALSE;
6953 7743
6954 strregname = get_var_string(argvars); 7744 strregname = get_vartv_string(argvars);
6955 retvar->var_val.var_number = 1; /* FAIL is default */ 7745 retvar->vval.v_number = 1; /* FAIL is default */
6956 7746
6957 regname = (strregname == NULL ? '"' : *strregname); 7747 regname = (strregname == NULL ? '"' : *strregname);
6958 if (regname == 0 || regname == '@') 7748 if (regname == 0 || regname == '@')
6959 regname = '"'; 7749 regname = '"';
6960 else if (regname == '=') 7750 else if (regname == '=')
6961 return; 7751 return;
6962 7752
6963 if (argvars[2].var_type != VAR_UNKNOWN) 7753 if (argvars[2].v_type != VAR_UNKNOWN)
6964 { 7754 {
6965 for (stropt = get_var_string(&argvars[2]); *stropt != NUL; ++stropt) 7755 for (stropt = get_vartv_string(&argvars[2]); *stropt != NUL; ++stropt)
6966 switch (*stropt) 7756 switch (*stropt)
6967 { 7757 {
6968 case 'a': case 'A': /* append */ 7758 case 'a': case 'A': /* append */
6969 append = TRUE; 7759 append = TRUE;
6970 break; 7760 break;
6986 break; 7776 break;
6987 #endif 7777 #endif
6988 } 7778 }
6989 } 7779 }
6990 7780
6991 write_reg_contents_ex(regname, get_var_string(&argvars[1]), -1, 7781 write_reg_contents_ex(regname, get_vartv_string(&argvars[1]), -1,
6992 append, yank_type, block_len); 7782 append, yank_type, block_len);
6993 retvar->var_val.var_number = 0; 7783 retvar->vval.v_number = 0;
6994 } 7784 }
6995 7785
6996 7786
6997 /* 7787 /*
6998 * "setwinvar(expr)" function 7788 * "setwinvar(expr)" function
6999 */ 7789 */
7000 /*ARGSUSED*/ 7790 /*ARGSUSED*/
7001 static void 7791 static void
7002 f_setwinvar(argvars, retvar) 7792 f_setwinvar(argvars, retvar)
7003 VAR argvars; 7793 typeval *argvars;
7004 VAR retvar; 7794 typeval *retvar;
7005 { 7795 {
7006 win_T *win; 7796 win_T *win;
7007 #ifdef FEAT_WINDOWS 7797 #ifdef FEAT_WINDOWS
7008 win_T *save_curwin; 7798 win_T *save_curwin;
7009 #endif 7799 #endif
7010 char_u *varname, *winvarname; 7800 char_u *varname, *winvarname;
7011 VAR varp; 7801 typeval *varp;
7012 char_u nbuf[NUMBUFLEN]; 7802 char_u nbuf[NUMBUFLEN];
7013 7803
7014 if (check_restricted() || check_secure()) 7804 if (check_restricted() || check_secure())
7015 return; 7805 return;
7016 ++emsg_off; 7806 ++emsg_off;
7017 win = find_win_by_nr(&argvars[0]); 7807 win = find_win_by_nr(&argvars[0]);
7018 varname = get_var_string(&argvars[1]); 7808 varname = get_vartv_string(&argvars[1]);
7019 varp = &argvars[2]; 7809 varp = &argvars[2];
7020 7810
7021 if (win != NULL && varname != NULL && varp != NULL) 7811 if (win != NULL && varname != NULL && varp != NULL)
7022 { 7812 {
7023 #ifdef FEAT_WINDOWS 7813 #ifdef FEAT_WINDOWS
7028 #endif 7818 #endif
7029 7819
7030 if (*varname == '&') 7820 if (*varname == '&')
7031 { 7821 {
7032 ++varname; 7822 ++varname;
7033 set_option_value(varname, get_var_number(varp), 7823 set_option_value(varname, get_vartv_number(varp),
7034 get_var_string_buf(varp, nbuf), OPT_LOCAL); 7824 get_vartv_string_buf(varp, nbuf), OPT_LOCAL);
7035 } 7825 }
7036 else 7826 else
7037 { 7827 {
7038 winvarname = alloc((unsigned)STRLEN(varname) + 3); 7828 winvarname = alloc((unsigned)STRLEN(varname) + 3);
7039 if (winvarname != NULL) 7829 if (winvarname != NULL)
7061 /* 7851 /*
7062 * "nextnonblank()" function 7852 * "nextnonblank()" function
7063 */ 7853 */
7064 static void 7854 static void
7065 f_nextnonblank(argvars, retvar) 7855 f_nextnonblank(argvars, retvar)
7066 VAR argvars; 7856 typeval *argvars;
7067 VAR retvar; 7857 typeval *retvar;
7068 { 7858 {
7069 linenr_T lnum; 7859 linenr_T lnum;
7070 7860
7071 for (lnum = get_var_lnum(argvars); ; ++lnum) 7861 for (lnum = get_vartv_lnum(argvars); ; ++lnum)
7072 { 7862 {
7073 if (lnum > curbuf->b_ml.ml_line_count) 7863 if (lnum > curbuf->b_ml.ml_line_count)
7074 { 7864 {
7075 lnum = 0; 7865 lnum = 0;
7076 break; 7866 break;
7077 } 7867 }
7078 if (*skipwhite(ml_get(lnum)) != NUL) 7868 if (*skipwhite(ml_get(lnum)) != NUL)
7079 break; 7869 break;
7080 } 7870 }
7081 retvar->var_val.var_number = lnum; 7871 retvar->vval.v_number = lnum;
7082 } 7872 }
7083 7873
7084 /* 7874 /*
7085 * "prevnonblank()" function 7875 * "prevnonblank()" function
7086 */ 7876 */
7087 static void 7877 static void
7088 f_prevnonblank(argvars, retvar) 7878 f_prevnonblank(argvars, retvar)
7089 VAR argvars; 7879 typeval *argvars;
7090 VAR retvar; 7880 typeval *retvar;
7091 { 7881 {
7092 linenr_T lnum; 7882 linenr_T lnum;
7093 7883
7094 lnum = get_var_lnum(argvars); 7884 lnum = get_vartv_lnum(argvars);
7095 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) 7885 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
7096 lnum = 0; 7886 lnum = 0;
7097 else 7887 else
7098 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL) 7888 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
7099 --lnum; 7889 --lnum;
7100 retvar->var_val.var_number = lnum; 7890 retvar->vval.v_number = lnum;
7101 } 7891 }
7102 7892
7103 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11) 7893 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
7104 static void make_connection __ARGS((void)); 7894 static void make_connection __ARGS((void));
7105 static int check_connection __ARGS((void)); 7895 static int check_connection __ARGS((void));
7133 #endif 7923 #endif
7134 7924
7135 /*ARGSUSED*/ 7925 /*ARGSUSED*/
7136 static void 7926 static void
7137 f_serverlist(argvars, retvar) 7927 f_serverlist(argvars, retvar)
7138 VAR argvars; 7928 typeval *argvars;
7139 VAR retvar; 7929 typeval *retvar;
7140 { 7930 {
7141 char_u *r = NULL; 7931 char_u *r = NULL;
7142 7932
7143 #ifdef FEAT_CLIENTSERVER 7933 #ifdef FEAT_CLIENTSERVER
7144 # ifdef WIN32 7934 # ifdef WIN32
7147 make_connection(); 7937 make_connection();
7148 if (X_DISPLAY != NULL) 7938 if (X_DISPLAY != NULL)
7149 r = serverGetVimNames(X_DISPLAY); 7939 r = serverGetVimNames(X_DISPLAY);
7150 # endif 7940 # endif
7151 #endif 7941 #endif
7152 retvar->var_type = VAR_STRING; 7942 retvar->v_type = VAR_STRING;
7153 retvar->var_val.var_string = r; 7943 retvar->vval.v_string = r;
7154 } 7944 }
7155 7945
7156 /*ARGSUSED*/ 7946 /*ARGSUSED*/
7157 static void 7947 static void
7158 f_remote_peek(argvars, retvar) 7948 f_remote_peek(argvars, retvar)
7159 VAR argvars; 7949 typeval *argvars;
7160 VAR retvar; 7950 typeval *retvar;
7161 { 7951 {
7162 #ifdef FEAT_CLIENTSERVER 7952 #ifdef FEAT_CLIENTSERVER
7163 var v; 7953 var v;
7164 char_u *s = NULL; 7954 char_u *s = NULL;
7165 # ifdef WIN32 7955 # ifdef WIN32
7166 int n = 0; 7956 int n = 0;
7167 # endif 7957 # endif
7168 7958
7169 if (check_restricted() || check_secure()) 7959 if (check_restricted() || check_secure())
7170 { 7960 {
7171 retvar->var_val.var_number = -1; 7961 retvar->vval.v_number = -1;
7172 return; 7962 return;
7173 } 7963 }
7174 # ifdef WIN32 7964 # ifdef WIN32
7175 sscanf(get_var_string(&argvars[0]), "%x", &n); 7965 sscanf(get_vartv_string(&argvars[0]), "%x", &n);
7176 if (n == 0) 7966 if (n == 0)
7177 retvar->var_val.var_number = -1; 7967 retvar->vval.v_number = -1;
7178 else 7968 else
7179 { 7969 {
7180 s = serverGetReply((HWND)n, FALSE, FALSE, FALSE); 7970 s = serverGetReply((HWND)n, FALSE, FALSE, FALSE);
7181 retvar->var_val.var_number = (s != NULL); 7971 retvar->vval.v_number = (s != NULL);
7182 } 7972 }
7183 # else 7973 # else
7184 retvar->var_val.var_number = 0; 7974 retvar->vval.v_number = 0;
7185 if (check_connection() == FAIL) 7975 if (check_connection() == FAIL)
7186 return; 7976 return;
7187 7977
7188 retvar->var_val.var_number = serverPeekReply(X_DISPLAY, 7978 retvar->vval.v_number = serverPeekReply(X_DISPLAY,
7189 serverStrToWin(get_var_string(&argvars[0])), &s); 7979 serverStrToWin(get_vartv_string(&argvars[0])), &s);
7190 # endif 7980 # endif
7191 7981
7192 if (argvars[1].var_type != VAR_UNKNOWN && retvar->var_val.var_number > 0) 7982 if (argvars[1].v_type != VAR_UNKNOWN && retvar->vval.v_number > 0)
7193 { 7983 {
7194 v.var_type = VAR_STRING; 7984 v.tv.v_type = VAR_STRING;
7195 v.var_val.var_string = vim_strsave(s); 7985 v.tv.vval.v_string = vim_strsave(s);
7196 set_var(get_var_string(&argvars[1]), &v, FALSE); 7986 set_var(get_vartv_string(&argvars[1]), &v.tv, FALSE);
7197 vim_free(v.var_val.var_string); 7987 vim_free(v.tv.vval.v_string);
7198 } 7988 }
7199 #else 7989 #else
7200 retvar->var_val.var_number = -1; 7990 retvar->vval.v_number = -1;
7201 #endif 7991 #endif
7202 } 7992 }
7203 7993
7204 /*ARGSUSED*/ 7994 /*ARGSUSED*/
7205 static void 7995 static void
7206 f_remote_read(argvars, retvar) 7996 f_remote_read(argvars, retvar)
7207 VAR argvars; 7997 typeval *argvars;
7208 VAR retvar; 7998 typeval *retvar;
7209 { 7999 {
7210 char_u *r = NULL; 8000 char_u *r = NULL;
7211 8001
7212 #ifdef FEAT_CLIENTSERVER 8002 #ifdef FEAT_CLIENTSERVER
7213 if (!check_restricted() && !check_secure()) 8003 if (!check_restricted() && !check_secure())
7214 { 8004 {
7215 # ifdef WIN32 8005 # ifdef WIN32
7216 /* The server's HWND is encoded in the 'id' parameter */ 8006 /* The server's HWND is encoded in the 'id' parameter */
7217 int n = 0; 8007 int n = 0;
7218 8008
7219 sscanf(get_var_string(&argvars[0]), "%x", &n); 8009 sscanf(get_vartv_string(&argvars[0]), "%x", &n);
7220 if (n != 0) 8010 if (n != 0)
7221 r = serverGetReply((HWND)n, FALSE, TRUE, TRUE); 8011 r = serverGetReply((HWND)n, FALSE, TRUE, TRUE);
7222 if (r == NULL) 8012 if (r == NULL)
7223 # else 8013 # else
7224 if (check_connection() == FAIL || serverReadReply(X_DISPLAY, 8014 if (check_connection() == FAIL || serverReadReply(X_DISPLAY,
7225 serverStrToWin(get_var_string(&argvars[0])), &r, FALSE) < 0) 8015 serverStrToWin(get_vartv_string(&argvars[0])), &r, FALSE) < 0)
7226 # endif 8016 # endif
7227 EMSG(_("E277: Unable to read a server reply")); 8017 EMSG(_("E277: Unable to read a server reply"));
7228 } 8018 }
7229 #endif 8019 #endif
7230 retvar->var_type = VAR_STRING; 8020 retvar->v_type = VAR_STRING;
7231 retvar->var_val.var_string = r; 8021 retvar->vval.v_string = r;
7232 } 8022 }
7233 8023
7234 /*ARGSUSED*/ 8024 /*ARGSUSED*/
7235 static void 8025 static void
7236 f_server2client(argvars, retvar) 8026 f_server2client(argvars, retvar)
7237 VAR argvars; 8027 typeval *argvars;
7238 VAR retvar; 8028 typeval *retvar;
7239 { 8029 {
7240 #ifdef FEAT_CLIENTSERVER 8030 #ifdef FEAT_CLIENTSERVER
7241 char_u buf[NUMBUFLEN]; 8031 char_u buf[NUMBUFLEN];
7242 char_u *server = get_var_string(&argvars[0]); 8032 char_u *server = get_vartv_string(&argvars[0]);
7243 char_u *reply = get_var_string_buf(&argvars[1], buf); 8033 char_u *reply = get_vartv_string_buf(&argvars[1], buf);
7244 8034
7245 retvar->var_val.var_number = -1; 8035 retvar->vval.v_number = -1;
7246 if (check_restricted() || check_secure()) 8036 if (check_restricted() || check_secure())
7247 return; 8037 return;
7248 # ifdef FEAT_X11 8038 # ifdef FEAT_X11
7249 if (check_connection() == FAIL) 8039 if (check_connection() == FAIL)
7250 return; 8040 return;
7253 if (serverSendReply(server, reply) < 0) 8043 if (serverSendReply(server, reply) < 0)
7254 { 8044 {
7255 EMSG(_("E258: Unable to send to client")); 8045 EMSG(_("E258: Unable to send to client"));
7256 return; 8046 return;
7257 } 8047 }
7258 retvar->var_val.var_number = 0; 8048 retvar->vval.v_number = 0;
7259 #else 8049 #else
7260 retvar->var_val.var_number = -1; 8050 retvar->vval.v_number = -1;
7261 #endif 8051 #endif
7262 } 8052 }
7263 8053
7264 #ifdef FEAT_CLIENTSERVER 8054 #ifdef FEAT_CLIENTSERVER
7265 static void remote_common __ARGS((VAR argvars, VAR retvar, int expr)); 8055 static void remote_common __ARGS((typeval *argvars, typeval *retvar, int expr));
7266 8056
7267 static void 8057 static void
7268 remote_common(argvars, retvar, expr) 8058 remote_common(argvars, retvar, expr)
7269 VAR argvars; 8059 typeval *argvars;
7270 VAR retvar; 8060 typeval *retvar;
7271 int expr; 8061 int expr;
7272 { 8062 {
7273 char_u *server_name; 8063 char_u *server_name;
7274 char_u *keys; 8064 char_u *keys;
7275 char_u *r = NULL; 8065 char_u *r = NULL;
7286 # ifdef FEAT_X11 8076 # ifdef FEAT_X11
7287 if (check_connection() == FAIL) 8077 if (check_connection() == FAIL)
7288 return; 8078 return;
7289 # endif 8079 # endif
7290 8080
7291 server_name = get_var_string(&argvars[0]); 8081 server_name = get_vartv_string(&argvars[0]);
7292 keys = get_var_string_buf(&argvars[1], buf); 8082 keys = get_vartv_string_buf(&argvars[1], buf);
7293 # ifdef WIN32 8083 # ifdef WIN32
7294 if (serverSendToVim(server_name, keys, &r, &w, expr, TRUE) < 0) 8084 if (serverSendToVim(server_name, keys, &r, &w, expr, TRUE) < 0)
7295 # else 8085 # else
7296 if (serverSendToVim(X_DISPLAY, server_name, keys, &r, &w, expr, 0, TRUE) 8086 if (serverSendToVim(X_DISPLAY, server_name, keys, &r, &w, expr, 0, TRUE)
7297 < 0) 8087 < 0)
7302 else 8092 else
7303 EMSG2(_("E241: Unable to send to %s"), server_name); 8093 EMSG2(_("E241: Unable to send to %s"), server_name);
7304 return; 8094 return;
7305 } 8095 }
7306 8096
7307 retvar->var_val.var_string = r; 8097 retvar->vval.v_string = r;
7308 8098
7309 if (argvars[2].var_type != VAR_UNKNOWN) 8099 if (argvars[2].v_type != VAR_UNKNOWN)
7310 { 8100 {
7311 var v; 8101 var v;
7312 char_u str[30]; 8102 char_u str[30];
7313 8103
7314 sprintf((char *)str, "0x%x", (unsigned int)w); 8104 sprintf((char *)str, "0x%x", (unsigned int)w);
7315 v.var_type = VAR_STRING; 8105 v.tv.v_type = VAR_STRING;
7316 v.var_val.var_string = vim_strsave(str); 8106 v.tv.vval.v_string = vim_strsave(str);
7317 set_var(get_var_string(&argvars[2]), &v, FALSE); 8107 set_var(get_vartv_string(&argvars[2]), &v.tv, FALSE);
7318 vim_free(v.var_val.var_string); 8108 vim_free(v.tv.vval.v_string);
7319 } 8109 }
7320 } 8110 }
7321 #endif 8111 #endif
7322 8112
7323 /* 8113 /*
7324 * "remote_expr()" function 8114 * "remote_expr()" function
7325 */ 8115 */
7326 /*ARGSUSED*/ 8116 /*ARGSUSED*/
7327 static void 8117 static void
7328 f_remote_expr(argvars, retvar) 8118 f_remote_expr(argvars, retvar)
7329 VAR argvars; 8119 typeval *argvars;
7330 VAR retvar; 8120 typeval *retvar;
7331 { 8121 {
7332 retvar->var_type = VAR_STRING; 8122 retvar->v_type = VAR_STRING;
7333 retvar->var_val.var_string = NULL; 8123 retvar->vval.v_string = NULL;
7334 #ifdef FEAT_CLIENTSERVER 8124 #ifdef FEAT_CLIENTSERVER
7335 remote_common(argvars, retvar, TRUE); 8125 remote_common(argvars, retvar, TRUE);
7336 #endif 8126 #endif
7337 } 8127 }
7338 8128
7340 * "remote_send()" function 8130 * "remote_send()" function
7341 */ 8131 */
7342 /*ARGSUSED*/ 8132 /*ARGSUSED*/
7343 static void 8133 static void
7344 f_remote_send(argvars, retvar) 8134 f_remote_send(argvars, retvar)
7345 VAR argvars; 8135 typeval *argvars;
7346 VAR retvar; 8136 typeval *retvar;
7347 { 8137 {
7348 retvar->var_type = VAR_STRING; 8138 retvar->v_type = VAR_STRING;
7349 retvar->var_val.var_string = NULL; 8139 retvar->vval.v_string = NULL;
7350 #ifdef FEAT_CLIENTSERVER 8140 #ifdef FEAT_CLIENTSERVER
7351 remote_common(argvars, retvar, FALSE); 8141 remote_common(argvars, retvar, FALSE);
7352 #endif 8142 #endif
7353 } 8143 }
7354 8144
7356 * "remote_foreground()" function 8146 * "remote_foreground()" function
7357 */ 8147 */
7358 /*ARGSUSED*/ 8148 /*ARGSUSED*/
7359 static void 8149 static void
7360 f_remote_foreground(argvars, retvar) 8150 f_remote_foreground(argvars, retvar)
7361 VAR argvars; 8151 typeval *argvars;
7362 VAR retvar; 8152 typeval *retvar;
7363 { 8153 {
7364 retvar->var_val.var_number = 0; 8154 retvar->vval.v_number = 0;
7365 #ifdef FEAT_CLIENTSERVER 8155 #ifdef FEAT_CLIENTSERVER
7366 # ifdef WIN32 8156 # ifdef WIN32
7367 /* On Win32 it's done in this application. */ 8157 /* On Win32 it's done in this application. */
7368 serverForeground(get_var_string(&argvars[0])); 8158 serverForeground(get_vartv_string(&argvars[0]));
7369 # else 8159 # else
7370 /* Send a foreground() expression to the server. */ 8160 /* Send a foreground() expression to the server. */
7371 argvars[1].var_type = VAR_STRING; 8161 argvars[1].v_type = VAR_STRING;
7372 argvars[1].var_val.var_string = vim_strsave((char_u *)"foreground()"); 8162 argvars[1].vval.v_string = vim_strsave((char_u *)"foreground()");
7373 argvars[2].var_type = VAR_UNKNOWN; 8163 argvars[2].v_type = VAR_UNKNOWN;
7374 remote_common(argvars, retvar, TRUE); 8164 remote_common(argvars, retvar, TRUE);
7375 vim_free(argvars[1].var_val.var_string); 8165 vim_free(argvars[1].vval.v_string);
7376 # endif 8166 # endif
7377 #endif 8167 #endif
7378 } 8168 }
7379 8169
7380 /* 8170 /*
7381 * "repeat()" function 8171 * "repeat()" function
7382 */ 8172 */
7383 /*ARGSUSED*/ 8173 /*ARGSUSED*/
7384 static void 8174 static void
7385 f_repeat(argvars, retvar) 8175 f_repeat(argvars, retvar)
7386 VAR argvars; 8176 typeval *argvars;
7387 VAR retvar; 8177 typeval *retvar;
7388 { 8178 {
7389 char_u *p; 8179 char_u *p;
7390 int n; 8180 int n;
7391 int slen; 8181 int slen;
7392 int len; 8182 int len;
7393 char_u *r; 8183 char_u *r;
7394 int i; 8184 int i;
7395 8185
7396 p = get_var_string(&argvars[0]); 8186 p = get_vartv_string(&argvars[0]);
7397 n = get_var_number(&argvars[1]); 8187 n = get_vartv_number(&argvars[1]);
7398 8188
7399 retvar->var_type = VAR_STRING; 8189 retvar->v_type = VAR_STRING;
7400 retvar->var_val.var_string = NULL; 8190 retvar->vval.v_string = NULL;
7401 8191
7402 slen = (int)STRLEN(p); 8192 slen = (int)STRLEN(p);
7403 len = slen * n; 8193 len = slen * n;
7404 8194
7405 if (len <= 0) 8195 if (len <= 0)
7411 for (i = 0; i < n; i++) 8201 for (i = 0; i < n; i++)
7412 mch_memmove(r + i * slen, p, (size_t)slen); 8202 mch_memmove(r + i * slen, p, (size_t)slen);
7413 r[len] = NUL; 8203 r[len] = NUL;
7414 } 8204 }
7415 8205
7416 retvar->var_val.var_string = r; 8206 retvar->vval.v_string = r;
7417 } 8207 }
7418 8208
7419 #ifdef HAVE_STRFTIME 8209 #ifdef HAVE_STRFTIME
7420 /* 8210 /*
7421 * "strftime({format}[, {time}])" function 8211 * "strftime({format}[, {time}])" function
7422 */ 8212 */
7423 static void 8213 static void
7424 f_strftime(argvars, retvar) 8214 f_strftime(argvars, retvar)
7425 VAR argvars; 8215 typeval *argvars;
7426 VAR retvar; 8216 typeval *retvar;
7427 { 8217 {
7428 char_u result_buf[256]; 8218 char_u result_buf[256];
7429 struct tm *curtime; 8219 struct tm *curtime;
7430 time_t seconds; 8220 time_t seconds;
7431 char_u *p; 8221 char_u *p;
7432 8222
7433 retvar->var_type = VAR_STRING; 8223 retvar->v_type = VAR_STRING;
7434 8224
7435 p = get_var_string(&argvars[0]); 8225 p = get_vartv_string(&argvars[0]);
7436 if (argvars[1].var_type == VAR_UNKNOWN) 8226 if (argvars[1].v_type == VAR_UNKNOWN)
7437 seconds = time(NULL); 8227 seconds = time(NULL);
7438 else 8228 else
7439 seconds = (time_t)get_var_number(&argvars[1]); 8229 seconds = (time_t)get_vartv_number(&argvars[1]);
7440 curtime = localtime(&seconds); 8230 curtime = localtime(&seconds);
7441 /* MSVC returns NULL for an invalid value of seconds. */ 8231 /* MSVC returns NULL for an invalid value of seconds. */
7442 if (curtime == NULL) 8232 if (curtime == NULL)
7443 retvar->var_val.var_string = vim_strsave((char_u *)_("(Invalid)")); 8233 retvar->vval.v_string = vim_strsave((char_u *)_("(Invalid)"));
7444 else 8234 else
7445 { 8235 {
7446 # ifdef FEAT_MBYTE 8236 # ifdef FEAT_MBYTE
7447 vimconv_T conv; 8237 vimconv_T conv;
7448 char_u *enc; 8238 char_u *enc;
7462 # ifdef FEAT_MBYTE 8252 # ifdef FEAT_MBYTE
7463 if (conv.vc_type != CONV_NONE) 8253 if (conv.vc_type != CONV_NONE)
7464 vim_free(p); 8254 vim_free(p);
7465 convert_setup(&conv, enc, p_enc); 8255 convert_setup(&conv, enc, p_enc);
7466 if (conv.vc_type != CONV_NONE) 8256 if (conv.vc_type != CONV_NONE)
7467 retvar->var_val.var_string = 8257 retvar->vval.v_string = string_convert(&conv, result_buf, NULL);
7468 string_convert(&conv, result_buf, NULL);
7469 else 8258 else
7470 # endif 8259 # endif
7471 retvar->var_val.var_string = vim_strsave(result_buf); 8260 retvar->vval.v_string = vim_strsave(result_buf);
7472 8261
7473 # ifdef FEAT_MBYTE 8262 # ifdef FEAT_MBYTE
7474 /* Release conversion descriptors */ 8263 /* Release conversion descriptors */
7475 convert_setup(&conv, NULL, NULL); 8264 convert_setup(&conv, NULL, NULL);
7476 vim_free(enc); 8265 vim_free(enc);
7482 /* 8271 /*
7483 * "stridx()" function 8272 * "stridx()" function
7484 */ 8273 */
7485 static void 8274 static void
7486 f_stridx(argvars, retvar) 8275 f_stridx(argvars, retvar)
7487 VAR argvars; 8276 typeval *argvars;
7488 VAR retvar; 8277 typeval *retvar;
7489 { 8278 {
7490 char_u buf[NUMBUFLEN]; 8279 char_u buf[NUMBUFLEN];
7491 char_u *needle; 8280 char_u *needle;
7492 char_u *haystack; 8281 char_u *haystack;
7493 char_u *pos; 8282 char_u *pos;
7494 8283
7495 needle = get_var_string(&argvars[1]); 8284 needle = get_vartv_string(&argvars[1]);
7496 haystack = get_var_string_buf(&argvars[0], buf); 8285 haystack = get_vartv_string_buf(&argvars[0], buf);
7497 pos = (char_u *)strstr((char *)haystack, (char *)needle); 8286 pos = (char_u *)strstr((char *)haystack, (char *)needle);
7498 8287
7499 if (pos == NULL) 8288 if (pos == NULL)
7500 retvar->var_val.var_number = -1; 8289 retvar->vval.v_number = -1;
7501 else 8290 else
7502 retvar->var_val.var_number = (varnumber_T) (pos - haystack); 8291 retvar->vval.v_number = (varnumber_T) (pos - haystack);
7503 } 8292 }
7504 8293
7505 /* 8294 /*
7506 * "strridx()" function 8295 * "strridx()" function
7507 */ 8296 */
7508 static void 8297 static void
7509 f_strridx(argvars, retvar) 8298 f_strridx(argvars, retvar)
7510 VAR argvars; 8299 typeval *argvars;
7511 VAR retvar; 8300 typeval *retvar;
7512 { 8301 {
7513 char_u buf[NUMBUFLEN]; 8302 char_u buf[NUMBUFLEN];
7514 char_u *needle; 8303 char_u *needle;
7515 char_u *haystack; 8304 char_u *haystack;
7516 char_u *rest; 8305 char_u *rest;
7517 char_u *lastmatch = NULL; 8306 char_u *lastmatch = NULL;
7518 8307
7519 needle = get_var_string(&argvars[1]); 8308 needle = get_vartv_string(&argvars[1]);
7520 haystack = get_var_string_buf(&argvars[0], buf); 8309 haystack = get_vartv_string_buf(&argvars[0], buf);
7521 if (*needle == NUL) 8310 if (*needle == NUL)
7522 /* Empty string matches past the end. */ 8311 /* Empty string matches past the end. */
7523 lastmatch = haystack + STRLEN(haystack); 8312 lastmatch = haystack + STRLEN(haystack);
7524 else 8313 else
7525 for (rest = haystack; *rest != '\0'; ++rest) 8314 for (rest = haystack; *rest != '\0'; ++rest)
7529 break; 8318 break;
7530 lastmatch = rest; 8319 lastmatch = rest;
7531 } 8320 }
7532 8321
7533 if (lastmatch == NULL) 8322 if (lastmatch == NULL)
7534 retvar->var_val.var_number = -1; 8323 retvar->vval.v_number = -1;
7535 else 8324 else
7536 retvar->var_val.var_number = (varnumber_T)(lastmatch - haystack); 8325 retvar->vval.v_number = (varnumber_T)(lastmatch - haystack);
8326 }
8327
8328 /*
8329 * "string()" function
8330 */
8331 static void
8332 f_string(argvars, retvar)
8333 typeval *argvars;
8334 typeval *retvar;
8335 {
8336 char_u *tofree;
8337
8338 retvar->v_type = VAR_STRING;
8339 retvar->vval.v_string = tv2string(&argvars[0], &tofree);
8340 if (tofree == NULL)
8341 retvar->vval.v_string = vim_strsave(retvar->vval.v_string);
7537 } 8342 }
7538 8343
7539 /* 8344 /*
7540 * "strlen()" function 8345 * "strlen()" function
7541 */ 8346 */
7542 static void 8347 static void
7543 f_strlen(argvars, retvar) 8348 f_strlen(argvars, retvar)
7544 VAR argvars; 8349 typeval *argvars;
7545 VAR retvar; 8350 typeval *retvar;
7546 { 8351 {
7547 retvar->var_val.var_number = (varnumber_T) (STRLEN(get_var_string(&argvars[0]))); 8352 retvar->vval.v_number = (varnumber_T)(STRLEN(
8353 get_vartv_string(&argvars[0])));
7548 } 8354 }
7549 8355
7550 /* 8356 /*
7551 * "strpart()" function 8357 * "strpart()" function
7552 */ 8358 */
7553 static void 8359 static void
7554 f_strpart(argvars, retvar) 8360 f_strpart(argvars, retvar)
7555 VAR argvars; 8361 typeval *argvars;
7556 VAR retvar; 8362 typeval *retvar;
7557 { 8363 {
7558 char_u *p; 8364 char_u *p;
7559 int n; 8365 int n;
7560 int len; 8366 int len;
7561 int slen; 8367 int slen;
7562 8368
7563 p = get_var_string(&argvars[0]); 8369 p = get_vartv_string(&argvars[0]);
7564 slen = (int)STRLEN(p); 8370 slen = (int)STRLEN(p);
7565 8371
7566 n = get_var_number(&argvars[1]); 8372 n = get_vartv_number(&argvars[1]);
7567 if (argvars[2].var_type != VAR_UNKNOWN) 8373 if (argvars[2].v_type != VAR_UNKNOWN)
7568 len = get_var_number(&argvars[2]); 8374 len = get_vartv_number(&argvars[2]);
7569 else 8375 else
7570 len = slen - n; /* default len: all bytes that are available. */ 8376 len = slen - n; /* default len: all bytes that are available. */
7571 8377
7572 /* 8378 /*
7573 * Only return the overlap between the specified part and the actual 8379 * Only return the overlap between the specified part and the actual
7583 if (len < 0) 8389 if (len < 0)
7584 len = 0; 8390 len = 0;
7585 else if (n + len > slen) 8391 else if (n + len > slen)
7586 len = slen - n; 8392 len = slen - n;
7587 8393
7588 retvar->var_type = VAR_STRING; 8394 retvar->v_type = VAR_STRING;
7589 retvar->var_val.var_string = vim_strnsave(p + n, len); 8395 retvar->vval.v_string = vim_strnsave(p + n, len);
7590 } 8396 }
7591 8397
7592 /* 8398 /*
7593 * "strtrans()" function 8399 * "strtrans()" function
7594 */ 8400 */
7595 static void 8401 static void
7596 f_strtrans(argvars, retvar) 8402 f_strtrans(argvars, retvar)
7597 VAR argvars; 8403 typeval *argvars;
7598 VAR retvar; 8404 typeval *retvar;
7599 { 8405 {
7600 retvar->var_type = VAR_STRING; 8406 retvar->v_type = VAR_STRING;
7601 retvar->var_val.var_string = transstr(get_var_string(&argvars[0])); 8407 retvar->vval.v_string = transstr(get_vartv_string(&argvars[0]));
7602 } 8408 }
7603 8409
7604 /* 8410 /*
7605 * "synID(line, col, trans)" function 8411 * "synID(line, col, trans)" function
7606 */ 8412 */
7607 /*ARGSUSED*/ 8413 /*ARGSUSED*/
7608 static void 8414 static void
7609 f_synID(argvars, retvar) 8415 f_synID(argvars, retvar)
7610 VAR argvars; 8416 typeval *argvars;
7611 VAR retvar; 8417 typeval *retvar;
7612 { 8418 {
7613 int id = 0; 8419 int id = 0;
7614 #ifdef FEAT_SYN_HL 8420 #ifdef FEAT_SYN_HL
7615 long line; 8421 long line;
7616 long col; 8422 long col;
7617 int trans; 8423 int trans;
7618 8424
7619 line = get_var_lnum(argvars); 8425 line = get_vartv_lnum(argvars);
7620 col = get_var_number(&argvars[1]) - 1; 8426 col = get_vartv_number(&argvars[1]) - 1;
7621 trans = get_var_number(&argvars[2]); 8427 trans = get_vartv_number(&argvars[2]);
7622 8428
7623 if (line >= 1 && line <= curbuf->b_ml.ml_line_count 8429 if (line >= 1 && line <= curbuf->b_ml.ml_line_count
7624 && col >= 0 && col < (long)STRLEN(ml_get(line))) 8430 && col >= 0 && col < (long)STRLEN(ml_get(line)))
7625 id = syn_get_id(line, col, trans); 8431 id = syn_get_id(line, col, trans);
7626 #endif 8432 #endif
7627 8433
7628 retvar->var_val.var_number = id; 8434 retvar->vval.v_number = id;
7629 } 8435 }
7630 8436
7631 /* 8437 /*
7632 * "synIDattr(id, what [, mode])" function 8438 * "synIDattr(id, what [, mode])" function
7633 */ 8439 */
7634 /*ARGSUSED*/ 8440 /*ARGSUSED*/
7635 static void 8441 static void
7636 f_synIDattr(argvars, retvar) 8442 f_synIDattr(argvars, retvar)
7637 VAR argvars; 8443 typeval *argvars;
7638 VAR retvar; 8444 typeval *retvar;
7639 { 8445 {
7640 char_u *p = NULL; 8446 char_u *p = NULL;
7641 #ifdef FEAT_SYN_HL 8447 #ifdef FEAT_SYN_HL
7642 int id; 8448 int id;
7643 char_u *what; 8449 char_u *what;
7644 char_u *mode; 8450 char_u *mode;
7645 char_u modebuf[NUMBUFLEN]; 8451 char_u modebuf[NUMBUFLEN];
7646 int modec; 8452 int modec;
7647 8453
7648 id = get_var_number(&argvars[0]); 8454 id = get_vartv_number(&argvars[0]);
7649 what = get_var_string(&argvars[1]); 8455 what = get_vartv_string(&argvars[1]);
7650 if (argvars[2].var_type != VAR_UNKNOWN) 8456 if (argvars[2].v_type != VAR_UNKNOWN)
7651 { 8457 {
7652 mode = get_var_string_buf(&argvars[2], modebuf); 8458 mode = get_vartv_string_buf(&argvars[2], modebuf);
7653 modec = TOLOWER_ASC(mode[0]); 8459 modec = TOLOWER_ASC(mode[0]);
7654 if (modec != 't' && modec != 'c' 8460 if (modec != 't' && modec != 'c'
7655 #ifdef FEAT_GUI 8461 #ifdef FEAT_GUI
7656 && modec != 'g' 8462 && modec != 'g'
7657 #endif 8463 #endif
7710 } 8516 }
7711 8517
7712 if (p != NULL) 8518 if (p != NULL)
7713 p = vim_strsave(p); 8519 p = vim_strsave(p);
7714 #endif 8520 #endif
7715 retvar->var_type = VAR_STRING; 8521 retvar->v_type = VAR_STRING;
7716 retvar->var_val.var_string = p; 8522 retvar->vval.v_string = p;
7717 } 8523 }
7718 8524
7719 /* 8525 /*
7720 * "synIDtrans(id)" function 8526 * "synIDtrans(id)" function
7721 */ 8527 */
7722 /*ARGSUSED*/ 8528 /*ARGSUSED*/
7723 static void 8529 static void
7724 f_synIDtrans(argvars, retvar) 8530 f_synIDtrans(argvars, retvar)
7725 VAR argvars; 8531 typeval *argvars;
7726 VAR retvar; 8532 typeval *retvar;
7727 { 8533 {
7728 int id; 8534 int id;
7729 8535
7730 #ifdef FEAT_SYN_HL 8536 #ifdef FEAT_SYN_HL
7731 id = get_var_number(&argvars[0]); 8537 id = get_vartv_number(&argvars[0]);
7732 8538
7733 if (id > 0) 8539 if (id > 0)
7734 id = syn_get_final_id(id); 8540 id = syn_get_final_id(id);
7735 else 8541 else
7736 #endif 8542 #endif
7737 id = 0; 8543 id = 0;
7738 8544
7739 retvar->var_val.var_number = id; 8545 retvar->vval.v_number = id;
7740 } 8546 }
7741 8547
7742 /* 8548 /*
7743 * "system()" function 8549 * "system()" function
7744 */ 8550 */
7745 static void 8551 static void
7746 f_system(argvars, retvar) 8552 f_system(argvars, retvar)
7747 VAR argvars; 8553 typeval *argvars;
7748 VAR retvar; 8554 typeval *retvar;
7749 { 8555 {
7750 char_u *res = NULL; 8556 char_u *res = NULL;
7751 char_u *p; 8557 char_u *p;
7752 char_u *infile = NULL; 8558 char_u *infile = NULL;
7753 char_u buf[NUMBUFLEN]; 8559 char_u buf[NUMBUFLEN];
7754 int err = FALSE; 8560 int err = FALSE;
7755 FILE *fd; 8561 FILE *fd;
7756 8562
7757 if (argvars[1].var_type != VAR_UNKNOWN) 8563 if (argvars[1].v_type != VAR_UNKNOWN)
7758 { 8564 {
7759 /* 8565 /*
7760 * Write the string to a temp file, to be used for input of the shell 8566 * Write the string to a temp file, to be used for input of the shell
7761 * command. 8567 * command.
7762 */ 8568 */
7770 if (fd == NULL) 8576 if (fd == NULL)
7771 { 8577 {
7772 EMSG2(_(e_notopen), infile); 8578 EMSG2(_(e_notopen), infile);
7773 goto done; 8579 goto done;
7774 } 8580 }
7775 p = get_var_string_buf(&argvars[1], buf); 8581 p = get_vartv_string_buf(&argvars[1], buf);
7776 if (fwrite(p, STRLEN(p), 1, fd) != 1) 8582 if (fwrite(p, STRLEN(p), 1, fd) != 1)
7777 err = TRUE; 8583 err = TRUE;
7778 if (fclose(fd) != 0) 8584 if (fclose(fd) != 0)
7779 err = TRUE; 8585 err = TRUE;
7780 if (err) 8586 if (err)
7782 EMSG(_("E677: Error writing temp file")); 8588 EMSG(_("E677: Error writing temp file"));
7783 goto done; 8589 goto done;
7784 } 8590 }
7785 } 8591 }
7786 8592
7787 res = get_cmd_output(get_var_string(&argvars[0]), infile, SHELL_SILENT); 8593 res = get_cmd_output(get_vartv_string(&argvars[0]), infile, SHELL_SILENT);
7788 8594
7789 #ifdef USE_CR 8595 #ifdef USE_CR
7790 /* translate <CR> into <NL> */ 8596 /* translate <CR> into <NL> */
7791 if (res != NULL) 8597 if (res != NULL)
7792 { 8598 {
7821 if (infile != NULL) 8627 if (infile != NULL)
7822 { 8628 {
7823 mch_remove(infile); 8629 mch_remove(infile);
7824 vim_free(infile); 8630 vim_free(infile);
7825 } 8631 }
7826 retvar->var_type = VAR_STRING; 8632 retvar->v_type = VAR_STRING;
7827 retvar->var_val.var_string = res; 8633 retvar->vval.v_string = res;
7828 } 8634 }
7829 8635
7830 /* 8636 /*
7831 * "submatch()" function 8637 * "submatch()" function
7832 */ 8638 */
7833 static void 8639 static void
7834 f_submatch(argvars, retvar) 8640 f_submatch(argvars, retvar)
7835 VAR argvars; 8641 typeval *argvars;
7836 VAR retvar; 8642 typeval *retvar;
7837 { 8643 {
7838 retvar->var_type = VAR_STRING; 8644 retvar->v_type = VAR_STRING;
7839 retvar->var_val.var_string = reg_submatch((int)get_var_number(&argvars[0])); 8645 retvar->vval.v_string = reg_submatch((int)get_vartv_number(&argvars[0]));
7840 } 8646 }
7841 8647
7842 /* 8648 /*
7843 * "substitute()" function 8649 * "substitute()" function
7844 */ 8650 */
7845 static void 8651 static void
7846 f_substitute(argvars, retvar) 8652 f_substitute(argvars, retvar)
7847 VAR argvars; 8653 typeval *argvars;
7848 VAR retvar; 8654 typeval *retvar;
7849 { 8655 {
7850 char_u patbuf[NUMBUFLEN]; 8656 char_u patbuf[NUMBUFLEN];
7851 char_u subbuf[NUMBUFLEN]; 8657 char_u subbuf[NUMBUFLEN];
7852 char_u flagsbuf[NUMBUFLEN]; 8658 char_u flagsbuf[NUMBUFLEN];
7853 8659
7854 retvar->var_type = VAR_STRING; 8660 retvar->v_type = VAR_STRING;
7855 retvar->var_val.var_string = do_string_sub( 8661 retvar->vval.v_string = do_string_sub(
7856 get_var_string(&argvars[0]), 8662 get_vartv_string(&argvars[0]),
7857 get_var_string_buf(&argvars[1], patbuf), 8663 get_vartv_string_buf(&argvars[1], patbuf),
7858 get_var_string_buf(&argvars[2], subbuf), 8664 get_vartv_string_buf(&argvars[2], subbuf),
7859 get_var_string_buf(&argvars[3], flagsbuf)); 8665 get_vartv_string_buf(&argvars[3], flagsbuf));
7860 } 8666 }
7861 8667
7862 /* 8668 /*
7863 * "tempname()" function 8669 * "tempname()" function
7864 */ 8670 */
7865 /*ARGSUSED*/ 8671 /*ARGSUSED*/
7866 static void 8672 static void
7867 f_tempname(argvars, retvar) 8673 f_tempname(argvars, retvar)
7868 VAR argvars; 8674 typeval *argvars;
7869 VAR retvar; 8675 typeval *retvar;
7870 { 8676 {
7871 static int x = 'A'; 8677 static int x = 'A';
7872 8678
7873 retvar->var_type = VAR_STRING; 8679 retvar->v_type = VAR_STRING;
7874 retvar->var_val.var_string = vim_tempname(x); 8680 retvar->vval.v_string = vim_tempname(x);
7875 8681
7876 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different 8682 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
7877 * names. Skip 'I' and 'O', they are used for shell redirection. */ 8683 * names. Skip 'I' and 'O', they are used for shell redirection. */
7878 do 8684 do
7879 { 8685 {
7898 /* 8704 /*
7899 * "tolower(string)" function 8705 * "tolower(string)" function
7900 */ 8706 */
7901 static void 8707 static void
7902 f_tolower(argvars, retvar) 8708 f_tolower(argvars, retvar)
7903 VAR argvars; 8709 typeval *argvars;
7904 VAR retvar; 8710 typeval *retvar;
7905 { 8711 {
7906 char_u *p; 8712 char_u *p;
7907 8713
7908 p = vim_strsave(get_var_string(&argvars[0])); 8714 p = vim_strsave(get_vartv_string(&argvars[0]));
7909 retvar->var_type = VAR_STRING; 8715 retvar->v_type = VAR_STRING;
7910 retvar->var_val.var_string = p; 8716 retvar->vval.v_string = p;
7911 8717
7912 if (p != NULL) 8718 if (p != NULL)
7913 while (*p != NUL) 8719 while (*p != NUL)
7914 { 8720 {
7915 #ifdef FEAT_MBYTE 8721 #ifdef FEAT_MBYTE
7941 /* 8747 /*
7942 * "toupper(string)" function 8748 * "toupper(string)" function
7943 */ 8749 */
7944 static void 8750 static void
7945 f_toupper(argvars, retvar) 8751 f_toupper(argvars, retvar)
7946 VAR argvars; 8752 typeval *argvars;
7947 VAR retvar; 8753 typeval *retvar;
7948 { 8754 {
7949 char_u *p; 8755 char_u *p;
7950 8756
7951 p = vim_strsave(get_var_string(&argvars[0])); 8757 p = vim_strsave(get_vartv_string(&argvars[0]));
7952 retvar->var_type = VAR_STRING; 8758 retvar->v_type = VAR_STRING;
7953 retvar->var_val.var_string = p; 8759 retvar->vval.v_string = p;
7954 8760
7955 if (p != NULL) 8761 if (p != NULL)
7956 while (*p != NUL) 8762 while (*p != NUL)
7957 { 8763 {
7958 #ifdef FEAT_MBYTE 8764 #ifdef FEAT_MBYTE
7984 /* 8790 /*
7985 * "tr(string, fromstr, tostr)" function 8791 * "tr(string, fromstr, tostr)" function
7986 */ 8792 */
7987 static void 8793 static void
7988 f_tr(argvars, retvar) 8794 f_tr(argvars, retvar)
7989 VAR argvars; 8795 typeval *argvars;
7990 VAR retvar; 8796 typeval *retvar;
7991 { 8797 {
7992 char_u *instr; 8798 char_u *instr;
7993 char_u *fromstr; 8799 char_u *fromstr;
7994 char_u *tostr; 8800 char_u *tostr;
7995 char_u *p; 8801 char_u *p;
8004 #endif 8810 #endif
8005 char_u buf[NUMBUFLEN]; 8811 char_u buf[NUMBUFLEN];
8006 char_u buf2[NUMBUFLEN]; 8812 char_u buf2[NUMBUFLEN];
8007 garray_T ga; 8813 garray_T ga;
8008 8814
8009 instr = get_var_string(&argvars[0]); 8815 instr = get_vartv_string(&argvars[0]);
8010 fromstr = get_var_string_buf(&argvars[1], buf); 8816 fromstr = get_vartv_string_buf(&argvars[1], buf);
8011 tostr = get_var_string_buf(&argvars[2], buf2); 8817 tostr = get_vartv_string_buf(&argvars[2], buf2);
8012 8818
8013 /* Default return value: empty string. */ 8819 /* Default return value: empty string. */
8014 retvar->var_type = VAR_STRING; 8820 retvar->v_type = VAR_STRING;
8015 retvar->var_val.var_string = NULL; 8821 retvar->vval.v_string = NULL;
8016 ga_init2(&ga, (int)sizeof(char), 80); 8822 ga_init2(&ga, (int)sizeof(char), 80);
8017 8823
8018 #ifdef FEAT_MBYTE 8824 #ifdef FEAT_MBYTE
8019 if (!has_mbyte) 8825 if (!has_mbyte)
8020 #endif 8826 #endif
8093 ga_append(&ga, *instr); 8899 ga_append(&ga, *instr);
8094 ++instr; 8900 ++instr;
8095 } 8901 }
8096 } 8902 }
8097 8903
8098 retvar->var_val.var_string = ga.ga_data; 8904 retvar->vval.v_string = ga.ga_data;
8099 } 8905 }
8100 8906
8101 /* 8907 /*
8102 * "type(expr)" function 8908 * "type(expr)" function
8103 */ 8909 */
8104 static void 8910 static void
8105 f_type(argvars, retvar) 8911 f_type(argvars, retvar)
8106 VAR argvars; 8912 typeval *argvars;
8107 VAR retvar; 8913 typeval *retvar;
8108 { 8914 {
8109 if (argvars[0].var_type == VAR_NUMBER) 8915 if (argvars[0].v_type == VAR_NUMBER)
8110 retvar->var_val.var_number = 0; 8916 retvar->vval.v_number = 0;
8111 else 8917 else
8112 retvar->var_val.var_number = 1; 8918 retvar->vval.v_number = 1;
8113 } 8919 }
8114 8920
8115 /* 8921 /*
8116 * "virtcol(string)" function 8922 * "virtcol(string)" function
8117 */ 8923 */
8118 static void 8924 static void
8119 f_virtcol(argvars, retvar) 8925 f_virtcol(argvars, retvar)
8120 VAR argvars; 8926 typeval *argvars;
8121 VAR retvar; 8927 typeval *retvar;
8122 { 8928 {
8123 colnr_T vcol = 0; 8929 colnr_T vcol = 0;
8124 pos_T *fp; 8930 pos_T *fp;
8125 8931
8126 fp = var2fpos(&argvars[0], FALSE); 8932 fp = var2fpos(&argvars[0], FALSE);
8128 { 8934 {
8129 getvvcol(curwin, fp, NULL, NULL, &vcol); 8935 getvvcol(curwin, fp, NULL, NULL, &vcol);
8130 ++vcol; 8936 ++vcol;
8131 } 8937 }
8132 8938
8133 retvar->var_val.var_number = vcol; 8939 retvar->vval.v_number = vcol;
8134 } 8940 }
8135 8941
8136 /* 8942 /*
8137 * "visualmode()" function 8943 * "visualmode()" function
8138 */ 8944 */
8139 /*ARGSUSED*/ 8945 /*ARGSUSED*/
8140 static void 8946 static void
8141 f_visualmode(argvars, retvar) 8947 f_visualmode(argvars, retvar)
8142 VAR argvars; 8948 typeval *argvars;
8143 VAR retvar; 8949 typeval *retvar;
8144 { 8950 {
8145 #ifdef FEAT_VISUAL 8951 #ifdef FEAT_VISUAL
8146 char_u str[2]; 8952 char_u str[2];
8147 8953
8148 retvar->var_type = VAR_STRING; 8954 retvar->v_type = VAR_STRING;
8149 str[0] = curbuf->b_visual_mode_eval; 8955 str[0] = curbuf->b_visual_mode_eval;
8150 str[1] = NUL; 8956 str[1] = NUL;
8151 retvar->var_val.var_string = vim_strsave(str); 8957 retvar->vval.v_string = vim_strsave(str);
8152 8958
8153 /* A non-zero number or non-empty string argument: reset mode. */ 8959 /* A non-zero number or non-empty string argument: reset mode. */
8154 if ((argvars[0].var_type == VAR_NUMBER 8960 if ((argvars[0].v_type == VAR_NUMBER
8155 && argvars[0].var_val.var_number != 0) 8961 && argvars[0].vval.v_number != 0)
8156 || (argvars[0].var_type == VAR_STRING 8962 || (argvars[0].v_type == VAR_STRING
8157 && *get_var_string(&argvars[0]) != NUL)) 8963 && *get_vartv_string(&argvars[0]) != NUL))
8158 curbuf->b_visual_mode_eval = NUL; 8964 curbuf->b_visual_mode_eval = NUL;
8159 #else 8965 #else
8160 retvar->var_val.var_number = 0; /* return anything, it won't work anyway */ 8966 retvar->vval.v_number = 0; /* return anything, it won't work anyway */
8161 #endif 8967 #endif
8162 } 8968 }
8163 8969
8164 /* 8970 /*
8165 * "winbufnr(nr)" function 8971 * "winbufnr(nr)" function
8166 */ 8972 */
8167 static void 8973 static void
8168 f_winbufnr(argvars, retvar) 8974 f_winbufnr(argvars, retvar)
8169 VAR argvars; 8975 typeval *argvars;
8170 VAR retvar; 8976 typeval *retvar;
8171 { 8977 {
8172 win_T *wp; 8978 win_T *wp;
8173 8979
8174 wp = find_win_by_nr(&argvars[0]); 8980 wp = find_win_by_nr(&argvars[0]);
8175 if (wp == NULL) 8981 if (wp == NULL)
8176 retvar->var_val.var_number = -1; 8982 retvar->vval.v_number = -1;
8177 else 8983 else
8178 retvar->var_val.var_number = wp->w_buffer->b_fnum; 8984 retvar->vval.v_number = wp->w_buffer->b_fnum;
8179 } 8985 }
8180 8986
8181 /* 8987 /*
8182 * "wincol()" function 8988 * "wincol()" function
8183 */ 8989 */
8184 /*ARGSUSED*/ 8990 /*ARGSUSED*/
8185 static void 8991 static void
8186 f_wincol(argvars, retvar) 8992 f_wincol(argvars, retvar)
8187 VAR argvars; 8993 typeval *argvars;
8188 VAR retvar; 8994 typeval *retvar;
8189 { 8995 {
8190 validate_cursor(); 8996 validate_cursor();
8191 retvar->var_val.var_number = curwin->w_wcol + 1; 8997 retvar->vval.v_number = curwin->w_wcol + 1;
8192 } 8998 }
8193 8999
8194 /* 9000 /*
8195 * "winheight(nr)" function 9001 * "winheight(nr)" function
8196 */ 9002 */
8197 static void 9003 static void
8198 f_winheight(argvars, retvar) 9004 f_winheight(argvars, retvar)
8199 VAR argvars; 9005 typeval *argvars;
8200 VAR retvar; 9006 typeval *retvar;
8201 { 9007 {
8202 win_T *wp; 9008 win_T *wp;
8203 9009
8204 wp = find_win_by_nr(&argvars[0]); 9010 wp = find_win_by_nr(&argvars[0]);
8205 if (wp == NULL) 9011 if (wp == NULL)
8206 retvar->var_val.var_number = -1; 9012 retvar->vval.v_number = -1;
8207 else 9013 else
8208 retvar->var_val.var_number = wp->w_height; 9014 retvar->vval.v_number = wp->w_height;
8209 } 9015 }
8210 9016
8211 /* 9017 /*
8212 * "winline()" function 9018 * "winline()" function
8213 */ 9019 */
8214 /*ARGSUSED*/ 9020 /*ARGSUSED*/
8215 static void 9021 static void
8216 f_winline(argvars, retvar) 9022 f_winline(argvars, retvar)
8217 VAR argvars; 9023 typeval *argvars;
8218 VAR retvar; 9024 typeval *retvar;
8219 { 9025 {
8220 validate_cursor(); 9026 validate_cursor();
8221 retvar->var_val.var_number = curwin->w_wrow + 1; 9027 retvar->vval.v_number = curwin->w_wrow + 1;
8222 } 9028 }
8223 9029
8224 /* 9030 /*
8225 * "winnr()" function 9031 * "winnr()" function
8226 */ 9032 */
8227 /* ARGSUSED */ 9033 /* ARGSUSED */
8228 static void 9034 static void
8229 f_winnr(argvars, retvar) 9035 f_winnr(argvars, retvar)
8230 VAR argvars; 9036 typeval *argvars;
8231 VAR retvar; 9037 typeval *retvar;
8232 { 9038 {
8233 int nr = 1; 9039 int nr = 1;
8234 #ifdef FEAT_WINDOWS 9040 #ifdef FEAT_WINDOWS
8235 win_T *wp; 9041 win_T *wp;
8236 win_T *twin = curwin; 9042 win_T *twin = curwin;
8237 char_u *arg; 9043 char_u *arg;
8238 9044
8239 if (argvars[0].var_type != VAR_UNKNOWN) 9045 if (argvars[0].v_type != VAR_UNKNOWN)
8240 { 9046 {
8241 arg = get_var_string(&argvars[0]); 9047 arg = get_vartv_string(&argvars[0]);
8242 if (STRCMP(arg, "$") == 0) 9048 if (STRCMP(arg, "$") == 0)
8243 twin = lastwin; 9049 twin = lastwin;
8244 else if (STRCMP(arg, "#") == 0) 9050 else if (STRCMP(arg, "#") == 0)
8245 { 9051 {
8246 twin = prevwin; 9052 twin = prevwin;
8256 9062
8257 if (nr > 0) 9063 if (nr > 0)
8258 for (wp = firstwin; wp != twin; wp = wp->w_next) 9064 for (wp = firstwin; wp != twin; wp = wp->w_next)
8259 ++nr; 9065 ++nr;
8260 #endif 9066 #endif
8261 retvar->var_val.var_number = nr; 9067 retvar->vval.v_number = nr;
8262 } 9068 }
8263 9069
8264 /* 9070 /*
8265 * "winrestcmd()" function 9071 * "winrestcmd()" function
8266 */ 9072 */
8267 /* ARGSUSED */ 9073 /* ARGSUSED */
8268 static void 9074 static void
8269 f_winrestcmd(argvars, retvar) 9075 f_winrestcmd(argvars, retvar)
8270 VAR argvars; 9076 typeval *argvars;
8271 VAR retvar; 9077 typeval *retvar;
8272 { 9078 {
8273 #ifdef FEAT_WINDOWS 9079 #ifdef FEAT_WINDOWS
8274 win_T *wp; 9080 win_T *wp;
8275 int winnr = 1; 9081 int winnr = 1;
8276 garray_T ga; 9082 garray_T ga;
8287 # endif 9093 # endif
8288 ++winnr; 9094 ++winnr;
8289 } 9095 }
8290 ga_append(&ga, NUL); 9096 ga_append(&ga, NUL);
8291 9097
8292 retvar->var_val.var_string = ga.ga_data; 9098 retvar->vval.v_string = ga.ga_data;
8293 #else 9099 #else
8294 retvar->var_val.var_string = NULL; 9100 retvar->vval.v_string = NULL;
8295 #endif 9101 #endif
8296 retvar->var_type = VAR_STRING; 9102 retvar->v_type = VAR_STRING;
8297 } 9103 }
8298 9104
8299 /* 9105 /*
8300 * "winwidth(nr)" function 9106 * "winwidth(nr)" function
8301 */ 9107 */
8302 static void 9108 static void
8303 f_winwidth(argvars, retvar) 9109 f_winwidth(argvars, retvar)
8304 VAR argvars; 9110 typeval *argvars;
8305 VAR retvar; 9111 typeval *retvar;
8306 { 9112 {
8307 win_T *wp; 9113 win_T *wp;
8308 9114
8309 wp = find_win_by_nr(&argvars[0]); 9115 wp = find_win_by_nr(&argvars[0]);
8310 if (wp == NULL) 9116 if (wp == NULL)
8311 retvar->var_val.var_number = -1; 9117 retvar->vval.v_number = -1;
8312 else 9118 else
8313 #ifdef FEAT_VERTSPLIT 9119 #ifdef FEAT_VERTSPLIT
8314 retvar->var_val.var_number = wp->w_width; 9120 retvar->vval.v_number = wp->w_width;
8315 #else 9121 #else
8316 retvar->var_val.var_number = Columns; 9122 retvar->vval.v_number = Columns;
8317 #endif 9123 #endif
8318 } 9124 }
8319 9125
8320 static win_T * 9126 static win_T *
8321 find_win_by_nr(vp) 9127 find_win_by_nr(vp)
8322 VAR vp; 9128 typeval *vp;
8323 { 9129 {
8324 #ifdef FEAT_WINDOWS 9130 #ifdef FEAT_WINDOWS
8325 win_T *wp; 9131 win_T *wp;
8326 #endif 9132 #endif
8327 int nr; 9133 int nr;
8328 9134
8329 nr = get_var_number(vp); 9135 nr = get_vartv_number(vp);
8330 9136
8331 #ifdef FEAT_WINDOWS 9137 #ifdef FEAT_WINDOWS
8332 if (nr == 0) 9138 if (nr == 0)
8333 return curwin; 9139 return curwin;
8334 9140
8346 /* 9152 /*
8347 * Translate a String variable into a position. 9153 * Translate a String variable into a position.
8348 */ 9154 */
8349 static pos_T * 9155 static pos_T *
8350 var2fpos(varp, lnum) 9156 var2fpos(varp, lnum)
8351 VAR varp; 9157 typeval *varp;
8352 int lnum; /* TRUE when $ is last line */ 9158 int lnum; /* TRUE when $ is last line */
8353 { 9159 {
8354 char_u *name; 9160 char_u *name;
8355 static pos_T pos; 9161 static pos_T pos;
8356 pos_T *pp; 9162 pos_T *pp;
8357 9163
8358 name = get_var_string(varp); 9164 name = get_vartv_string(varp);
8359 if (name[0] == '.') /* cursor */ 9165 if (name[0] == '.') /* cursor */
8360 return &curwin->w_cursor; 9166 return &curwin->w_cursor;
8361 if (name[0] == '\'') /* mark */ 9167 if (name[0] == '\'') /* mark */
8362 { 9168 {
8363 pp = getmark(name[1], FALSE); 9169 pp = getmark(name[1], FALSE);
8748 /* 9554 /*
8749 * Get the value of internal variable "name". 9555 * Get the value of internal variable "name".
8750 * Return OK or FAIL. 9556 * Return OK or FAIL.
8751 */ 9557 */
8752 static int 9558 static int
8753 get_var_var(name, len, retvar) 9559 get_var_vartv(name, len, retvar)
8754 char_u *name; 9560 char_u *name;
8755 int len; /* length of "name" */ 9561 int len; /* length of "name" */
8756 VAR retvar; /* NULL when only checking existence */ 9562 typeval *retvar; /* NULL when only checking existence */
8757 { 9563 {
8758 int ret = OK; 9564 int ret = OK;
8759 int type = VAR_UNKNOWN; 9565 typeval tv;
8760 long number = 1;
8761 char_u *string = NULL;
8762 VAR v; 9566 VAR v;
8763 int cc; 9567 int cc;
8764 int i; 9568 int i;
9569
9570 tv.v_type = VAR_UNKNOWN;
8765 9571
8766 /* truncate the name, so that we can use strcmp() */ 9572 /* truncate the name, so that we can use strcmp() */
8767 cc = name[len]; 9573 cc = name[len];
8768 name[len] = NUL; 9574 name[len] = NUL;
8769 9575
8770 /* 9576 /*
8771 * Check for "b:changedtick". 9577 * Check for "b:changedtick".
8772 */ 9578 */
8773 if (STRCMP(name, "b:changedtick") == 0) 9579 if (STRCMP(name, "b:changedtick") == 0)
8774 { 9580 {
8775 type = VAR_NUMBER; 9581 tv.v_type = VAR_NUMBER;
8776 number = curbuf->b_changedtick; 9582 tv.vval.v_number = curbuf->b_changedtick;
8777 } 9583 }
8778 9584
8779 /* 9585 /*
8780 * Check for built-in v: variables. 9586 * Check for built-in v: variables.
8781 */ 9587 */
8782 else if ((i = find_vim_var(name, len)) >= 0) 9588 else if ((i = find_vim_var(name, len)) >= 0)
8783 { 9589 {
8784 type = vimvars[i].type; 9590 tv.v_type = vimvars[i].type;
8785 number = (long)vimvars[i].val; 9591 if (tv.v_type == VAR_NUMBER)
8786 string = vimvars[i].val; 9592 tv.vval.v_number = (long)vimvars[i].val;
9593 else
9594 tv.vval.v_string = vimvars[i].val;
8787 } 9595 }
8788 9596
8789 /* 9597 /*
8790 * Check for user-defined variables. 9598 * Check for user-defined variables.
8791 */ 9599 */
8792 else 9600 else
8793 { 9601 {
8794 v = find_var(name, FALSE); 9602 v = find_var(name, FALSE);
8795 if (v != NULL) 9603 if (v != NULL)
8796 { 9604 tv = v->tv;
8797 type = v->var_type; 9605 }
8798 number = v->var_val.var_number; 9606
8799 string = v->var_val.var_string; 9607 if (tv.v_type == VAR_UNKNOWN)
8800 }
8801 }
8802
8803 if (type == VAR_UNKNOWN)
8804 { 9608 {
8805 if (retvar != NULL) 9609 if (retvar != NULL)
8806 EMSG2(_("E121: Undefined variable: %s"), name); 9610 EMSG2(_("E121: Undefined variable: %s"), name);
8807 ret = FAIL; 9611 ret = FAIL;
8808 } 9612 }
8809 else if (retvar != NULL) 9613 else if (retvar != NULL)
8810 { 9614 copy_vartv(&tv, retvar);
8811 retvar->var_type = type;
8812 if (type == VAR_NUMBER)
8813 retvar->var_val.var_number = number;
8814 else if (type == VAR_STRING)
8815 {
8816 if (string != NULL)
8817 string = vim_strsave(string);
8818 retvar->var_val.var_string = string;
8819 }
8820 }
8821 9615
8822 name[len] = cc; 9616 name[len] = cc;
8823 9617
8824 return ret; 9618 return ret;
8825 } 9619 }
8832 { 9626 {
8833 return (VAR)alloc_clear((unsigned)sizeof(var)); 9627 return (VAR)alloc_clear((unsigned)sizeof(var));
8834 } 9628 }
8835 9629
8836 /* 9630 /*
8837 * Allocate memory for a variable, and assign a string to it. 9631 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
9632 * value).
9633 */
9634 static typeval *
9635 alloc_vartv()
9636 {
9637 return (typeval *)alloc_clear((unsigned)sizeof(typeval));
9638 }
9639
9640 /*
9641 * Allocate memory for a variable type-value, and assign a string to it.
8838 * The string "s" must have been allocated, it is consumed. 9642 * The string "s" must have been allocated, it is consumed.
8839 * Return NULL for out of memory, the variable otherwise. 9643 * Return NULL for out of memory, the variable otherwise.
8840 */ 9644 */
8841 static VAR 9645 static typeval *
8842 alloc_string_var(s) 9646 alloc_string_vartv(s)
8843 char_u *s; 9647 char_u *s;
8844 { 9648 {
8845 VAR retvar; 9649 typeval *retvar;
8846 9650
8847 retvar = alloc_var(); 9651 retvar = alloc_vartv();
8848 if (retvar != NULL) 9652 if (retvar != NULL)
8849 { 9653 {
8850 retvar->var_type = VAR_STRING; 9654 retvar->v_type = VAR_STRING;
8851 retvar->var_val.var_string = s; 9655 retvar->vval.v_string = s;
8852 } 9656 }
8853 else 9657 else
8854 vim_free(s); 9658 vim_free(s);
8855 return retvar; 9659 return retvar;
8856 } 9660 }
8857 9661
8858 /* 9662 /*
8859 * Free the memory for a variable. 9663 * Free the memory for a variable type-value.
8860 */ 9664 */
8861 static void 9665 static void
8862 free_var(varp) 9666 free_vartv(varp)
8863 VAR varp; 9667 typeval *varp;
8864 { 9668 {
8865 if (varp != NULL) 9669 if (varp != NULL)
8866 { 9670 {
8867 if (varp->var_type == VAR_STRING) 9671 switch (varp->v_type)
8868 vim_free(varp->var_val.var_string); 9672 {
8869 vim_free(varp->var_name); 9673 case VAR_STRING:
9674 case VAR_FUNC:
9675 vim_free(varp->vval.v_string);
9676 break;
9677 case VAR_LIST:
9678 list_unref(varp->vval.v_list);
9679 break;
9680 default:
9681 break;
9682 }
8870 vim_free(varp); 9683 vim_free(varp);
8871 } 9684 }
8872 } 9685 }
8873 9686
8874 /* 9687 /*
8875 * Free the memory for a variable value and set the value to NULL or 0. 9688 * Free the memory for a variable value and set the value to NULL or 0.
8876 */ 9689 */
8877 static void 9690 static void
8878 clear_var(varp) 9691 clear_vartv(varp)
8879 VAR varp; 9692 typeval *varp;
8880 { 9693 {
8881 if (varp != NULL) 9694 if (varp != NULL)
8882 { 9695 {
8883 if (varp->var_type == VAR_STRING) 9696 switch (varp->v_type)
8884 { 9697 {
8885 vim_free(varp->var_val.var_string); 9698 case VAR_STRING:
8886 varp->var_val.var_string = NULL; 9699 case VAR_FUNC:
8887 } 9700 vim_free(varp->vval.v_string);
8888 else 9701 varp->vval.v_string = NULL;
8889 varp->var_val.var_number = 0; 9702 break;
9703 case VAR_LIST:
9704 list_unref(varp->vval.v_list);
9705 break;
9706 default:
9707 varp->vval.v_number = 0;
9708 break;
9709 }
8890 } 9710 }
8891 } 9711 }
8892 9712
8893 /* 9713 /*
8894 * Get the number value of a variable. 9714 * Get the number value of a variable.
8895 * If it is a String variable, uses vim_str2nr(). 9715 * If it is a String variable, uses vim_str2nr().
8896 */ 9716 */
8897 static long 9717 static long
8898 get_var_number(varp) 9718 get_vartv_number(varp)
8899 VAR varp; 9719 typeval *varp;
8900 { 9720 {
8901 long n; 9721 long n = 0L;
8902 9722
8903 if (varp->var_type == VAR_NUMBER) 9723 switch (varp->v_type)
8904 return (long)(varp->var_val.var_number); 9724 {
8905 else if (varp->var_type == VAR_UNKNOWN || varp->var_val.var_string == NULL) 9725 case VAR_NUMBER:
8906 return 0L; 9726 n = (long)(varp->vval.v_number);
8907 else 9727 break;
8908 { 9728 case VAR_FUNC:
8909 vim_str2nr(varp->var_val.var_string, NULL, NULL, TRUE, TRUE, &n, NULL); 9729 EMSG(_("E999: Using function reference as a number"));
8910 return n; 9730 break;
8911 } 9731 case VAR_STRING:
9732 if (varp->vval.v_string != NULL)
9733 vim_str2nr(varp->vval.v_string, NULL, NULL,
9734 TRUE, TRUE, &n, NULL);
9735 break;
9736 default:
9737 break;
9738 }
9739 return n;
8912 } 9740 }
8913 9741
8914 /* 9742 /*
8915 * Get the lnum from the first argument. Also accepts ".", "$", etc. 9743 * Get the lnum from the first argument. Also accepts ".", "$", etc.
8916 */ 9744 */
8917 static linenr_T 9745 static linenr_T
8918 get_var_lnum(argvars) 9746 get_vartv_lnum(argvars)
8919 VAR argvars; 9747 typeval *argvars;
8920 { 9748 {
8921 var retvar; 9749 typeval retvar;
8922 linenr_T lnum; 9750 linenr_T lnum;
8923 9751
8924 lnum = get_var_number(&argvars[0]); 9752 lnum = get_vartv_number(&argvars[0]);
8925 if (lnum == 0) /* no valid number, try using line() */ 9753 if (lnum == 0) /* no valid number, try using line() */
8926 { 9754 {
8927 retvar.var_type = VAR_NUMBER; 9755 retvar.v_type = VAR_NUMBER;
8928 f_line(argvars, &retvar); 9756 f_line(argvars, &retvar);
8929 lnum = retvar.var_val.var_number; 9757 lnum = retvar.vval.v_number;
8930 clear_var(&retvar); 9758 clear_vartv(&retvar);
8931 } 9759 }
8932 return lnum; 9760 return lnum;
8933 } 9761 }
8934 9762
8935 /* 9763 /*
8939 * get_var_string_buf() uses a given buffer. 9767 * get_var_string_buf() uses a given buffer.
8940 * If the String variable has never been set, return an empty string. 9768 * If the String variable has never been set, return an empty string.
8941 * Never returns NULL; 9769 * Never returns NULL;
8942 */ 9770 */
8943 static char_u * 9771 static char_u *
8944 get_var_string(varp) 9772 get_vartv_string(varp)
8945 VAR varp; 9773 typeval *varp;
8946 { 9774 {
8947 static char_u mybuf[NUMBUFLEN]; 9775 static char_u mybuf[NUMBUFLEN];
8948 9776
8949 return get_var_string_buf(varp, mybuf); 9777 return get_vartv_string_buf(varp, mybuf);
8950 } 9778 }
8951 9779
8952 static char_u * 9780 static char_u *
8953 get_var_string_buf(varp, buf) 9781 get_vartv_string_buf(varp, buf)
8954 VAR varp; 9782 typeval *varp;
8955 char_u *buf; 9783 char_u *buf;
8956 { 9784 {
8957 if (varp->var_type == VAR_NUMBER) 9785 switch (varp->v_type)
8958 { 9786 {
8959 sprintf((char *)buf, "%ld", (long)varp->var_val.var_number); 9787 case VAR_NUMBER:
8960 return buf; 9788 sprintf((char *)buf, "%ld", (long)varp->vval.v_number);
8961 } 9789 return buf;
8962 else if (varp->var_val.var_string == NULL) 9790 case VAR_FUNC:
8963 return (char_u *)""; 9791 EMSG(_("E99: using Funcref as a String"));
8964 else 9792 break;
8965 return varp->var_val.var_string; 9793 case VAR_LIST:
9794 EMSG(_("E99: using List as a String"));
9795 break;
9796 case VAR_STRING:
9797 if (varp->vval.v_string != NULL)
9798 return varp->vval.v_string;
9799 break;
9800 default:
9801 EMSG(_("E999: Internal error: get_vartv_string_buf()"));
9802 break;
9803 }
9804 return (char_u *)"";
8966 } 9805 }
8967 9806
8968 /* 9807 /*
8969 * Find variable "name" in the list of variables. 9808 * Find variable "name" in the list of variables.
8970 * Return a pointer to it if found, NULL if not found. 9809 * Return a pointer to it if found, NULL if not found.
9810 * Careful: "a:0" variables don't have a name.
8971 */ 9811 */
8972 static VAR 9812 static VAR
8973 find_var(name, writing) 9813 find_var(name, writing)
8974 char_u *name; 9814 char_u *name;
8975 int writing; 9815 int writing;
8976 { 9816 {
8977 int i; 9817 int i;
8978 char_u *varname; 9818 char_u *varname;
8979 garray_T *gap; 9819 garray_T *gap;
8980 9820
8981 /* Check for function arguments "a:" */
8982 if (name[0] == 'a' && name[1] == ':') 9821 if (name[0] == 'a' && name[1] == ':')
8983 { 9822 {
9823 /* Function arguments "a:".
9824 * NOTE: We use a typecast, because function arguments don't have a
9825 * name. The caller must not try to access the name! */
8984 if (writing) 9826 if (writing)
8985 { 9827 {
8986 EMSG2(_(e_readonlyvar), name); 9828 EMSG2(_(e_readonlyvar), name);
8987 return NULL; 9829 return NULL;
8988 } 9830 }
8995 if (i == 0) /* a:0 */ 9837 if (i == 0) /* a:0 */
8996 return &current_funccal->a0_var; 9838 return &current_funccal->a0_var;
8997 i += current_funccal->func->args.ga_len; 9839 i += current_funccal->func->args.ga_len;
8998 if (i > current_funccal->argcount) /* a:999 */ 9840 if (i > current_funccal->argcount) /* a:999 */
8999 return NULL; 9841 return NULL;
9000 return &(current_funccal->argvars[i - 1]); /* a:1, a:2, etc. */ 9842 return (VAR)&(current_funccal->argvars[i - 1]); /* a:1, a:2, etc. */
9001 } 9843 }
9002 if (STRCMP(name, "firstline") == 0) 9844 if (STRCMP(name, "firstline") == 0)
9003 return &(current_funccal->firstline); 9845 return &(current_funccal->firstline);
9004 if (STRCMP(name, "lastline") == 0) 9846 if (STRCMP(name, "lastline") == 0)
9005 return &(current_funccal->lastline); 9847 return &(current_funccal->lastline);
9006 for (i = 0; i < current_funccal->func->args.ga_len; ++i) 9848 for (i = 0; i < current_funccal->func->args.ga_len; ++i)
9007 if (STRCMP(name, ((char_u **) 9849 if (STRCMP(name, ((char_u **)
9008 (current_funccal->func->args.ga_data))[i]) == 0) 9850 (current_funccal->func->args.ga_data))[i]) == 0)
9009 return &(current_funccal->argvars[i]); /* a:name */ 9851 return (VAR)&(current_funccal->argvars[i]); /* a:name */
9010 return NULL; 9852 return NULL;
9011 } 9853 }
9012 9854
9013 gap = find_var_ga(name, &varname); 9855 gap = find_var_ga(name, &varname);
9014 if (gap == NULL) 9856 if (gap == NULL)
9022 char_u *varname; 9864 char_u *varname;
9023 { 9865 {
9024 int i; 9866 int i;
9025 9867
9026 for (i = gap->ga_len; --i >= 0; ) 9868 for (i = gap->ga_len; --i >= 0; )
9027 if (VAR_GAP_ENTRY(i, gap).var_name != NULL 9869 if (VAR_GAP_ENTRY(i, gap).v_name != NULL
9028 && STRCMP(VAR_GAP_ENTRY(i, gap).var_name, varname) == 0) 9870 && STRCMP(VAR_GAP_ENTRY(i, gap).v_name, varname) == 0)
9029 break; 9871 break;
9030 if (i < 0) 9872 if (i < 0)
9031 return NULL; 9873 return NULL;
9032 return &VAR_GAP_ENTRY(i, gap); 9874 return &VAR_GAP_ENTRY(i, gap);
9033 } 9875 }
9091 { 9933 {
9092 if (ga_grow(&ga_scripts, (int)(id - ga_scripts.ga_len)) == OK) 9934 if (ga_grow(&ga_scripts, (int)(id - ga_scripts.ga_len)) == OK)
9093 { 9935 {
9094 while (ga_scripts.ga_len < id) 9936 while (ga_scripts.ga_len < id)
9095 { 9937 {
9096 var_init(&SCRIPT_VARS(ga_scripts.ga_len + 1)); 9938 vars_init(&SCRIPT_VARS(ga_scripts.ga_len + 1));
9097 ++ga_scripts.ga_len; 9939 ++ga_scripts.ga_len;
9098 } 9940 }
9099 } 9941 }
9100 } 9942 }
9101 9943
9102 /* 9944 /*
9103 * Initialize internal variables for use. 9945 * Initialize internal variables for use.
9104 */ 9946 */
9105 void 9947 void
9106 var_init(gap) 9948 vars_init(gap)
9107 garray_T *gap; 9949 garray_T *gap;
9108 { 9950 {
9109 ga_init2(gap, (int)sizeof(var), 4); 9951 ga_init2(gap, (int)sizeof(var), 4);
9110 } 9952 }
9111 9953
9112 /* 9954 /*
9113 * Clean up a list of internal variables. 9955 * Clean up a list of internal variables.
9114 */ 9956 */
9115 void 9957 void
9116 var_clear(gap) 9958 vars_clear(gap)
9117 garray_T *gap; 9959 garray_T *gap;
9118 { 9960 {
9119 int i; 9961 int i;
9120 9962
9121 for (i = gap->ga_len; --i >= 0; ) 9963 for (i = gap->ga_len; --i >= 0; )
9122 var_free_one(&VAR_GAP_ENTRY(i, gap)); 9964 clear_var(&VAR_GAP_ENTRY(i, gap));
9123 ga_clear(gap); 9965 ga_clear(gap);
9124 } 9966 }
9125 9967
9126 static void 9968 static void
9127 var_free_one(v) 9969 clear_var(v)
9128 VAR v; 9970 VAR v;
9129 { 9971 {
9130 vim_free(v->var_name); 9972 vim_free(v->v_name);
9131 v->var_name = NULL; 9973 v->v_name = NULL;
9132 if (v->var_type == VAR_STRING) 9974 clear_vartv(&v->tv);
9133 vim_free(v->var_val.var_string);
9134 v->var_val.var_string = NULL;
9135 } 9975 }
9136 9976
9137 /* 9977 /*
9138 * List the value of one internal variable. 9978 * List the value of one internal variable.
9139 */ 9979 */
9140 static void 9980 static void
9141 list_one_var(v, prefix) 9981 list_one_var(v, prefix)
9142 VAR v; 9982 VAR v;
9143 char_u *prefix; 9983 char_u *prefix;
9144 { 9984 {
9145 list_one_var_a(prefix, v->var_name, v->var_type, get_var_string(v)); 9985 char_u *tofree;
9986 char_u *s;
9987
9988 s = tv2string(&v->tv, &tofree);
9989 list_one_var_a(prefix, v->v_name, v->tv.v_type,
9990 s == NULL ? (char_u *)"" : s);
9991 vim_free(tofree);
9146 } 9992 }
9147 9993
9148 /* 9994 /*
9149 * List the value of one "v:" variable. 9995 * List the value of one "v:" variable.
9150 */ 9996 */
9180 msg_puts(name); 10026 msg_puts(name);
9181 msg_putchar(' '); 10027 msg_putchar(' ');
9182 msg_advance(22); 10028 msg_advance(22);
9183 if (type == VAR_NUMBER) 10029 if (type == VAR_NUMBER)
9184 msg_putchar('#'); 10030 msg_putchar('#');
10031 else if (type == VAR_FUNC)
10032 msg_putchar('*');
10033 else if (type == VAR_LIST)
10034 {
10035 msg_putchar('[');
10036 if (*string == '[')
10037 ++string;
10038 }
9185 else 10039 else
9186 msg_putchar(' '); 10040 msg_putchar(' ');
10041
9187 msg_outtrans(string); 10042 msg_outtrans(string);
10043
10044 if (type == VAR_FUNC)
10045 msg_puts((char_u *)"()");
9188 } 10046 }
9189 10047
9190 /* 10048 /*
9191 * Set variable "name" to value in "varp". 10049 * Set variable "name" to value in "varp".
9192 * If the variable already exists, the value is updated. 10050 * If the variable already exists, the value is updated.
9193 * Otherwise the variable is created. 10051 * Otherwise the variable is created.
9194 */ 10052 */
9195 static void 10053 static void
9196 set_var(name, varp, copy) 10054 set_var(name, varp, copy)
9197 char_u *name; 10055 char_u *name;
9198 VAR varp; 10056 typeval *varp;
9199 int copy; /* make copy of value in "varp" */ 10057 int copy; /* make copy of value in "varp" */
9200 { 10058 {
9201 int i; 10059 int i;
9202 VAR v; 10060 VAR v;
9203 char_u *varname; 10061 char_u *varname;
9216 else 10074 else
9217 { 10075 {
9218 if (vimvars[i].type == VAR_STRING) 10076 if (vimvars[i].type == VAR_STRING)
9219 { 10077 {
9220 vim_free(vimvars[i].val); 10078 vim_free(vimvars[i].val);
9221 if (copy || varp->var_type != VAR_STRING) 10079 if (copy || varp->v_type != VAR_STRING)
9222 vimvars[i].val = vim_strsave(get_var_string(varp)); 10080 vimvars[i].val = vim_strsave(get_vartv_string(varp));
9223 else 10081 else
9224 { 10082 {
9225 /* Take over the string to avoid an extra alloc/free. */ 10083 /* Take over the string to avoid an extra alloc/free. */
9226 vimvars[i].val = varp->var_val.var_string; 10084 vimvars[i].val = varp->vval.v_string;
9227 varp->var_val.var_string = NULL; 10085 varp->vval.v_string = NULL;
9228 } 10086 }
9229 } 10087 }
9230 else 10088 else
9231 vimvars[i].val = (char_u *)get_var_number(varp); 10089 vimvars[i].val = (char_u *)get_vartv_number(varp);
9232 } 10090 }
9233 return; 10091 return;
10092 }
10093
10094 if (varp->v_type == VAR_FUNC)
10095 {
10096 if (!(vim_strchr((char_u *)"wbs", name[0]) != NULL && name[1] == ':')
10097 && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':')
10098 ? name[2] : name[0]))
10099 {
10100 EMSG2(_("E999: Funcref variable name must start with a capital: %s"), name);
10101 return;
10102 }
10103 if (function_exists(name))
10104 {
10105 EMSG2(_("E999: Variable name conflicts with existing function: %s"), name);
10106 return;
10107 }
9234 } 10108 }
9235 10109
9236 v = find_var(name, TRUE); 10110 v = find_var(name, TRUE);
9237 if (v != NULL) /* existing variable, only need to free string */ 10111 if (v != NULL) /* existing variable, only need to free string */
9238 { 10112 {
9239 if (v->var_type == VAR_STRING) 10113 if (v->tv.v_type != varp->v_type
9240 vim_free(v->var_val.var_string); 10114 && !((v->tv.v_type == VAR_STRING
10115 || v->tv.v_type == VAR_NUMBER)
10116 && (varp->v_type == VAR_STRING
10117 || varp->v_type == VAR_NUMBER)))
10118 {
10119 EMSG2(_("E999: Variable type mismatch for: %s"), name);
10120 return;
10121 }
10122 if (v->tv.v_type == VAR_STRING || v->tv.v_type == VAR_FUNC)
10123 vim_free(v->tv.vval.v_string);
9241 } 10124 }
9242 else /* add a new variable */ 10125 else /* add a new variable */
9243 { 10126 {
9244 gap = find_var_ga(name, &varname); 10127 gap = find_var_ga(name, &varname);
9245 if (gap == NULL) /* illegal name */ 10128 if (gap == NULL) /* illegal name */
9248 return; 10131 return;
9249 } 10132 }
9250 10133
9251 /* Try to use an empty entry */ 10134 /* Try to use an empty entry */
9252 for (i = gap->ga_len; --i >= 0; ) 10135 for (i = gap->ga_len; --i >= 0; )
9253 if (VAR_GAP_ENTRY(i, gap).var_name == NULL) 10136 if (VAR_GAP_ENTRY(i, gap).v_name == NULL)
9254 break; 10137 break;
9255 if (i < 0) /* need to allocate more room */ 10138 if (i < 0) /* need to allocate more room */
9256 { 10139 {
9257 if (ga_grow(gap, 1) == FAIL) 10140 if (ga_grow(gap, 1) == FAIL)
9258 return; 10141 return;
9259 i = gap->ga_len; 10142 i = gap->ga_len;
9260 } 10143 }
9261 v = &VAR_GAP_ENTRY(i, gap); 10144 v = &VAR_GAP_ENTRY(i, gap);
9262 if ((v->var_name = vim_strsave(varname)) == NULL) 10145 if ((v->v_name = vim_strsave(varname)) == NULL)
9263 return; 10146 return;
9264 if (i == gap->ga_len) 10147 if (i == gap->ga_len)
9265 ++gap->ga_len; 10148 ++gap->ga_len;
9266 } 10149 }
9267 if (copy || varp->var_type != VAR_STRING) 10150 if (copy || (varp->v_type != VAR_STRING && varp->v_type != VAR_FUNC))
9268 copy_var(varp, v); 10151 copy_vartv(varp, &v->tv);
9269 else 10152 else
9270 { 10153 {
9271 v->var_type = varp->var_type; 10154 v->tv.v_type = varp->v_type;
9272 v->var_val.var_string = varp->var_val.var_string; 10155 v->tv.vval.v_string = varp->vval.v_string;
9273 } 10156 varp->vval.v_string = NULL;
9274 } 10157 }
9275 10158 }
9276 static void 10159
9277 copy_var(from, to) 10160 /*
9278 VAR from; 10161 * Copy the values from typeval "from" to typeval "to".
9279 VAR to; 10162 * When needed allocates string or increases reference count.
9280 { 10163 * Does not make a copy of a list!
9281 to->var_type = from->var_type; 10164 */
9282 if (from->var_type == VAR_STRING) 10165 static void
9283 to->var_val.var_string = vim_strsave(get_var_string(from)); 10166 copy_vartv(from, to)
9284 else 10167 typeval *from;
9285 to->var_val.var_number = from->var_val.var_number; 10168 typeval *to;
10169 {
10170 to->v_type = from->v_type;
10171 switch (from->v_type)
10172 {
10173 case VAR_NUMBER:
10174 to->vval.v_number = from->vval.v_number;
10175 break;
10176 case VAR_STRING:
10177 case VAR_FUNC:
10178 if (from->vval.v_string == NULL)
10179 to->vval.v_string = NULL;
10180 else
10181 to->vval.v_string = vim_strsave(from->vval.v_string);
10182 break;
10183 case VAR_LIST:
10184 if (from->vval.v_list == NULL)
10185 to->vval.v_list = NULL;
10186 else
10187 {
10188 to->vval.v_list = from->vval.v_list;
10189 ++to->vval.v_list->lv_refcount;
10190 }
10191 break;
10192 default:
10193 EMSG(_("E999: Internal error: copy_vartv()"));
10194 break;
10195 }
9286 } 10196 }
9287 10197
9288 /* 10198 /*
9289 * ":echo expr1 ..." print each argument separated with a space, add a 10199 * ":echo expr1 ..." print each argument separated with a space, add a
9290 * newline at the end. 10200 * newline at the end.
9293 void 10203 void
9294 ex_echo(eap) 10204 ex_echo(eap)
9295 exarg_T *eap; 10205 exarg_T *eap;
9296 { 10206 {
9297 char_u *arg = eap->arg; 10207 char_u *arg = eap->arg;
9298 var retvar; 10208 typeval retvar;
10209 char_u *tofree;
9299 char_u *p; 10210 char_u *p;
9300 int needclr = TRUE; 10211 int needclr = TRUE;
9301 int atstart = TRUE; 10212 int atstart = TRUE;
9302 10213
9303 if (eap->skip) 10214 if (eap->skip)
9326 if (eap->cmdidx == CMD_echo) 10237 if (eap->cmdidx == CMD_echo)
9327 msg_start(); 10238 msg_start();
9328 } 10239 }
9329 else if (eap->cmdidx == CMD_echo) 10240 else if (eap->cmdidx == CMD_echo)
9330 msg_puts_attr((char_u *)" ", echo_attr); 10241 msg_puts_attr((char_u *)" ", echo_attr);
9331 for (p = get_var_string(&retvar); *p != NUL && !got_int; ++p) 10242 for (p = tv2string(&retvar, &tofree); *p != NUL && !got_int; ++p)
9332 if (*p == '\n' || *p == '\r' || *p == TAB) 10243 if (*p == '\n' || *p == '\r' || *p == TAB)
9333 { 10244 {
9334 if (*p != TAB && needclr) 10245 if (*p != TAB && needclr)
9335 { 10246 {
9336 /* remove any text still there from the command */ 10247 /* remove any text still there from the command */
9351 } 10262 }
9352 else 10263 else
9353 #endif 10264 #endif
9354 (void)msg_outtrans_len_attr(p, 1, echo_attr); 10265 (void)msg_outtrans_len_attr(p, 1, echo_attr);
9355 } 10266 }
9356 } 10267 vim_free(tofree);
9357 clear_var(&retvar); 10268 }
10269 clear_vartv(&retvar);
9358 arg = skipwhite(arg); 10270 arg = skipwhite(arg);
9359 } 10271 }
9360 eap->nextcmd = check_nextcmd(arg); 10272 eap->nextcmd = check_nextcmd(arg);
9361 10273
9362 if (eap->skip) 10274 if (eap->skip)
9397 void 10309 void
9398 ex_execute(eap) 10310 ex_execute(eap)
9399 exarg_T *eap; 10311 exarg_T *eap;
9400 { 10312 {
9401 char_u *arg = eap->arg; 10313 char_u *arg = eap->arg;
9402 var retvar; 10314 typeval retvar;
9403 int ret = OK; 10315 int ret = OK;
9404 char_u *p; 10316 char_u *p;
9405 garray_T ga; 10317 garray_T ga;
9406 int len; 10318 int len;
9407 int save_did_emsg; 10319 int save_did_emsg;
9426 break; 10338 break;
9427 } 10339 }
9428 10340
9429 if (!eap->skip) 10341 if (!eap->skip)
9430 { 10342 {
9431 p = get_var_string(&retvar); 10343 p = get_vartv_string(&retvar);
9432 len = (int)STRLEN(p); 10344 len = (int)STRLEN(p);
9433 if (ga_grow(&ga, len + 2) == FAIL) 10345 if (ga_grow(&ga, len + 2) == FAIL)
9434 { 10346 {
9435 clear_var(&retvar); 10347 clear_vartv(&retvar);
9436 ret = FAIL; 10348 ret = FAIL;
9437 break; 10349 break;
9438 } 10350 }
9439 if (ga.ga_len) 10351 if (ga.ga_len)
9440 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; 10352 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' ';
9441 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); 10353 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p);
9442 ga.ga_len += len; 10354 ga.ga_len += len;
9443 } 10355 }
9444 10356
9445 clear_var(&retvar); 10357 clear_vartv(&retvar);
9446 arg = skipwhite(arg); 10358 arg = skipwhite(arg);
9447 } 10359 }
9448 10360
9449 if (ret != FAIL && ga.ga_data != NULL) 10361 if (ret != FAIL && ga.ga_data != NULL)
9450 { 10362 {
9534 ufunc_T *fp; 10446 ufunc_T *fp;
9535 int indent; 10447 int indent;
9536 int nesting; 10448 int nesting;
9537 char_u *skip_until = NULL; 10449 char_u *skip_until = NULL;
9538 static char_u e_funcexts[] = N_("E122: Function %s already exists, add ! to replace it"); 10450 static char_u e_funcexts[] = N_("E122: Function %s already exists, add ! to replace it");
10451 VAR v;
9539 10452
9540 /* 10453 /*
9541 * ":function" without argument: list functions. 10454 * ":function" without argument: list functions.
9542 */ 10455 */
9543 if (ends_excmd(*eap->arg)) 10456 if (ends_excmd(*eap->arg))
9828 goto erret; 10741 goto erret;
9829 10742
9830 /* 10743 /*
9831 * If there are no errors, add the function 10744 * If there are no errors, add the function
9832 */ 10745 */
10746 v = find_var(name, FALSE);
10747 if (v != NULL && v->tv.v_type == VAR_FUNC)
10748 {
10749 EMSG2(_("E999: Function name conflicts with variable: %s"), name);
10750 goto erret;
10751 }
10752
9833 fp = find_func(name); 10753 fp = find_func(name);
9834 if (fp != NULL) 10754 if (fp != NULL)
9835 { 10755 {
9836 if (!eap->forceit) 10756 if (!eap->forceit)
9837 { 10757 {
10063 if (STRCMP(name, fp->name) == 0) 10983 if (STRCMP(name, fp->name) == 0)
10064 break; 10984 break;
10065 return fp; 10985 return fp;
10066 } 10986 }
10067 10987
10988 /*
10989 * Return TRUE if a function "name" exists.
10990 */
10991 static int
10992 function_exists(name)
10993 char_u *name;
10994 {
10995 char_u *p = name;
10996 int n = FALSE;
10997
10998 p = trans_function_name(&p, FALSE, TRUE);
10999 if (p != NULL)
11000 {
11001 if (ASCII_ISUPPER(*p) || p[0] == K_SPECIAL)
11002 n = (find_func(p) != NULL);
11003 else if (ASCII_ISLOWER(*p))
11004 n = (find_internal_func(p) >= 0);
11005 vim_free(p);
11006 }
11007 return n;
11008 }
11009
10068 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 11010 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
10069 11011
10070 /* 11012 /*
10071 * Function given to ExpandGeneric() to obtain the list of user defined 11013 * Function given to ExpandGeneric() to obtain the list of user defined
10072 * function names. 11014 * function names.
10188 */ 11130 */
10189 static void 11131 static void
10190 call_user_func(fp, argcount, argvars, retvar, firstline, lastline) 11132 call_user_func(fp, argcount, argvars, retvar, firstline, lastline)
10191 ufunc_T *fp; /* pointer to function */ 11133 ufunc_T *fp; /* pointer to function */
10192 int argcount; /* nr of args */ 11134 int argcount; /* nr of args */
10193 VAR argvars; /* arguments */ 11135 typeval *argvars; /* arguments */
10194 VAR retvar; /* return value */ 11136 typeval *retvar; /* return value */
10195 linenr_T firstline; /* first line of range */ 11137 linenr_T firstline; /* first line of range */
10196 linenr_T lastline; /* last line of range */ 11138 linenr_T lastline; /* last line of range */
10197 { 11139 {
10198 char_u *save_sourcing_name; 11140 char_u *save_sourcing_name;
10199 linenr_T save_sourcing_lnum; 11141 linenr_T save_sourcing_lnum;
10205 11147
10206 /* If depth of calling is getting too high, don't execute the function */ 11148 /* If depth of calling is getting too high, don't execute the function */
10207 if (depth >= p_mfd) 11149 if (depth >= p_mfd)
10208 { 11150 {
10209 EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'")); 11151 EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'"));
10210 retvar->var_type = VAR_NUMBER; 11152 retvar->v_type = VAR_NUMBER;
10211 retvar->var_val.var_number = -1; 11153 retvar->vval.v_number = -1;
10212 return; 11154 return;
10213 } 11155 }
10214 ++depth; 11156 ++depth;
10215 11157
10216 line_breakcheck(); /* check for CTRL-C hit */ 11158 line_breakcheck(); /* check for CTRL-C hit */
10217 11159
10218 /* set local variables */ 11160 /* set local variables */
10219 var_init(&fc.l_vars); 11161 vars_init(&fc.l_vars);
10220 fc.func = fp; 11162 fc.func = fp;
10221 fc.argcount = argcount; 11163 fc.argcount = argcount;
10222 fc.argvars = argvars; 11164 fc.argvars = argvars;
10223 fc.retvar = retvar; 11165 fc.retvar = retvar;
10224 retvar->var_val.var_number = 0; 11166 retvar->vval.v_number = 0;
10225 fc.linenr = 0; 11167 fc.linenr = 0;
10226 fc.returned = FALSE; 11168 fc.returned = FALSE;
10227 fc.level = ex_nesting_level; 11169 fc.level = ex_nesting_level;
10228 fc.a0_var.var_type = VAR_NUMBER; 11170 fc.a0_var.tv.v_type = VAR_NUMBER;
10229 fc.a0_var.var_val.var_number = argcount - fp->args.ga_len; 11171 fc.a0_var.tv.vval.v_number = argcount - fp->args.ga_len;
10230 fc.a0_var.var_name = NULL; 11172 fc.a0_var.v_name = NULL;
10231 current_funccal = &fc; 11173 current_funccal = &fc;
10232 fc.firstline.var_type = VAR_NUMBER; 11174 fc.firstline.tv.v_type = VAR_NUMBER;
10233 fc.firstline.var_val.var_number = firstline; 11175 fc.firstline.tv.vval.v_number = firstline;
10234 fc.firstline.var_name = NULL; 11176 fc.firstline.v_name = NULL;
10235 fc.lastline.var_type = VAR_NUMBER; 11177 fc.lastline.tv.v_type = VAR_NUMBER;
10236 fc.lastline.var_val.var_number = lastline; 11178 fc.lastline.tv.vval.v_number = lastline;
10237 fc.lastline.var_name = NULL; 11179 fc.lastline.v_name = NULL;
10238 /* Check if this function has a breakpoint. */ 11180 /* Check if this function has a breakpoint. */
10239 fc.breakpoint = dbg_find_breakpoint(FALSE, fp->name, (linenr_T)0); 11181 fc.breakpoint = dbg_find_breakpoint(FALSE, fp->name, (linenr_T)0);
10240 fc.dbg_tick = debug_tick; 11182 fc.dbg_tick = debug_tick;
10241 11183
10242 /* Don't redraw while executing the function. */ 11184 /* Don't redraw while executing the function. */
10268 msg_puts((char_u *)"("); 11210 msg_puts((char_u *)"(");
10269 for (i = 0; i < argcount; ++i) 11211 for (i = 0; i < argcount; ++i)
10270 { 11212 {
10271 if (i > 0) 11213 if (i > 0)
10272 msg_puts((char_u *)", "); 11214 msg_puts((char_u *)", ");
10273 if (argvars[i].var_type == VAR_NUMBER) 11215 if (argvars[i].v_type == VAR_NUMBER)
10274 msg_outnum((long)argvars[i].var_val.var_number); 11216 msg_outnum((long)argvars[i].vval.v_number);
10275 else 11217 else
10276 { 11218 {
10277 trunc_string(get_var_string(&argvars[i]), 11219 trunc_string(get_vartv_string(&argvars[i]),
10278 buf, MSG_BUF_LEN); 11220 buf, MSG_BUF_LEN);
10279 msg_puts((char_u *)"\""); 11221 msg_puts((char_u *)"\"");
10280 msg_puts(buf); 11222 msg_puts(buf);
10281 msg_puts((char_u *)"\""); 11223 msg_puts((char_u *)"\"");
10282 } 11224 }
10298 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT); 11240 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
10299 11241
10300 --RedrawingDisabled; 11242 --RedrawingDisabled;
10301 11243
10302 /* when the function was aborted because of an error, return -1 */ 11244 /* when the function was aborted because of an error, return -1 */
10303 if ((did_emsg && (fp->flags & FC_ABORT)) || retvar->var_type == VAR_UNKNOWN) 11245 if ((did_emsg && (fp->flags & FC_ABORT)) || retvar->v_type == VAR_UNKNOWN)
10304 { 11246 {
10305 clear_var(retvar); 11247 clear_vartv(retvar);
10306 retvar->var_type = VAR_NUMBER; 11248 retvar->v_type = VAR_NUMBER;
10307 retvar->var_val.var_number = -1; 11249 retvar->vval.v_number = -1;
10308 } 11250 }
10309 11251
10310 /* when being verbose, mention the return value */ 11252 /* when being verbose, mention the return value */
10311 if (p_verbose >= 12) 11253 if (p_verbose >= 12)
10312 { 11254 {
10320 if (STRLEN(sourcing_name) > IOSIZE / 2 - 50) 11262 if (STRLEN(sourcing_name) > IOSIZE / 2 - 50)
10321 sn = sourcing_name + STRLEN(sourcing_name) - (IOSIZE / 2 - 50); 11263 sn = sourcing_name + STRLEN(sourcing_name) - (IOSIZE / 2 - 50);
10322 11264
10323 if (aborting()) 11265 if (aborting())
10324 smsg((char_u *)_("%s aborted"), sn); 11266 smsg((char_u *)_("%s aborted"), sn);
10325 else if (fc.retvar->var_type == VAR_NUMBER) 11267 else if (fc.retvar->v_type == VAR_NUMBER)
10326 smsg((char_u *)_("%s returning #%ld"), sn, 11268 smsg((char_u *)_("%s returning #%ld"), sn,
10327 (long)fc.retvar->var_val.var_number); 11269 (long)fc.retvar->vval.v_number);
10328 else if (fc.retvar->var_type == VAR_STRING) 11270 else if (fc.retvar->v_type == VAR_STRING)
10329 { 11271 {
10330 val = get_var_string(fc.retvar); 11272 val = get_vartv_string(fc.retvar);
10331 if (STRLEN(val) > IOSIZE / 2 - 50) 11273 if (STRLEN(val) > IOSIZE / 2 - 50)
10332 val = val + STRLEN(val) - (IOSIZE / 2 - 50); 11274 val = val + STRLEN(val) - (IOSIZE / 2 - 50);
10333 smsg((char_u *)_("%s returning \"%s\""), sn, val); 11275 smsg((char_u *)_("%s returning \"%s\""), sn, val);
10334 } 11276 }
10335 msg_puts((char_u *)"\n"); /* don't overwrite this either */ 11277 msg_puts((char_u *)"\n"); /* don't overwrite this either */
10353 } 11295 }
10354 11296
10355 did_emsg |= save_did_emsg; 11297 did_emsg |= save_did_emsg;
10356 current_funccal = save_fcp; 11298 current_funccal = save_fcp;
10357 11299
10358 var_clear(&fc.l_vars); /* free all local variables */ 11300 vars_clear(&fc.l_vars); /* free all local variables */
10359 --depth; 11301 --depth;
10360 } 11302 }
10361 11303
10362 /* 11304 /*
10363 * ":return [expr]" 11305 * ":return [expr]"
10384 && eval0(arg, &retvar, &eap->nextcmd, !eap->skip) != FAIL) 11326 && eval0(arg, &retvar, &eap->nextcmd, !eap->skip) != FAIL)
10385 { 11327 {
10386 if (!eap->skip) 11328 if (!eap->skip)
10387 returning = do_return(eap, FALSE, TRUE, &retvar); 11329 returning = do_return(eap, FALSE, TRUE, &retvar);
10388 else 11330 else
10389 clear_var(&retvar); 11331 clear_vartv(&retvar.tv);
10390 } 11332 }
10391 /* It's safer to return also on error. */ 11333 /* It's safer to return also on error. */
10392 else if (!eap->skip) 11334 else if (!eap->skip)
10393 { 11335 {
10394 /* 11336 /*
10458 11400
10459 if (value != NULL) 11401 if (value != NULL)
10460 { 11402 {
10461 /* Store the value of the pending return. */ 11403 /* Store the value of the pending return. */
10462 if ((cstack->cs_retvar[idx] = alloc_var()) != NULL) 11404 if ((cstack->cs_retvar[idx] = alloc_var()) != NULL)
10463 *(VAR)cstack->cs_retvar[idx] = *(VAR)value; 11405 *(typeval *)cstack->cs_retvar[idx] = *(typeval *)value;
10464 else 11406 else
10465 EMSG(_(e_outofmem)); 11407 EMSG(_(e_outofmem));
10466 } 11408 }
10467 else 11409 else
10468 cstack->cs_retvar[idx] = NULL; 11410 cstack->cs_retvar[idx] = NULL;
10470 if (reanimate) 11412 if (reanimate)
10471 { 11413 {
10472 /* The pending return value could be overwritten by a ":return" 11414 /* The pending return value could be overwritten by a ":return"
10473 * without argument in a finally clause; reset the default 11415 * without argument in a finally clause; reset the default
10474 * return value. */ 11416 * return value. */
10475 current_funccal->retvar->var_type = VAR_NUMBER; 11417 current_funccal->retvar->v_type = VAR_NUMBER;
10476 current_funccal->retvar->var_val.var_number = 0; 11418 current_funccal->retvar->vval.v_number = 0;
10477 } 11419 }
10478 } 11420 }
10479 report_make_pending(CSTP_RETURN, value); 11421 report_make_pending(CSTP_RETURN, value);
10480 } 11422 }
10481 else 11423 else
10485 /* If the return is carried out now, store the return value. For 11427 /* If the return is carried out now, store the return value. For
10486 * a return immediately after reanimation, the value is already 11428 * a return immediately after reanimation, the value is already
10487 * there. */ 11429 * there. */
10488 if (!reanimate && value != NULL) 11430 if (!reanimate && value != NULL)
10489 { 11431 {
10490 clear_var(current_funccal->retvar); 11432 clear_vartv(current_funccal->retvar);
10491 *current_funccal->retvar = *(VAR)value; 11433 *current_funccal->retvar = *(typeval *)value;
10492 if (!is_cmd) 11434 if (!is_cmd)
10493 vim_free(value); 11435 vim_free(value);
10494 } 11436 }
10495 } 11437 }
10496 11438
10502 */ 11444 */
10503 void 11445 void
10504 discard_pending_return(retvar) 11446 discard_pending_return(retvar)
10505 void *retvar; 11447 void *retvar;
10506 { 11448 {
10507 /* The variable was copied from one with an undefined var_name. So we can't 11449 /* The variable was copied from one with an undefined v_name. So we can't
10508 * use free_var() to clear and free it. */ 11450 * use free_vartv() to clear and free it. */
10509 clear_var((VAR)retvar); 11451 clear_vartv(&((VAR)retvar)->tv);
10510 vim_free(retvar); 11452 vim_free(retvar);
10511 } 11453 }
10512 11454
10513 /* 11455 /*
10514 * Generate a return command for producing the value of "retvar". The result 11456 * Generate a return command for producing the value of "retvar". The result
10518 get_return_cmd(retvar) 11460 get_return_cmd(retvar)
10519 void *retvar; 11461 void *retvar;
10520 { 11462 {
10521 char_u *s = IObuff; 11463 char_u *s = IObuff;
10522 11464
10523 if (retvar == NULL || ((VAR)retvar)->var_type == VAR_UNKNOWN) 11465 if (retvar == NULL || ((VAR)retvar)->tv.v_type == VAR_UNKNOWN)
10524 s = (char_u *)":return"; 11466 s = (char_u *)":return";
10525 else if (((VAR)retvar)->var_type == VAR_STRING) 11467 else if (((VAR)retvar)->tv.v_type == VAR_STRING)
10526 sprintf((char *)IObuff, ":return \"%s\"", 11468 sprintf((char *)IObuff, ":return \"%s\"",
10527 ((VAR)retvar)->var_val.var_string); 11469 ((VAR)retvar)->tv.vval.v_string);
10528 else 11470 else
10529 sprintf((char *)IObuff, ":return %ld", 11471 sprintf((char *)IObuff, ":return %ld",
10530 (long)(((VAR)retvar)->var_val.var_number)); 11472 (long)(((VAR)retvar)->tv.vval.v_number));
10531 return vim_strsave(s); 11473 return vim_strsave(s);
10532 } 11474 }
10533 11475
10534 /* 11476 /*
10535 * Get next function line. 11477 * Get next function line.
10642 vir_T *virp; 11584 vir_T *virp;
10643 int writing; 11585 int writing;
10644 { 11586 {
10645 char_u *tab; 11587 char_u *tab;
10646 int is_string = FALSE; 11588 int is_string = FALSE;
10647 VAR varp = NULL; 11589 typeval *vartvp = NULL;
10648 char_u *val; 11590 char_u *val;
10649 11591
10650 if (!writing && (find_viminfo_parameter('!') != NULL)) 11592 if (!writing && (find_viminfo_parameter('!') != NULL))
10651 { 11593 {
10652 tab = vim_strchr(virp->vir_line + 1, '\t'); 11594 tab = vim_strchr(virp->vir_line + 1, '\t');
10663 if (is_string) 11605 if (is_string)
10664 { 11606 {
10665 val = viminfo_readstring(virp, 11607 val = viminfo_readstring(virp,
10666 (int)(tab - virp->vir_line + 1), TRUE); 11608 (int)(tab - virp->vir_line + 1), TRUE);
10667 if (val != NULL) 11609 if (val != NULL)
10668 varp = alloc_string_var(val); 11610 vartvp = alloc_string_vartv(val);
10669 } 11611 }
10670 else 11612 else
10671 { 11613 {
10672 varp = alloc_var(); 11614 vartvp = alloc_vartv();
10673 if (varp != NULL) 11615 if (vartvp != NULL)
10674 { 11616 {
10675 varp->var_type = VAR_NUMBER; 11617 vartvp->v_type = VAR_NUMBER;
10676 varp->var_val.var_number = atol((char *)tab + 1); 11618 vartvp->vval.v_number = atol((char *)tab + 1);
10677 } 11619 }
10678 } 11620 }
10679 /* assign the value to the variable */ 11621 /* assign the value to the variable */
10680 if (varp != NULL) 11622 if (vartvp != NULL)
10681 { 11623 {
10682 set_var(virp->vir_line + 1, varp, FALSE); 11624 set_var(virp->vir_line + 1, vartvp, FALSE);
10683 free_var(varp); 11625 free_vartv(vartvp);
10684 } 11626 }
10685 } 11627 }
10686 } 11628 }
10687 } 11629 }
10688 11630
10705 11647
10706 fprintf(fp, _("\n# global variables:\n")); 11648 fprintf(fp, _("\n# global variables:\n"));
10707 for (i = gap->ga_len; --i >= 0; ) 11649 for (i = gap->ga_len; --i >= 0; )
10708 { 11650 {
10709 this_var = &VAR_GAP_ENTRY(i, gap); 11651 this_var = &VAR_GAP_ENTRY(i, gap);
10710 if (this_var->var_name != NULL 11652 if (this_var->v_name != NULL
10711 && var_flavour(this_var->var_name) == VAR_FLAVOUR_VIMINFO) 11653 && var_flavour(this_var->v_name) == VAR_FLAVOUR_VIMINFO)
10712 { 11654 {
10713 fprintf(fp, "!%s\t%s\t", this_var->var_name, 11655 fprintf(fp, "!%s\t%s\t", this_var->v_name,
10714 (this_var->var_type == VAR_STRING) ? "STR" : "NUM"); 11656 (this_var->tv.v_type == VAR_STRING) ? "STR" : "NUM");
10715 viminfo_writestring(fp, get_var_string(this_var)); 11657 viminfo_writestring(fp, get_var_string(this_var));
10716 } 11658 }
10717 } 11659 }
10718 } 11660 }
10719 #endif 11661 #endif
10729 char_u *p, *t; 11671 char_u *p, *t;
10730 11672
10731 for (i = gap->ga_len; --i >= 0; ) 11673 for (i = gap->ga_len; --i >= 0; )
10732 { 11674 {
10733 this_var = &VAR_GAP_ENTRY(i, gap); 11675 this_var = &VAR_GAP_ENTRY(i, gap);
10734 if (this_var->var_name != NULL) 11676 if (this_var->v_name != NULL)
10735 { 11677 {
10736 if (var_flavour(this_var->var_name) == VAR_FLAVOUR_SESSION) 11678 if (var_flavour(this_var->v_name) == VAR_FLAVOUR_SESSION)
10737 { 11679 {
10738 /* Escapse special characters with a backslash. Turn a LF and 11680 /* Escapse special characters with a backslash. Turn a LF and
10739 * CR into \n and \r. */ 11681 * CR into \n and \r. */
10740 p = vim_strsave_escaped(get_var_string(this_var), 11682 p = vim_strsave_escaped(get_var_string(this_var),
10741 (char_u *)"\\\"\n\r"); 11683 (char_u *)"\\\"\n\r");
10745 if (*t == '\n') 11687 if (*t == '\n')
10746 *t = 'n'; 11688 *t = 'n';
10747 else if (*t == '\r') 11689 else if (*t == '\r')
10748 *t = 'r'; 11690 *t = 'r';
10749 if ((fprintf(fd, "let %s = %c%s%c", 11691 if ((fprintf(fd, "let %s = %c%s%c",
10750 this_var->var_name, 11692 this_var->v_name,
10751 (this_var->var_type == VAR_STRING) ? '"' : ' ', 11693 (this_var->tv.v_type == VAR_STRING) ? '"' : ' ',
10752 p, 11694 p,
10753 (this_var->var_type == VAR_STRING) ? '"' : ' ') < 0) 11695 (this_var->tv.v_type == VAR_STRING) ? '"' : ' ') < 0)
10754 || put_eol(fd) == FAIL) 11696 || put_eol(fd) == FAIL)
10755 { 11697 {
10756 vim_free(p); 11698 vim_free(p);
10757 return FAIL; 11699 return FAIL;
10758 } 11700 }