Mercurial > vim

comparison src/eval.c @ 71:7557b6ea0fb1 v7.0030

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.0030
author vimboss
date Tue, 04 Jan 2005 21:52:38 +0000
parents dbf53ece2e23
children 0ef9cebc4f5d
comparison
equal deleted inserted replaced
70:088a834ca0aa 71:7557b6ea0fb1
92 }; 92 };
93 93
94 typedef struct listvar_S listvar; 94 typedef struct listvar_S listvar;
95 95
96 #define VAR_LIST_MAXNEST 100 /* maximum nesting of lists */ 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"); 97 static char *e_letunexp = N_("E18: Unexpected characters in :let");
98 static char *e_listidx = N_("E999: list index out of range: %ld");
99 static char *e_undefvar = N_("E121: Undefined variable: %s");
100 static char *e_missbrac = N_("E111: Missing ']'");
101 static char *e_intern2 = N_("E999: Internal error: %s");
98 102
99 /* 103 /*
100 * All user-defined global variables are stored in "variables". 104 * All user-defined global variables are stored in "variables".
101 */ 105 */
102 garray_T variables = {0, 0, sizeof(var), 4, NULL}; 106 garray_T variables = {0, 0, sizeof(var), 4, NULL};
157 typeval *argvars; /* arguments */ 161 typeval *argvars; /* arguments */
158 var a0_var; /* "a:0" variable */ 162 var a0_var; /* "a:0" variable */
159 var firstline; /* "a:firstline" variable */ 163 var firstline; /* "a:firstline" variable */
160 var lastline; /* "a:lastline" variable */ 164 var lastline; /* "a:lastline" variable */
161 garray_T l_vars; /* local function variables */ 165 garray_T l_vars; /* local function variables */
162 typeval *retvar; /* return value variable */ 166 typeval *rettv; /* return value */
163 linenr_T breakpoint; /* next line with breakpoint or zero */ 167 linenr_T breakpoint; /* next line with breakpoint or zero */
164 int dbg_tick; /* debug_tick when breakpoint was set */ 168 int dbg_tick; /* debug_tick when breakpoint was set */
165 int level; /* top nesting level of executed function */ 169 int level; /* top nesting level of executed function */
166 }; 170 };
167 171
273 {"register", sizeof("register") - 1, NULL, VAR_STRING, VV_RO}, 277 {"register", sizeof("register") - 1, NULL, VAR_STRING, VV_RO},
274 {"cmdbang", sizeof("cmdbang") - 1, NULL, VAR_NUMBER, VV_RO}, 278 {"cmdbang", sizeof("cmdbang") - 1, NULL, VAR_NUMBER, VV_RO},
275 {"insertmode", sizeof("insertmode") - 1, NULL, VAR_STRING, VV_RO}, 279 {"insertmode", sizeof("insertmode") - 1, NULL, VAR_STRING, VV_RO},
276 }; 280 };
277 281
278 static int eval0 __ARGS((char_u *arg, VAR retvar, char_u **nextcmd, int evaluate)); 282 static int eval0 __ARGS((char_u *arg, typeval *rettv, char_u **nextcmd, int evaluate));
279 static int eval1 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 283 static int eval1 __ARGS((char_u **arg, typeval *rettv, int evaluate));
280 static int eval2 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 284 static int eval2 __ARGS((char_u **arg, typeval *rettv, int evaluate));
281 static int eval3 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 285 static int eval3 __ARGS((char_u **arg, typeval *rettv, int evaluate));
282 static int eval4 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 286 static int eval4 __ARGS((char_u **arg, typeval *rettv, int evaluate));
283 static int eval5 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 287 static int eval5 __ARGS((char_u **arg, typeval *rettv, int evaluate));
284 static int eval6 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 288 static int eval6 __ARGS((char_u **arg, typeval *rettv, int evaluate));
285 static int eval7 __ARGS((char_u **arg, typeval *retvar, int evaluate)); 289 static int eval7 __ARGS((char_u **arg, typeval *rettv, int evaluate));
286 static int eval_index __ARGS((char_u **arg, typeval *retvar, int evaluate)); 290 static int eval_index __ARGS((char_u **arg, typeval *rettv, int evaluate));
287 static int get_option_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate)); 291 static int get_option_tv __ARGS((char_u **arg, typeval *rettv, int evaluate));
288 static int get_string_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate)); 292 static int get_string_tv __ARGS((char_u **arg, typeval *rettv, int evaluate));
289 static int get_lit_string_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate)); 293 static int get_lit_string_tv __ARGS((char_u **arg, typeval *rettv, int evaluate));
290 static int get_list_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate)); 294 static int get_list_tv __ARGS((char_u **arg, typeval *rettv, int evaluate));
291 static listvar *list_alloc __ARGS((void)); 295 static listvar *list_alloc __ARGS((void));
292 static void list_unref __ARGS((listvar *l)); 296 static void list_unref __ARGS((listvar *l));
293 static void list_free __ARGS((listvar *l)); 297 static void list_free __ARGS((listvar *l));
294 static listitem *listitem_alloc __ARGS((void)); 298 static listitem *listitem_alloc __ARGS((void));
295 static void listitem_free __ARGS((listitem *item)); 299 static void listitem_free __ARGS((listitem *item));
299 static int list_append_tv __ARGS((listvar *l, typeval *tv)); 303 static int list_append_tv __ARGS((listvar *l, typeval *tv));
300 static listvar *list_copy __ARGS((listvar *orig, int deep)); 304 static listvar *list_copy __ARGS((listvar *orig, int deep));
301 static listitem *list_getrem __ARGS((listvar *l, long n)); 305 static listitem *list_getrem __ARGS((listvar *l, long n));
302 static char_u *list2string __ARGS((typeval *tv)); 306 static char_u *list2string __ARGS((typeval *tv));
303 static char_u *tv2string __ARGS((typeval *tv, char_u **tofree)); 307 static char_u *tv2string __ARGS((typeval *tv, char_u **tofree));
304 static int get_env_vartv __ARGS((char_u **arg, typeval *retvar, int evaluate)); 308 static int get_env_tv __ARGS((char_u **arg, typeval *rettv, int evaluate));
305 static int find_internal_func __ARGS((char_u *name)); 309 static int find_internal_func __ARGS((char_u *name));
306 static char_u *deref_func_name __ARGS((char_u *name, int *lenp)); 310 static char_u *deref_func_name __ARGS((char_u *name, int *lenp));
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)); 311 static int get_func_tv __ARGS((char_u *name, int len, typeval *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate));
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)); 312 static int call_func __ARGS((char_u *name, int len, typeval *rettv, int argcount, typeval *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate));
309 static void f_append __ARGS((typeval *argvars, typeval *retvar)); 313 static void f_append __ARGS((typeval *argvars, typeval *rettv));
310 static void f_argc __ARGS((typeval *argvars, typeval *retvar)); 314 static void f_argc __ARGS((typeval *argvars, typeval *rettv));
311 static void f_argidx __ARGS((typeval *argvars, typeval *retvar)); 315 static void f_argidx __ARGS((typeval *argvars, typeval *rettv));
312 static void f_argv __ARGS((typeval *argvars, typeval *retvar)); 316 static void f_argv __ARGS((typeval *argvars, typeval *rettv));
313 static void f_browse __ARGS((typeval *argvars, typeval *retvar)); 317 static void f_browse __ARGS((typeval *argvars, typeval *rettv));
314 static void f_browsedir __ARGS((typeval *argvars, typeval *retvar)); 318 static void f_browsedir __ARGS((typeval *argvars, typeval *rettv));
315 static buf_T *find_buffer __ARGS((typeval *avar)); 319 static buf_T *find_buffer __ARGS((typeval *avar));
316 static void f_bufexists __ARGS((typeval *argvars, typeval *retvar)); 320 static void f_bufexists __ARGS((typeval *argvars, typeval *rettv));
317 static void f_buflisted __ARGS((typeval *argvars, typeval *retvar)); 321 static void f_buflisted __ARGS((typeval *argvars, typeval *rettv));
318 static void f_bufloaded __ARGS((typeval *argvars, typeval *retvar)); 322 static void f_bufloaded __ARGS((typeval *argvars, typeval *rettv));
319 static buf_T *get_buf_vartv __ARGS((typeval *avar)); 323 static buf_T *get_buf_tv __ARGS((typeval *tv));
320 static void f_bufname __ARGS((typeval *argvars, typeval *retvar)); 324 static void f_bufname __ARGS((typeval *argvars, typeval *rettv));
321 static void f_bufnr __ARGS((typeval *argvars, typeval *retvar)); 325 static void f_bufnr __ARGS((typeval *argvars, typeval *rettv));
322 static void f_bufwinnr __ARGS((typeval *argvars, typeval *retvar)); 326 static void f_bufwinnr __ARGS((typeval *argvars, typeval *rettv));
323 static void f_byte2line __ARGS((typeval *argvars, typeval *retvar)); 327 static void f_byte2line __ARGS((typeval *argvars, typeval *rettv));
324 static void f_byteidx __ARGS((typeval *argvars, typeval *retvar)); 328 static void f_byteidx __ARGS((typeval *argvars, typeval *rettv));
325 static void f_char2nr __ARGS((typeval *argvars, typeval *retvar)); 329 static void f_char2nr __ARGS((typeval *argvars, typeval *rettv));
326 static void f_cindent __ARGS((typeval *argvars, typeval *retvar)); 330 static void f_cindent __ARGS((typeval *argvars, typeval *rettv));
327 static void f_col __ARGS((typeval *argvars, typeval *retvar)); 331 static void f_col __ARGS((typeval *argvars, typeval *rettv));
328 static void f_confirm __ARGS((typeval *argvars, typeval *retvar)); 332 static void f_confirm __ARGS((typeval *argvars, typeval *rettv));
329 static void f_copy __ARGS((typeval *argvars, typeval *retvar)); 333 static void f_copy __ARGS((typeval *argvars, typeval *rettv));
330 static void f_cscope_connection __ARGS((typeval *argvars, typeval *retvar)); 334 static void f_cscope_connection __ARGS((typeval *argvars, typeval *rettv));
331 static void f_cursor __ARGS((typeval *argsvars, typeval *retvar)); 335 static void f_cursor __ARGS((typeval *argsvars, typeval *rettv));
332 static void f_deepcopy __ARGS((typeval *argvars, typeval *retvar)); 336 static void f_deepcopy __ARGS((typeval *argvars, typeval *rettv));
333 static void f_delete __ARGS((typeval *argvars, typeval *retvar)); 337 static void f_delete __ARGS((typeval *argvars, typeval *rettv));
334 static void f_did_filetype __ARGS((typeval *argvars, typeval *retvar)); 338 static void f_did_filetype __ARGS((typeval *argvars, typeval *rettv));
335 static void f_diff_filler __ARGS((typeval *argvars, typeval *retvar)); 339 static void f_diff_filler __ARGS((typeval *argvars, typeval *rettv));
336 static void f_diff_hlID __ARGS((typeval *argvars, typeval *retvar)); 340 static void f_diff_hlID __ARGS((typeval *argvars, typeval *rettv));
337 static void f_escape __ARGS((typeval *argvars, typeval *retvar)); 341 static void f_escape __ARGS((typeval *argvars, typeval *rettv));
338 static void f_eventhandler __ARGS((typeval *argvars, typeval *retvar)); 342 static void f_eventhandler __ARGS((typeval *argvars, typeval *rettv));
339 static void f_executable __ARGS((typeval *argvars, typeval *retvar)); 343 static void f_executable __ARGS((typeval *argvars, typeval *rettv));
340 static void f_exists __ARGS((typeval *argvars, typeval *retvar)); 344 static void f_exists __ARGS((typeval *argvars, typeval *rettv));
341 static void f_expand __ARGS((typeval *argvars, typeval *retvar)); 345 static void f_expand __ARGS((typeval *argvars, typeval *rettv));
342 static void f_filereadable __ARGS((typeval *argvars, typeval *retvar)); 346 static void f_filereadable __ARGS((typeval *argvars, typeval *rettv));
343 static void f_filewritable __ARGS((typeval *argvars, typeval *retvar)); 347 static void f_filewritable __ARGS((typeval *argvars, typeval *rettv));
344 static void f_finddir __ARGS((typeval *argvars, typeval *retvar)); 348 static void f_finddir __ARGS((typeval *argvars, typeval *rettv));
345 static void f_findfile __ARGS((typeval *argvars, typeval *retvar)); 349 static void f_findfile __ARGS((typeval *argvars, typeval *rettv));
346 static void f_findfilendir __ARGS((typeval *argvars, typeval *retvar, int dir)); 350 static void f_findfilendir __ARGS((typeval *argvars, typeval *rettv, int dir));
347 static void f_fnamemodify __ARGS((typeval *argvars, typeval *retvar)); 351 static void f_fnamemodify __ARGS((typeval *argvars, typeval *rettv));
348 static void f_foldclosed __ARGS((typeval *argvars, typeval *retvar)); 352 static void f_foldclosed __ARGS((typeval *argvars, typeval *rettv));
349 static void f_foldclosedend __ARGS((typeval *argvars, typeval *retvar)); 353 static void f_foldclosedend __ARGS((typeval *argvars, typeval *rettv));
350 static void foldclosed_both __ARGS((typeval *argvars, typeval *retvar, int end)); 354 static void foldclosed_both __ARGS((typeval *argvars, typeval *rettv, int end));
351 static void f_foldlevel __ARGS((typeval *argvars, typeval *retvar)); 355 static void f_foldlevel __ARGS((typeval *argvars, typeval *rettv));
352 static void f_foldtext __ARGS((typeval *argvars, typeval *retvar)); 356 static void f_foldtext __ARGS((typeval *argvars, typeval *rettv));
353 static void f_foldtextresult __ARGS((typeval *argvars, typeval *retvar)); 357 static void f_foldtextresult __ARGS((typeval *argvars, typeval *rettv));
354 static void f_foreground __ARGS((typeval *argvars, typeval *retvar)); 358 static void f_foreground __ARGS((typeval *argvars, typeval *rettv));
355 static void f_function __ARGS((typeval *argvars, typeval *retvar)); 359 static void f_function __ARGS((typeval *argvars, typeval *rettv));
356 static void f_getbufvar __ARGS((typeval *argvars, typeval *retvar)); 360 static void f_getbufvar __ARGS((typeval *argvars, typeval *rettv));
357 static void f_getchar __ARGS((typeval *argvars, typeval *retvar)); 361 static void f_getchar __ARGS((typeval *argvars, typeval *rettv));
358 static void f_getcharmod __ARGS((typeval *argvars, typeval *retvar)); 362 static void f_getcharmod __ARGS((typeval *argvars, typeval *rettv));
359 static void f_getcmdline __ARGS((typeval *argvars, typeval *retvar)); 363 static void f_getcmdline __ARGS((typeval *argvars, typeval *rettv));
360 static void f_getcmdpos __ARGS((typeval *argvars, typeval *retvar)); 364 static void f_getcmdpos __ARGS((typeval *argvars, typeval *rettv));
361 static void f_getcwd __ARGS((typeval *argvars, typeval *retvar)); 365 static void f_getcwd __ARGS((typeval *argvars, typeval *rettv));
362 static void f_getfontname __ARGS((typeval *argvars, typeval *retvar)); 366 static void f_getfontname __ARGS((typeval *argvars, typeval *rettv));
363 static void f_getfperm __ARGS((typeval *argvars, typeval *retvar)); 367 static void f_getfperm __ARGS((typeval *argvars, typeval *rettv));
364 static void f_getfsize __ARGS((typeval *argvars, typeval *retvar)); 368 static void f_getfsize __ARGS((typeval *argvars, typeval *rettv));
365 static void f_getftime __ARGS((typeval *argvars, typeval *retvar)); 369 static void f_getftime __ARGS((typeval *argvars, typeval *rettv));
366 static void f_getftype __ARGS((typeval *argvars, typeval *retvar)); 370 static void f_getftype __ARGS((typeval *argvars, typeval *rettv));
367 static void f_getline __ARGS((typeval *argvars, typeval *retvar)); 371 static void f_getline __ARGS((typeval *argvars, typeval *rettv));
368 static void f_getreg __ARGS((typeval *argvars, typeval *retvar)); 372 static void f_getreg __ARGS((typeval *argvars, typeval *rettv));
369 static void f_getregtype __ARGS((typeval *argvars, typeval *retvar)); 373 static void f_getregtype __ARGS((typeval *argvars, typeval *rettv));
370 static void f_getwinposx __ARGS((typeval *argvars, typeval *retvar)); 374 static void f_getwinposx __ARGS((typeval *argvars, typeval *rettv));
371 static void f_getwinposy __ARGS((typeval *argvars, typeval *retvar)); 375 static void f_getwinposy __ARGS((typeval *argvars, typeval *rettv));
372 static void f_getwinvar __ARGS((typeval *argvars, typeval *retvar)); 376 static void f_getwinvar __ARGS((typeval *argvars, typeval *rettv));
373 static void f_glob __ARGS((typeval *argvars, typeval *retvar)); 377 static void f_glob __ARGS((typeval *argvars, typeval *rettv));
374 static void f_globpath __ARGS((typeval *argvars, typeval *retvar)); 378 static void f_globpath __ARGS((typeval *argvars, typeval *rettv));
375 static void f_has __ARGS((typeval *argvars, typeval *retvar)); 379 static void f_has __ARGS((typeval *argvars, typeval *rettv));
376 static void f_hasmapto __ARGS((typeval *argvars, typeval *retvar)); 380 static void f_hasmapto __ARGS((typeval *argvars, typeval *rettv));
377 static void f_histadd __ARGS((typeval *argvars, typeval *retvar)); 381 static void f_histadd __ARGS((typeval *argvars, typeval *rettv));
378 static void f_histdel __ARGS((typeval *argvars, typeval *retvar)); 382 static void f_histdel __ARGS((typeval *argvars, typeval *rettv));
379 static void f_histget __ARGS((typeval *argvars, typeval *retvar)); 383 static void f_histget __ARGS((typeval *argvars, typeval *rettv));
380 static void f_histnr __ARGS((typeval *argvars, typeval *retvar)); 384 static void f_histnr __ARGS((typeval *argvars, typeval *rettv));
381 static void f_hlexists __ARGS((typeval *argvars, typeval *retvar)); 385 static void f_hlexists __ARGS((typeval *argvars, typeval *rettv));
382 static void f_hlID __ARGS((typeval *argvars, typeval *retvar)); 386 static void f_hlID __ARGS((typeval *argvars, typeval *rettv));
383 static void f_hostname __ARGS((typeval *argvars, typeval *retvar)); 387 static void f_hostname __ARGS((typeval *argvars, typeval *rettv));
384 static void f_iconv __ARGS((typeval *argvars, typeval *retvar)); 388 static void f_iconv __ARGS((typeval *argvars, typeval *rettv));
385 static void f_indent __ARGS((typeval *argvars, typeval *retvar)); 389 static void f_indent __ARGS((typeval *argvars, typeval *rettv));
386 static void f_insert __ARGS((typeval *argvars, typeval *retvar)); 390 static void f_insert __ARGS((typeval *argvars, typeval *rettv));
387 static void f_isdirectory __ARGS((typeval *argvars, typeval *retvar)); 391 static void f_isdirectory __ARGS((typeval *argvars, typeval *rettv));
388 static void f_input __ARGS((typeval *argvars, typeval *retvar)); 392 static void f_input __ARGS((typeval *argvars, typeval *rettv));
389 static void f_inputdialog __ARGS((typeval *argvars, typeval *retvar)); 393 static void f_inputdialog __ARGS((typeval *argvars, typeval *rettv));
390 static void f_inputrestore __ARGS((typeval *argvars, typeval *retvar)); 394 static void f_inputrestore __ARGS((typeval *argvars, typeval *rettv));
391 static void f_inputsave __ARGS((typeval *argvars, typeval *retvar)); 395 static void f_inputsave __ARGS((typeval *argvars, typeval *rettv));
392 static void f_inputsecret __ARGS((typeval *argvars, typeval *retvar)); 396 static void f_inputsecret __ARGS((typeval *argvars, typeval *rettv));
393 static void f_last_buffer_nr __ARGS((typeval *argvars, typeval *retvar)); 397 static void f_last_buffer_nr __ARGS((typeval *argvars, typeval *rettv));
394 static void f_len __ARGS((typeval *argvars, typeval *retvar)); 398 static void f_len __ARGS((typeval *argvars, typeval *rettv));
395 static void f_libcall __ARGS((typeval *argvars, typeval *retvar)); 399 static void f_libcall __ARGS((typeval *argvars, typeval *rettv));
396 static void f_libcallnr __ARGS((typeval *argvars, typeval *retvar)); 400 static void f_libcallnr __ARGS((typeval *argvars, typeval *rettv));
397 static void libcall_common __ARGS((typeval *argvars, typeval *retvar, int type)); 401 static void libcall_common __ARGS((typeval *argvars, typeval *rettv, int type));
398 static void f_line __ARGS((typeval *argvars, typeval *retvar)); 402 static void f_line __ARGS((typeval *argvars, typeval *rettv));
399 static void f_line2byte __ARGS((typeval *argvars, typeval *retvar)); 403 static void f_line2byte __ARGS((typeval *argvars, typeval *rettv));
400 static void f_lispindent __ARGS((typeval *argvars, typeval *retvar)); 404 static void f_lispindent __ARGS((typeval *argvars, typeval *rettv));
401 static void f_localtime __ARGS((typeval *argvars, typeval *retvar)); 405 static void f_localtime __ARGS((typeval *argvars, typeval *rettv));
402 static void f_maparg __ARGS((typeval *argvars, typeval *retvar)); 406 static void f_maparg __ARGS((typeval *argvars, typeval *rettv));
403 static void f_mapcheck __ARGS((typeval *argvars, typeval *retvar)); 407 static void f_mapcheck __ARGS((typeval *argvars, typeval *rettv));
404 static void get_maparg __ARGS((typeval *argvars, typeval *retvar, int exact)); 408 static void get_maparg __ARGS((typeval *argvars, typeval *rettv, int exact));
405 static void f_match __ARGS((typeval *argvars, typeval *retvar)); 409 static void f_match __ARGS((typeval *argvars, typeval *rettv));
406 static void f_matchend __ARGS((typeval *argvars, typeval *retvar)); 410 static void f_matchend __ARGS((typeval *argvars, typeval *rettv));
407 static void f_matchstr __ARGS((typeval *argvars, typeval *retvar)); 411 static void f_matchstr __ARGS((typeval *argvars, typeval *rettv));
408 static void f_mode __ARGS((typeval *argvars, typeval *retvar)); 412 static void f_mode __ARGS((typeval *argvars, typeval *rettv));
409 static void f_nextnonblank __ARGS((typeval *argvars, typeval *retvar)); 413 static void f_nextnonblank __ARGS((typeval *argvars, typeval *rettv));
410 static void f_nr2char __ARGS((typeval *argvars, typeval *retvar)); 414 static void f_nr2char __ARGS((typeval *argvars, typeval *rettv));
411 static void f_prevnonblank __ARGS((typeval *argvars, typeval *retvar)); 415 static void f_prevnonblank __ARGS((typeval *argvars, typeval *rettv));
412 static void f_setbufvar __ARGS((typeval *argvars, typeval *retvar)); 416 static void f_setbufvar __ARGS((typeval *argvars, typeval *rettv));
413 static void f_setcmdpos __ARGS((typeval *argvars, typeval *retvar)); 417 static void f_setcmdpos __ARGS((typeval *argvars, typeval *rettv));
414 static void f_setwinvar __ARGS((typeval *argvars, typeval *retvar)); 418 static void f_setwinvar __ARGS((typeval *argvars, typeval *rettv));
415 static void f_remove __ARGS((typeval *argvars, typeval *retvar)); 419 static void f_remove __ARGS((typeval *argvars, typeval *rettv));
416 static void f_rename __ARGS((typeval *argvars, typeval *retvar)); 420 static void f_rename __ARGS((typeval *argvars, typeval *rettv));
417 static void f_resolve __ARGS((typeval *argvars, typeval *retvar)); 421 static void f_resolve __ARGS((typeval *argvars, typeval *rettv));
418 static void f_search __ARGS((typeval *argvars, typeval *retvar)); 422 static void f_search __ARGS((typeval *argvars, typeval *rettv));
419 static void f_searchpair __ARGS((typeval *argvars, typeval *retvar)); 423 static void f_searchpair __ARGS((typeval *argvars, typeval *rettv));
420 static int get_search_arg __ARGS((typeval *varp, int *flagsp)); 424 static int get_search_arg __ARGS((typeval *varp, int *flagsp));
421 static void f_remote_expr __ARGS((typeval *argvars, typeval *retvar)); 425 static void f_remote_expr __ARGS((typeval *argvars, typeval *rettv));
422 static void f_remote_foreground __ARGS((typeval *argvars, typeval *retvar)); 426 static void f_remote_foreground __ARGS((typeval *argvars, typeval *rettv));
423 static void f_remote_peek __ARGS((typeval *argvars, typeval *retvar)); 427 static void f_remote_peek __ARGS((typeval *argvars, typeval *rettv));
424 static void f_remote_read __ARGS((typeval *argvars, typeval *retvar)); 428 static void f_remote_read __ARGS((typeval *argvars, typeval *rettv));
425 static void f_remote_send __ARGS((typeval *argvars, typeval *retvar)); 429 static void f_remote_send __ARGS((typeval *argvars, typeval *rettv));
426 static void f_repeat __ARGS((typeval *argvars, typeval *retvar)); 430 static void f_repeat __ARGS((typeval *argvars, typeval *rettv));
427 static void f_server2client __ARGS((typeval *argvars, typeval *retvar)); 431 static void f_server2client __ARGS((typeval *argvars, typeval *rettv));
428 static void f_serverlist __ARGS((typeval *argvars, typeval *retvar)); 432 static void f_serverlist __ARGS((typeval *argvars, typeval *rettv));
429 static void f_setline __ARGS((typeval *argvars, typeval *retvar)); 433 static void f_setline __ARGS((typeval *argvars, typeval *rettv));
430 static void f_setreg __ARGS((typeval *argvars, typeval *retvar)); 434 static void f_setreg __ARGS((typeval *argvars, typeval *rettv));
431 static void f_simplify __ARGS((typeval *argvars, typeval *retvar)); 435 static void f_simplify __ARGS((typeval *argvars, typeval *rettv));
432 static void find_some_match __ARGS((typeval *argvars, typeval *retvar, int start)); 436 static void find_some_match __ARGS((typeval *argvars, typeval *rettv, int start));
433 static void f_strftime __ARGS((typeval *argvars, typeval *retvar)); 437 static void f_strftime __ARGS((typeval *argvars, typeval *rettv));
434 static void f_stridx __ARGS((typeval *argvars, typeval *retvar)); 438 static void f_stridx __ARGS((typeval *argvars, typeval *rettv));
435 static void f_string __ARGS((typeval *argvars, typeval *retvar)); 439 static void f_string __ARGS((typeval *argvars, typeval *rettv));
436 static void f_strlen __ARGS((typeval *argvars, typeval *retvar)); 440 static void f_strlen __ARGS((typeval *argvars, typeval *rettv));
437 static void f_strpart __ARGS((typeval *argvars, typeval *retvar)); 441 static void f_strpart __ARGS((typeval *argvars, typeval *rettv));
438 static void f_strridx __ARGS((typeval *argvars, typeval *retvar)); 442 static void f_strridx __ARGS((typeval *argvars, typeval *rettv));
439 static void f_strtrans __ARGS((typeval *argvars, typeval *retvar)); 443 static void f_strtrans __ARGS((typeval *argvars, typeval *rettv));
440 static void f_synID __ARGS((typeval *argvars, typeval *retvar)); 444 static void f_synID __ARGS((typeval *argvars, typeval *rettv));
441 static void f_synIDattr __ARGS((typeval *argvars, typeval *retvar)); 445 static void f_synIDattr __ARGS((typeval *argvars, typeval *rettv));
442 static void f_synIDtrans __ARGS((typeval *argvars, typeval *retvar)); 446 static void f_synIDtrans __ARGS((typeval *argvars, typeval *rettv));
443 static void f_system __ARGS((typeval *argvars, typeval *retvar)); 447 static void f_system __ARGS((typeval *argvars, typeval *rettv));
444 static void f_submatch __ARGS((typeval *argvars, typeval *retvar)); 448 static void f_submatch __ARGS((typeval *argvars, typeval *rettv));
445 static void f_substitute __ARGS((typeval *argvars, typeval *retvar)); 449 static void f_substitute __ARGS((typeval *argvars, typeval *rettv));
446 static void f_tempname __ARGS((typeval *argvars, typeval *retvar)); 450 static void f_tempname __ARGS((typeval *argvars, typeval *rettv));
447 static void f_tolower __ARGS((typeval *argvars, typeval *retvar)); 451 static void f_tolower __ARGS((typeval *argvars, typeval *rettv));
448 static void f_toupper __ARGS((typeval *argvars, typeval *retvar)); 452 static void f_toupper __ARGS((typeval *argvars, typeval *rettv));
449 static void f_tr __ARGS((typeval *argvars, typeval *retvar)); 453 static void f_tr __ARGS((typeval *argvars, typeval *rettv));
450 static void f_type __ARGS((typeval *argvars, typeval *retvar)); 454 static void f_type __ARGS((typeval *argvars, typeval *rettv));
451 static void f_virtcol __ARGS((typeval *argvars, typeval *retvar)); 455 static void f_virtcol __ARGS((typeval *argvars, typeval *rettv));
452 static void f_visualmode __ARGS((typeval *argvars, typeval *retvar)); 456 static void f_visualmode __ARGS((typeval *argvars, typeval *rettv));
453 static void f_winbufnr __ARGS((typeval *argvars, typeval *retvar)); 457 static void f_winbufnr __ARGS((typeval *argvars, typeval *rettv));
454 static void f_wincol __ARGS((typeval *argvars, typeval *retvar)); 458 static void f_wincol __ARGS((typeval *argvars, typeval *rettv));
455 static void f_winheight __ARGS((typeval *argvars, typeval *retvar)); 459 static void f_winheight __ARGS((typeval *argvars, typeval *rettv));
456 static void f_winline __ARGS((typeval *argvars, typeval *retvar)); 460 static void f_winline __ARGS((typeval *argvars, typeval *rettv));
457 static void f_winnr __ARGS((typeval *argvars, typeval *retvar)); 461 static void f_winnr __ARGS((typeval *argvars, typeval *rettv));
458 static void f_winrestcmd __ARGS((typeval *argvars, typeval *retvar)); 462 static void f_winrestcmd __ARGS((typeval *argvars, typeval *rettv));
459 static void f_winwidth __ARGS((typeval *argvars, typeval *retvar)); 463 static void f_winwidth __ARGS((typeval *argvars, typeval *rettv));
460 static win_T *find_win_by_nr __ARGS((typeval *vp)); 464 static win_T *find_win_by_nr __ARGS((typeval *vp));
461 static pos_T *var2fpos __ARGS((typeval *varp, int lnum)); 465 static pos_T *var2fpos __ARGS((typeval *varp, int lnum));
462 static int get_env_len __ARGS((char_u **arg)); 466 static int get_env_len __ARGS((char_u **arg));
463 static int get_id_len __ARGS((char_u **arg)); 467 static int get_id_len __ARGS((char_u **arg));
464 static int get_func_len __ARGS((char_u **arg, char_u **alias, int evaluate)); 468 static int get_func_len __ARGS((char_u **arg, char_u **alias, int evaluate));
465 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end)); 469 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int incl_br));
466 static int eval_isnamec __ARGS((int c)); 470 static int eval_isnamec __ARGS((int c));
467 static int find_vim_var __ARGS((char_u *name, int len)); 471 static int find_vim_var __ARGS((char_u *name, int len));
468 static int get_var_vartv __ARGS((char_u *name, int len, typeval *retvar)); 472 static int get_var_tv __ARGS((char_u *name, int len, typeval *rettv));
469 static VAR alloc_var __ARGS((void)); 473 static typeval *alloc_tv __ARGS((void));
470 static typeval *alloc_vartv __ARGS((void)); 474 static typeval *alloc_string_tv __ARGS((char_u *string));
471 static typeval *alloc_string_vartv __ARGS((char_u *string)); 475 static void free_tv __ARGS((typeval *varp));
472 static void free_vartv __ARGS((typeval *varp)); 476 static void clear_tv __ARGS((typeval *varp));
473 static void clear_vartv __ARGS((typeval *varp)); 477 static void init_tv __ARGS((typeval *varp));
474 static long get_vartv_number __ARGS((typeval *varp)); 478 static long get_tv_number __ARGS((typeval *varp));
475 static linenr_T get_vartv_lnum __ARGS((typeval *argvars)); 479 static linenr_T get_tv_lnum __ARGS((typeval *argvars));
476 static char_u *get_vartv_string __ARGS((typeval *varp)); 480 static char_u *get_tv_string __ARGS((typeval *varp));
477 static char_u *get_vartv_string_buf __ARGS((typeval *varp, char_u *buf)); 481 static char_u *get_tv_string_buf __ARGS((typeval *varp, char_u *buf));
478 static VAR find_var __ARGS((char_u *name, int writing)); 482 static VAR find_var __ARGS((char_u *name, int writing));
479 static VAR find_var_in_ga __ARGS((garray_T *gap, char_u *varname)); 483 static VAR find_var_in_ga __ARGS((garray_T *gap, char_u *varname));
480 static garray_T *find_var_ga __ARGS((char_u *name, char_u **varname)); 484 static garray_T *find_var_ga __ARGS((char_u *name, char_u **varname));
481 static void clear_var __ARGS((VAR v)); 485 static void clear_var __ARGS((VAR v));
482 static void list_one_var __ARGS((VAR v, char_u *prefix)); 486 static void list_one_var __ARGS((VAR v, char_u *prefix));
483 static void list_vim_var __ARGS((int i)); 487 static void list_vim_var __ARGS((int i));
484 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string)); 488 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string));
485 static void set_var __ARGS((char_u *name, typeval *varp, int copy)); 489 static void set_var __ARGS((char_u *name, typeval *varp, int copy));
486 static void copy_vartv __ARGS((typeval *from, typeval *to)); 490 static void copy_tv __ARGS((typeval *from, typeval *to));
487 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags)); 491 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags));
488 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int internal)); 492 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int internal));
489 static int eval_fname_script __ARGS((char_u *p)); 493 static int eval_fname_script __ARGS((char_u *p));
490 static int eval_fname_sid __ARGS((char_u *p)); 494 static int eval_fname_sid __ARGS((char_u *p));
491 static void list_func_head __ARGS((ufunc_T *fp, int indent)); 495 static void list_func_head __ARGS((ufunc_T *fp, int indent));
492 static void cat_func_name __ARGS((char_u *buf, ufunc_T *fp)); 496 static void cat_func_name __ARGS((char_u *buf, ufunc_T *fp));
493 static ufunc_T *find_func __ARGS((char_u *name)); 497 static ufunc_T *find_func __ARGS((char_u *name));
494 static int function_exists __ARGS((char_u *name)); 498 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)); 499 static void call_user_func __ARGS((ufunc_T *fp, int argcount, typeval *argvars, typeval *rettv, linenr_T firstline, linenr_T lastline));
496 500
497 #define get_var_string(p) get_vartv_string(&(p)->tv) 501 #define get_var_string(p) get_tv_string(&(p)->tv)
498 #define get_var_string_buf(p, b) get_vartv_string_buf(&(p)->tv, (b)) 502 #define get_var_string_buf(p, b) get_tv_string_buf(&(p)->tv, (b))
499 #define get_var_number(p) get_vartv_number(&((p)->tv)) 503 #define get_var_number(p) get_tv_number(&((p)->tv))
500 504
501 /* Magic braces are always enabled, otherwise Vim scripts would not be
502 * portable. */
503 #define FEAT_MAGIC_BRACES
504
505 #ifdef FEAT_MAGIC_BRACES
506 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end)); 505 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
507 #endif 506
507 static void list_all_vars __ARGS((void));
508 static char_u *list_arg_vars __ARGS((exarg_T *eap, char_u *arg));
509 static char_u *ex_let_one __ARGS((char_u *arg, typeval *tv, int copy, char_u *endchars));
510 static char_u *set_var_idx __ARGS((char_u *name, char_u *ip, typeval *rettv, int copy, char_u *endchars));
508 511
509 /* 512 /*
510 * Set an internal variable to a string value. Creates the variable if it does 513 * Set an internal variable to a string value. Creates the variable if it does
511 * not already exist. 514 * not already exist.
512 */ 515 */
519 typeval *tvp; 522 typeval *tvp;
520 523
521 val = vim_strsave(value); 524 val = vim_strsave(value);
522 if (val != NULL) 525 if (val != NULL)
523 { 526 {
524 tvp = alloc_string_vartv(val); 527 tvp = alloc_string_tv(val);
525 if (tvp != NULL) 528 if (tvp != NULL)
526 { 529 {
527 set_var(name, tvp, FALSE); 530 set_var(name, tvp, FALSE);
528 free_vartv(tvp); 531 free_tv(tvp);
529 } 532 }
530 } 533 }
531 } 534 }
532 535
533 # if defined(FEAT_MBYTE) || defined(PROTO) 536 # if defined(FEAT_MBYTE) || defined(PROTO)
627 char_u *arg; 630 char_u *arg;
628 int *error; 631 int *error;
629 char_u **nextcmd; 632 char_u **nextcmd;
630 int skip; /* only parse, don't execute */ 633 int skip; /* only parse, don't execute */
631 { 634 {
632 var retvar; 635 typeval tv;
633 int retval = FALSE; 636 int retval = FALSE;
634 637
635 if (skip) 638 if (skip)
636 ++emsg_skip; 639 ++emsg_skip;
637 if (eval0(arg, &retvar, nextcmd, !skip) == FAIL) 640 if (eval0(arg, &tv, nextcmd, !skip) == FAIL)
638 {
639 *error = TRUE; 641 *error = TRUE;
640 }
641 else 642 else
642 { 643 {
643 *error = FALSE; 644 *error = FALSE;
644 if (!skip) 645 if (!skip)
645 { 646 {
646 retval = (get_var_number(&retvar) != 0); 647 retval = (get_tv_number(&tv) != 0);
647 clear_vartv(&retvar.tv); 648 clear_tv(&tv);
648 } 649 }
649 } 650 }
650 if (skip) 651 if (skip)
651 --emsg_skip; 652 --emsg_skip;
652 653
662 eval_to_string_skip(arg, nextcmd, skip) 663 eval_to_string_skip(arg, nextcmd, skip)
663 char_u *arg; 664 char_u *arg;
664 char_u **nextcmd; 665 char_u **nextcmd;
665 int skip; /* only parse, don't execute */ 666 int skip; /* only parse, don't execute */
666 { 667 {
667 var retvar; 668 typeval tv;
668 char_u *retval; 669 char_u *retval;
669 670
670 if (skip) 671 if (skip)
671 ++emsg_skip; 672 ++emsg_skip;
672 if (eval0(arg, &retvar, nextcmd, !skip) == FAIL || skip) 673 if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip)
673 retval = NULL; 674 retval = NULL;
674 else 675 else
675 { 676 {
676 retval = vim_strsave(get_var_string(&retvar)); 677 retval = vim_strsave(get_tv_string(&tv));
677 clear_vartv(&retvar.tv); 678 clear_tv(&tv);
678 } 679 }
679 if (skip) 680 if (skip)
680 --emsg_skip; 681 --emsg_skip;
681 682
682 return retval; 683 return retval;
688 */ 689 */
689 int 690 int
690 skip_expr(pp) 691 skip_expr(pp)
691 char_u **pp; 692 char_u **pp;
692 { 693 {
693 typeval retvar; 694 typeval rettv;
694 695
695 *pp = skipwhite(*pp); 696 *pp = skipwhite(*pp);
696 return eval1(pp, &retvar, FALSE); 697 return eval1(pp, &rettv, FALSE);
697 } 698 }
698 699
699 /* 700 /*
700 * Top level evaluation function, returning a string. 701 * Top level evaluation function, returning a string.
701 * Return pointer to allocated memory, or NULL for failure. 702 * Return pointer to allocated memory, or NULL for failure.
703 char_u * 704 char_u *
704 eval_to_string(arg, nextcmd) 705 eval_to_string(arg, nextcmd)
705 char_u *arg; 706 char_u *arg;
706 char_u **nextcmd; 707 char_u **nextcmd;
707 { 708 {
708 var retvar; 709 typeval tv;
709 char_u *retval; 710 char_u *retval;
710 711
711 if (eval0(arg, &retvar, nextcmd, TRUE) == FAIL) 712 if (eval0(arg, &tv, nextcmd, TRUE) == FAIL)
712 retval = NULL; 713 retval = NULL;
713 else 714 else
714 { 715 {
715 retval = vim_strsave(get_var_string(&retvar)); 716 retval = vim_strsave(get_tv_string(&tv));
716 clear_vartv(&retvar.tv); 717 clear_tv(&tv);
717 } 718 }
718 719
719 return retval; 720 return retval;
720 } 721 }
721 722
747 */ 748 */
748 char_u * 749 char_u *
749 eval_arg_to_string(arg) 750 eval_arg_to_string(arg)
750 char_u **arg; 751 char_u **arg;
751 { 752 {
752 typeval retvar; 753 typeval rettv;
753 char_u *retval; 754 char_u *retval;
754 int ret; 755 int ret;
755 756
756 ++emsg_off; 757 ++emsg_off;
757 758
758 ret = eval1(arg, &retvar, TRUE); 759 ret = eval1(arg, &rettv, TRUE);
759 if (ret == FAIL) 760 if (ret == FAIL)
760 retval = NULL; 761 retval = NULL;
761 else 762 else
762 { 763 {
763 retval = vim_strsave(get_vartv_string(&retvar)); 764 retval = vim_strsave(get_tv_string(&rettv));
764 clear_vartv(&retvar); 765 clear_tv(&rettv);
765 } 766 }
766 767
767 --emsg_off; 768 --emsg_off;
768 769
769 return retval; 770 return retval;
777 */ 778 */
778 int 779 int
779 eval_to_number(expr) 780 eval_to_number(expr)
780 char_u *expr; 781 char_u *expr;
781 { 782 {
782 typeval retvar; 783 typeval rettv;
783 int retval; 784 int retval;
784 char_u *p = expr; 785 char_u *p = expr;
785 786
786 ++emsg_off; 787 ++emsg_off;
787 788
788 if (eval1(&p, &retvar, TRUE) == FAIL) 789 if (eval1(&p, &rettv, TRUE) == FAIL)
789 retval = -1; 790 retval = -1;
790 else 791 else
791 { 792 {
792 retval = get_vartv_number(&retvar); 793 retval = get_tv_number(&rettv);
793 clear_vartv(&retvar); 794 clear_tv(&rettv);
794 } 795 }
795 --emsg_off; 796 --emsg_off;
796 797
797 return retval; 798 return retval;
798 } 799 }
808 int argc; 809 int argc;
809 char_u **argv; 810 char_u **argv;
810 int safe; /* use the sandbox */ 811 int safe; /* use the sandbox */
811 { 812 {
812 char_u *retval = NULL; 813 char_u *retval = NULL;
813 var retvar; 814 typeval rettv;
814 typeval *argvars; 815 typeval *argvars;
815 long n; 816 long n;
816 int len; 817 int len;
817 int i; 818 int i;
818 int doesrange; 819 int doesrange;
850 { 851 {
851 save_funccalp = save_funccal(); 852 save_funccalp = save_funccal();
852 ++sandbox; 853 ++sandbox;
853 } 854 }
854 855
855 retvar.tv.v_type = VAR_UNKNOWN; /* clear_vartv() uses this */ 856 rettv.v_type = VAR_UNKNOWN; /* clear_tv() uses this */
856 if (call_func(func, (int)STRLEN(func), &retvar.tv, argc, argvars, 857 if (call_func(func, (int)STRLEN(func), &rettv, argc, argvars,
857 curwin->w_cursor.lnum, curwin->w_cursor.lnum, 858 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
858 &doesrange, TRUE) == OK) 859 &doesrange, TRUE) == OK)
859 retval = vim_strsave(get_var_string(&retvar)); 860 retval = vim_strsave(get_tv_string(&rettv));
860 861
861 clear_vartv(&retvar.tv); 862 clear_tv(&rettv);
862 vim_free(argvars); 863 vim_free(argvars);
863 864
864 if (safe) 865 if (safe)
865 { 866 {
866 --sandbox; 867 --sandbox;
899 int 900 int
900 eval_foldexpr(arg, cp) 901 eval_foldexpr(arg, cp)
901 char_u *arg; 902 char_u *arg;
902 int *cp; 903 int *cp;
903 { 904 {
904 var retvar; 905 typeval tv;
905 int retval; 906 int retval;
906 char_u *s; 907 char_u *s;
907 908
908 ++emsg_off; 909 ++emsg_off;
909 ++sandbox; 910 ++sandbox;
910 *cp = NUL; 911 *cp = NUL;
911 if (eval0(arg, &retvar, NULL, TRUE) == FAIL) 912 if (eval0(arg, &tv, NULL, TRUE) == FAIL)
912 retval = 0; 913 retval = 0;
913 else 914 else
914 { 915 {
915 /* If the result is a number, just return the number. */ 916 /* If the result is a number, just return the number. */
916 if (retvar.tv.v_type == VAR_NUMBER) 917 if (tv.v_type == VAR_NUMBER)
917 retval = retvar.tv.vval.v_number; 918 retval = tv.vval.v_number;
918 else if (retvar.tv.v_type == VAR_UNKNOWN 919 else if (tv.v_type == VAR_UNKNOWN
919 || retvar.tv.vval.v_string == NULL) 920 || tv.vval.v_string == NULL)
920 retval = 0; 921 retval = 0;
921 else 922 else
922 { 923 {
923 /* If the result is a string, check if there is a non-digit before 924 /* If the result is a string, check if there is a non-digit before
924 * the number. */ 925 * the number. */
925 s = retvar.tv.vval.v_string; 926 s = tv.vval.v_string;
926 if (!VIM_ISDIGIT(*s) && *s != '-') 927 if (!VIM_ISDIGIT(*s) && *s != '-')
927 *cp = *s++; 928 *cp = *s++;
928 retval = atol((char *)s); 929 retval = atol((char *)s);
929 } 930 }
930 clear_vartv(&retvar.tv); 931 clear_tv(&tv);
931 } 932 }
932 --emsg_off; 933 --emsg_off;
933 --sandbox; 934 --sandbox;
934 935
935 return retval; 936 return retval;
936 } 937 }
937 #endif 938 #endif
938 939
939 #ifdef FEAT_MAGIC_BRACES
940 /* 940 /*
941 * Expands out the 'magic' {}'s in a variable/function name. 941 * Expands out the 'magic' {}'s in a variable/function name.
942 * Note that this can call itself recursively, to deal with 942 * Note that this can call itself recursively, to deal with
943 * constructs like foo{bar}{baz}{bam} 943 * constructs like foo{bar}{baz}{bam}
944 * The four pointer arguments point to "foo{expre}ss{ion}bar" 944 * The four pointer arguments point to "foo{expre}ss{ion}bar"
988 *expr_start = '{'; 988 *expr_start = '{';
989 *expr_end = '}'; 989 *expr_end = '}';
990 990
991 if (retval != NULL) 991 if (retval != NULL)
992 { 992 {
993 temp_result = find_name_end(retval, &expr_start, &expr_end); 993 temp_result = find_name_end(retval, &expr_start, &expr_end, FALSE);
994 if (expr_start != NULL) 994 if (expr_start != NULL)
995 { 995 {
996 /* Further expansion! */ 996 /* Further expansion! */
997 temp_result = make_expanded_name(retval, expr_start, 997 temp_result = make_expanded_name(retval, expr_start,
998 expr_end, temp_result); 998 expr_end, temp_result);
1002 } 1002 }
1003 1003
1004 return retval; 1004 return retval;
1005 1005
1006 } 1006 }
1007 #endif /* FEAT_MAGIC_BRACES */ 1007
1008 1008 /*
1009 /* 1009 * ":let" list all variable values
1010 * ":let var = expr" assignment command. 1010 * ":let var1 var2" list variable values
1011 * ":let var" list one variable value 1011 * ":let var = expr" assignment command.
1012 * ":let" list all variable values 1012 * ":let [var1, var2] = expr" unpack list.
1013 */ 1013 */
1014 void 1014 void
1015 ex_let(eap) 1015 ex_let(eap)
1016 exarg_T *eap; 1016 exarg_T *eap;
1017 { 1017 {
1018 char_u *arg = eap->arg; 1018 char_u *arg = eap->arg;
1019 char_u *expr; 1019 char_u *expr = NULL;
1020 char_u *name; 1020 typeval rettv;
1021 VAR varp;
1022 var retvar;
1023 char_u *p;
1024 int c1 = 0, c2;
1025 int i; 1021 int i;
1022 int var_count = 0;
1023 int semicolon = 0;
1024 listvar *l;
1025 listitem *item;
1026
1027 if (*arg != '[')
1028 expr = vim_strchr(find_name_end(arg, NULL, NULL, TRUE), '=');
1029 if (*arg != '[' && expr == NULL)
1030 {
1031 if (!ends_excmd(*arg))
1032 /* ":let var1 var2" */
1033 arg = list_arg_vars(eap, arg);
1034 else if (!eap->skip)
1035 /* ":let" */
1036 list_all_vars();
1037 eap->nextcmd = check_nextcmd(arg);
1038 }
1039 else
1040 {
1041 if (*arg == '[')
1042 {
1043 /* ":let [a, b] = expr": find the matching ']' to get to the
1044 * expression. */
1045 while (1)
1046 {
1047 arg = skipwhite(arg + 1);
1048 if (vim_strchr((char_u *)"$@&", *arg) != NULL)
1049 ++arg;
1050 expr = find_name_end(arg, NULL, NULL, TRUE);
1051 if (expr == arg)
1052 {
1053 EMSG2(_(e_invarg2), arg);
1054 return;
1055 }
1056 ++var_count;
1057
1058 arg = skipwhite(expr);
1059 if (*arg == ']')
1060 break;
1061 else if (*arg == ';')
1062 {
1063 if (semicolon == 1)
1064 {
1065 EMSG(_("Double ; in :let"));
1066 return;
1067 }
1068 semicolon = 1;
1069 }
1070 else if (*arg != ',')
1071 {
1072 EMSG2(_(e_invarg2), arg);
1073 return;
1074 }
1075 }
1076
1077 /* check for '=' after the ']' */
1078 expr = skipwhite(arg + 1);
1079 if (*expr != '=')
1080 {
1081 EMSG(_(e_letunexp));
1082 return;
1083 }
1084 }
1085
1086 if (eap->skip)
1087 ++emsg_skip;
1088 i = eval0(expr + 1, &rettv, &eap->nextcmd, !eap->skip);
1089 if (eap->skip)
1090 {
1091 if (i != FAIL)
1092 clear_tv(&rettv);
1093 --emsg_skip;
1094 }
1095 else if (i != FAIL)
1096 {
1097 /* Move "arg" back to the variable name(s). */
1098 arg = eap->arg;
1099 if (*arg != '[')
1100 {
1101 /* ":let var = expr" */
1102 (void)ex_let_one(arg, &rettv, FALSE, (char_u *)"=");
1103 }
1104 else
1105 {
1106 /* ":let [v1, v2] = list" */
1107 l = rettv.vval.v_list;
1108 if (rettv.v_type != VAR_LIST || l == NULL)
1109 EMSG(_("E999: List required"));
1110 else
1111 {
1112 i = list_len(l);
1113 if (semicolon == 0 && var_count < i)
1114 EMSG(_("E999: Less targets than List items"));
1115 else if (var_count - semicolon > i)
1116 EMSG(_("E999: More targets than List items"));
1117 else
1118 {
1119 item = l->lv_first;
1120 while (*arg != ']')
1121 {
1122 arg = skipwhite(arg + 1);
1123 arg = ex_let_one(arg, &item->li_tv,
1124 TRUE, (char_u *)",;]");
1125 item = item->li_next;
1126 if (arg == NULL)
1127 break;
1128
1129 arg = skipwhite(arg);
1130 if (*arg == ';')
1131 {
1132 /* Put the rest of the list (may be empty) in
1133 * the var after ';'. */
1134 l = list_alloc();
1135 if (l == NULL)
1136 break;
1137 while (item != NULL)
1138 {
1139 list_append_tv(l, &item->li_tv);
1140 item = item->li_next;
1141 }
1142 list_unref(rettv.vval.v_list);
1143 rettv.vval.v_list = l;
1144 l->lv_refcount = 1;
1145 (void)ex_let_one(skipwhite(arg + 1), &rettv,
1146 FALSE, (char_u *)"]");
1147 break;
1148 }
1149 else if (*arg != ',' && *arg != ']')
1150 {
1151 EMSG2(_(e_intern2), "ex_let()");
1152 break;
1153 }
1154 }
1155 }
1156 }
1157 }
1158 clear_tv(&rettv);
1159 }
1160 }
1161 }
1162
1163 static void
1164 list_all_vars()
1165 {
1166 int i;
1167
1168 /*
1169 * List all variables.
1170 */
1171 for (i = 0; i < variables.ga_len && !got_int; ++i)
1172 if (VAR_ENTRY(i).v_name != NULL)
1173 list_one_var(&VAR_ENTRY(i), (char_u *)"");
1174 for (i = 0; i < curbuf->b_vars.ga_len && !got_int; ++i)
1175 if (BVAR_ENTRY(i).v_name != NULL)
1176 list_one_var(&BVAR_ENTRY(i), (char_u *)"b:");
1177 for (i = 0; i < curwin->w_vars.ga_len && !got_int; ++i)
1178 if (WVAR_ENTRY(i).v_name != NULL)
1179 list_one_var(&WVAR_ENTRY(i), (char_u *)"w:");
1180 for (i = 0; i < VV_LEN && !got_int; ++i)
1181 if (vimvars[i].type == VAR_NUMBER || vimvars[i].val != NULL)
1182 list_vim_var(i);
1183 }
1184
1185 /*
1186 * List variables in "arg".
1187 */
1188 static char_u *
1189 list_arg_vars(eap, arg)
1190 exarg_T *eap;
1191 char_u *arg;
1192 {
1193 int error = FALSE;
1194 char_u *temp_string = NULL;
1195 int arg_len;
1026 char_u *expr_start; 1196 char_u *expr_start;
1027 char_u *expr_end; 1197 char_u *expr_end;
1028 char_u *name_end; 1198 char_u *name_end;
1029 1199 int c1 = 0, c2;
1030 name_end = find_name_end(arg, &expr_start, &expr_end); 1200 int i;
1031 expr = vim_strchr(name_end, '='); 1201 VAR varp;
1032 if (expr == NULL) 1202 char_u *name;
1033 { 1203
1034 if (ends_excmd(*arg)) 1204 while (!ends_excmd(*arg) && !got_int)
1035 { 1205 {
1036 if (!eap->skip) 1206 /* Find the end of the name. */
1207 name_end = find_name_end(arg, &expr_start, &expr_end, FALSE);
1208
1209 if (!vim_iswhite(*name_end) && !ends_excmd(*name_end))
1210 {
1211 emsg_severe = TRUE;
1212 EMSG(_(e_trailing));
1213 break;
1214 }
1215 if (!error && !eap->skip)
1216 {
1217 if (expr_start != NULL)
1037 { 1218 {
1038 /* 1219 temp_string = make_expanded_name(arg, expr_start,
1039 * List all variables. 1220 expr_end, name_end);
1040 */ 1221 if (temp_string == NULL)
1041 for (i = 0; i < variables.ga_len && !got_int; ++i) 1222 {
1042 if (VAR_ENTRY(i).v_name != NULL) 1223 /*
1043 list_one_var(&VAR_ENTRY(i), (char_u *)""); 1224 * Report an invalid expression in braces, unless
1044 for (i = 0; i < curbuf->b_vars.ga_len && !got_int; ++i) 1225 * the expression evaluation has been cancelled due
1045 if (BVAR_ENTRY(i).v_name != NULL) 1226 * to an aborting error, an interrupt, or an
1046 list_one_var(&BVAR_ENTRY(i), (char_u *)"b:"); 1227 * exception.
1047 for (i = 0; i < curwin->w_vars.ga_len && !got_int; ++i) 1228 */
1048 if (WVAR_ENTRY(i).v_name != NULL) 1229 if (!aborting())
1049 list_one_var(&WVAR_ENTRY(i), (char_u *)"w:"); 1230 {
1050 for (i = 0; i < VV_LEN && !got_int; ++i) 1231 emsg_severe = TRUE;
1051 if (vimvars[i].type == VAR_NUMBER || vimvars[i].val != NULL) 1232 EMSG2(_(e_invarg2), arg);
1052 list_vim_var(i); 1233 break;
1234 }
1235 error = TRUE;
1236 arg = skipwhite(name_end);
1237 continue;
1238 }
1239 arg = temp_string;
1240 arg_len = STRLEN(temp_string);
1053 } 1241 }
1054 } 1242 else
1055 else
1056 {
1057 int error = FALSE;
1058
1059 /*
1060 * List variables.
1061 */
1062 while (!ends_excmd(*arg) && !got_int)
1063 { 1243 {
1064 char_u *temp_string = NULL; 1244 c1 = *name_end;
1065 int arg_len; 1245 *name_end = NUL;
1066 1246 arg_len = (int)(name_end - arg);
1067 /* Find the end of the name. */ 1247 }
1068 name_end = find_name_end(arg, &expr_start, &expr_end); 1248 i = find_vim_var(arg, arg_len);
1069 1249 if (i >= 0)
1070 if (!vim_iswhite(*name_end) && !ends_excmd(*name_end)) 1250 list_vim_var(i);
1251 else if (STRCMP("b:changedtick", arg) == 0)
1252 {
1253 char_u numbuf[NUMBUFLEN];
1254
1255 sprintf((char *)numbuf, "%ld",
1256 (long)curbuf->b_changedtick);
1257 list_one_var_a((char_u *)"b:", (char_u *)"changedtick",
1258 VAR_NUMBER, numbuf);
1259 }
1260 else
1261 {
1262 varp = find_var(arg, FALSE);
1263 if (varp == NULL)
1071 { 1264 {
1072 emsg_severe = TRUE; 1265 /* Skip further arguments but do continue to
1073 EMSG(_(e_trailing)); 1266 * search for a trailing command. */
1074 break; 1267 EMSG2(_("E106: Unknown variable: \"%s\""), arg);
1268 error = TRUE;
1075 } 1269 }
1076 if (!error && !eap->skip) 1270 else
1077 { 1271 {
1078 #ifdef FEAT_MAGIC_BRACES 1272 name = vim_strchr(arg, ':');
1079 if (expr_start != NULL) 1273 if (name != NULL)
1080 { 1274 {
1081 temp_string = make_expanded_name(arg, expr_start, 1275 /* "a:" vars have no name stored, use whole arg */
1082 expr_end, name_end); 1276 if (arg[0] == 'a' && arg[1] == ':')
1083 if (temp_string == NULL) 1277 c2 = NUL;
1278 else
1084 { 1279 {
1085 /* 1280 c2 = *++name;
1086 * Report an invalid expression in braces, unless 1281 *name = NUL;
1087 * the expression evaluation has been cancelled due
1088 * to an aborting error, an interrupt, or an
1089 * exception.
1090 */
1091 if (!aborting())
1092 {
1093 emsg_severe = TRUE;
1094 EMSG2(_(e_invarg2), arg);
1095 break;
1096 }
1097 error = TRUE;
1098 arg = skipwhite(name_end);
1099 continue;
1100 } 1282 }
1101 arg = temp_string; 1283 list_one_var(varp, arg);
1102 arg_len = STRLEN(temp_string); 1284 if (c2 != NUL)
1285 *name = c2;
1103 } 1286 }
1104 else 1287 else
1105 #endif 1288 list_one_var(varp, (char_u *)"");
1106 {
1107 c1 = *name_end;
1108 *name_end = NUL;
1109 arg_len = (int)(name_end - arg);
1110 }
1111 i = find_vim_var(arg, arg_len);
1112 if (i >= 0)
1113 list_vim_var(i);
1114 else if (STRCMP("b:changedtick", arg) == 0)
1115 {
1116 char_u numbuf[NUMBUFLEN];
1117
1118 sprintf((char *)numbuf, "%ld",
1119 (long)curbuf->b_changedtick);
1120 list_one_var_a((char_u *)"b:", (char_u *)"changedtick",
1121 VAR_NUMBER, numbuf);
1122 }
1123 else
1124 {
1125 varp = find_var(arg, FALSE);
1126 if (varp == NULL)
1127 {
1128 /* Skip further arguments but do continue to
1129 * search for a trailing command. */
1130 EMSG2(_("E106: Unknown variable: \"%s\""), arg);
1131 error = TRUE;
1132 }
1133 else
1134 {
1135 name = vim_strchr(arg, ':');
1136 if (name != NULL)
1137 {
1138 /* "a:" vars have no name stored, use whole
1139 * arg */
1140 if (arg[0] == 'a' && arg[1] == ':')
1141 c2 = NUL;
1142 else
1143 {
1144 c2 = *++name;
1145 *name = NUL;
1146 }
1147 list_one_var(varp, arg);
1148 if (c2 != NUL)
1149 *name = c2;
1150 }
1151 else
1152 list_one_var(varp, (char_u *)"");
1153 }
1154 }
1155 #ifdef FEAT_MAGIC_BRACES
1156 if (expr_start != NULL)
1157 vim_free(temp_string);
1158 else
1159 #endif
1160 *name_end = c1;
1161 }
1162 arg = skipwhite(name_end);
1163 }
1164 }
1165 eap->nextcmd = check_nextcmd(arg);
1166 }
1167 else
1168 {
1169 if (eap->skip)
1170 ++emsg_skip;
1171 i = eval0(expr + 1, &retvar, &eap->nextcmd, !eap->skip);
1172 if (eap->skip)
1173 {
1174 if (i != FAIL)
1175 clear_vartv(&retvar.tv);
1176 --emsg_skip;
1177 }
1178 else if (i != FAIL)
1179 {
1180 /*
1181 * ":let $VAR = expr": Set environment variable.
1182 */
1183 if (*arg == '$')
1184 {
1185 int len;
1186 int cc;
1187
1188 /* Find the end of the name. */
1189 ++arg;
1190 name = arg;
1191 len = get_env_len(&arg);
1192 if (len == 0)
1193 EMSG2(_(e_invarg2), name - 1);
1194 else
1195 {
1196 if (*skipwhite(arg) != '=')
1197 EMSG(_(e_letunexp));
1198 else
1199 {
1200 cc = name[len];
1201 name[len] = NUL;
1202 p = get_var_string(&retvar);
1203 vim_setenv(name, p);
1204 if (STRICMP(name, "HOME") == 0)
1205 init_homedir();
1206 else if (didset_vim && STRICMP(name, "VIM") == 0)
1207 didset_vim = FALSE;
1208 else if (didset_vimruntime
1209 && STRICMP(name, "VIMRUNTIME") == 0)
1210 didset_vimruntime = FALSE;
1211 name[len] = cc;
1212 }
1213 } 1289 }
1214 } 1290 }
1215 1291 if (expr_start != NULL)
1216 /* 1292 vim_free(temp_string);
1217 * ":let &option = expr": Set option value. 1293 else
1218 * ":let &l:option = expr": Set local option value. 1294 *name_end = c1;
1219 * ":let &g:option = expr": Set global option value. 1295 }
1220 */ 1296 arg = skipwhite(name_end);
1221 else if (*arg == '&') 1297 }
1222 { 1298
1223 int opt_flags; 1299 return arg;
1224 1300 }
1225 /* 1301
1226 * Find the end of the name; 1302 /*
1227 */ 1303 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
1228 p = find_option_end(&arg, &opt_flags); 1304 * Returns a pointer to the char just after the var name.
1229 if (p == NULL || *skipwhite(p) != '=') 1305 * Returns NULL if there is an error.
1230 EMSG(_(e_letunexp)); 1306 */
1231 else 1307 static char_u *
1232 { 1308 ex_let_one(arg, tv, copy, endchars)
1233 c1 = *p; 1309 char_u *arg; /* points to variable name */
1234 *p = NUL; 1310 typeval *tv; /* value to assign to variable */
1235 set_option_value(arg, get_var_number(&retvar), 1311 int copy; /* copy value from "tv" */
1236 get_var_string(&retvar), opt_flags); 1312 char_u *endchars; /* valid chars after variable name */
1237 *p = c1; /* put back for error messages */ 1313 {
1238 } 1314 int c1;
1239 } 1315 char_u *name;
1240 1316 char_u *p;
1241 /* 1317 char_u *arg_end = NULL;
1242 * ":let @r = expr": Set register contents. 1318 int len;
1243 */ 1319 int opt_flags;
1244 else if (*arg == '@') 1320
1245 { 1321 /*
1246 ++arg; 1322 * ":let $VAR = expr": Set environment variable.
1247 if (*skipwhite(arg + 1) != '=') 1323 */
1248 EMSG(_(e_letunexp)); 1324 if (*arg == '$')
1249 else 1325 {
1250 write_reg_contents(*arg == '@' ? '"' : *arg, 1326 /* Find the end of the name. */
1251 get_var_string(&retvar), -1, FALSE); 1327 ++arg;
1252 } 1328 name = arg;
1253 1329 len = get_env_len(&arg);
1254 /* 1330 if (len == 0)
1255 * ":let var = expr": Set internal variable. 1331 EMSG2(_(e_invarg2), name - 1);
1256 */ 1332 else
1257 else if (eval_isnamec(*arg) && !VIM_ISDIGIT(*arg)) 1333 {
1258 { 1334 if (vim_strchr(endchars, *skipwhite(arg)) == NULL)
1259 /* Find the end of the name. */ 1335 EMSG(_(e_letunexp));
1260 p = find_name_end(arg, &expr_start, &expr_end);
1261
1262 if (*skipwhite(p) != '=')
1263 EMSG(_(e_letunexp));
1264 else if (p - arg == 13
1265 && STRNCMP(arg, "b:changedtick", 13) == 0)
1266 EMSG2(_(e_readonlyvar), arg);
1267 #ifdef FEAT_MAGIC_BRACES
1268 else if (expr_start != NULL)
1269 {
1270 char_u *temp_string;
1271
1272 temp_string = make_expanded_name(arg, expr_start,
1273 expr_end, p);
1274 if (temp_string == NULL)
1275 {
1276 /*
1277 * Report an invalid expression in braces, unless the
1278 * expression evaluation has been cancelled due to an
1279 * aborting error, an interrupt, or an exception.
1280 */
1281 if (!aborting())
1282 EMSG2(_(e_invarg2), arg);
1283 }
1284 else
1285 {
1286 set_var(temp_string, &retvar.tv, TRUE);
1287 vim_free(temp_string);
1288 }
1289 }
1290 #endif
1291 else
1292 {
1293 c1 = *p;
1294 *p = NUL;
1295 set_var(arg, &retvar.tv, TRUE);
1296 *p = c1; /* put char back for error messages */
1297 }
1298 }
1299
1300 else 1336 else
1301 { 1337 {
1338 c1 = name[len];
1339 name[len] = NUL;
1340 p = get_tv_string(tv);
1341 vim_setenv(name, p);
1342 if (STRICMP(name, "HOME") == 0)
1343 init_homedir();
1344 else if (didset_vim && STRICMP(name, "VIM") == 0)
1345 didset_vim = FALSE;
1346 else if (didset_vimruntime && STRICMP(name, "VIMRUNTIME") == 0)
1347 didset_vimruntime = FALSE;
1348 name[len] = c1;
1349 arg_end = arg;
1350 }
1351 }
1352 }
1353
1354 /*
1355 * ":let &option = expr": Set option value.
1356 * ":let &l:option = expr": Set local option value.
1357 * ":let &g:option = expr": Set global option value.
1358 */
1359 else if (*arg == '&')
1360 {
1361 /* Find the end of the name. */
1362 p = find_option_end(&arg, &opt_flags);
1363 if (p == NULL || vim_strchr(endchars, *skipwhite(p)) == NULL)
1364 EMSG(_(e_letunexp));
1365 else
1366 {
1367 c1 = *p;
1368 *p = NUL;
1369 set_option_value(arg, get_tv_number(tv),
1370 get_tv_string(tv), opt_flags);
1371 *p = c1;
1372 arg_end = p;
1373 }
1374 }
1375
1376 /*
1377 * ":let @r = expr": Set register contents.
1378 */
1379 else if (*arg == '@')
1380 {
1381 ++arg;
1382 if (vim_strchr(endchars, *skipwhite(arg + 1)) == NULL)
1383 EMSG(_(e_letunexp));
1384 else
1385 {
1386 write_reg_contents(*arg == '@' ? '"' : *arg,
1387 get_tv_string(tv), -1, FALSE);
1388 arg_end = arg + 1;
1389 }
1390 }
1391
1392 /*
1393 * ":let var = expr": Set internal variable.
1394 */
1395 else if (eval_isnamec(*arg) && !VIM_ISDIGIT(*arg))
1396 {
1397 char_u *exp_name = NULL;
1398 char_u *expr_start, *expr_end;
1399
1400 /* Find the end of the name. */
1401 p = find_name_end(arg, &expr_start, &expr_end, FALSE);
1402 if (expr_start != NULL)
1403 {
1404 exp_name = make_expanded_name(arg, expr_start, expr_end, p);
1405 arg = exp_name;
1406 }
1407
1408 if (arg == NULL)
1409 {
1410 /* Report an invalid expression in braces, unless the
1411 * expression evaluation has been cancelled due to an
1412 * aborting error, an interrupt, or an exception. */
1413 if (!aborting())
1302 EMSG2(_(e_invarg2), arg); 1414 EMSG2(_(e_invarg2), arg);
1415 }
1416 else if (*p == '[')
1417 arg_end = set_var_idx(arg, p, tv, copy, endchars);
1418 else if (vim_strchr(endchars, *skipwhite(p)) == NULL)
1419 EMSG(_(e_letunexp));
1420 else if (STRNCMP(arg, "b:changedtick", 13) == 0
1421 && !eval_isnamec(arg[13]))
1422 EMSG2(_(e_readonlyvar), arg);
1423 else
1424 {
1425 c1 = *p;
1426 *p = NUL;
1427 set_var(arg, tv, copy);
1428 *p = c1;
1429 arg_end = p;
1430 }
1431
1432 vim_free(exp_name);
1433 }
1434
1435 else
1436 EMSG2(_(e_invarg2), arg);
1437
1438 return arg_end;
1439 }
1440
1441 /*
1442 * Set a variable with an index: "name[expr]", "name[expr][expr]", etc.
1443 * Only works if "name" is an existing List.
1444 * "ip" points to the first '['.
1445 * Returns a pointer to just after the last used ']'; NULL for error.
1446 */
1447 static char_u *
1448 set_var_idx(name, ip, rettv, copy, endchars)
1449 char_u *name;
1450 char_u *ip;
1451 typeval *rettv;
1452 int copy;
1453 char_u *endchars;
1454 {
1455 VAR v;
1456 int c1;
1457 char_u *p;
1458 typeval var1;
1459 typeval *tv;
1460 long n;
1461 listitem *item;
1462
1463 c1 = *ip;
1464 *ip = NUL;
1465 v = find_var(name, TRUE);
1466 if (v == NULL)
1467 EMSG2(_(e_undefvar), name);
1468 *ip = c1;
1469 if (v == NULL)
1470 return NULL;
1471
1472 tv = &v->tv;
1473 for (p = ip; *p == '['; p = skipwhite(p + 1))
1474 {
1475 if (tv->v_type != VAR_LIST || tv->vval.v_list == NULL)
1476 {
1477 EMSG(_("E999: Can only index a List"));
1478 p = NULL;
1479 break;
1480 }
1481 p = skipwhite(p + 1);
1482 if (eval1(&p, &var1, TRUE) == FAIL) /* recursive! */
1483 {
1484 p = NULL;
1485 break;
1486 }
1487 if (*p != ']')
1488 {
1489 EMSG(_(e_missbrac));
1490 clear_tv(&var1);
1491 p = NULL;
1492 break;
1493 }
1494 n = get_tv_number(&var1);
1495 clear_tv(&var1);
1496 item = list_find(tv->vval.v_list, n);
1497 if (item == NULL)
1498 {
1499 EMSGN(_(e_listidx), n);
1500 p = NULL;
1501 break;
1502 }
1503 tv = &item->li_tv;
1504 }
1505
1506 if (p != NULL)
1507 {
1508 if (vim_strchr(endchars, *p) == NULL)
1509 {
1510 EMSG(_(e_letunexp));
1511 p = NULL;
1512 }
1513 else
1514 {
1515 clear_tv(tv);
1516 if (copy)
1517 copy_tv(tv, rettv);
1518 else
1519 {
1520 *tv = *rettv;
1521 init_tv(rettv);
1303 } 1522 }
1304 1523 }
1305 clear_vartv(&retvar.tv); 1524 }
1306 } 1525 return p;
1307 }
1308 } 1526 }
1309 1527
1310 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 1528 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
1311 1529
1312 void 1530 void
1403 { 1621 {
1404 char_u *arg = eap->arg; 1622 char_u *arg = eap->arg;
1405 char_u *startarg; 1623 char_u *startarg;
1406 char_u *alias; 1624 char_u *alias;
1407 char_u *name; 1625 char_u *name;
1408 var retvar; 1626 typeval rettv;
1409 int len; 1627 int len;
1410 linenr_T lnum; 1628 linenr_T lnum;
1411 int doesrange; 1629 int doesrange;
1412 int failed = FALSE; 1630 int failed = FALSE;
1413 1631
1417 goto end; 1635 goto end;
1418 if (alias != NULL) 1636 if (alias != NULL)
1419 name = alias; 1637 name = alias;
1420 1638
1421 startarg = arg; 1639 startarg = arg;
1422 retvar.tv.v_type = VAR_UNKNOWN; /* clear_vartv() uses this */ 1640 rettv.v_type = VAR_UNKNOWN; /* clear_tv() uses this */
1423 1641
1424 if (*startarg != '(') 1642 if (*startarg != '(')
1425 { 1643 {
1426 EMSG2(_("E107: Missing braces: %s"), name); 1644 EMSG2(_("E107: Missing braces: %s"), name);
1427 goto end; 1645 goto end;
1446 { 1664 {
1447 curwin->w_cursor.lnum = lnum; 1665 curwin->w_cursor.lnum = lnum;
1448 curwin->w_cursor.col = 0; 1666 curwin->w_cursor.col = 0;
1449 } 1667 }
1450 arg = startarg; 1668 arg = startarg;
1451 if (get_func_vartv(name, len, &retvar.tv, &arg, 1669 if (get_func_tv(name, len, &rettv, &arg,
1452 eap->line1, eap->line2, &doesrange, !eap->skip) == FAIL) 1670 eap->line1, eap->line2, &doesrange, !eap->skip) == FAIL)
1453 { 1671 {
1454 failed = TRUE; 1672 failed = TRUE;
1455 break; 1673 break;
1456 } 1674 }
1457 clear_vartv(&retvar.tv); 1675 clear_tv(&rettv);
1458 if (doesrange || eap->skip) 1676 if (doesrange || eap->skip)
1459 break; 1677 break;
1460 /* Stop when immediately aborting on error, or when an interrupt 1678 /* Stop when immediately aborting on error, or when an interrupt
1461 * occurred or an exception was thrown but not caught. 1679 * occurred or an exception was thrown but not caught.
1462 * get_func_vartv() returned OK, so that the check for trailing 1680 * get_func_tv() returned OK, so that the check for trailing
1463 * characters below is executed. */ 1681 * characters below is executed. */
1464 if (aborting()) 1682 if (aborting())
1465 break; 1683 break;
1466 } 1684 }
1467 if (eap->skip) 1685 if (eap->skip)
1499 int error = FALSE; 1717 int error = FALSE;
1500 1718
1501 do 1719 do
1502 { 1720 {
1503 /* Find the end of the name. */ 1721 /* Find the end of the name. */
1504 name_end = find_name_end(arg, &expr_start, &expr_end); 1722 name_end = find_name_end(arg, &expr_start, &expr_end, FALSE);
1505 1723
1506 if (!vim_iswhite(*name_end) && !ends_excmd(*name_end)) 1724 if (!vim_iswhite(*name_end) && !ends_excmd(*name_end))
1507 { 1725 {
1508 emsg_severe = TRUE; 1726 emsg_severe = TRUE;
1509 EMSG(_(e_trailing)); 1727 EMSG(_(e_trailing));
1510 break; 1728 break;
1511 } 1729 }
1512 1730
1513 if (!error && !eap->skip) 1731 if (!error && !eap->skip)
1514 { 1732 {
1515 #ifdef FEAT_MAGIC_BRACES
1516 if (expr_start != NULL) 1733 if (expr_start != NULL)
1517 { 1734 {
1518 char_u *temp_string; 1735 char_u *temp_string;
1519 1736
1520 temp_string = make_expanded_name(arg, expr_start, 1737 temp_string = make_expanded_name(arg, expr_start,
1543 } 1760 }
1544 vim_free(temp_string); 1761 vim_free(temp_string);
1545 } 1762 }
1546 } 1763 }
1547 else 1764 else
1548 #endif
1549 { 1765 {
1550 cc = *name_end; 1766 cc = *name_end;
1551 *name_end = NUL; 1767 *name_end = NUL;
1552 1768
1553 if (do_unlet(arg) == FAIL && !eap->forceit) 1769 if (do_unlet(arg) == FAIL && !eap->forceit)
1720 , TYPE_NOMATCH /* !~ */ 1936 , TYPE_NOMATCH /* !~ */
1721 } exptype_T; 1937 } exptype_T;
1722 1938
1723 /* 1939 /*
1724 * The "evaluate" argument: When FALSE, the argument is only parsed but not 1940 * The "evaluate" argument: When FALSE, the argument is only parsed but not
1725 * executed. The function may return OK, but the retvar will be of type 1941 * executed. The function may return OK, but the rettv will be of type
1726 * VAR_UNKNOWN. The function still returns FAIL for a syntax error. 1942 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
1727 */ 1943 */
1728 1944
1729 /* 1945 /*
1730 * Handle zero level expression. 1946 * Handle zero level expression.
1731 * This calls eval1() and handles error message and nextcmd. 1947 * This calls eval1() and handles error message and nextcmd.
1948 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
1732 * Return OK or FAIL. 1949 * Return OK or FAIL.
1733 */ 1950 */
1734 static int 1951 static int
1735 eval0(arg, retvar, nextcmd, evaluate) 1952 eval0(arg, rettv, nextcmd, evaluate)
1736 char_u *arg; 1953 char_u *arg;
1737 VAR retvar; 1954 typeval *rettv;
1738 char_u **nextcmd; 1955 char_u **nextcmd;
1739 int evaluate; 1956 int evaluate;
1740 { 1957 {
1741 int ret; 1958 int ret;
1742 char_u *p; 1959 char_u *p;
1743 1960
1744 p = skipwhite(arg); 1961 p = skipwhite(arg);
1745 ret = eval1(&p, &retvar->tv, evaluate); 1962 ret = eval1(&p, rettv, evaluate);
1746 if (ret == FAIL || !ends_excmd(*p)) 1963 if (ret == FAIL || !ends_excmd(*p))
1747 { 1964 {
1748 if (ret != FAIL) 1965 if (ret != FAIL)
1749 clear_vartv(&retvar->tv); 1966 clear_tv(rettv);
1750 /* 1967 /*
1751 * Report the invalid expression unless the expression evaluation has 1968 * Report the invalid expression unless the expression evaluation has
1752 * been cancelled due to an aborting error, an interrupt, or an 1969 * been cancelled due to an aborting error, an interrupt, or an
1753 * exception. 1970 * exception.
1754 */ 1971 */
1770 * "arg" is advanced to the next non-white after the recognized expression. 1987 * "arg" is advanced to the next non-white after the recognized expression.
1771 * 1988 *
1772 * Return OK or FAIL. 1989 * Return OK or FAIL.
1773 */ 1990 */
1774 static int 1991 static int
1775 eval1(arg, retvar, evaluate) 1992 eval1(arg, rettv, evaluate)
1776 char_u **arg; 1993 char_u **arg;
1777 typeval *retvar; 1994 typeval *rettv;
1778 int evaluate; 1995 int evaluate;
1779 { 1996 {
1780 int result; 1997 int result;
1781 typeval var2; 1998 typeval var2;
1782 1999
1783 /* 2000 /*
1784 * Get the first variable. 2001 * Get the first variable.
1785 */ 2002 */
1786 if (eval2(arg, retvar, evaluate) == FAIL) 2003 if (eval2(arg, rettv, evaluate) == FAIL)
1787 return FAIL; 2004 return FAIL;
1788 2005
1789 if ((*arg)[0] == '?') 2006 if ((*arg)[0] == '?')
1790 { 2007 {
1791 result = FALSE; 2008 result = FALSE;
1792 if (evaluate) 2009 if (evaluate)
1793 { 2010 {
1794 if (get_vartv_number(retvar) != 0) 2011 if (get_tv_number(rettv) != 0)
1795 result = TRUE; 2012 result = TRUE;
1796 clear_vartv(retvar); 2013 clear_tv(rettv);
1797 } 2014 }
1798 2015
1799 /* 2016 /*
1800 * Get the second variable. 2017 * Get the second variable.
1801 */ 2018 */
1802 *arg = skipwhite(*arg + 1); 2019 *arg = skipwhite(*arg + 1);
1803 if (eval1(arg, retvar, evaluate && result) == FAIL) /* recursive! */ 2020 if (eval1(arg, rettv, evaluate && result) == FAIL) /* recursive! */
1804 return FAIL; 2021 return FAIL;
1805 2022
1806 /* 2023 /*
1807 * Check for the ":". 2024 * Check for the ":".
1808 */ 2025 */
1809 if ((*arg)[0] != ':') 2026 if ((*arg)[0] != ':')
1810 { 2027 {
1811 EMSG(_("E109: Missing ':' after '?'")); 2028 EMSG(_("E109: Missing ':' after '?'"));
1812 if (evaluate && result) 2029 if (evaluate && result)
1813 clear_vartv(retvar); 2030 clear_tv(rettv);
1814 return FAIL; 2031 return FAIL;
1815 } 2032 }
1816 2033
1817 /* 2034 /*
1818 * Get the third variable. 2035 * Get the third variable.
1819 */ 2036 */
1820 *arg = skipwhite(*arg + 1); 2037 *arg = skipwhite(*arg + 1);
1821 if (eval1(arg, &var2, evaluate && !result) == FAIL) /* recursive! */ 2038 if (eval1(arg, &var2, evaluate && !result) == FAIL) /* recursive! */
1822 { 2039 {
1823 if (evaluate && result) 2040 if (evaluate && result)
1824 clear_vartv(retvar); 2041 clear_tv(rettv);
1825 return FAIL; 2042 return FAIL;
1826 } 2043 }
1827 if (evaluate && !result) 2044 if (evaluate && !result)
1828 *retvar = var2; 2045 *rettv = var2;
1829 } 2046 }
1830 2047
1831 return OK; 2048 return OK;
1832 } 2049 }
1833 2050
1839 * "arg" is advanced to the next non-white after the recognized expression. 2056 * "arg" is advanced to the next non-white after the recognized expression.
1840 * 2057 *
1841 * Return OK or FAIL. 2058 * Return OK or FAIL.
1842 */ 2059 */
1843 static int 2060 static int
1844 eval2(arg, retvar, evaluate) 2061 eval2(arg, rettv, evaluate)
1845 char_u **arg; 2062 char_u **arg;
1846 typeval *retvar; 2063 typeval *rettv;
1847 int evaluate; 2064 int evaluate;
1848 { 2065 {
1849 typeval var2; 2066 typeval var2;
1850 long result; 2067 long result;
1851 int first; 2068 int first;
1852 2069
1853 /* 2070 /*
1854 * Get the first variable. 2071 * Get the first variable.
1855 */ 2072 */
1856 if (eval3(arg, retvar, evaluate) == FAIL) 2073 if (eval3(arg, rettv, evaluate) == FAIL)
1857 return FAIL; 2074 return FAIL;
1858 2075
1859 /* 2076 /*
1860 * Repeat until there is no following "||". 2077 * Repeat until there is no following "||".
1861 */ 2078 */
1863 result = FALSE; 2080 result = FALSE;
1864 while ((*arg)[0] == '|' && (*arg)[1] == '|') 2081 while ((*arg)[0] == '|' && (*arg)[1] == '|')
1865 { 2082 {
1866 if (evaluate && first) 2083 if (evaluate && first)
1867 { 2084 {
1868 if (get_vartv_number(retvar) != 0) 2085 if (get_tv_number(rettv) != 0)
1869 result = TRUE; 2086 result = TRUE;
1870 clear_vartv(retvar); 2087 clear_tv(rettv);
1871 first = FALSE; 2088 first = FALSE;
1872 } 2089 }
1873 2090
1874 /* 2091 /*
1875 * Get the second variable. 2092 * Get the second variable.
1881 /* 2098 /*
1882 * Compute the result. 2099 * Compute the result.
1883 */ 2100 */
1884 if (evaluate && !result) 2101 if (evaluate && !result)
1885 { 2102 {
1886 if (get_vartv_number(&var2) != 0) 2103 if (get_tv_number(&var2) != 0)
1887 result = TRUE; 2104 result = TRUE;
1888 clear_vartv(&var2); 2105 clear_tv(&var2);
1889 } 2106 }
1890 if (evaluate) 2107 if (evaluate)
1891 { 2108 {
1892 retvar->v_type = VAR_NUMBER; 2109 rettv->v_type = VAR_NUMBER;
1893 retvar->vval.v_number = result; 2110 rettv->vval.v_number = result;
1894 } 2111 }
1895 } 2112 }
1896 2113
1897 return OK; 2114 return OK;
1898 } 2115 }
1905 * "arg" is advanced to the next non-white after the recognized expression. 2122 * "arg" is advanced to the next non-white after the recognized expression.
1906 * 2123 *
1907 * Return OK or FAIL. 2124 * Return OK or FAIL.
1908 */ 2125 */
1909 static int 2126 static int
1910 eval3(arg, retvar, evaluate) 2127 eval3(arg, rettv, evaluate)
1911 char_u **arg; 2128 char_u **arg;
1912 typeval *retvar; 2129 typeval *rettv;
1913 int evaluate; 2130 int evaluate;
1914 { 2131 {
1915 typeval var2; 2132 typeval var2;
1916 long result; 2133 long result;
1917 int first; 2134 int first;
1918 2135
1919 /* 2136 /*
1920 * Get the first variable. 2137 * Get the first variable.
1921 */ 2138 */
1922 if (eval4(arg, retvar, evaluate) == FAIL) 2139 if (eval4(arg, rettv, evaluate) == FAIL)
1923 return FAIL; 2140 return FAIL;
1924 2141
1925 /* 2142 /*
1926 * Repeat until there is no following "&&". 2143 * Repeat until there is no following "&&".
1927 */ 2144 */
1929 result = TRUE; 2146 result = TRUE;
1930 while ((*arg)[0] == '&' && (*arg)[1] == '&') 2147 while ((*arg)[0] == '&' && (*arg)[1] == '&')
1931 { 2148 {
1932 if (evaluate && first) 2149 if (evaluate && first)
1933 { 2150 {
1934 if (get_vartv_number(retvar) == 0) 2151 if (get_tv_number(rettv) == 0)
1935 result = FALSE; 2152 result = FALSE;
1936 clear_vartv(retvar); 2153 clear_tv(rettv);
1937 first = FALSE; 2154 first = FALSE;
1938 } 2155 }
1939 2156
1940 /* 2157 /*
1941 * Get the second variable. 2158 * Get the second variable.
1947 /* 2164 /*
1948 * Compute the result. 2165 * Compute the result.
1949 */ 2166 */
1950 if (evaluate && result) 2167 if (evaluate && result)
1951 { 2168 {
1952 if (get_vartv_number(&var2) == 0) 2169 if (get_tv_number(&var2) == 0)
1953 result = FALSE; 2170 result = FALSE;
1954 clear_vartv(&var2); 2171 clear_tv(&var2);
1955 } 2172 }
1956 if (evaluate) 2173 if (evaluate)
1957 { 2174 {
1958 retvar->v_type = VAR_NUMBER; 2175 rettv->v_type = VAR_NUMBER;
1959 retvar->vval.v_number = result; 2176 rettv->vval.v_number = result;
1960 } 2177 }
1961 } 2178 }
1962 2179
1963 return OK; 2180 return OK;
1964 } 2181 }
1978 * "arg" is advanced to the next non-white after the recognized expression. 2195 * "arg" is advanced to the next non-white after the recognized expression.
1979 * 2196 *
1980 * Return OK or FAIL. 2197 * Return OK or FAIL.
1981 */ 2198 */
1982 static int 2199 static int
1983 eval4(arg, retvar, evaluate) 2200 eval4(arg, rettv, evaluate)
1984 char_u **arg; 2201 char_u **arg;
1985 typeval *retvar; 2202 typeval *rettv;
1986 int evaluate; 2203 int evaluate;
1987 { 2204 {
1988 typeval var2; 2205 typeval var2;
1989 char_u *p; 2206 char_u *p;
1990 int i; 2207 int i;
1998 char_u *save_cpo; 2215 char_u *save_cpo;
1999 2216
2000 /* 2217 /*
2001 * Get the first variable. 2218 * Get the first variable.
2002 */ 2219 */
2003 if (eval5(arg, retvar, evaluate) == FAIL) 2220 if (eval5(arg, rettv, evaluate) == FAIL)
2004 return FAIL; 2221 return FAIL;
2005 2222
2006 p = *arg; 2223 p = *arg;
2007 switch (p[0]) 2224 switch (p[0])
2008 { 2225 {
2059 * Get the second variable. 2276 * Get the second variable.
2060 */ 2277 */
2061 *arg = skipwhite(p + len); 2278 *arg = skipwhite(p + len);
2062 if (eval5(arg, &var2, evaluate) == FAIL) 2279 if (eval5(arg, &var2, evaluate) == FAIL)
2063 { 2280 {
2064 clear_vartv(retvar); 2281 clear_tv(rettv);
2065 return FAIL; 2282 return FAIL;
2066 } 2283 }
2067 2284
2068 if (evaluate) 2285 if (evaluate)
2069 { 2286 {
2070 /* 2287 /*
2071 * If one of the two variables is a number, compare as a number. 2288 * If one of the two variables is a number, compare as a number.
2072 * When using "=~" or "!~", always compare as string. 2289 * When using "=~" or "!~", always compare as string.
2073 */ 2290 */
2074 if ((retvar->v_type == VAR_NUMBER || var2.v_type == VAR_NUMBER) 2291 if ((rettv->v_type == VAR_NUMBER || var2.v_type == VAR_NUMBER)
2075 && type != TYPE_MATCH && type != TYPE_NOMATCH) 2292 && type != TYPE_MATCH && type != TYPE_NOMATCH)
2076 { 2293 {
2077 n1 = get_vartv_number(retvar); 2294 n1 = get_tv_number(rettv);
2078 n2 = get_vartv_number(&var2); 2295 n2 = get_tv_number(&var2);
2079 switch (type) 2296 switch (type)
2080 { 2297 {
2081 case TYPE_EQUAL: n1 = (n1 == n2); break; 2298 case TYPE_EQUAL: n1 = (n1 == n2); break;
2082 case TYPE_NEQUAL: n1 = (n1 != n2); break; 2299 case TYPE_NEQUAL: n1 = (n1 != n2); break;
2083 case TYPE_GREATER: n1 = (n1 > n2); break; 2300 case TYPE_GREATER: n1 = (n1 > n2); break;
2089 case TYPE_NOMATCH: break; /* avoid gcc warning */ 2306 case TYPE_NOMATCH: break; /* avoid gcc warning */
2090 } 2307 }
2091 } 2308 }
2092 else 2309 else
2093 { 2310 {
2094 s1 = get_vartv_string_buf(retvar, buf1); 2311 s1 = get_tv_string_buf(rettv, buf1);
2095 s2 = get_vartv_string_buf(&var2, buf2); 2312 s2 = get_tv_string_buf(&var2, buf2);
2096 if (type != TYPE_MATCH && type != TYPE_NOMATCH) 2313 if (type != TYPE_MATCH && type != TYPE_NOMATCH)
2097 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); 2314 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2);
2098 else 2315 else
2099 i = 0; 2316 i = 0;
2100 n1 = FALSE; 2317 n1 = FALSE;
2126 break; 2343 break;
2127 2344
2128 case TYPE_UNKNOWN: break; /* avoid gcc warning */ 2345 case TYPE_UNKNOWN: break; /* avoid gcc warning */
2129 } 2346 }
2130 } 2347 }
2131 clear_vartv(retvar); 2348 clear_tv(rettv);
2132 clear_vartv(&var2); 2349 clear_tv(&var2);
2133 retvar->v_type = VAR_NUMBER; 2350 rettv->v_type = VAR_NUMBER;
2134 retvar->vval.v_number = n1; 2351 rettv->vval.v_number = n1;
2135 } 2352 }
2136 } 2353 }
2137 2354
2138 return OK; 2355 return OK;
2139 } 2356 }
2148 * "arg" is advanced to the next non-white after the recognized expression. 2365 * "arg" is advanced to the next non-white after the recognized expression.
2149 * 2366 *
2150 * Return OK or FAIL. 2367 * Return OK or FAIL.
2151 */ 2368 */
2152 static int 2369 static int
2153 eval5(arg, retvar, evaluate) 2370 eval5(arg, rettv, evaluate)
2154 char_u **arg; 2371 char_u **arg;
2155 typeval *retvar; 2372 typeval *rettv;
2156 int evaluate; 2373 int evaluate;
2157 { 2374 {
2158 typeval var2; 2375 typeval var2;
2159 int op; 2376 int op;
2160 long n1, n2; 2377 long n1, n2;
2163 char_u *p; 2380 char_u *p;
2164 2381
2165 /* 2382 /*
2166 * Get the first variable. 2383 * Get the first variable.
2167 */ 2384 */
2168 if (eval6(arg, retvar, evaluate) == FAIL) 2385 if (eval6(arg, rettv, evaluate) == FAIL)
2169 return FAIL; 2386 return FAIL;
2170 2387
2171 /* 2388 /*
2172 * Repeat computing, until no '+', '-' or '.' is following. 2389 * Repeat computing, until no '+', '-' or '.' is following.
2173 */ 2390 */
2181 * Get the second variable. 2398 * Get the second variable.
2182 */ 2399 */
2183 *arg = skipwhite(*arg + 1); 2400 *arg = skipwhite(*arg + 1);
2184 if (eval6(arg, &var2, evaluate) == FAIL) 2401 if (eval6(arg, &var2, evaluate) == FAIL)
2185 { 2402 {
2186 clear_vartv(retvar); 2403 clear_tv(rettv);
2187 return FAIL; 2404 return FAIL;
2188 } 2405 }
2189 2406
2190 if (evaluate) 2407 if (evaluate)
2191 { 2408 {
2192 /* 2409 /*
2193 * Compute the result. 2410 * Compute the result.
2194 */ 2411 */
2195 if (op == '.') 2412 if (op == '.')
2196 { 2413 {
2197 s1 = get_vartv_string_buf(retvar, buf1); 2414 s1 = get_tv_string_buf(rettv, buf1);
2198 s2 = get_vartv_string_buf(&var2, buf2); 2415 s2 = get_tv_string_buf(&var2, buf2);
2199 op = (int)STRLEN(s1); 2416 op = (int)STRLEN(s1);
2200 p = alloc((unsigned)(op + STRLEN(s2) + 1)); 2417 p = alloc((unsigned)(op + STRLEN(s2) + 1));
2201 if (p != NULL) 2418 if (p != NULL)
2202 { 2419 {
2203 STRCPY(p, s1); 2420 STRCPY(p, s1);
2204 STRCPY(p + op, s2); 2421 STRCPY(p + op, s2);
2205 } 2422 }
2206 clear_vartv(retvar); 2423 clear_tv(rettv);
2207 retvar->v_type = VAR_STRING; 2424 rettv->v_type = VAR_STRING;
2208 retvar->vval.v_string = p; 2425 rettv->vval.v_string = p;
2209 } 2426 }
2210 else 2427 else
2211 { 2428 {
2212 n1 = get_vartv_number(retvar); 2429 n1 = get_tv_number(rettv);
2213 n2 = get_vartv_number(&var2); 2430 n2 = get_tv_number(&var2);
2214 clear_vartv(retvar); 2431 clear_tv(rettv);
2215 if (op == '+') 2432 if (op == '+')
2216 n1 = n1 + n2; 2433 n1 = n1 + n2;
2217 else 2434 else
2218 n1 = n1 - n2; 2435 n1 = n1 - n2;
2219 retvar->v_type = VAR_NUMBER; 2436 rettv->v_type = VAR_NUMBER;
2220 retvar->vval.v_number = n1; 2437 rettv->vval.v_number = n1;
2221 } 2438 }
2222 clear_vartv(&var2); 2439 clear_tv(&var2);
2223 } 2440 }
2224 } 2441 }
2225 return OK; 2442 return OK;
2226 } 2443 }
2227 2444
2235 * "arg" is advanced to the next non-white after the recognized expression. 2452 * "arg" is advanced to the next non-white after the recognized expression.
2236 * 2453 *
2237 * Return OK or FAIL. 2454 * Return OK or FAIL.
2238 */ 2455 */
2239 static int 2456 static int
2240 eval6(arg, retvar, evaluate) 2457 eval6(arg, rettv, evaluate)
2241 char_u **arg; 2458 char_u **arg;
2242 typeval *retvar; 2459 typeval *rettv;
2243 int evaluate; 2460 int evaluate;
2244 { 2461 {
2245 typeval var2; 2462 typeval var2;
2246 int op; 2463 int op;
2247 long n1, n2; 2464 long n1, n2;
2248 2465
2249 /* 2466 /*
2250 * Get the first variable. 2467 * Get the first variable.
2251 */ 2468 */
2252 if (eval7(arg, retvar, evaluate) == FAIL) 2469 if (eval7(arg, rettv, evaluate) == FAIL)
2253 return FAIL; 2470 return FAIL;
2254 2471
2255 /* 2472 /*
2256 * Repeat computing, until no '*', '/' or '%' is following. 2473 * Repeat computing, until no '*', '/' or '%' is following.
2257 */ 2474 */
2261 if (op != '*' && op != '/' && op != '%') 2478 if (op != '*' && op != '/' && op != '%')
2262 break; 2479 break;
2263 2480
2264 if (evaluate) 2481 if (evaluate)
2265 { 2482 {
2266 n1 = get_vartv_number(retvar); 2483 n1 = get_tv_number(rettv);
2267 clear_vartv(retvar); 2484 clear_tv(rettv);
2268 } 2485 }
2269 else 2486 else
2270 n1 = 0; 2487 n1 = 0;
2271 2488
2272 /* 2489 /*
2276 if (eval7(arg, &var2, evaluate) == FAIL) 2493 if (eval7(arg, &var2, evaluate) == FAIL)
2277 return FAIL; 2494 return FAIL;
2278 2495
2279 if (evaluate) 2496 if (evaluate)
2280 { 2497 {
2281 n2 = get_vartv_number(&var2); 2498 n2 = get_tv_number(&var2);
2282 clear_vartv(&var2); 2499 clear_tv(&var2);
2283 2500
2284 /* 2501 /*
2285 * Compute the result. 2502 * Compute the result.
2286 */ 2503 */
2287 if (op == '*') 2504 if (op == '*')
2298 if (n2 == 0) /* give an error message? */ 2515 if (n2 == 0) /* give an error message? */
2299 n1 = 0; 2516 n1 = 0;
2300 else 2517 else
2301 n1 = n1 % n2; 2518 n1 = n1 % n2;
2302 } 2519 }
2303 retvar->v_type = VAR_NUMBER; 2520 rettv->v_type = VAR_NUMBER;
2304 retvar->vval.v_number = n1; 2521 rettv->vval.v_number = n1;
2305 } 2522 }
2306 } 2523 }
2307 2524
2308 return OK; 2525 return OK;
2309 } 2526 }
2330 * "arg" is advanced to the next non-white after the recognized expression. 2547 * "arg" is advanced to the next non-white after the recognized expression.
2331 * 2548 *
2332 * Return OK or FAIL. 2549 * Return OK or FAIL.
2333 */ 2550 */
2334 static int 2551 static int
2335 eval7(arg, retvar, evaluate) 2552 eval7(arg, rettv, evaluate)
2336 char_u **arg; 2553 char_u **arg;
2337 typeval *retvar; 2554 typeval *rettv;
2338 int evaluate; 2555 int evaluate;
2339 { 2556 {
2340 long n; 2557 long n;
2341 int len; 2558 int len;
2342 char_u *s; 2559 char_u *s;
2344 char_u *start_leader, *end_leader; 2561 char_u *start_leader, *end_leader;
2345 int ret = OK; 2562 int ret = OK;
2346 char_u *alias; 2563 char_u *alias;
2347 2564
2348 /* 2565 /*
2349 * Initialise variable so that clear_vartv() can't mistake this for a 2566 * Initialise variable so that clear_tv() can't mistake this for a
2350 * string and free a string that isn't there. 2567 * string and free a string that isn't there.
2351 */ 2568 */
2352 retvar->v_type = VAR_UNKNOWN; 2569 rettv->v_type = VAR_UNKNOWN;
2353 2570
2354 /* 2571 /*
2355 * Skip '!' and '-' characters. They are handled later. 2572 * Skip '!' and '-' characters. They are handled later.
2356 */ 2573 */
2357 start_leader = *arg; 2574 start_leader = *arg;
2376 case '9': 2593 case '9':
2377 vim_str2nr(*arg, NULL, &len, TRUE, TRUE, &n, NULL); 2594 vim_str2nr(*arg, NULL, &len, TRUE, TRUE, &n, NULL);
2378 *arg += len; 2595 *arg += len;
2379 if (evaluate) 2596 if (evaluate)
2380 { 2597 {
2381 retvar->v_type = VAR_NUMBER; 2598 rettv->v_type = VAR_NUMBER;
2382 retvar->vval.v_number = n; 2599 rettv->vval.v_number = n;
2383 } 2600 }
2384 break; 2601 break;
2385 2602
2386 /* 2603 /*
2387 * String constant: "string". 2604 * String constant: "string".
2388 */ 2605 */
2389 case '"': ret = get_string_vartv(arg, retvar, evaluate); 2606 case '"': ret = get_string_tv(arg, rettv, evaluate);
2390 break; 2607 break;
2391 2608
2392 /* 2609 /*
2393 * Literal string constant: 'string'. 2610 * Literal string constant: 'string'.
2394 */ 2611 */
2395 case '\'': ret = get_lit_string_vartv(arg, retvar, evaluate); 2612 case '\'': ret = get_lit_string_tv(arg, rettv, evaluate);
2396 break; 2613 break;
2397 2614
2398 /* 2615 /*
2399 * List: [expr, expr] 2616 * List: [expr, expr]
2400 */ 2617 */
2401 case '[': ret = get_list_vartv(arg, retvar, evaluate); 2618 case '[': ret = get_list_tv(arg, rettv, evaluate);
2402 break; 2619 break;
2403 2620
2404 /* 2621 /*
2405 * Option value: &name 2622 * Option value: &name
2406 */ 2623 */
2407 case '&': ret = get_option_vartv(arg, retvar, evaluate); 2624 case '&': ret = get_option_tv(arg, rettv, evaluate);
2408 break; 2625 break;
2409 2626
2410 /* 2627 /*
2411 * Environment variable: $VAR. 2628 * Environment variable: $VAR.
2412 */ 2629 */
2413 case '$': ret = get_env_vartv(arg, retvar, evaluate); 2630 case '$': ret = get_env_tv(arg, rettv, evaluate);
2414 break; 2631 break;
2415 2632
2416 /* 2633 /*
2417 * Register contents: @r. 2634 * Register contents: @r.
2418 */ 2635 */
2419 case '@': ++*arg; 2636 case '@': ++*arg;
2420 if (evaluate) 2637 if (evaluate)
2421 { 2638 {
2422 retvar->v_type = VAR_STRING; 2639 rettv->v_type = VAR_STRING;
2423 retvar->vval.v_string = get_reg_contents(**arg, FALSE); 2640 rettv->vval.v_string = get_reg_contents(**arg, FALSE);
2424 } 2641 }
2425 if (**arg != NUL) 2642 if (**arg != NUL)
2426 ++*arg; 2643 ++*arg;
2427 break; 2644 break;
2428 2645
2429 /* 2646 /*
2430 * nested expression: (expression). 2647 * nested expression: (expression).
2431 */ 2648 */
2432 case '(': *arg = skipwhite(*arg + 1); 2649 case '(': *arg = skipwhite(*arg + 1);
2433 ret = eval1(arg, retvar, evaluate); /* recursive! */ 2650 ret = eval1(arg, rettv, evaluate); /* recursive! */
2434 if (**arg == ')') 2651 if (**arg == ')')
2435 ++*arg; 2652 ++*arg;
2436 else if (ret == OK) 2653 else if (ret == OK)
2437 { 2654 {
2438 EMSG(_("E110: Missing ')'")); 2655 EMSG(_("E110: Missing ')'"));
2439 clear_vartv(retvar); 2656 clear_tv(rettv);
2440 ret = FAIL; 2657 ret = FAIL;
2441 } 2658 }
2442 break; 2659 break;
2443 2660
2444 /* 2661 /*
2458 /* If "s" is the name of a variable of type VAR_FUNC 2675 /* If "s" is the name of a variable of type VAR_FUNC
2459 * use its contents. */ 2676 * use its contents. */
2460 s = deref_func_name(s, &len); 2677 s = deref_func_name(s, &len);
2461 2678
2462 /* Invoke the function. */ 2679 /* Invoke the function. */
2463 ret = get_func_vartv(s, len, retvar, arg, 2680 ret = get_func_tv(s, len, rettv, arg,
2464 curwin->w_cursor.lnum, curwin->w_cursor.lnum, 2681 curwin->w_cursor.lnum, curwin->w_cursor.lnum,
2465 &len, evaluate); 2682 &len, evaluate);
2466 /* Stop the expression evaluation when immediately 2683 /* Stop the expression evaluation when immediately
2467 * aborting on error, or when an interrupt occurred or 2684 * aborting on error, or when an interrupt occurred or
2468 * an exception was thrown but not caught. */ 2685 * an exception was thrown but not caught. */
2469 if (aborting()) 2686 if (aborting())
2470 { 2687 {
2471 if (ret == OK) 2688 if (ret == OK)
2472 clear_vartv(retvar); 2689 clear_tv(rettv);
2473 ret = FAIL; 2690 ret = FAIL;
2474 } 2691 }
2475 } 2692 }
2476 else if (evaluate) 2693 else if (evaluate)
2477 ret = get_var_vartv(s, len, retvar); 2694 ret = get_var_tv(s, len, rettv);
2478 } 2695 }
2479 2696
2480 if (alias != NULL) 2697 if (alias != NULL)
2481 vim_free(alias); 2698 vim_free(alias);
2482 2699
2487 /* 2704 /*
2488 * Handle expr[expr] and expr[expr:expr] subscript. 2705 * Handle expr[expr] and expr[expr:expr] subscript.
2489 */ 2706 */
2490 while (**arg == '[' && ret == OK) 2707 while (**arg == '[' && ret == OK)
2491 { 2708 {
2492 if (eval_index(arg, retvar, evaluate) == FAIL) 2709 if (eval_index(arg, rettv, evaluate) == FAIL)
2493 { 2710 {
2494 clear_vartv(retvar); 2711 clear_tv(rettv);
2495 return FAIL; 2712 return FAIL;
2496 } 2713 }
2497 } 2714 }
2498 2715
2499 /* 2716 /*
2500 * Apply logical NOT and unary '-', from right to left, ignore '+'. 2717 * Apply logical NOT and unary '-', from right to left, ignore '+'.
2501 */ 2718 */
2502 if (ret == OK && evaluate && end_leader > start_leader) 2719 if (ret == OK && evaluate && end_leader > start_leader)
2503 { 2720 {
2504 val = get_vartv_number(retvar); 2721 val = get_tv_number(rettv);
2505 while (end_leader > start_leader) 2722 while (end_leader > start_leader)
2506 { 2723 {
2507 --end_leader; 2724 --end_leader;
2508 if (*end_leader == '!') 2725 if (*end_leader == '!')
2509 val = !val; 2726 val = !val;
2510 else if (*end_leader == '-') 2727 else if (*end_leader == '-')
2511 val = -val; 2728 val = -val;
2512 } 2729 }
2513 clear_vartv(retvar); 2730 clear_tv(rettv);
2514 retvar->v_type = VAR_NUMBER; 2731 rettv->v_type = VAR_NUMBER;
2515 retvar->vval.v_number = val; 2732 rettv->vval.v_number = val;
2516 } 2733 }
2517 2734
2518 return ret; 2735 return ret;
2519 } 2736 }
2520 2737
2522 * Evaluate an "[expr]" or "[expr:expr]" index. 2739 * Evaluate an "[expr]" or "[expr:expr]" index.
2523 * "*arg" points to the '['. 2740 * "*arg" points to the '['.
2524 * Returns FAIL or OK. "*arg" is advanced to after the ']'. 2741 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
2525 */ 2742 */
2526 static int 2743 static int
2527 eval_index(arg, retvar, evaluate) 2744 eval_index(arg, rettv, evaluate)
2528 char_u **arg; 2745 char_u **arg;
2529 typeval *retvar; 2746 typeval *rettv;
2530 int evaluate; 2747 int evaluate;
2531 { 2748 {
2532 int empty1 = FALSE, empty2 = FALSE; 2749 int empty1 = FALSE, empty2 = FALSE;
2533 typeval var1, var2; 2750 typeval var1, var2;
2534 long n1, n2 = 0; 2751 long n1, n2 = 0;
2535 long len; 2752 long len;
2536 int range; 2753 int range;
2537 char_u *s; 2754 char_u *s;
2538 2755
2539 if (retvar->v_type == VAR_FUNC) 2756 if (rettv->v_type == VAR_FUNC)
2540 { 2757 {
2541 EMSG(_("E999: Cannot index a Funcref")); 2758 EMSG(_("E999: Cannot index a Funcref"));
2542 return FAIL; 2759 return FAIL;
2543 } 2760 }
2544 2761
2560 *arg = skipwhite(*arg + 1); 2777 *arg = skipwhite(*arg + 1);
2561 if (**arg == ']') 2778 if (**arg == ']')
2562 empty2 = TRUE; 2779 empty2 = TRUE;
2563 else if (eval1(arg, &var2, evaluate) == FAIL) /* recursive! */ 2780 else if (eval1(arg, &var2, evaluate) == FAIL) /* recursive! */
2564 { 2781 {
2565 clear_vartv(&var1); 2782 clear_tv(&var1);
2566 return FAIL; 2783 return FAIL;
2567 } 2784 }
2568 } 2785 }
2569 else 2786 else
2570 range = FALSE; 2787 range = FALSE;
2571 2788
2572 /* Check for the ']'. */ 2789 /* Check for the ']'. */
2573 if (**arg != ']') 2790 if (**arg != ']')
2574 { 2791 {
2575 EMSG(_("E111: Missing ']'")); 2792 EMSG(_(e_missbrac));
2576 clear_vartv(&var1); 2793 clear_tv(&var1);
2577 if (range) 2794 if (range)
2578 clear_vartv(&var2); 2795 clear_tv(&var2);
2579 return FAIL; 2796 return FAIL;
2580 } 2797 }
2581 2798
2582 if (evaluate) 2799 if (evaluate)
2583 { 2800 {
2584 if (empty1) 2801 if (empty1)
2585 n1 = 0; 2802 n1 = 0;
2586 else 2803 else
2587 { 2804 {
2588 n1 = get_vartv_number(&var1); 2805 n1 = get_tv_number(&var1);
2589 clear_vartv(&var1); 2806 clear_tv(&var1);
2590 } 2807 }
2591 if (range) 2808 if (range)
2592 { 2809 {
2593 if (empty2) 2810 if (empty2)
2594 n2 = -1; 2811 n2 = -1;
2595 else 2812 else
2596 { 2813 {
2597 n2 = get_vartv_number(&var2); 2814 n2 = get_tv_number(&var2);
2598 clear_vartv(&var2); 2815 clear_tv(&var2);
2599 } 2816 }
2600 } 2817 }
2601 2818
2602 switch (retvar->v_type) 2819 switch (rettv->v_type)
2603 { 2820 {
2604 case VAR_NUMBER: 2821 case VAR_NUMBER:
2605 case VAR_STRING: 2822 case VAR_STRING:
2606 s = get_vartv_string(retvar); 2823 s = get_tv_string(rettv);
2607 len = (long)STRLEN(s); 2824 len = (long)STRLEN(s);
2608 if (range) 2825 if (range)
2609 { 2826 {
2610 /* The resulting variable is a substring. If the indexes 2827 /* The resulting variable is a substring. If the indexes
2611 * are out of range the result is empty. */ 2828 * are out of range the result is empty. */
2632 if (n1 >= len || n1 < 0) 2849 if (n1 >= len || n1 < 0)
2633 s = NULL; 2850 s = NULL;
2634 else 2851 else
2635 s = vim_strnsave(s + n1, 1); 2852 s = vim_strnsave(s + n1, 1);
2636 } 2853 }
2637 clear_vartv(retvar); 2854 clear_tv(rettv);
2638 retvar->v_type = VAR_STRING; 2855 rettv->v_type = VAR_STRING;
2639 retvar->vval.v_string = s; 2856 rettv->vval.v_string = s;
2640 break; 2857 break;
2641 2858
2642 case VAR_LIST: 2859 case VAR_LIST:
2643 len = list_len(retvar->vval.v_list); 2860 len = list_len(rettv->vval.v_list);
2644 if (n1 < 0) 2861 if (n1 < 0)
2645 n1 = len + n1; 2862 n1 = len + n1;
2646 if (!empty1 && (n1 < 0 || n1 >= len)) 2863 if (!empty1 && (n1 < 0 || n1 >= len))
2647 { 2864 {
2648 EMSGN(_(e_listidx), n1); 2865 EMSGN(_(e_listidx), n1);
2661 return FAIL; 2878 return FAIL;
2662 } 2879 }
2663 l = list_alloc(); 2880 l = list_alloc();
2664 if (l == NULL) 2881 if (l == NULL)
2665 return FAIL; 2882 return FAIL;
2666 for (item = list_find(retvar->vval.v_list, n1); 2883 for (item = list_find(rettv->vval.v_list, n1);
2667 n1 <= n2; ++n1) 2884 n1 <= n2; ++n1)
2668 { 2885 {
2669 if (list_append_tv(l, &item->li_tv) == FAIL) 2886 if (list_append_tv(l, &item->li_tv) == FAIL)
2670 { 2887 {
2671 list_free(l); 2888 list_free(l);
2672 return FAIL; 2889 return FAIL;
2673 } 2890 }
2674 item = item->li_next; 2891 item = item->li_next;
2675 } 2892 }
2676 clear_vartv(retvar); 2893 clear_tv(rettv);
2677 retvar->v_type = VAR_LIST; 2894 rettv->v_type = VAR_LIST;
2678 retvar->vval.v_list = l; 2895 rettv->vval.v_list = l;
2679 } 2896 }
2680 else 2897 else
2681 { 2898 {
2682 copy_vartv(&list_find(retvar->vval.v_list, n1)->li_tv, 2899 copy_tv(&list_find(rettv->vval.v_list, n1)->li_tv,
2683 &var1); 2900 &var1);
2684 clear_vartv(retvar); 2901 clear_tv(rettv);
2685 *retvar = var1; 2902 *rettv = var1;
2686 } 2903 }
2687 break; 2904 break;
2688 } 2905 }
2689 } 2906 }
2690 2907
2697 * "arg" points to the '&' or '+' before the option name. 2914 * "arg" points to the '&' or '+' before the option name.
2698 * "arg" is advanced to character after the option name. 2915 * "arg" is advanced to character after the option name.
2699 * Return OK or FAIL. 2916 * Return OK or FAIL.
2700 */ 2917 */
2701 static int 2918 static int
2702 get_option_vartv(arg, retvar, evaluate) 2919 get_option_tv(arg, rettv, evaluate)
2703 char_u **arg; 2920 char_u **arg;
2704 typeval *retvar; /* when NULL, only check if option exists */ 2921 typeval *rettv; /* when NULL, only check if option exists */
2705 int evaluate; 2922 int evaluate;
2706 { 2923 {
2707 char_u *option_end; 2924 char_u *option_end;
2708 long numval; 2925 long numval;
2709 char_u *stringval; 2926 char_u *stringval;
2717 * Isolate the option name and find its value. 2934 * Isolate the option name and find its value.
2718 */ 2935 */
2719 option_end = find_option_end(arg, &opt_flags); 2936 option_end = find_option_end(arg, &opt_flags);
2720 if (option_end == NULL) 2937 if (option_end == NULL)
2721 { 2938 {
2722 if (retvar != NULL) 2939 if (rettv != NULL)
2723 EMSG2(_("E112: Option name missing: %s"), *arg); 2940 EMSG2(_("E112: Option name missing: %s"), *arg);
2724 return FAIL; 2941 return FAIL;
2725 } 2942 }
2726 2943
2727 if (!evaluate) 2944 if (!evaluate)
2731 } 2948 }
2732 2949
2733 c = *option_end; 2950 c = *option_end;
2734 *option_end = NUL; 2951 *option_end = NUL;
2735 opt_type = get_option_value(*arg, &numval, 2952 opt_type = get_option_value(*arg, &numval,
2736 retvar == NULL ? NULL : &stringval, opt_flags); 2953 rettv == NULL ? NULL : &stringval, opt_flags);
2737 2954
2738 if (opt_type == -3) /* invalid name */ 2955 if (opt_type == -3) /* invalid name */
2739 { 2956 {
2740 if (retvar != NULL) 2957 if (rettv != NULL)
2741 EMSG2(_("E113: Unknown option: %s"), *arg); 2958 EMSG2(_("E113: Unknown option: %s"), *arg);
2742 ret = FAIL; 2959 ret = FAIL;
2743 } 2960 }
2744 else if (retvar != NULL) 2961 else if (rettv != NULL)
2745 { 2962 {
2746 if (opt_type == -2) /* hidden string option */ 2963 if (opt_type == -2) /* hidden string option */
2747 { 2964 {
2748 retvar->v_type = VAR_STRING; 2965 rettv->v_type = VAR_STRING;
2749 retvar->vval.v_string = NULL; 2966 rettv->vval.v_string = NULL;
2750 } 2967 }
2751 else if (opt_type == -1) /* hidden number option */ 2968 else if (opt_type == -1) /* hidden number option */
2752 { 2969 {
2753 retvar->v_type = VAR_NUMBER; 2970 rettv->v_type = VAR_NUMBER;
2754 retvar->vval.v_number = 0; 2971 rettv->vval.v_number = 0;
2755 } 2972 }
2756 else if (opt_type == 1) /* number option */ 2973 else if (opt_type == 1) /* number option */
2757 { 2974 {
2758 retvar->v_type = VAR_NUMBER; 2975 rettv->v_type = VAR_NUMBER;
2759 retvar->vval.v_number = numval; 2976 rettv->vval.v_number = numval;
2760 } 2977 }
2761 else /* string option */ 2978 else /* string option */
2762 { 2979 {
2763 retvar->v_type = VAR_STRING; 2980 rettv->v_type = VAR_STRING;
2764 retvar->vval.v_string = stringval; 2981 rettv->vval.v_string = stringval;
2765 } 2982 }
2766 } 2983 }
2767 else if (working && (opt_type == -2 || opt_type == -1)) 2984 else if (working && (opt_type == -2 || opt_type == -1))
2768 ret = FAIL; 2985 ret = FAIL;
2769 2986
2776 /* 2993 /*
2777 * Allocate a variable for a string constant. 2994 * Allocate a variable for a string constant.
2778 * Return OK or FAIL. 2995 * Return OK or FAIL.
2779 */ 2996 */
2780 static int 2997 static int
2781 get_string_vartv(arg, retvar, evaluate) 2998 get_string_tv(arg, rettv, evaluate)
2782 char_u **arg; 2999 char_u **arg;
2783 typeval *retvar; 3000 typeval *rettv;
2784 int evaluate; 3001 int evaluate;
2785 { 3002 {
2786 char_u *p; 3003 char_u *p;
2787 char_u *name; 3004 char_u *name;
2788 int i; 3005 int i;
2921 #endif 3138 #endif
2922 } 3139 }
2923 name[i] = NUL; 3140 name[i] = NUL;
2924 *arg = p + 1; 3141 *arg = p + 1;
2925 3142
2926 retvar->v_type = VAR_STRING; 3143 rettv->v_type = VAR_STRING;
2927 retvar->vval.v_string = name; 3144 rettv->vval.v_string = name;
2928 3145
2929 return OK; 3146 return OK;
2930 } 3147 }
2931 3148
2932 /* 3149 /*
2933 * Allocate a variable for an backtick-string constant. 3150 * Allocate a variable for an backtick-string constant.
2934 * Return OK or FAIL. 3151 * Return OK or FAIL.
2935 */ 3152 */
2936 static int 3153 static int
2937 get_lit_string_vartv(arg, retvar, evaluate) 3154 get_lit_string_tv(arg, rettv, evaluate)
2938 char_u **arg; 3155 char_u **arg;
2939 typeval *retvar; 3156 typeval *rettv;
2940 int evaluate; 3157 int evaluate;
2941 { 3158 {
2942 char_u *p; 3159 char_u *p;
2943 char_u *name; 3160 char_u *name;
2944 3161
2959 */ 3176 */
2960 name = vim_strnsave(*arg + 1, (int)(p - (*arg + 1))); 3177 name = vim_strnsave(*arg + 1, (int)(p - (*arg + 1)));
2961 if (name == NULL) 3178 if (name == NULL)
2962 return FAIL; 3179 return FAIL;
2963 3180
2964 retvar->v_type = VAR_STRING; 3181 rettv->v_type = VAR_STRING;
2965 retvar->vval.v_string = name; 3182 rettv->vval.v_string = name;
2966 } 3183 }
2967 3184
2968 *arg = p + 1; 3185 *arg = p + 1;
2969 3186
2970 return OK; 3187 return OK;
2973 /* 3190 /*
2974 * Allocate a variable for a List and fill it from "*arg". 3191 * Allocate a variable for a List and fill it from "*arg".
2975 * Return OK or FAIL. 3192 * Return OK or FAIL.
2976 */ 3193 */
2977 static int 3194 static int
2978 get_list_vartv(arg, retvar, evaluate) 3195 get_list_tv(arg, rettv, evaluate)
2979 char_u **arg; 3196 char_u **arg;
2980 typeval *retvar; 3197 typeval *rettv;
2981 int evaluate; 3198 int evaluate;
2982 { 3199 {
2983 listvar *l = NULL; 3200 listvar *l = NULL;
2984 typeval tv; 3201 typeval tv;
2985 listitem *item; 3202 listitem *item;
3026 } 3243 }
3027 3244
3028 *arg = skipwhite(*arg + 1); 3245 *arg = skipwhite(*arg + 1);
3029 if (evaluate) 3246 if (evaluate)
3030 { 3247 {
3031 retvar->v_type = VAR_LIST; 3248 rettv->v_type = VAR_LIST;
3032 retvar->vval.v_list = l; 3249 rettv->vval.v_list = l;
3033 ++l->lv_refcount; 3250 ++l->lv_refcount;
3034 } 3251 }
3035 3252
3036 return OK; 3253 return OK;
3037 } 3254 }
3090 */ 3307 */
3091 static void 3308 static void
3092 listitem_free(item) 3309 listitem_free(item)
3093 listitem *item; 3310 listitem *item;
3094 { 3311 {
3095 clear_vartv(&item->li_tv); 3312 clear_tv(&item->li_tv);
3096 vim_free(item); 3313 vim_free(item);
3097 } 3314 }
3098 3315
3099 /* 3316 /*
3100 * Get the number of items in a list. 3317 * Get the number of items in a list.
3179 { 3396 {
3180 listitem *ni = listitem_alloc(); 3397 listitem *ni = listitem_alloc();
3181 3398
3182 if (ni == NULL) 3399 if (ni == NULL)
3183 return FAIL; 3400 return FAIL;
3184 copy_vartv(tv, &ni->li_tv); 3401 copy_tv(tv, &ni->li_tv);
3185 list_append(l, ni); 3402 list_append(l, ni);
3186 return OK; 3403 return OK;
3187 } 3404 }
3188 3405
3189 /* 3406 /*
3228 vim_free(ni); 3445 vim_free(ni);
3229 break; 3446 break;
3230 } 3447 }
3231 } 3448 }
3232 else 3449 else
3233 copy_vartv(&item->li_tv, &ni->li_tv); 3450 copy_tv(&item->li_tv, &ni->li_tv);
3234 list_append(copy, ni); 3451 list_append(copy, ni);
3235 } 3452 }
3236 ++copy->lv_refcount; 3453 ++copy->lv_refcount;
3237 } 3454 }
3238 3455
3321 *tofree = NULL; 3538 *tofree = NULL;
3322 return tv->vval.v_string; 3539 return tv->vval.v_string;
3323 case VAR_LIST: 3540 case VAR_LIST:
3324 *tofree = list2string(tv); 3541 *tofree = list2string(tv);
3325 return *tofree; 3542 return *tofree;
3543 case VAR_STRING:
3544 case VAR_NUMBER:
3545 break;
3326 default: 3546 default:
3327 break; 3547 EMSG2(_(e_intern2), "tv2string()");
3328 } 3548 }
3329 *tofree = NULL; 3549 *tofree = NULL;
3330 return get_vartv_string(tv); 3550 return get_tv_string(tv);
3331 } 3551 }
3332 3552
3333 /* 3553 /*
3334 * Get the value of an environment variable. 3554 * Get the value of an environment variable.
3335 * "arg" is pointing to the '$'. It is advanced to after the name. 3555 * "arg" is pointing to the '$'. It is advanced to after the name.
3336 * If the environment variable was not set, silently assume it is empty. 3556 * If the environment variable was not set, silently assume it is empty.
3337 * Always return OK. 3557 * Always return OK.
3338 */ 3558 */
3339 static int 3559 static int
3340 get_env_vartv(arg, retvar, evaluate) 3560 get_env_tv(arg, rettv, evaluate)
3341 char_u **arg; 3561 char_u **arg;
3342 typeval *retvar; 3562 typeval *rettv;
3343 int evaluate; 3563 int evaluate;
3344 { 3564 {
3345 char_u *string = NULL; 3565 char_u *string = NULL;
3346 int len; 3566 int len;
3347 int cc; 3567 int cc;
3370 string = NULL; 3590 string = NULL;
3371 } 3591 }
3372 } 3592 }
3373 name[len] = cc; 3593 name[len] = cc;
3374 } 3594 }
3375 retvar->v_type = VAR_STRING; 3595 rettv->v_type = VAR_STRING;
3376 retvar->vval.v_string = string; 3596 rettv->vval.v_string = string;
3377 } 3597 }
3378 3598
3379 return OK; 3599 return OK;
3380 } 3600 }
3381 3601
3668 /* 3888 /*
3669 * Allocate a variable for the result of a function. 3889 * Allocate a variable for the result of a function.
3670 * Return OK or FAIL. 3890 * Return OK or FAIL.
3671 */ 3891 */
3672 static int 3892 static int
3673 get_func_vartv(name, len, retvar, arg, firstline, lastline, doesrange, evaluate) 3893 get_func_tv(name, len, rettv, arg, firstline, lastline, doesrange, evaluate)
3674 char_u *name; /* name of the function */ 3894 char_u *name; /* name of the function */
3675 int len; /* length of "name" */ 3895 int len; /* length of "name" */
3676 typeval *retvar; 3896 typeval *rettv;
3677 char_u **arg; /* argument, pointing to the '(' */ 3897 char_u **arg; /* argument, pointing to the '(' */
3678 linenr_T firstline; /* first line of range */ 3898 linenr_T firstline; /* first line of range */
3679 linenr_T lastline; /* last line of range */ 3899 linenr_T lastline; /* last line of range */
3680 int *doesrange; /* return: function handled range */ 3900 int *doesrange; /* return: function handled range */
3681 int evaluate; 3901 int evaluate;
3708 ++argp; 3928 ++argp;
3709 else 3929 else
3710 ret = FAIL; 3930 ret = FAIL;
3711 3931
3712 if (ret == OK) 3932 if (ret == OK)
3713 ret = call_func(name, len, retvar, argcount, argvars, 3933 ret = call_func(name, len, rettv, argcount, argvars,
3714 firstline, lastline, doesrange, evaluate); 3934 firstline, lastline, doesrange, evaluate);
3715 else if (!aborting()) 3935 else if (!aborting())
3716 EMSG2(_("E116: Invalid arguments for function %s"), name); 3936 EMSG2(_("E116: Invalid arguments for function %s"), name);
3717 3937
3718 while (--argcount >= 0) 3938 while (--argcount >= 0)
3719 clear_vartv(&argvars[argcount]); 3939 clear_tv(&argvars[argcount]);
3720 3940
3721 *arg = skipwhite(argp); 3941 *arg = skipwhite(argp);
3722 return ret; 3942 return ret;
3723 } 3943 }
3724 3944
3726 /* 3946 /*
3727 * Call a function with its resolved parameters 3947 * Call a function with its resolved parameters
3728 * Return OK or FAIL. 3948 * Return OK or FAIL.
3729 */ 3949 */
3730 static int 3950 static int
3731 call_func(name, len, retvar, argcount, argvars, firstline, lastline, 3951 call_func(name, len, rettv, argcount, argvars, firstline, lastline,
3732 doesrange, evaluate) 3952 doesrange, evaluate)
3733 char_u *name; /* name of the function */ 3953 char_u *name; /* name of the function */
3734 int len; /* length of "name" */ 3954 int len; /* length of "name" */
3735 typeval *retvar; /* return value goes here */ 3955 typeval *rettv; /* return value goes here */
3736 int argcount; /* number of "argvars" */ 3956 int argcount; /* number of "argvars" */
3737 typeval *argvars; /* vars for arguments */ 3957 typeval *argvars; /* vars for arguments */
3738 linenr_T firstline; /* first line of range */ 3958 linenr_T firstline; /* first line of range */
3739 linenr_T lastline; /* last line of range */ 3959 linenr_T lastline; /* last line of range */
3740 int *doesrange; /* return: function handled range */ 3960 int *doesrange; /* return: function handled range */
3810 4030
3811 4031
3812 /* execute the function if no errors detected and executing */ 4032 /* execute the function if no errors detected and executing */
3813 if (evaluate && error == ERROR_NONE) 4033 if (evaluate && error == ERROR_NONE)
3814 { 4034 {
3815 retvar->v_type = VAR_NUMBER; /* default is number retvar */ 4035 rettv->v_type = VAR_NUMBER; /* default is number rettv */
3816 error = ERROR_UNKNOWN; 4036 error = ERROR_UNKNOWN;
3817 4037
3818 if (!ASCII_ISLOWER(fname[0])) 4038 if (!ASCII_ISLOWER(fname[0]))
3819 { 4039 {
3820 /* 4040 /*
3849 * redo buffer. 4069 * redo buffer.
3850 */ 4070 */
3851 save_search_patterns(); 4071 save_search_patterns();
3852 saveRedobuff(); 4072 saveRedobuff();
3853 ++fp->calls; 4073 ++fp->calls;
3854 call_user_func(fp, argcount, argvars, retvar, 4074 call_user_func(fp, argcount, argvars, rettv,
3855 firstline, lastline); 4075 firstline, lastline);
3856 --fp->calls; 4076 --fp->calls;
3857 restoreRedobuff(); 4077 restoreRedobuff();
3858 restore_search_patterns(); 4078 restore_search_patterns();
3859 error = ERROR_NONE; 4079 error = ERROR_NONE;
3873 else if (argcount > functions[i].f_max_argc) 4093 else if (argcount > functions[i].f_max_argc)
3874 error = ERROR_TOOMANY; 4094 error = ERROR_TOOMANY;
3875 else 4095 else
3876 { 4096 {
3877 argvars[argcount].v_type = VAR_UNKNOWN; 4097 argvars[argcount].v_type = VAR_UNKNOWN;
3878 functions[i].f_func(argvars, retvar); 4098 functions[i].f_func(argvars, rettv);
3879 error = ERROR_NONE; 4099 error = ERROR_NONE;
3880 } 4100 }
3881 } 4101 }
3882 } 4102 }
3883 /* 4103 /*
3916 /* 4136 /*
3917 * "append(lnum, string)" function 4137 * "append(lnum, string)" function
3918 * or "append(list, item)" function 4138 * or "append(list, item)" function
3919 */ 4139 */
3920 static void 4140 static void
3921 f_append(argvars, retvar) 4141 f_append(argvars, rettv)
3922 typeval *argvars; 4142 typeval *argvars;
3923 typeval *retvar; 4143 typeval *rettv;
3924 { 4144 {
3925 long lnum; 4145 long lnum;
3926 4146
3927 retvar->vval.v_number = 1; /* Default: Failed */ 4147 rettv->vval.v_number = 1; /* Default: Failed */
3928 if (argvars[0].v_type == VAR_LIST) 4148 if (argvars[0].v_type == VAR_LIST)
3929 { 4149 {
3930 if (argvars[0].vval.v_list != NULL 4150 if (argvars[0].vval.v_list != NULL
3931 && list_append_tv(argvars[0].vval.v_list, &argvars[1]) == OK) 4151 && list_append_tv(argvars[0].vval.v_list, &argvars[1]) == OK)
3932 copy_vartv(&argvars[0], retvar); 4152 copy_tv(&argvars[0], rettv);
3933 } 4153 }
3934 else 4154 else
3935 { 4155 {
3936 lnum = get_vartv_lnum(argvars); 4156 lnum = get_tv_lnum(argvars);
3937 if (lnum >= 0 4157 if (lnum >= 0
3938 && lnum <= curbuf->b_ml.ml_line_count 4158 && lnum <= curbuf->b_ml.ml_line_count
3939 && u_save(lnum, lnum + 1) == OK) 4159 && u_save(lnum, lnum + 1) == OK)
3940 { 4160 {
3941 ml_append(lnum, get_vartv_string(&argvars[1]), (colnr_T)0, FALSE); 4161 ml_append(lnum, get_tv_string(&argvars[1]), (colnr_T)0, FALSE);
3942 if (curwin->w_cursor.lnum > lnum) 4162 if (curwin->w_cursor.lnum > lnum)
3943 ++curwin->w_cursor.lnum; 4163 ++curwin->w_cursor.lnum;
3944 appended_lines_mark(lnum, 1L); 4164 appended_lines_mark(lnum, 1L);
3945 retvar->vval.v_number = 0; 4165 rettv->vval.v_number = 0;
3946 } 4166 }
3947 } 4167 }
3948 } 4168 }
3949 4169
3950 /* 4170 /*
3951 * "argc()" function 4171 * "argc()" function
3952 */ 4172 */
3953 /* ARGSUSED */ 4173 /* ARGSUSED */
3954 static void 4174 static void
3955 f_argc(argvars, retvar) 4175 f_argc(argvars, rettv)
3956 typeval *argvars; 4176 typeval *argvars;
3957 typeval *retvar; 4177 typeval *rettv;
3958 { 4178 {
3959 retvar->vval.v_number = ARGCOUNT; 4179 rettv->vval.v_number = ARGCOUNT;
3960 } 4180 }
3961 4181
3962 /* 4182 /*
3963 * "argidx()" function 4183 * "argidx()" function
3964 */ 4184 */
3965 /* ARGSUSED */ 4185 /* ARGSUSED */
3966 static void 4186 static void
3967 f_argidx(argvars, retvar) 4187 f_argidx(argvars, rettv)
3968 typeval *argvars; 4188 typeval *argvars;
3969 typeval *retvar; 4189 typeval *rettv;
3970 { 4190 {
3971 retvar->vval.v_number = curwin->w_arg_idx; 4191 rettv->vval.v_number = curwin->w_arg_idx;
3972 } 4192 }
3973 4193
3974 /* 4194 /*
3975 * "argv(nr)" function 4195 * "argv(nr)" function
3976 */ 4196 */
3977 static void 4197 static void
3978 f_argv(argvars, retvar) 4198 f_argv(argvars, rettv)
3979 typeval *argvars; 4199 typeval *argvars;
3980 typeval *retvar; 4200 typeval *rettv;
3981 { 4201 {
3982 int idx; 4202 int idx;
3983 4203
3984 idx = get_vartv_number(&argvars[0]); 4204 idx = get_tv_number(&argvars[0]);
3985 if (idx >= 0 && idx < ARGCOUNT) 4205 if (idx >= 0 && idx < ARGCOUNT)
3986 retvar->vval.v_string = vim_strsave(alist_name(&ARGLIST[idx])); 4206 rettv->vval.v_string = vim_strsave(alist_name(&ARGLIST[idx]));
3987 else 4207 else
3988 retvar->vval.v_string = NULL; 4208 rettv->vval.v_string = NULL;
3989 retvar->v_type = VAR_STRING; 4209 rettv->v_type = VAR_STRING;
3990 } 4210 }
3991 4211
3992 /* 4212 /*
3993 * "browse(save, title, initdir, default)" function 4213 * "browse(save, title, initdir, default)" function
3994 */ 4214 */
3995 /* ARGSUSED */ 4215 /* ARGSUSED */
3996 static void 4216 static void
3997 f_browse(argvars, retvar) 4217 f_browse(argvars, rettv)
3998 typeval *argvars; 4218 typeval *argvars;
3999 typeval *retvar; 4219 typeval *rettv;
4000 { 4220 {
4001 #ifdef FEAT_BROWSE 4221 #ifdef FEAT_BROWSE
4002 int save; 4222 int save;
4003 char_u *title; 4223 char_u *title;
4004 char_u *initdir; 4224 char_u *initdir;
4005 char_u *defname; 4225 char_u *defname;
4006 char_u buf[NUMBUFLEN]; 4226 char_u buf[NUMBUFLEN];
4007 char_u buf2[NUMBUFLEN]; 4227 char_u buf2[NUMBUFLEN];
4008 4228
4009 save = get_vartv_number(&argvars[0]); 4229 save = get_tv_number(&argvars[0]);
4010 title = get_vartv_string(&argvars[1]); 4230 title = get_tv_string(&argvars[1]);
4011 initdir = get_vartv_string_buf(&argvars[2], buf); 4231 initdir = get_tv_string_buf(&argvars[2], buf);
4012 defname = get_vartv_string_buf(&argvars[3], buf2); 4232 defname = get_tv_string_buf(&argvars[3], buf2);
4013 4233
4014 retvar->vval.v_string = 4234 rettv->vval.v_string =
4015 do_browse(save ? BROWSE_SAVE : 0, 4235 do_browse(save ? BROWSE_SAVE : 0,
4016 title, defname, NULL, initdir, NULL, curbuf); 4236 title, defname, NULL, initdir, NULL, curbuf);
4017 #else 4237 #else
4018 retvar->vval.v_string = NULL; 4238 rettv->vval.v_string = NULL;
4019 #endif 4239 #endif
4020 retvar->v_type = VAR_STRING; 4240 rettv->v_type = VAR_STRING;
4021 } 4241 }
4022 4242
4023 /* 4243 /*
4024 * "browsedir(title, initdir)" function 4244 * "browsedir(title, initdir)" function
4025 */ 4245 */
4026 /* ARGSUSED */ 4246 /* ARGSUSED */
4027 static void 4247 static void
4028 f_browsedir(argvars, retvar) 4248 f_browsedir(argvars, rettv)
4029 typeval *argvars; 4249 typeval *argvars;
4030 typeval *retvar; 4250 typeval *rettv;
4031 { 4251 {
4032 #ifdef FEAT_BROWSE 4252 #ifdef FEAT_BROWSE
4033 char_u *title; 4253 char_u *title;
4034 char_u *initdir; 4254 char_u *initdir;
4035 char_u buf[NUMBUFLEN]; 4255 char_u buf[NUMBUFLEN];
4036 4256
4037 title = get_vartv_string(&argvars[0]); 4257 title = get_tv_string(&argvars[0]);
4038 initdir = get_vartv_string_buf(&argvars[1], buf); 4258 initdir = get_tv_string_buf(&argvars[1], buf);
4039 4259
4040 retvar->vval.v_string = do_browse(BROWSE_DIR, 4260 rettv->vval.v_string = do_browse(BROWSE_DIR,
4041 title, NULL, NULL, initdir, NULL, curbuf); 4261 title, NULL, NULL, initdir, NULL, curbuf);
4042 #else 4262 #else
4043 retvar->vval.v_string = NULL; 4263 rettv->vval.v_string = NULL;
4044 #endif 4264 #endif
4045 retvar->v_type = VAR_STRING; 4265 rettv->v_type = VAR_STRING;
4046 } 4266 }
4047 4267
4048 /* 4268 /*
4049 * Find a buffer by number or exact name. 4269 * Find a buffer by number or exact name.
4050 */ 4270 */
4079 4299
4080 /* 4300 /*
4081 * "bufexists(expr)" function 4301 * "bufexists(expr)" function
4082 */ 4302 */
4083 static void 4303 static void
4084 f_bufexists(argvars, retvar) 4304 f_bufexists(argvars, rettv)
4085 typeval *argvars; 4305 typeval *argvars;
4086 typeval *retvar; 4306 typeval *rettv;
4087 { 4307 {
4088 retvar->vval.v_number = (find_buffer(&argvars[0]) != NULL); 4308 rettv->vval.v_number = (find_buffer(&argvars[0]) != NULL);
4089 } 4309 }
4090 4310
4091 /* 4311 /*
4092 * "buflisted(expr)" function 4312 * "buflisted(expr)" function
4093 */ 4313 */
4094 static void 4314 static void
4095 f_buflisted(argvars, retvar) 4315 f_buflisted(argvars, rettv)
4096 typeval *argvars; 4316 typeval *argvars;
4097 typeval *retvar; 4317 typeval *rettv;
4098 { 4318 {
4099 buf_T *buf; 4319 buf_T *buf;
4100 4320
4101 buf = find_buffer(&argvars[0]); 4321 buf = find_buffer(&argvars[0]);
4102 retvar->vval.v_number = (buf != NULL && buf->b_p_bl); 4322 rettv->vval.v_number = (buf != NULL && buf->b_p_bl);
4103 } 4323 }
4104 4324
4105 /* 4325 /*
4106 * "bufloaded(expr)" function 4326 * "bufloaded(expr)" function
4107 */ 4327 */
4108 static void 4328 static void
4109 f_bufloaded(argvars, retvar) 4329 f_bufloaded(argvars, rettv)
4110 typeval *argvars; 4330 typeval *argvars;
4111 typeval *retvar; 4331 typeval *rettv;
4112 { 4332 {
4113 buf_T *buf; 4333 buf_T *buf;
4114 4334
4115 buf = find_buffer(&argvars[0]); 4335 buf = find_buffer(&argvars[0]);
4116 retvar->vval.v_number = (buf != NULL && buf->b_ml.ml_mfp != NULL); 4336 rettv->vval.v_number = (buf != NULL && buf->b_ml.ml_mfp != NULL);
4117 } 4337 }
4118 4338
4119 /* 4339 /*
4120 * Get buffer by number or pattern. 4340 * Get buffer by number or pattern.
4121 */ 4341 */
4122 static buf_T * 4342 static buf_T *
4123 get_buf_vartv(avar) 4343 get_buf_tv(tv)
4124 typeval *avar; 4344 typeval *tv;
4125 { 4345 {
4126 char_u *name = avar->vval.v_string; 4346 char_u *name = tv->vval.v_string;
4127 int save_magic; 4347 int save_magic;
4128 char_u *save_cpo; 4348 char_u *save_cpo;
4129 buf_T *buf; 4349 buf_T *buf;
4130 4350
4131 if (avar->v_type == VAR_NUMBER) 4351 if (tv->v_type == VAR_NUMBER)
4132 return buflist_findnr((int)avar->vval.v_number); 4352 return buflist_findnr((int)tv->vval.v_number);
4133 if (name == NULL || *name == NUL) 4353 if (name == NULL || *name == NUL)
4134 return curbuf; 4354 return curbuf;
4135 if (name[0] == '$' && name[1] == NUL) 4355 if (name[0] == '$' && name[1] == NUL)
4136 return lastbuf; 4356 return lastbuf;
4137 4357
4147 p_magic = save_magic; 4367 p_magic = save_magic;
4148 p_cpo = save_cpo; 4368 p_cpo = save_cpo;
4149 4369
4150 /* If not found, try expanding the name, like done for bufexists(). */ 4370 /* If not found, try expanding the name, like done for bufexists(). */
4151 if (buf == NULL) 4371 if (buf == NULL)
4152 buf = find_buffer(avar); 4372 buf = find_buffer(tv);
4153 4373
4154 return buf; 4374 return buf;
4155 } 4375 }
4156 4376
4157 /* 4377 /*
4158 * "bufname(expr)" function 4378 * "bufname(expr)" function
4159 */ 4379 */
4160 static void 4380 static void
4161 f_bufname(argvars, retvar) 4381 f_bufname(argvars, rettv)
4162 typeval *argvars; 4382 typeval *argvars;
4163 typeval *retvar; 4383 typeval *rettv;
4164 { 4384 {
4165 buf_T *buf; 4385 buf_T *buf;
4166 4386
4167 ++emsg_off; 4387 ++emsg_off;
4168 buf = get_buf_vartv(&argvars[0]); 4388 buf = get_buf_tv(&argvars[0]);
4169 retvar->v_type = VAR_STRING; 4389 rettv->v_type = VAR_STRING;
4170 if (buf != NULL && buf->b_fname != NULL) 4390 if (buf != NULL && buf->b_fname != NULL)
4171 retvar->vval.v_string = vim_strsave(buf->b_fname); 4391 rettv->vval.v_string = vim_strsave(buf->b_fname);
4172 else 4392 else
4173 retvar->vval.v_string = NULL; 4393 rettv->vval.v_string = NULL;
4174 --emsg_off; 4394 --emsg_off;
4175 } 4395 }
4176 4396
4177 /* 4397 /*
4178 * "bufnr(expr)" function 4398 * "bufnr(expr)" function
4179 */ 4399 */
4180 static void 4400 static void
4181 f_bufnr(argvars, retvar) 4401 f_bufnr(argvars, rettv)
4182 typeval *argvars; 4402 typeval *argvars;
4183 typeval *retvar; 4403 typeval *rettv;
4184 { 4404 {
4185 buf_T *buf; 4405 buf_T *buf;
4186 4406
4187 ++emsg_off; 4407 ++emsg_off;
4188 buf = get_buf_vartv(&argvars[0]); 4408 buf = get_buf_tv(&argvars[0]);
4189 if (buf != NULL) 4409 if (buf != NULL)
4190 retvar->vval.v_number = buf->b_fnum; 4410 rettv->vval.v_number = buf->b_fnum;
4191 else 4411 else
4192 retvar->vval.v_number = -1; 4412 rettv->vval.v_number = -1;
4193 --emsg_off; 4413 --emsg_off;
4194 } 4414 }
4195 4415
4196 /* 4416 /*
4197 * "bufwinnr(nr)" function 4417 * "bufwinnr(nr)" function
4198 */ 4418 */
4199 static void 4419 static void
4200 f_bufwinnr(argvars, retvar) 4420 f_bufwinnr(argvars, rettv)
4201 typeval *argvars; 4421 typeval *argvars;
4202 typeval *retvar; 4422 typeval *rettv;
4203 { 4423 {
4204 #ifdef FEAT_WINDOWS 4424 #ifdef FEAT_WINDOWS
4205 win_T *wp; 4425 win_T *wp;
4206 int winnr = 0; 4426 int winnr = 0;
4207 #endif 4427 #endif
4208 buf_T *buf; 4428 buf_T *buf;
4209 4429
4210 ++emsg_off; 4430 ++emsg_off;
4211 buf = get_buf_vartv(&argvars[0]); 4431 buf = get_buf_tv(&argvars[0]);
4212 #ifdef FEAT_WINDOWS 4432 #ifdef FEAT_WINDOWS
4213 for (wp = firstwin; wp; wp = wp->w_next) 4433 for (wp = firstwin; wp; wp = wp->w_next)
4214 { 4434 {
4215 ++winnr; 4435 ++winnr;
4216 if (wp->w_buffer == buf) 4436 if (wp->w_buffer == buf)
4217 break; 4437 break;
4218 } 4438 }
4219 retvar->vval.v_number = (wp != NULL ? winnr : -1); 4439 rettv->vval.v_number = (wp != NULL ? winnr : -1);
4220 #else 4440 #else
4221 retvar->vval.v_number = (curwin->w_buffer == buf ? 1 : -1); 4441 rettv->vval.v_number = (curwin->w_buffer == buf ? 1 : -1);
4222 #endif 4442 #endif
4223 --emsg_off; 4443 --emsg_off;
4224 } 4444 }
4225 4445
4226 /* 4446 /*
4227 * "byte2line(byte)" function 4447 * "byte2line(byte)" function
4228 */ 4448 */
4229 /*ARGSUSED*/ 4449 /*ARGSUSED*/
4230 static void 4450 static void
4231 f_byte2line(argvars, retvar) 4451 f_byte2line(argvars, rettv)
4232 typeval *argvars; 4452 typeval *argvars;
4233 typeval *retvar; 4453 typeval *rettv;
4234 { 4454 {
4235 #ifndef FEAT_BYTEOFF 4455 #ifndef FEAT_BYTEOFF
4236 retvar->vval.v_number = -1; 4456 rettv->vval.v_number = -1;
4237 #else 4457 #else
4238 long boff = 0; 4458 long boff = 0;
4239 4459
4240 boff = get_vartv_number(&argvars[0]) - 1; 4460 boff = get_tv_number(&argvars[0]) - 1;
4241 if (boff < 0) 4461 if (boff < 0)
4242 retvar->vval.v_number = -1; 4462 rettv->vval.v_number = -1;
4243 else 4463 else
4244 retvar->vval.v_number = ml_find_line_or_offset(curbuf, 4464 rettv->vval.v_number = ml_find_line_or_offset(curbuf,
4245 (linenr_T)0, &boff); 4465 (linenr_T)0, &boff);
4246 #endif 4466 #endif
4247 } 4467 }
4248 4468
4249 /* 4469 /*
4250 * "byteidx()" function 4470 * "byteidx()" function
4251 */ 4471 */
4252 /*ARGSUSED*/ 4472 /*ARGSUSED*/
4253 static void 4473 static void
4254 f_byteidx(argvars, retvar) 4474 f_byteidx(argvars, rettv)
4255 typeval *argvars; 4475 typeval *argvars;
4256 typeval *retvar; 4476 typeval *rettv;
4257 { 4477 {
4258 #ifdef FEAT_MBYTE 4478 #ifdef FEAT_MBYTE
4259 char_u *t; 4479 char_u *t;
4260 #endif 4480 #endif
4261 char_u *str; 4481 char_u *str;
4262 long idx; 4482 long idx;
4263 4483
4264 str = get_vartv_string(&argvars[0]); 4484 str = get_tv_string(&argvars[0]);
4265 idx = get_vartv_number(&argvars[1]); 4485 idx = get_tv_number(&argvars[1]);
4266 retvar->vval.v_number = -1; 4486 rettv->vval.v_number = -1;
4267 if (idx < 0) 4487 if (idx < 0)
4268 return; 4488 return;
4269 4489
4270 #ifdef FEAT_MBYTE 4490 #ifdef FEAT_MBYTE
4271 t = str; 4491 t = str;
4273 { 4493 {
4274 if (*t == NUL) /* EOL reached */ 4494 if (*t == NUL) /* EOL reached */
4275 return; 4495 return;
4276 t += mb_ptr2len_check(t); 4496 t += mb_ptr2len_check(t);
4277 } 4497 }
4278 retvar->vval.v_number = t - str; 4498 rettv->vval.v_number = t - str;
4279 #else 4499 #else
4280 if (idx <= STRLEN(str)) 4500 if (idx <= STRLEN(str))
4281 retvar->vval.v_number = idx; 4501 rettv->vval.v_number = idx;
4282 #endif 4502 #endif
4283 } 4503 }
4284 4504
4285 /* 4505 /*
4286 * "char2nr(string)" function 4506 * "char2nr(string)" function
4287 */ 4507 */
4288 static void 4508 static void
4289 f_char2nr(argvars, retvar) 4509 f_char2nr(argvars, rettv)
4290 typeval *argvars; 4510 typeval *argvars;
4291 typeval *retvar; 4511 typeval *rettv;
4292 { 4512 {
4293 #ifdef FEAT_MBYTE 4513 #ifdef FEAT_MBYTE
4294 if (has_mbyte) 4514 if (has_mbyte)
4295 retvar->vval.v_number = 4515 rettv->vval.v_number =
4296 (*mb_ptr2char)(get_vartv_string(&argvars[0])); 4516 (*mb_ptr2char)(get_tv_string(&argvars[0]));
4297 else 4517 else
4298 #endif 4518 #endif
4299 retvar->vval.v_number = get_vartv_string(&argvars[0])[0]; 4519 rettv->vval.v_number = get_tv_string(&argvars[0])[0];
4300 } 4520 }
4301 4521
4302 /* 4522 /*
4303 * "cindent(lnum)" function 4523 * "cindent(lnum)" function
4304 */ 4524 */
4305 static void 4525 static void
4306 f_cindent(argvars, retvar) 4526 f_cindent(argvars, rettv)
4307 typeval *argvars; 4527 typeval *argvars;
4308 typeval *retvar; 4528 typeval *rettv;
4309 { 4529 {
4310 #ifdef FEAT_CINDENT 4530 #ifdef FEAT_CINDENT
4311 pos_T pos; 4531 pos_T pos;
4312 linenr_T lnum; 4532 linenr_T lnum;
4313 4533
4314 pos = curwin->w_cursor; 4534 pos = curwin->w_cursor;
4315 lnum = get_vartv_lnum(argvars); 4535 lnum = get_tv_lnum(argvars);
4316 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 4536 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4317 { 4537 {
4318 curwin->w_cursor.lnum = lnum; 4538 curwin->w_cursor.lnum = lnum;
4319 retvar->vval.v_number = get_c_indent(); 4539 rettv->vval.v_number = get_c_indent();
4320 curwin->w_cursor = pos; 4540 curwin->w_cursor = pos;
4321 } 4541 }
4322 else 4542 else
4323 #endif 4543 #endif
4324 retvar->vval.v_number = -1; 4544 rettv->vval.v_number = -1;
4325 } 4545 }
4326 4546
4327 /* 4547 /*
4328 * "col(string)" function 4548 * "col(string)" function
4329 */ 4549 */
4330 static void 4550 static void
4331 f_col(argvars, retvar) 4551 f_col(argvars, rettv)
4332 typeval *argvars; 4552 typeval *argvars;
4333 typeval *retvar; 4553 typeval *rettv;
4334 { 4554 {
4335 colnr_T col = 0; 4555 colnr_T col = 0;
4336 pos_T *fp; 4556 pos_T *fp;
4337 4557
4338 fp = var2fpos(&argvars[0], FALSE); 4558 fp = var2fpos(&argvars[0], FALSE);
4371 } 4591 }
4372 } 4592 }
4373 #endif 4593 #endif
4374 } 4594 }
4375 } 4595 }
4376 retvar->vval.v_number = col; 4596 rettv->vval.v_number = col;
4377 } 4597 }
4378 4598
4379 /* 4599 /*
4380 * "confirm(message, buttons[, default [, type]])" function 4600 * "confirm(message, buttons[, default [, type]])" function
4381 */ 4601 */
4382 /*ARGSUSED*/ 4602 /*ARGSUSED*/
4383 static void 4603 static void
4384 f_confirm(argvars, retvar) 4604 f_confirm(argvars, rettv)
4385 typeval *argvars; 4605 typeval *argvars;
4386 typeval *retvar; 4606 typeval *rettv;
4387 { 4607 {
4388 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 4608 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
4389 char_u *message; 4609 char_u *message;
4390 char_u *buttons = NULL; 4610 char_u *buttons = NULL;
4391 char_u buf[NUMBUFLEN]; 4611 char_u buf[NUMBUFLEN];
4392 char_u buf2[NUMBUFLEN]; 4612 char_u buf2[NUMBUFLEN];
4393 int def = 1; 4613 int def = 1;
4394 int type = VIM_GENERIC; 4614 int type = VIM_GENERIC;
4395 int c; 4615 int c;
4396 4616
4397 message = get_vartv_string(&argvars[0]); 4617 message = get_tv_string(&argvars[0]);
4398 if (argvars[1].v_type != VAR_UNKNOWN) 4618 if (argvars[1].v_type != VAR_UNKNOWN)
4399 { 4619 {
4400 buttons = get_vartv_string_buf(&argvars[1], buf); 4620 buttons = get_tv_string_buf(&argvars[1], buf);
4401 if (argvars[2].v_type != VAR_UNKNOWN) 4621 if (argvars[2].v_type != VAR_UNKNOWN)
4402 { 4622 {
4403 def = get_vartv_number(&argvars[2]); 4623 def = get_tv_number(&argvars[2]);
4404 if (argvars[3].v_type != VAR_UNKNOWN) 4624 if (argvars[3].v_type != VAR_UNKNOWN)
4405 { 4625 {
4406 /* avoid that TOUPPER_ASC calls get_var_string_buf() twice */ 4626 /* avoid that TOUPPER_ASC calls get_var_string_buf() twice */
4407 c = *get_vartv_string_buf(&argvars[3], buf2); 4627 c = *get_tv_string_buf(&argvars[3], buf2);
4408 switch (TOUPPER_ASC(c)) 4628 switch (TOUPPER_ASC(c))
4409 { 4629 {
4410 case 'E': type = VIM_ERROR; break; 4630 case 'E': type = VIM_ERROR; break;
4411 case 'Q': type = VIM_QUESTION; break; 4631 case 'Q': type = VIM_QUESTION; break;
4412 case 'I': type = VIM_INFO; break; 4632 case 'I': type = VIM_INFO; break;
4418 } 4638 }
4419 4639
4420 if (buttons == NULL || *buttons == NUL) 4640 if (buttons == NULL || *buttons == NUL)
4421 buttons = (char_u *)_("&Ok"); 4641 buttons = (char_u *)_("&Ok");
4422 4642
4423 retvar->vval.v_number = do_dialog(type, NULL, message, buttons, 4643 rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
4424 def, NULL); 4644 def, NULL);
4425 #else 4645 #else
4426 retvar->vval.v_number = 0; 4646 rettv->vval.v_number = 0;
4427 #endif 4647 #endif
4428 } 4648 }
4429 4649
4430 /* 4650 /*
4431 * "copy()" function 4651 * "copy()" function
4432 */ 4652 */
4433 static void 4653 static void
4434 f_copy(argvars, retvar) 4654 f_copy(argvars, rettv)
4435 typeval *argvars; 4655 typeval *argvars;
4436 typeval *retvar; 4656 typeval *rettv;
4437 { 4657 {
4438 if (argvars[0].v_type == VAR_LIST) 4658 if (argvars[0].v_type == VAR_LIST)
4439 { 4659 {
4440 retvar->v_type = VAR_LIST; 4660 rettv->v_type = VAR_LIST;
4441 retvar->vval.v_list = list_copy(argvars[0].vval.v_list, FALSE); 4661 rettv->vval.v_list = list_copy(argvars[0].vval.v_list, FALSE);
4442 } 4662 }
4443 else 4663 else
4444 copy_vartv(&argvars[0], retvar); 4664 copy_tv(&argvars[0], rettv);
4445 } 4665 }
4446 4666
4447 /* 4667 /*
4448 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function 4668 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
4449 * 4669 *
4450 * Checks the existence of a cscope connection. 4670 * Checks the existence of a cscope connection.
4451 */ 4671 */
4452 /*ARGSUSED*/ 4672 /*ARGSUSED*/
4453 static void 4673 static void
4454 f_cscope_connection(argvars, retvar) 4674 f_cscope_connection(argvars, rettv)
4455 typeval *argvars; 4675 typeval *argvars;
4456 typeval *retvar; 4676 typeval *rettv;
4457 { 4677 {
4458 #ifdef FEAT_CSCOPE 4678 #ifdef FEAT_CSCOPE
4459 int num = 0; 4679 int num = 0;
4460 char_u *dbpath = NULL; 4680 char_u *dbpath = NULL;
4461 char_u *prepend = NULL; 4681 char_u *prepend = NULL;
4462 char_u buf[NUMBUFLEN]; 4682 char_u buf[NUMBUFLEN];
4463 4683
4464 if (argvars[0].v_type != VAR_UNKNOWN 4684 if (argvars[0].v_type != VAR_UNKNOWN
4465 && argvars[1].v_type != VAR_UNKNOWN) 4685 && argvars[1].v_type != VAR_UNKNOWN)
4466 { 4686 {
4467 num = (int)get_vartv_number(&argvars[0]); 4687 num = (int)get_tv_number(&argvars[0]);
4468 dbpath = get_vartv_string(&argvars[1]); 4688 dbpath = get_tv_string(&argvars[1]);
4469 if (argvars[2].v_type != VAR_UNKNOWN) 4689 if (argvars[2].v_type != VAR_UNKNOWN)
4470 prepend = get_vartv_string_buf(&argvars[2], buf); 4690 prepend = get_tv_string_buf(&argvars[2], buf);
4471 } 4691 }
4472 4692
4473 retvar->vval.v_number = cs_connection(num, dbpath, prepend); 4693 rettv->vval.v_number = cs_connection(num, dbpath, prepend);
4474 #else 4694 #else
4475 retvar->vval.v_number = 0; 4695 rettv->vval.v_number = 0;
4476 #endif 4696 #endif
4477 } 4697 }
4478 4698
4479 /* 4699 /*
4480 * "cursor(lnum, col)" function 4700 * "cursor(lnum, col)" function
4481 * 4701 *
4482 * Moves the cursor to the specified line and column 4702 * Moves the cursor to the specified line and column
4483 */ 4703 */
4484 /*ARGSUSED*/ 4704 /*ARGSUSED*/
4485 static void 4705 static void
4486 f_cursor(argvars, retvar) 4706 f_cursor(argvars, rettv)
4487 typeval *argvars; 4707 typeval *argvars;
4488 typeval *retvar; 4708 typeval *rettv;
4489 { 4709 {
4490 long line, col; 4710 long line, col;
4491 4711
4492 line = get_vartv_lnum(argvars); 4712 line = get_tv_lnum(argvars);
4493 if (line > 0) 4713 if (line > 0)
4494 curwin->w_cursor.lnum = line; 4714 curwin->w_cursor.lnum = line;
4495 col = get_vartv_number(&argvars[1]); 4715 col = get_tv_number(&argvars[1]);
4496 if (col > 0) 4716 if (col > 0)
4497 curwin->w_cursor.col = col - 1; 4717 curwin->w_cursor.col = col - 1;
4498 #ifdef FEAT_VIRTUALEDIT 4718 #ifdef FEAT_VIRTUALEDIT
4499 curwin->w_cursor.coladd = 0; 4719 curwin->w_cursor.coladd = 0;
4500 #endif 4720 #endif
4512 4732
4513 /* 4733 /*
4514 * "deepcopy()" function 4734 * "deepcopy()" function
4515 */ 4735 */
4516 static void 4736 static void
4517 f_deepcopy(argvars, retvar) 4737 f_deepcopy(argvars, rettv)
4518 typeval *argvars; 4738 typeval *argvars;
4519 typeval *retvar; 4739 typeval *rettv;
4520 { 4740 {
4521 if (argvars[0].v_type == VAR_LIST) 4741 if (argvars[0].v_type == VAR_LIST)
4522 { 4742 {
4523 retvar->v_type = VAR_LIST; 4743 rettv->v_type = VAR_LIST;
4524 retvar->vval.v_list = list_copy(argvars[0].vval.v_list, TRUE); 4744 rettv->vval.v_list = list_copy(argvars[0].vval.v_list, TRUE);
4525 } 4745 }
4526 else 4746 else
4527 copy_vartv(&argvars[0], retvar); 4747 copy_tv(&argvars[0], rettv);
4528 } 4748 }
4529 4749
4530 /* 4750 /*
4531 * "delete()" function 4751 * "delete()" function
4532 */ 4752 */
4533 static void 4753 static void
4534 f_delete(argvars, retvar) 4754 f_delete(argvars, rettv)
4535 typeval *argvars; 4755 typeval *argvars;
4536 typeval *retvar; 4756 typeval *rettv;
4537 { 4757 {
4538 if (check_restricted() || check_secure()) 4758 if (check_restricted() || check_secure())
4539 retvar->vval.v_number = -1; 4759 rettv->vval.v_number = -1;
4540 else 4760 else
4541 retvar->vval.v_number = mch_remove(get_vartv_string(&argvars[0])); 4761 rettv->vval.v_number = mch_remove(get_tv_string(&argvars[0]));
4542 } 4762 }
4543 4763
4544 /* 4764 /*
4545 * "did_filetype()" function 4765 * "did_filetype()" function
4546 */ 4766 */
4547 /*ARGSUSED*/ 4767 /*ARGSUSED*/
4548 static void 4768 static void
4549 f_did_filetype(argvars, retvar) 4769 f_did_filetype(argvars, rettv)
4550 typeval *argvars; 4770 typeval *argvars;
4551 typeval *retvar; 4771 typeval *rettv;
4552 { 4772 {
4553 #ifdef FEAT_AUTOCMD 4773 #ifdef FEAT_AUTOCMD
4554 retvar->vval.v_number = did_filetype; 4774 rettv->vval.v_number = did_filetype;
4555 #else 4775 #else
4556 retvar->vval.v_number = 0; 4776 rettv->vval.v_number = 0;
4557 #endif 4777 #endif
4558 } 4778 }
4559 4779
4560 /* 4780 /*
4561 * "diff_filler()" function 4781 * "diff_filler()" function
4562 */ 4782 */
4563 /*ARGSUSED*/ 4783 /*ARGSUSED*/
4564 static void 4784 static void
4565 f_diff_filler(argvars, retvar) 4785 f_diff_filler(argvars, rettv)
4566 typeval *argvars; 4786 typeval *argvars;
4567 typeval *retvar; 4787 typeval *rettv;
4568 { 4788 {
4569 #ifdef FEAT_DIFF 4789 #ifdef FEAT_DIFF
4570 retvar->vval.v_number = diff_check_fill(curwin, get_vartv_lnum(argvars)); 4790 rettv->vval.v_number = diff_check_fill(curwin, get_tv_lnum(argvars));
4571 #endif 4791 #endif
4572 } 4792 }
4573 4793
4574 /* 4794 /*
4575 * "diff_hlID()" function 4795 * "diff_hlID()" function
4576 */ 4796 */
4577 /*ARGSUSED*/ 4797 /*ARGSUSED*/
4578 static void 4798 static void
4579 f_diff_hlID(argvars, retvar) 4799 f_diff_hlID(argvars, rettv)
4580 typeval *argvars; 4800 typeval *argvars;
4581 typeval *retvar; 4801 typeval *rettv;
4582 { 4802 {
4583 #ifdef FEAT_DIFF 4803 #ifdef FEAT_DIFF
4584 linenr_T lnum = get_vartv_lnum(argvars); 4804 linenr_T lnum = get_tv_lnum(argvars);
4585 static linenr_T prev_lnum = 0; 4805 static linenr_T prev_lnum = 0;
4586 static int changedtick = 0; 4806 static int changedtick = 0;
4587 static int fnum = 0; 4807 static int fnum = 0;
4588 static int change_start = 0; 4808 static int change_start = 0;
4589 static int change_end = 0; 4809 static int change_end = 0;
4618 fnum = curbuf->b_fnum; 4838 fnum = curbuf->b_fnum;
4619 } 4839 }
4620 4840
4621 if (hlID == HLF_CHD || hlID == HLF_TXD) 4841 if (hlID == HLF_CHD || hlID == HLF_TXD)
4622 { 4842 {
4623 col = get_vartv_number(&argvars[1]) - 1; 4843 col = get_tv_number(&argvars[1]) - 1;
4624 if (col >= change_start && col <= change_end) 4844 if (col >= change_start && col <= change_end)
4625 hlID = HLF_TXD; /* changed text */ 4845 hlID = HLF_TXD; /* changed text */
4626 else 4846 else
4627 hlID = HLF_CHD; /* changed line */ 4847 hlID = HLF_CHD; /* changed line */
4628 } 4848 }
4629 retvar->vval.v_number = hlID == (enum hlf_value)0 ? 0 : (int)hlID; 4849 rettv->vval.v_number = hlID == (enum hlf_value)0 ? 0 : (int)hlID;
4630 #endif 4850 #endif
4631 } 4851 }
4632 4852
4633 /* 4853 /*
4634 * "escape({string}, {chars})" function 4854 * "escape({string}, {chars})" function
4635 */ 4855 */
4636 static void 4856 static void
4637 f_escape(argvars, retvar) 4857 f_escape(argvars, rettv)
4638 typeval *argvars; 4858 typeval *argvars;
4639 typeval *retvar; 4859 typeval *rettv;
4640 { 4860 {
4641 char_u buf[NUMBUFLEN]; 4861 char_u buf[NUMBUFLEN];
4642 4862
4643 retvar->vval.v_string = 4863 rettv->vval.v_string =
4644 vim_strsave_escaped(get_vartv_string(&argvars[0]), 4864 vim_strsave_escaped(get_tv_string(&argvars[0]),
4645 get_vartv_string_buf(&argvars[1], buf)); 4865 get_tv_string_buf(&argvars[1], buf));
4646 retvar->v_type = VAR_STRING; 4866 rettv->v_type = VAR_STRING;
4647 } 4867 }
4648 4868
4649 /* 4869 /*
4650 * "eventhandler()" function 4870 * "eventhandler()" function
4651 */ 4871 */
4652 /*ARGSUSED*/ 4872 /*ARGSUSED*/
4653 static void 4873 static void
4654 f_eventhandler(argvars, retvar) 4874 f_eventhandler(argvars, rettv)
4655 typeval *argvars; 4875 typeval *argvars;
4656 typeval *retvar; 4876 typeval *rettv;
4657 { 4877 {
4658 retvar->vval.v_number = vgetc_busy; 4878 rettv->vval.v_number = vgetc_busy;
4659 } 4879 }
4660 4880
4661 /* 4881 /*
4662 * "executable()" function 4882 * "executable()" function
4663 */ 4883 */
4664 static void 4884 static void
4665 f_executable(argvars, retvar) 4885 f_executable(argvars, rettv)
4666 typeval *argvars; 4886 typeval *argvars;
4667 typeval *retvar; 4887 typeval *rettv;
4668 { 4888 {
4669 retvar->vval.v_number = mch_can_exe(get_vartv_string(&argvars[0])); 4889 rettv->vval.v_number = mch_can_exe(get_tv_string(&argvars[0]));
4670 } 4890 }
4671 4891
4672 /* 4892 /*
4673 * "exists()" function 4893 * "exists()" function
4674 */ 4894 */
4675 static void 4895 static void
4676 f_exists(argvars, retvar) 4896 f_exists(argvars, rettv)
4677 typeval *argvars; 4897 typeval *argvars;
4678 typeval *retvar; 4898 typeval *rettv;
4679 { 4899 {
4680 char_u *p; 4900 char_u *p;
4681 char_u *name; 4901 char_u *name;
4682 int n = FALSE; 4902 int n = FALSE;
4683 int len = 0; 4903 int len = 0;
4684 4904
4685 p = get_vartv_string(&argvars[0]); 4905 p = get_tv_string(&argvars[0]);
4686 if (*p == '$') /* environment variable */ 4906 if (*p == '$') /* environment variable */
4687 { 4907 {
4688 /* first try "normal" environment variables (fast) */ 4908 /* first try "normal" environment variables (fast) */
4689 if (mch_getenv(p + 1) != NULL) 4909 if (mch_getenv(p + 1) != NULL)
4690 n = TRUE; 4910 n = TRUE;
4696 n = TRUE; 4916 n = TRUE;
4697 vim_free(p); 4917 vim_free(p);
4698 } 4918 }
4699 } 4919 }
4700 else if (*p == '&' || *p == '+') /* option */ 4920 else if (*p == '&' || *p == '+') /* option */
4701 n = (get_option_vartv(&p, NULL, TRUE) == OK); 4921 n = (get_option_tv(&p, NULL, TRUE) == OK);
4702 else if (*p == '*') /* internal or user defined function */ 4922 else if (*p == '*') /* internal or user defined function */
4703 { 4923 {
4704 n = function_exists(p + 1); 4924 n = function_exists(p + 1);
4705 } 4925 }
4706 else if (*p == ':') 4926 else if (*p == ':')
4718 n = au_exists(name, name + STRLEN(name), NULL); 4938 n = au_exists(name, name + STRLEN(name), NULL);
4719 #endif 4939 #endif
4720 } 4940 }
4721 else /* internal variable */ 4941 else /* internal variable */
4722 { 4942 {
4723 #ifdef FEAT_MAGIC_BRACES
4724 char_u *expr_start; 4943 char_u *expr_start;
4725 char_u *expr_end; 4944 char_u *expr_end;
4726 char_u *temp_string = NULL; 4945 char_u *temp_string = NULL;
4727 char_u *s; 4946 char_u *s;
4728 #endif
4729 name = p; 4947 name = p;
4730 4948
4731 #ifdef FEAT_MAGIC_BRACES
4732 /* Find the end of the name. */ 4949 /* Find the end of the name. */
4733 s = find_name_end(name, &expr_start, &expr_end); 4950 s = find_name_end(name, &expr_start, &expr_end, FALSE);
4734 if (expr_start != NULL) 4951 if (expr_start != NULL)
4735 { 4952 {
4736 temp_string = make_expanded_name(name, expr_start, expr_end, s); 4953 temp_string = make_expanded_name(name, expr_start, expr_end, s);
4737 if (temp_string != NULL) 4954 if (temp_string != NULL)
4738 { 4955 {
4739 len = STRLEN(temp_string); 4956 len = STRLEN(temp_string);
4740 name = temp_string; 4957 name = temp_string;
4741 } 4958 }
4742 } 4959 }
4743 #endif
4744 if (len == 0) 4960 if (len == 0)
4745 len = get_id_len(&p); 4961 len = get_id_len(&p);
4746 if (len != 0) 4962 if (len != 0)
4747 n = (get_var_vartv(name, len, NULL) == OK); 4963 n = (get_var_tv(name, len, NULL) == OK);
4748 4964
4749 #ifdef FEAT_MAGIC_BRACES
4750 vim_free(temp_string); 4965 vim_free(temp_string);
4751 #endif 4966 }
4752 } 4967
4753 4968 rettv->vval.v_number = n;
4754 retvar->vval.v_number = n;
4755 } 4969 }
4756 4970
4757 /* 4971 /*
4758 * "expand()" function 4972 * "expand()" function
4759 */ 4973 */
4760 static void 4974 static void
4761 f_expand(argvars, retvar) 4975 f_expand(argvars, rettv)
4762 typeval *argvars; 4976 typeval *argvars;
4763 typeval *retvar; 4977 typeval *rettv;
4764 { 4978 {
4765 char_u *s; 4979 char_u *s;
4766 int len; 4980 int len;
4767 char_u *errormsg; 4981 char_u *errormsg;
4768 int flags = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND; 4982 int flags = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
4769 expand_T xpc; 4983 expand_T xpc;
4770 4984
4771 retvar->v_type = VAR_STRING; 4985 rettv->v_type = VAR_STRING;
4772 s = get_vartv_string(&argvars[0]); 4986 s = get_tv_string(&argvars[0]);
4773 if (*s == '%' || *s == '#' || *s == '<') 4987 if (*s == '%' || *s == '#' || *s == '<')
4774 { 4988 {
4775 ++emsg_off; 4989 ++emsg_off;
4776 retvar->vval.v_string = eval_vars(s, &len, NULL, &errormsg, s); 4990 rettv->vval.v_string = eval_vars(s, &len, NULL, &errormsg, s);
4777 --emsg_off; 4991 --emsg_off;
4778 } 4992 }
4779 else 4993 else
4780 { 4994 {
4781 /* When the optional second argument is non-zero, don't remove matches 4995 /* When the optional second argument is non-zero, don't remove matches
4782 * for 'suffixes' and 'wildignore' */ 4996 * for 'suffixes' and 'wildignore' */
4783 if (argvars[1].v_type != VAR_UNKNOWN && get_vartv_number(&argvars[1])) 4997 if (argvars[1].v_type != VAR_UNKNOWN && get_tv_number(&argvars[1]))
4784 flags |= WILD_KEEP_ALL; 4998 flags |= WILD_KEEP_ALL;
4785 ExpandInit(&xpc); 4999 ExpandInit(&xpc);
4786 xpc.xp_context = EXPAND_FILES; 5000 xpc.xp_context = EXPAND_FILES;
4787 retvar->vval.v_string = ExpandOne(&xpc, s, NULL, flags, WILD_ALL); 5001 rettv->vval.v_string = ExpandOne(&xpc, s, NULL, flags, WILD_ALL);
4788 ExpandCleanup(&xpc); 5002 ExpandCleanup(&xpc);
4789 } 5003 }
4790 } 5004 }
4791 5005
4792 /* 5006 /*
4793 * "filereadable()" function 5007 * "filereadable()" function
4794 */ 5008 */
4795 static void 5009 static void
4796 f_filereadable(argvars, retvar) 5010 f_filereadable(argvars, rettv)
4797 typeval *argvars; 5011 typeval *argvars;
4798 typeval *retvar; 5012 typeval *rettv;
4799 { 5013 {
4800 FILE *fd; 5014 FILE *fd;
4801 char_u *p; 5015 char_u *p;
4802 int n; 5016 int n;
4803 5017
4804 p = get_vartv_string(&argvars[0]); 5018 p = get_tv_string(&argvars[0]);
4805 if (*p && !mch_isdir(p) && (fd = mch_fopen((char *)p, "r")) != NULL) 5019 if (*p && !mch_isdir(p) && (fd = mch_fopen((char *)p, "r")) != NULL)
4806 { 5020 {
4807 n = TRUE; 5021 n = TRUE;
4808 fclose(fd); 5022 fclose(fd);
4809 } 5023 }
4810 else 5024 else
4811 n = FALSE; 5025 n = FALSE;
4812 5026
4813 retvar->vval.v_number = n; 5027 rettv->vval.v_number = n;
4814 } 5028 }
4815 5029
4816 /* 5030 /*
4817 * return 0 for not writable, 1 for writable file, 2 for a dir which we have 5031 * return 0 for not writable, 1 for writable file, 2 for a dir which we have
4818 * rights to write into. 5032 * rights to write into.
4819 */ 5033 */
4820 static void 5034 static void
4821 f_filewritable(argvars, retvar) 5035 f_filewritable(argvars, rettv)
4822 typeval *argvars; 5036 typeval *argvars;
4823 typeval *retvar; 5037 typeval *rettv;
4824 { 5038 {
4825 char_u *p; 5039 char_u *p;
4826 int retval = 0; 5040 int retval = 0;
4827 #if defined(UNIX) || defined(VMS) 5041 #if defined(UNIX) || defined(VMS)
4828 int perm = 0; 5042 int perm = 0;
4829 #endif 5043 #endif
4830 5044
4831 p = get_vartv_string(&argvars[0]); 5045 p = get_tv_string(&argvars[0]);
4832 #if defined(UNIX) || defined(VMS) 5046 #if defined(UNIX) || defined(VMS)
4833 perm = mch_getperm(p); 5047 perm = mch_getperm(p);
4834 #endif 5048 #endif
4835 #ifndef MACOS_CLASSIC /* TODO: get either mch_writable or mch_access */ 5049 #ifndef MACOS_CLASSIC /* TODO: get either mch_writable or mch_access */
4836 if ( 5050 if (
4847 { 5061 {
4848 ++retval; 5062 ++retval;
4849 if (mch_isdir(p)) 5063 if (mch_isdir(p))
4850 ++retval; 5064 ++retval;
4851 } 5065 }
4852 retvar->vval.v_number = retval; 5066 rettv->vval.v_number = retval;
4853 } 5067 }
4854 5068
4855 /* 5069 /*
4856 * "finddir({fname}[, {path}[, {count}]])" function 5070 * "finddir({fname}[, {path}[, {count}]])" function
4857 */ 5071 */
4858 static void 5072 static void
4859 f_finddir(argvars, retvar) 5073 f_finddir(argvars, rettv)
4860 typeval *argvars; 5074 typeval *argvars;
4861 typeval *retvar; 5075 typeval *rettv;
4862 { 5076 {
4863 f_findfilendir(argvars, retvar, TRUE); 5077 f_findfilendir(argvars, rettv, TRUE);
4864 } 5078 }
4865 5079
4866 /* 5080 /*
4867 * "findfile({fname}[, {path}[, {count}]])" function 5081 * "findfile({fname}[, {path}[, {count}]])" function
4868 */ 5082 */
4869 static void 5083 static void
4870 f_findfile(argvars, retvar) 5084 f_findfile(argvars, rettv)
4871 typeval *argvars; 5085 typeval *argvars;
4872 typeval *retvar; 5086 typeval *rettv;
4873 { 5087 {
4874 f_findfilendir(argvars, retvar, FALSE); 5088 f_findfilendir(argvars, rettv, FALSE);
4875 } 5089 }
4876 5090
4877 static void 5091 static void
4878 f_findfilendir(argvars, retvar, dir) 5092 f_findfilendir(argvars, rettv, dir)
4879 typeval *argvars; 5093 typeval *argvars;
4880 typeval *retvar; 5094 typeval *rettv;
4881 int dir; 5095 int dir;
4882 { 5096 {
4883 #ifdef FEAT_SEARCHPATH 5097 #ifdef FEAT_SEARCHPATH
4884 char_u *fname; 5098 char_u *fname;
4885 char_u *fresult = NULL; 5099 char_u *fresult = NULL;
4887 char_u *p; 5101 char_u *p;
4888 char_u pathbuf[NUMBUFLEN]; 5102 char_u pathbuf[NUMBUFLEN];
4889 int count = 1; 5103 int count = 1;
4890 int first = TRUE; 5104 int first = TRUE;
4891 5105
4892 fname = get_vartv_string(&argvars[0]); 5106 fname = get_tv_string(&argvars[0]);
4893 5107
4894 if (argvars[1].v_type != VAR_UNKNOWN) 5108 if (argvars[1].v_type != VAR_UNKNOWN)
4895 { 5109 {
4896 p = get_vartv_string_buf(&argvars[1], pathbuf); 5110 p = get_tv_string_buf(&argvars[1], pathbuf);
4897 if (*p != NUL) 5111 if (*p != NUL)
4898 path = p; 5112 path = p;
4899 5113
4900 if (argvars[2].v_type != VAR_UNKNOWN) 5114 if (argvars[2].v_type != VAR_UNKNOWN)
4901 count = get_vartv_number(&argvars[2]); 5115 count = get_tv_number(&argvars[2]);
4902 } 5116 }
4903 5117
4904 do 5118 do
4905 { 5119 {
4906 vim_free(fresult); 5120 vim_free(fresult);
4908 first ? (int)STRLEN(fname) : 0, 5122 first ? (int)STRLEN(fname) : 0,
4909 0, first, path, dir, NULL); 5123 0, first, path, dir, NULL);
4910 first = FALSE; 5124 first = FALSE;
4911 } while (--count > 0 && fresult != NULL); 5125 } while (--count > 0 && fresult != NULL);
4912 5126
4913 retvar->vval.v_string = fresult; 5127 rettv->vval.v_string = fresult;
4914 #else 5128 #else
4915 retvar->vval.v_string = NULL; 5129 rettv->vval.v_string = NULL;
4916 #endif 5130 #endif
4917 retvar->v_type = VAR_STRING; 5131 rettv->v_type = VAR_STRING;
4918 } 5132 }
4919 5133
4920 /* 5134 /*
4921 * "fnamemodify({fname}, {mods})" function 5135 * "fnamemodify({fname}, {mods})" function
4922 */ 5136 */
4923 static void 5137 static void
4924 f_fnamemodify(argvars, retvar) 5138 f_fnamemodify(argvars, rettv)
4925 typeval *argvars; 5139 typeval *argvars;
4926 typeval *retvar; 5140 typeval *rettv;
4927 { 5141 {
4928 char_u *fname; 5142 char_u *fname;
4929 char_u *mods; 5143 char_u *mods;
4930 int usedlen = 0; 5144 int usedlen = 0;
4931 int len; 5145 int len;
4932 char_u *fbuf = NULL; 5146 char_u *fbuf = NULL;
4933 char_u buf[NUMBUFLEN]; 5147 char_u buf[NUMBUFLEN];
4934 5148
4935 fname = get_vartv_string(&argvars[0]); 5149 fname = get_tv_string(&argvars[0]);
4936 mods = get_vartv_string_buf(&argvars[1], buf); 5150 mods = get_tv_string_buf(&argvars[1], buf);
4937 len = (int)STRLEN(fname); 5151 len = (int)STRLEN(fname);
4938 5152
4939 (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len); 5153 (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len);
4940 5154
4941 retvar->v_type = VAR_STRING; 5155 rettv->v_type = VAR_STRING;
4942 if (fname == NULL) 5156 if (fname == NULL)
4943 retvar->vval.v_string = NULL; 5157 rettv->vval.v_string = NULL;
4944 else 5158 else
4945 retvar->vval.v_string = vim_strnsave(fname, len); 5159 rettv->vval.v_string = vim_strnsave(fname, len);
4946 vim_free(fbuf); 5160 vim_free(fbuf);
4947 } 5161 }
4948 5162
4949 /* 5163 /*
4950 * "foldclosed()" function 5164 * "foldclosed()" function
4951 */ 5165 */
4952 static void 5166 static void
4953 f_foldclosed(argvars, retvar) 5167 f_foldclosed(argvars, rettv)
4954 typeval *argvars; 5168 typeval *argvars;
4955 typeval *retvar; 5169 typeval *rettv;
4956 { 5170 {
4957 foldclosed_both(argvars, retvar, FALSE); 5171 foldclosed_both(argvars, rettv, FALSE);
4958 } 5172 }
4959 5173
4960 /* 5174 /*
4961 * "foldclosedend()" function 5175 * "foldclosedend()" function
4962 */ 5176 */
4963 static void 5177 static void
4964 f_foldclosedend(argvars, retvar) 5178 f_foldclosedend(argvars, rettv)
4965 typeval *argvars; 5179 typeval *argvars;
4966 typeval *retvar; 5180 typeval *rettv;
4967 { 5181 {
4968 foldclosed_both(argvars, retvar, TRUE); 5182 foldclosed_both(argvars, rettv, TRUE);
4969 } 5183 }
4970 5184
4971 /* 5185 /*
4972 * "foldclosed()" function 5186 * "foldclosed()" function
4973 */ 5187 */
4974 static void 5188 static void
4975 foldclosed_both(argvars, retvar, end) 5189 foldclosed_both(argvars, rettv, end)
4976 typeval *argvars; 5190 typeval *argvars;
4977 typeval *retvar; 5191 typeval *rettv;
4978 int end; 5192 int end;
4979 { 5193 {
4980 #ifdef FEAT_FOLDING 5194 #ifdef FEAT_FOLDING
4981 linenr_T lnum; 5195 linenr_T lnum;
4982 linenr_T first, last; 5196 linenr_T first, last;
4983 5197
4984 lnum = get_vartv_lnum(argvars); 5198 lnum = get_tv_lnum(argvars);
4985 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 5199 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
4986 { 5200 {
4987 if (hasFoldingWin(curwin, lnum, &first, &last, FALSE, NULL)) 5201 if (hasFoldingWin(curwin, lnum, &first, &last, FALSE, NULL))
4988 { 5202 {
4989 if (end) 5203 if (end)
4990 retvar->vval.v_number = (varnumber_T)last; 5204 rettv->vval.v_number = (varnumber_T)last;
4991 else 5205 else
4992 retvar->vval.v_number = (varnumber_T)first; 5206 rettv->vval.v_number = (varnumber_T)first;
4993 return; 5207 return;
4994 } 5208 }
4995 } 5209 }
4996 #endif 5210 #endif
4997 retvar->vval.v_number = -1; 5211 rettv->vval.v_number = -1;
4998 } 5212 }
4999 5213
5000 /* 5214 /*
5001 * "foldlevel()" function 5215 * "foldlevel()" function
5002 */ 5216 */
5003 static void 5217 static void
5004 f_foldlevel(argvars, retvar) 5218 f_foldlevel(argvars, rettv)
5005 typeval *argvars; 5219 typeval *argvars;
5006 typeval *retvar; 5220 typeval *rettv;
5007 { 5221 {
5008 #ifdef FEAT_FOLDING 5222 #ifdef FEAT_FOLDING
5009 linenr_T lnum; 5223 linenr_T lnum;
5010 5224
5011 lnum = get_vartv_lnum(argvars); 5225 lnum = get_tv_lnum(argvars);
5012 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 5226 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
5013 retvar->vval.v_number = foldLevel(lnum); 5227 rettv->vval.v_number = foldLevel(lnum);
5014 else 5228 else
5015 #endif 5229 #endif
5016 retvar->vval.v_number = 0; 5230 rettv->vval.v_number = 0;
5017 } 5231 }
5018 5232
5019 /* 5233 /*
5020 * "foldtext()" function 5234 * "foldtext()" function
5021 */ 5235 */
5022 /*ARGSUSED*/ 5236 /*ARGSUSED*/
5023 static void 5237 static void
5024 f_foldtext(argvars, retvar) 5238 f_foldtext(argvars, rettv)
5025 typeval *argvars; 5239 typeval *argvars;
5026 typeval *retvar; 5240 typeval *rettv;
5027 { 5241 {
5028 #ifdef FEAT_FOLDING 5242 #ifdef FEAT_FOLDING
5029 linenr_T lnum; 5243 linenr_T lnum;
5030 char_u *s; 5244 char_u *s;
5031 char_u *r; 5245 char_u *r;
5032 int len; 5246 int len;
5033 char *txt; 5247 char *txt;
5034 #endif 5248 #endif
5035 5249
5036 retvar->v_type = VAR_STRING; 5250 rettv->v_type = VAR_STRING;
5037 retvar->vval.v_string = NULL; 5251 rettv->vval.v_string = NULL;
5038 #ifdef FEAT_FOLDING 5252 #ifdef FEAT_FOLDING
5039 if ((linenr_T)vimvars[VV_FOLDSTART].val > 0 5253 if ((linenr_T)vimvars[VV_FOLDSTART].val > 0
5040 && (linenr_T)vimvars[VV_FOLDEND].val <= curbuf->b_ml.ml_line_count 5254 && (linenr_T)vimvars[VV_FOLDEND].val <= curbuf->b_ml.ml_line_count
5041 && vimvars[VV_FOLDDASHES].val != NULL) 5255 && vimvars[VV_FOLDDASHES].val != NULL)
5042 { 5256 {
5075 - (linenr_T)vimvars[VV_FOLDSTART].val + 1)); 5289 - (linenr_T)vimvars[VV_FOLDSTART].val + 1));
5076 len = (int)STRLEN(r); 5290 len = (int)STRLEN(r);
5077 STRCAT(r, s); 5291 STRCAT(r, s);
5078 /* remove 'foldmarker' and 'commentstring' */ 5292 /* remove 'foldmarker' and 'commentstring' */
5079 foldtext_cleanup(r + len); 5293 foldtext_cleanup(r + len);
5080 retvar->vval.v_string = r; 5294 rettv->vval.v_string = r;
5081 } 5295 }
5082 } 5296 }
5083 #endif 5297 #endif
5084 } 5298 }
5085 5299
5086 /* 5300 /*
5087 * "foldtextresult(lnum)" function 5301 * "foldtextresult(lnum)" function
5088 */ 5302 */
5089 /*ARGSUSED*/ 5303 /*ARGSUSED*/
5090 static void 5304 static void
5091 f_foldtextresult(argvars, retvar) 5305 f_foldtextresult(argvars, rettv)
5092 typeval *argvars; 5306 typeval *argvars;
5093 typeval *retvar; 5307 typeval *rettv;
5094 { 5308 {
5095 #ifdef FEAT_FOLDING 5309 #ifdef FEAT_FOLDING
5096 linenr_T lnum; 5310 linenr_T lnum;
5097 char_u *text; 5311 char_u *text;
5098 char_u buf[51]; 5312 char_u buf[51];
5099 foldinfo_T foldinfo; 5313 foldinfo_T foldinfo;
5100 int fold_count; 5314 int fold_count;
5101 #endif 5315 #endif
5102 5316
5103 retvar->v_type = VAR_STRING; 5317 rettv->v_type = VAR_STRING;
5104 retvar->vval.v_string = NULL; 5318 rettv->vval.v_string = NULL;
5105 #ifdef FEAT_FOLDING 5319 #ifdef FEAT_FOLDING
5106 lnum = get_vartv_lnum(argvars); 5320 lnum = get_tv_lnum(argvars);
5107 fold_count = foldedCount(curwin, lnum, &foldinfo); 5321 fold_count = foldedCount(curwin, lnum, &foldinfo);
5108 if (fold_count > 0) 5322 if (fold_count > 0)
5109 { 5323 {
5110 text = get_foldtext(curwin, lnum, lnum + fold_count - 1, 5324 text = get_foldtext(curwin, lnum, lnum + fold_count - 1,
5111 &foldinfo, buf); 5325 &foldinfo, buf);
5112 if (text == buf) 5326 if (text == buf)
5113 text = vim_strsave(text); 5327 text = vim_strsave(text);
5114 retvar->vval.v_string = text; 5328 rettv->vval.v_string = text;
5115 } 5329 }
5116 #endif 5330 #endif
5117 } 5331 }
5118 5332
5119 /* 5333 /*
5120 * "foreground()" function 5334 * "foreground()" function
5121 */ 5335 */
5122 /*ARGSUSED*/ 5336 /*ARGSUSED*/
5123 static void 5337 static void
5124 f_foreground(argvars, retvar) 5338 f_foreground(argvars, rettv)
5125 typeval *argvars; 5339 typeval *argvars;
5126 typeval *retvar; 5340 typeval *rettv;
5127 { 5341 {
5128 retvar->vval.v_number = 0; 5342 rettv->vval.v_number = 0;
5129 #ifdef FEAT_GUI 5343 #ifdef FEAT_GUI
5130 if (gui.in_use) 5344 if (gui.in_use)
5131 gui_mch_set_foreground(); 5345 gui_mch_set_foreground();
5132 #else 5346 #else
5133 # ifdef WIN32 5347 # ifdef WIN32
5139 /* 5353 /*
5140 * "function()" function 5354 * "function()" function
5141 */ 5355 */
5142 /*ARGSUSED*/ 5356 /*ARGSUSED*/
5143 static void 5357 static void
5144 f_function(argvars, retvar) 5358 f_function(argvars, rettv)
5145 typeval *argvars; 5359 typeval *argvars;
5146 typeval *retvar; 5360 typeval *rettv;
5147 { 5361 {
5148 char_u *s; 5362 char_u *s;
5149 5363
5150 s = get_vartv_string(&argvars[0]); 5364 s = get_tv_string(&argvars[0]);
5151 if (s == NULL || *s == NUL || isdigit(*s)) 5365 if (s == NULL || *s == NUL || isdigit(*s))
5152 EMSG2(_(e_invarg2), s); 5366 EMSG2(_(e_invarg2), s);
5153 else if (!function_exists(s)) 5367 else if (!function_exists(s))
5154 EMSG2(_("E999: Unknown function: %s"), s); 5368 EMSG2(_("E999: Unknown function: %s"), s);
5155 else 5369 else
5156 { 5370 {
5157 retvar->vval.v_string = vim_strsave(s); 5371 rettv->vval.v_string = vim_strsave(s);
5158 retvar->v_type = VAR_FUNC; 5372 rettv->v_type = VAR_FUNC;
5159 } 5373 }
5160 } 5374 }
5161 5375
5162 /* 5376 /*
5163 * "getchar()" function 5377 * "getchar()" function
5164 */ 5378 */
5165 static void 5379 static void
5166 f_getchar(argvars, retvar) 5380 f_getchar(argvars, rettv)
5167 typeval *argvars; 5381 typeval *argvars;
5168 typeval *retvar; 5382 typeval *rettv;
5169 { 5383 {
5170 varnumber_T n; 5384 varnumber_T n;
5171 5385
5172 ++no_mapping; 5386 ++no_mapping;
5173 ++allow_keys; 5387 ++allow_keys;
5174 if (argvars[0].v_type == VAR_UNKNOWN) 5388 if (argvars[0].v_type == VAR_UNKNOWN)
5175 /* getchar(): blocking wait. */ 5389 /* getchar(): blocking wait. */
5176 n = safe_vgetc(); 5390 n = safe_vgetc();
5177 else if (get_vartv_number(&argvars[0]) == 1) 5391 else if (get_tv_number(&argvars[0]) == 1)
5178 /* getchar(1): only check if char avail */ 5392 /* getchar(1): only check if char avail */
5179 n = vpeekc(); 5393 n = vpeekc();
5180 else if (vpeekc() == NUL) 5394 else if (vpeekc() == NUL)
5181 /* getchar(0) and no char avail: return zero */ 5395 /* getchar(0) and no char avail: return zero */
5182 n = 0; 5396 n = 0;
5184 /* getchar(0) and char avail: return char */ 5398 /* getchar(0) and char avail: return char */
5185 n = safe_vgetc(); 5399 n = safe_vgetc();
5186 --no_mapping; 5400 --no_mapping;
5187 --allow_keys; 5401 --allow_keys;
5188 5402
5189 retvar->vval.v_number = n; 5403 rettv->vval.v_number = n;
5190 if (IS_SPECIAL(n) || mod_mask != 0) 5404 if (IS_SPECIAL(n) || mod_mask != 0)
5191 { 5405 {
5192 char_u temp[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */ 5406 char_u temp[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */
5193 int i = 0; 5407 int i = 0;
5194 5408
5210 i += (*mb_char2bytes)(n, temp + i); 5424 i += (*mb_char2bytes)(n, temp + i);
5211 #endif 5425 #endif
5212 else 5426 else
5213 temp[i++] = n; 5427 temp[i++] = n;
5214 temp[i++] = NUL; 5428 temp[i++] = NUL;
5215 retvar->v_type = VAR_STRING; 5429 rettv->v_type = VAR_STRING;
5216 retvar->vval.v_string = vim_strsave(temp); 5430 rettv->vval.v_string = vim_strsave(temp);
5217 } 5431 }
5218 } 5432 }
5219 5433
5220 /* 5434 /*
5221 * "getcharmod()" function 5435 * "getcharmod()" function
5222 */ 5436 */
5223 /*ARGSUSED*/ 5437 /*ARGSUSED*/
5224 static void 5438 static void
5225 f_getcharmod(argvars, retvar) 5439 f_getcharmod(argvars, rettv)
5226 typeval *argvars; 5440 typeval *argvars;
5227 typeval *retvar; 5441 typeval *rettv;
5228 { 5442 {
5229 retvar->vval.v_number = mod_mask; 5443 rettv->vval.v_number = mod_mask;
5230 } 5444 }
5231 5445
5232 /* 5446 /*
5233 * "getcmdline()" function 5447 * "getcmdline()" function
5234 */ 5448 */
5235 /*ARGSUSED*/ 5449 /*ARGSUSED*/
5236 static void 5450 static void
5237 f_getcmdline(argvars, retvar) 5451 f_getcmdline(argvars, rettv)
5238 typeval *argvars; 5452 typeval *argvars;
5239 typeval *retvar; 5453 typeval *rettv;
5240 { 5454 {
5241 retvar->v_type = VAR_STRING; 5455 rettv->v_type = VAR_STRING;
5242 retvar->vval.v_string = get_cmdline_str(); 5456 rettv->vval.v_string = get_cmdline_str();
5243 } 5457 }
5244 5458
5245 /* 5459 /*
5246 * "getcmdpos()" function 5460 * "getcmdpos()" function
5247 */ 5461 */
5248 /*ARGSUSED*/ 5462 /*ARGSUSED*/
5249 static void 5463 static void
5250 f_getcmdpos(argvars, retvar) 5464 f_getcmdpos(argvars, rettv)
5251 typeval *argvars; 5465 typeval *argvars;
5252 typeval *retvar; 5466 typeval *rettv;
5253 { 5467 {
5254 retvar->vval.v_number = get_cmdline_pos() + 1; 5468 rettv->vval.v_number = get_cmdline_pos() + 1;
5255 } 5469 }
5256 5470
5257 /* 5471 /*
5258 * "getbufvar()" function 5472 * "getbufvar()" function
5259 */ 5473 */
5260 static void 5474 static void
5261 f_getbufvar(argvars, retvar) 5475 f_getbufvar(argvars, rettv)
5262 typeval *argvars; 5476 typeval *argvars;
5263 typeval *retvar; 5477 typeval *rettv;
5264 { 5478 {
5265 buf_T *buf; 5479 buf_T *buf;
5266 buf_T *save_curbuf; 5480 buf_T *save_curbuf;
5267 char_u *varname; 5481 char_u *varname;
5268 VAR v; 5482 VAR v;
5269 5483
5270 ++emsg_off; 5484 ++emsg_off;
5271 buf = get_buf_vartv(&argvars[0]); 5485 buf = get_buf_tv(&argvars[0]);
5272 varname = get_vartv_string(&argvars[1]); 5486 varname = get_tv_string(&argvars[1]);
5273 5487
5274 retvar->v_type = VAR_STRING; 5488 rettv->v_type = VAR_STRING;
5275 retvar->vval.v_string = NULL; 5489 rettv->vval.v_string = NULL;
5276 5490
5277 if (buf != NULL && varname != NULL) 5491 if (buf != NULL && varname != NULL)
5278 { 5492 {
5279 if (*varname == '&') /* buffer-local-option */ 5493 if (*varname == '&') /* buffer-local-option */
5280 { 5494 {
5281 /* set curbuf to be our buf, temporarily */ 5495 /* set curbuf to be our buf, temporarily */
5282 save_curbuf = curbuf; 5496 save_curbuf = curbuf;
5283 curbuf = buf; 5497 curbuf = buf;
5284 5498
5285 get_option_vartv(&varname, retvar, TRUE); 5499 get_option_tv(&varname, rettv, TRUE);
5286 5500
5287 /* restore previous notion of curbuf */ 5501 /* restore previous notion of curbuf */
5288 curbuf = save_curbuf; 5502 curbuf = save_curbuf;
5289 } 5503 }
5290 else 5504 else
5291 { 5505 {
5292 /* look up the variable */ 5506 /* look up the variable */
5293 v = find_var_in_ga(&buf->b_vars, varname); 5507 v = find_var_in_ga(&buf->b_vars, varname);
5294 if (v != NULL) 5508 if (v != NULL)
5295 copy_vartv(&v->tv, retvar); 5509 copy_tv(&v->tv, rettv);
5296 } 5510 }
5297 } 5511 }
5298 5512
5299 --emsg_off; 5513 --emsg_off;
5300 } 5514 }
5302 /* 5516 /*
5303 * "getcwd()" function 5517 * "getcwd()" function
5304 */ 5518 */
5305 /*ARGSUSED*/ 5519 /*ARGSUSED*/
5306 static void 5520 static void
5307 f_getcwd(argvars, retvar) 5521 f_getcwd(argvars, rettv)
5308 typeval *argvars; 5522 typeval *argvars;
5309 typeval *retvar; 5523 typeval *rettv;
5310 { 5524 {
5311 char_u cwd[MAXPATHL]; 5525 char_u cwd[MAXPATHL];
5312 5526
5313 retvar->v_type = VAR_STRING; 5527 rettv->v_type = VAR_STRING;
5314 if (mch_dirname(cwd, MAXPATHL) == FAIL) 5528 if (mch_dirname(cwd, MAXPATHL) == FAIL)
5315 retvar->vval.v_string = NULL; 5529 rettv->vval.v_string = NULL;
5316 else 5530 else
5317 { 5531 {
5318 retvar->vval.v_string = vim_strsave(cwd); 5532 rettv->vval.v_string = vim_strsave(cwd);
5319 #ifdef BACKSLASH_IN_FILENAME 5533 #ifdef BACKSLASH_IN_FILENAME
5320 slash_adjust(retvar->vval.v_string); 5534 slash_adjust(rettv->vval.v_string);
5321 #endif 5535 #endif
5322 } 5536 }
5323 } 5537 }
5324 5538
5325 /* 5539 /*
5326 * "getfontname()" function 5540 * "getfontname()" function
5327 */ 5541 */
5328 /*ARGSUSED*/ 5542 /*ARGSUSED*/
5329 static void 5543 static void
5330 f_getfontname(argvars, retvar) 5544 f_getfontname(argvars, rettv)
5331 typeval *argvars; 5545 typeval *argvars;
5332 typeval *retvar; 5546 typeval *rettv;
5333 { 5547 {
5334 retvar->v_type = VAR_STRING; 5548 rettv->v_type = VAR_STRING;
5335 retvar->vval.v_string = NULL; 5549 rettv->vval.v_string = NULL;
5336 #ifdef FEAT_GUI 5550 #ifdef FEAT_GUI
5337 if (gui.in_use) 5551 if (gui.in_use)
5338 { 5552 {
5339 GuiFont font; 5553 GuiFont font;
5340 char_u *name = NULL; 5554 char_u *name = NULL;
5346 font = gui.norm_font; 5560 font = gui.norm_font;
5347 name = hl_get_font_name(); 5561 name = hl_get_font_name();
5348 } 5562 }
5349 else 5563 else
5350 { 5564 {
5351 name = get_vartv_string(&argvars[0]); 5565 name = get_tv_string(&argvars[0]);
5352 if (STRCMP(name, "*") == 0) /* don't use font dialog */ 5566 if (STRCMP(name, "*") == 0) /* don't use font dialog */
5353 return; 5567 return;
5354 font = gui_mch_get_font(name, FALSE); 5568 font = gui_mch_get_font(name, FALSE);
5355 if (font == NOFONT) 5569 if (font == NOFONT)
5356 return; /* Invalid font name, return empty string. */ 5570 return; /* Invalid font name, return empty string. */
5357 } 5571 }
5358 retvar->vval.v_string = gui_mch_get_fontname(font, name); 5572 rettv->vval.v_string = gui_mch_get_fontname(font, name);
5359 if (argvars[0].v_type != VAR_UNKNOWN) 5573 if (argvars[0].v_type != VAR_UNKNOWN)
5360 gui_mch_free_font(font); 5574 gui_mch_free_font(font);
5361 } 5575 }
5362 #endif 5576 #endif
5363 } 5577 }
5364 5578
5365 /* 5579 /*
5366 * "getfperm({fname})" function 5580 * "getfperm({fname})" function
5367 */ 5581 */
5368 static void 5582 static void
5369 f_getfperm(argvars, retvar) 5583 f_getfperm(argvars, rettv)
5370 typeval *argvars; 5584 typeval *argvars;
5371 typeval *retvar; 5585 typeval *rettv;
5372 { 5586 {
5373 char_u *fname; 5587 char_u *fname;
5374 struct stat st; 5588 struct stat st;
5375 char_u *perm = NULL; 5589 char_u *perm = NULL;
5376 char_u flags[] = "rwx"; 5590 char_u flags[] = "rwx";
5377 int i; 5591 int i;
5378 5592
5379 fname = get_vartv_string(&argvars[0]); 5593 fname = get_tv_string(&argvars[0]);
5380 5594
5381 retvar->v_type = VAR_STRING; 5595 rettv->v_type = VAR_STRING;
5382 if (mch_stat((char *)fname, &st) >= 0) 5596 if (mch_stat((char *)fname, &st) >= 0)
5383 { 5597 {
5384 perm = vim_strsave((char_u *)"---------"); 5598 perm = vim_strsave((char_u *)"---------");
5385 if (perm != NULL) 5599 if (perm != NULL)
5386 { 5600 {
5389 if (st.st_mode & (1 << (8 - i))) 5603 if (st.st_mode & (1 << (8 - i)))
5390 perm[i] = flags[i % 3]; 5604 perm[i] = flags[i % 3];
5391 } 5605 }
5392 } 5606 }
5393 } 5607 }
5394 retvar->vval.v_string = perm; 5608 rettv->vval.v_string = perm;
5395 } 5609 }
5396 5610
5397 /* 5611 /*
5398 * "getfsize({fname})" function 5612 * "getfsize({fname})" function
5399 */ 5613 */
5400 static void 5614 static void
5401 f_getfsize(argvars, retvar) 5615 f_getfsize(argvars, rettv)
5402 typeval *argvars; 5616 typeval *argvars;
5403 typeval *retvar; 5617 typeval *rettv;
5404 { 5618 {
5405 char_u *fname; 5619 char_u *fname;
5406 struct stat st; 5620 struct stat st;
5407 5621
5408 fname = get_vartv_string(&argvars[0]); 5622 fname = get_tv_string(&argvars[0]);
5409 5623
5410 retvar->v_type = VAR_NUMBER; 5624 rettv->v_type = VAR_NUMBER;
5411 5625
5412 if (mch_stat((char *)fname, &st) >= 0) 5626 if (mch_stat((char *)fname, &st) >= 0)
5413 { 5627 {
5414 if (mch_isdir(fname)) 5628 if (mch_isdir(fname))
5415 retvar->vval.v_number = 0; 5629 rettv->vval.v_number = 0;
5416 else 5630 else
5417 retvar->vval.v_number = (varnumber_T)st.st_size; 5631 rettv->vval.v_number = (varnumber_T)st.st_size;
5418 } 5632 }
5419 else 5633 else
5420 retvar->vval.v_number = -1; 5634 rettv->vval.v_number = -1;
5421 } 5635 }
5422 5636
5423 /* 5637 /*
5424 * "getftime({fname})" function 5638 * "getftime({fname})" function
5425 */ 5639 */
5426 static void 5640 static void
5427 f_getftime(argvars, retvar) 5641 f_getftime(argvars, rettv)
5428 typeval *argvars; 5642 typeval *argvars;
5429 typeval *retvar; 5643 typeval *rettv;
5430 { 5644 {
5431 char_u *fname; 5645 char_u *fname;
5432 struct stat st; 5646 struct stat st;
5433 5647
5434 fname = get_vartv_string(&argvars[0]); 5648 fname = get_tv_string(&argvars[0]);
5435 5649
5436 if (mch_stat((char *)fname, &st) >= 0) 5650 if (mch_stat((char *)fname, &st) >= 0)
5437 retvar->vval.v_number = (varnumber_T)st.st_mtime; 5651 rettv->vval.v_number = (varnumber_T)st.st_mtime;
5438 else 5652 else
5439 retvar->vval.v_number = -1; 5653 rettv->vval.v_number = -1;
5440 } 5654 }
5441 5655
5442 /* 5656 /*
5443 * "getftype({fname})" function 5657 * "getftype({fname})" function
5444 */ 5658 */
5445 static void 5659 static void
5446 f_getftype(argvars, retvar) 5660 f_getftype(argvars, rettv)
5447 typeval *argvars; 5661 typeval *argvars;
5448 typeval *retvar; 5662 typeval *rettv;
5449 { 5663 {
5450 char_u *fname; 5664 char_u *fname;
5451 struct stat st; 5665 struct stat st;
5452 char_u *type = NULL; 5666 char_u *type = NULL;
5453 char *t; 5667 char *t;
5454 5668
5455 fname = get_vartv_string(&argvars[0]); 5669 fname = get_tv_string(&argvars[0]);
5456 5670
5457 retvar->v_type = VAR_STRING; 5671 rettv->v_type = VAR_STRING;
5458 if (mch_lstat((char *)fname, &st) >= 0) 5672 if (mch_lstat((char *)fname, &st) >= 0)
5459 { 5673 {
5460 #ifdef S_ISREG 5674 #ifdef S_ISREG
5461 if (S_ISREG(st.st_mode)) 5675 if (S_ISREG(st.st_mode))
5462 t = "file"; 5676 t = "file";
5514 t = "file"; 5728 t = "file";
5515 # endif 5729 # endif
5516 #endif 5730 #endif
5517 type = vim_strsave((char_u *)t); 5731 type = vim_strsave((char_u *)t);
5518 } 5732 }
5519 retvar->vval.v_string = type; 5733 rettv->vval.v_string = type;
5520 } 5734 }
5521 5735
5522 /* 5736 /*
5523 * "getreg()" function 5737 * "getreg()" function
5524 */ 5738 */
5525 static void 5739 static void
5526 f_getreg(argvars, retvar) 5740 f_getreg(argvars, rettv)
5527 typeval *argvars; 5741 typeval *argvars;
5528 typeval *retvar; 5742 typeval *rettv;
5529 { 5743 {
5530 char_u *strregname; 5744 char_u *strregname;
5531 int regname; 5745 int regname;
5532 5746
5533 if (argvars[0].v_type != VAR_UNKNOWN) 5747 if (argvars[0].v_type != VAR_UNKNOWN)
5534 strregname = get_vartv_string(&argvars[0]); 5748 strregname = get_tv_string(&argvars[0]);
5535 else 5749 else
5536 strregname = vimvars[VV_REG].val; 5750 strregname = vimvars[VV_REG].val;
5537 regname = (strregname == NULL ? '"' : *strregname); 5751 regname = (strregname == NULL ? '"' : *strregname);
5538 if (regname == 0) 5752 if (regname == 0)
5539 regname = '"'; 5753 regname = '"';
5540 5754
5541 retvar->v_type = VAR_STRING; 5755 rettv->v_type = VAR_STRING;
5542 retvar->vval.v_string = get_reg_contents(regname, TRUE); 5756 rettv->vval.v_string = get_reg_contents(regname, TRUE);
5543 } 5757 }
5544 5758
5545 /* 5759 /*
5546 * "getregtype()" function 5760 * "getregtype()" function
5547 */ 5761 */
5548 static void 5762 static void
5549 f_getregtype(argvars, retvar) 5763 f_getregtype(argvars, rettv)
5550 typeval *argvars; 5764 typeval *argvars;
5551 typeval *retvar; 5765 typeval *rettv;
5552 { 5766 {
5553 char_u *strregname; 5767 char_u *strregname;
5554 int regname; 5768 int regname;
5555 char_u buf[NUMBUFLEN + 2]; 5769 char_u buf[NUMBUFLEN + 2];
5556 long reglen = 0; 5770 long reglen = 0;
5557 5771
5558 if (argvars[0].v_type != VAR_UNKNOWN) 5772 if (argvars[0].v_type != VAR_UNKNOWN)
5559 strregname = get_vartv_string(&argvars[0]); 5773 strregname = get_tv_string(&argvars[0]);
5560 else 5774 else
5561 /* Default to v:register */ 5775 /* Default to v:register */
5562 strregname = vimvars[VV_REG].val; 5776 strregname = vimvars[VV_REG].val;
5563 5777
5564 regname = (strregname == NULL ? '"' : *strregname); 5778 regname = (strregname == NULL ? '"' : *strregname);
5576 buf[0] = Ctrl_V; 5790 buf[0] = Ctrl_V;
5577 sprintf((char *)buf + 1, "%ld", reglen + 1); 5791 sprintf((char *)buf + 1, "%ld", reglen + 1);
5578 break; 5792 break;
5579 #endif 5793 #endif
5580 } 5794 }
5581 retvar->v_type = VAR_STRING; 5795 rettv->v_type = VAR_STRING;
5582 retvar->vval.v_string = vim_strsave(buf); 5796 rettv->vval.v_string = vim_strsave(buf);
5583 } 5797 }
5584 5798
5585 /* 5799 /*
5586 * "getline(lnum)" function 5800 * "getline(lnum)" function
5587 */ 5801 */
5588 static void 5802 static void
5589 f_getline(argvars, retvar) 5803 f_getline(argvars, rettv)
5590 typeval *argvars; 5804 typeval *argvars;
5591 typeval *retvar; 5805 typeval *rettv;
5592 { 5806 {
5593 linenr_T lnum; 5807 linenr_T lnum;
5594 char_u *p; 5808 char_u *p;
5595 5809
5596 lnum = get_vartv_lnum(argvars); 5810 lnum = get_tv_lnum(argvars);
5597 5811
5598 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 5812 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
5599 p = ml_get(lnum); 5813 p = ml_get(lnum);
5600 else 5814 else
5601 p = (char_u *)""; 5815 p = (char_u *)"";
5602 5816
5603 retvar->v_type = VAR_STRING; 5817 rettv->v_type = VAR_STRING;
5604 retvar->vval.v_string = vim_strsave(p); 5818 rettv->vval.v_string = vim_strsave(p);
5605 } 5819 }
5606 5820
5607 /* 5821 /*
5608 * "getwinposx()" function 5822 * "getwinposx()" function
5609 */ 5823 */
5610 /*ARGSUSED*/ 5824 /*ARGSUSED*/
5611 static void 5825 static void
5612 f_getwinposx(argvars, retvar) 5826 f_getwinposx(argvars, rettv)
5613 typeval *argvars; 5827 typeval *argvars;
5614 typeval *retvar; 5828 typeval *rettv;
5615 { 5829 {
5616 retvar->vval.v_number = -1; 5830 rettv->vval.v_number = -1;
5617 #ifdef FEAT_GUI 5831 #ifdef FEAT_GUI
5618 if (gui.in_use) 5832 if (gui.in_use)
5619 { 5833 {
5620 int x, y; 5834 int x, y;
5621 5835
5622 if (gui_mch_get_winpos(&x, &y) == OK) 5836 if (gui_mch_get_winpos(&x, &y) == OK)
5623 retvar->vval.v_number = x; 5837 rettv->vval.v_number = x;
5624 } 5838 }
5625 #endif 5839 #endif
5626 } 5840 }
5627 5841
5628 /* 5842 /*
5629 * "getwinposy()" function 5843 * "getwinposy()" function
5630 */ 5844 */
5631 /*ARGSUSED*/ 5845 /*ARGSUSED*/
5632 static void 5846 static void
5633 f_getwinposy(argvars, retvar) 5847 f_getwinposy(argvars, rettv)
5634 typeval *argvars; 5848 typeval *argvars;
5635 typeval *retvar; 5849 typeval *rettv;
5636 { 5850 {
5637 retvar->vval.v_number = -1; 5851 rettv->vval.v_number = -1;
5638 #ifdef FEAT_GUI 5852 #ifdef FEAT_GUI
5639 if (gui.in_use) 5853 if (gui.in_use)
5640 { 5854 {
5641 int x, y; 5855 int x, y;
5642 5856
5643 if (gui_mch_get_winpos(&x, &y) == OK) 5857 if (gui_mch_get_winpos(&x, &y) == OK)
5644 retvar->vval.v_number = y; 5858 rettv->vval.v_number = y;
5645 } 5859 }
5646 #endif 5860 #endif
5647 } 5861 }
5648 5862
5649 /* 5863 /*
5650 * "getwinvar()" function 5864 * "getwinvar()" function
5651 */ 5865 */
5652 static void 5866 static void
5653 f_getwinvar(argvars, retvar) 5867 f_getwinvar(argvars, rettv)
5654 typeval *argvars; 5868 typeval *argvars;
5655 typeval *retvar; 5869 typeval *rettv;
5656 { 5870 {
5657 win_T *win, *oldcurwin; 5871 win_T *win, *oldcurwin;
5658 char_u *varname; 5872 char_u *varname;
5659 VAR v; 5873 VAR v;
5660 5874
5661 ++emsg_off; 5875 ++emsg_off;
5662 win = find_win_by_nr(&argvars[0]); 5876 win = find_win_by_nr(&argvars[0]);
5663 varname = get_vartv_string(&argvars[1]); 5877 varname = get_tv_string(&argvars[1]);
5664 5878
5665 retvar->v_type = VAR_STRING; 5879 rettv->v_type = VAR_STRING;
5666 retvar->vval.v_string = NULL; 5880 rettv->vval.v_string = NULL;
5667 5881
5668 if (win != NULL && varname != NULL) 5882 if (win != NULL && varname != NULL)
5669 { 5883 {
5670 if (*varname == '&') /* window-local-option */ 5884 if (*varname == '&') /* window-local-option */
5671 { 5885 {
5672 /* set curwin to be our win, temporarily */ 5886 /* set curwin to be our win, temporarily */
5673 oldcurwin = curwin; 5887 oldcurwin = curwin;
5674 curwin = win; 5888 curwin = win;
5675 5889
5676 get_option_vartv(&varname, retvar, 1); 5890 get_option_tv(&varname, rettv, 1);
5677 5891
5678 /* restore previous notion of curwin */ 5892 /* restore previous notion of curwin */
5679 curwin = oldcurwin; 5893 curwin = oldcurwin;
5680 } 5894 }
5681 else 5895 else
5682 { 5896 {
5683 /* look up the variable */ 5897 /* look up the variable */
5684 v = find_var_in_ga(&win->w_vars, varname); 5898 v = find_var_in_ga(&win->w_vars, varname);
5685 if (v != NULL) 5899 if (v != NULL)
5686 copy_vartv(&v->tv, retvar); 5900 copy_tv(&v->tv, rettv);
5687 } 5901 }
5688 } 5902 }
5689 5903
5690 --emsg_off; 5904 --emsg_off;
5691 } 5905 }
5692 5906
5693 /* 5907 /*
5694 * "glob()" function 5908 * "glob()" function
5695 */ 5909 */
5696 static void 5910 static void
5697 f_glob(argvars, retvar) 5911 f_glob(argvars, rettv)
5698 typeval *argvars; 5912 typeval *argvars;
5699 typeval *retvar; 5913 typeval *rettv;
5700 { 5914 {
5701 expand_T xpc; 5915 expand_T xpc;
5702 5916
5703 ExpandInit(&xpc); 5917 ExpandInit(&xpc);
5704 xpc.xp_context = EXPAND_FILES; 5918 xpc.xp_context = EXPAND_FILES;
5705 retvar->v_type = VAR_STRING; 5919 rettv->v_type = VAR_STRING;
5706 retvar->vval.v_string = ExpandOne(&xpc, get_vartv_string(&argvars[0]), 5920 rettv->vval.v_string = ExpandOne(&xpc, get_tv_string(&argvars[0]),
5707 NULL, WILD_USE_NL|WILD_SILENT, WILD_ALL); 5921 NULL, WILD_USE_NL|WILD_SILENT, WILD_ALL);
5708 ExpandCleanup(&xpc); 5922 ExpandCleanup(&xpc);
5709 } 5923 }
5710 5924
5711 /* 5925 /*
5712 * "globpath()" function 5926 * "globpath()" function
5713 */ 5927 */
5714 static void 5928 static void
5715 f_globpath(argvars, retvar) 5929 f_globpath(argvars, rettv)
5716 typeval *argvars; 5930 typeval *argvars;
5717 typeval *retvar; 5931 typeval *rettv;
5718 { 5932 {
5719 char_u buf1[NUMBUFLEN]; 5933 char_u buf1[NUMBUFLEN];
5720 5934
5721 retvar->v_type = VAR_STRING; 5935 rettv->v_type = VAR_STRING;
5722 retvar->vval.v_string = globpath(get_vartv_string(&argvars[0]), 5936 rettv->vval.v_string = globpath(get_tv_string(&argvars[0]),
5723 get_vartv_string_buf(&argvars[1], buf1)); 5937 get_tv_string_buf(&argvars[1], buf1));
5724 } 5938 }
5725 5939
5726 /* 5940 /*
5727 * "has()" function 5941 * "has()" function
5728 */ 5942 */
5729 static void 5943 static void
5730 f_has(argvars, retvar) 5944 f_has(argvars, rettv)
5731 typeval *argvars; 5945 typeval *argvars;
5732 typeval *retvar; 5946 typeval *rettv;
5733 { 5947 {
5734 int i; 5948 int i;
5735 char_u *name; 5949 char_u *name;
5736 int n = FALSE; 5950 int n = FALSE;
5737 static char *(has_list[]) = 5951 static char *(has_list[]) =
5889 # ifdef FEAT_GUI_NEXTAW 6103 # ifdef FEAT_GUI_NEXTAW
5890 "gui_neXtaw", 6104 "gui_neXtaw",
5891 # else 6105 # else
5892 "gui_athena", 6106 "gui_athena",
5893 # endif 6107 # endif
5894 #endif
5895 #ifdef FEAT_GUI_BEOS
5896 "gui_beos",
5897 #endif 6108 #endif
5898 #ifdef FEAT_GUI_KDE 6109 #ifdef FEAT_GUI_KDE
5899 "gui_kde", 6110 "gui_kde",
5900 #endif 6111 #endif
5901 #ifdef FEAT_GUI_GTK 6112 #ifdef FEAT_GUI_GTK
6155 "X11", 6366 "X11",
6156 #endif 6367 #endif
6157 NULL 6368 NULL
6158 }; 6369 };
6159 6370
6160 name = get_vartv_string(&argvars[0]); 6371 name = get_tv_string(&argvars[0]);
6161 for (i = 0; has_list[i] != NULL; ++i) 6372 for (i = 0; has_list[i] != NULL; ++i)
6162 if (STRICMP(name, has_list[i]) == 0) 6373 if (STRICMP(name, has_list[i]) == 0)
6163 { 6374 {
6164 n = TRUE; 6375 n = TRUE;
6165 break; 6376 break;
6215 else if (STRICMP(name, "netbeans_enabled") == 0) 6426 else if (STRICMP(name, "netbeans_enabled") == 0)
6216 n = usingNetbeans; 6427 n = usingNetbeans;
6217 #endif 6428 #endif
6218 } 6429 }
6219 6430
6220 retvar->vval.v_number = n; 6431 rettv->vval.v_number = n;
6221 } 6432 }
6222 6433
6223 /* 6434 /*
6224 * "hasmapto()" function 6435 * "hasmapto()" function
6225 */ 6436 */
6226 static void 6437 static void
6227 f_hasmapto(argvars, retvar) 6438 f_hasmapto(argvars, rettv)
6228 typeval *argvars; 6439 typeval *argvars;
6229 typeval *retvar; 6440 typeval *rettv;
6230 { 6441 {
6231 char_u *name; 6442 char_u *name;
6232 char_u *mode; 6443 char_u *mode;
6233 char_u buf[NUMBUFLEN]; 6444 char_u buf[NUMBUFLEN];
6234 6445
6235 name = get_vartv_string(&argvars[0]); 6446 name = get_tv_string(&argvars[0]);
6236 if (argvars[1].v_type == VAR_UNKNOWN) 6447 if (argvars[1].v_type == VAR_UNKNOWN)
6237 mode = (char_u *)"nvo"; 6448 mode = (char_u *)"nvo";
6238 else 6449 else
6239 mode = get_vartv_string_buf(&argvars[1], buf); 6450 mode = get_tv_string_buf(&argvars[1], buf);
6240 6451
6241 if (map_to_exists(name, mode)) 6452 if (map_to_exists(name, mode))
6242 retvar->vval.v_number = TRUE; 6453 rettv->vval.v_number = TRUE;
6243 else 6454 else
6244 retvar->vval.v_number = FALSE; 6455 rettv->vval.v_number = FALSE;
6245 } 6456 }
6246 6457
6247 /* 6458 /*
6248 * "histadd()" function 6459 * "histadd()" function
6249 */ 6460 */
6250 /*ARGSUSED*/ 6461 /*ARGSUSED*/
6251 static void 6462 static void
6252 f_histadd(argvars, retvar) 6463 f_histadd(argvars, rettv)
6253 typeval *argvars; 6464 typeval *argvars;
6254 typeval *retvar; 6465 typeval *rettv;
6255 { 6466 {
6256 #ifdef FEAT_CMDHIST 6467 #ifdef FEAT_CMDHIST
6257 int histype; 6468 int histype;
6258 char_u *str; 6469 char_u *str;
6259 char_u buf[NUMBUFLEN]; 6470 char_u buf[NUMBUFLEN];
6260 #endif 6471 #endif
6261 6472
6262 retvar->vval.v_number = FALSE; 6473 rettv->vval.v_number = FALSE;
6263 if (check_restricted() || check_secure()) 6474 if (check_restricted() || check_secure())
6264 return; 6475 return;
6265 #ifdef FEAT_CMDHIST 6476 #ifdef FEAT_CMDHIST
6266 histype = get_histtype(get_vartv_string(&argvars[0])); 6477 histype = get_histtype(get_tv_string(&argvars[0]));
6267 if (histype >= 0) 6478 if (histype >= 0)
6268 { 6479 {
6269 str = get_vartv_string_buf(&argvars[1], buf); 6480 str = get_tv_string_buf(&argvars[1], buf);
6270 if (*str != NUL) 6481 if (*str != NUL)
6271 { 6482 {
6272 add_to_history(histype, str, FALSE, NUL); 6483 add_to_history(histype, str, FALSE, NUL);
6273 retvar->vval.v_number = TRUE; 6484 rettv->vval.v_number = TRUE;
6274 return; 6485 return;
6275 } 6486 }
6276 } 6487 }
6277 #endif 6488 #endif
6278 } 6489 }
6280 /* 6491 /*
6281 * "histdel()" function 6492 * "histdel()" function
6282 */ 6493 */
6283 /*ARGSUSED*/ 6494 /*ARGSUSED*/
6284 static void 6495 static void
6285 f_histdel(argvars, retvar) 6496 f_histdel(argvars, rettv)
6286 typeval *argvars; 6497 typeval *argvars;
6287 typeval *retvar; 6498 typeval *rettv;
6288 { 6499 {
6289 #ifdef FEAT_CMDHIST 6500 #ifdef FEAT_CMDHIST
6290 int n; 6501 int n;
6291 char_u buf[NUMBUFLEN]; 6502 char_u buf[NUMBUFLEN];
6292 6503
6293 if (argvars[1].v_type == VAR_UNKNOWN) 6504 if (argvars[1].v_type == VAR_UNKNOWN)
6294 /* only one argument: clear entire history */ 6505 /* only one argument: clear entire history */
6295 n = clr_history(get_histtype(get_vartv_string(&argvars[0]))); 6506 n = clr_history(get_histtype(get_tv_string(&argvars[0])));
6296 else if (argvars[1].v_type == VAR_NUMBER) 6507 else if (argvars[1].v_type == VAR_NUMBER)
6297 /* index given: remove that entry */ 6508 /* index given: remove that entry */
6298 n = del_history_idx(get_histtype(get_vartv_string(&argvars[0])), 6509 n = del_history_idx(get_histtype(get_tv_string(&argvars[0])),
6299 (int)get_vartv_number(&argvars[1])); 6510 (int)get_tv_number(&argvars[1]));
6300 else 6511 else
6301 /* string given: remove all matching entries */ 6512 /* string given: remove all matching entries */
6302 n = del_history_entry(get_histtype(get_vartv_string(&argvars[0])), 6513 n = del_history_entry(get_histtype(get_tv_string(&argvars[0])),
6303 get_vartv_string_buf(&argvars[1], buf)); 6514 get_tv_string_buf(&argvars[1], buf));
6304 retvar->vval.v_number = n; 6515 rettv->vval.v_number = n;
6305 #else 6516 #else
6306 retvar->vval.v_number = 0; 6517 rettv->vval.v_number = 0;
6307 #endif 6518 #endif
6308 } 6519 }
6309 6520
6310 /* 6521 /*
6311 * "histget()" function 6522 * "histget()" function
6312 */ 6523 */
6313 /*ARGSUSED*/ 6524 /*ARGSUSED*/
6314 static void 6525 static void
6315 f_histget(argvars, retvar) 6526 f_histget(argvars, rettv)
6316 typeval *argvars; 6527 typeval *argvars;
6317 typeval *retvar; 6528 typeval *rettv;
6318 { 6529 {
6319 #ifdef FEAT_CMDHIST 6530 #ifdef FEAT_CMDHIST
6320 int type; 6531 int type;
6321 int idx; 6532 int idx;
6322 6533
6323 type = get_histtype(get_vartv_string(&argvars[0])); 6534 type = get_histtype(get_tv_string(&argvars[0]));
6324 if (argvars[1].v_type == VAR_UNKNOWN) 6535 if (argvars[1].v_type == VAR_UNKNOWN)
6325 idx = get_history_idx(type); 6536 idx = get_history_idx(type);
6326 else 6537 else
6327 idx = (int)get_vartv_number(&argvars[1]); 6538 idx = (int)get_tv_number(&argvars[1]);
6328 retvar->vval.v_string = vim_strsave(get_history_entry(type, idx)); 6539 rettv->vval.v_string = vim_strsave(get_history_entry(type, idx));
6329 #else 6540 #else
6330 retvar->vval.v_string = NULL; 6541 rettv->vval.v_string = NULL;
6331 #endif 6542 #endif
6332 retvar->v_type = VAR_STRING; 6543 rettv->v_type = VAR_STRING;
6333 } 6544 }
6334 6545
6335 /* 6546 /*
6336 * "histnr()" function 6547 * "histnr()" function
6337 */ 6548 */
6338 /*ARGSUSED*/ 6549 /*ARGSUSED*/
6339 static void 6550 static void
6340 f_histnr(argvars, retvar) 6551 f_histnr(argvars, rettv)
6341 typeval *argvars; 6552 typeval *argvars;
6342 typeval *retvar; 6553 typeval *rettv;
6343 { 6554 {
6344 int i; 6555 int i;
6345 6556
6346 #ifdef FEAT_CMDHIST 6557 #ifdef FEAT_CMDHIST
6347 i = get_histtype(get_vartv_string(&argvars[0])); 6558 i = get_histtype(get_tv_string(&argvars[0]));
6348 if (i >= HIST_CMD && i < HIST_COUNT) 6559 if (i >= HIST_CMD && i < HIST_COUNT)
6349 i = get_history_idx(i); 6560 i = get_history_idx(i);
6350 else 6561 else
6351 #endif 6562 #endif
6352 i = -1; 6563 i = -1;
6353 retvar->vval.v_number = i; 6564 rettv->vval.v_number = i;
6354 } 6565 }
6355 6566
6356 /* 6567 /*
6357 * "highlight_exists()" function 6568 * "highlight_exists()" function
6358 */ 6569 */
6359 static void 6570 static void
6360 f_hlexists(argvars, retvar) 6571 f_hlexists(argvars, rettv)
6361 typeval *argvars; 6572 typeval *argvars;
6362 typeval *retvar; 6573 typeval *rettv;
6363 { 6574 {
6364 retvar->vval.v_number = highlight_exists(get_vartv_string(&argvars[0])); 6575 rettv->vval.v_number = highlight_exists(get_tv_string(&argvars[0]));
6365 } 6576 }
6366 6577
6367 /* 6578 /*
6368 * "highlightID(name)" function 6579 * "highlightID(name)" function
6369 */ 6580 */
6370 static void 6581 static void
6371 f_hlID(argvars, retvar) 6582 f_hlID(argvars, rettv)
6372 typeval *argvars; 6583 typeval *argvars;
6373 typeval *retvar; 6584 typeval *rettv;
6374 { 6585 {
6375 retvar->vval.v_number = syn_name2id(get_vartv_string(&argvars[0])); 6586 rettv->vval.v_number = syn_name2id(get_tv_string(&argvars[0]));
6376 } 6587 }
6377 6588
6378 /* 6589 /*
6379 * "hostname()" function 6590 * "hostname()" function
6380 */ 6591 */
6381 /*ARGSUSED*/ 6592 /*ARGSUSED*/
6382 static void 6593 static void
6383 f_hostname(argvars, retvar) 6594 f_hostname(argvars, rettv)
6384 typeval *argvars; 6595 typeval *argvars;
6385 typeval *retvar; 6596 typeval *rettv;
6386 { 6597 {
6387 char_u hostname[256]; 6598 char_u hostname[256];
6388 6599
6389 mch_get_host_name(hostname, 256); 6600 mch_get_host_name(hostname, 256);
6390 retvar->v_type = VAR_STRING; 6601 rettv->v_type = VAR_STRING;
6391 retvar->vval.v_string = vim_strsave(hostname); 6602 rettv->vval.v_string = vim_strsave(hostname);
6392 } 6603 }
6393 6604
6394 /* 6605 /*
6395 * iconv() function 6606 * iconv() function
6396 */ 6607 */
6397 /*ARGSUSED*/ 6608 /*ARGSUSED*/
6398 static void 6609 static void
6399 f_iconv(argvars, retvar) 6610 f_iconv(argvars, rettv)
6400 typeval *argvars; 6611 typeval *argvars;
6401 typeval *retvar; 6612 typeval *rettv;
6402 { 6613 {
6403 #ifdef FEAT_MBYTE 6614 #ifdef FEAT_MBYTE
6404 char_u buf1[NUMBUFLEN]; 6615 char_u buf1[NUMBUFLEN];
6405 char_u buf2[NUMBUFLEN]; 6616 char_u buf2[NUMBUFLEN];
6406 char_u *from, *to, *str; 6617 char_u *from, *to, *str;
6407 vimconv_T vimconv; 6618 vimconv_T vimconv;
6408 #endif 6619 #endif
6409 6620
6410 retvar->v_type = VAR_STRING; 6621 rettv->v_type = VAR_STRING;
6411 retvar->vval.v_string = NULL; 6622 rettv->vval.v_string = NULL;
6412 6623
6413 #ifdef FEAT_MBYTE 6624 #ifdef FEAT_MBYTE
6414 str = get_vartv_string(&argvars[0]); 6625 str = get_tv_string(&argvars[0]);
6415 from = enc_canonize(enc_skip(get_vartv_string_buf(&argvars[1], buf1))); 6626 from = enc_canonize(enc_skip(get_tv_string_buf(&argvars[1], buf1)));
6416 to = enc_canonize(enc_skip(get_vartv_string_buf(&argvars[2], buf2))); 6627 to = enc_canonize(enc_skip(get_tv_string_buf(&argvars[2], buf2)));
6417 vimconv.vc_type = CONV_NONE; 6628 vimconv.vc_type = CONV_NONE;
6418 convert_setup(&vimconv, from, to); 6629 convert_setup(&vimconv, from, to);
6419 6630
6420 /* If the encodings are equal, no conversion needed. */ 6631 /* If the encodings are equal, no conversion needed. */
6421 if (vimconv.vc_type == CONV_NONE) 6632 if (vimconv.vc_type == CONV_NONE)
6422 retvar->vval.v_string = vim_strsave(str); 6633 rettv->vval.v_string = vim_strsave(str);
6423 else 6634 else
6424 retvar->vval.v_string = string_convert(&vimconv, str, NULL); 6635 rettv->vval.v_string = string_convert(&vimconv, str, NULL);
6425 6636
6426 convert_setup(&vimconv, NULL, NULL); 6637 convert_setup(&vimconv, NULL, NULL);
6427 vim_free(from); 6638 vim_free(from);
6428 vim_free(to); 6639 vim_free(to);
6429 #endif 6640 #endif
6431 6642
6432 /* 6643 /*
6433 * "indent()" function 6644 * "indent()" function
6434 */ 6645 */
6435 static void 6646 static void
6436 f_indent(argvars, retvar) 6647 f_indent(argvars, rettv)
6437 typeval *argvars; 6648 typeval *argvars;
6438 typeval *retvar; 6649 typeval *rettv;
6439 { 6650 {
6440 linenr_T lnum; 6651 linenr_T lnum;
6441 6652
6442 lnum = get_vartv_lnum(argvars); 6653 lnum = get_tv_lnum(argvars);
6443 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 6654 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
6444 retvar->vval.v_number = get_indent_lnum(lnum); 6655 rettv->vval.v_number = get_indent_lnum(lnum);
6445 else 6656 else
6446 retvar->vval.v_number = -1; 6657 rettv->vval.v_number = -1;
6447 } 6658 }
6448 6659
6449 static int inputsecret_flag = 0; 6660 static int inputsecret_flag = 0;
6450 6661
6451 /* 6662 /*
6452 * "input()" function 6663 * "input()" function
6453 * Also handles inputsecret() when inputsecret is set. 6664 * Also handles inputsecret() when inputsecret is set.
6454 */ 6665 */
6455 static void 6666 static void
6456 f_input(argvars, retvar) 6667 f_input(argvars, rettv)
6457 typeval *argvars; 6668 typeval *argvars;
6458 typeval *retvar; 6669 typeval *rettv;
6459 { 6670 {
6460 char_u *prompt = get_vartv_string(&argvars[0]); 6671 char_u *prompt = get_tv_string(&argvars[0]);
6461 char_u *p = NULL; 6672 char_u *p = NULL;
6462 int c; 6673 int c;
6463 char_u buf[NUMBUFLEN]; 6674 char_u buf[NUMBUFLEN];
6464 int cmd_silent_save = cmd_silent; 6675 int cmd_silent_save = cmd_silent;
6465 6676
6466 retvar->v_type = VAR_STRING; 6677 rettv->v_type = VAR_STRING;
6467 6678
6468 #ifdef NO_CONSOLE_INPUT 6679 #ifdef NO_CONSOLE_INPUT
6469 /* While starting up, there is no place to enter text. */ 6680 /* While starting up, there is no place to enter text. */
6470 if (no_console_input()) 6681 if (no_console_input())
6471 { 6682 {
6472 retvar->vval.v_string = NULL; 6683 rettv->vval.v_string = NULL;
6473 return; 6684 return;
6474 } 6685 }
6475 #endif 6686 #endif
6476 6687
6477 cmd_silent = FALSE; /* Want to see the prompt. */ 6688 cmd_silent = FALSE; /* Want to see the prompt. */
6496 } 6707 }
6497 cmdline_row = msg_row; 6708 cmdline_row = msg_row;
6498 } 6709 }
6499 6710
6500 if (argvars[1].v_type != VAR_UNKNOWN) 6711 if (argvars[1].v_type != VAR_UNKNOWN)
6501 stuffReadbuffSpec(get_vartv_string_buf(&argvars[1], buf)); 6712 stuffReadbuffSpec(get_tv_string_buf(&argvars[1], buf));
6502 6713
6503 retvar->vval.v_string = 6714 rettv->vval.v_string =
6504 getcmdline_prompt(inputsecret_flag ? NUL : '@', p, echo_attr); 6715 getcmdline_prompt(inputsecret_flag ? NUL : '@', p, echo_attr);
6505 6716
6506 /* since the user typed this, no need to wait for return */ 6717 /* since the user typed this, no need to wait for return */
6507 need_wait_return = FALSE; 6718 need_wait_return = FALSE;
6508 msg_didout = FALSE; 6719 msg_didout = FALSE;
6511 6722
6512 /* 6723 /*
6513 * "inputdialog()" function 6724 * "inputdialog()" function
6514 */ 6725 */
6515 static void 6726 static void
6516 f_inputdialog(argvars, retvar) 6727 f_inputdialog(argvars, rettv)
6517 typeval *argvars; 6728 typeval *argvars;
6518 typeval *retvar; 6729 typeval *rettv;
6519 { 6730 {
6520 #if defined(FEAT_GUI_TEXTDIALOG) 6731 #if defined(FEAT_GUI_TEXTDIALOG)
6521 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */ 6732 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
6522 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL) 6733 if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
6523 { 6734 {
6524 char_u *message; 6735 char_u *message;
6525 char_u buf[NUMBUFLEN]; 6736 char_u buf[NUMBUFLEN];
6526 6737
6527 message = get_vartv_string(&argvars[0]); 6738 message = get_tv_string(&argvars[0]);
6528 if (argvars[1].v_type != VAR_UNKNOWN) 6739 if (argvars[1].v_type != VAR_UNKNOWN)
6529 { 6740 {
6530 STRNCPY(IObuff, get_vartv_string_buf(&argvars[1], buf), IOSIZE); 6741 STRNCPY(IObuff, get_tv_string_buf(&argvars[1], buf), IOSIZE);
6531 IObuff[IOSIZE - 1] = NUL; 6742 IObuff[IOSIZE - 1] = NUL;
6532 } 6743 }
6533 else 6744 else
6534 IObuff[0] = NUL; 6745 IObuff[0] = NUL;
6535 if (do_dialog(VIM_QUESTION, NULL, message, (char_u *)_("&OK\n&Cancel"), 6746 if (do_dialog(VIM_QUESTION, NULL, message, (char_u *)_("&OK\n&Cancel"),
6536 1, IObuff) == 1) 6747 1, IObuff) == 1)
6537 retvar->vval.v_string = vim_strsave(IObuff); 6748 rettv->vval.v_string = vim_strsave(IObuff);
6538 else 6749 else
6539 { 6750 {
6540 if (argvars[1].v_type != VAR_UNKNOWN 6751 if (argvars[1].v_type != VAR_UNKNOWN
6541 && argvars[2].v_type != VAR_UNKNOWN) 6752 && argvars[2].v_type != VAR_UNKNOWN)
6542 retvar->vval.v_string = vim_strsave( 6753 rettv->vval.v_string = vim_strsave(
6543 get_vartv_string_buf(&argvars[2], buf)); 6754 get_tv_string_buf(&argvars[2], buf));
6544 else 6755 else
6545 retvar->vval.v_string = NULL; 6756 rettv->vval.v_string = NULL;
6546 } 6757 }
6547 retvar->v_type = VAR_STRING; 6758 rettv->v_type = VAR_STRING;
6548 } 6759 }
6549 else 6760 else
6550 #endif 6761 #endif
6551 f_input(argvars, retvar); 6762 f_input(argvars, rettv);
6552 } 6763 }
6553 6764
6554 static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL}; 6765 static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL};
6555 6766
6556 /* 6767 /*
6557 * "inputrestore()" function 6768 * "inputrestore()" function
6558 */ 6769 */
6559 /*ARGSUSED*/ 6770 /*ARGSUSED*/
6560 static void 6771 static void
6561 f_inputrestore(argvars, retvar) 6772 f_inputrestore(argvars, rettv)
6562 typeval *argvars; 6773 typeval *argvars;
6563 typeval *retvar; 6774 typeval *rettv;
6564 { 6775 {
6565 if (ga_userinput.ga_len > 0) 6776 if (ga_userinput.ga_len > 0)
6566 { 6777 {
6567 --ga_userinput.ga_len; 6778 --ga_userinput.ga_len;
6568 restore_typeahead((tasave_T *)(ga_userinput.ga_data) 6779 restore_typeahead((tasave_T *)(ga_userinput.ga_data)
6569 + ga_userinput.ga_len); 6780 + ga_userinput.ga_len);
6570 retvar->vval.v_number = 0; /* OK */ 6781 rettv->vval.v_number = 0; /* OK */
6571 } 6782 }
6572 else if (p_verbose > 1) 6783 else if (p_verbose > 1)
6573 { 6784 {
6574 msg((char_u *)_("called inputrestore() more often than inputsave()")); 6785 msg((char_u *)_("called inputrestore() more often than inputsave()"));
6575 retvar->vval.v_number = 1; /* Failed */ 6786 rettv->vval.v_number = 1; /* Failed */
6576 } 6787 }
6577 } 6788 }
6578 6789
6579 /* 6790 /*
6580 * "inputsave()" function 6791 * "inputsave()" function
6581 */ 6792 */
6582 /*ARGSUSED*/ 6793 /*ARGSUSED*/
6583 static void 6794 static void
6584 f_inputsave(argvars, retvar) 6795 f_inputsave(argvars, rettv)
6585 typeval *argvars; 6796 typeval *argvars;
6586 typeval *retvar; 6797 typeval *rettv;
6587 { 6798 {
6588 /* Add an entry to the stack of typehead storage. */ 6799 /* Add an entry to the stack of typehead storage. */
6589 if (ga_grow(&ga_userinput, 1) == OK) 6800 if (ga_grow(&ga_userinput, 1) == OK)
6590 { 6801 {
6591 save_typeahead((tasave_T *)(ga_userinput.ga_data) 6802 save_typeahead((tasave_T *)(ga_userinput.ga_data)
6592 + ga_userinput.ga_len); 6803 + ga_userinput.ga_len);
6593 ++ga_userinput.ga_len; 6804 ++ga_userinput.ga_len;
6594 retvar->vval.v_number = 0; /* OK */ 6805 rettv->vval.v_number = 0; /* OK */
6595 } 6806 }
6596 else 6807 else
6597 retvar->vval.v_number = 1; /* Failed */ 6808 rettv->vval.v_number = 1; /* Failed */
6598 } 6809 }
6599 6810
6600 /* 6811 /*
6601 * "inputsecret()" function 6812 * "inputsecret()" function
6602 */ 6813 */
6603 static void 6814 static void
6604 f_inputsecret(argvars, retvar) 6815 f_inputsecret(argvars, rettv)
6605 typeval *argvars; 6816 typeval *argvars;
6606 typeval *retvar; 6817 typeval *rettv;
6607 { 6818 {
6608 ++cmdline_star; 6819 ++cmdline_star;
6609 ++inputsecret_flag; 6820 ++inputsecret_flag;
6610 f_input(argvars, retvar); 6821 f_input(argvars, rettv);
6611 --cmdline_star; 6822 --cmdline_star;
6612 --inputsecret_flag; 6823 --inputsecret_flag;
6613 } 6824 }
6614 6825
6615 /* 6826 /*
6616 * "insert()" function 6827 * "insert()" function
6617 */ 6828 */
6618 static void 6829 static void
6619 f_insert(argvars, retvar) 6830 f_insert(argvars, rettv)
6620 typeval *argvars; 6831 typeval *argvars;
6621 typeval *retvar; 6832 typeval *rettv;
6622 { 6833 {
6623 long before = 0; 6834 long before = 0;
6624 long n; 6835 long n;
6625 listitem *item; 6836 listitem *item;
6626 listitem *ni; 6837 listitem *ni;
6629 if (argvars[0].v_type != VAR_LIST) 6840 if (argvars[0].v_type != VAR_LIST)
6630 EMSG(_("E999: First argument of insert() must be a list")); 6841 EMSG(_("E999: First argument of insert() must be a list"));
6631 else if ((l = argvars[0].vval.v_list) != NULL) 6842 else if ((l = argvars[0].vval.v_list) != NULL)
6632 { 6843 {
6633 if (argvars[2].v_type != VAR_UNKNOWN) 6844 if (argvars[2].v_type != VAR_UNKNOWN)
6634 before = get_vartv_number(&argvars[2]); 6845 before = get_tv_number(&argvars[2]);
6635 6846
6636 if (before < 0) 6847 if (before < 0)
6637 { 6848 {
6638 /* Count from the end: -1 is before last item. */ 6849 /* Count from the end: -1 is before last item. */
6639 item = l->lv_last; 6850 item = l->lv_last;
6654 else 6865 else
6655 { 6866 {
6656 ni = listitem_alloc(); 6867 ni = listitem_alloc();
6657 if (ni != NULL) 6868 if (ni != NULL)
6658 { 6869 {
6659 copy_vartv(&argvars[1], &ni->li_tv); 6870 copy_tv(&argvars[1], &ni->li_tv);
6660 if (item == NULL) 6871 if (item == NULL)
6661 /* Append new item at end of list. */ 6872 /* Append new item at end of list. */
6662 list_append(l, ni); 6873 list_append(l, ni);
6663 else 6874 else
6664 { 6875 {
6669 l->lv_first = ni; 6880 l->lv_first = ni;
6670 else 6881 else
6671 item->li_prev->li_next = ni; 6882 item->li_prev->li_next = ni;
6672 item->li_prev = ni; 6883 item->li_prev = ni;
6673 } 6884 }
6674 copy_vartv(&argvars[0], retvar); 6885 copy_tv(&argvars[0], rettv);
6675 } 6886 }
6676 } 6887 }
6677 } 6888 }
6678 } 6889 }
6679 6890
6680 /* 6891 /*
6681 * "isdirectory()" function 6892 * "isdirectory()" function
6682 */ 6893 */
6683 static void 6894 static void
6684 f_isdirectory(argvars, retvar) 6895 f_isdirectory(argvars, rettv)
6685 typeval *argvars; 6896 typeval *argvars;
6686 typeval *retvar; 6897 typeval *rettv;
6687 { 6898 {
6688 retvar->vval.v_number = mch_isdir(get_vartv_string(&argvars[0])); 6899 rettv->vval.v_number = mch_isdir(get_tv_string(&argvars[0]));
6689 } 6900 }
6690 6901
6691 /* 6902 /*
6692 * "last_buffer_nr()" function. 6903 * "last_buffer_nr()" function.
6693 */ 6904 */
6694 /*ARGSUSED*/ 6905 /*ARGSUSED*/
6695 static void 6906 static void
6696 f_last_buffer_nr(argvars, retvar) 6907 f_last_buffer_nr(argvars, rettv)
6697 typeval *argvars; 6908 typeval *argvars;
6698 typeval *retvar; 6909 typeval *rettv;
6699 { 6910 {
6700 int n = 0; 6911 int n = 0;
6701 buf_T *buf; 6912 buf_T *buf;
6702 6913
6703 for (buf = firstbuf; buf != NULL; buf = buf->b_next) 6914 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
6704 if (n < buf->b_fnum) 6915 if (n < buf->b_fnum)
6705 n = buf->b_fnum; 6916 n = buf->b_fnum;
6706 6917
6707 retvar->vval.v_number = n; 6918 rettv->vval.v_number = n;
6708 } 6919 }
6709 6920
6710 /* 6921 /*
6711 * "len()" function 6922 * "len()" function
6712 */ 6923 */
6713 static void 6924 static void
6714 f_len(argvars, retvar) 6925 f_len(argvars, rettv)
6715 typeval *argvars; 6926 typeval *argvars;
6716 typeval *retvar; 6927 typeval *rettv;
6717 { 6928 {
6718 switch (argvars[0].v_type) 6929 switch (argvars[0].v_type)
6719 { 6930 {
6720 case VAR_STRING: 6931 case VAR_STRING:
6721 case VAR_NUMBER: 6932 case VAR_NUMBER:
6722 retvar->vval.v_number = (varnumber_T)STRLEN( 6933 rettv->vval.v_number = (varnumber_T)STRLEN(
6723 get_vartv_string(&argvars[0])); 6934 get_tv_string(&argvars[0]));
6724 break; 6935 break;
6725 case VAR_LIST: 6936 case VAR_LIST:
6726 retvar->vval.v_number = list_len(argvars[0].vval.v_list); 6937 rettv->vval.v_number = list_len(argvars[0].vval.v_list);
6727 break; 6938 break;
6728 default: 6939 default:
6729 EMSG(_("E999: Invalid type for len()")); 6940 EMSG(_("E999: Invalid type for len()"));
6730 break; 6941 break;
6731 } 6942 }
6733 6944
6734 /* 6945 /*
6735 * "libcall()" function 6946 * "libcall()" function
6736 */ 6947 */
6737 static void 6948 static void
6738 f_libcall(argvars, retvar) 6949 f_libcall(argvars, rettv)
6739 typeval *argvars; 6950 typeval *argvars;
6740 typeval *retvar; 6951 typeval *rettv;
6741 { 6952 {
6742 libcall_common(argvars, retvar, VAR_STRING); 6953 libcall_common(argvars, rettv, VAR_STRING);
6743 } 6954 }
6744 6955
6745 /* 6956 /*
6746 * "libcallnr()" function 6957 * "libcallnr()" function
6747 */ 6958 */
6748 static void 6959 static void
6749 f_libcallnr(argvars, retvar) 6960 f_libcallnr(argvars, rettv)
6750 typeval *argvars; 6961 typeval *argvars;
6751 typeval *retvar; 6962 typeval *rettv;
6752 { 6963 {
6753 libcall_common(argvars, retvar, VAR_NUMBER); 6964 libcall_common(argvars, rettv, VAR_NUMBER);
6754 } 6965 }
6755 6966
6756 static void 6967 static void
6757 libcall_common(argvars, retvar, type) 6968 libcall_common(argvars, rettv, type)
6758 typeval *argvars; 6969 typeval *argvars;
6759 typeval *retvar; 6970 typeval *rettv;
6760 int type; 6971 int type;
6761 { 6972 {
6762 #ifdef FEAT_LIBCALL 6973 #ifdef FEAT_LIBCALL
6763 char_u *string_in; 6974 char_u *string_in;
6764 char_u **string_result; 6975 char_u **string_result;
6765 int nr_result; 6976 int nr_result;
6766 #endif 6977 #endif
6767 6978
6768 retvar->v_type = type; 6979 rettv->v_type = type;
6769 if (type == VAR_NUMBER) 6980 if (type == VAR_NUMBER)
6770 retvar->vval.v_number = 0; 6981 rettv->vval.v_number = 0;
6771 else 6982 else
6772 retvar->vval.v_string = NULL; 6983 rettv->vval.v_string = NULL;
6773 6984
6774 if (check_restricted() || check_secure()) 6985 if (check_restricted() || check_secure())
6775 return; 6986 return;
6776 6987
6777 #ifdef FEAT_LIBCALL 6988 #ifdef FEAT_LIBCALL
6783 else 6994 else
6784 string_in = argvars[2].vval.v_string; 6995 string_in = argvars[2].vval.v_string;
6785 if (type == VAR_NUMBER) 6996 if (type == VAR_NUMBER)
6786 string_result = NULL; 6997 string_result = NULL;
6787 else 6998 else
6788 string_result = &retvar->vval.v_string; 6999 string_result = &rettv->vval.v_string;
6789 if (mch_libcall(argvars[0].vval.v_string, 7000 if (mch_libcall(argvars[0].vval.v_string,
6790 argvars[1].vval.v_string, 7001 argvars[1].vval.v_string,
6791 string_in, 7002 string_in,
6792 argvars[2].vval.v_number, 7003 argvars[2].vval.v_number,
6793 string_result, 7004 string_result,
6794 &nr_result) == OK 7005 &nr_result) == OK
6795 && type == VAR_NUMBER) 7006 && type == VAR_NUMBER)
6796 retvar->vval.v_number = nr_result; 7007 rettv->vval.v_number = nr_result;
6797 } 7008 }
6798 #endif 7009 #endif
6799 } 7010 }
6800 7011
6801 /* 7012 /*
6802 * "line(string)" function 7013 * "line(string)" function
6803 */ 7014 */
6804 static void 7015 static void
6805 f_line(argvars, retvar) 7016 f_line(argvars, rettv)
6806 typeval *argvars; 7017 typeval *argvars;
6807 typeval *retvar; 7018 typeval *rettv;
6808 { 7019 {
6809 linenr_T lnum = 0; 7020 linenr_T lnum = 0;
6810 pos_T *fp; 7021 pos_T *fp;
6811 7022
6812 fp = var2fpos(&argvars[0], TRUE); 7023 fp = var2fpos(&argvars[0], TRUE);
6813 if (fp != NULL) 7024 if (fp != NULL)
6814 lnum = fp->lnum; 7025 lnum = fp->lnum;
6815 retvar->vval.v_number = lnum; 7026 rettv->vval.v_number = lnum;
6816 } 7027 }
6817 7028
6818 /* 7029 /*
6819 * "line2byte(lnum)" function 7030 * "line2byte(lnum)" function
6820 */ 7031 */
6821 /*ARGSUSED*/ 7032 /*ARGSUSED*/
6822 static void 7033 static void
6823 f_line2byte(argvars, retvar) 7034 f_line2byte(argvars, rettv)
6824 typeval *argvars; 7035 typeval *argvars;
6825 typeval *retvar; 7036 typeval *rettv;
6826 { 7037 {
6827 #ifndef FEAT_BYTEOFF 7038 #ifndef FEAT_BYTEOFF
6828 retvar->vval.v_number = -1; 7039 rettv->vval.v_number = -1;
6829 #else 7040 #else
6830 linenr_T lnum; 7041 linenr_T lnum;
6831 7042
6832 lnum = get_vartv_lnum(argvars); 7043 lnum = get_tv_lnum(argvars);
6833 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1) 7044 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1)
6834 retvar->vval.v_number = -1; 7045 rettv->vval.v_number = -1;
6835 else 7046 else
6836 retvar->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL); 7047 rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL);
6837 if (retvar->vval.v_number >= 0) 7048 if (rettv->vval.v_number >= 0)
6838 ++retvar->vval.v_number; 7049 ++rettv->vval.v_number;
6839 #endif 7050 #endif
6840 } 7051 }
6841 7052
6842 /* 7053 /*
6843 * "lispindent(lnum)" function 7054 * "lispindent(lnum)" function
6844 */ 7055 */
6845 static void 7056 static void
6846 f_lispindent(argvars, retvar) 7057 f_lispindent(argvars, rettv)
6847 typeval *argvars; 7058 typeval *argvars;
6848 typeval *retvar; 7059 typeval *rettv;
6849 { 7060 {
6850 #ifdef FEAT_LISP 7061 #ifdef FEAT_LISP
6851 pos_T pos; 7062 pos_T pos;
6852 linenr_T lnum; 7063 linenr_T lnum;
6853 7064
6854 pos = curwin->w_cursor; 7065 pos = curwin->w_cursor;
6855 lnum = get_vartv_lnum(argvars); 7066 lnum = get_tv_lnum(argvars);
6856 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) 7067 if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
6857 { 7068 {
6858 curwin->w_cursor.lnum = lnum; 7069 curwin->w_cursor.lnum = lnum;
6859 retvar->vval.v_number = get_lisp_indent(); 7070 rettv->vval.v_number = get_lisp_indent();
6860 curwin->w_cursor = pos; 7071 curwin->w_cursor = pos;
6861 } 7072 }
6862 else 7073 else
6863 #endif 7074 #endif
6864 retvar->vval.v_number = -1; 7075 rettv->vval.v_number = -1;
6865 } 7076 }
6866 7077
6867 /* 7078 /*
6868 * "localtime()" function 7079 * "localtime()" function
6869 */ 7080 */
6870 /*ARGSUSED*/ 7081 /*ARGSUSED*/
6871 static void 7082 static void
6872 f_localtime(argvars, retvar) 7083 f_localtime(argvars, rettv)
6873 typeval *argvars; 7084 typeval *argvars;
6874 typeval *retvar; 7085 typeval *rettv;
6875 { 7086 {
6876 retvar->vval.v_number = (varnumber_T)time(NULL); 7087 rettv->vval.v_number = (varnumber_T)time(NULL);
6877 } 7088 }
6878 7089
6879 /* 7090 /*
6880 * "maparg()" function 7091 * "maparg()" function
6881 */ 7092 */
6882 static void 7093 static void
6883 f_maparg(argvars, retvar) 7094 f_maparg(argvars, rettv)
6884 typeval *argvars; 7095 typeval *argvars;
6885 typeval *retvar; 7096 typeval *rettv;
6886 { 7097 {
6887 get_maparg(argvars, retvar, TRUE); 7098 get_maparg(argvars, rettv, TRUE);
6888 } 7099 }
6889 7100
6890 /* 7101 /*
6891 * "mapcheck()" function 7102 * "mapcheck()" function
6892 */ 7103 */
6893 static void 7104 static void
6894 f_mapcheck(argvars, retvar) 7105 f_mapcheck(argvars, rettv)
6895 typeval *argvars; 7106 typeval *argvars;
6896 typeval *retvar; 7107 typeval *rettv;
6897 { 7108 {
6898 get_maparg(argvars, retvar, FALSE); 7109 get_maparg(argvars, rettv, FALSE);
6899 } 7110 }
6900 7111
6901 static void 7112 static void
6902 get_maparg(argvars, retvar, exact) 7113 get_maparg(argvars, rettv, exact)
6903 typeval *argvars; 7114 typeval *argvars;
6904 typeval *retvar; 7115 typeval *rettv;
6905 int exact; 7116 int exact;
6906 { 7117 {
6907 char_u *keys; 7118 char_u *keys;
6908 char_u *which; 7119 char_u *which;
6909 char_u buf[NUMBUFLEN]; 7120 char_u buf[NUMBUFLEN];
6911 char_u *rhs; 7122 char_u *rhs;
6912 int mode; 7123 int mode;
6913 garray_T ga; 7124 garray_T ga;
6914 7125
6915 /* return empty string for failure */ 7126 /* return empty string for failure */
6916 retvar->v_type = VAR_STRING; 7127 rettv->v_type = VAR_STRING;
6917 retvar->vval.v_string = NULL; 7128 rettv->vval.v_string = NULL;
6918 7129
6919 keys = get_vartv_string(&argvars[0]); 7130 keys = get_tv_string(&argvars[0]);
6920 if (*keys == NUL) 7131 if (*keys == NUL)
6921 return; 7132 return;
6922 7133
6923 if (argvars[1].v_type != VAR_UNKNOWN) 7134 if (argvars[1].v_type != VAR_UNKNOWN)
6924 which = get_vartv_string_buf(&argvars[1], buf); 7135 which = get_tv_string_buf(&argvars[1], buf);
6925 else 7136 else
6926 which = (char_u *)""; 7137 which = (char_u *)"";
6927 mode = get_map_mode(&which, 0); 7138 mode = get_map_mode(&which, 0);
6928 7139
6929 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE); 7140 keys = replace_termcodes(keys, &keys_buf, TRUE, TRUE);
6937 7148
6938 while (*rhs != NUL) 7149 while (*rhs != NUL)
6939 ga_concat(&ga, str2special(&rhs, FALSE)); 7150 ga_concat(&ga, str2special(&rhs, FALSE));
6940 7151
6941 ga_append(&ga, NUL); 7152 ga_append(&ga, NUL);
6942 retvar->vval.v_string = (char_u *)ga.ga_data; 7153 rettv->vval.v_string = (char_u *)ga.ga_data;
6943 } 7154 }
6944 } 7155 }
6945 7156
6946 /* 7157 /*
6947 * "match()" function 7158 * "match()" function
6948 */ 7159 */
6949 static void 7160 static void
6950 f_match(argvars, retvar) 7161 f_match(argvars, rettv)
6951 typeval *argvars; 7162 typeval *argvars;
6952 typeval *retvar; 7163 typeval *rettv;
6953 { 7164 {
6954 find_some_match(argvars, retvar, 1); 7165 find_some_match(argvars, rettv, 1);
6955 } 7166 }
6956 7167
6957 /* 7168 /*
6958 * "matchend()" function 7169 * "matchend()" function
6959 */ 7170 */
6960 static void 7171 static void
6961 f_matchend(argvars, retvar) 7172 f_matchend(argvars, rettv)
6962 typeval *argvars; 7173 typeval *argvars;
6963 typeval *retvar; 7174 typeval *rettv;
6964 { 7175 {
6965 find_some_match(argvars, retvar, 0); 7176 find_some_match(argvars, rettv, 0);
6966 } 7177 }
6967 7178
6968 /* 7179 /*
6969 * "matchstr()" function 7180 * "matchstr()" function
6970 */ 7181 */
6971 static void 7182 static void
6972 f_matchstr(argvars, retvar) 7183 f_matchstr(argvars, rettv)
6973 typeval *argvars; 7184 typeval *argvars;
6974 typeval *retvar; 7185 typeval *rettv;
6975 { 7186 {
6976 find_some_match(argvars, retvar, 2); 7187 find_some_match(argvars, rettv, 2);
6977 } 7188 }
6978 7189
6979 static void 7190 static void
6980 find_some_match(argvars, retvar, type) 7191 find_some_match(argvars, rettv, type)
6981 typeval *argvars; 7192 typeval *argvars;
6982 typeval *retvar; 7193 typeval *rettv;
6983 int type; 7194 int type;
6984 { 7195 {
6985 char_u *str; 7196 char_u *str;
6986 char_u *expr; 7197 char_u *expr;
6987 char_u *pat; 7198 char_u *pat;
6994 7205
6995 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */ 7206 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
6996 save_cpo = p_cpo; 7207 save_cpo = p_cpo;
6997 p_cpo = (char_u *)""; 7208 p_cpo = (char_u *)"";
6998 7209
6999 expr = str = get_vartv_string(&argvars[0]); 7210 expr = str = get_tv_string(&argvars[0]);
7000 pat = get_vartv_string_buf(&argvars[1], patbuf); 7211 pat = get_tv_string_buf(&argvars[1], patbuf);
7001 7212
7002 if (type == 2) 7213 if (type == 2)
7003 { 7214 {
7004 retvar->v_type = VAR_STRING; 7215 rettv->v_type = VAR_STRING;
7005 retvar->vval.v_string = NULL; 7216 rettv->vval.v_string = NULL;
7006 } 7217 }
7007 else 7218 else
7008 retvar->vval.v_number = -1; 7219 rettv->vval.v_number = -1;
7009 7220
7010 if (argvars[2].v_type != VAR_UNKNOWN) 7221 if (argvars[2].v_type != VAR_UNKNOWN)
7011 { 7222 {
7012 start = get_vartv_number(&argvars[2]); 7223 start = get_tv_number(&argvars[2]);
7013 if (start < 0) 7224 if (start < 0)
7014 start = 0; 7225 start = 0;
7015 if (start > (long)STRLEN(str)) 7226 if (start > (long)STRLEN(str))
7016 goto theend; 7227 goto theend;
7017 str += start; 7228 str += start;
7018 7229
7019 if (argvars[3].v_type != VAR_UNKNOWN) 7230 if (argvars[3].v_type != VAR_UNKNOWN)
7020 nth = get_vartv_number(&argvars[3]); 7231 nth = get_tv_number(&argvars[3]);
7021 } 7232 }
7022 7233
7023 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); 7234 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
7024 if (regmatch.regprog != NULL) 7235 if (regmatch.regprog != NULL)
7025 { 7236 {
7039 } 7250 }
7040 7251
7041 if (match) 7252 if (match)
7042 { 7253 {
7043 if (type == 2) 7254 if (type == 2)
7044 retvar->vval.v_string = vim_strnsave(regmatch.startp[0], 7255 rettv->vval.v_string = vim_strnsave(regmatch.startp[0],
7045 (int)(regmatch.endp[0] - regmatch.startp[0])); 7256 (int)(regmatch.endp[0] - regmatch.startp[0]));
7046 else 7257 else
7047 { 7258 {
7048 if (type != 0) 7259 if (type != 0)
7049 retvar->vval.v_number = 7260 rettv->vval.v_number =
7050 (varnumber_T)(regmatch.startp[0] - str); 7261 (varnumber_T)(regmatch.startp[0] - str);
7051 else 7262 else
7052 retvar->vval.v_number = 7263 rettv->vval.v_number =
7053 (varnumber_T)(regmatch.endp[0] - str); 7264 (varnumber_T)(regmatch.endp[0] - str);
7054 retvar->vval.v_number += str - expr; 7265 rettv->vval.v_number += str - expr;
7055 } 7266 }
7056 } 7267 }
7057 vim_free(regmatch.regprog); 7268 vim_free(regmatch.regprog);
7058 } 7269 }
7059 7270
7064 /* 7275 /*
7065 * "mode()" function 7276 * "mode()" function
7066 */ 7277 */
7067 /*ARGSUSED*/ 7278 /*ARGSUSED*/
7068 static void 7279 static void
7069 f_mode(argvars, retvar) 7280 f_mode(argvars, rettv)
7070 typeval *argvars; 7281 typeval *argvars;
7071 typeval *retvar; 7282 typeval *rettv;
7072 { 7283 {
7073 char_u buf[2]; 7284 char_u buf[2];
7074 7285
7075 #ifdef FEAT_VISUAL 7286 #ifdef FEAT_VISUAL
7076 if (VIsual_active) 7287 if (VIsual_active)
7095 buf[0] = 'c'; 7306 buf[0] = 'c';
7096 else 7307 else
7097 buf[0] = 'n'; 7308 buf[0] = 'n';
7098 7309
7099 buf[1] = NUL; 7310 buf[1] = NUL;
7100 retvar->vval.v_string = vim_strsave(buf); 7311 rettv->vval.v_string = vim_strsave(buf);
7101 retvar->v_type = VAR_STRING; 7312 rettv->v_type = VAR_STRING;
7102 } 7313 }
7103 7314
7104 /* 7315 /*
7105 * "nr2char()" function 7316 * "nr2char()" function
7106 */ 7317 */
7107 static void 7318 static void
7108 f_nr2char(argvars, retvar) 7319 f_nr2char(argvars, rettv)
7109 typeval *argvars; 7320 typeval *argvars;
7110 typeval *retvar; 7321 typeval *rettv;
7111 { 7322 {
7112 char_u buf[NUMBUFLEN]; 7323 char_u buf[NUMBUFLEN];
7113 7324
7114 #ifdef FEAT_MBYTE 7325 #ifdef FEAT_MBYTE
7115 if (has_mbyte) 7326 if (has_mbyte)
7116 buf[(*mb_char2bytes)((int)get_vartv_number(&argvars[0]), buf)] = NUL; 7327 buf[(*mb_char2bytes)((int)get_tv_number(&argvars[0]), buf)] = NUL;
7117 else 7328 else
7118 #endif 7329 #endif
7119 { 7330 {
7120 buf[0] = (char_u)get_vartv_number(&argvars[0]); 7331 buf[0] = (char_u)get_tv_number(&argvars[0]);
7121 buf[1] = NUL; 7332 buf[1] = NUL;
7122 } 7333 }
7123 retvar->v_type = VAR_STRING; 7334 rettv->v_type = VAR_STRING;
7124 retvar->vval.v_string = vim_strsave(buf); 7335 rettv->vval.v_string = vim_strsave(buf);
7125 } 7336 }
7126 7337
7127 /* 7338 /*
7128 * "remove({list}, {idx})" function 7339 * "remove({list}, {idx})" function
7129 */ 7340 */
7130 static void 7341 static void
7131 f_remove(argvars, retvar) 7342 f_remove(argvars, rettv)
7132 typeval *argvars; 7343 typeval *argvars;
7133 typeval *retvar; 7344 typeval *rettv;
7134 { 7345 {
7135 listvar *l; 7346 listvar *l;
7136 listitem *item; 7347 listitem *item;
7137 long idx; 7348 long idx;
7138 7349
7139 if (argvars[0].v_type != VAR_LIST) 7350 if (argvars[0].v_type != VAR_LIST)
7140 EMSG(_("E999: First argument of remove() must be a list")); 7351 EMSG(_("E999: First argument of remove() must be a list"));
7141 else if ((l = argvars[0].vval.v_list) != NULL) 7352 else if ((l = argvars[0].vval.v_list) != NULL)
7142 { 7353 {
7143 idx = get_vartv_number(&argvars[1]); 7354 idx = get_tv_number(&argvars[1]);
7144 item = list_getrem(l, idx); 7355 item = list_getrem(l, idx);
7145 if (item == NULL) 7356 if (item == NULL)
7146 EMSGN(_(e_listidx), idx); 7357 EMSGN(_(e_listidx), idx);
7147 else 7358 else
7148 { 7359 {
7149 *retvar = item->li_tv; 7360 *rettv = item->li_tv;
7150 vim_free(item); 7361 vim_free(item);
7151 } 7362 }
7152 } 7363 }
7153 } 7364 }
7154 7365
7155 /* 7366 /*
7156 * "rename({from}, {to})" function 7367 * "rename({from}, {to})" function
7157 */ 7368 */
7158 static void 7369 static void
7159 f_rename(argvars, retvar) 7370 f_rename(argvars, rettv)
7160 typeval *argvars; 7371 typeval *argvars;
7161 typeval *retvar; 7372 typeval *rettv;
7162 { 7373 {
7163 char_u buf[NUMBUFLEN]; 7374 char_u buf[NUMBUFLEN];
7164 7375
7165 if (check_restricted() || check_secure()) 7376 if (check_restricted() || check_secure())
7166 retvar->vval.v_number = -1; 7377 rettv->vval.v_number = -1;
7167 else 7378 else
7168 retvar->vval.v_number = vim_rename(get_vartv_string(&argvars[0]), 7379 rettv->vval.v_number = vim_rename(get_tv_string(&argvars[0]),
7169 get_vartv_string_buf(&argvars[1], buf)); 7380 get_tv_string_buf(&argvars[1], buf));
7170 } 7381 }
7171 7382
7172 /* 7383 /*
7173 * "resolve()" function 7384 * "resolve()" function
7174 */ 7385 */
7175 static void 7386 static void
7176 f_resolve(argvars, retvar) 7387 f_resolve(argvars, rettv)
7177 typeval *argvars; 7388 typeval *argvars;
7178 typeval *retvar; 7389 typeval *rettv;
7179 { 7390 {
7180 char_u *p; 7391 char_u *p;
7181 7392
7182 p = get_vartv_string(&argvars[0]); 7393 p = get_tv_string(&argvars[0]);
7183 #ifdef FEAT_SHORTCUT 7394 #ifdef FEAT_SHORTCUT
7184 { 7395 {
7185 char_u *v = NULL; 7396 char_u *v = NULL;
7186 7397
7187 v = mch_resolve_shortcut(p); 7398 v = mch_resolve_shortcut(p);
7188 if (v != NULL) 7399 if (v != NULL)
7189 retvar->vval.v_string = v; 7400 rettv->vval.v_string = v;
7190 else 7401 else
7191 retvar->vval.v_string = vim_strsave(p); 7402 rettv->vval.v_string = vim_strsave(p);
7192 } 7403 }
7193 #else 7404 #else
7194 # ifdef HAVE_READLINK 7405 # ifdef HAVE_READLINK
7195 { 7406 {
7196 char_u buf[MAXPATHL + 1]; 7407 char_u buf[MAXPATHL + 1];
7233 if (limit-- == 0) 7444 if (limit-- == 0)
7234 { 7445 {
7235 vim_free(p); 7446 vim_free(p);
7236 vim_free(remain); 7447 vim_free(remain);
7237 EMSG(_("E655: Too many symbolic links (cycle?)")); 7448 EMSG(_("E655: Too many symbolic links (cycle?)"));
7238 retvar->vval.v_string = NULL; 7449 rettv->vval.v_string = NULL;
7239 goto fail; 7450 goto fail;
7240 } 7451 }
7241 7452
7242 /* Ensure that the result will have a trailing path separator 7453 /* Ensure that the result will have a trailing path separator
7243 * if the argument has one. */ 7454 * if the argument has one. */
7353 q = p + STRLEN(p); 7564 q = p + STRLEN(p);
7354 if (after_pathsep(p, q)) 7565 if (after_pathsep(p, q))
7355 *gettail_sep(p) = NUL; 7566 *gettail_sep(p) = NUL;
7356 } 7567 }
7357 7568
7358 retvar->vval.v_string = p; 7569 rettv->vval.v_string = p;
7359 } 7570 }
7360 # else 7571 # else
7361 retvar->vval.v_string = vim_strsave(p); 7572 rettv->vval.v_string = vim_strsave(p);
7362 # endif 7573 # endif
7363 #endif 7574 #endif
7364 7575
7365 simplify_filename(retvar->vval.v_string); 7576 simplify_filename(rettv->vval.v_string);
7366 7577
7367 #ifdef HAVE_READLINK 7578 #ifdef HAVE_READLINK
7368 fail: 7579 fail:
7369 #endif 7580 #endif
7370 retvar->v_type = VAR_STRING; 7581 rettv->v_type = VAR_STRING;
7371 } 7582 }
7372 7583
7373 /* 7584 /*
7374 * "simplify()" function 7585 * "simplify()" function
7375 */ 7586 */
7376 static void 7587 static void
7377 f_simplify(argvars, retvar) 7588 f_simplify(argvars, rettv)
7378 typeval *argvars; 7589 typeval *argvars;
7379 typeval *retvar; 7590 typeval *rettv;
7380 { 7591 {
7381 char_u *p; 7592 char_u *p;
7382 7593
7383 p = get_vartv_string(&argvars[0]); 7594 p = get_tv_string(&argvars[0]);
7384 retvar->vval.v_string = vim_strsave(p); 7595 rettv->vval.v_string = vim_strsave(p);
7385 simplify_filename(retvar->vval.v_string); /* simplify in place */ 7596 simplify_filename(rettv->vval.v_string); /* simplify in place */
7386 retvar->v_type = VAR_STRING; 7597 rettv->v_type = VAR_STRING;
7387 } 7598 }
7388 7599
7389 #define SP_NOMOVE 1 /* don't move cursor */ 7600 #define SP_NOMOVE 1 /* don't move cursor */
7390 #define SP_REPEAT 2 /* repeat to find outer pair */ 7601 #define SP_REPEAT 2 /* repeat to find outer pair */
7391 #define SP_RETCOUNT 4 /* return matchcount */ 7602 #define SP_RETCOUNT 4 /* return matchcount */
7392 7603
7393 /* 7604 /*
7394 * "search()" function 7605 * "search()" function
7395 */ 7606 */
7396 static void 7607 static void
7397 f_search(argvars, retvar) 7608 f_search(argvars, rettv)
7398 typeval *argvars; 7609 typeval *argvars;
7399 typeval *retvar; 7610 typeval *rettv;
7400 { 7611 {
7401 char_u *pat; 7612 char_u *pat;
7402 pos_T pos; 7613 pos_T pos;
7403 pos_T save_cursor; 7614 pos_T save_cursor;
7404 int save_p_ws = p_ws; 7615 int save_p_ws = p_ws;
7405 int dir; 7616 int dir;
7406 int flags = 0; 7617 int flags = 0;
7407 7618
7408 retvar->vval.v_number = 0; /* default: FAIL */ 7619 rettv->vval.v_number = 0; /* default: FAIL */
7409 7620
7410 pat = get_vartv_string(&argvars[0]); 7621 pat = get_tv_string(&argvars[0]);
7411 dir = get_search_arg(&argvars[1], &flags); /* may set p_ws */ 7622 dir = get_search_arg(&argvars[1], &flags); /* may set p_ws */
7412 if (dir == 0) 7623 if (dir == 0)
7413 goto theend; 7624 goto theend;
7414 if ((flags & ~SP_NOMOVE) != 0) 7625 if ((flags & ~SP_NOMOVE) != 0)
7415 { 7626 {
7416 EMSG2(_(e_invarg2), get_vartv_string(&argvars[1])); 7627 EMSG2(_(e_invarg2), get_tv_string(&argvars[1]));
7417 goto theend; 7628 goto theend;
7418 } 7629 }
7419 7630
7420 pos = save_cursor = curwin->w_cursor; 7631 pos = save_cursor = curwin->w_cursor;
7421 if (searchit(curwin, curbuf, &pos, dir, pat, 1L, 7632 if (searchit(curwin, curbuf, &pos, dir, pat, 1L,
7422 SEARCH_KEEP, RE_SEARCH) != FAIL) 7633 SEARCH_KEEP, RE_SEARCH) != FAIL)
7423 { 7634 {
7424 retvar->vval.v_number = pos.lnum; 7635 rettv->vval.v_number = pos.lnum;
7425 curwin->w_cursor = pos; 7636 curwin->w_cursor = pos;
7426 /* "/$" will put the cursor after the end of the line, may need to 7637 /* "/$" will put the cursor after the end of the line, may need to
7427 * correct that here */ 7638 * correct that here */
7428 check_cursor(); 7639 check_cursor();
7429 } 7640 }
7437 7648
7438 /* 7649 /*
7439 * "searchpair()" function 7650 * "searchpair()" function
7440 */ 7651 */
7441 static void 7652 static void
7442 f_searchpair(argvars, retvar) 7653 f_searchpair(argvars, rettv)
7443 typeval *argvars; 7654 typeval *argvars;
7444 typeval *retvar; 7655 typeval *rettv;
7445 { 7656 {
7446 char_u *spat, *mpat, *epat; 7657 char_u *spat, *mpat, *epat;
7447 char_u *skip; 7658 char_u *skip;
7448 char_u *pat, *pat2, *pat3; 7659 char_u *pat, *pat2, *pat3;
7449 pos_T pos; 7660 pos_T pos;
7460 int n; 7671 int n;
7461 int r; 7672 int r;
7462 int nest = 1; 7673 int nest = 1;
7463 int err; 7674 int err;
7464 7675
7465 retvar->vval.v_number = 0; /* default: FAIL */ 7676 rettv->vval.v_number = 0; /* default: FAIL */
7466 7677
7467 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */ 7678 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
7468 save_cpo = p_cpo; 7679 save_cpo = p_cpo;
7469 p_cpo = (char_u *)""; 7680 p_cpo = (char_u *)"";
7470 7681
7471 /* Get the three pattern arguments: start, middle, end. */ 7682 /* Get the three pattern arguments: start, middle, end. */
7472 spat = get_vartv_string(&argvars[0]); 7683 spat = get_tv_string(&argvars[0]);
7473 mpat = get_vartv_string_buf(&argvars[1], nbuf1); 7684 mpat = get_tv_string_buf(&argvars[1], nbuf1);
7474 epat = get_vartv_string_buf(&argvars[2], nbuf2); 7685 epat = get_tv_string_buf(&argvars[2], nbuf2);
7475 7686
7476 /* Make two search patterns: start/end (pat2, for in nested pairs) and 7687 /* Make two search patterns: start/end (pat2, for in nested pairs) and
7477 * start/middle/end (pat3, for the top pair). */ 7688 * start/middle/end (pat3, for the top pair). */
7478 pat2 = alloc((unsigned)(STRLEN(spat) + STRLEN(epat) + 15)); 7689 pat2 = alloc((unsigned)(STRLEN(spat) + STRLEN(epat) + 15));
7479 pat3 = alloc((unsigned)(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 23)); 7690 pat3 = alloc((unsigned)(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 23));
7494 /* Optional fifth argument: skip expresion */ 7705 /* Optional fifth argument: skip expresion */
7495 if (argvars[3].v_type == VAR_UNKNOWN 7706 if (argvars[3].v_type == VAR_UNKNOWN
7496 || argvars[4].v_type == VAR_UNKNOWN) 7707 || argvars[4].v_type == VAR_UNKNOWN)
7497 skip = (char_u *)""; 7708 skip = (char_u *)"";
7498 else 7709 else
7499 skip = get_vartv_string_buf(&argvars[4], nbuf3); 7710 skip = get_tv_string_buf(&argvars[4], nbuf3);
7500 7711
7501 save_cursor = curwin->w_cursor; 7712 save_cursor = curwin->w_cursor;
7502 pos = curwin->w_cursor; 7713 pos = curwin->w_cursor;
7503 firstpos.lnum = 0; 7714 firstpos.lnum = 0;
7504 pat = pat3; 7715 pat = pat3;
7522 curwin->w_cursor = save_pos; 7733 curwin->w_cursor = save_pos;
7523 if (err) 7734 if (err)
7524 { 7735 {
7525 /* Evaluating {skip} caused an error, break here. */ 7736 /* Evaluating {skip} caused an error, break here. */
7526 curwin->w_cursor = save_cursor; 7737 curwin->w_cursor = save_cursor;
7527 retvar->vval.v_number = -1; 7738 rettv->vval.v_number = -1;
7528 break; 7739 break;
7529 } 7740 }
7530 if (r) 7741 if (r)
7531 continue; 7742 continue;
7532 } 7743 }
7548 7759
7549 if (nest == 0) 7760 if (nest == 0)
7550 { 7761 {
7551 /* Found the match: return matchcount or line number. */ 7762 /* Found the match: return matchcount or line number. */
7552 if (flags & SP_RETCOUNT) 7763 if (flags & SP_RETCOUNT)
7553 ++retvar->vval.v_number; 7764 ++rettv->vval.v_number;
7554 else 7765 else
7555 retvar->vval.v_number = pos.lnum; 7766 rettv->vval.v_number = pos.lnum;
7556 curwin->w_cursor = pos; 7767 curwin->w_cursor = pos;
7557 if (!(flags & SP_REPEAT)) 7768 if (!(flags & SP_REPEAT))
7558 break; 7769 break;
7559 nest = 1; /* search for next unmatched */ 7770 nest = 1; /* search for next unmatched */
7560 } 7771 }
7561 } 7772 }
7562 7773
7563 /* If 'n' flag is used or search failed: restore cursor position. */ 7774 /* If 'n' flag is used or search failed: restore cursor position. */
7564 if ((flags & SP_NOMOVE) || retvar->vval.v_number == 0) 7775 if ((flags & SP_NOMOVE) || rettv->vval.v_number == 0)
7565 curwin->w_cursor = save_cursor; 7776 curwin->w_cursor = save_cursor;
7566 7777
7567 theend: 7778 theend:
7568 vim_free(pat2); 7779 vim_free(pat2);
7569 vim_free(pat3); 7780 vim_free(pat3);
7586 char_u nbuf[NUMBUFLEN]; 7797 char_u nbuf[NUMBUFLEN];
7587 int mask; 7798 int mask;
7588 7799
7589 if (varp->v_type != VAR_UNKNOWN) 7800 if (varp->v_type != VAR_UNKNOWN)
7590 { 7801 {
7591 flags = get_vartv_string_buf(varp, nbuf); 7802 flags = get_tv_string_buf(varp, nbuf);
7592 while (*flags != NUL) 7803 while (*flags != NUL)
7593 { 7804 {
7594 switch (*flags) 7805 switch (*flags)
7595 { 7806 {
7596 case 'b': dir = BACKWARD; break; 7807 case 'b': dir = BACKWARD; break;
7623 /* 7834 /*
7624 * "setbufvar()" function 7835 * "setbufvar()" function
7625 */ 7836 */
7626 /*ARGSUSED*/ 7837 /*ARGSUSED*/
7627 static void 7838 static void
7628 f_setbufvar(argvars, retvar) 7839 f_setbufvar(argvars, rettv)
7629 typeval *argvars; 7840 typeval *argvars;
7630 typeval *retvar; 7841 typeval *rettv;
7631 { 7842 {
7632 buf_T *buf; 7843 buf_T *buf;
7633 #ifdef FEAT_AUTOCMD 7844 #ifdef FEAT_AUTOCMD
7634 aco_save_T aco; 7845 aco_save_T aco;
7635 #else 7846 #else
7640 char_u nbuf[NUMBUFLEN]; 7851 char_u nbuf[NUMBUFLEN];
7641 7852
7642 if (check_restricted() || check_secure()) 7853 if (check_restricted() || check_secure())
7643 return; 7854 return;
7644 ++emsg_off; 7855 ++emsg_off;
7645 buf = get_buf_vartv(&argvars[0]); 7856 buf = get_buf_tv(&argvars[0]);
7646 varname = get_vartv_string(&argvars[1]); 7857 varname = get_tv_string(&argvars[1]);
7647 varp = &argvars[2]; 7858 varp = &argvars[2];
7648 7859
7649 if (buf != NULL && varname != NULL && varp != NULL) 7860 if (buf != NULL && varname != NULL && varp != NULL)
7650 { 7861 {
7651 /* set curbuf to be our buf, temporarily */ 7862 /* set curbuf to be our buf, temporarily */
7657 #endif 7868 #endif
7658 7869
7659 if (*varname == '&') 7870 if (*varname == '&')
7660 { 7871 {
7661 ++varname; 7872 ++varname;
7662 set_option_value(varname, get_vartv_number(varp), 7873 set_option_value(varname, get_tv_number(varp),
7663 get_vartv_string_buf(varp, nbuf), OPT_LOCAL); 7874 get_tv_string_buf(varp, nbuf), OPT_LOCAL);
7664 } 7875 }
7665 else 7876 else
7666 { 7877 {
7667 bufvarname = alloc((unsigned)STRLEN(varname) + 3); 7878 bufvarname = alloc((unsigned)STRLEN(varname) + 3);
7668 if (bufvarname != NULL) 7879 if (bufvarname != NULL)
7686 7897
7687 /* 7898 /*
7688 * "setcmdpos()" function 7899 * "setcmdpos()" function
7689 */ 7900 */
7690 static void 7901 static void
7691 f_setcmdpos(argvars, retvar) 7902 f_setcmdpos(argvars, rettv)
7692 typeval *argvars; 7903 typeval *argvars;
7693 typeval *retvar; 7904 typeval *rettv;
7694 { 7905 {
7695 retvar->vval.v_number = set_cmdline_pos( 7906 rettv->vval.v_number = set_cmdline_pos(
7696 (int)get_vartv_number(&argvars[0]) - 1); 7907 (int)get_tv_number(&argvars[0]) - 1);
7697 } 7908 }
7698 7909
7699 /* 7910 /*
7700 * "setline()" function 7911 * "setline()" function
7701 */ 7912 */
7702 static void 7913 static void
7703 f_setline(argvars, retvar) 7914 f_setline(argvars, rettv)
7704 typeval *argvars; 7915 typeval *argvars;
7705 typeval *retvar; 7916 typeval *rettv;
7706 { 7917 {
7707 linenr_T lnum; 7918 linenr_T lnum;
7708 char_u *line; 7919 char_u *line;
7709 7920
7710 lnum = get_vartv_lnum(argvars); 7921 lnum = get_tv_lnum(argvars);
7711 line = get_vartv_string(&argvars[1]); 7922 line = get_tv_string(&argvars[1]);
7712 retvar->vval.v_number = 1; /* FAIL is default */ 7923 rettv->vval.v_number = 1; /* FAIL is default */
7713 7924
7714 if (lnum >= 1 7925 if (lnum >= 1
7715 && lnum <= curbuf->b_ml.ml_line_count 7926 && lnum <= curbuf->b_ml.ml_line_count
7716 && u_savesub(lnum) == OK 7927 && u_savesub(lnum) == OK
7717 && ml_replace(lnum, line, TRUE) == OK) 7928 && ml_replace(lnum, line, TRUE) == OK)
7718 { 7929 {
7719 changed_bytes(lnum, 0); 7930 changed_bytes(lnum, 0);
7720 check_cursor_col(); 7931 check_cursor_col();
7721 retvar->vval.v_number = 0; 7932 rettv->vval.v_number = 0;
7722 } 7933 }
7723 } 7934 }
7724 7935
7725 /* 7936 /*
7726 * "setreg()" function 7937 * "setreg()" function
7727 */ 7938 */
7728 static void 7939 static void
7729 f_setreg(argvars, retvar) 7940 f_setreg(argvars, rettv)
7730 typeval *argvars; 7941 typeval *argvars;
7731 typeval *retvar; 7942 typeval *rettv;
7732 { 7943 {
7733 int regname; 7944 int regname;
7734 char_u *strregname; 7945 char_u *strregname;
7735 char_u *stropt; 7946 char_u *stropt;
7736 int append; 7947 int append;
7739 7950
7740 block_len = -1; 7951 block_len = -1;
7741 yank_type = MAUTO; 7952 yank_type = MAUTO;
7742 append = FALSE; 7953 append = FALSE;
7743 7954
7744 strregname = get_vartv_string(argvars); 7955 strregname = get_tv_string(argvars);
7745 retvar->vval.v_number = 1; /* FAIL is default */ 7956 rettv->vval.v_number = 1; /* FAIL is default */
7746 7957
7747 regname = (strregname == NULL ? '"' : *strregname); 7958 regname = (strregname == NULL ? '"' : *strregname);
7748 if (regname == 0 || regname == '@') 7959 if (regname == 0 || regname == '@')
7749 regname = '"'; 7960 regname = '"';
7750 else if (regname == '=') 7961 else if (regname == '=')
7751 return; 7962 return;
7752 7963
7753 if (argvars[2].v_type != VAR_UNKNOWN) 7964 if (argvars[2].v_type != VAR_UNKNOWN)
7754 { 7965 {
7755 for (stropt = get_vartv_string(&argvars[2]); *stropt != NUL; ++stropt) 7966 for (stropt = get_tv_string(&argvars[2]); *stropt != NUL; ++stropt)
7756 switch (*stropt) 7967 switch (*stropt)
7757 { 7968 {
7758 case 'a': case 'A': /* append */ 7969 case 'a': case 'A': /* append */
7759 append = TRUE; 7970 append = TRUE;
7760 break; 7971 break;
7776 break; 7987 break;
7777 #endif 7988 #endif
7778 } 7989 }
7779 } 7990 }
7780 7991
7781 write_reg_contents_ex(regname, get_vartv_string(&argvars[1]), -1, 7992 write_reg_contents_ex(regname, get_tv_string(&argvars[1]), -1,
7782 append, yank_type, block_len); 7993 append, yank_type, block_len);
7783 retvar->vval.v_number = 0; 7994 rettv->vval.v_number = 0;
7784 } 7995 }
7785 7996
7786 7997
7787 /* 7998 /*
7788 * "setwinvar(expr)" function 7999 * "setwinvar(expr)" function
7789 */ 8000 */
7790 /*ARGSUSED*/ 8001 /*ARGSUSED*/
7791 static void 8002 static void
7792 f_setwinvar(argvars, retvar) 8003 f_setwinvar(argvars, rettv)
7793 typeval *argvars; 8004 typeval *argvars;
7794 typeval *retvar; 8005 typeval *rettv;
7795 { 8006 {
7796 win_T *win; 8007 win_T *win;
7797 #ifdef FEAT_WINDOWS 8008 #ifdef FEAT_WINDOWS
7798 win_T *save_curwin; 8009 win_T *save_curwin;
7799 #endif 8010 #endif
7803 8014
7804 if (check_restricted() || check_secure()) 8015 if (check_restricted() || check_secure())
7805 return; 8016 return;
7806 ++emsg_off; 8017 ++emsg_off;
7807 win = find_win_by_nr(&argvars[0]); 8018 win = find_win_by_nr(&argvars[0]);
7808 varname = get_vartv_string(&argvars[1]); 8019 varname = get_tv_string(&argvars[1]);
7809 varp = &argvars[2]; 8020 varp = &argvars[2];
7810 8021
7811 if (win != NULL && varname != NULL && varp != NULL) 8022 if (win != NULL && varname != NULL && varp != NULL)
7812 { 8023 {
7813 #ifdef FEAT_WINDOWS 8024 #ifdef FEAT_WINDOWS
7818 #endif 8029 #endif
7819 8030
7820 if (*varname == '&') 8031 if (*varname == '&')
7821 { 8032 {
7822 ++varname; 8033 ++varname;
7823 set_option_value(varname, get_vartv_number(varp), 8034 set_option_value(varname, get_tv_number(varp),
7824 get_vartv_string_buf(varp, nbuf), OPT_LOCAL); 8035 get_tv_string_buf(varp, nbuf), OPT_LOCAL);
7825 } 8036 }
7826 else 8037 else
7827 { 8038 {
7828 winvarname = alloc((unsigned)STRLEN(varname) + 3); 8039 winvarname = alloc((unsigned)STRLEN(varname) + 3);
7829 if (winvarname != NULL) 8040 if (winvarname != NULL)
7850 8061
7851 /* 8062 /*
7852 * "nextnonblank()" function 8063 * "nextnonblank()" function
7853 */ 8064 */
7854 static void 8065 static void
7855 f_nextnonblank(argvars, retvar) 8066 f_nextnonblank(argvars, rettv)
7856 typeval *argvars; 8067 typeval *argvars;
7857 typeval *retvar; 8068 typeval *rettv;
7858 { 8069 {
7859 linenr_T lnum; 8070 linenr_T lnum;
7860 8071
7861 for (lnum = get_vartv_lnum(argvars); ; ++lnum) 8072 for (lnum = get_tv_lnum(argvars); ; ++lnum)
7862 { 8073 {
7863 if (lnum > curbuf->b_ml.ml_line_count) 8074 if (lnum > curbuf->b_ml.ml_line_count)
7864 { 8075 {
7865 lnum = 0; 8076 lnum = 0;
7866 break; 8077 break;
7867 } 8078 }
7868 if (*skipwhite(ml_get(lnum)) != NUL) 8079 if (*skipwhite(ml_get(lnum)) != NUL)
7869 break; 8080 break;
7870 } 8081 }
7871 retvar->vval.v_number = lnum; 8082 rettv->vval.v_number = lnum;
7872 } 8083 }
7873 8084
7874 /* 8085 /*
7875 * "prevnonblank()" function 8086 * "prevnonblank()" function
7876 */ 8087 */
7877 static void 8088 static void
7878 f_prevnonblank(argvars, retvar) 8089 f_prevnonblank(argvars, rettv)
7879 typeval *argvars; 8090 typeval *argvars;
7880 typeval *retvar; 8091 typeval *rettv;
7881 { 8092 {
7882 linenr_T lnum; 8093 linenr_T lnum;
7883 8094
7884 lnum = get_vartv_lnum(argvars); 8095 lnum = get_tv_lnum(argvars);
7885 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) 8096 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
7886 lnum = 0; 8097 lnum = 0;
7887 else 8098 else
7888 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL) 8099 while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL)
7889 --lnum; 8100 --lnum;
7890 retvar->vval.v_number = lnum; 8101 rettv->vval.v_number = lnum;
7891 } 8102 }
7892 8103
7893 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11) 8104 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
7894 static void make_connection __ARGS((void)); 8105 static void make_connection __ARGS((void));
7895 static int check_connection __ARGS((void)); 8106 static int check_connection __ARGS((void));
7922 } 8133 }
7923 #endif 8134 #endif
7924 8135
7925 /*ARGSUSED*/ 8136 /*ARGSUSED*/
7926 static void 8137 static void
7927 f_serverlist(argvars, retvar) 8138 f_serverlist(argvars, rettv)
7928 typeval *argvars; 8139 typeval *argvars;
7929 typeval *retvar; 8140 typeval *rettv;
7930 { 8141 {
7931 char_u *r = NULL; 8142 char_u *r = NULL;
7932 8143
7933 #ifdef FEAT_CLIENTSERVER 8144 #ifdef FEAT_CLIENTSERVER
7934 # ifdef WIN32 8145 # ifdef WIN32
7937 make_connection(); 8148 make_connection();
7938 if (X_DISPLAY != NULL) 8149 if (X_DISPLAY != NULL)
7939 r = serverGetVimNames(X_DISPLAY); 8150 r = serverGetVimNames(X_DISPLAY);
7940 # endif 8151 # endif
7941 #endif 8152 #endif
7942 retvar->v_type = VAR_STRING; 8153 rettv->v_type = VAR_STRING;
7943 retvar->vval.v_string = r; 8154 rettv->vval.v_string = r;
7944 } 8155 }
7945 8156
7946 /*ARGSUSED*/ 8157 /*ARGSUSED*/
7947 static void 8158 static void
7948 f_remote_peek(argvars, retvar) 8159 f_remote_peek(argvars, rettv)
7949 typeval *argvars; 8160 typeval *argvars;
7950 typeval *retvar; 8161 typeval *rettv;
7951 { 8162 {
7952 #ifdef FEAT_CLIENTSERVER 8163 #ifdef FEAT_CLIENTSERVER
7953 var v; 8164 var v;
7954 char_u *s = NULL; 8165 char_u *s = NULL;
7955 # ifdef WIN32 8166 # ifdef WIN32
7956 int n = 0; 8167 int n = 0;
7957 # endif 8168 # endif
7958 8169
7959 if (check_restricted() || check_secure()) 8170 if (check_restricted() || check_secure())
7960 { 8171 {
7961 retvar->vval.v_number = -1; 8172 rettv->vval.v_number = -1;
7962 return; 8173 return;
7963 } 8174 }
7964 # ifdef WIN32 8175 # ifdef WIN32
7965 sscanf(get_vartv_string(&argvars[0]), "%x", &n); 8176 sscanf(get_tv_string(&argvars[0]), "%x", &n);
7966 if (n == 0) 8177 if (n == 0)
7967 retvar->vval.v_number = -1; 8178 rettv->vval.v_number = -1;
7968 else 8179 else
7969 { 8180 {
7970 s = serverGetReply((HWND)n, FALSE, FALSE, FALSE); 8181 s = serverGetReply((HWND)n, FALSE, FALSE, FALSE);
7971 retvar->vval.v_number = (s != NULL); 8182 rettv->vval.v_number = (s != NULL);
7972 } 8183 }
7973 # else 8184 # else
7974 retvar->vval.v_number = 0; 8185 rettv->vval.v_number = 0;
7975 if (check_connection() == FAIL) 8186 if (check_connection() == FAIL)
7976 return; 8187 return;
7977 8188
7978 retvar->vval.v_number = serverPeekReply(X_DISPLAY, 8189 rettv->vval.v_number = serverPeekReply(X_DISPLAY,
7979 serverStrToWin(get_vartv_string(&argvars[0])), &s); 8190 serverStrToWin(get_tv_string(&argvars[0])), &s);
7980 # endif 8191 # endif
7981 8192
7982 if (argvars[1].v_type != VAR_UNKNOWN && retvar->vval.v_number > 0) 8193 if (argvars[1].v_type != VAR_UNKNOWN && rettv->vval.v_number > 0)
7983 { 8194 {
7984 v.tv.v_type = VAR_STRING; 8195 v.tv.v_type = VAR_STRING;
7985 v.tv.vval.v_string = vim_strsave(s); 8196 v.tv.vval.v_string = vim_strsave(s);
7986 set_var(get_vartv_string(&argvars[1]), &v.tv, FALSE); 8197 set_var(get_tv_string(&argvars[1]), &v.tv, FALSE);
7987 vim_free(v.tv.vval.v_string); 8198 vim_free(v.tv.vval.v_string);
7988 } 8199 }
7989 #else 8200 #else
7990 retvar->vval.v_number = -1; 8201 rettv->vval.v_number = -1;
7991 #endif 8202 #endif
7992 } 8203 }
7993 8204
7994 /*ARGSUSED*/ 8205 /*ARGSUSED*/
7995 static void 8206 static void
7996 f_remote_read(argvars, retvar) 8207 f_remote_read(argvars, rettv)
7997 typeval *argvars; 8208 typeval *argvars;
7998 typeval *retvar; 8209 typeval *rettv;
7999 { 8210 {
8000 char_u *r = NULL; 8211 char_u *r = NULL;
8001 8212
8002 #ifdef FEAT_CLIENTSERVER 8213 #ifdef FEAT_CLIENTSERVER
8003 if (!check_restricted() && !check_secure()) 8214 if (!check_restricted() && !check_secure())
8004 { 8215 {
8005 # ifdef WIN32 8216 # ifdef WIN32
8006 /* The server's HWND is encoded in the 'id' parameter */ 8217 /* The server's HWND is encoded in the 'id' parameter */
8007 int n = 0; 8218 int n = 0;
8008 8219
8009 sscanf(get_vartv_string(&argvars[0]), "%x", &n); 8220 sscanf(get_tv_string(&argvars[0]), "%x", &n);
8010 if (n != 0) 8221 if (n != 0)
8011 r = serverGetReply((HWND)n, FALSE, TRUE, TRUE); 8222 r = serverGetReply((HWND)n, FALSE, TRUE, TRUE);
8012 if (r == NULL) 8223 if (r == NULL)
8013 # else 8224 # else
8014 if (check_connection() == FAIL || serverReadReply(X_DISPLAY, 8225 if (check_connection() == FAIL || serverReadReply(X_DISPLAY,
8015 serverStrToWin(get_vartv_string(&argvars[0])), &r, FALSE) < 0) 8226 serverStrToWin(get_tv_string(&argvars[0])), &r, FALSE) < 0)
8016 # endif 8227 # endif
8017 EMSG(_("E277: Unable to read a server reply")); 8228 EMSG(_("E277: Unable to read a server reply"));
8018 } 8229 }
8019 #endif 8230 #endif
8020 retvar->v_type = VAR_STRING; 8231 rettv->v_type = VAR_STRING;
8021 retvar->vval.v_string = r; 8232 rettv->vval.v_string = r;
8022 } 8233 }
8023 8234
8024 /*ARGSUSED*/ 8235 /*ARGSUSED*/
8025 static void 8236 static void
8026 f_server2client(argvars, retvar) 8237 f_server2client(argvars, rettv)
8027 typeval *argvars; 8238 typeval *argvars;
8028 typeval *retvar; 8239 typeval *rettv;
8029 { 8240 {
8030 #ifdef FEAT_CLIENTSERVER 8241 #ifdef FEAT_CLIENTSERVER
8031 char_u buf[NUMBUFLEN]; 8242 char_u buf[NUMBUFLEN];
8032 char_u *server = get_vartv_string(&argvars[0]); 8243 char_u *server = get_tv_string(&argvars[0]);
8033 char_u *reply = get_vartv_string_buf(&argvars[1], buf); 8244 char_u *reply = get_tv_string_buf(&argvars[1], buf);
8034 8245
8035 retvar->vval.v_number = -1; 8246 rettv->vval.v_number = -1;
8036 if (check_restricted() || check_secure()) 8247 if (check_restricted() || check_secure())
8037 return; 8248 return;
8038 # ifdef FEAT_X11 8249 # ifdef FEAT_X11
8039 if (check_connection() == FAIL) 8250 if (check_connection() == FAIL)
8040 return; 8251 return;
8043 if (serverSendReply(server, reply) < 0) 8254 if (serverSendReply(server, reply) < 0)
8044 { 8255 {
8045 EMSG(_("E258: Unable to send to client")); 8256 EMSG(_("E258: Unable to send to client"));
8046 return; 8257 return;
8047 } 8258 }
8048 retvar->vval.v_number = 0; 8259 rettv->vval.v_number = 0;
8049 #else 8260 #else
8050 retvar->vval.v_number = -1; 8261 rettv->vval.v_number = -1;
8051 #endif 8262 #endif
8052 } 8263 }
8053 8264
8054 #ifdef FEAT_CLIENTSERVER 8265 #ifdef FEAT_CLIENTSERVER
8055 static void remote_common __ARGS((typeval *argvars, typeval *retvar, int expr)); 8266 static void remote_common __ARGS((typeval *argvars, typeval *rettv, int expr));
8056 8267
8057 static void 8268 static void
8058 remote_common(argvars, retvar, expr) 8269 remote_common(argvars, rettv, expr)
8059 typeval *argvars; 8270 typeval *argvars;
8060 typeval *retvar; 8271 typeval *rettv;
8061 int expr; 8272 int expr;
8062 { 8273 {
8063 char_u *server_name; 8274 char_u *server_name;
8064 char_u *keys; 8275 char_u *keys;
8065 char_u *r = NULL; 8276 char_u *r = NULL;
8076 # ifdef FEAT_X11 8287 # ifdef FEAT_X11
8077 if (check_connection() == FAIL) 8288 if (check_connection() == FAIL)
8078 return; 8289 return;
8079 # endif 8290 # endif
8080 8291
8081 server_name = get_vartv_string(&argvars[0]); 8292 server_name = get_tv_string(&argvars[0]);
8082 keys = get_vartv_string_buf(&argvars[1], buf); 8293 keys = get_tv_string_buf(&argvars[1], buf);
8083 # ifdef WIN32 8294 # ifdef WIN32
8084 if (serverSendToVim(server_name, keys, &r, &w, expr, TRUE) < 0) 8295 if (serverSendToVim(server_name, keys, &r, &w, expr, TRUE) < 0)
8085 # else 8296 # else
8086 if (serverSendToVim(X_DISPLAY, server_name, keys, &r, &w, expr, 0, TRUE) 8297 if (serverSendToVim(X_DISPLAY, server_name, keys, &r, &w, expr, 0, TRUE)
8087 < 0) 8298 < 0)
8092 else 8303 else
8093 EMSG2(_("E241: Unable to send to %s"), server_name); 8304 EMSG2(_("E241: Unable to send to %s"), server_name);
8094 return; 8305 return;
8095 } 8306 }
8096 8307
8097 retvar->vval.v_string = r; 8308 rettv->vval.v_string = r;
8098 8309
8099 if (argvars[2].v_type != VAR_UNKNOWN) 8310 if (argvars[2].v_type != VAR_UNKNOWN)
8100 { 8311 {
8101 var v; 8312 var v;
8102 char_u str[30]; 8313 char_u str[30];
8103 8314
8104 sprintf((char *)str, "0x%x", (unsigned int)w); 8315 sprintf((char *)str, "0x%x", (unsigned int)w);
8105 v.tv.v_type = VAR_STRING; 8316 v.tv.v_type = VAR_STRING;
8106 v.tv.vval.v_string = vim_strsave(str); 8317 v.tv.vval.v_string = vim_strsave(str);
8107 set_var(get_vartv_string(&argvars[2]), &v.tv, FALSE); 8318 set_var(get_tv_string(&argvars[2]), &v.tv, FALSE);
8108 vim_free(v.tv.vval.v_string); 8319 vim_free(v.tv.vval.v_string);
8109 } 8320 }
8110 } 8321 }
8111 #endif 8322 #endif
8112 8323
8113 /* 8324 /*
8114 * "remote_expr()" function 8325 * "remote_expr()" function
8115 */ 8326 */
8116 /*ARGSUSED*/ 8327 /*ARGSUSED*/
8117 static void 8328 static void
8118 f_remote_expr(argvars, retvar) 8329 f_remote_expr(argvars, rettv)
8119 typeval *argvars; 8330 typeval *argvars;
8120 typeval *retvar; 8331 typeval *rettv;
8121 { 8332 {
8122 retvar->v_type = VAR_STRING; 8333 rettv->v_type = VAR_STRING;
8123 retvar->vval.v_string = NULL; 8334 rettv->vval.v_string = NULL;
8124 #ifdef FEAT_CLIENTSERVER 8335 #ifdef FEAT_CLIENTSERVER
8125 remote_common(argvars, retvar, TRUE); 8336 remote_common(argvars, rettv, TRUE);
8126 #endif 8337 #endif
8127 } 8338 }
8128 8339
8129 /* 8340 /*
8130 * "remote_send()" function 8341 * "remote_send()" function
8131 */ 8342 */
8132 /*ARGSUSED*/ 8343 /*ARGSUSED*/
8133 static void 8344 static void
8134 f_remote_send(argvars, retvar) 8345 f_remote_send(argvars, rettv)
8135 typeval *argvars; 8346 typeval *argvars;
8136 typeval *retvar; 8347 typeval *rettv;
8137 { 8348 {
8138 retvar->v_type = VAR_STRING; 8349 rettv->v_type = VAR_STRING;
8139 retvar->vval.v_string = NULL; 8350 rettv->vval.v_string = NULL;
8140 #ifdef FEAT_CLIENTSERVER 8351 #ifdef FEAT_CLIENTSERVER
8141 remote_common(argvars, retvar, FALSE); 8352 remote_common(argvars, rettv, FALSE);
8142 #endif 8353 #endif
8143 } 8354 }
8144 8355
8145 /* 8356 /*
8146 * "remote_foreground()" function 8357 * "remote_foreground()" function
8147 */ 8358 */
8148 /*ARGSUSED*/ 8359 /*ARGSUSED*/
8149 static void 8360 static void
8150 f_remote_foreground(argvars, retvar) 8361 f_remote_foreground(argvars, rettv)
8151 typeval *argvars; 8362 typeval *argvars;
8152 typeval *retvar; 8363 typeval *rettv;
8153 { 8364 {
8154 retvar->vval.v_number = 0; 8365 rettv->vval.v_number = 0;
8155 #ifdef FEAT_CLIENTSERVER 8366 #ifdef FEAT_CLIENTSERVER
8156 # ifdef WIN32 8367 # ifdef WIN32
8157 /* On Win32 it's done in this application. */ 8368 /* On Win32 it's done in this application. */
8158 serverForeground(get_vartv_string(&argvars[0])); 8369 serverForeground(get_tv_string(&argvars[0]));
8159 # else 8370 # else
8160 /* Send a foreground() expression to the server. */ 8371 /* Send a foreground() expression to the server. */
8161 argvars[1].v_type = VAR_STRING; 8372 argvars[1].v_type = VAR_STRING;
8162 argvars[1].vval.v_string = vim_strsave((char_u *)"foreground()"); 8373 argvars[1].vval.v_string = vim_strsave((char_u *)"foreground()");
8163 argvars[2].v_type = VAR_UNKNOWN; 8374 argvars[2].v_type = VAR_UNKNOWN;
8164 remote_common(argvars, retvar, TRUE); 8375 remote_common(argvars, rettv, TRUE);
8165 vim_free(argvars[1].vval.v_string); 8376 vim_free(argvars[1].vval.v_string);
8166 # endif 8377 # endif
8167 #endif 8378 #endif
8168 } 8379 }
8169 8380
8170 /* 8381 /*
8171 * "repeat()" function 8382 * "repeat()" function
8172 */ 8383 */
8173 /*ARGSUSED*/ 8384 /*ARGSUSED*/
8174 static void 8385 static void
8175 f_repeat(argvars, retvar) 8386 f_repeat(argvars, rettv)
8176 typeval *argvars; 8387 typeval *argvars;
8177 typeval *retvar; 8388 typeval *rettv;
8178 { 8389 {
8179 char_u *p; 8390 char_u *p;
8180 int n; 8391 int n;
8181 int slen; 8392 int slen;
8182 int len; 8393 int len;
8183 char_u *r; 8394 char_u *r;
8184 int i; 8395 int i;
8185 8396
8186 p = get_vartv_string(&argvars[0]); 8397 p = get_tv_string(&argvars[0]);
8187 n = get_vartv_number(&argvars[1]); 8398 n = get_tv_number(&argvars[1]);
8188 8399
8189 retvar->v_type = VAR_STRING; 8400 rettv->v_type = VAR_STRING;
8190 retvar->vval.v_string = NULL; 8401 rettv->vval.v_string = NULL;
8191 8402
8192 slen = (int)STRLEN(p); 8403 slen = (int)STRLEN(p);
8193 len = slen * n; 8404 len = slen * n;
8194 8405
8195 if (len <= 0) 8406 if (len <= 0)
8201 for (i = 0; i < n; i++) 8412 for (i = 0; i < n; i++)
8202 mch_memmove(r + i * slen, p, (size_t)slen); 8413 mch_memmove(r + i * slen, p, (size_t)slen);
8203 r[len] = NUL; 8414 r[len] = NUL;
8204 } 8415 }
8205 8416
8206 retvar->vval.v_string = r; 8417 rettv->vval.v_string = r;
8207 } 8418 }
8208 8419
8209 #ifdef HAVE_STRFTIME 8420 #ifdef HAVE_STRFTIME
8210 /* 8421 /*
8211 * "strftime({format}[, {time}])" function 8422 * "strftime({format}[, {time}])" function
8212 */ 8423 */
8213 static void 8424 static void
8214 f_strftime(argvars, retvar) 8425 f_strftime(argvars, rettv)
8215 typeval *argvars; 8426 typeval *argvars;
8216 typeval *retvar; 8427 typeval *rettv;
8217 { 8428 {
8218 char_u result_buf[256]; 8429 char_u result_buf[256];
8219 struct tm *curtime; 8430 struct tm *curtime;
8220 time_t seconds; 8431 time_t seconds;
8221 char_u *p; 8432 char_u *p;
8222 8433
8223 retvar->v_type = VAR_STRING; 8434 rettv->v_type = VAR_STRING;
8224 8435
8225 p = get_vartv_string(&argvars[0]); 8436 p = get_tv_string(&argvars[0]);
8226 if (argvars[1].v_type == VAR_UNKNOWN) 8437 if (argvars[1].v_type == VAR_UNKNOWN)
8227 seconds = time(NULL); 8438 seconds = time(NULL);
8228 else 8439 else
8229 seconds = (time_t)get_vartv_number(&argvars[1]); 8440 seconds = (time_t)get_tv_number(&argvars[1]);
8230 curtime = localtime(&seconds); 8441 curtime = localtime(&seconds);
8231 /* MSVC returns NULL for an invalid value of seconds. */ 8442 /* MSVC returns NULL for an invalid value of seconds. */
8232 if (curtime == NULL) 8443 if (curtime == NULL)
8233 retvar->vval.v_string = vim_strsave((char_u *)_("(Invalid)")); 8444 rettv->vval.v_string = vim_strsave((char_u *)_("(Invalid)"));
8234 else 8445 else
8235 { 8446 {
8236 # ifdef FEAT_MBYTE 8447 # ifdef FEAT_MBYTE
8237 vimconv_T conv; 8448 vimconv_T conv;
8238 char_u *enc; 8449 char_u *enc;
8252 # ifdef FEAT_MBYTE 8463 # ifdef FEAT_MBYTE
8253 if (conv.vc_type != CONV_NONE) 8464 if (conv.vc_type != CONV_NONE)
8254 vim_free(p); 8465 vim_free(p);
8255 convert_setup(&conv, enc, p_enc); 8466 convert_setup(&conv, enc, p_enc);
8256 if (conv.vc_type != CONV_NONE) 8467 if (conv.vc_type != CONV_NONE)
8257 retvar->vval.v_string = string_convert(&conv, result_buf, NULL); 8468 rettv->vval.v_string = string_convert(&conv, result_buf, NULL);
8258 else 8469 else
8259 # endif 8470 # endif
8260 retvar->vval.v_string = vim_strsave(result_buf); 8471 rettv->vval.v_string = vim_strsave(result_buf);
8261 8472
8262 # ifdef FEAT_MBYTE 8473 # ifdef FEAT_MBYTE
8263 /* Release conversion descriptors */ 8474 /* Release conversion descriptors */
8264 convert_setup(&conv, NULL, NULL); 8475 convert_setup(&conv, NULL, NULL);
8265 vim_free(enc); 8476 vim_free(enc);
8270 8481
8271 /* 8482 /*
8272 * "stridx()" function 8483 * "stridx()" function
8273 */ 8484 */
8274 static void 8485 static void
8275 f_stridx(argvars, retvar) 8486 f_stridx(argvars, rettv)
8276 typeval *argvars; 8487 typeval *argvars;
8277 typeval *retvar; 8488 typeval *rettv;
8278 { 8489 {
8279 char_u buf[NUMBUFLEN]; 8490 char_u buf[NUMBUFLEN];
8280 char_u *needle; 8491 char_u *needle;
8281 char_u *haystack; 8492 char_u *haystack;
8282 char_u *pos; 8493 char_u *pos;
8283 8494
8284 needle = get_vartv_string(&argvars[1]); 8495 needle = get_tv_string(&argvars[1]);
8285 haystack = get_vartv_string_buf(&argvars[0], buf); 8496 haystack = get_tv_string_buf(&argvars[0], buf);
8286 pos = (char_u *)strstr((char *)haystack, (char *)needle); 8497 pos = (char_u *)strstr((char *)haystack, (char *)needle);
8287 8498
8288 if (pos == NULL) 8499 if (pos == NULL)
8289 retvar->vval.v_number = -1; 8500 rettv->vval.v_number = -1;
8290 else 8501 else
8291 retvar->vval.v_number = (varnumber_T) (pos - haystack); 8502 rettv->vval.v_number = (varnumber_T) (pos - haystack);
8292 } 8503 }
8293 8504
8294 /* 8505 /*
8295 * "strridx()" function 8506 * "strridx()" function
8296 */ 8507 */
8297 static void 8508 static void
8298 f_strridx(argvars, retvar) 8509 f_strridx(argvars, rettv)
8299 typeval *argvars; 8510 typeval *argvars;
8300 typeval *retvar; 8511 typeval *rettv;
8301 { 8512 {
8302 char_u buf[NUMBUFLEN]; 8513 char_u buf[NUMBUFLEN];
8303 char_u *needle; 8514 char_u *needle;
8304 char_u *haystack; 8515 char_u *haystack;
8305 char_u *rest; 8516 char_u *rest;
8306 char_u *lastmatch = NULL; 8517 char_u *lastmatch = NULL;
8307 8518
8308 needle = get_vartv_string(&argvars[1]); 8519 needle = get_tv_string(&argvars[1]);
8309 haystack = get_vartv_string_buf(&argvars[0], buf); 8520 haystack = get_tv_string_buf(&argvars[0], buf);
8310 if (*needle == NUL) 8521 if (*needle == NUL)
8311 /* Empty string matches past the end. */ 8522 /* Empty string matches past the end. */
8312 lastmatch = haystack + STRLEN(haystack); 8523 lastmatch = haystack + STRLEN(haystack);
8313 else 8524 else
8314 for (rest = haystack; *rest != '\0'; ++rest) 8525 for (rest = haystack; *rest != '\0'; ++rest)
8318 break; 8529 break;
8319 lastmatch = rest; 8530 lastmatch = rest;
8320 } 8531 }
8321 8532
8322 if (lastmatch == NULL) 8533 if (lastmatch == NULL)
8323 retvar->vval.v_number = -1; 8534 rettv->vval.v_number = -1;
8324 else 8535 else
8325 retvar->vval.v_number = (varnumber_T)(lastmatch - haystack); 8536 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
8326 } 8537 }
8327 8538
8328 /* 8539 /*
8329 * "string()" function 8540 * "string()" function
8330 */ 8541 */
8331 static void 8542 static void
8332 f_string(argvars, retvar) 8543 f_string(argvars, rettv)
8333 typeval *argvars; 8544 typeval *argvars;
8334 typeval *retvar; 8545 typeval *rettv;
8335 { 8546 {
8336 char_u *tofree; 8547 char_u *tofree;
8337 8548
8338 retvar->v_type = VAR_STRING; 8549 rettv->v_type = VAR_STRING;
8339 retvar->vval.v_string = tv2string(&argvars[0], &tofree); 8550 rettv->vval.v_string = tv2string(&argvars[0], &tofree);
8340 if (tofree == NULL) 8551 if (tofree == NULL)
8341 retvar->vval.v_string = vim_strsave(retvar->vval.v_string); 8552 rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
8342 } 8553 }
8343 8554
8344 /* 8555 /*
8345 * "strlen()" function 8556 * "strlen()" function
8346 */ 8557 */
8347 static void 8558 static void
8348 f_strlen(argvars, retvar) 8559 f_strlen(argvars, rettv)
8349 typeval *argvars; 8560 typeval *argvars;
8350 typeval *retvar; 8561 typeval *rettv;
8351 { 8562 {
8352 retvar->vval.v_number = (varnumber_T)(STRLEN( 8563 rettv->vval.v_number = (varnumber_T)(STRLEN(
8353 get_vartv_string(&argvars[0]))); 8564 get_tv_string(&argvars[0])));
8354 } 8565 }
8355 8566
8356 /* 8567 /*
8357 * "strpart()" function 8568 * "strpart()" function
8358 */ 8569 */
8359 static void 8570 static void
8360 f_strpart(argvars, retvar) 8571 f_strpart(argvars, rettv)
8361 typeval *argvars; 8572 typeval *argvars;
8362 typeval *retvar; 8573 typeval *rettv;
8363 { 8574 {
8364 char_u *p; 8575 char_u *p;
8365 int n; 8576 int n;
8366 int len; 8577 int len;
8367 int slen; 8578 int slen;
8368 8579
8369 p = get_vartv_string(&argvars[0]); 8580 p = get_tv_string(&argvars[0]);
8370 slen = (int)STRLEN(p); 8581 slen = (int)STRLEN(p);
8371 8582
8372 n = get_vartv_number(&argvars[1]); 8583 n = get_tv_number(&argvars[1]);
8373 if (argvars[2].v_type != VAR_UNKNOWN) 8584 if (argvars[2].v_type != VAR_UNKNOWN)
8374 len = get_vartv_number(&argvars[2]); 8585 len = get_tv_number(&argvars[2]);
8375 else 8586 else
8376 len = slen - n; /* default len: all bytes that are available. */ 8587 len = slen - n; /* default len: all bytes that are available. */
8377 8588
8378 /* 8589 /*
8379 * Only return the overlap between the specified part and the actual 8590 * Only return the overlap between the specified part and the actual
8389 if (len < 0) 8600 if (len < 0)
8390 len = 0; 8601 len = 0;
8391 else if (n + len > slen) 8602 else if (n + len > slen)
8392 len = slen - n; 8603 len = slen - n;
8393 8604
8394 retvar->v_type = VAR_STRING; 8605 rettv->v_type = VAR_STRING;
8395 retvar->vval.v_string = vim_strnsave(p + n, len); 8606 rettv->vval.v_string = vim_strnsave(p + n, len);
8396 } 8607 }
8397 8608
8398 /* 8609 /*
8399 * "strtrans()" function 8610 * "strtrans()" function
8400 */ 8611 */
8401 static void 8612 static void
8402 f_strtrans(argvars, retvar) 8613 f_strtrans(argvars, rettv)
8403 typeval *argvars; 8614 typeval *argvars;
8404 typeval *retvar; 8615 typeval *rettv;
8405 { 8616 {
8406 retvar->v_type = VAR_STRING; 8617 rettv->v_type = VAR_STRING;
8407 retvar->vval.v_string = transstr(get_vartv_string(&argvars[0])); 8618 rettv->vval.v_string = transstr(get_tv_string(&argvars[0]));
8408 } 8619 }
8409 8620
8410 /* 8621 /*
8411 * "synID(line, col, trans)" function 8622 * "synID(line, col, trans)" function
8412 */ 8623 */
8413 /*ARGSUSED*/ 8624 /*ARGSUSED*/
8414 static void 8625 static void
8415 f_synID(argvars, retvar) 8626 f_synID(argvars, rettv)
8416 typeval *argvars; 8627 typeval *argvars;
8417 typeval *retvar; 8628 typeval *rettv;
8418 { 8629 {
8419 int id = 0; 8630 int id = 0;
8420 #ifdef FEAT_SYN_HL 8631 #ifdef FEAT_SYN_HL
8421 long line; 8632 long line;
8422 long col; 8633 long col;
8423 int trans; 8634 int trans;
8424 8635
8425 line = get_vartv_lnum(argvars); 8636 line = get_tv_lnum(argvars);
8426 col = get_vartv_number(&argvars[1]) - 1; 8637 col = get_tv_number(&argvars[1]) - 1;
8427 trans = get_vartv_number(&argvars[2]); 8638 trans = get_tv_number(&argvars[2]);
8428 8639
8429 if (line >= 1 && line <= curbuf->b_ml.ml_line_count 8640 if (line >= 1 && line <= curbuf->b_ml.ml_line_count
8430 && col >= 0 && col < (long)STRLEN(ml_get(line))) 8641 && col >= 0 && col < (long)STRLEN(ml_get(line)))
8431 id = syn_get_id(line, col, trans); 8642 id = syn_get_id(line, col, trans);
8432 #endif 8643 #endif
8433 8644
8434 retvar->vval.v_number = id; 8645 rettv->vval.v_number = id;
8435 } 8646 }
8436 8647
8437 /* 8648 /*
8438 * "synIDattr(id, what [, mode])" function 8649 * "synIDattr(id, what [, mode])" function
8439 */ 8650 */
8440 /*ARGSUSED*/ 8651 /*ARGSUSED*/
8441 static void 8652 static void
8442 f_synIDattr(argvars, retvar) 8653 f_synIDattr(argvars, rettv)
8443 typeval *argvars; 8654 typeval *argvars;
8444 typeval *retvar; 8655 typeval *rettv;
8445 { 8656 {
8446 char_u *p = NULL; 8657 char_u *p = NULL;
8447 #ifdef FEAT_SYN_HL 8658 #ifdef FEAT_SYN_HL
8448 int id; 8659 int id;
8449 char_u *what; 8660 char_u *what;
8450 char_u *mode; 8661 char_u *mode;
8451 char_u modebuf[NUMBUFLEN]; 8662 char_u modebuf[NUMBUFLEN];
8452 int modec; 8663 int modec;
8453 8664
8454 id = get_vartv_number(&argvars[0]); 8665 id = get_tv_number(&argvars[0]);
8455 what = get_vartv_string(&argvars[1]); 8666 what = get_tv_string(&argvars[1]);
8456 if (argvars[2].v_type != VAR_UNKNOWN) 8667 if (argvars[2].v_type != VAR_UNKNOWN)
8457 { 8668 {
8458 mode = get_vartv_string_buf(&argvars[2], modebuf); 8669 mode = get_tv_string_buf(&argvars[2], modebuf);
8459 modec = TOLOWER_ASC(mode[0]); 8670 modec = TOLOWER_ASC(mode[0]);
8460 if (modec != 't' && modec != 'c' 8671 if (modec != 't' && modec != 'c'
8461 #ifdef FEAT_GUI 8672 #ifdef FEAT_GUI
8462 && modec != 'g' 8673 && modec != 'g'
8463 #endif 8674 #endif
8516 } 8727 }
8517 8728
8518 if (p != NULL) 8729 if (p != NULL)
8519 p = vim_strsave(p); 8730 p = vim_strsave(p);
8520 #endif 8731 #endif
8521 retvar->v_type = VAR_STRING; 8732 rettv->v_type = VAR_STRING;
8522 retvar->vval.v_string = p; 8733 rettv->vval.v_string = p;
8523 } 8734 }
8524 8735
8525 /* 8736 /*
8526 * "synIDtrans(id)" function 8737 * "synIDtrans(id)" function
8527 */ 8738 */
8528 /*ARGSUSED*/ 8739 /*ARGSUSED*/
8529 static void 8740 static void
8530 f_synIDtrans(argvars, retvar) 8741 f_synIDtrans(argvars, rettv)
8531 typeval *argvars; 8742 typeval *argvars;
8532 typeval *retvar; 8743 typeval *rettv;
8533 { 8744 {
8534 int id; 8745 int id;
8535 8746
8536 #ifdef FEAT_SYN_HL 8747 #ifdef FEAT_SYN_HL
8537 id = get_vartv_number(&argvars[0]); 8748 id = get_tv_number(&argvars[0]);
8538 8749
8539 if (id > 0) 8750 if (id > 0)
8540 id = syn_get_final_id(id); 8751 id = syn_get_final_id(id);
8541 else 8752 else
8542 #endif 8753 #endif
8543 id = 0; 8754 id = 0;
8544 8755
8545 retvar->vval.v_number = id; 8756 rettv->vval.v_number = id;
8546 } 8757 }
8547 8758
8548 /* 8759 /*
8549 * "system()" function 8760 * "system()" function
8550 */ 8761 */
8551 static void 8762 static void
8552 f_system(argvars, retvar) 8763 f_system(argvars, rettv)
8553 typeval *argvars; 8764 typeval *argvars;
8554 typeval *retvar; 8765 typeval *rettv;
8555 { 8766 {
8556 char_u *res = NULL; 8767 char_u *res = NULL;
8557 char_u *p; 8768 char_u *p;
8558 char_u *infile = NULL; 8769 char_u *infile = NULL;
8559 char_u buf[NUMBUFLEN]; 8770 char_u buf[NUMBUFLEN];
8576 if (fd == NULL) 8787 if (fd == NULL)
8577 { 8788 {
8578 EMSG2(_(e_notopen), infile); 8789 EMSG2(_(e_notopen), infile);
8579 goto done; 8790 goto done;
8580 } 8791 }
8581 p = get_vartv_string_buf(&argvars[1], buf); 8792 p = get_tv_string_buf(&argvars[1], buf);
8582 if (fwrite(p, STRLEN(p), 1, fd) != 1) 8793 if (fwrite(p, STRLEN(p), 1, fd) != 1)
8583 err = TRUE; 8794 err = TRUE;
8584 if (fclose(fd) != 0) 8795 if (fclose(fd) != 0)
8585 err = TRUE; 8796 err = TRUE;
8586 if (err) 8797 if (err)
8588 EMSG(_("E677: Error writing temp file")); 8799 EMSG(_("E677: Error writing temp file"));
8589 goto done; 8800 goto done;
8590 } 8801 }
8591 } 8802 }
8592 8803
8593 res = get_cmd_output(get_vartv_string(&argvars[0]), infile, SHELL_SILENT); 8804 res = get_cmd_output(get_tv_string(&argvars[0]), infile, SHELL_SILENT);
8594 8805
8595 #ifdef USE_CR 8806 #ifdef USE_CR
8596 /* translate <CR> into <NL> */ 8807 /* translate <CR> into <NL> */
8597 if (res != NULL) 8808 if (res != NULL)
8598 { 8809 {
8627 if (infile != NULL) 8838 if (infile != NULL)
8628 { 8839 {
8629 mch_remove(infile); 8840 mch_remove(infile);
8630 vim_free(infile); 8841 vim_free(infile);
8631 } 8842 }
8632 retvar->v_type = VAR_STRING; 8843 rettv->v_type = VAR_STRING;
8633 retvar->vval.v_string = res; 8844 rettv->vval.v_string = res;
8634 } 8845 }
8635 8846
8636 /* 8847 /*
8637 * "submatch()" function 8848 * "submatch()" function
8638 */ 8849 */
8639 static void 8850 static void
8640 f_submatch(argvars, retvar) 8851 f_submatch(argvars, rettv)
8641 typeval *argvars; 8852 typeval *argvars;
8642 typeval *retvar; 8853 typeval *rettv;
8643 { 8854 {
8644 retvar->v_type = VAR_STRING; 8855 rettv->v_type = VAR_STRING;
8645 retvar->vval.v_string = reg_submatch((int)get_vartv_number(&argvars[0])); 8856 rettv->vval.v_string = reg_submatch((int)get_tv_number(&argvars[0]));
8646 } 8857 }
8647 8858
8648 /* 8859 /*
8649 * "substitute()" function 8860 * "substitute()" function
8650 */ 8861 */
8651 static void 8862 static void
8652 f_substitute(argvars, retvar) 8863 f_substitute(argvars, rettv)
8653 typeval *argvars; 8864 typeval *argvars;
8654 typeval *retvar; 8865 typeval *rettv;
8655 { 8866 {
8656 char_u patbuf[NUMBUFLEN]; 8867 char_u patbuf[NUMBUFLEN];
8657 char_u subbuf[NUMBUFLEN]; 8868 char_u subbuf[NUMBUFLEN];
8658 char_u flagsbuf[NUMBUFLEN]; 8869 char_u flagsbuf[NUMBUFLEN];
8659 8870
8660 retvar->v_type = VAR_STRING; 8871 rettv->v_type = VAR_STRING;
8661 retvar->vval.v_string = do_string_sub( 8872 rettv->vval.v_string = do_string_sub(
8662 get_vartv_string(&argvars[0]), 8873 get_tv_string(&argvars[0]),
8663 get_vartv_string_buf(&argvars[1], patbuf), 8874 get_tv_string_buf(&argvars[1], patbuf),
8664 get_vartv_string_buf(&argvars[2], subbuf), 8875 get_tv_string_buf(&argvars[2], subbuf),
8665 get_vartv_string_buf(&argvars[3], flagsbuf)); 8876 get_tv_string_buf(&argvars[3], flagsbuf));
8666 } 8877 }
8667 8878
8668 /* 8879 /*
8669 * "tempname()" function 8880 * "tempname()" function
8670 */ 8881 */
8671 /*ARGSUSED*/ 8882 /*ARGSUSED*/
8672 static void 8883 static void
8673 f_tempname(argvars, retvar) 8884 f_tempname(argvars, rettv)
8674 typeval *argvars; 8885 typeval *argvars;
8675 typeval *retvar; 8886 typeval *rettv;
8676 { 8887 {
8677 static int x = 'A'; 8888 static int x = 'A';
8678 8889
8679 retvar->v_type = VAR_STRING; 8890 rettv->v_type = VAR_STRING;
8680 retvar->vval.v_string = vim_tempname(x); 8891 rettv->vval.v_string = vim_tempname(x);
8681 8892
8682 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different 8893 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
8683 * names. Skip 'I' and 'O', they are used for shell redirection. */ 8894 * names. Skip 'I' and 'O', they are used for shell redirection. */
8684 do 8895 do
8685 { 8896 {
8703 8914
8704 /* 8915 /*
8705 * "tolower(string)" function 8916 * "tolower(string)" function
8706 */ 8917 */
8707 static void 8918 static void
8708 f_tolower(argvars, retvar) 8919 f_tolower(argvars, rettv)
8709 typeval *argvars; 8920 typeval *argvars;
8710 typeval *retvar; 8921 typeval *rettv;
8711 { 8922 {
8712 char_u *p; 8923 char_u *p;
8713 8924
8714 p = vim_strsave(get_vartv_string(&argvars[0])); 8925 p = vim_strsave(get_tv_string(&argvars[0]));
8715 retvar->v_type = VAR_STRING; 8926 rettv->v_type = VAR_STRING;
8716 retvar->vval.v_string = p; 8927 rettv->vval.v_string = p;
8717 8928
8718 if (p != NULL) 8929 if (p != NULL)
8719 while (*p != NUL) 8930 while (*p != NUL)
8720 { 8931 {
8721 #ifdef FEAT_MBYTE 8932 #ifdef FEAT_MBYTE
8746 8957
8747 /* 8958 /*
8748 * "toupper(string)" function 8959 * "toupper(string)" function
8749 */ 8960 */
8750 static void 8961 static void
8751 f_toupper(argvars, retvar) 8962 f_toupper(argvars, rettv)
8752 typeval *argvars; 8963 typeval *argvars;
8753 typeval *retvar; 8964 typeval *rettv;
8754 { 8965 {
8755 char_u *p; 8966 char_u *p;
8756 8967
8757 p = vim_strsave(get_vartv_string(&argvars[0])); 8968 p = vim_strsave(get_tv_string(&argvars[0]));
8758 retvar->v_type = VAR_STRING; 8969 rettv->v_type = VAR_STRING;
8759 retvar->vval.v_string = p; 8970 rettv->vval.v_string = p;
8760 8971
8761 if (p != NULL) 8972 if (p != NULL)
8762 while (*p != NUL) 8973 while (*p != NUL)
8763 { 8974 {
8764 #ifdef FEAT_MBYTE 8975 #ifdef FEAT_MBYTE
8789 9000
8790 /* 9001 /*
8791 * "tr(string, fromstr, tostr)" function 9002 * "tr(string, fromstr, tostr)" function
8792 */ 9003 */
8793 static void 9004 static void
8794 f_tr(argvars, retvar) 9005 f_tr(argvars, rettv)
8795 typeval *argvars; 9006 typeval *argvars;
8796 typeval *retvar; 9007 typeval *rettv;
8797 { 9008 {
8798 char_u *instr; 9009 char_u *instr;
8799 char_u *fromstr; 9010 char_u *fromstr;
8800 char_u *tostr; 9011 char_u *tostr;
8801 char_u *p; 9012 char_u *p;
8810 #endif 9021 #endif
8811 char_u buf[NUMBUFLEN]; 9022 char_u buf[NUMBUFLEN];
8812 char_u buf2[NUMBUFLEN]; 9023 char_u buf2[NUMBUFLEN];
8813 garray_T ga; 9024 garray_T ga;
8814 9025
8815 instr = get_vartv_string(&argvars[0]); 9026 instr = get_tv_string(&argvars[0]);
8816 fromstr = get_vartv_string_buf(&argvars[1], buf); 9027 fromstr = get_tv_string_buf(&argvars[1], buf);
8817 tostr = get_vartv_string_buf(&argvars[2], buf2); 9028 tostr = get_tv_string_buf(&argvars[2], buf2);
8818 9029
8819 /* Default return value: empty string. */ 9030 /* Default return value: empty string. */
8820 retvar->v_type = VAR_STRING; 9031 rettv->v_type = VAR_STRING;
8821 retvar->vval.v_string = NULL; 9032 rettv->vval.v_string = NULL;
8822 ga_init2(&ga, (int)sizeof(char), 80); 9033 ga_init2(&ga, (int)sizeof(char), 80);
8823 9034
8824 #ifdef FEAT_MBYTE 9035 #ifdef FEAT_MBYTE
8825 if (!has_mbyte) 9036 if (!has_mbyte)
8826 #endif 9037 #endif
8899 ga_append(&ga, *instr); 9110 ga_append(&ga, *instr);
8900 ++instr; 9111 ++instr;
8901 } 9112 }
8902 } 9113 }
8903 9114
8904 retvar->vval.v_string = ga.ga_data; 9115 rettv->vval.v_string = ga.ga_data;
8905 } 9116 }
8906 9117
8907 /* 9118 /*
8908 * "type(expr)" function 9119 * "type(expr)" function
8909 */ 9120 */
8910 static void 9121 static void
8911 f_type(argvars, retvar) 9122 f_type(argvars, rettv)
8912 typeval *argvars; 9123 typeval *argvars;
8913 typeval *retvar; 9124 typeval *rettv;
8914 { 9125 {
8915 if (argvars[0].v_type == VAR_NUMBER) 9126 if (argvars[0].v_type == VAR_NUMBER)
8916 retvar->vval.v_number = 0; 9127 rettv->vval.v_number = 0;
8917 else 9128 else
8918 retvar->vval.v_number = 1; 9129 rettv->vval.v_number = 1;
8919 } 9130 }
8920 9131
8921 /* 9132 /*
8922 * "virtcol(string)" function 9133 * "virtcol(string)" function
8923 */ 9134 */
8924 static void 9135 static void
8925 f_virtcol(argvars, retvar) 9136 f_virtcol(argvars, rettv)
8926 typeval *argvars; 9137 typeval *argvars;
8927 typeval *retvar; 9138 typeval *rettv;
8928 { 9139 {
8929 colnr_T vcol = 0; 9140 colnr_T vcol = 0;
8930 pos_T *fp; 9141 pos_T *fp;
8931 9142
8932 fp = var2fpos(&argvars[0], FALSE); 9143 fp = var2fpos(&argvars[0], FALSE);
8934 { 9145 {
8935 getvvcol(curwin, fp, NULL, NULL, &vcol); 9146 getvvcol(curwin, fp, NULL, NULL, &vcol);
8936 ++vcol; 9147 ++vcol;
8937 } 9148 }
8938 9149
8939 retvar->vval.v_number = vcol; 9150 rettv->vval.v_number = vcol;
8940 } 9151 }
8941 9152
8942 /* 9153 /*
8943 * "visualmode()" function 9154 * "visualmode()" function
8944 */ 9155 */
8945 /*ARGSUSED*/ 9156 /*ARGSUSED*/
8946 static void 9157 static void
8947 f_visualmode(argvars, retvar) 9158 f_visualmode(argvars, rettv)
8948 typeval *argvars; 9159 typeval *argvars;
8949 typeval *retvar; 9160 typeval *rettv;
8950 { 9161 {
8951 #ifdef FEAT_VISUAL 9162 #ifdef FEAT_VISUAL
8952 char_u str[2]; 9163 char_u str[2];
8953 9164
8954 retvar->v_type = VAR_STRING; 9165 rettv->v_type = VAR_STRING;
8955 str[0] = curbuf->b_visual_mode_eval; 9166 str[0] = curbuf->b_visual_mode_eval;
8956 str[1] = NUL; 9167 str[1] = NUL;
8957 retvar->vval.v_string = vim_strsave(str); 9168 rettv->vval.v_string = vim_strsave(str);
8958 9169
8959 /* A non-zero number or non-empty string argument: reset mode. */ 9170 /* A non-zero number or non-empty string argument: reset mode. */
8960 if ((argvars[0].v_type == VAR_NUMBER 9171 if ((argvars[0].v_type == VAR_NUMBER
8961 && argvars[0].vval.v_number != 0) 9172 && argvars[0].vval.v_number != 0)
8962 || (argvars[0].v_type == VAR_STRING 9173 || (argvars[0].v_type == VAR_STRING
8963 && *get_vartv_string(&argvars[0]) != NUL)) 9174 && *get_tv_string(&argvars[0]) != NUL))
8964 curbuf->b_visual_mode_eval = NUL; 9175 curbuf->b_visual_mode_eval = NUL;
8965 #else 9176 #else
8966 retvar->vval.v_number = 0; /* return anything, it won't work anyway */ 9177 rettv->vval.v_number = 0; /* return anything, it won't work anyway */
8967 #endif 9178 #endif
8968 } 9179 }
8969 9180
8970 /* 9181 /*
8971 * "winbufnr(nr)" function 9182 * "winbufnr(nr)" function
8972 */ 9183 */
8973 static void 9184 static void
8974 f_winbufnr(argvars, retvar) 9185 f_winbufnr(argvars, rettv)
8975 typeval *argvars; 9186 typeval *argvars;
8976 typeval *retvar; 9187 typeval *rettv;
8977 { 9188 {
8978 win_T *wp; 9189 win_T *wp;
8979 9190
8980 wp = find_win_by_nr(&argvars[0]); 9191 wp = find_win_by_nr(&argvars[0]);
8981 if (wp == NULL) 9192 if (wp == NULL)
8982 retvar->vval.v_number = -1; 9193 rettv->vval.v_number = -1;
8983 else 9194 else
8984 retvar->vval.v_number = wp->w_buffer->b_fnum; 9195 rettv->vval.v_number = wp->w_buffer->b_fnum;
8985 } 9196 }
8986 9197
8987 /* 9198 /*
8988 * "wincol()" function 9199 * "wincol()" function
8989 */ 9200 */
8990 /*ARGSUSED*/ 9201 /*ARGSUSED*/
8991 static void 9202 static void
8992 f_wincol(argvars, retvar) 9203 f_wincol(argvars, rettv)
8993 typeval *argvars; 9204 typeval *argvars;
8994 typeval *retvar; 9205 typeval *rettv;
8995 { 9206 {
8996 validate_cursor(); 9207 validate_cursor();
8997 retvar->vval.v_number = curwin->w_wcol + 1; 9208 rettv->vval.v_number = curwin->w_wcol + 1;
8998 } 9209 }
8999 9210
9000 /* 9211 /*
9001 * "winheight(nr)" function 9212 * "winheight(nr)" function
9002 */ 9213 */
9003 static void 9214 static void
9004 f_winheight(argvars, retvar) 9215 f_winheight(argvars, rettv)
9005 typeval *argvars; 9216 typeval *argvars;
9006 typeval *retvar; 9217 typeval *rettv;
9007 { 9218 {
9008 win_T *wp; 9219 win_T *wp;
9009 9220
9010 wp = find_win_by_nr(&argvars[0]); 9221 wp = find_win_by_nr(&argvars[0]);
9011 if (wp == NULL) 9222 if (wp == NULL)
9012 retvar->vval.v_number = -1; 9223 rettv->vval.v_number = -1;
9013 else 9224 else
9014 retvar->vval.v_number = wp->w_height; 9225 rettv->vval.v_number = wp->w_height;
9015 } 9226 }
9016 9227
9017 /* 9228 /*
9018 * "winline()" function 9229 * "winline()" function
9019 */ 9230 */
9020 /*ARGSUSED*/ 9231 /*ARGSUSED*/
9021 static void 9232 static void
9022 f_winline(argvars, retvar) 9233 f_winline(argvars, rettv)
9023 typeval *argvars; 9234 typeval *argvars;
9024 typeval *retvar; 9235 typeval *rettv;
9025 { 9236 {
9026 validate_cursor(); 9237 validate_cursor();
9027 retvar->vval.v_number = curwin->w_wrow + 1; 9238 rettv->vval.v_number = curwin->w_wrow + 1;
9028 } 9239 }
9029 9240
9030 /* 9241 /*
9031 * "winnr()" function 9242 * "winnr()" function
9032 */ 9243 */
9033 /* ARGSUSED */ 9244 /* ARGSUSED */
9034 static void 9245 static void
9035 f_winnr(argvars, retvar) 9246 f_winnr(argvars, rettv)
9036 typeval *argvars; 9247 typeval *argvars;
9037 typeval *retvar; 9248 typeval *rettv;
9038 { 9249 {
9039 int nr = 1; 9250 int nr = 1;
9040 #ifdef FEAT_WINDOWS 9251 #ifdef FEAT_WINDOWS
9041 win_T *wp; 9252 win_T *wp;
9042 win_T *twin = curwin; 9253 win_T *twin = curwin;
9043 char_u *arg; 9254 char_u *arg;
9044 9255
9045 if (argvars[0].v_type != VAR_UNKNOWN) 9256 if (argvars[0].v_type != VAR_UNKNOWN)
9046 { 9257 {
9047 arg = get_vartv_string(&argvars[0]); 9258 arg = get_tv_string(&argvars[0]);
9048 if (STRCMP(arg, "$") == 0) 9259 if (STRCMP(arg, "$") == 0)
9049 twin = lastwin; 9260 twin = lastwin;
9050 else if (STRCMP(arg, "#") == 0) 9261 else if (STRCMP(arg, "#") == 0)
9051 { 9262 {
9052 twin = prevwin; 9263 twin = prevwin;
9062 9273
9063 if (nr > 0) 9274 if (nr > 0)
9064 for (wp = firstwin; wp != twin; wp = wp->w_next) 9275 for (wp = firstwin; wp != twin; wp = wp->w_next)
9065 ++nr; 9276 ++nr;
9066 #endif 9277 #endif
9067 retvar->vval.v_number = nr; 9278 rettv->vval.v_number = nr;
9068 } 9279 }
9069 9280
9070 /* 9281 /*
9071 * "winrestcmd()" function 9282 * "winrestcmd()" function
9072 */ 9283 */
9073 /* ARGSUSED */ 9284 /* ARGSUSED */
9074 static void 9285 static void
9075 f_winrestcmd(argvars, retvar) 9286 f_winrestcmd(argvars, rettv)
9076 typeval *argvars; 9287 typeval *argvars;
9077 typeval *retvar; 9288 typeval *rettv;
9078 { 9289 {
9079 #ifdef FEAT_WINDOWS 9290 #ifdef FEAT_WINDOWS
9080 win_T *wp; 9291 win_T *wp;
9081 int winnr = 1; 9292 int winnr = 1;
9082 garray_T ga; 9293 garray_T ga;
9093 # endif 9304 # endif
9094 ++winnr; 9305 ++winnr;
9095 } 9306 }
9096 ga_append(&ga, NUL); 9307 ga_append(&ga, NUL);
9097 9308
9098 retvar->vval.v_string = ga.ga_data; 9309 rettv->vval.v_string = ga.ga_data;
9099 #else 9310 #else
9100 retvar->vval.v_string = NULL; 9311 rettv->vval.v_string = NULL;
9101 #endif 9312 #endif
9102 retvar->v_type = VAR_STRING; 9313 rettv->v_type = VAR_STRING;
9103 } 9314 }
9104 9315
9105 /* 9316 /*
9106 * "winwidth(nr)" function 9317 * "winwidth(nr)" function
9107 */ 9318 */
9108 static void 9319 static void
9109 f_winwidth(argvars, retvar) 9320 f_winwidth(argvars, rettv)
9110 typeval *argvars; 9321 typeval *argvars;
9111 typeval *retvar; 9322 typeval *rettv;
9112 { 9323 {
9113 win_T *wp; 9324 win_T *wp;
9114 9325
9115 wp = find_win_by_nr(&argvars[0]); 9326 wp = find_win_by_nr(&argvars[0]);
9116 if (wp == NULL) 9327 if (wp == NULL)
9117 retvar->vval.v_number = -1; 9328 rettv->vval.v_number = -1;
9118 else 9329 else
9119 #ifdef FEAT_VERTSPLIT 9330 #ifdef FEAT_VERTSPLIT
9120 retvar->vval.v_number = wp->w_width; 9331 rettv->vval.v_number = wp->w_width;
9121 #else 9332 #else
9122 retvar->vval.v_number = Columns; 9333 rettv->vval.v_number = Columns;
9123 #endif 9334 #endif
9124 } 9335 }
9125 9336
9126 static win_T * 9337 static win_T *
9127 find_win_by_nr(vp) 9338 find_win_by_nr(vp)
9130 #ifdef FEAT_WINDOWS 9341 #ifdef FEAT_WINDOWS
9131 win_T *wp; 9342 win_T *wp;
9132 #endif 9343 #endif
9133 int nr; 9344 int nr;
9134 9345
9135 nr = get_vartv_number(vp); 9346 nr = get_tv_number(vp);
9136 9347
9137 #ifdef FEAT_WINDOWS 9348 #ifdef FEAT_WINDOWS
9138 if (nr == 0) 9349 if (nr == 0)
9139 return curwin; 9350 return curwin;
9140 9351
9159 { 9370 {
9160 char_u *name; 9371 char_u *name;
9161 static pos_T pos; 9372 static pos_T pos;
9162 pos_T *pp; 9373 pos_T *pp;
9163 9374
9164 name = get_vartv_string(varp); 9375 name = get_tv_string(varp);
9165 if (name[0] == '.') /* cursor */ 9376 if (name[0] == '.') /* cursor */
9166 return &curwin->w_cursor; 9377 return &curwin->w_cursor;
9167 if (name[0] == '\'') /* mark */ 9378 if (name[0] == '\'') /* mark */
9168 { 9379 {
9169 pp = getmark(name[1], FALSE); 9380 pp = getmark(name[1], FALSE);
9246 char_u **arg; 9457 char_u **arg;
9247 char_u **alias; 9458 char_u **alias;
9248 int evaluate; 9459 int evaluate;
9249 { 9460 {
9250 int len; 9461 int len;
9251 #ifdef FEAT_MAGIC_BRACES
9252 char_u *p; 9462 char_u *p;
9253 char_u *expr_start; 9463 char_u *expr_start;
9254 char_u *expr_end; 9464 char_u *expr_end;
9255 #endif
9256 9465
9257 *alias = NULL; /* default to no alias */ 9466 *alias = NULL; /* default to no alias */
9258 9467
9259 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA 9468 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA
9260 && (*arg)[2] == (int)KE_SNR) 9469 && (*arg)[2] == (int)KE_SNR)
9268 { 9477 {
9269 /* literal "<SID>", "s:" or "<SNR>" */ 9478 /* literal "<SID>", "s:" or "<SNR>" */
9270 *arg += len; 9479 *arg += len;
9271 } 9480 }
9272 9481
9273 #ifdef FEAT_MAGIC_BRACES
9274 /* 9482 /*
9275 * Find the end of the name; 9483 * Find the end of the name; check for {} construction.
9276 */ 9484 */
9277 p = find_name_end(*arg, &expr_start, &expr_end); 9485 p = find_name_end(*arg, &expr_start, &expr_end, FALSE);
9278 /* check for {} construction */
9279 if (expr_start != NULL) 9486 if (expr_start != NULL)
9280 { 9487 {
9281 char_u *temp_string; 9488 char_u *temp_string;
9282 9489
9283 if (!evaluate) 9490 if (!evaluate)
9296 return 0; 9503 return 0;
9297 *alias = temp_string; 9504 *alias = temp_string;
9298 *arg = skipwhite(p); 9505 *arg = skipwhite(p);
9299 return (int)STRLEN(temp_string); 9506 return (int)STRLEN(temp_string);
9300 } 9507 }
9301 #endif
9302 9508
9303 len += get_id_len(arg); 9509 len += get_id_len(arg);
9304 if (len == 0) 9510 if (len == 0)
9305 EMSG2(_(e_invexpr2), *arg); 9511 EMSG2(_(e_invexpr2), *arg);
9306 9512
9307 return len; 9513 return len;
9308 } 9514 }
9309 9515
9516 /*
9517 * Find the end of a variable or function name, taking care of magic braces.
9518 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
9519 * start and end of the first magic braces item.
9520 * Return a pointer to just after the name. Equal to "arg" if there is no
9521 * valid name.
9522 */
9310 static char_u * 9523 static char_u *
9311 find_name_end(arg, expr_start, expr_end) 9524 find_name_end(arg, expr_start, expr_end, incl_br)
9312 char_u *arg; 9525 char_u *arg;
9313 char_u **expr_start; 9526 char_u **expr_start;
9314 char_u **expr_end; 9527 char_u **expr_end;
9315 { 9528 int incl_br; /* Include [] indexes */
9316 int nesting = 0; 9529 {
9530 int mb_nest = 0;
9531 int br_nest = 0;
9317 char_u *p; 9532 char_u *p;
9318 9533
9319 *expr_start = NULL; 9534 if (expr_start != NULL)
9320 *expr_end = NULL; 9535 {
9321 9536 *expr_start = NULL;
9322 for (p = arg; (*p != NUL && (eval_isnamec(*p) || nesting != 0)); ++p) 9537 *expr_end = NULL;
9323 { 9538 }
9324 #ifdef FEAT_MAGIC_BRACES 9539
9325 if (*p == '{') 9540 for (p = arg; *p != NUL
9326 { 9541 && (eval_isnamec(*p)
9327 nesting++; 9542 || (*p == '[' && incl_br)
9328 if (*expr_start == NULL) 9543 || mb_nest != 0
9329 *expr_start = p; 9544 || br_nest != 0); ++p)
9330 } 9545 {
9331 else if (*p == '}') 9546 if (mb_nest == 0)
9332 { 9547 {
9333 nesting--; 9548 if (*p == '[')
9334 if (nesting == 0 && *expr_end == NULL) 9549 ++br_nest;
9335 *expr_end = p; 9550 else if (*p == ']')
9336 } 9551 --br_nest;
9337 #endif 9552 }
9553 if (br_nest == 0)
9554 {
9555 if (*p == '{')
9556 {
9557 mb_nest++;
9558 if (expr_start != NULL && *expr_start == NULL)
9559 *expr_start = p;
9560 }
9561 else if (*p == '}')
9562 {
9563 mb_nest--;
9564 if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL)
9565 *expr_end = p;
9566 }
9567 }
9338 } 9568 }
9339 9569
9340 return p; 9570 return p;
9341 } 9571 }
9342 9572
9345 */ 9575 */
9346 static int 9576 static int
9347 eval_isnamec(c) 9577 eval_isnamec(c)
9348 int c; 9578 int c;
9349 { 9579 {
9350 return (ASCII_ISALNUM(c) || c == '_' || c == ':' 9580 return (ASCII_ISALNUM(c) || c == '_' || c == ':' || c == '{' || c == '}');
9351 #ifdef FEAT_MAGIC_BRACES
9352 || c == '{' || c == '}'
9353 #endif
9354 );
9355 } 9581 }
9356 9582
9357 /* 9583 /*
9358 * Find a v: variable. 9584 * Find a v: variable.
9359 * Return it's index, or -1 if not found. 9585 * Return it's index, or -1 if not found.
9554 /* 9780 /*
9555 * Get the value of internal variable "name". 9781 * Get the value of internal variable "name".
9556 * Return OK or FAIL. 9782 * Return OK or FAIL.
9557 */ 9783 */
9558 static int 9784 static int
9559 get_var_vartv(name, len, retvar) 9785 get_var_tv(name, len, rettv)
9560 char_u *name; 9786 char_u *name;
9561 int len; /* length of "name" */ 9787 int len; /* length of "name" */
9562 typeval *retvar; /* NULL when only checking existence */ 9788 typeval *rettv; /* NULL when only checking existence */
9563 { 9789 {
9564 int ret = OK; 9790 int ret = OK;
9565 typeval tv; 9791 typeval tv;
9566 VAR v; 9792 VAR v;
9567 int cc; 9793 int cc;
9604 tv = v->tv; 9830 tv = v->tv;
9605 } 9831 }
9606 9832
9607 if (tv.v_type == VAR_UNKNOWN) 9833 if (tv.v_type == VAR_UNKNOWN)
9608 { 9834 {
9609 if (retvar != NULL) 9835 if (rettv != NULL)
9610 EMSG2(_("E121: Undefined variable: %s"), name); 9836 EMSG2(_(e_undefvar), name);
9611 ret = FAIL; 9837 ret = FAIL;
9612 } 9838 }
9613 else if (retvar != NULL) 9839 else if (rettv != NULL)
9614 copy_vartv(&tv, retvar); 9840 copy_tv(&tv, rettv);
9615 9841
9616 name[len] = cc; 9842 name[len] = cc;
9617 9843
9618 return ret; 9844 return ret;
9619 }
9620
9621 /*
9622 * Allocate memory for a variable, and make it emtpy (0 or NULL value).
9623 */
9624 static VAR
9625 alloc_var()
9626 {
9627 return (VAR)alloc_clear((unsigned)sizeof(var));
9628 } 9845 }
9629 9846
9630 /* 9847 /*
9631 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL 9848 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
9632 * value). 9849 * value).
9633 */ 9850 */
9634 static typeval * 9851 static typeval *
9635 alloc_vartv() 9852 alloc_tv()
9636 { 9853 {
9637 return (typeval *)alloc_clear((unsigned)sizeof(typeval)); 9854 return (typeval *)alloc_clear((unsigned)sizeof(typeval));
9638 } 9855 }
9639 9856
9640 /* 9857 /*
9641 * Allocate memory for a variable type-value, and assign a string to it. 9858 * Allocate memory for a variable type-value, and assign a string to it.
9642 * The string "s" must have been allocated, it is consumed. 9859 * The string "s" must have been allocated, it is consumed.
9643 * Return NULL for out of memory, the variable otherwise. 9860 * Return NULL for out of memory, the variable otherwise.
9644 */ 9861 */
9645 static typeval * 9862 static typeval *
9646 alloc_string_vartv(s) 9863 alloc_string_tv(s)
9647 char_u *s; 9864 char_u *s;
9648 { 9865 {
9649 typeval *retvar; 9866 typeval *rettv;
9650 9867
9651 retvar = alloc_vartv(); 9868 rettv = alloc_tv();
9652 if (retvar != NULL) 9869 if (rettv != NULL)
9653 { 9870 {
9654 retvar->v_type = VAR_STRING; 9871 rettv->v_type = VAR_STRING;
9655 retvar->vval.v_string = s; 9872 rettv->vval.v_string = s;
9656 } 9873 }
9657 else 9874 else
9658 vim_free(s); 9875 vim_free(s);
9659 return retvar; 9876 return rettv;
9660 } 9877 }
9661 9878
9662 /* 9879 /*
9663 * Free the memory for a variable type-value. 9880 * Free the memory for a variable type-value.
9664 */ 9881 */
9665 static void 9882 static void
9666 free_vartv(varp) 9883 free_tv(varp)
9667 typeval *varp; 9884 typeval *varp;
9668 { 9885 {
9669 if (varp != NULL) 9886 if (varp != NULL)
9670 { 9887 {
9671 switch (varp->v_type) 9888 switch (varp->v_type)
9686 9903
9687 /* 9904 /*
9688 * Free the memory for a variable value and set the value to NULL or 0. 9905 * Free the memory for a variable value and set the value to NULL or 0.
9689 */ 9906 */
9690 static void 9907 static void
9691 clear_vartv(varp) 9908 clear_tv(varp)
9692 typeval *varp; 9909 typeval *varp;
9693 { 9910 {
9694 if (varp != NULL) 9911 if (varp != NULL)
9695 { 9912 {
9696 switch (varp->v_type) 9913 switch (varp->v_type)
9701 varp->vval.v_string = NULL; 9918 varp->vval.v_string = NULL;
9702 break; 9919 break;
9703 case VAR_LIST: 9920 case VAR_LIST:
9704 list_unref(varp->vval.v_list); 9921 list_unref(varp->vval.v_list);
9705 break; 9922 break;
9706 default: 9923 case VAR_NUMBER:
9707 varp->vval.v_number = 0; 9924 varp->vval.v_number = 0;
9708 break; 9925 break;
9709 } 9926 case VAR_UNKNOWN:
9710 } 9927 break;
9928 default:
9929 EMSG2(_(e_intern2), "clear_tv()");
9930 }
9931 }
9932 }
9933
9934 /*
9935 * Set the value of a variable to NULL without freeing items.
9936 */
9937 static void
9938 init_tv(varp)
9939 typeval *varp;
9940 {
9941 if (varp != NULL)
9942 vim_memset(varp, 0, sizeof(typeval));
9711 } 9943 }
9712 9944
9713 /* 9945 /*
9714 * Get the number value of a variable. 9946 * Get the number value of a variable.
9715 * If it is a String variable, uses vim_str2nr(). 9947 * If it is a String variable, uses vim_str2nr().
9716 */ 9948 */
9717 static long 9949 static long
9718 get_vartv_number(varp) 9950 get_tv_number(varp)
9719 typeval *varp; 9951 typeval *varp;
9720 { 9952 {
9721 long n = 0L; 9953 long n = 0L;
9722 9954
9723 switch (varp->v_type) 9955 switch (varp->v_type)
9741 9973
9742 /* 9974 /*
9743 * Get the lnum from the first argument. Also accepts ".", "$", etc. 9975 * Get the lnum from the first argument. Also accepts ".", "$", etc.
9744 */ 9976 */
9745 static linenr_T 9977 static linenr_T
9746 get_vartv_lnum(argvars) 9978 get_tv_lnum(argvars)
9747 typeval *argvars; 9979 typeval *argvars;
9748 { 9980 {
9749 typeval retvar; 9981 typeval rettv;
9750 linenr_T lnum; 9982 linenr_T lnum;
9751 9983
9752 lnum = get_vartv_number(&argvars[0]); 9984 lnum = get_tv_number(&argvars[0]);
9753 if (lnum == 0) /* no valid number, try using line() */ 9985 if (lnum == 0) /* no valid number, try using line() */
9754 { 9986 {
9755 retvar.v_type = VAR_NUMBER; 9987 rettv.v_type = VAR_NUMBER;
9756 f_line(argvars, &retvar); 9988 f_line(argvars, &rettv);
9757 lnum = retvar.vval.v_number; 9989 lnum = rettv.vval.v_number;
9758 clear_vartv(&retvar); 9990 clear_tv(&rettv);
9759 } 9991 }
9760 return lnum; 9992 return lnum;
9761 } 9993 }
9762 9994
9763 /* 9995 /*
9767 * get_var_string_buf() uses a given buffer. 9999 * get_var_string_buf() uses a given buffer.
9768 * If the String variable has never been set, return an empty string. 10000 * If the String variable has never been set, return an empty string.
9769 * Never returns NULL; 10001 * Never returns NULL;
9770 */ 10002 */
9771 static char_u * 10003 static char_u *
9772 get_vartv_string(varp) 10004 get_tv_string(varp)
9773 typeval *varp; 10005 typeval *varp;
9774 { 10006 {
9775 static char_u mybuf[NUMBUFLEN]; 10007 static char_u mybuf[NUMBUFLEN];
9776 10008
9777 return get_vartv_string_buf(varp, mybuf); 10009 return get_tv_string_buf(varp, mybuf);
9778 } 10010 }
9779 10011
9780 static char_u * 10012 static char_u *
9781 get_vartv_string_buf(varp, buf) 10013 get_tv_string_buf(varp, buf)
9782 typeval *varp; 10014 typeval *varp;
9783 char_u *buf; 10015 char_u *buf;
9784 { 10016 {
9785 switch (varp->v_type) 10017 switch (varp->v_type)
9786 { 10018 {
9796 case VAR_STRING: 10028 case VAR_STRING:
9797 if (varp->vval.v_string != NULL) 10029 if (varp->vval.v_string != NULL)
9798 return varp->vval.v_string; 10030 return varp->vval.v_string;
9799 break; 10031 break;
9800 default: 10032 default:
9801 EMSG(_("E999: Internal error: get_vartv_string_buf()")); 10033 EMSG2(_(e_intern2), "get_tv_string_buf()");
9802 break; 10034 break;
9803 } 10035 }
9804 return (char_u *)""; 10036 return (char_u *)"";
9805 } 10037 }
9806 10038
9969 clear_var(v) 10201 clear_var(v)
9970 VAR v; 10202 VAR v;
9971 { 10203 {
9972 vim_free(v->v_name); 10204 vim_free(v->v_name);
9973 v->v_name = NULL; 10205 v->v_name = NULL;
9974 clear_vartv(&v->tv); 10206 clear_tv(&v->tv);
9975 } 10207 }
9976 10208
9977 /* 10209 /*
9978 * List the value of one internal variable. 10210 * List the value of one internal variable.
9979 */ 10211 */
10044 if (type == VAR_FUNC) 10276 if (type == VAR_FUNC)
10045 msg_puts((char_u *)"()"); 10277 msg_puts((char_u *)"()");
10046 } 10278 }
10047 10279
10048 /* 10280 /*
10049 * Set variable "name" to value in "varp". 10281 * Set variable "name" to value in "tv".
10050 * If the variable already exists, the value is updated. 10282 * If the variable already exists, the value is updated.
10051 * Otherwise the variable is created. 10283 * Otherwise the variable is created.
10052 */ 10284 */
10053 static void 10285 static void
10054 set_var(name, varp, copy) 10286 set_var(name, tv, copy)
10055 char_u *name; 10287 char_u *name;
10056 typeval *varp; 10288 typeval *tv;
10057 int copy; /* make copy of value in "varp" */ 10289 int copy; /* make copy of value in "tv" */
10058 { 10290 {
10059 int i; 10291 int i;
10060 VAR v; 10292 VAR v;
10061 char_u *varname; 10293 char_u *varname;
10062 garray_T *gap; 10294 garray_T *gap;
10074 else 10306 else
10075 { 10307 {
10076 if (vimvars[i].type == VAR_STRING) 10308 if (vimvars[i].type == VAR_STRING)
10077 { 10309 {
10078 vim_free(vimvars[i].val); 10310 vim_free(vimvars[i].val);
10079 if (copy || varp->v_type != VAR_STRING) 10311 if (copy || tv->v_type != VAR_STRING)
10080 vimvars[i].val = vim_strsave(get_vartv_string(varp)); 10312 vimvars[i].val = vim_strsave(get_tv_string(tv));
10081 else 10313 else
10082 { 10314 {
10083 /* Take over the string to avoid an extra alloc/free. */ 10315 /* Take over the string to avoid an extra alloc/free. */
10084 vimvars[i].val = varp->vval.v_string; 10316 vimvars[i].val = tv->vval.v_string;
10085 varp->vval.v_string = NULL; 10317 tv->vval.v_string = NULL;
10086 } 10318 }
10087 } 10319 }
10088 else 10320 else
10089 vimvars[i].val = (char_u *)get_vartv_number(varp); 10321 vimvars[i].val = (char_u *)get_tv_number(tv);
10090 } 10322 }
10091 return; 10323 return;
10092 } 10324 }
10093 10325
10094 if (varp->v_type == VAR_FUNC) 10326 if (tv->v_type == VAR_FUNC)
10095 { 10327 {
10096 if (!(vim_strchr((char_u *)"wbs", name[0]) != NULL && name[1] == ':') 10328 if (!(vim_strchr((char_u *)"wbs", name[0]) != NULL && name[1] == ':')
10097 && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':') 10329 && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':')
10098 ? name[2] : name[0])) 10330 ? name[2] : name[0]))
10099 { 10331 {
10108 } 10340 }
10109 10341
10110 v = find_var(name, TRUE); 10342 v = find_var(name, TRUE);
10111 if (v != NULL) /* existing variable, only need to free string */ 10343 if (v != NULL) /* existing variable, only need to free string */
10112 { 10344 {
10113 if (v->tv.v_type != varp->v_type 10345 if (v->tv.v_type != tv->v_type
10114 && !((v->tv.v_type == VAR_STRING 10346 && !((v->tv.v_type == VAR_STRING
10115 || v->tv.v_type == VAR_NUMBER) 10347 || v->tv.v_type == VAR_NUMBER)
10116 && (varp->v_type == VAR_STRING 10348 && (tv->v_type == VAR_STRING
10117 || varp->v_type == VAR_NUMBER))) 10349 || tv->v_type == VAR_NUMBER)))
10118 { 10350 {
10119 EMSG2(_("E999: Variable type mismatch for: %s"), name); 10351 EMSG2(_("E999: Variable type mismatch for: %s"), name);
10120 return; 10352 return;
10121 } 10353 }
10122 if (v->tv.v_type == VAR_STRING || v->tv.v_type == VAR_FUNC) 10354 clear_tv(&v->tv);
10123 vim_free(v->tv.vval.v_string);
10124 } 10355 }
10125 else /* add a new variable */ 10356 else /* add a new variable */
10126 { 10357 {
10127 gap = find_var_ga(name, &varname); 10358 gap = find_var_ga(name, &varname);
10128 if (gap == NULL) /* illegal name */ 10359 if (gap == NULL) /* illegal name */
10145 if ((v->v_name = vim_strsave(varname)) == NULL) 10376 if ((v->v_name = vim_strsave(varname)) == NULL)
10146 return; 10377 return;
10147 if (i == gap->ga_len) 10378 if (i == gap->ga_len)
10148 ++gap->ga_len; 10379 ++gap->ga_len;
10149 } 10380 }
10150 if (copy || (varp->v_type != VAR_STRING && varp->v_type != VAR_FUNC)) 10381 if (copy || tv->v_type == VAR_NUMBER)
10151 copy_vartv(varp, &v->tv); 10382 copy_tv(tv, &v->tv);
10152 else 10383 else
10153 { 10384 {
10154 v->tv.v_type = varp->v_type; 10385 v->tv = *tv;
10155 v->tv.vval.v_string = varp->vval.v_string; 10386 init_tv(tv);
10156 varp->vval.v_string = NULL;
10157 } 10387 }
10158 } 10388 }
10159 10389
10160 /* 10390 /*
10161 * Copy the values from typeval "from" to typeval "to". 10391 * Copy the values from typeval "from" to typeval "to".
10162 * When needed allocates string or increases reference count. 10392 * When needed allocates string or increases reference count.
10163 * Does not make a copy of a list! 10393 * Does not make a copy of a list!
10164 */ 10394 */
10165 static void 10395 static void
10166 copy_vartv(from, to) 10396 copy_tv(from, to)
10167 typeval *from; 10397 typeval *from;
10168 typeval *to; 10398 typeval *to;
10169 { 10399 {
10170 to->v_type = from->v_type; 10400 to->v_type = from->v_type;
10171 switch (from->v_type) 10401 switch (from->v_type)
10188 to->vval.v_list = from->vval.v_list; 10418 to->vval.v_list = from->vval.v_list;
10189 ++to->vval.v_list->lv_refcount; 10419 ++to->vval.v_list->lv_refcount;
10190 } 10420 }
10191 break; 10421 break;
10192 default: 10422 default:
10193 EMSG(_("E999: Internal error: copy_vartv()")); 10423 EMSG2(_(e_intern2), "copy_tv()");
10194 break; 10424 break;
10195 } 10425 }
10196 } 10426 }
10197 10427
10198 /* 10428 /*
10203 void 10433 void
10204 ex_echo(eap) 10434 ex_echo(eap)
10205 exarg_T *eap; 10435 exarg_T *eap;
10206 { 10436 {
10207 char_u *arg = eap->arg; 10437 char_u *arg = eap->arg;
10208 typeval retvar; 10438 typeval rettv;
10209 char_u *tofree; 10439 char_u *tofree;
10210 char_u *p; 10440 char_u *p;
10211 int needclr = TRUE; 10441 int needclr = TRUE;
10212 int atstart = TRUE; 10442 int atstart = TRUE;
10213 10443
10214 if (eap->skip) 10444 if (eap->skip)
10215 ++emsg_skip; 10445 ++emsg_skip;
10216 while (*arg != NUL && *arg != '|' && *arg != '\n' && !got_int) 10446 while (*arg != NUL && *arg != '|' && *arg != '\n' && !got_int)
10217 { 10447 {
10218 p = arg; 10448 p = arg;
10219 if (eval1(&arg, &retvar, !eap->skip) == FAIL) 10449 if (eval1(&arg, &rettv, !eap->skip) == FAIL)
10220 { 10450 {
10221 /* 10451 /*
10222 * Report the invalid expression unless the expression evaluation 10452 * Report the invalid expression unless the expression evaluation
10223 * has been cancelled due to an aborting error, an interrupt, or an 10453 * has been cancelled due to an aborting error, an interrupt, or an
10224 * exception. 10454 * exception.
10237 if (eap->cmdidx == CMD_echo) 10467 if (eap->cmdidx == CMD_echo)
10238 msg_start(); 10468 msg_start();
10239 } 10469 }
10240 else if (eap->cmdidx == CMD_echo) 10470 else if (eap->cmdidx == CMD_echo)
10241 msg_puts_attr((char_u *)" ", echo_attr); 10471 msg_puts_attr((char_u *)" ", echo_attr);
10242 for (p = tv2string(&retvar, &tofree); *p != NUL && !got_int; ++p) 10472 for (p = tv2string(&rettv, &tofree); *p != NUL && !got_int; ++p)
10243 if (*p == '\n' || *p == '\r' || *p == TAB) 10473 if (*p == '\n' || *p == '\r' || *p == TAB)
10244 { 10474 {
10245 if (*p != TAB && needclr) 10475 if (*p != TAB && needclr)
10246 { 10476 {
10247 /* remove any text still there from the command */ 10477 /* remove any text still there from the command */
10264 #endif 10494 #endif
10265 (void)msg_outtrans_len_attr(p, 1, echo_attr); 10495 (void)msg_outtrans_len_attr(p, 1, echo_attr);
10266 } 10496 }
10267 vim_free(tofree); 10497 vim_free(tofree);
10268 } 10498 }
10269 clear_vartv(&retvar); 10499 clear_tv(&rettv);
10270 arg = skipwhite(arg); 10500 arg = skipwhite(arg);
10271 } 10501 }
10272 eap->nextcmd = check_nextcmd(arg); 10502 eap->nextcmd = check_nextcmd(arg);
10273 10503
10274 if (eap->skip) 10504 if (eap->skip)
10309 void 10539 void
10310 ex_execute(eap) 10540 ex_execute(eap)
10311 exarg_T *eap; 10541 exarg_T *eap;
10312 { 10542 {
10313 char_u *arg = eap->arg; 10543 char_u *arg = eap->arg;
10314 typeval retvar; 10544 typeval rettv;
10315 int ret = OK; 10545 int ret = OK;
10316 char_u *p; 10546 char_u *p;
10317 garray_T ga; 10547 garray_T ga;
10318 int len; 10548 int len;
10319 int save_did_emsg; 10549 int save_did_emsg;
10323 if (eap->skip) 10553 if (eap->skip)
10324 ++emsg_skip; 10554 ++emsg_skip;
10325 while (*arg != NUL && *arg != '|' && *arg != '\n') 10555 while (*arg != NUL && *arg != '|' && *arg != '\n')
10326 { 10556 {
10327 p = arg; 10557 p = arg;
10328 if (eval1(&arg, &retvar, !eap->skip) == FAIL) 10558 if (eval1(&arg, &rettv, !eap->skip) == FAIL)
10329 { 10559 {
10330 /* 10560 /*
10331 * Report the invalid expression unless the expression evaluation 10561 * Report the invalid expression unless the expression evaluation
10332 * has been cancelled due to an aborting error, an interrupt, or an 10562 * has been cancelled due to an aborting error, an interrupt, or an
10333 * exception. 10563 * exception.
10338 break; 10568 break;
10339 } 10569 }
10340 10570
10341 if (!eap->skip) 10571 if (!eap->skip)
10342 { 10572 {
10343 p = get_vartv_string(&retvar); 10573 p = get_tv_string(&rettv);
10344 len = (int)STRLEN(p); 10574 len = (int)STRLEN(p);
10345 if (ga_grow(&ga, len + 2) == FAIL) 10575 if (ga_grow(&ga, len + 2) == FAIL)
10346 { 10576 {
10347 clear_vartv(&retvar); 10577 clear_tv(&rettv);
10348 ret = FAIL; 10578 ret = FAIL;
10349 break; 10579 break;
10350 } 10580 }
10351 if (ga.ga_len) 10581 if (ga.ga_len)
10352 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; 10582 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' ';
10353 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); 10583 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p);
10354 ga.ga_len += len; 10584 ga.ga_len += len;
10355 } 10585 }
10356 10586
10357 clear_vartv(&retvar); 10587 clear_tv(&rettv);
10358 arg = skipwhite(arg); 10588 arg = skipwhite(arg);
10359 } 10589 }
10360 10590
10361 if (ret != FAIL && ga.ga_data != NULL) 10591 if (ret != FAIL && ga.ga_data != NULL)
10362 { 10592 {
10430 exarg_T *eap; 10660 exarg_T *eap;
10431 { 10661 {
10432 char_u *theline; 10662 char_u *theline;
10433 int j; 10663 int j;
10434 int c; 10664 int c;
10435 #ifdef FEAT_MAGIC_BRACES
10436 int saved_did_emsg; 10665 int saved_did_emsg;
10437 #endif
10438 char_u *name = NULL; 10666 char_u *name = NULL;
10439 char_u *p; 10667 char_u *p;
10440 char_u *arg; 10668 char_u *arg;
10441 garray_T newargs; 10669 garray_T newargs;
10442 garray_T newlines; 10670 garray_T newlines;
10474 if (!aborting()) 10702 if (!aborting())
10475 return; 10703 return;
10476 else 10704 else
10477 eap->skip = TRUE; 10705 eap->skip = TRUE;
10478 } 10706 }
10479 #ifdef FEAT_MAGIC_BRACES
10480 /* An error in a function call during evaluation of an expression in magic 10707 /* An error in a function call during evaluation of an expression in magic
10481 * braces should not cause the function not to be defined. */ 10708 * braces should not cause the function not to be defined. */
10482 saved_did_emsg = did_emsg; 10709 saved_did_emsg = did_emsg;
10483 did_emsg = FALSE; 10710 did_emsg = FALSE;
10484 #endif
10485 10711
10486 /* 10712 /*
10487 * ":function func" with only function name: list function. 10713 * ":function func" with only function name: list function.
10488 */ 10714 */
10489 if (vim_strchr(p, '(') == NULL) 10715 if (vim_strchr(p, '(') == NULL)
10782 fp->lines = newlines; 11008 fp->lines = newlines;
10783 fp->varargs = varargs; 11009 fp->varargs = varargs;
10784 fp->flags = flags; 11010 fp->flags = flags;
10785 fp->calls = 0; 11011 fp->calls = 0;
10786 fp->script_ID = current_SID; 11012 fp->script_ID = current_SID;
10787 #ifdef FEAT_MAGIC_BRACES
10788 did_emsg |= saved_did_emsg; 11013 did_emsg |= saved_did_emsg;
10789 #endif
10790 vim_free(skip_until); 11014 vim_free(skip_until);
10791 return; 11015 return;
10792 11016
10793 erret: 11017 erret:
10794 vim_free(skip_until); 11018 vim_free(skip_until);
10795 ga_clear_strings(&newargs); 11019 ga_clear_strings(&newargs);
10796 ga_clear_strings(&newlines); 11020 ga_clear_strings(&newlines);
10797 erret_name: 11021 erret_name:
10798 vim_free(name); 11022 vim_free(name);
10799 #ifdef FEAT_MAGIC_BRACES
10800 did_emsg |= saved_did_emsg; 11023 did_emsg |= saved_did_emsg;
10801 #endif
10802 } 11024 }
10803 11025
10804 /* 11026 /*
10805 * Get a function name, translating "<SID>" and "<SNR>". 11027 * Get a function name, translating "<SID>" and "<SNR>".
10806 * Returns the function name in allocated memory, or NULL for failure. 11028 * Returns the function name in allocated memory, or NULL for failure.
10824 /* A name starting with "<SID>" or "<SNR>" is local to a script. */ 11046 /* A name starting with "<SID>" or "<SNR>" is local to a script. */
10825 start = *pp; 11047 start = *pp;
10826 lead = eval_fname_script(start); 11048 lead = eval_fname_script(start);
10827 if (lead > 0) 11049 if (lead > 0)
10828 start += lead; 11050 start += lead;
10829 end = find_name_end(start, &expr_start, &expr_end); 11051 end = find_name_end(start, &expr_start, &expr_end, FALSE);
10830 if (end == start) 11052 if (end == start)
10831 { 11053 {
10832 if (!skip) 11054 if (!skip)
10833 EMSG(_("E129: Function name required")); 11055 EMSG(_("E129: Function name required"));
10834 return NULL; 11056 return NULL;
10835 } 11057 }
10836 #ifdef FEAT_MAGIC_BRACES
10837 if (expr_start != NULL && !skip) 11058 if (expr_start != NULL && !skip)
10838 { 11059 {
10839 /* expand magic curlies */ 11060 /* expand magic curlies */
10840 temp_string = make_expanded_name(start, expr_start, expr_end, end); 11061 temp_string = make_expanded_name(start, expr_start, expr_end, end);
10841 if (temp_string == NULL) 11062 if (temp_string == NULL)
10853 } 11074 }
10854 start = temp_string; 11075 start = temp_string;
10855 len = (int)STRLEN(temp_string); 11076 len = (int)STRLEN(temp_string);
10856 } 11077 }
10857 else 11078 else
10858 #endif
10859 len = (int)(end - start); 11079 len = (int)(end - start);
10860 11080
10861 /* 11081 /*
10862 * Copy the function name to allocated memory. 11082 * Copy the function name to allocated memory.
10863 * Accept <SID>name() inside a script, translate into <SNR>123_name(). 11083 * Accept <SID>name() inside a script, translate into <SNR>123_name().
11127 11347
11128 /* 11348 /*
11129 * Call a user function. 11349 * Call a user function.
11130 */ 11350 */
11131 static void 11351 static void
11132 call_user_func(fp, argcount, argvars, retvar, firstline, lastline) 11352 call_user_func(fp, argcount, argvars, rettv, firstline, lastline)
11133 ufunc_T *fp; /* pointer to function */ 11353 ufunc_T *fp; /* pointer to function */
11134 int argcount; /* nr of args */ 11354 int argcount; /* nr of args */
11135 typeval *argvars; /* arguments */ 11355 typeval *argvars; /* arguments */
11136 typeval *retvar; /* return value */ 11356 typeval *rettv; /* return value */
11137 linenr_T firstline; /* first line of range */ 11357 linenr_T firstline; /* first line of range */
11138 linenr_T lastline; /* last line of range */ 11358 linenr_T lastline; /* last line of range */
11139 { 11359 {
11140 char_u *save_sourcing_name; 11360 char_u *save_sourcing_name;
11141 linenr_T save_sourcing_lnum; 11361 linenr_T save_sourcing_lnum;
11147 11367
11148 /* If depth of calling is getting too high, don't execute the function */ 11368 /* If depth of calling is getting too high, don't execute the function */
11149 if (depth >= p_mfd) 11369 if (depth >= p_mfd)
11150 { 11370 {
11151 EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'")); 11371 EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'"));
11152 retvar->v_type = VAR_NUMBER; 11372 rettv->v_type = VAR_NUMBER;
11153 retvar->vval.v_number = -1; 11373 rettv->vval.v_number = -1;
11154 return; 11374 return;
11155 } 11375 }
11156 ++depth; 11376 ++depth;
11157 11377
11158 line_breakcheck(); /* check for CTRL-C hit */ 11378 line_breakcheck(); /* check for CTRL-C hit */
11160 /* set local variables */ 11380 /* set local variables */
11161 vars_init(&fc.l_vars); 11381 vars_init(&fc.l_vars);
11162 fc.func = fp; 11382 fc.func = fp;
11163 fc.argcount = argcount; 11383 fc.argcount = argcount;
11164 fc.argvars = argvars; 11384 fc.argvars = argvars;
11165 fc.retvar = retvar; 11385 fc.rettv = rettv;
11166 retvar->vval.v_number = 0; 11386 rettv->vval.v_number = 0;
11167 fc.linenr = 0; 11387 fc.linenr = 0;
11168 fc.returned = FALSE; 11388 fc.returned = FALSE;
11169 fc.level = ex_nesting_level; 11389 fc.level = ex_nesting_level;
11170 fc.a0_var.tv.v_type = VAR_NUMBER; 11390 fc.a0_var.tv.v_type = VAR_NUMBER;
11171 fc.a0_var.tv.vval.v_number = argcount - fp->args.ga_len; 11391 fc.a0_var.tv.vval.v_number = argcount - fp->args.ga_len;
11214 msg_puts((char_u *)", "); 11434 msg_puts((char_u *)", ");
11215 if (argvars[i].v_type == VAR_NUMBER) 11435 if (argvars[i].v_type == VAR_NUMBER)
11216 msg_outnum((long)argvars[i].vval.v_number); 11436 msg_outnum((long)argvars[i].vval.v_number);
11217 else 11437 else
11218 { 11438 {
11219 trunc_string(get_vartv_string(&argvars[i]), 11439 trunc_string(get_tv_string(&argvars[i]),
11220 buf, MSG_BUF_LEN); 11440 buf, MSG_BUF_LEN);
11221 msg_puts((char_u *)"\""); 11441 msg_puts((char_u *)"\"");
11222 msg_puts(buf); 11442 msg_puts(buf);
11223 msg_puts((char_u *)"\""); 11443 msg_puts((char_u *)"\"");
11224 } 11444 }
11240 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT); 11460 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
11241 11461
11242 --RedrawingDisabled; 11462 --RedrawingDisabled;
11243 11463
11244 /* when the function was aborted because of an error, return -1 */ 11464 /* when the function was aborted because of an error, return -1 */
11245 if ((did_emsg && (fp->flags & FC_ABORT)) || retvar->v_type == VAR_UNKNOWN) 11465 if ((did_emsg && (fp->flags & FC_ABORT)) || rettv->v_type == VAR_UNKNOWN)
11246 { 11466 {
11247 clear_vartv(retvar); 11467 clear_tv(rettv);
11248 retvar->v_type = VAR_NUMBER; 11468 rettv->v_type = VAR_NUMBER;
11249 retvar->vval.v_number = -1; 11469 rettv->vval.v_number = -1;
11250 } 11470 }
11251 11471
11252 /* when being verbose, mention the return value */ 11472 /* when being verbose, mention the return value */
11253 if (p_verbose >= 12) 11473 if (p_verbose >= 12)
11254 { 11474 {
11262 if (STRLEN(sourcing_name) > IOSIZE / 2 - 50) 11482 if (STRLEN(sourcing_name) > IOSIZE / 2 - 50)
11263 sn = sourcing_name + STRLEN(sourcing_name) - (IOSIZE / 2 - 50); 11483 sn = sourcing_name + STRLEN(sourcing_name) - (IOSIZE / 2 - 50);
11264 11484
11265 if (aborting()) 11485 if (aborting())
11266 smsg((char_u *)_("%s aborted"), sn); 11486 smsg((char_u *)_("%s aborted"), sn);
11267 else if (fc.retvar->v_type == VAR_NUMBER) 11487 else if (fc.rettv->v_type == VAR_NUMBER)
11268 smsg((char_u *)_("%s returning #%ld"), sn, 11488 smsg((char_u *)_("%s returning #%ld"), sn,
11269 (long)fc.retvar->vval.v_number); 11489 (long)fc.rettv->vval.v_number);
11270 else if (fc.retvar->v_type == VAR_STRING) 11490 else if (fc.rettv->v_type == VAR_STRING)
11271 { 11491 {
11272 val = get_vartv_string(fc.retvar); 11492 val = get_tv_string(fc.rettv);
11273 if (STRLEN(val) > IOSIZE / 2 - 50) 11493 if (STRLEN(val) > IOSIZE / 2 - 50)
11274 val = val + STRLEN(val) - (IOSIZE / 2 - 50); 11494 val = val + STRLEN(val) - (IOSIZE / 2 - 50);
11275 smsg((char_u *)_("%s returning \"%s\""), sn, val); 11495 smsg((char_u *)_("%s returning \"%s\""), sn, val);
11276 } 11496 }
11277 msg_puts((char_u *)"\n"); /* don't overwrite this either */ 11497 msg_puts((char_u *)"\n"); /* don't overwrite this either */
11307 void 11527 void
11308 ex_return(eap) 11528 ex_return(eap)
11309 exarg_T *eap; 11529 exarg_T *eap;
11310 { 11530 {
11311 char_u *arg = eap->arg; 11531 char_u *arg = eap->arg;
11312 var retvar; 11532 typeval rettv;
11313 int returning = FALSE; 11533 int returning = FALSE;
11314 11534
11315 if (current_funccal == NULL) 11535 if (current_funccal == NULL)
11316 { 11536 {
11317 EMSG(_("E133: :return not inside a function")); 11537 EMSG(_("E133: :return not inside a function"));
11321 if (eap->skip) 11541 if (eap->skip)
11322 ++emsg_skip; 11542 ++emsg_skip;
11323 11543
11324 eap->nextcmd = NULL; 11544 eap->nextcmd = NULL;
11325 if ((*arg != NUL && *arg != '|' && *arg != '\n') 11545 if ((*arg != NUL && *arg != '|' && *arg != '\n')
11326 && eval0(arg, &retvar, &eap->nextcmd, !eap->skip) != FAIL) 11546 && eval0(arg, &rettv, &eap->nextcmd, !eap->skip) != FAIL)
11327 { 11547 {
11328 if (!eap->skip) 11548 if (!eap->skip)
11329 returning = do_return(eap, FALSE, TRUE, &retvar); 11549 returning = do_return(eap, FALSE, TRUE, &rettv);
11330 else 11550 else
11331 clear_vartv(&retvar.tv); 11551 clear_tv(&rettv);
11332 } 11552 }
11333 /* It's safer to return also on error. */ 11553 /* It's safer to return also on error. */
11334 else if (!eap->skip) 11554 else if (!eap->skip)
11335 { 11555 {
11336 /* 11556 /*
11355 11575
11356 /* 11576 /*
11357 * Return from a function. Possibly makes the return pending. Also called 11577 * Return from a function. Possibly makes the return pending. Also called
11358 * for a pending return at the ":endtry" or after returning from an extra 11578 * for a pending return at the ":endtry" or after returning from an extra
11359 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set 11579 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
11360 * when called due to a ":return" command. "value" may point to a variable 11580 * when called due to a ":return" command. "rettv" may point to a typeval
11361 * with the return value. Returns TRUE when the return can be carried out, 11581 * with the return rettv. Returns TRUE when the return can be carried out,
11362 * FALSE when the return gets pending. 11582 * FALSE when the return gets pending.
11363 */ 11583 */
11364 int 11584 int
11365 do_return(eap, reanimate, is_cmd, value) 11585 do_return(eap, reanimate, is_cmd, rettv)
11366 exarg_T *eap; 11586 exarg_T *eap;
11367 int reanimate; 11587 int reanimate;
11368 int is_cmd; 11588 int is_cmd;
11369 void *value; 11589 void *rettv;
11370 { 11590 {
11371 int idx; 11591 int idx;
11372 struct condstack *cstack = eap->cstack; 11592 struct condstack *cstack = eap->cstack;
11373 11593
11374 if (reanimate) 11594 if (reanimate)
11385 if (idx >= 0) 11605 if (idx >= 0)
11386 { 11606 {
11387 cstack->cs_pending[idx] = CSTP_RETURN; 11607 cstack->cs_pending[idx] = CSTP_RETURN;
11388 11608
11389 if (!is_cmd && !reanimate) 11609 if (!is_cmd && !reanimate)
11390 /* A pending return again gets pending. "value" points to an 11610 /* A pending return again gets pending. "rettv" points to an
11391 * allocated variable with the value of the original ":return"'s 11611 * allocated variable with the rettv of the original ":return"'s
11392 * argument if present or is NULL else. */ 11612 * argument if present or is NULL else. */
11393 cstack->cs_retvar[idx] = value; 11613 cstack->cs_rettv[idx] = rettv;
11394 else 11614 else
11395 { 11615 {
11396 /* When undoing a return in order to make it pending, get the stored 11616 /* When undoing a return in order to make it pending, get the stored
11397 * return value. */ 11617 * return rettv. */
11398 if (reanimate) 11618 if (reanimate)
11399 value = current_funccal->retvar; 11619 rettv = current_funccal->rettv;
11400 11620
11401 if (value != NULL) 11621 if (rettv != NULL)
11402 { 11622 {
11403 /* Store the value of the pending return. */ 11623 /* Store the value of the pending return. */
11404 if ((cstack->cs_retvar[idx] = alloc_var()) != NULL) 11624 if ((cstack->cs_rettv[idx] = alloc_tv()) != NULL)
11405 *(typeval *)cstack->cs_retvar[idx] = *(typeval *)value; 11625 *(typeval *)cstack->cs_rettv[idx] = *(typeval *)rettv;
11406 else 11626 else
11407 EMSG(_(e_outofmem)); 11627 EMSG(_(e_outofmem));
11408 } 11628 }
11409 else 11629 else
11410 cstack->cs_retvar[idx] = NULL; 11630 cstack->cs_rettv[idx] = NULL;
11411 11631
11412 if (reanimate) 11632 if (reanimate)
11413 { 11633 {
11414 /* The pending return value could be overwritten by a ":return" 11634 /* The pending return value could be overwritten by a ":return"
11415 * without argument in a finally clause; reset the default 11635 * without argument in a finally clause; reset the default
11416 * return value. */ 11636 * return value. */
11417 current_funccal->retvar->v_type = VAR_NUMBER; 11637 current_funccal->rettv->v_type = VAR_NUMBER;
11418 current_funccal->retvar->vval.v_number = 0; 11638 current_funccal->rettv->vval.v_number = 0;
11419 } 11639 }
11420 } 11640 }
11421 report_make_pending(CSTP_RETURN, value); 11641 report_make_pending(CSTP_RETURN, rettv);
11422 } 11642 }
11423 else 11643 else
11424 { 11644 {
11425 current_funccal->returned = TRUE; 11645 current_funccal->returned = TRUE;
11426 11646
11427 /* If the return is carried out now, store the return value. For 11647 /* If the return is carried out now, store the return value. For
11428 * a return immediately after reanimation, the value is already 11648 * a return immediately after reanimation, the value is already
11429 * there. */ 11649 * there. */
11430 if (!reanimate && value != NULL) 11650 if (!reanimate && rettv != NULL)
11431 { 11651 {
11432 clear_vartv(current_funccal->retvar); 11652 clear_tv(current_funccal->rettv);
11433 *current_funccal->retvar = *(typeval *)value; 11653 *current_funccal->rettv = *(typeval *)rettv;
11434 if (!is_cmd) 11654 if (!is_cmd)
11435 vim_free(value); 11655 vim_free(rettv);
11436 } 11656 }
11437 } 11657 }
11438 11658
11439 return idx < 0; 11659 return idx < 0;
11440 } 11660 }
11441 11661
11442 /* 11662 /*
11443 * Free the variable with a pending return value. 11663 * Free the variable with a pending return value.
11444 */ 11664 */
11445 void 11665 void
11446 discard_pending_return(retvar) 11666 discard_pending_return(rettv)
11447 void *retvar; 11667 void *rettv;
11448 { 11668 {
11449 /* The variable was copied from one with an undefined v_name. So we can't 11669 free_tv((typeval *)rettv);
11450 * use free_vartv() to clear and free it. */ 11670 }
11451 clear_vartv(&((VAR)retvar)->tv); 11671
11452 vim_free(retvar); 11672 /*
11453 } 11673 * Generate a return command for producing the value of "rettv". The result
11454
11455 /*
11456 * Generate a return command for producing the value of "retvar". The result
11457 * is an allocated string. Used by report_pending() for verbose messages. 11674 * is an allocated string. Used by report_pending() for verbose messages.
11458 */ 11675 */
11459 char_u * 11676 char_u *
11460 get_return_cmd(retvar) 11677 get_return_cmd(rettv)
11461 void *retvar; 11678 void *rettv;
11462 { 11679 {
11463 char_u *s = IObuff; 11680 char_u *s;
11464 11681 char_u *tofree = NULL;
11465 if (retvar == NULL || ((VAR)retvar)->tv.v_type == VAR_UNKNOWN) 11682
11466 s = (char_u *)":return"; 11683 if (rettv == NULL)
11467 else if (((VAR)retvar)->tv.v_type == VAR_STRING) 11684 s = (char_u *)"";
11468 sprintf((char *)IObuff, ":return \"%s\"",
11469 ((VAR)retvar)->tv.vval.v_string);
11470 else 11685 else
11471 sprintf((char *)IObuff, ":return %ld", 11686 s = tv2string((typeval *)rettv, &tofree);
11472 (long)(((VAR)retvar)->tv.vval.v_number)); 11687
11473 return vim_strsave(s); 11688 STRCPY(IObuff, ":return ");
11689 STRNCPY(IObuff + 8, s, IOSIZE - 8);
11690 if (STRLEN(s) + 8 >= IOSIZE)
11691 STRCPY(IObuff + IOSIZE - 4, "...");
11692 vim_free(tofree);
11693 return vim_strsave(IObuff);
11474 } 11694 }
11475 11695
11476 /* 11696 /*
11477 * Get next function line. 11697 * Get next function line.
11478 * Called by do_cmdline() to get the next line. 11698 * Called by do_cmdline() to get the next line.
11584 vir_T *virp; 11804 vir_T *virp;
11585 int writing; 11805 int writing;
11586 { 11806 {
11587 char_u *tab; 11807 char_u *tab;
11588 int is_string = FALSE; 11808 int is_string = FALSE;
11589 typeval *vartvp = NULL; 11809 typeval *tvp = NULL;
11590 char_u *val; 11810 char_u *val;
11591 11811
11592 if (!writing && (find_viminfo_parameter('!') != NULL)) 11812 if (!writing && (find_viminfo_parameter('!') != NULL))
11593 { 11813 {
11594 tab = vim_strchr(virp->vir_line + 1, '\t'); 11814 tab = vim_strchr(virp->vir_line + 1, '\t');
11599 is_string = TRUE; 11819 is_string = TRUE;
11600 11820
11601 tab = vim_strchr(tab, '\t'); 11821 tab = vim_strchr(tab, '\t');
11602 if (tab != NULL) 11822 if (tab != NULL)
11603 { 11823 {
11604 /* create a nameless variable to hold the value */ 11824 /* create a typeval to hold the value */
11605 if (is_string) 11825 if (is_string)
11606 { 11826 {
11607 val = viminfo_readstring(virp, 11827 val = viminfo_readstring(virp,
11608 (int)(tab - virp->vir_line + 1), TRUE); 11828 (int)(tab - virp->vir_line + 1), TRUE);
11609 if (val != NULL) 11829 if (val != NULL)
11610 vartvp = alloc_string_vartv(val); 11830 tvp = alloc_string_tv(val);
11611 } 11831 }
11612 else 11832 else
11613 { 11833 {
11614 vartvp = alloc_vartv(); 11834 tvp = alloc_tv();
11615 if (vartvp != NULL) 11835 if (tvp != NULL)
11616 { 11836 {
11617 vartvp->v_type = VAR_NUMBER; 11837 tvp->v_type = VAR_NUMBER;
11618 vartvp->vval.v_number = atol((char *)tab + 1); 11838 tvp->vval.v_number = atol((char *)tab + 1);
11619 } 11839 }
11620 } 11840 }
11621 /* assign the value to the variable */ 11841 /* assign the value to the variable */
11622 if (vartvp != NULL) 11842 if (tvp != NULL)
11623 { 11843 {
11624 set_var(virp->vir_line + 1, vartvp, FALSE); 11844 set_var(virp->vir_line + 1, tvp, FALSE);
11625 free_vartv(vartvp); 11845 free_tv(tvp);
11626 } 11846 }
11627 } 11847 }
11628 } 11848 }
11629 } 11849 }
11630 11850
11639 FILE *fp; 11859 FILE *fp;
11640 { 11860 {
11641 garray_T *gap = &variables; /* global variable */ 11861 garray_T *gap = &variables; /* global variable */
11642 VAR this_var; 11862 VAR this_var;
11643 int i; 11863 int i;
11864 char *s;
11865 char_u *tofree;
11644 11866
11645 if (find_viminfo_parameter('!') == NULL) 11867 if (find_viminfo_parameter('!') == NULL)
11646 return; 11868 return;
11647 11869
11648 fprintf(fp, _("\n# global variables:\n")); 11870 fprintf(fp, _("\n# global variables:\n"));
11650 { 11872 {
11651 this_var = &VAR_GAP_ENTRY(i, gap); 11873 this_var = &VAR_GAP_ENTRY(i, gap);
11652 if (this_var->v_name != NULL 11874 if (this_var->v_name != NULL
11653 && var_flavour(this_var->v_name) == VAR_FLAVOUR_VIMINFO) 11875 && var_flavour(this_var->v_name) == VAR_FLAVOUR_VIMINFO)
11654 { 11876 {
11655 fprintf(fp, "!%s\t%s\t", this_var->v_name, 11877 switch (this_var->tv.v_type)
11656 (this_var->tv.v_type == VAR_STRING) ? "STR" : "NUM"); 11878 {
11657 viminfo_writestring(fp, get_var_string(this_var)); 11879 case VAR_STRING: s = "STR"; break;
11880 case VAR_NUMBER: s = "NUM"; break;
11881 case VAR_LIST: s = "LST"; break;
11882 case VAR_FUNC: s = "FUN"; break;
11883 default:
11884 EMSGN(_("E999: Internal error: write_viminfo_varlist(): %ld"), (long)this_var->tv.v_type);
11885 s = "ERR";
11886 }
11887 fprintf(fp, "!%s\t%s\t", this_var->v_name, s);
11888 viminfo_writestring(fp, tv2string(&this_var->tv, &tofree));
11889 vim_free(tofree);
11658 } 11890 }
11659 } 11891 }
11660 } 11892 }
11661 #endif 11893 #endif
11662 11894