1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * eval.c: Expression evaluation.
13 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
14 # include "vimio.h" /* for mch_open(), must be before vim.h */
19 #if defined(FEAT_EVAL) || defined(PROTO)
22 # include <time.h> /* for strftime() */
26 # include <time.h> /* for time_t */
29 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
33 #define DICT_MAXNEST 100 /* maximum nesting of lists and dicts */
35 #define DO_NOT_FREE_CNT 99999 /* refcount for dict or list that should not
39 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
40 * This avoids adding a pointer to the hashtab item.
41 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
42 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
43 * HI2DI() converts a hashitem pointer to a dictitem pointer.
45 static dictitem_T dumdi
;
46 #define DI2HIKEY(di) ((di)->di_key)
47 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
48 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
51 * Structure returned by get_lval() and used by set_var_lval().
53 * "name" points to the variable name.
56 * For a magic braces name:
57 * "name" points to the expanded variable name.
58 * "exp_name" is non-NULL, to be freed later.
60 * For an index in a list:
61 * "name" points to the (expanded) variable name.
62 * "exp_name" NULL or non-NULL, to be freed later.
63 * "tv" points to the (first) list item value
64 * "li" points to the (first) list item
65 * "range", "n1", "n2" and "empty2" indicate what items are used.
66 * For an existing Dict item:
67 * "name" points to the (expanded) variable name.
68 * "exp_name" NULL or non-NULL, to be freed later.
69 * "tv" points to the dict item value
71 * For a non-existing Dict item:
72 * "name" points to the (expanded) variable name.
73 * "exp_name" NULL or non-NULL, to be freed later.
74 * "tv" points to the Dictionary typval_T
75 * "newkey" is the key for the new item.
79 char_u
*ll_name
; /* start of variable name (can be NULL) */
80 char_u
*ll_exp_name
; /* NULL or expanded name in allocated memory. */
81 typval_T
*ll_tv
; /* Typeval of item being used. If "newkey"
82 isn't NULL it's the Dict to which to add
84 listitem_T
*ll_li
; /* The list item or NULL. */
85 list_T
*ll_list
; /* The list or NULL. */
86 int ll_range
; /* TRUE when a [i:j] range was used */
87 long ll_n1
; /* First index for list */
88 long ll_n2
; /* Second index for list range */
89 int ll_empty2
; /* Second index is empty: [i:] */
90 dict_T
*ll_dict
; /* The Dictionary or NULL */
91 dictitem_T
*ll_di
; /* The dictitem or NULL */
92 char_u
*ll_newkey
; /* New key for Dict in alloc. mem or NULL. */
96 static char *e_letunexp
= N_("E18: Unexpected characters in :let");
97 static char *e_listidx
= N_("E684: list index out of range: %ld");
98 static char *e_undefvar
= N_("E121: Undefined variable: %s");
99 static char *e_missbrac
= N_("E111: Missing ']'");
100 static char *e_listarg
= N_("E686: Argument of %s must be a List");
101 static char *e_listdictarg
= N_("E712: Argument of %s must be a List or Dictionary");
102 static char *e_emptykey
= N_("E713: Cannot use empty key for Dictionary");
103 static char *e_listreq
= N_("E714: List required");
104 static char *e_dictreq
= N_("E715: Dictionary required");
105 static char *e_toomanyarg
= N_("E118: Too many arguments for function: %s");
106 static char *e_dictkey
= N_("E716: Key not present in Dictionary: %s");
107 static char *e_funcexts
= N_("E122: Function %s already exists, add ! to replace it");
108 static char *e_funcdict
= N_("E717: Dictionary entry already exists");
109 static char *e_funcref
= N_("E718: Funcref required");
110 static char *e_dictrange
= N_("E719: Cannot use [:] with a Dictionary");
111 static char *e_letwrong
= N_("E734: Wrong variable type for %s=");
112 static char *e_nofunc
= N_("E130: Unknown function: %s");
113 static char *e_illvar
= N_("E461: Illegal variable name: %s");
116 * All user-defined global variables are stored in dictionary "globvardict".
117 * "globvars_var" is the variable that is used for "g:".
119 static dict_T globvardict
;
120 static dictitem_T globvars_var
;
121 #define globvarht globvardict.dv_hashtab
124 * Old Vim variables such as "v:version" are also available without the "v:".
125 * Also in functions. We need a special hashtable for them.
127 static hashtab_T compat_hashtab
;
130 * When recursively copying lists and dicts we need to remember which ones we
131 * have done to avoid endless recursiveness. This unique ID is used for that.
132 * The last bit is used for previous_funccal, ignored when comparing.
134 static int current_copyID
= 0;
136 #define COPYID_MASK (~0x1)
139 * Array to hold the hashtab with variables local to each sourced script.
140 * Each item holds a variable (nameless) that points to the dict_T.
148 static garray_T ga_scripts
= {0, 0, sizeof(scriptvar_T
*), 4, NULL
};
149 #define SCRIPT_SV(id) (((scriptvar_T **)ga_scripts.ga_data)[(id) - 1])
150 #define SCRIPT_VARS(id) (SCRIPT_SV(id)->sv_dict.dv_hashtab)
152 static int echo_attr
= 0; /* attributes used for ":echo" */
154 /* Values for trans_function_name() argument: */
155 #define TFN_INT 1 /* internal function name OK */
156 #define TFN_QUIET 2 /* no error messages */
159 * Structure to hold info for a user function.
161 typedef struct ufunc ufunc_T
;
165 int uf_varargs
; /* variable nr of arguments */
167 int uf_calls
; /* nr of active calls */
168 garray_T uf_args
; /* arguments */
169 garray_T uf_lines
; /* function lines */
171 int uf_profiling
; /* TRUE when func is being profiled */
172 /* profiling the function as a whole */
173 int uf_tm_count
; /* nr of calls */
174 proftime_T uf_tm_total
; /* time spent in function + children */
175 proftime_T uf_tm_self
; /* time spent in function itself */
176 proftime_T uf_tm_children
; /* time spent in children this call */
177 /* profiling the function per line */
178 int *uf_tml_count
; /* nr of times line was executed */
179 proftime_T
*uf_tml_total
; /* time spent in a line + children */
180 proftime_T
*uf_tml_self
; /* time spent in a line itself */
181 proftime_T uf_tml_start
; /* start time for current line */
182 proftime_T uf_tml_children
; /* time spent in children for this line */
183 proftime_T uf_tml_wait
; /* start wait time for current line */
184 int uf_tml_idx
; /* index of line being timed; -1 if none */
185 int uf_tml_execed
; /* line being timed was executed */
187 scid_T uf_script_ID
; /* ID of script where function was defined,
188 used for s: variables */
189 int uf_refcount
; /* for numbered function: reference count */
190 char_u uf_name
[1]; /* name of function (actually longer); can
191 start with <SNR>123_ (<SNR> is K_SPECIAL
196 #define FC_ABORT 1 /* abort function on error */
197 #define FC_RANGE 2 /* function accepts range */
198 #define FC_DICT 4 /* Dict function, uses "self" */
201 * All user-defined functions are found in this hashtable.
203 static hashtab_T func_hashtab
;
205 /* The names of packages that once were loaded are remembered. */
206 static garray_T ga_loaded
= {0, 0, sizeof(char_u
*), 4, NULL
};
208 /* list heads for garbage collection */
209 static dict_T
*first_dict
= NULL
; /* list of all dicts */
210 static list_T
*first_list
= NULL
; /* list of all lists */
212 /* From user function to hashitem and back. */
213 static ufunc_T dumuf
;
214 #define UF2HIKEY(fp) ((fp)->uf_name)
215 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
216 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
218 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
219 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
221 #define MAX_FUNC_ARGS 20 /* maximum number of function arguments */
222 #define VAR_SHORT_LEN 20 /* short variable name length */
223 #define FIXVAR_CNT 12 /* number of fixed variables */
225 /* structure to hold info for a function that is currently being executed. */
226 typedef struct funccall_S funccall_T
;
230 ufunc_T
*func
; /* function being called */
231 int linenr
; /* next line to be executed */
232 int returned
; /* ":return" used */
233 struct /* fixed variables for arguments */
235 dictitem_T var
; /* variable (without room for name) */
236 char_u room
[VAR_SHORT_LEN
]; /* room for the name */
237 } fixvar
[FIXVAR_CNT
];
238 dict_T l_vars
; /* l: local function variables */
239 dictitem_T l_vars_var
; /* variable for l: scope */
240 dict_T l_avars
; /* a: argument variables */
241 dictitem_T l_avars_var
; /* variable for a: scope */
242 list_T l_varlist
; /* list for a:000 */
243 listitem_T l_listitems
[MAX_FUNC_ARGS
]; /* listitems for a:000 */
244 typval_T
*rettv
; /* return value */
245 linenr_T breakpoint
; /* next line with breakpoint or zero */
246 int dbg_tick
; /* debug_tick when breakpoint was set */
247 int level
; /* top nesting level of executed function */
249 proftime_T prof_child
; /* time spent in a child */
251 funccall_T
*caller
; /* calling function or NULL */
255 * Info used by a ":for" loop.
259 int fi_semicolon
; /* TRUE if ending in '; var]' */
260 int fi_varcount
; /* nr of variables in the list */
261 listwatch_T fi_lw
; /* keep an eye on the item used. */
262 list_T
*fi_list
; /* list being used */
266 * Struct used by trans_function_name()
270 dict_T
*fd_dict
; /* Dictionary used */
271 char_u
*fd_newkey
; /* new key in "dict" in allocated memory */
272 dictitem_T
*fd_di
; /* Dictionary item used */
277 * Array to hold the value of v: variables.
278 * The value is in a dictitem, so that it can also be used in the v: scope.
279 * The reason to use this table anyway is for very quick access to the
280 * variables with the VV_ defines.
284 /* values for vv_flags: */
285 #define VV_COMPAT 1 /* compatible, also used without "v:" */
286 #define VV_RO 2 /* read-only */
287 #define VV_RO_SBX 4 /* read-only in the sandbox */
289 #define VV_NAME(s, t) s, {{t, 0, {0}}, 0, {0}}, {0}
293 char *vv_name
; /* name of variable, without v: */
294 dictitem_T vv_di
; /* value and name for key */
295 char vv_filler
[16]; /* space for LONGEST name below!!! */
296 char vv_flags
; /* VV_COMPAT, VV_RO, VV_RO_SBX */
300 * The order here must match the VV_ defines in vim.h!
301 * Initializing a union does not work, leave tv.vval empty to get zero's.
303 {VV_NAME("count", VAR_NUMBER
), VV_COMPAT
+VV_RO
},
304 {VV_NAME("count1", VAR_NUMBER
), VV_RO
},
305 {VV_NAME("prevcount", VAR_NUMBER
), VV_RO
},
306 {VV_NAME("errmsg", VAR_STRING
), VV_COMPAT
},
307 {VV_NAME("warningmsg", VAR_STRING
), 0},
308 {VV_NAME("statusmsg", VAR_STRING
), 0},
309 {VV_NAME("shell_error", VAR_NUMBER
), VV_COMPAT
+VV_RO
},
310 {VV_NAME("this_session", VAR_STRING
), VV_COMPAT
},
311 {VV_NAME("version", VAR_NUMBER
), VV_COMPAT
+VV_RO
},
312 {VV_NAME("lnum", VAR_NUMBER
), VV_RO_SBX
},
313 {VV_NAME("termresponse", VAR_STRING
), VV_RO
},
314 {VV_NAME("fname", VAR_STRING
), VV_RO
},
315 {VV_NAME("lang", VAR_STRING
), VV_RO
},
316 {VV_NAME("lc_time", VAR_STRING
), VV_RO
},
317 {VV_NAME("ctype", VAR_STRING
), VV_RO
},
318 {VV_NAME("charconvert_from", VAR_STRING
), VV_RO
},
319 {VV_NAME("charconvert_to", VAR_STRING
), VV_RO
},
320 {VV_NAME("fname_in", VAR_STRING
), VV_RO
},
321 {VV_NAME("fname_out", VAR_STRING
), VV_RO
},
322 {VV_NAME("fname_new", VAR_STRING
), VV_RO
},
323 {VV_NAME("fname_diff", VAR_STRING
), VV_RO
},
324 {VV_NAME("cmdarg", VAR_STRING
), VV_RO
},
325 {VV_NAME("foldstart", VAR_NUMBER
), VV_RO_SBX
},
326 {VV_NAME("foldend", VAR_NUMBER
), VV_RO_SBX
},
327 {VV_NAME("folddashes", VAR_STRING
), VV_RO_SBX
},
328 {VV_NAME("foldlevel", VAR_NUMBER
), VV_RO_SBX
},
329 {VV_NAME("progname", VAR_STRING
), VV_RO
},
330 {VV_NAME("servername", VAR_STRING
), VV_RO
},
331 {VV_NAME("dying", VAR_NUMBER
), VV_RO
},
332 {VV_NAME("exception", VAR_STRING
), VV_RO
},
333 {VV_NAME("throwpoint", VAR_STRING
), VV_RO
},
334 {VV_NAME("register", VAR_STRING
), VV_RO
},
335 {VV_NAME("cmdbang", VAR_NUMBER
), VV_RO
},
336 {VV_NAME("insertmode", VAR_STRING
), VV_RO
},
337 {VV_NAME("val", VAR_UNKNOWN
), VV_RO
},
338 {VV_NAME("key", VAR_UNKNOWN
), VV_RO
},
339 {VV_NAME("profiling", VAR_NUMBER
), VV_RO
},
340 {VV_NAME("fcs_reason", VAR_STRING
), VV_RO
},
341 {VV_NAME("fcs_choice", VAR_STRING
), 0},
342 {VV_NAME("beval_bufnr", VAR_NUMBER
), VV_RO
},
343 {VV_NAME("beval_winnr", VAR_NUMBER
), VV_RO
},
344 {VV_NAME("beval_lnum", VAR_NUMBER
), VV_RO
},
345 {VV_NAME("beval_col", VAR_NUMBER
), VV_RO
},
346 {VV_NAME("beval_text", VAR_STRING
), VV_RO
},
347 {VV_NAME("scrollstart", VAR_STRING
), 0},
348 {VV_NAME("swapname", VAR_STRING
), VV_RO
},
349 {VV_NAME("swapchoice", VAR_STRING
), 0},
350 {VV_NAME("swapcommand", VAR_STRING
), VV_RO
},
351 {VV_NAME("char", VAR_STRING
), VV_RO
},
352 {VV_NAME("mouse_win", VAR_NUMBER
), 0},
353 {VV_NAME("mouse_lnum", VAR_NUMBER
), 0},
354 {VV_NAME("mouse_col", VAR_NUMBER
), 0},
355 {VV_NAME("operator", VAR_STRING
), VV_RO
},
356 {VV_NAME("searchforward", VAR_NUMBER
), 0},
357 {VV_NAME("oldfiles", VAR_LIST
), 0},
361 #define vv_type vv_di.di_tv.v_type
362 #define vv_nr vv_di.di_tv.vval.v_number
363 #define vv_float vv_di.di_tv.vval.v_float
364 #define vv_str vv_di.di_tv.vval.v_string
365 #define vv_list vv_di.di_tv.vval.v_list
366 #define vv_tv vv_di.di_tv
369 * The v: variables are stored in dictionary "vimvardict".
370 * "vimvars_var" is the variable that is used for the "l:" scope.
372 static dict_T vimvardict
;
373 static dictitem_T vimvars_var
;
374 #define vimvarht vimvardict.dv_hashtab
376 static void prepare_vimvar
__ARGS((int idx
, typval_T
*save_tv
));
377 static void restore_vimvar
__ARGS((int idx
, typval_T
*save_tv
));
378 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
379 static int call_vim_function
__ARGS((char_u
*func
, int argc
, char_u
**argv
, int safe
, typval_T
*rettv
));
381 static int ex_let_vars
__ARGS((char_u
*arg
, typval_T
*tv
, int copy
, int semicolon
, int var_count
, char_u
*nextchars
));
382 static char_u
*skip_var_list
__ARGS((char_u
*arg
, int *var_count
, int *semicolon
));
383 static char_u
*skip_var_one
__ARGS((char_u
*arg
));
384 static void list_hashtable_vars
__ARGS((hashtab_T
*ht
, char_u
*prefix
, int empty
, int *first
));
385 static void list_glob_vars
__ARGS((int *first
));
386 static void list_buf_vars
__ARGS((int *first
));
387 static void list_win_vars
__ARGS((int *first
));
389 static void list_tab_vars
__ARGS((int *first
));
391 static void list_vim_vars
__ARGS((int *first
));
392 static void list_script_vars
__ARGS((int *first
));
393 static void list_func_vars
__ARGS((int *first
));
394 static char_u
*list_arg_vars
__ARGS((exarg_T
*eap
, char_u
*arg
, int *first
));
395 static char_u
*ex_let_one
__ARGS((char_u
*arg
, typval_T
*tv
, int copy
, char_u
*endchars
, char_u
*op
));
396 static int check_changedtick
__ARGS((char_u
*arg
));
397 static char_u
*get_lval
__ARGS((char_u
*name
, typval_T
*rettv
, lval_T
*lp
, int unlet
, int skip
, int quiet
, int fne_flags
));
398 static void clear_lval
__ARGS((lval_T
*lp
));
399 static void set_var_lval
__ARGS((lval_T
*lp
, char_u
*endp
, typval_T
*rettv
, int copy
, char_u
*op
));
400 static int tv_op
__ARGS((typval_T
*tv1
, typval_T
*tv2
, char_u
*op
));
401 static void list_add_watch
__ARGS((list_T
*l
, listwatch_T
*lw
));
402 static void list_rem_watch
__ARGS((list_T
*l
, listwatch_T
*lwrem
));
403 static void list_fix_watch
__ARGS((list_T
*l
, listitem_T
*item
));
404 static void ex_unletlock
__ARGS((exarg_T
*eap
, char_u
*argstart
, int deep
));
405 static int do_unlet_var
__ARGS((lval_T
*lp
, char_u
*name_end
, int forceit
));
406 static int do_lock_var
__ARGS((lval_T
*lp
, char_u
*name_end
, int deep
, int lock
));
407 static void item_lock
__ARGS((typval_T
*tv
, int deep
, int lock
));
408 static int tv_islocked
__ARGS((typval_T
*tv
));
410 static int eval0
__ARGS((char_u
*arg
, typval_T
*rettv
, char_u
**nextcmd
, int evaluate
));
411 static int eval1
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
412 static int eval2
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
413 static int eval3
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
414 static int eval4
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
415 static int eval5
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
416 static int eval6
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
, int want_string
));
417 static int eval7
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
, int want_string
));
419 static int eval_index
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
, int verbose
));
420 static int get_option_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
421 static int get_string_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
422 static int get_lit_string_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
423 static int get_list_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
424 static int rettv_list_alloc
__ARGS((typval_T
*rettv
));
425 static listitem_T
*listitem_alloc
__ARGS((void));
426 static void listitem_free
__ARGS((listitem_T
*item
));
427 static void listitem_remove
__ARGS((list_T
*l
, listitem_T
*item
));
428 static long list_len
__ARGS((list_T
*l
));
429 static int list_equal
__ARGS((list_T
*l1
, list_T
*l2
, int ic
));
430 static int dict_equal
__ARGS((dict_T
*d1
, dict_T
*d2
, int ic
));
431 static int tv_equal
__ARGS((typval_T
*tv1
, typval_T
*tv2
, int ic
));
432 static listitem_T
*list_find
__ARGS((list_T
*l
, long n
));
433 static long list_find_nr
__ARGS((list_T
*l
, long idx
, int *errorp
));
434 static long list_idx_of_item
__ARGS((list_T
*l
, listitem_T
*item
));
435 static void list_append
__ARGS((list_T
*l
, listitem_T
*item
));
436 static int list_append_number
__ARGS((list_T
*l
, varnumber_T n
));
437 static int list_insert_tv
__ARGS((list_T
*l
, typval_T
*tv
, listitem_T
*item
));
438 static int list_extend
__ARGS((list_T
*l1
, list_T
*l2
, listitem_T
*bef
));
439 static int list_concat
__ARGS((list_T
*l1
, list_T
*l2
, typval_T
*tv
));
440 static list_T
*list_copy
__ARGS((list_T
*orig
, int deep
, int copyID
));
441 static void list_remove
__ARGS((list_T
*l
, listitem_T
*item
, listitem_T
*item2
));
442 static char_u
*list2string
__ARGS((typval_T
*tv
, int copyID
));
443 static int list_join
__ARGS((garray_T
*gap
, list_T
*l
, char_u
*sep
, int echo
, int copyID
));
444 static int free_unref_items
__ARGS((int copyID
));
445 static void set_ref_in_ht
__ARGS((hashtab_T
*ht
, int copyID
));
446 static void set_ref_in_list
__ARGS((list_T
*l
, int copyID
));
447 static void set_ref_in_item
__ARGS((typval_T
*tv
, int copyID
));
448 static void dict_unref
__ARGS((dict_T
*d
));
449 static void dict_free
__ARGS((dict_T
*d
, int recurse
));
450 static dictitem_T
*dictitem_copy
__ARGS((dictitem_T
*org
));
451 static void dictitem_remove
__ARGS((dict_T
*dict
, dictitem_T
*item
));
452 static dict_T
*dict_copy
__ARGS((dict_T
*orig
, int deep
, int copyID
));
453 static long dict_len
__ARGS((dict_T
*d
));
454 static char_u
*dict2string
__ARGS((typval_T
*tv
, int copyID
));
455 static int get_dict_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
456 static char_u
*echo_string
__ARGS((typval_T
*tv
, char_u
**tofree
, char_u
*numbuf
, int copyID
));
457 static char_u
*tv2string
__ARGS((typval_T
*tv
, char_u
**tofree
, char_u
*numbuf
, int copyID
));
458 static char_u
*string_quote
__ARGS((char_u
*str
, int function
));
460 static int string2float
__ARGS((char_u
*text
, float_T
*value
));
462 static int get_env_tv
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
));
463 static int find_internal_func
__ARGS((char_u
*name
));
464 static char_u
*deref_func_name
__ARGS((char_u
*name
, int *lenp
));
465 static int get_func_tv
__ARGS((char_u
*name
, int len
, typval_T
*rettv
, char_u
**arg
, linenr_T firstline
, linenr_T lastline
, int *doesrange
, int evaluate
, dict_T
*selfdict
));
466 static int call_func
__ARGS((char_u
*func_name
, int len
, typval_T
*rettv
, int argcount
, typval_T
*argvars
, linenr_T firstline
, linenr_T lastline
, int *doesrange
, int evaluate
, dict_T
*selfdict
));
467 static void emsg_funcname
__ARGS((char *ermsg
, char_u
*name
));
468 static int non_zero_arg
__ARGS((typval_T
*argvars
));
471 static void f_abs
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
473 /* Below are the 10 added FP functions - I've kept them together */
474 /* here and in their definitions later on. Because the functions[] */
475 /* table must be in ASCII order, they are scattered there - WJMc */
477 static void f_acos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
478 static void f_asin
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
479 static void f_atan2
__ARGS((typval_T
*argvars
, typval_T
*rettv
)); /* 2 args */
480 static void f_cosh
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
481 static void f_exp
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
482 static void f_fmod
__ARGS((typval_T
*argvars
, typval_T
*rettv
)); /* 2 args */
483 static void f_log
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
484 static void f_sinh
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
485 static void f_tan
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
486 static void f_tanh
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
488 static void f_add
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
489 static void f_append
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
490 static void f_argc
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
491 static void f_argidx
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
492 static void f_argv
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
494 static void f_atan
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
496 static void f_browse
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
497 static void f_browsedir
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
498 static void f_bufexists
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
499 static void f_buflisted
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
500 static void f_bufloaded
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
501 static void f_bufname
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
502 static void f_bufnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
503 static void f_bufwinnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
504 static void f_byte2line
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
505 static void f_byteidx
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
506 static void f_call
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
508 static void f_ceil
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
510 static void f_changenr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
511 static void f_char2nr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
512 static void f_cindent
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
513 static void f_clearmatches
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
514 static void f_col
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
515 #if defined(FEAT_INS_EXPAND)
516 static void f_complete
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
517 static void f_complete_add
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
518 static void f_complete_check
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
520 static void f_confirm
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
521 static void f_copy
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
523 static void f_cos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
525 static void f_count
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
526 static void f_cscope_connection
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
527 static void f_cursor
__ARGS((typval_T
*argsvars
, typval_T
*rettv
));
528 static void f_deepcopy
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
529 static void f_delete
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
530 static void f_did_filetype
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
531 static void f_diff_filler
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
532 static void f_diff_hlID
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
533 static void f_empty
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
534 static void f_escape
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
535 static void f_eval
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
536 static void f_eventhandler
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
537 static void f_executable
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
538 static void f_exists
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
539 static void f_expand
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
540 static void f_extend
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
541 static void f_feedkeys
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
542 static void f_filereadable
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
543 static void f_filewritable
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
544 static void f_filter
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
545 static void f_finddir
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
546 static void f_findfile
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
548 static void f_float2nr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
549 static void f_floor
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
551 static void f_fnameescape
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
552 static void f_fnamemodify
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
553 static void f_foldclosed
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
554 static void f_foldclosedend
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
555 static void f_foldlevel
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
556 static void f_foldtext
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
557 static void f_foldtextresult
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
558 static void f_foreground
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
559 static void f_function
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
560 static void f_garbagecollect
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
561 static void f_get
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
562 static void f_getbufline
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
563 static void f_getbufvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
564 static void f_getchar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
565 static void f_getcharmod
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
566 static void f_getcmdline
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
567 static void f_getcmdpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
568 static void f_getcmdtype
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
569 static void f_getcwd
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
570 static void f_getfontname
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
571 static void f_getfperm
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
572 static void f_getfsize
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
573 static void f_getftime
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
574 static void f_getftype
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
575 static void f_getline
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
576 static void f_getmatches
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
577 static void f_getpid
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
578 static void f_getpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
579 static void f_getqflist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
580 static void f_getreg
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
581 static void f_getregtype
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
582 static void f_gettabwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
583 static void f_getwinposx
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
584 static void f_getwinposy
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
585 static void f_getwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
586 static void f_glob
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
587 static void f_globpath
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
588 static void f_has
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
589 static void f_has_key
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
590 static void f_haslocaldir
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
591 static void f_hasmapto
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
592 static void f_histadd
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
593 static void f_histdel
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
594 static void f_histget
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
595 static void f_histnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
596 static void f_hlID
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
597 static void f_hlexists
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
598 static void f_hostname
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
599 static void f_iconv
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
600 static void f_indent
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
601 static void f_index
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
602 static void f_input
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
603 static void f_inputdialog
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
604 static void f_inputlist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
605 static void f_inputrestore
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
606 static void f_inputsave
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
607 static void f_inputsecret
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
608 static void f_insert
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
609 static void f_isdirectory
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
610 static void f_islocked
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
611 static void f_items
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
612 static void f_join
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
613 static void f_keys
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
614 static void f_last_buffer_nr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
615 static void f_len
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
616 static void f_libcall
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
617 static void f_libcallnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
618 static void f_line
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
619 static void f_line2byte
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
620 static void f_lispindent
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
621 static void f_localtime
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
623 static void f_log10
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
625 static void f_map
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
626 static void f_maparg
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
627 static void f_mapcheck
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
628 static void f_match
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
629 static void f_matchadd
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
630 static void f_matcharg
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
631 static void f_matchdelete
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
632 static void f_matchend
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
633 static void f_matchlist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
634 static void f_matchstr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
635 static void f_max
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
636 static void f_min
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
638 static void f_mkdir
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
640 static void f_mode
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
642 static void f_mzeval
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
644 static void f_nextnonblank
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
645 static void f_nr2char
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
646 static void f_pathshorten
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
648 static void f_pow
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
650 static void f_prevnonblank
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
651 static void f_printf
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
652 static void f_pumvisible
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
653 static void f_range
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
654 static void f_readfile
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
655 static void f_reltime
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
656 static void f_reltimestr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
657 static void f_remote_expr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
658 static void f_remote_foreground
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
659 static void f_remote_peek
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
660 static void f_remote_read
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
661 static void f_remote_send
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
662 static void f_remove
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
663 static void f_rename
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
664 static void f_repeat
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
665 static void f_resolve
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
666 static void f_reverse
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
668 static void f_round
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
670 static void f_search
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
671 static void f_searchdecl
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
672 static void f_searchpair
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
673 static void f_searchpairpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
674 static void f_searchpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
675 static void f_server2client
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
676 static void f_serverlist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
677 static void f_setbufvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
678 static void f_setcmdpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
679 static void f_setline
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
680 static void f_setloclist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
681 static void f_setmatches
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
682 static void f_setpos
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
683 static void f_setqflist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
684 static void f_setreg
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
685 static void f_settabwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
686 static void f_setwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
687 static void f_shellescape
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
688 static void f_simplify
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
690 static void f_sin
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
692 static void f_sort
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
693 static void f_soundfold
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
694 static void f_spellbadword
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
695 static void f_spellsuggest
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
696 static void f_split
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
698 static void f_sqrt
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
699 static void f_str2float
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
701 static void f_str2nr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
703 static void f_strftime
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
705 static void f_stridx
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
706 static void f_string
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
707 static void f_strlen
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
708 static void f_strpart
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
709 static void f_strridx
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
710 static void f_strtrans
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
711 static void f_submatch
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
712 static void f_substitute
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
713 static void f_synID
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
714 static void f_synIDattr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
715 static void f_synIDtrans
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
716 static void f_synstack
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
717 static void f_system
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
718 static void f_tabpagebuflist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
719 static void f_tabpagenr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
720 static void f_tabpagewinnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
721 static void f_taglist
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
722 static void f_tagfiles
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
723 static void f_tempname
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
724 static void f_test
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
725 static void f_tolower
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
726 static void f_toupper
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
727 static void f_tr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
729 static void f_trunc
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
731 static void f_type
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
732 static void f_values
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
733 static void f_virtcol
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
734 static void f_visualmode
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
735 static void f_winbufnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
736 static void f_wincol
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
737 static void f_winheight
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
738 static void f_winline
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
739 static void f_winnr
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
740 static void f_winrestcmd
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
741 static void f_winrestview
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
742 static void f_winsaveview
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
743 static void f_winwidth
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
744 static void f_writefile
__ARGS((typval_T
*argvars
, typval_T
*rettv
));
746 static int list2fpos
__ARGS((typval_T
*arg
, pos_T
*posp
, int *fnump
));
747 static pos_T
*var2fpos
__ARGS((typval_T
*varp
, int dollar_lnum
, int *fnum
));
748 static int get_env_len
__ARGS((char_u
**arg
));
749 static int get_id_len
__ARGS((char_u
**arg
));
750 static int get_name_len
__ARGS((char_u
**arg
, char_u
**alias
, int evaluate
, int verbose
));
751 static char_u
*find_name_end
__ARGS((char_u
*arg
, char_u
**expr_start
, char_u
**expr_end
, int flags
));
752 #define FNE_INCL_BR 1 /* find_name_end(): include [] in name */
753 #define FNE_CHECK_START 2 /* find_name_end(): check name starts with
755 static char_u
* make_expanded_name
__ARGS((char_u
*in_start
, char_u
*expr_start
, char_u
*expr_end
, char_u
*in_end
));
756 static int eval_isnamec
__ARGS((int c
));
757 static int eval_isnamec1
__ARGS((int c
));
758 static int get_var_tv
__ARGS((char_u
*name
, int len
, typval_T
*rettv
, int verbose
));
759 static int handle_subscript
__ARGS((char_u
**arg
, typval_T
*rettv
, int evaluate
, int verbose
));
760 static typval_T
*alloc_tv
__ARGS((void));
761 static typval_T
*alloc_string_tv
__ARGS((char_u
*string
));
762 static void init_tv
__ARGS((typval_T
*varp
));
763 static long get_tv_number
__ARGS((typval_T
*varp
));
764 static linenr_T get_tv_lnum
__ARGS((typval_T
*argvars
));
765 static linenr_T get_tv_lnum_buf
__ARGS((typval_T
*argvars
, buf_T
*buf
));
766 static char_u
*get_tv_string
__ARGS((typval_T
*varp
));
767 static char_u
*get_tv_string_buf
__ARGS((typval_T
*varp
, char_u
*buf
));
768 static char_u
*get_tv_string_buf_chk
__ARGS((typval_T
*varp
, char_u
*buf
));
769 static dictitem_T
*find_var
__ARGS((char_u
*name
, hashtab_T
**htp
));
770 static dictitem_T
*find_var_in_ht
__ARGS((hashtab_T
*ht
, char_u
*varname
, int writing
));
771 static hashtab_T
*find_var_ht
__ARGS((char_u
*name
, char_u
**varname
));
772 static void vars_clear_ext
__ARGS((hashtab_T
*ht
, int free_val
));
773 static void delete_var
__ARGS((hashtab_T
*ht
, hashitem_T
*hi
));
774 static void list_one_var
__ARGS((dictitem_T
*v
, char_u
*prefix
, int *first
));
775 static void list_one_var_a
__ARGS((char_u
*prefix
, char_u
*name
, int type
, char_u
*string
, int *first
));
776 static void set_var
__ARGS((char_u
*name
, typval_T
*varp
, int copy
));
777 static int var_check_ro
__ARGS((int flags
, char_u
*name
));
778 static int var_check_fixed
__ARGS((int flags
, char_u
*name
));
779 static int tv_check_lock
__ARGS((int lock
, char_u
*name
));
780 static int item_copy
__ARGS((typval_T
*from
, typval_T
*to
, int deep
, int copyID
));
781 static char_u
*find_option_end
__ARGS((char_u
**arg
, int *opt_flags
));
782 static char_u
*trans_function_name
__ARGS((char_u
**pp
, int skip
, int flags
, funcdict_T
*fd
));
783 static int eval_fname_script
__ARGS((char_u
*p
));
784 static int eval_fname_sid
__ARGS((char_u
*p
));
785 static void list_func_head
__ARGS((ufunc_T
*fp
, int indent
));
786 static ufunc_T
*find_func
__ARGS((char_u
*name
));
787 static int function_exists
__ARGS((char_u
*name
));
788 static int builtin_function
__ARGS((char_u
*name
));
790 static void func_do_profile
__ARGS((ufunc_T
*fp
));
791 static void prof_sort_list
__ARGS((FILE *fd
, ufunc_T
**sorttab
, int st_len
, char *title
, int prefer_self
));
792 static void prof_func_line
__ARGS((FILE *fd
, int count
, proftime_T
*total
, proftime_T
*self
, int prefer_self
));
797 prof_total_cmp
__ARGS((const void *s1
, const void *s2
));
802 prof_self_cmp
__ARGS((const void *s1
, const void *s2
));
804 static int script_autoload
__ARGS((char_u
*name
, int reload
));
805 static char_u
*autoload_name
__ARGS((char_u
*name
));
806 static void cat_func_name
__ARGS((char_u
*buf
, ufunc_T
*fp
));
807 static void func_free
__ARGS((ufunc_T
*fp
));
808 static void func_unref
__ARGS((char_u
*name
));
809 static void func_ref
__ARGS((char_u
*name
));
810 static void call_user_func
__ARGS((ufunc_T
*fp
, int argcount
, typval_T
*argvars
, typval_T
*rettv
, linenr_T firstline
, linenr_T lastline
, dict_T
*selfdict
));
811 static int can_free_funccal
__ARGS((funccall_T
*fc
, int copyID
)) ;
812 static void free_funccal
__ARGS((funccall_T
*fc
, int free_val
));
813 static void add_nr_var
__ARGS((dict_T
*dp
, dictitem_T
*v
, char *name
, varnumber_T nr
));
814 static win_T
*find_win_by_nr
__ARGS((typval_T
*vp
, tabpage_T
*tp
));
815 static void getwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int off
));
816 static int searchpair_cmn
__ARGS((typval_T
*argvars
, pos_T
*match_pos
));
817 static int search_cmn
__ARGS((typval_T
*argvars
, pos_T
*match_pos
, int *flagsp
));
818 static void setwinvar
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int off
));
820 /* Character used as separated in autoload function/variable names. */
821 #define AUTOLOAD_CHAR '#'
824 * Initialize the global and v: variables.
832 init_var_dict(&globvardict
, &globvars_var
);
833 init_var_dict(&vimvardict
, &vimvars_var
);
834 hash_init(&compat_hashtab
);
835 hash_init(&func_hashtab
);
837 for (i
= 0; i
< VV_LEN
; ++i
)
840 STRCPY(p
->vv_di
.di_key
, p
->vv_name
);
841 if (p
->vv_flags
& VV_RO
)
842 p
->vv_di
.di_flags
= DI_FLAGS_RO
| DI_FLAGS_FIX
;
843 else if (p
->vv_flags
& VV_RO_SBX
)
844 p
->vv_di
.di_flags
= DI_FLAGS_RO_SBX
| DI_FLAGS_FIX
;
846 p
->vv_di
.di_flags
= DI_FLAGS_FIX
;
848 /* add to v: scope dict, unless the value is not always available */
849 if (p
->vv_type
!= VAR_UNKNOWN
)
850 hash_add(&vimvarht
, p
->vv_di
.di_key
);
851 if (p
->vv_flags
& VV_COMPAT
)
852 /* add to compat scope dict */
853 hash_add(&compat_hashtab
, p
->vv_di
.di_key
);
855 set_vim_var_nr(VV_SEARCHFORWARD
, 1L);
858 #if defined(EXITFREE) || defined(PROTO)
865 for (i
= 0; i
< VV_LEN
; ++i
)
868 if (p
->vv_di
.di_tv
.v_type
== VAR_STRING
)
873 else if (p
->vv_di
.di_tv
.v_type
== VAR_LIST
)
875 list_unref(p
->vv_list
);
879 hash_clear(&vimvarht
);
880 hash_init(&vimvarht
); /* garbage_collect() will access it */
881 hash_clear(&compat_hashtab
);
885 /* global variables */
886 vars_clear(&globvarht
);
888 /* autoloaded script names */
889 ga_clear_strings(&ga_loaded
);
891 /* script-local variables */
892 for (i
= 1; i
<= ga_scripts
.ga_len
; ++i
)
894 vars_clear(&SCRIPT_VARS(i
));
895 vim_free(SCRIPT_SV(i
));
897 ga_clear(&ga_scripts
);
899 /* unreferenced lists and dicts */
900 (void)garbage_collect();
903 free_all_functions();
904 hash_clear(&func_hashtab
);
909 * Return the name of the executed function.
915 return ((funccall_T
*)cookie
)->func
->uf_name
;
919 * Return the address holding the next breakpoint line for a funccall cookie.
922 func_breakpoint(cookie
)
925 return &((funccall_T
*)cookie
)->breakpoint
;
929 * Return the address holding the debug tick for a funccall cookie.
932 func_dbg_tick(cookie
)
935 return &((funccall_T
*)cookie
)->dbg_tick
;
939 * Return the nesting level for a funccall cookie.
945 return ((funccall_T
*)cookie
)->level
;
948 /* pointer to funccal for currently active function */
949 funccall_T
*current_funccal
= NULL
;
951 /* pointer to list of previously used funccal, still around because some
952 * item in it is still being used. */
953 funccall_T
*previous_funccal
= NULL
;
956 * Return TRUE when a function was ended by a ":return" command.
959 current_func_returned()
961 return current_funccal
->returned
;
966 * Set an internal variable to a string value. Creates the variable if it does
970 set_internal_string_var(name
, value
)
977 val
= vim_strsave(value
);
980 tvp
= alloc_string_tv(val
);
983 set_var(name
, tvp
, FALSE
);
989 static lval_T
*redir_lval
= NULL
;
990 static garray_T redir_ga
; /* only valid when redir_lval is not NULL */
991 static char_u
*redir_endp
= NULL
;
992 static char_u
*redir_varname
= NULL
;
995 * Start recording command output to a variable
996 * Returns OK if successfully completed the setup. FAIL otherwise.
999 var_redir_start(name
, append
)
1001 int append
; /* append to an existing variable */
1007 /* Catch a bad name early. */
1008 if (!eval_isnamec1(*name
))
1014 /* Make a copy of the name, it is used in redir_lval until redir ends. */
1015 redir_varname
= vim_strsave(name
);
1016 if (redir_varname
== NULL
)
1019 redir_lval
= (lval_T
*)alloc_clear((unsigned)sizeof(lval_T
));
1020 if (redir_lval
== NULL
)
1026 /* The output is stored in growarray "redir_ga" until redirection ends. */
1027 ga_init2(&redir_ga
, (int)sizeof(char), 500);
1029 /* Parse the variable name (can be a dict or list entry). */
1030 redir_endp
= get_lval(redir_varname
, NULL
, redir_lval
, FALSE
, FALSE
, FALSE
,
1032 if (redir_endp
== NULL
|| redir_lval
->ll_name
== NULL
|| *redir_endp
!= NUL
)
1034 if (redir_endp
!= NULL
&& *redir_endp
!= NUL
)
1035 /* Trailing characters are present after the variable name */
1036 EMSG(_(e_trailing
));
1039 redir_endp
= NULL
; /* don't store a value, only cleanup */
1044 /* check if we can write to the variable: set it to or append an empty
1046 save_emsg
= did_emsg
;
1048 tv
.v_type
= VAR_STRING
;
1049 tv
.vval
.v_string
= (char_u
*)"";
1051 set_var_lval(redir_lval
, redir_endp
, &tv
, TRUE
, (char_u
*)".");
1053 set_var_lval(redir_lval
, redir_endp
, &tv
, TRUE
, (char_u
*)"=");
1055 did_emsg
|= save_emsg
;
1058 redir_endp
= NULL
; /* don't store a value, only cleanup */
1062 if (redir_lval
->ll_newkey
!= NULL
)
1064 /* Dictionary item was created, don't do it again. */
1065 vim_free(redir_lval
->ll_newkey
);
1066 redir_lval
->ll_newkey
= NULL
;
1073 * Append "value[value_len]" to the variable set by var_redir_start().
1074 * The actual appending is postponed until redirection ends, because the value
1075 * appended may in fact be the string we write to, changing it may cause freed
1076 * memory to be used:
1082 var_redir_str(value
, value_len
)
1088 if (redir_lval
== NULL
)
1091 if (value_len
== -1)
1092 len
= (int)STRLEN(value
); /* Append the entire string */
1094 len
= value_len
; /* Append only "value_len" characters */
1096 if (ga_grow(&redir_ga
, len
) == OK
)
1098 mch_memmove((char *)redir_ga
.ga_data
+ redir_ga
.ga_len
, value
, len
);
1099 redir_ga
.ga_len
+= len
;
1106 * Stop redirecting command output to a variable.
1107 * Frees the allocated memory.
1114 if (redir_lval
!= NULL
)
1116 /* If there was no error: assign the text to the variable. */
1117 if (redir_endp
!= NULL
)
1119 ga_append(&redir_ga
, NUL
); /* Append the trailing NUL. */
1120 tv
.v_type
= VAR_STRING
;
1121 tv
.vval
.v_string
= redir_ga
.ga_data
;
1122 set_var_lval(redir_lval
, redir_endp
, &tv
, FALSE
, (char_u
*)".");
1125 /* free the collected output */
1126 vim_free(redir_ga
.ga_data
);
1127 redir_ga
.ga_data
= NULL
;
1129 clear_lval(redir_lval
);
1130 vim_free(redir_lval
);
1133 vim_free(redir_varname
);
1134 redir_varname
= NULL
;
1137 # if defined(FEAT_MBYTE) || defined(PROTO)
1139 eval_charconvert(enc_from
, enc_to
, fname_from
, fname_to
)
1147 set_vim_var_string(VV_CC_FROM
, enc_from
, -1);
1148 set_vim_var_string(VV_CC_TO
, enc_to
, -1);
1149 set_vim_var_string(VV_FNAME_IN
, fname_from
, -1);
1150 set_vim_var_string(VV_FNAME_OUT
, fname_to
, -1);
1151 if (eval_to_bool(p_ccv
, &err
, NULL
, FALSE
))
1153 set_vim_var_string(VV_CC_FROM
, NULL
, -1);
1154 set_vim_var_string(VV_CC_TO
, NULL
, -1);
1155 set_vim_var_string(VV_FNAME_IN
, NULL
, -1);
1156 set_vim_var_string(VV_FNAME_OUT
, NULL
, -1);
1164 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1166 eval_printexpr(fname
, args
)
1172 set_vim_var_string(VV_FNAME_IN
, fname
, -1);
1173 set_vim_var_string(VV_CMDARG
, args
, -1);
1174 if (eval_to_bool(p_pexpr
, &err
, NULL
, FALSE
))
1176 set_vim_var_string(VV_FNAME_IN
, NULL
, -1);
1177 set_vim_var_string(VV_CMDARG
, NULL
, -1);
1188 # if defined(FEAT_DIFF) || defined(PROTO)
1190 eval_diff(origfile
, newfile
, outfile
)
1197 set_vim_var_string(VV_FNAME_IN
, origfile
, -1);
1198 set_vim_var_string(VV_FNAME_NEW
, newfile
, -1);
1199 set_vim_var_string(VV_FNAME_OUT
, outfile
, -1);
1200 (void)eval_to_bool(p_dex
, &err
, NULL
, FALSE
);
1201 set_vim_var_string(VV_FNAME_IN
, NULL
, -1);
1202 set_vim_var_string(VV_FNAME_NEW
, NULL
, -1);
1203 set_vim_var_string(VV_FNAME_OUT
, NULL
, -1);
1207 eval_patch(origfile
, difffile
, outfile
)
1214 set_vim_var_string(VV_FNAME_IN
, origfile
, -1);
1215 set_vim_var_string(VV_FNAME_DIFF
, difffile
, -1);
1216 set_vim_var_string(VV_FNAME_OUT
, outfile
, -1);
1217 (void)eval_to_bool(p_pex
, &err
, NULL
, FALSE
);
1218 set_vim_var_string(VV_FNAME_IN
, NULL
, -1);
1219 set_vim_var_string(VV_FNAME_DIFF
, NULL
, -1);
1220 set_vim_var_string(VV_FNAME_OUT
, NULL
, -1);
1225 * Top level evaluation function, returning a boolean.
1226 * Sets "error" to TRUE if there was an error.
1227 * Return TRUE or FALSE.
1230 eval_to_bool(arg
, error
, nextcmd
, skip
)
1234 int skip
; /* only parse, don't execute */
1241 if (eval0(arg
, &tv
, nextcmd
, !skip
) == FAIL
)
1248 retval
= (get_tv_number_chk(&tv
, error
) != 0);
1259 * Top level evaluation function, returning a string. If "skip" is TRUE,
1260 * only parsing to "nextcmd" is done, without reporting errors. Return
1261 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1264 eval_to_string_skip(arg
, nextcmd
, skip
)
1267 int skip
; /* only parse, don't execute */
1274 if (eval0(arg
, &tv
, nextcmd
, !skip
) == FAIL
|| skip
)
1278 retval
= vim_strsave(get_tv_string(&tv
));
1288 * Skip over an expression at "*pp".
1289 * Return FAIL for an error, OK otherwise.
1297 *pp
= skipwhite(*pp
);
1298 return eval1(pp
, &rettv
, FALSE
);
1302 * Top level evaluation function, returning a string.
1303 * When "convert" is TRUE convert a List into a sequence of lines and convert
1304 * a Float to a String.
1305 * Return pointer to allocated memory, or NULL for failure.
1308 eval_to_string(arg
, nextcmd
, convert
)
1317 char_u numbuf
[NUMBUFLEN
];
1320 if (eval0(arg
, &tv
, nextcmd
, TRUE
) == FAIL
)
1324 if (convert
&& tv
.v_type
== VAR_LIST
)
1326 ga_init2(&ga
, (int)sizeof(char), 80);
1327 if (tv
.vval
.v_list
!= NULL
)
1328 list_join(&ga
, tv
.vval
.v_list
, (char_u
*)"\n", TRUE
, 0);
1329 ga_append(&ga
, NUL
);
1330 retval
= (char_u
*)ga
.ga_data
;
1333 else if (convert
&& tv
.v_type
== VAR_FLOAT
)
1335 vim_snprintf((char *)numbuf
, NUMBUFLEN
, "%g", tv
.vval
.v_float
);
1336 retval
= vim_strsave(numbuf
);
1340 retval
= vim_strsave(get_tv_string(&tv
));
1348 * Call eval_to_string() without using current local variables and using
1349 * textlock. When "use_sandbox" is TRUE use the sandbox.
1352 eval_to_string_safe(arg
, nextcmd
, use_sandbox
)
1358 void *save_funccalp
;
1360 save_funccalp
= save_funccal();
1364 retval
= eval_to_string(arg
, nextcmd
, FALSE
);
1368 restore_funccal(save_funccalp
);
1373 * Top level evaluation function, returning a number.
1374 * Evaluates "expr" silently.
1375 * Returns -1 for an error.
1378 eval_to_number(expr
)
1383 char_u
*p
= skipwhite(expr
);
1387 if (eval1(&p
, &rettv
, TRUE
) == FAIL
)
1391 retval
= get_tv_number_chk(&rettv
, NULL
);
1400 * Prepare v: variable "idx" to be used.
1401 * Save the current typeval in "save_tv".
1402 * When not used yet add the variable to the v: hashtable.
1405 prepare_vimvar(idx
, save_tv
)
1409 *save_tv
= vimvars
[idx
].vv_tv
;
1410 if (vimvars
[idx
].vv_type
== VAR_UNKNOWN
)
1411 hash_add(&vimvarht
, vimvars
[idx
].vv_di
.di_key
);
1415 * Restore v: variable "idx" to typeval "save_tv".
1416 * When no longer defined, remove the variable from the v: hashtable.
1419 restore_vimvar(idx
, save_tv
)
1425 vimvars
[idx
].vv_tv
= *save_tv
;
1426 if (vimvars
[idx
].vv_type
== VAR_UNKNOWN
)
1428 hi
= hash_find(&vimvarht
, vimvars
[idx
].vv_di
.di_key
);
1429 if (HASHITEM_EMPTY(hi
))
1430 EMSG2(_(e_intern2
), "restore_vimvar()");
1432 hash_remove(&vimvarht
, hi
);
1436 #if defined(FEAT_SPELL) || defined(PROTO)
1438 * Evaluate an expression to a list with suggestions.
1439 * For the "expr:" part of 'spellsuggest'.
1440 * Returns NULL when there is an error.
1443 eval_spell_expr(badword
, expr
)
1449 list_T
*list
= NULL
;
1450 char_u
*p
= skipwhite(expr
);
1452 /* Set "v:val" to the bad word. */
1453 prepare_vimvar(VV_VAL
, &save_val
);
1454 vimvars
[VV_VAL
].vv_type
= VAR_STRING
;
1455 vimvars
[VV_VAL
].vv_str
= badword
;
1459 if (eval1(&p
, &rettv
, TRUE
) == OK
)
1461 if (rettv
.v_type
!= VAR_LIST
)
1464 list
= rettv
.vval
.v_list
;
1469 restore_vimvar(VV_VAL
, &save_val
);
1475 * "list" is supposed to contain two items: a word and a number. Return the
1476 * word in "pp" and the number as the return value.
1477 * Return -1 if anything isn't right.
1478 * Used to get the good word and score from the eval_spell_expr() result.
1481 get_spellword(list
, pp
)
1487 li
= list
->lv_first
;
1490 *pp
= get_tv_string(&li
->li_tv
);
1495 return get_tv_number(&li
->li_tv
);
1500 * Top level evaluation function.
1501 * Returns an allocated typval_T with the result.
1502 * Returns NULL when there is an error.
1505 eval_expr(arg
, nextcmd
)
1511 tv
= (typval_T
*)alloc(sizeof(typval_T
));
1512 if (tv
!= NULL
&& eval0(arg
, tv
, nextcmd
, TRUE
) == FAIL
)
1522 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1523 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1525 * Call some vimL function and return the result in "*rettv".
1526 * Uses argv[argc] for the function arguments. Only Number and String
1527 * arguments are currently supported.
1528 * Returns OK or FAIL.
1531 call_vim_function(func
, argc
, argv
, safe
, rettv
)
1535 int safe
; /* use the sandbox */
1543 void *save_funccalp
= NULL
;
1546 argvars
= (typval_T
*)alloc((unsigned)((argc
+ 1) * sizeof(typval_T
)));
1547 if (argvars
== NULL
)
1550 for (i
= 0; i
< argc
; i
++)
1552 /* Pass a NULL or empty argument as an empty string */
1553 if (argv
[i
] == NULL
|| *argv
[i
] == NUL
)
1555 argvars
[i
].v_type
= VAR_STRING
;
1556 argvars
[i
].vval
.v_string
= (char_u
*)"";
1560 /* Recognize a number argument, the others must be strings. */
1561 vim_str2nr(argv
[i
], NULL
, &len
, TRUE
, TRUE
, &n
, NULL
);
1562 if (len
!= 0 && len
== (int)STRLEN(argv
[i
]))
1564 argvars
[i
].v_type
= VAR_NUMBER
;
1565 argvars
[i
].vval
.v_number
= n
;
1569 argvars
[i
].v_type
= VAR_STRING
;
1570 argvars
[i
].vval
.v_string
= argv
[i
];
1576 save_funccalp
= save_funccal();
1580 rettv
->v_type
= VAR_UNKNOWN
; /* clear_tv() uses this */
1581 ret
= call_func(func
, (int)STRLEN(func
), rettv
, argc
, argvars
,
1582 curwin
->w_cursor
.lnum
, curwin
->w_cursor
.lnum
,
1583 &doesrange
, TRUE
, NULL
);
1587 restore_funccal(save_funccalp
);
1597 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1599 * Call vimL function "func" and return the result as a string.
1600 * Returns NULL when calling the function fails.
1601 * Uses argv[argc] for the function arguments.
1604 call_func_retstr(func
, argc
, argv
, safe
)
1608 int safe
; /* use the sandbox */
1613 if (call_vim_function(func
, argc
, argv
, safe
, &rettv
) == FAIL
)
1616 retval
= vim_strsave(get_tv_string(&rettv
));
1622 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1624 * Call vimL function "func" and return the result as a number.
1625 * Returns -1 when calling the function fails.
1626 * Uses argv[argc] for the function arguments.
1629 call_func_retnr(func
, argc
, argv
, safe
)
1633 int safe
; /* use the sandbox */
1638 if (call_vim_function(func
, argc
, argv
, safe
, &rettv
) == FAIL
)
1641 retval
= get_tv_number_chk(&rettv
, NULL
);
1648 * Call vimL function "func" and return the result as a List.
1649 * Uses argv[argc] for the function arguments.
1650 * Returns NULL when there is something wrong.
1653 call_func_retlist(func
, argc
, argv
, safe
)
1657 int safe
; /* use the sandbox */
1661 if (call_vim_function(func
, argc
, argv
, safe
, &rettv
) == FAIL
)
1664 if (rettv
.v_type
!= VAR_LIST
)
1670 return rettv
.vval
.v_list
;
1676 * Save the current function call pointer, and set it to NULL.
1677 * Used when executing autocommands and for ":source".
1682 funccall_T
*fc
= current_funccal
;
1684 current_funccal
= NULL
;
1689 restore_funccal(vfc
)
1692 funccall_T
*fc
= (funccall_T
*)vfc
;
1694 current_funccal
= fc
;
1697 #if defined(FEAT_PROFILE) || defined(PROTO)
1699 * Prepare profiling for entering a child or something else that is not
1700 * counted for the script/function itself.
1701 * Should always be called in pair with prof_child_exit().
1704 prof_child_enter(tm
)
1705 proftime_T
*tm
; /* place to store waittime */
1707 funccall_T
*fc
= current_funccal
;
1709 if (fc
!= NULL
&& fc
->func
->uf_profiling
)
1710 profile_start(&fc
->prof_child
);
1711 script_prof_save(tm
);
1715 * Take care of time spent in a child.
1716 * Should always be called after prof_child_enter().
1720 proftime_T
*tm
; /* where waittime was stored */
1722 funccall_T
*fc
= current_funccal
;
1724 if (fc
!= NULL
&& fc
->func
->uf_profiling
)
1726 profile_end(&fc
->prof_child
);
1727 profile_sub_wait(tm
, &fc
->prof_child
); /* don't count waiting time */
1728 profile_add(&fc
->func
->uf_tm_children
, &fc
->prof_child
);
1729 profile_add(&fc
->func
->uf_tml_children
, &fc
->prof_child
);
1731 script_prof_restore(tm
);
1738 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1739 * it in "*cp". Doesn't give error messages.
1742 eval_foldexpr(arg
, cp
)
1749 int use_sandbox
= was_set_insecurely((char_u
*)"foldexpr",
1757 if (eval0(arg
, &tv
, NULL
, TRUE
) == FAIL
)
1761 /* If the result is a number, just return the number. */
1762 if (tv
.v_type
== VAR_NUMBER
)
1763 retval
= tv
.vval
.v_number
;
1764 else if (tv
.v_type
!= VAR_STRING
|| tv
.vval
.v_string
== NULL
)
1768 /* If the result is a string, check if there is a non-digit before
1770 s
= tv
.vval
.v_string
;
1771 if (!VIM_ISDIGIT(*s
) && *s
!= '-')
1773 retval
= atol((char *)s
);
1787 * ":let" list all variable values
1788 * ":let var1 var2" list variable values
1789 * ":let var = expr" assignment command.
1790 * ":let var += expr" assignment command.
1791 * ":let var -= expr" assignment command.
1792 * ":let var .= expr" assignment command.
1793 * ":let [var1, var2] = expr" unpack list.
1799 char_u
*arg
= eap
->arg
;
1800 char_u
*expr
= NULL
;
1809 argend
= skip_var_list(arg
, &var_count
, &semicolon
);
1812 if (argend
> arg
&& argend
[-1] == '.') /* for var.='str' */
1814 expr
= vim_strchr(argend
, '=');
1818 * ":let" without "=": list variables
1822 else if (!ends_excmd(*arg
))
1823 /* ":let var1 var2" */
1824 arg
= list_arg_vars(eap
, arg
, &first
);
1825 else if (!eap
->skip
)
1828 list_glob_vars(&first
);
1829 list_buf_vars(&first
);
1830 list_win_vars(&first
);
1832 list_tab_vars(&first
);
1834 list_script_vars(&first
);
1835 list_func_vars(&first
);
1836 list_vim_vars(&first
);
1838 eap
->nextcmd
= check_nextcmd(arg
);
1846 if (vim_strchr((char_u
*)"+-.", expr
[-1]) != NULL
)
1847 op
[0] = expr
[-1]; /* +=, -= or .= */
1849 expr
= skipwhite(expr
+ 1);
1853 i
= eval0(expr
, &rettv
, &eap
->nextcmd
, !eap
->skip
);
1862 (void)ex_let_vars(eap
->arg
, &rettv
, FALSE
, semicolon
, var_count
,
1870 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1871 * Handles both "var" with any type and "[var, var; var]" with a list type.
1872 * When "nextchars" is not NULL it points to a string with characters that
1873 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1875 * Returns OK or FAIL;
1878 ex_let_vars(arg_start
, tv
, copy
, semicolon
, var_count
, nextchars
)
1881 int copy
; /* copy values from "tv", don't move */
1882 int semicolon
; /* from skip_var_list() */
1883 int var_count
; /* from skip_var_list() */
1886 char_u
*arg
= arg_start
;
1895 * ":let var = expr" or ":for var in list"
1897 if (ex_let_one(arg
, tv
, copy
, nextchars
, nextchars
) == NULL
)
1903 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1905 if (tv
->v_type
!= VAR_LIST
|| (l
= tv
->vval
.v_list
) == NULL
)
1912 if (semicolon
== 0 && var_count
< i
)
1914 EMSG(_("E687: Less targets than List items"));
1917 if (var_count
- semicolon
> i
)
1919 EMSG(_("E688: More targets than List items"));
1926 arg
= skipwhite(arg
+ 1);
1927 arg
= ex_let_one(arg
, &item
->li_tv
, TRUE
, (char_u
*)",;]", nextchars
);
1928 item
= item
->li_next
;
1932 arg
= skipwhite(arg
);
1935 /* Put the rest of the list (may be empty) in the var after ';'.
1936 * Create a new list for this. */
1940 while (item
!= NULL
)
1942 list_append_tv(l
, &item
->li_tv
);
1943 item
= item
->li_next
;
1946 ltv
.v_type
= VAR_LIST
;
1948 ltv
.vval
.v_list
= l
;
1951 arg
= ex_let_one(skipwhite(arg
+ 1), <v
, FALSE
,
1952 (char_u
*)"]", nextchars
);
1958 else if (*arg
!= ',' && *arg
!= ']')
1960 EMSG2(_(e_intern2
), "ex_let_vars()");
1969 * Skip over assignable variable "var" or list of variables "[var, var]".
1970 * Used for ":let varvar = expr" and ":for varvar in expr".
1971 * For "[var, var]" increment "*var_count" for each variable.
1972 * for "[var, var; var]" set "semicolon".
1973 * Return NULL for an error.
1976 skip_var_list(arg
, var_count
, semicolon
)
1985 /* "[var, var]": find the matching ']'. */
1989 p
= skipwhite(p
+ 1); /* skip whites after '[', ';' or ',' */
1990 s
= skip_var_one(p
);
1993 EMSG2(_(e_invarg2
), p
);
2003 if (*semicolon
== 1)
2005 EMSG(_("Double ; in list of variables"));
2012 EMSG2(_(e_invarg2
), p
);
2019 return skip_var_one(arg
);
2023 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
2030 if (*arg
== '@' && arg
[1] != NUL
)
2032 return find_name_end(*arg
== '$' || *arg
== '&' ? arg
+ 1 : arg
,
2033 NULL
, NULL
, FNE_INCL_BR
| FNE_CHECK_START
);
2037 * List variables for hashtab "ht" with prefix "prefix".
2038 * If "empty" is TRUE also list NULL strings as empty strings.
2041 list_hashtable_vars(ht
, prefix
, empty
, first
)
2051 todo
= (int)ht
->ht_used
;
2052 for (hi
= ht
->ht_array
; todo
> 0 && !got_int
; ++hi
)
2054 if (!HASHITEM_EMPTY(hi
))
2058 if (empty
|| di
->di_tv
.v_type
!= VAR_STRING
2059 || di
->di_tv
.vval
.v_string
!= NULL
)
2060 list_one_var(di
, prefix
, first
);
2066 * List global variables.
2069 list_glob_vars(first
)
2072 list_hashtable_vars(&globvarht
, (char_u
*)"", TRUE
, first
);
2076 * List buffer variables.
2079 list_buf_vars(first
)
2082 char_u numbuf
[NUMBUFLEN
];
2084 list_hashtable_vars(&curbuf
->b_vars
.dv_hashtab
, (char_u
*)"b:",
2087 sprintf((char *)numbuf
, "%ld", (long)curbuf
->b_changedtick
);
2088 list_one_var_a((char_u
*)"b:", (char_u
*)"changedtick", VAR_NUMBER
,
2093 * List window variables.
2096 list_win_vars(first
)
2099 list_hashtable_vars(&curwin
->w_vars
.dv_hashtab
,
2100 (char_u
*)"w:", TRUE
, first
);
2105 * List tab page variables.
2108 list_tab_vars(first
)
2111 list_hashtable_vars(&curtab
->tp_vars
.dv_hashtab
,
2112 (char_u
*)"t:", TRUE
, first
);
2117 * List Vim variables.
2120 list_vim_vars(first
)
2123 list_hashtable_vars(&vimvarht
, (char_u
*)"v:", FALSE
, first
);
2127 * List script-local variables, if there is a script.
2130 list_script_vars(first
)
2133 if (current_SID
> 0 && current_SID
<= ga_scripts
.ga_len
)
2134 list_hashtable_vars(&SCRIPT_VARS(current_SID
),
2135 (char_u
*)"s:", FALSE
, first
);
2139 * List function variables, if there is a function.
2142 list_func_vars(first
)
2145 if (current_funccal
!= NULL
)
2146 list_hashtable_vars(¤t_funccal
->l_vars
.dv_hashtab
,
2147 (char_u
*)"l:", FALSE
, first
);
2151 * List variables in "arg".
2154 list_arg_vars(eap
, arg
, first
)
2167 while (!ends_excmd(*arg
) && !got_int
)
2169 if (error
|| eap
->skip
)
2171 arg
= find_name_end(arg
, NULL
, NULL
, FNE_INCL_BR
| FNE_CHECK_START
);
2172 if (!vim_iswhite(*arg
) && !ends_excmd(*arg
))
2175 EMSG(_(e_trailing
));
2181 /* get_name_len() takes care of expanding curly braces */
2182 name_start
= name
= arg
;
2183 len
= get_name_len(&arg
, &tofree
, TRUE
, TRUE
);
2186 /* This is mainly to keep test 49 working: when expanding
2187 * curly braces fails overrule the exception error message. */
2188 if (len
< 0 && !aborting())
2191 EMSG2(_(e_invarg2
), arg
);
2200 if (get_var_tv(name
, len
, &tv
, TRUE
) == FAIL
)
2204 /* handle d.key, l[idx], f(expr) */
2206 if (handle_subscript(&arg
, &tv
, TRUE
, TRUE
) == FAIL
)
2210 if (arg
== arg_subsc
&& len
== 2 && name
[1] == ':')
2214 case 'g': list_glob_vars(first
); break;
2215 case 'b': list_buf_vars(first
); break;
2216 case 'w': list_win_vars(first
); break;
2218 case 't': list_tab_vars(first
); break;
2220 case 'v': list_vim_vars(first
); break;
2221 case 's': list_script_vars(first
); break;
2222 case 'l': list_func_vars(first
); break;
2224 EMSG2(_("E738: Can't list variables for %s"), name
);
2229 char_u numbuf
[NUMBUFLEN
];
2234 s
= echo_string(&tv
, &tf
, numbuf
, 0);
2237 list_one_var_a((char_u
*)"",
2238 arg
== arg_subsc
? name
: name_start
,
2240 s
== NULL
? (char_u
*)"" : s
,
2253 arg
= skipwhite(arg
);
2260 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2261 * Returns a pointer to the char just after the var name.
2262 * Returns NULL if there is an error.
2265 ex_let_one(arg
, tv
, copy
, endchars
, op
)
2266 char_u
*arg
; /* points to variable name */
2267 typval_T
*tv
; /* value to assign to variable */
2268 int copy
; /* copy value from "tv" */
2269 char_u
*endchars
; /* valid chars after variable name or NULL */
2270 char_u
*op
; /* "+", "-", "." or NULL*/
2275 char_u
*arg_end
= NULL
;
2278 char_u
*tofree
= NULL
;
2281 * ":let $VAR = expr": Set environment variable.
2285 /* Find the end of the name. */
2288 len
= get_env_len(&arg
);
2290 EMSG2(_(e_invarg2
), name
- 1);
2293 if (op
!= NULL
&& (*op
== '+' || *op
== '-'))
2294 EMSG2(_(e_letwrong
), op
);
2295 else if (endchars
!= NULL
2296 && vim_strchr(endchars
, *skipwhite(arg
)) == NULL
)
2297 EMSG(_(e_letunexp
));
2302 p
= get_tv_string_chk(tv
);
2303 if (p
!= NULL
&& op
!= NULL
&& *op
== '.')
2305 int mustfree
= FALSE
;
2306 char_u
*s
= vim_getenv(name
, &mustfree
);
2310 p
= tofree
= concat_str(s
, p
);
2317 vim_setenv(name
, p
);
2318 if (STRICMP(name
, "HOME") == 0)
2320 else if (didset_vim
&& STRICMP(name
, "VIM") == 0)
2322 else if (didset_vimruntime
2323 && STRICMP(name
, "VIMRUNTIME") == 0)
2324 didset_vimruntime
= FALSE
;
2334 * ":let &option = expr": Set option value.
2335 * ":let &l:option = expr": Set local option value.
2336 * ":let &g:option = expr": Set global option value.
2338 else if (*arg
== '&')
2340 /* Find the end of the name. */
2341 p
= find_option_end(&arg
, &opt_flags
);
2342 if (p
== NULL
|| (endchars
!= NULL
2343 && vim_strchr(endchars
, *skipwhite(p
)) == NULL
))
2344 EMSG(_(e_letunexp
));
2350 char_u
*stringval
= NULL
;
2356 n
= get_tv_number(tv
);
2357 s
= get_tv_string_chk(tv
); /* != NULL if number or string */
2358 if (s
!= NULL
&& op
!= NULL
&& *op
!= '=')
2360 opt_type
= get_option_value(arg
, &numval
,
2361 &stringval
, opt_flags
);
2362 if ((opt_type
== 1 && *op
== '.')
2363 || (opt_type
== 0 && *op
!= '.'))
2364 EMSG2(_(e_letwrong
), op
);
2367 if (opt_type
== 1) /* number */
2374 else if (opt_type
== 0 && stringval
!= NULL
) /* string */
2376 s
= concat_str(stringval
, s
);
2377 vim_free(stringval
);
2384 set_option_value(arg
, n
, s
, opt_flags
);
2388 vim_free(stringval
);
2393 * ":let @r = expr": Set register contents.
2395 else if (*arg
== '@')
2398 if (op
!= NULL
&& (*op
== '+' || *op
== '-'))
2399 EMSG2(_(e_letwrong
), op
);
2400 else if (endchars
!= NULL
2401 && vim_strchr(endchars
, *skipwhite(arg
+ 1)) == NULL
)
2402 EMSG(_(e_letunexp
));
2405 char_u
*ptofree
= NULL
;
2408 p
= get_tv_string_chk(tv
);
2409 if (p
!= NULL
&& op
!= NULL
&& *op
== '.')
2411 s
= get_reg_contents(*arg
== '@' ? '"' : *arg
, TRUE
, TRUE
);
2414 p
= ptofree
= concat_str(s
, p
);
2420 write_reg_contents(*arg
== '@' ? '"' : *arg
, p
, -1, FALSE
);
2428 * ":let var = expr": Set internal variable.
2429 * ":let {expr} = expr": Idem, name made with curly braces
2431 else if (eval_isnamec1(*arg
) || *arg
== '{')
2435 p
= get_lval(arg
, tv
, &lv
, FALSE
, FALSE
, FALSE
, FNE_CHECK_START
);
2436 if (p
!= NULL
&& lv
.ll_name
!= NULL
)
2438 if (endchars
!= NULL
&& vim_strchr(endchars
, *skipwhite(p
)) == NULL
)
2439 EMSG(_(e_letunexp
));
2442 set_var_lval(&lv
, p
, tv
, copy
, op
);
2450 EMSG2(_(e_invarg2
), arg
);
2456 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2459 check_changedtick(arg
)
2462 if (STRNCMP(arg
, "b:changedtick", 13) == 0 && !eval_isnamec(arg
[13]))
2464 EMSG2(_(e_readonlyvar
), arg
);
2471 * Get an lval: variable, Dict item or List item that can be assigned a value
2472 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2473 * "name.key", "name.key[expr]" etc.
2474 * Indexing only works if "name" is an existing List or Dictionary.
2475 * "name" points to the start of the name.
2476 * If "rettv" is not NULL it points to the value to be assigned.
2477 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2478 * wrong; must end in space or cmd separator.
2480 * Returns a pointer to just after the name, including indexes.
2481 * When an evaluation error occurs "lp->ll_name" is NULL;
2482 * Returns NULL for a parsing error. Still need to free items in "lp"!
2485 get_lval(name
, rettv
, lp
, unlet
, skip
, quiet
, fne_flags
)
2491 int quiet
; /* don't give error messages */
2492 int fne_flags
; /* flags for find_name_end() */
2495 char_u
*expr_start
, *expr_end
;
2506 /* Clear everything in "lp". */
2507 vim_memset(lp
, 0, sizeof(lval_T
));
2511 /* When skipping just find the end of the name. */
2513 return find_name_end(name
, NULL
, NULL
, FNE_INCL_BR
| fne_flags
);
2516 /* Find the end of the name. */
2517 p
= find_name_end(name
, &expr_start
, &expr_end
, fne_flags
);
2518 if (expr_start
!= NULL
)
2520 /* Don't expand the name when we already know there is an error. */
2521 if (unlet
&& !vim_iswhite(*p
) && !ends_excmd(*p
)
2522 && *p
!= '[' && *p
!= '.')
2524 EMSG(_(e_trailing
));
2528 lp
->ll_exp_name
= make_expanded_name(name
, expr_start
, expr_end
, p
);
2529 if (lp
->ll_exp_name
== NULL
)
2531 /* Report an invalid expression in braces, unless the
2532 * expression evaluation has been cancelled due to an
2533 * aborting error, an interrupt, or an exception. */
2534 if (!aborting() && !quiet
)
2537 EMSG2(_(e_invarg2
), name
);
2541 lp
->ll_name
= lp
->ll_exp_name
;
2546 /* Without [idx] or .key we are done. */
2547 if ((*p
!= '[' && *p
!= '.') || lp
->ll_name
== NULL
)
2552 v
= find_var(lp
->ll_name
, &ht
);
2553 if (v
== NULL
&& !quiet
)
2554 EMSG2(_(e_undefvar
), lp
->ll_name
);
2560 * Loop until no more [idx] or .key is following.
2562 lp
->ll_tv
= &v
->di_tv
;
2563 while (*p
== '[' || (*p
== '.' && lp
->ll_tv
->v_type
== VAR_DICT
))
2565 if (!(lp
->ll_tv
->v_type
== VAR_LIST
&& lp
->ll_tv
->vval
.v_list
!= NULL
)
2566 && !(lp
->ll_tv
->v_type
== VAR_DICT
2567 && lp
->ll_tv
->vval
.v_dict
!= NULL
))
2570 EMSG(_("E689: Can only index a List or Dictionary"));
2576 EMSG(_("E708: [:] must come last"));
2584 for (len
= 0; ASCII_ISALNUM(key
[len
]) || key
[len
] == '_'; ++len
)
2589 EMSG(_(e_emptykey
));
2596 /* Get the index [expr] or the first index [expr: ]. */
2597 p
= skipwhite(p
+ 1);
2603 if (eval1(&p
, &var1
, TRUE
) == FAIL
) /* recursive! */
2605 if (get_tv_string_chk(&var1
) == NULL
)
2607 /* not a number or string */
2613 /* Optionally get the second index [ :expr]. */
2616 if (lp
->ll_tv
->v_type
== VAR_DICT
)
2619 EMSG(_(e_dictrange
));
2624 if (rettv
!= NULL
&& (rettv
->v_type
!= VAR_LIST
2625 || rettv
->vval
.v_list
== NULL
))
2628 EMSG(_("E709: [:] requires a List value"));
2633 p
= skipwhite(p
+ 1);
2635 lp
->ll_empty2
= TRUE
;
2638 lp
->ll_empty2
= FALSE
;
2639 if (eval1(&p
, &var2
, TRUE
) == FAIL
) /* recursive! */
2645 if (get_tv_string_chk(&var2
) == NULL
)
2647 /* not a number or string */
2654 lp
->ll_range
= TRUE
;
2657 lp
->ll_range
= FALSE
;
2662 EMSG(_(e_missbrac
));
2665 if (lp
->ll_range
&& !lp
->ll_empty2
)
2670 /* Skip to past ']'. */
2674 if (lp
->ll_tv
->v_type
== VAR_DICT
)
2678 /* "[key]": get key from "var1" */
2679 key
= get_tv_string(&var1
); /* is number or string */
2683 EMSG(_(e_emptykey
));
2689 lp
->ll_dict
= lp
->ll_tv
->vval
.v_dict
;
2690 lp
->ll_di
= dict_find(lp
->ll_dict
, key
, len
);
2691 if (lp
->ll_di
== NULL
)
2693 /* Key does not exist in dict: may need to add it. */
2694 if (*p
== '[' || *p
== '.' || unlet
)
2697 EMSG2(_(e_dictkey
), key
);
2703 lp
->ll_newkey
= vim_strsave(key
);
2705 lp
->ll_newkey
= vim_strnsave(key
, len
);
2708 if (lp
->ll_newkey
== NULL
)
2714 lp
->ll_tv
= &lp
->ll_di
->di_tv
;
2719 * Get the number and item for the only or first index of the List.
2725 lp
->ll_n1
= get_tv_number(&var1
); /* is number or string */
2729 lp
->ll_list
= lp
->ll_tv
->vval
.v_list
;
2730 lp
->ll_li
= list_find(lp
->ll_list
, lp
->ll_n1
);
2731 if (lp
->ll_li
== NULL
)
2736 lp
->ll_li
= list_find(lp
->ll_list
, lp
->ll_n1
);
2739 if (lp
->ll_li
== NULL
)
2741 if (lp
->ll_range
&& !lp
->ll_empty2
)
2747 * May need to find the item or absolute index for the second
2749 * When no index given: "lp->ll_empty2" is TRUE.
2750 * Otherwise "lp->ll_n2" is set to the second index.
2752 if (lp
->ll_range
&& !lp
->ll_empty2
)
2754 lp
->ll_n2
= get_tv_number(&var2
); /* is number or string */
2758 ni
= list_find(lp
->ll_list
, lp
->ll_n2
);
2761 lp
->ll_n2
= list_idx_of_item(lp
->ll_list
, ni
);
2764 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2766 lp
->ll_n1
= list_idx_of_item(lp
->ll_list
, lp
->ll_li
);
2767 if (lp
->ll_n2
< lp
->ll_n1
)
2771 lp
->ll_tv
= &lp
->ll_li
->li_tv
;
2779 * Clear lval "lp" that was filled by get_lval().
2785 vim_free(lp
->ll_exp_name
);
2786 vim_free(lp
->ll_newkey
);
2790 * Set a variable that was parsed by get_lval() to "rettv".
2791 * "endp" points to just after the parsed name.
2792 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2795 set_var_lval(lp
, endp
, rettv
, copy
, op
)
2806 if (lp
->ll_tv
== NULL
)
2808 if (!check_changedtick(lp
->ll_name
))
2812 if (op
!= NULL
&& *op
!= '=')
2816 /* handle +=, -= and .= */
2817 if (get_var_tv(lp
->ll_name
, (int)STRLEN(lp
->ll_name
),
2820 if (tv_op(&tv
, rettv
, op
) == OK
)
2821 set_var(lp
->ll_name
, &tv
, FALSE
);
2826 set_var(lp
->ll_name
, rettv
, copy
);
2830 else if (tv_check_lock(lp
->ll_newkey
== NULL
2832 : lp
->ll_tv
->vval
.v_dict
->dv_lock
, lp
->ll_name
))
2834 else if (lp
->ll_range
)
2837 * Assign the List values to the list items.
2839 for (ri
= rettv
->vval
.v_list
->lv_first
; ri
!= NULL
; )
2841 if (op
!= NULL
&& *op
!= '=')
2842 tv_op(&lp
->ll_li
->li_tv
, &ri
->li_tv
, op
);
2845 clear_tv(&lp
->ll_li
->li_tv
);
2846 copy_tv(&ri
->li_tv
, &lp
->ll_li
->li_tv
);
2849 if (ri
== NULL
|| (!lp
->ll_empty2
&& lp
->ll_n2
== lp
->ll_n1
))
2851 if (lp
->ll_li
->li_next
== NULL
)
2853 /* Need to add an empty item. */
2854 if (list_append_number(lp
->ll_list
, 0) == FAIL
)
2860 lp
->ll_li
= lp
->ll_li
->li_next
;
2864 EMSG(_("E710: List value has more items than target"));
2865 else if (lp
->ll_empty2
2866 ? (lp
->ll_li
!= NULL
&& lp
->ll_li
->li_next
!= NULL
)
2867 : lp
->ll_n1
!= lp
->ll_n2
)
2868 EMSG(_("E711: List value has not enough items"));
2873 * Assign to a List or Dictionary item.
2875 if (lp
->ll_newkey
!= NULL
)
2877 if (op
!= NULL
&& *op
!= '=')
2879 EMSG2(_(e_letwrong
), op
);
2883 /* Need to add an item to the Dictionary. */
2884 di
= dictitem_alloc(lp
->ll_newkey
);
2887 if (dict_add(lp
->ll_tv
->vval
.v_dict
, di
) == FAIL
)
2892 lp
->ll_tv
= &di
->di_tv
;
2894 else if (op
!= NULL
&& *op
!= '=')
2896 tv_op(lp
->ll_tv
, rettv
, op
);
2900 clear_tv(lp
->ll_tv
);
2903 * Assign the value to the variable or list item.
2906 copy_tv(rettv
, lp
->ll_tv
);
2909 *lp
->ll_tv
= *rettv
;
2910 lp
->ll_tv
->v_lock
= 0;
2917 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2918 * Returns OK or FAIL.
2927 char_u numbuf
[NUMBUFLEN
];
2930 /* Can't do anything with a Funcref or a Dict on the right. */
2931 if (tv2
->v_type
!= VAR_FUNC
&& tv2
->v_type
!= VAR_DICT
)
2933 switch (tv1
->v_type
)
2940 if (*op
!= '+' || tv2
->v_type
!= VAR_LIST
)
2943 if (tv1
->vval
.v_list
!= NULL
&& tv2
->vval
.v_list
!= NULL
)
2944 list_extend(tv1
->vval
.v_list
, tv2
->vval
.v_list
, NULL
);
2949 if (tv2
->v_type
== VAR_LIST
)
2951 if (*op
== '+' || *op
== '-')
2953 /* nr += nr or nr -= nr*/
2954 n
= get_tv_number(tv1
);
2956 if (tv2
->v_type
== VAR_FLOAT
)
2961 f
+= tv2
->vval
.v_float
;
2963 f
-= tv2
->vval
.v_float
;
2965 tv1
->v_type
= VAR_FLOAT
;
2966 tv1
->vval
.v_float
= f
;
2972 n
+= get_tv_number(tv2
);
2974 n
-= get_tv_number(tv2
);
2976 tv1
->v_type
= VAR_NUMBER
;
2977 tv1
->vval
.v_number
= n
;
2982 if (tv2
->v_type
== VAR_FLOAT
)
2986 s
= get_tv_string(tv1
);
2987 s
= concat_str(s
, get_tv_string_buf(tv2
, numbuf
));
2989 tv1
->v_type
= VAR_STRING
;
2990 tv1
->vval
.v_string
= s
;
2999 if (*op
== '.' || (tv2
->v_type
!= VAR_FLOAT
3000 && tv2
->v_type
!= VAR_NUMBER
3001 && tv2
->v_type
!= VAR_STRING
))
3003 if (tv2
->v_type
== VAR_FLOAT
)
3004 f
= tv2
->vval
.v_float
;
3006 f
= get_tv_number(tv2
);
3008 tv1
->vval
.v_float
+= f
;
3010 tv1
->vval
.v_float
-= f
;
3017 EMSG2(_(e_letwrong
), op
);
3022 * Add a watcher to a list.
3025 list_add_watch(l
, lw
)
3029 lw
->lw_next
= l
->lv_watch
;
3034 * Remove a watcher from a list.
3035 * No warning when it isn't found...
3038 list_rem_watch(l
, lwrem
)
3042 listwatch_T
*lw
, **lwp
;
3045 for (lw
= l
->lv_watch
; lw
!= NULL
; lw
= lw
->lw_next
)
3057 * Just before removing an item from a list: advance watchers to the next
3061 list_fix_watch(l
, item
)
3067 for (lw
= l
->lv_watch
; lw
!= NULL
; lw
= lw
->lw_next
)
3068 if (lw
->lw_item
== item
)
3069 lw
->lw_item
= item
->li_next
;
3073 * Evaluate the expression used in a ":for var in expr" command.
3074 * "arg" points to "var".
3075 * Set "*errp" to TRUE for an error, FALSE otherwise;
3076 * Return a pointer that holds the info. Null when there is an error.
3079 eval_for_line(arg
, errp
, nextcmdp
, skip
)
3090 *errp
= TRUE
; /* default: there is an error */
3092 fi
= (forinfo_T
*)alloc_clear(sizeof(forinfo_T
));
3096 expr
= skip_var_list(arg
, &fi
->fi_varcount
, &fi
->fi_semicolon
);
3100 expr
= skipwhite(expr
);
3101 if (expr
[0] != 'i' || expr
[1] != 'n' || !vim_iswhite(expr
[2]))
3103 EMSG(_("E690: Missing \"in\" after :for"));
3109 if (eval0(skipwhite(expr
+ 2), &tv
, nextcmdp
, !skip
) == OK
)
3115 if (tv
.v_type
!= VAR_LIST
|| l
== NULL
)
3122 /* No need to increment the refcount, it's already set for the
3123 * list being used in "tv". */
3125 list_add_watch(l
, &fi
->fi_lw
);
3126 fi
->fi_lw
.lw_item
= l
->lv_first
;
3137 * Use the first item in a ":for" list. Advance to the next.
3138 * Assign the values to the variable (list). "arg" points to the first one.
3139 * Return TRUE when a valid item was found, FALSE when at end of list or
3143 next_for_item(fi_void
, arg
)
3147 forinfo_T
*fi
= (forinfo_T
*)fi_void
;
3151 item
= fi
->fi_lw
.lw_item
;
3156 fi
->fi_lw
.lw_item
= item
->li_next
;
3157 result
= (ex_let_vars(arg
, &item
->li_tv
, TRUE
,
3158 fi
->fi_semicolon
, fi
->fi_varcount
, NULL
) == OK
);
3164 * Free the structure used to store info used by ":for".
3167 free_for_info(fi_void
)
3170 forinfo_T
*fi
= (forinfo_T
*)fi_void
;
3172 if (fi
!= NULL
&& fi
->fi_list
!= NULL
)
3174 list_rem_watch(fi
->fi_list
, &fi
->fi_lw
);
3175 list_unref(fi
->fi_list
);
3180 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3183 set_context_for_expression(xp
, arg
, cmdidx
)
3192 if (cmdidx
== CMD_let
)
3194 xp
->xp_context
= EXPAND_USER_VARS
;
3195 if (vim_strpbrk(arg
, (char_u
*)"\"'+-*/%.=!?~|&$([<>,#") == NULL
)
3197 /* ":let var1 var2 ...": find last space. */
3198 for (p
= arg
+ STRLEN(arg
); p
>= arg
; )
3201 mb_ptr_back(arg
, p
);
3202 if (vim_iswhite(*p
))
3209 xp
->xp_context
= cmdidx
== CMD_call
? EXPAND_FUNCTIONS
3210 : EXPAND_EXPRESSION
;
3211 while ((xp
->xp_pattern
= vim_strpbrk(arg
,
3212 (char_u
*)"\"'+-*/%.=!?~|&$([<>,#")) != NULL
)
3214 c
= *xp
->xp_pattern
;
3217 c
= xp
->xp_pattern
[1];
3221 xp
->xp_context
= cmdidx
!= CMD_let
|| got_eq
3222 ? EXPAND_EXPRESSION
: EXPAND_NOTHING
;
3226 xp
->xp_context
= EXPAND_SETTINGS
;
3227 if ((c
== 'l' || c
== 'g') && xp
->xp_pattern
[2] == ':')
3228 xp
->xp_pattern
+= 2;
3234 /* environment variable */
3235 xp
->xp_context
= EXPAND_ENV_VARS
;
3240 xp
->xp_context
= EXPAND_EXPRESSION
;
3243 && xp
->xp_context
== EXPAND_FUNCTIONS
3244 && vim_strchr(xp
->xp_pattern
, '(') == NULL
)
3246 /* Function name can start with "<SNR>" */
3249 else if (cmdidx
!= CMD_let
|| got_eq
)
3251 if (c
== '"') /* string */
3253 while ((c
= *++xp
->xp_pattern
) != NUL
&& c
!= '"')
3254 if (c
== '\\' && xp
->xp_pattern
[1] != NUL
)
3256 xp
->xp_context
= EXPAND_NOTHING
;
3258 else if (c
== '\'') /* literal string */
3260 /* Trick: '' is like stopping and starting a literal string. */
3261 while ((c
= *++xp
->xp_pattern
) != NUL
&& c
!= '\'')
3263 xp
->xp_context
= EXPAND_NOTHING
;
3267 if (xp
->xp_pattern
[1] == '|')
3270 xp
->xp_context
= EXPAND_EXPRESSION
;
3273 xp
->xp_context
= EXPAND_COMMANDS
;
3276 xp
->xp_context
= EXPAND_EXPRESSION
;
3279 /* Doesn't look like something valid, expand as an expression
3281 xp
->xp_context
= EXPAND_EXPRESSION
;
3282 arg
= xp
->xp_pattern
;
3284 while ((c
= *++arg
) != NUL
&& (c
== ' ' || c
== '\t'))
3287 xp
->xp_pattern
= arg
;
3290 #endif /* FEAT_CMDL_COMPL */
3293 * ":1,25call func(arg1, arg2)" function call.
3299 char_u
*arg
= eap
->arg
;
3310 tofree
= trans_function_name(&arg
, eap
->skip
, TFN_INT
, &fudi
);
3311 if (fudi
.fd_newkey
!= NULL
)
3313 /* Still need to give an error message for missing key. */
3314 EMSG2(_(e_dictkey
), fudi
.fd_newkey
);
3315 vim_free(fudi
.fd_newkey
);
3320 /* Increase refcount on dictionary, it could get deleted when evaluating
3322 if (fudi
.fd_dict
!= NULL
)
3323 ++fudi
.fd_dict
->dv_refcount
;
3325 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3326 len
= (int)STRLEN(tofree
);
3327 name
= deref_func_name(tofree
, &len
);
3329 /* Skip white space to allow ":call func ()". Not good, but required for
3330 * backward compatibility. */
3331 startarg
= skipwhite(arg
);
3332 rettv
.v_type
= VAR_UNKNOWN
; /* clear_tv() uses this */
3334 if (*startarg
!= '(')
3336 EMSG2(_("E107: Missing parentheses: %s"), eap
->arg
);
3341 * When skipping, evaluate the function once, to find the end of the
3343 * When the function takes a range, this is discovered after the first
3344 * call, and the loop is broken.
3349 lnum
= eap
->line2
; /* do it once, also with an invalid range */
3353 for ( ; lnum
<= eap
->line2
; ++lnum
)
3355 if (!eap
->skip
&& eap
->addr_count
> 0)
3357 curwin
->w_cursor
.lnum
= lnum
;
3358 curwin
->w_cursor
.col
= 0;
3361 if (get_func_tv(name
, (int)STRLEN(name
), &rettv
, &arg
,
3362 eap
->line1
, eap
->line2
, &doesrange
,
3363 !eap
->skip
, fudi
.fd_dict
) == FAIL
)
3369 /* Handle a function returning a Funcref, Dictionary or List. */
3370 if (handle_subscript(&arg
, &rettv
, !eap
->skip
, TRUE
) == FAIL
)
3377 if (doesrange
|| eap
->skip
)
3380 /* Stop when immediately aborting on error, or when an interrupt
3381 * occurred or an exception was thrown but not caught.
3382 * get_func_tv() returned OK, so that the check for trailing
3383 * characters below is executed. */
3392 /* Check for trailing illegal characters and a following command. */
3393 if (!ends_excmd(*arg
))
3396 EMSG(_(e_trailing
));
3399 eap
->nextcmd
= check_nextcmd(arg
);
3403 dict_unref(fudi
.fd_dict
);
3408 * ":unlet[!] var1 ... " command.
3414 ex_unletlock(eap
, eap
->arg
, 0);
3418 * ":lockvar" and ":unlockvar" commands
3424 char_u
*arg
= eap
->arg
;
3429 else if (vim_isdigit(*arg
))
3431 deep
= getdigits(&arg
);
3432 arg
= skipwhite(arg
);
3435 ex_unletlock(eap
, arg
, deep
);
3439 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3442 ex_unletlock(eap
, argstart
, deep
)
3447 char_u
*arg
= argstart
;
3454 /* Parse the name and find the end. */
3455 name_end
= get_lval(arg
, NULL
, &lv
, TRUE
, eap
->skip
|| error
, FALSE
,
3457 if (lv
.ll_name
== NULL
)
3458 error
= TRUE
; /* error but continue parsing */
3459 if (name_end
== NULL
|| (!vim_iswhite(*name_end
)
3460 && !ends_excmd(*name_end
)))
3462 if (name_end
!= NULL
)
3465 EMSG(_(e_trailing
));
3467 if (!(eap
->skip
|| error
))
3472 if (!error
&& !eap
->skip
)
3474 if (eap
->cmdidx
== CMD_unlet
)
3476 if (do_unlet_var(&lv
, name_end
, eap
->forceit
) == FAIL
)
3481 if (do_lock_var(&lv
, name_end
, deep
,
3482 eap
->cmdidx
== CMD_lockvar
) == FAIL
)
3490 arg
= skipwhite(name_end
);
3491 } while (!ends_excmd(*arg
));
3493 eap
->nextcmd
= check_nextcmd(arg
);
3497 do_unlet_var(lp
, name_end
, forceit
)
3505 if (lp
->ll_tv
== NULL
)
3510 /* Normal name or expanded name. */
3511 if (check_changedtick(lp
->ll_name
))
3513 else if (do_unlet(lp
->ll_name
, forceit
) == FAIL
)
3517 else if (tv_check_lock(lp
->ll_tv
->v_lock
, lp
->ll_name
))
3519 else if (lp
->ll_range
)
3523 /* Delete a range of List items. */
3524 while (lp
->ll_li
!= NULL
&& (lp
->ll_empty2
|| lp
->ll_n2
>= lp
->ll_n1
))
3526 li
= lp
->ll_li
->li_next
;
3527 listitem_remove(lp
->ll_list
, lp
->ll_li
);
3534 if (lp
->ll_list
!= NULL
)
3535 /* unlet a List item. */
3536 listitem_remove(lp
->ll_list
, lp
->ll_li
);
3538 /* unlet a Dictionary item. */
3539 dictitem_remove(lp
->ll_dict
, lp
->ll_di
);
3546 * "unlet" a variable. Return OK if it existed, FAIL if not.
3547 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3550 do_unlet(name
, forceit
)
3559 ht
= find_var_ht(name
, &varname
);
3560 if (ht
!= NULL
&& *varname
!= NUL
)
3562 hi
= hash_find(ht
, varname
);
3563 if (!HASHITEM_EMPTY(hi
))
3566 if (var_check_fixed(di
->di_flags
, name
)
3567 || var_check_ro(di
->di_flags
, name
))
3575 EMSG2(_("E108: No such variable: \"%s\""), name
);
3580 * Lock or unlock variable indicated by "lp".
3581 * "deep" is the levels to go (-1 for unlimited);
3582 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3585 do_lock_var(lp
, name_end
, deep
, lock
)
3595 if (deep
== 0) /* nothing to do */
3598 if (lp
->ll_tv
== NULL
)
3603 /* Normal name or expanded name. */
3604 if (check_changedtick(lp
->ll_name
))
3608 di
= find_var(lp
->ll_name
, NULL
);
3614 di
->di_flags
|= DI_FLAGS_LOCK
;
3616 di
->di_flags
&= ~DI_FLAGS_LOCK
;
3617 item_lock(&di
->di_tv
, deep
, lock
);
3622 else if (lp
->ll_range
)
3624 listitem_T
*li
= lp
->ll_li
;
3626 /* (un)lock a range of List items. */
3627 while (li
!= NULL
&& (lp
->ll_empty2
|| lp
->ll_n2
>= lp
->ll_n1
))
3629 item_lock(&li
->li_tv
, deep
, lock
);
3634 else if (lp
->ll_list
!= NULL
)
3635 /* (un)lock a List item. */
3636 item_lock(&lp
->ll_li
->li_tv
, deep
, lock
);
3638 /* un(lock) a Dictionary item. */
3639 item_lock(&lp
->ll_di
->di_tv
, deep
, lock
);
3645 * Lock or unlock an item. "deep" is nr of levels to go.
3648 item_lock(tv
, deep
, lock
)
3653 static int recurse
= 0;
3660 if (recurse
>= DICT_MAXNEST
)
3662 EMSG(_("E743: variable nested too deep for (un)lock"));
3669 /* lock/unlock the item itself */
3671 tv
->v_lock
|= VAR_LOCKED
;
3673 tv
->v_lock
&= ~VAR_LOCKED
;
3678 if ((l
= tv
->vval
.v_list
) != NULL
)
3681 l
->lv_lock
|= VAR_LOCKED
;
3683 l
->lv_lock
&= ~VAR_LOCKED
;
3684 if (deep
< 0 || deep
> 1)
3685 /* recursive: lock/unlock the items the List contains */
3686 for (li
= l
->lv_first
; li
!= NULL
; li
= li
->li_next
)
3687 item_lock(&li
->li_tv
, deep
- 1, lock
);
3691 if ((d
= tv
->vval
.v_dict
) != NULL
)
3694 d
->dv_lock
|= VAR_LOCKED
;
3696 d
->dv_lock
&= ~VAR_LOCKED
;
3697 if (deep
< 0 || deep
> 1)
3699 /* recursive: lock/unlock the items the List contains */
3700 todo
= (int)d
->dv_hashtab
.ht_used
;
3701 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
3703 if (!HASHITEM_EMPTY(hi
))
3706 item_lock(&HI2DI(hi
)->di_tv
, deep
- 1, lock
);
3716 * Return TRUE if typeval "tv" is locked: Either that value is locked itself
3717 * or it refers to a List or Dictionary that is locked.
3723 return (tv
->v_lock
& VAR_LOCKED
)
3724 || (tv
->v_type
== VAR_LIST
3725 && tv
->vval
.v_list
!= NULL
3726 && (tv
->vval
.v_list
->lv_lock
& VAR_LOCKED
))
3727 || (tv
->v_type
== VAR_DICT
3728 && tv
->vval
.v_dict
!= NULL
3729 && (tv
->vval
.v_dict
->dv_lock
& VAR_LOCKED
));
3732 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3734 * Delete all "menutrans_" variables.
3737 del_menutrans_vars()
3742 hash_lock(&globvarht
);
3743 todo
= (int)globvarht
.ht_used
;
3744 for (hi
= globvarht
.ht_array
; todo
> 0 && !got_int
; ++hi
)
3746 if (!HASHITEM_EMPTY(hi
))
3749 if (STRNCMP(HI2DI(hi
)->di_key
, "menutrans_", 10) == 0)
3750 delete_var(&globvarht
, hi
);
3753 hash_unlock(&globvarht
);
3757 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3760 * Local string buffer for the next two functions to store a variable name
3761 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3762 * get_user_var_name().
3765 static char_u
*cat_prefix_varname
__ARGS((int prefix
, char_u
*name
));
3767 static char_u
*varnamebuf
= NULL
;
3768 static int varnamebuflen
= 0;
3771 * Function to concatenate a prefix and a variable name.
3774 cat_prefix_varname(prefix
, name
)
3780 len
= (int)STRLEN(name
) + 3;
3781 if (len
> varnamebuflen
)
3783 vim_free(varnamebuf
);
3784 len
+= 10; /* some additional space */
3785 varnamebuf
= alloc(len
);
3786 if (varnamebuf
== NULL
)
3791 varnamebuflen
= len
;
3793 *varnamebuf
= prefix
;
3794 varnamebuf
[1] = ':';
3795 STRCPY(varnamebuf
+ 2, name
);
3800 * Function given to ExpandGeneric() to obtain the list of user defined
3801 * (global/buffer/window/built-in) variable names.
3804 get_user_var_name(xp
, idx
)
3808 static long_u gdone
;
3809 static long_u bdone
;
3810 static long_u wdone
;
3812 static long_u tdone
;
3815 static hashitem_T
*hi
;
3820 gdone
= bdone
= wdone
= vidx
= 0;
3826 /* Global variables */
3827 if (gdone
< globvarht
.ht_used
)
3830 hi
= globvarht
.ht_array
;
3833 while (HASHITEM_EMPTY(hi
))
3835 if (STRNCMP("g:", xp
->xp_pattern
, 2) == 0)
3836 return cat_prefix_varname('g', hi
->hi_key
);
3841 ht
= &curbuf
->b_vars
.dv_hashtab
;
3842 if (bdone
< ht
->ht_used
)
3848 while (HASHITEM_EMPTY(hi
))
3850 return cat_prefix_varname('b', hi
->hi_key
);
3852 if (bdone
== ht
->ht_used
)
3855 return (char_u
*)"b:changedtick";
3859 ht
= &curwin
->w_vars
.dv_hashtab
;
3860 if (wdone
< ht
->ht_used
)
3866 while (HASHITEM_EMPTY(hi
))
3868 return cat_prefix_varname('w', hi
->hi_key
);
3873 ht
= &curtab
->tp_vars
.dv_hashtab
;
3874 if (tdone
< ht
->ht_used
)
3880 while (HASHITEM_EMPTY(hi
))
3882 return cat_prefix_varname('t', hi
->hi_key
);
3888 return cat_prefix_varname('v', (char_u
*)vimvars
[vidx
++].vv_name
);
3890 vim_free(varnamebuf
);
3896 #endif /* FEAT_CMDL_COMPL */
3899 * types for expressions.
3904 , TYPE_EQUAL
/* == */
3905 , TYPE_NEQUAL
/* != */
3906 , TYPE_GREATER
/* > */
3907 , TYPE_GEQUAL
/* >= */
3908 , TYPE_SMALLER
/* < */
3909 , TYPE_SEQUAL
/* <= */
3910 , TYPE_MATCH
/* =~ */
3911 , TYPE_NOMATCH
/* !~ */
3915 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3916 * executed. The function may return OK, but the rettv will be of type
3917 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3921 * Handle zero level expression.
3922 * This calls eval1() and handles error message and nextcmd.
3923 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3924 * Note: "rettv.v_lock" is not set.
3925 * Return OK or FAIL.
3928 eval0(arg
, rettv
, nextcmd
, evaluate
)
3938 ret
= eval1(&p
, rettv
, evaluate
);
3939 if (ret
== FAIL
|| !ends_excmd(*p
))
3944 * Report the invalid expression unless the expression evaluation has
3945 * been cancelled due to an aborting error, an interrupt, or an
3949 EMSG2(_(e_invexpr2
), arg
);
3952 if (nextcmd
!= NULL
)
3953 *nextcmd
= check_nextcmd(p
);
3959 * Handle top level expression:
3960 * expr2 ? expr1 : expr1
3962 * "arg" must point to the first non-white of the expression.
3963 * "arg" is advanced to the next non-white after the recognized expression.
3965 * Note: "rettv.v_lock" is not set.
3967 * Return OK or FAIL.
3970 eval1(arg
, rettv
, evaluate
)
3979 * Get the first variable.
3981 if (eval2(arg
, rettv
, evaluate
) == FAIL
)
3984 if ((*arg
)[0] == '?')
3991 if (get_tv_number_chk(rettv
, &error
) != 0)
3999 * Get the second variable.
4001 *arg
= skipwhite(*arg
+ 1);
4002 if (eval1(arg
, rettv
, evaluate
&& result
) == FAIL
) /* recursive! */
4006 * Check for the ":".
4008 if ((*arg
)[0] != ':')
4010 EMSG(_("E109: Missing ':' after '?'"));
4011 if (evaluate
&& result
)
4017 * Get the third variable.
4019 *arg
= skipwhite(*arg
+ 1);
4020 if (eval1(arg
, &var2
, evaluate
&& !result
) == FAIL
) /* recursive! */
4022 if (evaluate
&& result
)
4026 if (evaluate
&& !result
)
4034 * Handle first level expression:
4035 * expr2 || expr2 || expr2 logical OR
4037 * "arg" must point to the first non-white of the expression.
4038 * "arg" is advanced to the next non-white after the recognized expression.
4040 * Return OK or FAIL.
4043 eval2(arg
, rettv
, evaluate
)
4054 * Get the first variable.
4056 if (eval3(arg
, rettv
, evaluate
) == FAIL
)
4060 * Repeat until there is no following "||".
4064 while ((*arg
)[0] == '|' && (*arg
)[1] == '|')
4066 if (evaluate
&& first
)
4068 if (get_tv_number_chk(rettv
, &error
) != 0)
4077 * Get the second variable.
4079 *arg
= skipwhite(*arg
+ 2);
4080 if (eval3(arg
, &var2
, evaluate
&& !result
) == FAIL
)
4084 * Compute the result.
4086 if (evaluate
&& !result
)
4088 if (get_tv_number_chk(&var2
, &error
) != 0)
4096 rettv
->v_type
= VAR_NUMBER
;
4097 rettv
->vval
.v_number
= result
;
4105 * Handle second level expression:
4106 * expr3 && expr3 && expr3 logical AND
4108 * "arg" must point to the first non-white of the expression.
4109 * "arg" is advanced to the next non-white after the recognized expression.
4111 * Return OK or FAIL.
4114 eval3(arg
, rettv
, evaluate
)
4125 * Get the first variable.
4127 if (eval4(arg
, rettv
, evaluate
) == FAIL
)
4131 * Repeat until there is no following "&&".
4135 while ((*arg
)[0] == '&' && (*arg
)[1] == '&')
4137 if (evaluate
&& first
)
4139 if (get_tv_number_chk(rettv
, &error
) == 0)
4148 * Get the second variable.
4150 *arg
= skipwhite(*arg
+ 2);
4151 if (eval4(arg
, &var2
, evaluate
&& result
) == FAIL
)
4155 * Compute the result.
4157 if (evaluate
&& result
)
4159 if (get_tv_number_chk(&var2
, &error
) == 0)
4167 rettv
->v_type
= VAR_NUMBER
;
4168 rettv
->vval
.v_number
= result
;
4176 * Handle third level expression:
4188 * "arg" must point to the first non-white of the expression.
4189 * "arg" is advanced to the next non-white after the recognized expression.
4191 * Return OK or FAIL.
4194 eval4(arg
, rettv
, evaluate
)
4202 exptype_T type
= TYPE_UNKNOWN
;
4203 int type_is
= FALSE
; /* TRUE for "is" and "isnot" */
4207 char_u buf1
[NUMBUFLEN
], buf2
[NUMBUFLEN
];
4208 regmatch_T regmatch
;
4213 * Get the first variable.
4215 if (eval5(arg
, rettv
, evaluate
) == FAIL
)
4221 case '=': if (p
[1] == '=')
4223 else if (p
[1] == '~')
4226 case '!': if (p
[1] == '=')
4228 else if (p
[1] == '~')
4229 type
= TYPE_NOMATCH
;
4231 case '>': if (p
[1] != '=')
4233 type
= TYPE_GREATER
;
4239 case '<': if (p
[1] != '=')
4241 type
= TYPE_SMALLER
;
4247 case 'i': if (p
[1] == 's')
4249 if (p
[2] == 'n' && p
[3] == 'o' && p
[4] == 't')
4251 if (!vim_isIDc(p
[len
]))
4253 type
= len
== 2 ? TYPE_EQUAL
: TYPE_NEQUAL
;
4261 * If there is a comparative operator, use it.
4263 if (type
!= TYPE_UNKNOWN
)
4265 /* extra question mark appended: ignore case */
4271 /* extra '#' appended: match case */
4272 else if (p
[len
] == '#')
4277 /* nothing appended: use 'ignorecase' */
4282 * Get the second variable.
4284 *arg
= skipwhite(p
+ len
);
4285 if (eval5(arg
, &var2
, evaluate
) == FAIL
)
4293 if (type_is
&& rettv
->v_type
!= var2
.v_type
)
4295 /* For "is" a different type always means FALSE, for "notis"
4297 n1
= (type
== TYPE_NEQUAL
);
4299 else if (rettv
->v_type
== VAR_LIST
|| var2
.v_type
== VAR_LIST
)
4303 n1
= (rettv
->v_type
== var2
.v_type
4304 && rettv
->vval
.v_list
== var2
.vval
.v_list
);
4305 if (type
== TYPE_NEQUAL
)
4308 else if (rettv
->v_type
!= var2
.v_type
4309 || (type
!= TYPE_EQUAL
&& type
!= TYPE_NEQUAL
))
4311 if (rettv
->v_type
!= var2
.v_type
)
4312 EMSG(_("E691: Can only compare List with List"));
4314 EMSG(_("E692: Invalid operation for Lists"));
4321 /* Compare two Lists for being equal or unequal. */
4322 n1
= list_equal(rettv
->vval
.v_list
, var2
.vval
.v_list
, ic
);
4323 if (type
== TYPE_NEQUAL
)
4328 else if (rettv
->v_type
== VAR_DICT
|| var2
.v_type
== VAR_DICT
)
4332 n1
= (rettv
->v_type
== var2
.v_type
4333 && rettv
->vval
.v_dict
== var2
.vval
.v_dict
);
4334 if (type
== TYPE_NEQUAL
)
4337 else if (rettv
->v_type
!= var2
.v_type
4338 || (type
!= TYPE_EQUAL
&& type
!= TYPE_NEQUAL
))
4340 if (rettv
->v_type
!= var2
.v_type
)
4341 EMSG(_("E735: Can only compare Dictionary with Dictionary"));
4343 EMSG(_("E736: Invalid operation for Dictionary"));
4350 /* Compare two Dictionaries for being equal or unequal. */
4351 n1
= dict_equal(rettv
->vval
.v_dict
, var2
.vval
.v_dict
, ic
);
4352 if (type
== TYPE_NEQUAL
)
4357 else if (rettv
->v_type
== VAR_FUNC
|| var2
.v_type
== VAR_FUNC
)
4359 if (rettv
->v_type
!= var2
.v_type
4360 || (type
!= TYPE_EQUAL
&& type
!= TYPE_NEQUAL
))
4362 if (rettv
->v_type
!= var2
.v_type
)
4363 EMSG(_("E693: Can only compare Funcref with Funcref"));
4365 EMSG(_("E694: Invalid operation for Funcrefs"));
4372 /* Compare two Funcrefs for being equal or unequal. */
4373 if (rettv
->vval
.v_string
== NULL
4374 || var2
.vval
.v_string
== NULL
)
4377 n1
= STRCMP(rettv
->vval
.v_string
,
4378 var2
.vval
.v_string
) == 0;
4379 if (type
== TYPE_NEQUAL
)
4386 * If one of the two variables is a float, compare as a float.
4387 * When using "=~" or "!~", always compare as string.
4389 else if ((rettv
->v_type
== VAR_FLOAT
|| var2
.v_type
== VAR_FLOAT
)
4390 && type
!= TYPE_MATCH
&& type
!= TYPE_NOMATCH
)
4394 if (rettv
->v_type
== VAR_FLOAT
)
4395 f1
= rettv
->vval
.v_float
;
4397 f1
= get_tv_number(rettv
);
4398 if (var2
.v_type
== VAR_FLOAT
)
4399 f2
= var2
.vval
.v_float
;
4401 f2
= get_tv_number(&var2
);
4405 case TYPE_EQUAL
: n1
= (f1
== f2
); break;
4406 case TYPE_NEQUAL
: n1
= (f1
!= f2
); break;
4407 case TYPE_GREATER
: n1
= (f1
> f2
); break;
4408 case TYPE_GEQUAL
: n1
= (f1
>= f2
); break;
4409 case TYPE_SMALLER
: n1
= (f1
< f2
); break;
4410 case TYPE_SEQUAL
: n1
= (f1
<= f2
); break;
4413 case TYPE_NOMATCH
: break; /* avoid gcc warning */
4419 * If one of the two variables is a number, compare as a number.
4420 * When using "=~" or "!~", always compare as string.
4422 else if ((rettv
->v_type
== VAR_NUMBER
|| var2
.v_type
== VAR_NUMBER
)
4423 && type
!= TYPE_MATCH
&& type
!= TYPE_NOMATCH
)
4425 n1
= get_tv_number(rettv
);
4426 n2
= get_tv_number(&var2
);
4429 case TYPE_EQUAL
: n1
= (n1
== n2
); break;
4430 case TYPE_NEQUAL
: n1
= (n1
!= n2
); break;
4431 case TYPE_GREATER
: n1
= (n1
> n2
); break;
4432 case TYPE_GEQUAL
: n1
= (n1
>= n2
); break;
4433 case TYPE_SMALLER
: n1
= (n1
< n2
); break;
4434 case TYPE_SEQUAL
: n1
= (n1
<= n2
); break;
4437 case TYPE_NOMATCH
: break; /* avoid gcc warning */
4442 s1
= get_tv_string_buf(rettv
, buf1
);
4443 s2
= get_tv_string_buf(&var2
, buf2
);
4444 if (type
!= TYPE_MATCH
&& type
!= TYPE_NOMATCH
)
4445 i
= ic
? MB_STRICMP(s1
, s2
) : STRCMP(s1
, s2
);
4451 case TYPE_EQUAL
: n1
= (i
== 0); break;
4452 case TYPE_NEQUAL
: n1
= (i
!= 0); break;
4453 case TYPE_GREATER
: n1
= (i
> 0); break;
4454 case TYPE_GEQUAL
: n1
= (i
>= 0); break;
4455 case TYPE_SMALLER
: n1
= (i
< 0); break;
4456 case TYPE_SEQUAL
: n1
= (i
<= 0); break;
4460 /* avoid 'l' flag in 'cpoptions' */
4462 p_cpo
= (char_u
*)"";
4463 regmatch
.regprog
= vim_regcomp(s2
,
4464 RE_MAGIC
+ RE_STRING
);
4465 regmatch
.rm_ic
= ic
;
4466 if (regmatch
.regprog
!= NULL
)
4468 n1
= vim_regexec_nl(®match
, s1
, (colnr_T
)0);
4469 vim_free(regmatch
.regprog
);
4470 if (type
== TYPE_NOMATCH
)
4476 case TYPE_UNKNOWN
: break; /* avoid gcc warning */
4481 rettv
->v_type
= VAR_NUMBER
;
4482 rettv
->vval
.v_number
= n1
;
4490 * Handle fourth level expression:
4492 * - number subtraction
4493 * . string concatenation
4495 * "arg" must point to the first non-white of the expression.
4496 * "arg" is advanced to the next non-white after the recognized expression.
4498 * Return OK or FAIL.
4501 eval5(arg
, rettv
, evaluate
)
4511 float_T f1
= 0, f2
= 0;
4514 char_u buf1
[NUMBUFLEN
], buf2
[NUMBUFLEN
];
4518 * Get the first variable.
4520 if (eval6(arg
, rettv
, evaluate
, FALSE
) == FAIL
)
4524 * Repeat computing, until no '+', '-' or '.' is following.
4529 if (op
!= '+' && op
!= '-' && op
!= '.')
4532 if ((op
!= '+' || rettv
->v_type
!= VAR_LIST
)
4534 && (op
== '.' || rettv
->v_type
!= VAR_FLOAT
)
4538 /* For "list + ...", an illegal use of the first operand as
4539 * a number cannot be determined before evaluating the 2nd
4540 * operand: if this is also a list, all is ok.
4541 * For "something . ...", "something - ..." or "non-list + ...",
4542 * we know that the first operand needs to be a string or number
4543 * without evaluating the 2nd operand. So check before to avoid
4544 * side effects after an error. */
4545 if (evaluate
&& get_tv_string_chk(rettv
) == NULL
)
4553 * Get the second variable.
4555 *arg
= skipwhite(*arg
+ 1);
4556 if (eval6(arg
, &var2
, evaluate
, op
== '.') == FAIL
)
4565 * Compute the result.
4569 s1
= get_tv_string_buf(rettv
, buf1
); /* already checked */
4570 s2
= get_tv_string_buf_chk(&var2
, buf2
);
4571 if (s2
== NULL
) /* type error ? */
4577 p
= concat_str(s1
, s2
);
4579 rettv
->v_type
= VAR_STRING
;
4580 rettv
->vval
.v_string
= p
;
4582 else if (op
== '+' && rettv
->v_type
== VAR_LIST
4583 && var2
.v_type
== VAR_LIST
)
4585 /* concatenate Lists */
4586 if (list_concat(rettv
->vval
.v_list
, var2
.vval
.v_list
,
4601 if (rettv
->v_type
== VAR_FLOAT
)
4603 f1
= rettv
->vval
.v_float
;
4609 n1
= get_tv_number_chk(rettv
, &error
);
4612 /* This can only happen for "list + non-list". For
4613 * "non-list + ..." or "something - ...", we returned
4614 * before evaluating the 2nd operand. */
4619 if (var2
.v_type
== VAR_FLOAT
)
4624 if (var2
.v_type
== VAR_FLOAT
)
4626 f2
= var2
.vval
.v_float
;
4632 n2
= get_tv_number_chk(&var2
, &error
);
4640 if (rettv
->v_type
== VAR_FLOAT
)
4647 /* If there is a float on either side the result is a float. */
4648 if (rettv
->v_type
== VAR_FLOAT
|| var2
.v_type
== VAR_FLOAT
)
4654 rettv
->v_type
= VAR_FLOAT
;
4655 rettv
->vval
.v_float
= f1
;
4664 rettv
->v_type
= VAR_NUMBER
;
4665 rettv
->vval
.v_number
= n1
;
4675 * Handle fifth level expression:
4676 * * number multiplication
4680 * "arg" must point to the first non-white of the expression.
4681 * "arg" is advanced to the next non-white after the recognized expression.
4683 * Return OK or FAIL.
4686 eval6(arg
, rettv
, evaluate
, want_string
)
4690 int want_string
; /* after "." operator */
4696 int use_float
= FALSE
;
4702 * Get the first variable.
4704 if (eval7(arg
, rettv
, evaluate
, want_string
) == FAIL
)
4708 * Repeat computing, until no '*', '/' or '%' is following.
4713 if (op
!= '*' && op
!= '/' && op
!= '%')
4719 if (rettv
->v_type
== VAR_FLOAT
)
4721 f1
= rettv
->vval
.v_float
;
4727 n1
= get_tv_number_chk(rettv
, &error
);
4736 * Get the second variable.
4738 *arg
= skipwhite(*arg
+ 1);
4739 if (eval7(arg
, &var2
, evaluate
, FALSE
) == FAIL
)
4745 if (var2
.v_type
== VAR_FLOAT
)
4752 f2
= var2
.vval
.v_float
;
4758 n2
= get_tv_number_chk(&var2
, &error
);
4769 * Compute the result.
4770 * When either side is a float the result is a float.
4779 /* We rely on the floating point library to handle divide
4780 * by zero to result in "inf" and not a crash. */
4785 EMSG(_("E804: Cannot use '%' with Float"));
4788 rettv
->v_type
= VAR_FLOAT
;
4789 rettv
->vval
.v_float
= f1
;
4798 if (n2
== 0) /* give an error message? */
4801 n1
= -0x7fffffffL
- 1L; /* similar to NaN */
4812 if (n2
== 0) /* give an error message? */
4817 rettv
->v_type
= VAR_NUMBER
;
4818 rettv
->vval
.v_number
= n1
;
4827 * Handle sixth level expression:
4828 * number number constant
4829 * "string" string constant
4830 * 'string' literal string constant
4831 * &option-name option value
4832 * @r register contents
4833 * identifier variable value
4834 * function() function call
4835 * $VAR environment variable
4836 * (expression) nested expression
4838 * {key: val, key: val} Dictionary
4841 * ! in front logical NOT
4842 * - in front unary minus
4843 * + in front unary plus (ignored)
4844 * trailing [] subscript in String or List
4845 * trailing .name entry in Dictionary
4847 * "arg" must point to the first non-white of the expression.
4848 * "arg" is advanced to the next non-white after the recognized expression.
4850 * Return OK or FAIL.
4853 eval7(arg
, rettv
, evaluate
, want_string
)
4857 int want_string
; /* after "." operator */
4862 char_u
*start_leader
, *end_leader
;
4867 * Initialise variable so that clear_tv() can't mistake this for a
4868 * string and free a string that isn't there.
4870 rettv
->v_type
= VAR_UNKNOWN
;
4873 * Skip '!' and '-' characters. They are handled later.
4875 start_leader
= *arg
;
4876 while (**arg
== '!' || **arg
== '-' || **arg
== '+')
4877 *arg
= skipwhite(*arg
+ 1);
4897 char_u
*p
= skipdigits(*arg
+ 1);
4898 int get_float
= FALSE
;
4900 /* We accept a float when the format matches
4901 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
4902 * strict to avoid backwards compatibility problems.
4903 * Don't look for a float after the "." operator, so that
4904 * ":let vers = 1.2.3" doesn't fail. */
4905 if (!want_string
&& p
[0] == '.' && vim_isdigit(p
[1]))
4908 p
= skipdigits(p
+ 2);
4909 if (*p
== 'e' || *p
== 'E')
4912 if (*p
== '-' || *p
== '+')
4914 if (!vim_isdigit(*p
))
4917 p
= skipdigits(p
+ 1);
4919 if (ASCII_ISALPHA(*p
) || *p
== '.')
4926 *arg
+= string2float(*arg
, &f
);
4929 rettv
->v_type
= VAR_FLOAT
;
4930 rettv
->vval
.v_float
= f
;
4936 vim_str2nr(*arg
, NULL
, &len
, TRUE
, TRUE
, &n
, NULL
);
4940 rettv
->v_type
= VAR_NUMBER
;
4941 rettv
->vval
.v_number
= n
;
4948 * String constant: "string".
4950 case '"': ret
= get_string_tv(arg
, rettv
, evaluate
);
4954 * Literal string constant: 'str''ing'.
4956 case '\'': ret
= get_lit_string_tv(arg
, rettv
, evaluate
);
4960 * List: [expr, expr]
4962 case '[': ret
= get_list_tv(arg
, rettv
, evaluate
);
4966 * Dictionary: {key: val, key: val}
4968 case '{': ret
= get_dict_tv(arg
, rettv
, evaluate
);
4972 * Option value: &name
4974 case '&': ret
= get_option_tv(arg
, rettv
, evaluate
);
4978 * Environment variable: $VAR.
4980 case '$': ret
= get_env_tv(arg
, rettv
, evaluate
);
4984 * Register contents: @r.
4989 rettv
->v_type
= VAR_STRING
;
4990 rettv
->vval
.v_string
= get_reg_contents(**arg
, TRUE
, TRUE
);
4997 * nested expression: (expression).
4999 case '(': *arg
= skipwhite(*arg
+ 1);
5000 ret
= eval1(arg
, rettv
, evaluate
); /* recursive! */
5005 EMSG(_("E110: Missing ')'"));
5011 default: ret
= NOTDONE
;
5018 * Must be a variable or function name.
5019 * Can also be a curly-braces kind of name: {expr}.
5022 len
= get_name_len(arg
, &alias
, evaluate
, TRUE
);
5030 if (**arg
== '(') /* recursive! */
5032 /* If "s" is the name of a variable of type VAR_FUNC
5033 * use its contents. */
5034 s
= deref_func_name(s
, &len
);
5036 /* Invoke the function. */
5037 ret
= get_func_tv(s
, len
, rettv
, arg
,
5038 curwin
->w_cursor
.lnum
, curwin
->w_cursor
.lnum
,
5039 &len
, evaluate
, NULL
);
5040 /* Stop the expression evaluation when immediately
5041 * aborting on error, or when an interrupt occurred or
5042 * an exception was thrown but not caught. */
5051 ret
= get_var_tv(s
, len
, rettv
, TRUE
);
5060 *arg
= skipwhite(*arg
);
5062 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
5065 ret
= handle_subscript(arg
, rettv
, evaluate
, TRUE
);
5068 * Apply logical NOT and unary '-', from right to left, ignore '+'.
5070 if (ret
== OK
&& evaluate
&& end_leader
> start_leader
)
5077 if (rettv
->v_type
== VAR_FLOAT
)
5078 f
= rettv
->vval
.v_float
;
5081 val
= get_tv_number_chk(rettv
, &error
);
5089 while (end_leader
> start_leader
)
5092 if (*end_leader
== '!')
5095 if (rettv
->v_type
== VAR_FLOAT
)
5101 else if (*end_leader
== '-')
5104 if (rettv
->v_type
== VAR_FLOAT
)
5112 if (rettv
->v_type
== VAR_FLOAT
)
5115 rettv
->vval
.v_float
= f
;
5121 rettv
->v_type
= VAR_NUMBER
;
5122 rettv
->vval
.v_number
= val
;
5131 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
5132 * "*arg" points to the '[' or '.'.
5133 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
5136 eval_index(arg
, rettv
, evaluate
, verbose
)
5140 int verbose
; /* give error messages */
5142 int empty1
= FALSE
, empty2
= FALSE
;
5143 typval_T var1
, var2
;
5150 if (rettv
->v_type
== VAR_FUNC
5152 || rettv
->v_type
== VAR_FLOAT
5157 EMSG(_("E695: Cannot index a Funcref"));
5167 for (len
= 0; ASCII_ISALNUM(key
[len
]) || key
[len
] == '_'; ++len
)
5171 *arg
= skipwhite(key
+ len
);
5178 * Get the (first) variable from inside the [].
5180 *arg
= skipwhite(*arg
+ 1);
5183 else if (eval1(arg
, &var1
, evaluate
) == FAIL
) /* recursive! */
5185 else if (evaluate
&& get_tv_string_chk(&var1
) == NULL
)
5187 /* not a number or string */
5193 * Get the second variable from inside the [:].
5198 *arg
= skipwhite(*arg
+ 1);
5201 else if (eval1(arg
, &var2
, evaluate
) == FAIL
) /* recursive! */
5207 else if (evaluate
&& get_tv_string_chk(&var2
) == NULL
)
5209 /* not a number or string */
5217 /* Check for the ']'. */
5221 EMSG(_(e_missbrac
));
5227 *arg
= skipwhite(*arg
+ 1); /* skip the ']' */
5233 if (!empty1
&& rettv
->v_type
!= VAR_DICT
)
5235 n1
= get_tv_number(&var1
);
5244 n2
= get_tv_number(&var2
);
5249 switch (rettv
->v_type
)
5253 s
= get_tv_string(rettv
);
5254 len
= (long)STRLEN(s
);
5257 /* The resulting variable is a substring. If the indexes
5258 * are out of range the result is empty. */
5269 if (n1
>= len
|| n2
< 0 || n1
> n2
)
5272 s
= vim_strnsave(s
+ n1
, (int)(n2
- n1
+ 1));
5276 /* The resulting variable is a string of a single
5277 * character. If the index is too big or negative the
5278 * result is empty. */
5279 if (n1
>= len
|| n1
< 0)
5282 s
= vim_strnsave(s
+ n1
, 1);
5285 rettv
->v_type
= VAR_STRING
;
5286 rettv
->vval
.v_string
= s
;
5290 len
= list_len(rettv
->vval
.v_list
);
5293 if (!empty1
&& (n1
< 0 || n1
>= len
))
5295 /* For a range we allow invalid values and return an empty
5296 * list. A list index out of range is an error. */
5300 EMSGN(_(e_listidx
), n1
);
5314 if (!empty2
&& (n2
< 0 || n2
+ 1 < n1
))
5319 for (item
= list_find(rettv
->vval
.v_list
, n1
);
5322 if (list_append_tv(l
, &item
->li_tv
) == FAIL
)
5327 item
= item
->li_next
;
5330 rettv
->v_type
= VAR_LIST
;
5331 rettv
->vval
.v_list
= l
;
5336 copy_tv(&list_find(rettv
->vval
.v_list
, n1
)->li_tv
, &var1
);
5346 EMSG(_(e_dictrange
));
5356 key
= get_tv_string(&var1
);
5360 EMSG(_(e_emptykey
));
5366 item
= dict_find(rettv
->vval
.v_dict
, key
, (int)len
);
5368 if (item
== NULL
&& verbose
)
5369 EMSG2(_(e_dictkey
), key
);
5375 copy_tv(&item
->di_tv
, &var1
);
5387 * Get an option value.
5388 * "arg" points to the '&' or '+' before the option name.
5389 * "arg" is advanced to character after the option name.
5390 * Return OK or FAIL.
5393 get_option_tv(arg
, rettv
, evaluate
)
5395 typval_T
*rettv
; /* when NULL, only check if option exists */
5403 int working
= (**arg
== '+'); /* has("+option") */
5408 * Isolate the option name and find its value.
5410 option_end
= find_option_end(arg
, &opt_flags
);
5411 if (option_end
== NULL
)
5414 EMSG2(_("E112: Option name missing: %s"), *arg
);
5426 opt_type
= get_option_value(*arg
, &numval
,
5427 rettv
== NULL
? NULL
: &stringval
, opt_flags
);
5429 if (opt_type
== -3) /* invalid name */
5432 EMSG2(_("E113: Unknown option: %s"), *arg
);
5435 else if (rettv
!= NULL
)
5437 if (opt_type
== -2) /* hidden string option */
5439 rettv
->v_type
= VAR_STRING
;
5440 rettv
->vval
.v_string
= NULL
;
5442 else if (opt_type
== -1) /* hidden number option */
5444 rettv
->v_type
= VAR_NUMBER
;
5445 rettv
->vval
.v_number
= 0;
5447 else if (opt_type
== 1) /* number option */
5449 rettv
->v_type
= VAR_NUMBER
;
5450 rettv
->vval
.v_number
= numval
;
5452 else /* string option */
5454 rettv
->v_type
= VAR_STRING
;
5455 rettv
->vval
.v_string
= stringval
;
5458 else if (working
&& (opt_type
== -2 || opt_type
== -1))
5461 *option_end
= c
; /* put back for error messages */
5468 * Allocate a variable for a string constant.
5469 * Return OK or FAIL.
5472 get_string_tv(arg
, rettv
, evaluate
)
5482 * Find the end of the string, skipping backslashed characters.
5484 for (p
= *arg
+ 1; *p
!= NUL
&& *p
!= '"'; mb_ptr_adv(p
))
5486 if (*p
== '\\' && p
[1] != NUL
)
5489 /* A "\<x>" form occupies at least 4 characters, and produces up
5490 * to 6 characters: reserve space for 2 extra */
5498 EMSG2(_("E114: Missing quote: %s"), *arg
);
5502 /* If only parsing, set *arg and return here */
5510 * Copy the string into allocated memory, handling backslashed
5513 name
= alloc((unsigned)(p
- *arg
+ extra
));
5516 rettv
->v_type
= VAR_STRING
;
5517 rettv
->vval
.v_string
= name
;
5519 for (p
= *arg
+ 1; *p
!= NUL
&& *p
!= '"'; )
5525 case 'b': *name
++ = BS
; ++p
; break;
5526 case 'e': *name
++ = ESC
; ++p
; break;
5527 case 'f': *name
++ = FF
; ++p
; break;
5528 case 'n': *name
++ = NL
; ++p
; break;
5529 case 'r': *name
++ = CAR
; ++p
; break;
5530 case 't': *name
++ = TAB
; ++p
; break;
5532 case 'X': /* hex: "\x1", "\x12" */
5534 case 'u': /* Unicode: "\u0023" */
5536 if (vim_isxdigit(p
[1]))
5539 int c
= toupper(*p
);
5546 while (--n
>= 0 && vim_isxdigit(p
[1]))
5549 nr
= (nr
<< 4) + hex2nr(*p
);
5553 /* For "\u" store the number according to
5556 name
+= (*mb_char2bytes
)(nr
, name
);
5563 /* octal: "\1", "\12", "\123" */
5571 case '7': *name
= *p
++ - '0';
5572 if (*p
>= '0' && *p
<= '7')
5574 *name
= (*name
<< 3) + *p
++ - '0';
5575 if (*p
>= '0' && *p
<= '7')
5576 *name
= (*name
<< 3) + *p
++ - '0';
5581 /* Special key, e.g.: "\<C-W>" */
5582 case '<': extra
= trans_special(&p
, name
, TRUE
);
5590 default: MB_COPY_CHAR(p
, name
);
5595 MB_COPY_CHAR(p
, name
);
5605 * Allocate a variable for a 'str''ing' constant.
5606 * Return OK or FAIL.
5609 get_lit_string_tv(arg
, rettv
, evaluate
)
5619 * Find the end of the string, skipping ''.
5621 for (p
= *arg
+ 1; *p
!= NUL
; mb_ptr_adv(p
))
5634 EMSG2(_("E115: Missing quote: %s"), *arg
);
5638 /* If only parsing return after setting "*arg" */
5646 * Copy the string into allocated memory, handling '' to ' reduction.
5648 str
= alloc((unsigned)((p
- *arg
) - reduce
));
5651 rettv
->v_type
= VAR_STRING
;
5652 rettv
->vval
.v_string
= str
;
5654 for (p
= *arg
+ 1; *p
!= NUL
; )
5662 MB_COPY_CHAR(p
, str
);
5671 * Allocate a variable for a List and fill it from "*arg".
5672 * Return OK or FAIL.
5675 get_list_tv(arg
, rettv
, evaluate
)
5691 *arg
= skipwhite(*arg
+ 1);
5692 while (**arg
!= ']' && **arg
!= NUL
)
5694 if (eval1(arg
, &tv
, evaluate
) == FAIL
) /* recursive! */
5698 item
= listitem_alloc();
5702 item
->li_tv
.v_lock
= 0;
5703 list_append(l
, item
);
5713 EMSG2(_("E696: Missing comma in List: %s"), *arg
);
5716 *arg
= skipwhite(*arg
+ 1);
5721 EMSG2(_("E697: Missing end of List ']': %s"), *arg
);
5728 *arg
= skipwhite(*arg
+ 1);
5731 rettv
->v_type
= VAR_LIST
;
5732 rettv
->vval
.v_list
= l
;
5740 * Allocate an empty header for a list.
5741 * Caller should take care of the reference count.
5748 l
= (list_T
*)alloc_clear(sizeof(list_T
));
5751 /* Prepend the list to the list of lists for garbage collection. */
5752 if (first_list
!= NULL
)
5753 first_list
->lv_used_prev
= l
;
5754 l
->lv_used_prev
= NULL
;
5755 l
->lv_used_next
= first_list
;
5762 * Allocate an empty list for a return value.
5763 * Returns OK or FAIL.
5766 rettv_list_alloc(rettv
)
5769 list_T
*l
= list_alloc();
5774 rettv
->vval
.v_list
= l
;
5775 rettv
->v_type
= VAR_LIST
;
5781 * Unreference a list: decrement the reference count and free it when it
5788 if (l
!= NULL
&& --l
->lv_refcount
<= 0)
5793 * Free a list, including all items it points to.
5794 * Ignores the reference count.
5797 list_free(l
, recurse
)
5799 int recurse
; /* Free Lists and Dictionaries recursively. */
5803 /* Remove the list from the list of lists for garbage collection. */
5804 if (l
->lv_used_prev
== NULL
)
5805 first_list
= l
->lv_used_next
;
5807 l
->lv_used_prev
->lv_used_next
= l
->lv_used_next
;
5808 if (l
->lv_used_next
!= NULL
)
5809 l
->lv_used_next
->lv_used_prev
= l
->lv_used_prev
;
5811 for (item
= l
->lv_first
; item
!= NULL
; item
= l
->lv_first
)
5813 /* Remove the item before deleting it. */
5814 l
->lv_first
= item
->li_next
;
5815 if (recurse
|| (item
->li_tv
.v_type
!= VAR_LIST
5816 && item
->li_tv
.v_type
!= VAR_DICT
))
5817 clear_tv(&item
->li_tv
);
5824 * Allocate a list item.
5829 return (listitem_T
*)alloc(sizeof(listitem_T
));
5833 * Free a list item. Also clears the value. Does not notify watchers.
5839 clear_tv(&item
->li_tv
);
5844 * Remove a list item from a List and free it. Also clears the value.
5847 listitem_remove(l
, item
)
5851 list_remove(l
, item
, item
);
5852 listitem_free(item
);
5856 * Get the number of items in a list.
5868 * Return TRUE when two lists have exactly the same values.
5871 list_equal(l1
, l2
, ic
)
5874 int ic
; /* ignore case for strings */
5876 listitem_T
*item1
, *item2
;
5878 if (l1
== NULL
|| l2
== NULL
)
5882 if (list_len(l1
) != list_len(l2
))
5885 for (item1
= l1
->lv_first
, item2
= l2
->lv_first
;
5886 item1
!= NULL
&& item2
!= NULL
;
5887 item1
= item1
->li_next
, item2
= item2
->li_next
)
5888 if (!tv_equal(&item1
->li_tv
, &item2
->li_tv
, ic
))
5890 return item1
== NULL
&& item2
== NULL
;
5893 #if defined(FEAT_RUBY) || defined(FEAT_PYTHON) || defined(FEAT_MZSCHEME) \
5894 || defined(FEAT_LUA) || defined(PROTO)
5896 * Return the dictitem that an entry in a hashtable points to.
5907 * Return TRUE when two dictionaries have exactly the same key/values.
5910 dict_equal(d1
, d2
, ic
)
5913 int ic
; /* ignore case for strings */
5919 if (d1
== NULL
|| d2
== NULL
)
5923 if (dict_len(d1
) != dict_len(d2
))
5926 todo
= (int)d1
->dv_hashtab
.ht_used
;
5927 for (hi
= d1
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
5929 if (!HASHITEM_EMPTY(hi
))
5931 item2
= dict_find(d2
, hi
->hi_key
, -1);
5934 if (!tv_equal(&HI2DI(hi
)->di_tv
, &item2
->di_tv
, ic
))
5943 * Return TRUE if "tv1" and "tv2" have the same value.
5944 * Compares the items just like "==" would compare them, but strings and
5945 * numbers are different. Floats and numbers are also different.
5948 tv_equal(tv1
, tv2
, ic
)
5951 int ic
; /* ignore case */
5953 char_u buf1
[NUMBUFLEN
], buf2
[NUMBUFLEN
];
5955 static int recursive
= 0; /* cach recursive loops */
5958 if (tv1
->v_type
!= tv2
->v_type
)
5960 /* Catch lists and dicts that have an endless loop by limiting
5961 * recursiveness to 1000. We guess they are equal then. */
5962 if (recursive
>= 1000)
5965 switch (tv1
->v_type
)
5969 r
= list_equal(tv1
->vval
.v_list
, tv2
->vval
.v_list
, ic
);
5975 r
= dict_equal(tv1
->vval
.v_dict
, tv2
->vval
.v_dict
, ic
);
5980 return (tv1
->vval
.v_string
!= NULL
5981 && tv2
->vval
.v_string
!= NULL
5982 && STRCMP(tv1
->vval
.v_string
, tv2
->vval
.v_string
) == 0);
5985 return tv1
->vval
.v_number
== tv2
->vval
.v_number
;
5989 return tv1
->vval
.v_float
== tv2
->vval
.v_float
;
5993 s1
= get_tv_string_buf(tv1
, buf1
);
5994 s2
= get_tv_string_buf(tv2
, buf2
);
5995 return ((ic
? MB_STRICMP(s1
, s2
) : STRCMP(s1
, s2
)) == 0);
5998 EMSG2(_(e_intern2
), "tv_equal()");
6003 * Locate item with index "n" in list "l" and return it.
6004 * A negative index is counted from the end; -1 is the last item.
6005 * Returns NULL when "n" is out of range.
6018 /* Negative index is relative to the end. */
6022 /* Check for index out of range. */
6023 if (n
< 0 || n
>= l
->lv_len
)
6026 /* When there is a cached index may start search from there. */
6027 if (l
->lv_idx_item
!= NULL
)
6029 if (n
< l
->lv_idx
/ 2)
6031 /* closest to the start of the list */
6035 else if (n
> (l
->lv_idx
+ l
->lv_len
) / 2)
6037 /* closest to the end of the list */
6039 idx
= l
->lv_len
- 1;
6043 /* closest to the cached index */
6044 item
= l
->lv_idx_item
;
6050 if (n
< l
->lv_len
/ 2)
6052 /* closest to the start of the list */
6058 /* closest to the end of the list */
6060 idx
= l
->lv_len
- 1;
6066 /* search forward */
6067 item
= item
->li_next
;
6072 /* search backward */
6073 item
= item
->li_prev
;
6077 /* cache the used index */
6079 l
->lv_idx_item
= item
;
6085 * Get list item "l[idx]" as a number.
6088 list_find_nr(l
, idx
, errorp
)
6091 int *errorp
; /* set to TRUE when something wrong */
6095 li
= list_find(l
, idx
);
6102 return get_tv_number_chk(&li
->li_tv
, errorp
);
6106 * Get list item "l[idx - 1]" as a string. Returns NULL for failure.
6109 list_find_str(l
, idx
)
6115 li
= list_find(l
, idx
- 1);
6118 EMSGN(_(e_listidx
), idx
);
6121 return get_tv_string(&li
->li_tv
);
6125 * Locate "item" list "l" and return its index.
6126 * Returns -1 when "item" is not in the list.
6129 list_idx_of_item(l
, item
)
6139 for (li
= l
->lv_first
; li
!= NULL
&& li
!= item
; li
= li
->li_next
)
6147 * Append item "item" to the end of list "l".
6150 list_append(l
, item
)
6154 if (l
->lv_last
== NULL
)
6159 item
->li_prev
= NULL
;
6163 l
->lv_last
->li_next
= item
;
6164 item
->li_prev
= l
->lv_last
;
6168 item
->li_next
= NULL
;
6172 * Append typval_T "tv" to the end of list "l".
6173 * Return FAIL when out of memory.
6176 list_append_tv(l
, tv
)
6180 listitem_T
*li
= listitem_alloc();
6184 copy_tv(tv
, &li
->li_tv
);
6190 * Add a dictionary to a list. Used by getqflist().
6191 * Return FAIL when out of memory.
6194 list_append_dict(list
, dict
)
6198 listitem_T
*li
= listitem_alloc();
6202 li
->li_tv
.v_type
= VAR_DICT
;
6203 li
->li_tv
.v_lock
= 0;
6204 li
->li_tv
.vval
.v_dict
= dict
;
6205 list_append(list
, li
);
6206 ++dict
->dv_refcount
;
6211 * Make a copy of "str" and append it as an item to list "l".
6212 * When "len" >= 0 use "str[len]".
6213 * Returns FAIL when out of memory.
6216 list_append_string(l
, str
, len
)
6221 listitem_T
*li
= listitem_alloc();
6226 li
->li_tv
.v_type
= VAR_STRING
;
6227 li
->li_tv
.v_lock
= 0;
6229 li
->li_tv
.vval
.v_string
= NULL
;
6230 else if ((li
->li_tv
.vval
.v_string
= (len
>= 0 ? vim_strnsave(str
, len
)
6231 : vim_strsave(str
))) == NULL
)
6237 * Append "n" to list "l".
6238 * Returns FAIL when out of memory.
6241 list_append_number(l
, n
)
6247 li
= listitem_alloc();
6250 li
->li_tv
.v_type
= VAR_NUMBER
;
6251 li
->li_tv
.v_lock
= 0;
6252 li
->li_tv
.vval
.v_number
= n
;
6258 * Insert typval_T "tv" in list "l" before "item".
6259 * If "item" is NULL append at the end.
6260 * Return FAIL when out of memory.
6263 list_insert_tv(l
, tv
, item
)
6268 listitem_T
*ni
= listitem_alloc();
6272 copy_tv(tv
, &ni
->li_tv
);
6274 /* Append new item at end of list. */
6278 /* Insert new item before existing item. */
6279 ni
->li_prev
= item
->li_prev
;
6281 if (item
->li_prev
== NULL
)
6288 item
->li_prev
->li_next
= ni
;
6289 l
->lv_idx_item
= NULL
;
6298 * Extend "l1" with "l2".
6299 * If "bef" is NULL append at the end, otherwise insert before this item.
6300 * Returns FAIL when out of memory.
6303 list_extend(l1
, l2
, bef
)
6309 int todo
= l2
->lv_len
;
6311 /* We also quit the loop when we have inserted the original item count of
6312 * the list, avoid a hang when we extend a list with itself. */
6313 for (item
= l2
->lv_first
; item
!= NULL
&& --todo
>= 0; item
= item
->li_next
)
6314 if (list_insert_tv(l1
, &item
->li_tv
, bef
) == FAIL
)
6320 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
6321 * Return FAIL when out of memory.
6324 list_concat(l1
, l2
, tv
)
6331 if (l1
== NULL
|| l2
== NULL
)
6334 /* make a copy of the first list. */
6335 l
= list_copy(l1
, FALSE
, 0);
6338 tv
->v_type
= VAR_LIST
;
6339 tv
->vval
.v_list
= l
;
6341 /* append all items from the second list */
6342 return list_extend(l
, l2
, NULL
);
6346 * Make a copy of list "orig". Shallow if "deep" is FALSE.
6347 * The refcount of the new list is set to 1.
6348 * See item_copy() for "copyID".
6349 * Returns NULL when out of memory.
6352 list_copy(orig
, deep
, copyID
)
6364 copy
= list_alloc();
6369 /* Do this before adding the items, because one of the items may
6370 * refer back to this list. */
6371 orig
->lv_copyID
= copyID
;
6372 orig
->lv_copylist
= copy
;
6374 for (item
= orig
->lv_first
; item
!= NULL
&& !got_int
;
6375 item
= item
->li_next
)
6377 ni
= listitem_alloc();
6382 if (item_copy(&item
->li_tv
, &ni
->li_tv
, deep
, copyID
) == FAIL
)
6389 copy_tv(&item
->li_tv
, &ni
->li_tv
);
6390 list_append(copy
, ni
);
6392 ++copy
->lv_refcount
;
6404 * Remove items "item" to "item2" from list "l".
6405 * Does not free the listitem or the value!
6408 list_remove(l
, item
, item2
)
6415 /* notify watchers */
6416 for (ip
= item
; ip
!= NULL
; ip
= ip
->li_next
)
6419 list_fix_watch(l
, ip
);
6424 if (item2
->li_next
== NULL
)
6425 l
->lv_last
= item
->li_prev
;
6427 item2
->li_next
->li_prev
= item
->li_prev
;
6428 if (item
->li_prev
== NULL
)
6429 l
->lv_first
= item2
->li_next
;
6431 item
->li_prev
->li_next
= item2
->li_next
;
6432 l
->lv_idx_item
= NULL
;
6436 * Return an allocated string with the string representation of a list.
6440 list2string(tv
, copyID
)
6446 if (tv
->vval
.v_list
== NULL
)
6448 ga_init2(&ga
, (int)sizeof(char), 80);
6449 ga_append(&ga
, '[');
6450 if (list_join(&ga
, tv
->vval
.v_list
, (char_u
*)", ", FALSE
, copyID
) == FAIL
)
6452 vim_free(ga
.ga_data
);
6455 ga_append(&ga
, ']');
6456 ga_append(&ga
, NUL
);
6457 return (char_u
*)ga
.ga_data
;
6461 * Join list "l" into a string in "*gap", using separator "sep".
6462 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6463 * Return FAIL or OK.
6466 list_join(gap
, l
, sep
, echo
, copyID
)
6475 char_u numbuf
[NUMBUFLEN
];
6479 for (item
= l
->lv_first
; item
!= NULL
&& !got_int
; item
= item
->li_next
)
6484 ga_concat(gap
, sep
);
6487 s
= echo_string(&item
->li_tv
, &tofree
, numbuf
, copyID
);
6489 s
= tv2string(&item
->li_tv
, &tofree
, numbuf
, copyID
);
6501 * Garbage collection for lists and dictionaries.
6503 * We use reference counts to be able to free most items right away when they
6504 * are no longer used. But for composite items it's possible that it becomes
6505 * unused while the reference count is > 0: When there is a recursive
6506 * reference. Example:
6507 * :let l = [1, 2, 3]
6511 * Since this is quite unusual we handle this with garbage collection: every
6512 * once in a while find out which lists and dicts are not referenced from any
6515 * Here is a good reference text about garbage collection (refers to Python
6516 * but it applies to all reference-counting mechanisms):
6517 * http://python.ca/nas/python/gc/
6521 * Do garbage collection for lists and dicts.
6522 * Return TRUE if some memory was freed.
6531 funccall_T
*fc
, **pfc
;
6533 int did_free_funccal
= FALSE
;
6538 /* Only do this once. */
6539 want_garbage_collect
= FALSE
;
6540 may_garbage_collect
= FALSE
;
6541 garbage_collect_at_exit
= FALSE
;
6543 /* We advance by two because we add one for items referenced through
6544 * previous_funccal. */
6545 current_copyID
+= COPYID_INC
;
6546 copyID
= current_copyID
;
6549 * 1. Go through all accessible variables and mark all lists and dicts
6553 /* Don't free variables in the previous_funccal list unless they are only
6554 * referenced through previous_funccal. This must be first, because if
6555 * the item is referenced elsewhere the funccal must not be freed. */
6556 for (fc
= previous_funccal
; fc
!= NULL
; fc
= fc
->caller
)
6558 set_ref_in_ht(&fc
->l_vars
.dv_hashtab
, copyID
+ 1);
6559 set_ref_in_ht(&fc
->l_avars
.dv_hashtab
, copyID
+ 1);
6562 /* script-local variables */
6563 for (i
= 1; i
<= ga_scripts
.ga_len
; ++i
)
6564 set_ref_in_ht(&SCRIPT_VARS(i
), copyID
);
6566 /* buffer-local variables */
6567 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
6568 set_ref_in_ht(&buf
->b_vars
.dv_hashtab
, copyID
);
6570 /* window-local variables */
6571 FOR_ALL_TAB_WINDOWS(tp
, wp
)
6572 set_ref_in_ht(&wp
->w_vars
.dv_hashtab
, copyID
);
6575 /* tabpage-local variables */
6576 for (tp
= first_tabpage
; tp
!= NULL
; tp
= tp
->tp_next
)
6577 set_ref_in_ht(&tp
->tp_vars
.dv_hashtab
, copyID
);
6580 /* global variables */
6581 set_ref_in_ht(&globvarht
, copyID
);
6583 /* function-local variables */
6584 for (fc
= current_funccal
; fc
!= NULL
; fc
= fc
->caller
)
6586 set_ref_in_ht(&fc
->l_vars
.dv_hashtab
, copyID
);
6587 set_ref_in_ht(&fc
->l_avars
.dv_hashtab
, copyID
);
6591 set_ref_in_ht(&vimvarht
, copyID
);
6594 * 2. Free lists and dictionaries that are not referenced.
6596 did_free
= free_unref_items(copyID
);
6599 * 3. Check if any funccal can be freed now.
6601 for (pfc
= &previous_funccal
; *pfc
!= NULL
; )
6603 if (can_free_funccal(*pfc
, copyID
))
6607 free_funccal(fc
, TRUE
);
6609 did_free_funccal
= TRUE
;
6612 pfc
= &(*pfc
)->caller
;
6614 if (did_free_funccal
)
6615 /* When a funccal was freed some more items might be garbage
6616 * collected, so run again. */
6617 (void)garbage_collect();
6623 * Free lists and dictionaries that are no longer referenced.
6626 free_unref_items(copyID
)
6631 int did_free
= FALSE
;
6634 * Go through the list of dicts and free items without the copyID.
6636 for (dd
= first_dict
; dd
!= NULL
; )
6637 if ((dd
->dv_copyID
& COPYID_MASK
) != (copyID
& COPYID_MASK
))
6639 /* Free the Dictionary and ordinary items it contains, but don't
6640 * recurse into Lists and Dictionaries, they will be in the list
6641 * of dicts or list of lists. */
6642 dict_free(dd
, FALSE
);
6645 /* restart, next dict may also have been freed */
6649 dd
= dd
->dv_used_next
;
6652 * Go through the list of lists and free items without the copyID.
6653 * But don't free a list that has a watcher (used in a for loop), these
6654 * are not referenced anywhere.
6656 for (ll
= first_list
; ll
!= NULL
; )
6657 if ((ll
->lv_copyID
& COPYID_MASK
) != (copyID
& COPYID_MASK
)
6658 && ll
->lv_watch
== NULL
)
6660 /* Free the List and ordinary items it contains, but don't recurse
6661 * into Lists and Dictionaries, they will be in the list of dicts
6662 * or list of lists. */
6663 list_free(ll
, FALSE
);
6666 /* restart, next list may also have been freed */
6670 ll
= ll
->lv_used_next
;
6676 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6679 set_ref_in_ht(ht
, copyID
)
6686 todo
= (int)ht
->ht_used
;
6687 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
6688 if (!HASHITEM_EMPTY(hi
))
6691 set_ref_in_item(&HI2DI(hi
)->di_tv
, copyID
);
6696 * Mark all lists and dicts referenced through list "l" with "copyID".
6699 set_ref_in_list(l
, copyID
)
6705 for (li
= l
->lv_first
; li
!= NULL
; li
= li
->li_next
)
6706 set_ref_in_item(&li
->li_tv
, copyID
);
6710 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6713 set_ref_in_item(tv
, copyID
)
6723 dd
= tv
->vval
.v_dict
;
6724 if (dd
!= NULL
&& dd
->dv_copyID
!= copyID
)
6726 /* Didn't see this dict yet. */
6727 dd
->dv_copyID
= copyID
;
6728 set_ref_in_ht(&dd
->dv_hashtab
, copyID
);
6733 ll
= tv
->vval
.v_list
;
6734 if (ll
!= NULL
&& ll
->lv_copyID
!= copyID
)
6736 /* Didn't see this list yet. */
6737 ll
->lv_copyID
= copyID
;
6738 set_ref_in_list(ll
, copyID
);
6746 * Allocate an empty header for a dictionary.
6753 d
= (dict_T
*)alloc(sizeof(dict_T
));
6756 /* Add the list to the list of dicts for garbage collection. */
6757 if (first_dict
!= NULL
)
6758 first_dict
->dv_used_prev
= d
;
6759 d
->dv_used_next
= first_dict
;
6760 d
->dv_used_prev
= NULL
;
6763 hash_init(&d
->dv_hashtab
);
6772 * Unreference a Dictionary: decrement the reference count and free it when it
6779 if (d
!= NULL
&& --d
->dv_refcount
<= 0)
6784 * Free a Dictionary, including all items it contains.
6785 * Ignores the reference count.
6788 dict_free(d
, recurse
)
6790 int recurse
; /* Free Lists and Dictionaries recursively. */
6796 /* Remove the dict from the list of dicts for garbage collection. */
6797 if (d
->dv_used_prev
== NULL
)
6798 first_dict
= d
->dv_used_next
;
6800 d
->dv_used_prev
->dv_used_next
= d
->dv_used_next
;
6801 if (d
->dv_used_next
!= NULL
)
6802 d
->dv_used_next
->dv_used_prev
= d
->dv_used_prev
;
6804 /* Lock the hashtab, we don't want it to resize while freeing items. */
6805 hash_lock(&d
->dv_hashtab
);
6806 todo
= (int)d
->dv_hashtab
.ht_used
;
6807 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
6809 if (!HASHITEM_EMPTY(hi
))
6811 /* Remove the item before deleting it, just in case there is
6812 * something recursive causing trouble. */
6814 hash_remove(&d
->dv_hashtab
, hi
);
6815 if (recurse
|| (di
->di_tv
.v_type
!= VAR_LIST
6816 && di
->di_tv
.v_type
!= VAR_DICT
))
6817 clear_tv(&di
->di_tv
);
6822 hash_clear(&d
->dv_hashtab
);
6827 * Allocate a Dictionary item.
6828 * The "key" is copied to the new item.
6829 * Note that the value of the item "di_tv" still needs to be initialized!
6830 * Returns NULL when out of memory.
6838 di
= (dictitem_T
*)alloc((unsigned)(sizeof(dictitem_T
) + STRLEN(key
)));
6841 STRCPY(di
->di_key
, key
);
6848 * Make a copy of a Dictionary item.
6856 di
= (dictitem_T
*)alloc((unsigned)(sizeof(dictitem_T
)
6857 + STRLEN(org
->di_key
)));
6860 STRCPY(di
->di_key
, org
->di_key
);
6862 copy_tv(&org
->di_tv
, &di
->di_tv
);
6868 * Remove item "item" from Dictionary "dict" and free it.
6871 dictitem_remove(dict
, item
)
6877 hi
= hash_find(&dict
->dv_hashtab
, item
->di_key
);
6878 if (HASHITEM_EMPTY(hi
))
6879 EMSG2(_(e_intern2
), "dictitem_remove()");
6881 hash_remove(&dict
->dv_hashtab
, hi
);
6882 dictitem_free(item
);
6886 * Free a dict item. Also clears the value.
6892 clear_tv(&item
->di_tv
);
6897 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6898 * The refcount of the new dict is set to 1.
6899 * See item_copy() for "copyID".
6900 * Returns NULL when out of memory.
6903 dict_copy(orig
, deep
, copyID
)
6916 copy
= dict_alloc();
6921 orig
->dv_copyID
= copyID
;
6922 orig
->dv_copydict
= copy
;
6924 todo
= (int)orig
->dv_hashtab
.ht_used
;
6925 for (hi
= orig
->dv_hashtab
.ht_array
; todo
> 0 && !got_int
; ++hi
)
6927 if (!HASHITEM_EMPTY(hi
))
6931 di
= dictitem_alloc(hi
->hi_key
);
6936 if (item_copy(&HI2DI(hi
)->di_tv
, &di
->di_tv
, deep
,
6944 copy_tv(&HI2DI(hi
)->di_tv
, &di
->di_tv
);
6945 if (dict_add(copy
, di
) == FAIL
)
6953 ++copy
->dv_refcount
;
6965 * Add item "item" to Dictionary "d".
6966 * Returns FAIL when out of memory and when key already existed.
6973 return hash_add(&d
->dv_hashtab
, item
->di_key
);
6977 * Add a number or string entry to dictionary "d".
6978 * When "str" is NULL use number "nr", otherwise use "str".
6979 * Returns FAIL when out of memory and when key already exists.
6982 dict_add_nr_str(d
, key
, nr
, str
)
6990 item
= dictitem_alloc((char_u
*)key
);
6993 item
->di_tv
.v_lock
= 0;
6996 item
->di_tv
.v_type
= VAR_NUMBER
;
6997 item
->di_tv
.vval
.v_number
= nr
;
7001 item
->di_tv
.v_type
= VAR_STRING
;
7002 item
->di_tv
.vval
.v_string
= vim_strsave(str
);
7004 if (dict_add(d
, item
) == FAIL
)
7006 dictitem_free(item
);
7012 /* Initializes a data structure used for iterating over dictionary items in
7013 * dict_iterate_next().
7016 dict_iterate_start(argvars
, iter
)
7018 struct dict_iterator_S
*iter
;
7022 if (argvars
[0].v_type
!= VAR_DICT
)
7028 if ((d
= argvars
[0].vval
.v_dict
) == NULL
)
7034 iter
->items
= (int)d
->dv_hashtab
.ht_used
;
7035 iter
->hi
= d
->dv_hashtab
.ht_array
;
7038 /* Allows iterating over the items stored in a dictionary.
7039 * Returns the pointer to the key, *tv_result is set to point to the value
7041 * If there are no more items, NULL is returned.
7042 * iter should be initialized with dict_iterate_start() before calling this
7043 * function for the first time.
7046 dict_iterate_next(iter
, tv_result
)
7047 struct dict_iterator_S
*iter
;
7048 typval_T
**tv_result
;
7053 if (iter
->items
<= 0)
7056 while (HASHITEM_EMPTY(iter
->hi
))
7059 di
= HI2DI(iter
->hi
);
7060 result
= di
->di_key
;
7061 *tv_result
= &di
->di_tv
;
7069 * Get the number of items in a Dictionary.
7077 return (long)d
->dv_hashtab
.ht_used
;
7081 * Find item "key[len]" in Dictionary "d".
7082 * If "len" is negative use strlen(key).
7083 * Returns NULL when not found.
7086 dict_find(d
, key
, len
)
7092 char_u buf
[AKEYLEN
];
7094 char_u
*tofree
= NULL
;
7099 else if (len
>= AKEYLEN
)
7101 tofree
= akey
= vim_strnsave(key
, len
);
7107 /* Avoid a malloc/free by using buf[]. */
7108 vim_strncpy(buf
, key
, len
);
7112 hi
= hash_find(&d
->dv_hashtab
, akey
);
7114 if (HASHITEM_EMPTY(hi
))
7120 * Get a string item from a dictionary.
7121 * When "save" is TRUE allocate memory for it.
7122 * Returns NULL if the entry doesn't exist or out of memory.
7125 get_dict_string(d
, key
, save
)
7133 di
= dict_find(d
, key
, -1);
7136 s
= get_tv_string(&di
->di_tv
);
7137 if (save
&& s
!= NULL
)
7143 * Get a number item from a dictionary.
7144 * Returns 0 if the entry doesn't exist or out of memory.
7147 get_dict_number(d
, key
)
7153 di
= dict_find(d
, key
, -1);
7156 return get_tv_number(&di
->di_tv
);
7160 * Return an allocated string with the string representation of a Dictionary.
7164 dict2string(tv
, copyID
)
7171 char_u numbuf
[NUMBUFLEN
];
7177 if ((d
= tv
->vval
.v_dict
) == NULL
)
7179 ga_init2(&ga
, (int)sizeof(char), 80);
7180 ga_append(&ga
, '{');
7182 todo
= (int)d
->dv_hashtab
.ht_used
;
7183 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0 && !got_int
; ++hi
)
7185 if (!HASHITEM_EMPTY(hi
))
7192 ga_concat(&ga
, (char_u
*)", ");
7194 tofree
= string_quote(hi
->hi_key
, FALSE
);
7197 ga_concat(&ga
, tofree
);
7200 ga_concat(&ga
, (char_u
*)": ");
7201 s
= tv2string(&HI2DI(hi
)->di_tv
, &tofree
, numbuf
, copyID
);
7211 vim_free(ga
.ga_data
);
7215 ga_append(&ga
, '}');
7216 ga_append(&ga
, NUL
);
7217 return (char_u
*)ga
.ga_data
;
7221 * Allocate a variable for a Dictionary and fill it from "*arg".
7222 * Return OK or FAIL. Returns NOTDONE for {expr}.
7225 get_dict_tv(arg
, rettv
, evaluate
)
7235 char_u
*start
= skipwhite(*arg
+ 1);
7236 char_u buf
[NUMBUFLEN
];
7239 * First check if it's not a curly-braces thing: {expr}.
7240 * Must do this without evaluating, otherwise a function may be called
7241 * twice. Unfortunately this means we need to call eval1() twice for the
7243 * But {} is an empty Dictionary.
7247 if (eval1(&start
, &tv
, FALSE
) == FAIL
) /* recursive! */
7259 tvkey
.v_type
= VAR_UNKNOWN
;
7260 tv
.v_type
= VAR_UNKNOWN
;
7262 *arg
= skipwhite(*arg
+ 1);
7263 while (**arg
!= '}' && **arg
!= NUL
)
7265 if (eval1(arg
, &tvkey
, evaluate
) == FAIL
) /* recursive! */
7269 EMSG2(_("E720: Missing colon in Dictionary: %s"), *arg
);
7275 key
= get_tv_string_buf_chk(&tvkey
, buf
);
7276 if (key
== NULL
|| *key
== NUL
)
7278 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
7280 EMSG(_(e_emptykey
));
7286 *arg
= skipwhite(*arg
+ 1);
7287 if (eval1(arg
, &tv
, evaluate
) == FAIL
) /* recursive! */
7295 item
= dict_find(d
, key
, -1);
7298 EMSG2(_("E721: Duplicate key in Dictionary: \"%s\""), key
);
7303 item
= dictitem_alloc(key
);
7308 item
->di_tv
.v_lock
= 0;
7309 if (dict_add(d
, item
) == FAIL
)
7310 dictitem_free(item
);
7318 EMSG2(_("E722: Missing comma in Dictionary: %s"), *arg
);
7321 *arg
= skipwhite(*arg
+ 1);
7326 EMSG2(_("E723: Missing end of Dictionary '}': %s"), *arg
);
7333 *arg
= skipwhite(*arg
+ 1);
7336 rettv
->v_type
= VAR_DICT
;
7337 rettv
->vval
.v_dict
= d
;
7345 * Return a string with the string representation of a variable.
7346 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7347 * "numbuf" is used for a number.
7348 * Does not put quotes around strings, as ":echo" displays values.
7349 * When "copyID" is not NULL replace recursive lists and dicts with "...".
7353 echo_string(tv
, tofree
, numbuf
, copyID
)
7359 static int recurse
= 0;
7362 if (recurse
>= DICT_MAXNEST
)
7364 EMSG(_("E724: variable nested too deep for displaying"));
7374 r
= tv
->vval
.v_string
;
7378 if (tv
->vval
.v_list
== NULL
)
7383 else if (copyID
!= 0 && tv
->vval
.v_list
->lv_copyID
== copyID
)
7386 r
= (char_u
*)"[...]";
7390 tv
->vval
.v_list
->lv_copyID
= copyID
;
7391 *tofree
= list2string(tv
, copyID
);
7397 if (tv
->vval
.v_dict
== NULL
)
7402 else if (copyID
!= 0 && tv
->vval
.v_dict
->dv_copyID
== copyID
)
7405 r
= (char_u
*)"{...}";
7409 tv
->vval
.v_dict
->dv_copyID
= copyID
;
7410 *tofree
= dict2string(tv
, copyID
);
7418 r
= get_tv_string_buf(tv
, numbuf
);
7424 vim_snprintf((char *)numbuf
, NUMBUFLEN
, "%g", tv
->vval
.v_float
);
7430 EMSG2(_(e_intern2
), "echo_string()");
7439 * Return a string with the string representation of a variable.
7440 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7441 * "numbuf" is used for a number.
7442 * Puts quotes around strings, so that they can be parsed back by eval().
7446 tv2string(tv
, tofree
, numbuf
, copyID
)
7455 *tofree
= string_quote(tv
->vval
.v_string
, TRUE
);
7458 *tofree
= string_quote(tv
->vval
.v_string
, FALSE
);
7463 vim_snprintf((char *)numbuf
, NUMBUFLEN
- 1, "%g", tv
->vval
.v_float
);
7471 EMSG2(_(e_intern2
), "tv2string()");
7473 return echo_string(tv
, tofree
, numbuf
, copyID
);
7477 * Return string "str" in ' quotes, doubling ' characters.
7478 * If "str" is NULL an empty string is assumed.
7479 * If "function" is TRUE make it function('string').
7482 string_quote(str
, function
)
7489 len
= (function
? 13 : 3);
7492 len
+= (unsigned)STRLEN(str
);
7493 for (p
= str
; *p
!= NUL
; mb_ptr_adv(p
))
7502 STRCPY(r
, "function('");
7508 for (p
= str
; *p
!= NUL
; )
7524 * Convert the string "text" to a floating point number.
7525 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
7526 * this always uses a decimal point.
7527 * Returns the length of the text that was consumed.
7530 string2float(text
, value
)
7532 float_T
*value
; /* result stored here */
7534 char *s
= (char *)text
;
7539 return (int)((char_u
*)s
- text
);
7544 * Get the value of an environment variable.
7545 * "arg" is pointing to the '$'. It is advanced to after the name.
7546 * If the environment variable was not set, silently assume it is empty.
7550 get_env_tv(arg
, rettv
, evaluate
)
7555 char_u
*string
= NULL
;
7559 int mustfree
= FALSE
;
7563 len
= get_env_len(arg
);
7570 /* first try vim_getenv(), fast for normal environment vars */
7571 string
= vim_getenv(name
, &mustfree
);
7572 if (string
!= NULL
&& *string
!= NUL
)
7575 string
= vim_strsave(string
);
7582 /* next try expanding things like $VIM and ${HOME} */
7583 string
= expand_env_save(name
- 1);
7584 if (string
!= NULL
&& *string
== '$')
7592 rettv
->v_type
= VAR_STRING
;
7593 rettv
->vval
.v_string
= string
;
7600 * Array with names and number of arguments of all internal functions
7601 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7605 char *f_name
; /* function name */
7606 char f_min_argc
; /* minimal number of arguments */
7607 char f_max_argc
; /* maximal number of arguments */
7608 void (*f_func
) __ARGS((typval_T
*args
, typval_T
*rvar
));
7609 /* implementation of function */
7613 {"abs", 1, 1, f_abs
},
7614 {"acos", 1, 1, f_acos
}, /* WJMc */
7616 {"add", 2, 2, f_add
},
7617 {"append", 2, 2, f_append
},
7618 {"argc", 0, 0, f_argc
},
7619 {"argidx", 0, 0, f_argidx
},
7620 {"argv", 0, 1, f_argv
},
7622 {"asin", 1, 1, f_asin
}, /* WJMc */
7623 {"atan", 1, 1, f_atan
},
7624 {"atan2", 2, 2, f_atan2
}, /* WJMc */
7626 {"browse", 4, 4, f_browse
},
7627 {"browsedir", 2, 2, f_browsedir
},
7628 {"bufexists", 1, 1, f_bufexists
},
7629 {"buffer_exists", 1, 1, f_bufexists
}, /* obsolete */
7630 {"buffer_name", 1, 1, f_bufname
}, /* obsolete */
7631 {"buffer_number", 1, 1, f_bufnr
}, /* obsolete */
7632 {"buflisted", 1, 1, f_buflisted
},
7633 {"bufloaded", 1, 1, f_bufloaded
},
7634 {"bufname", 1, 1, f_bufname
},
7635 {"bufnr", 1, 2, f_bufnr
},
7636 {"bufwinnr", 1, 1, f_bufwinnr
},
7637 {"byte2line", 1, 1, f_byte2line
},
7638 {"byteidx", 2, 2, f_byteidx
},
7639 {"call", 2, 3, f_call
},
7641 {"ceil", 1, 1, f_ceil
},
7643 {"changenr", 0, 0, f_changenr
},
7644 {"char2nr", 1, 1, f_char2nr
},
7645 {"cindent", 1, 1, f_cindent
},
7646 {"clearmatches", 0, 0, f_clearmatches
},
7647 {"col", 1, 1, f_col
},
7648 #if defined(FEAT_INS_EXPAND)
7649 {"complete", 2, 2, f_complete
},
7650 {"complete_add", 1, 1, f_complete_add
},
7651 {"complete_check", 0, 0, f_complete_check
},
7653 {"confirm", 1, 4, f_confirm
},
7654 {"copy", 1, 1, f_copy
},
7656 {"cos", 1, 1, f_cos
},
7657 {"cosh", 1, 1, f_cosh
}, /* WJMc */
7659 {"count", 2, 4, f_count
},
7660 {"cscope_connection",0,3, f_cscope_connection
},
7661 {"cursor", 1, 3, f_cursor
},
7662 {"deepcopy", 1, 2, f_deepcopy
},
7663 {"delete", 1, 1, f_delete
},
7664 {"did_filetype", 0, 0, f_did_filetype
},
7665 {"diff_filler", 1, 1, f_diff_filler
},
7666 {"diff_hlID", 2, 2, f_diff_hlID
},
7667 {"empty", 1, 1, f_empty
},
7668 {"escape", 2, 2, f_escape
},
7669 {"eval", 1, 1, f_eval
},
7670 {"eventhandler", 0, 0, f_eventhandler
},
7671 {"executable", 1, 1, f_executable
},
7672 {"exists", 1, 1, f_exists
},
7674 {"exp", 1, 1, f_exp
}, /* WJMc */
7676 {"expand", 1, 2, f_expand
},
7677 {"extend", 2, 3, f_extend
},
7678 {"feedkeys", 1, 2, f_feedkeys
},
7679 {"file_readable", 1, 1, f_filereadable
}, /* obsolete */
7680 {"filereadable", 1, 1, f_filereadable
},
7681 {"filewritable", 1, 1, f_filewritable
},
7682 {"filter", 2, 2, f_filter
},
7683 {"finddir", 1, 3, f_finddir
},
7684 {"findfile", 1, 3, f_findfile
},
7686 {"float2nr", 1, 1, f_float2nr
},
7687 {"floor", 1, 1, f_floor
},
7688 {"fmod", 2, 2, f_fmod
}, /* WJMc */
7690 {"fnameescape", 1, 1, f_fnameescape
},
7691 {"fnamemodify", 2, 2, f_fnamemodify
},
7692 {"foldclosed", 1, 1, f_foldclosed
},
7693 {"foldclosedend", 1, 1, f_foldclosedend
},
7694 {"foldlevel", 1, 1, f_foldlevel
},
7695 {"foldtext", 0, 0, f_foldtext
},
7696 {"foldtextresult", 1, 1, f_foldtextresult
},
7697 {"foreground", 0, 0, f_foreground
},
7698 {"function", 1, 1, f_function
},
7699 {"garbagecollect", 0, 1, f_garbagecollect
},
7700 {"get", 2, 3, f_get
},
7701 {"getbufline", 2, 3, f_getbufline
},
7702 {"getbufvar", 2, 2, f_getbufvar
},
7703 {"getchar", 0, 1, f_getchar
},
7704 {"getcharmod", 0, 0, f_getcharmod
},
7705 {"getcmdline", 0, 0, f_getcmdline
},
7706 {"getcmdpos", 0, 0, f_getcmdpos
},
7707 {"getcmdtype", 0, 0, f_getcmdtype
},
7708 {"getcwd", 0, 0, f_getcwd
},
7709 {"getfontname", 0, 1, f_getfontname
},
7710 {"getfperm", 1, 1, f_getfperm
},
7711 {"getfsize", 1, 1, f_getfsize
},
7712 {"getftime", 1, 1, f_getftime
},
7713 {"getftype", 1, 1, f_getftype
},
7714 {"getline", 1, 2, f_getline
},
7715 {"getloclist", 1, 1, f_getqflist
},
7716 {"getmatches", 0, 0, f_getmatches
},
7717 {"getpid", 0, 0, f_getpid
},
7718 {"getpos", 1, 1, f_getpos
},
7719 {"getqflist", 0, 0, f_getqflist
},
7720 {"getreg", 0, 2, f_getreg
},
7721 {"getregtype", 0, 1, f_getregtype
},
7722 {"gettabwinvar", 3, 3, f_gettabwinvar
},
7723 {"getwinposx", 0, 0, f_getwinposx
},
7724 {"getwinposy", 0, 0, f_getwinposy
},
7725 {"getwinvar", 2, 2, f_getwinvar
},
7726 {"glob", 1, 2, f_glob
},
7727 {"globpath", 2, 3, f_globpath
},
7728 {"has", 1, 1, f_has
},
7729 {"has_key", 2, 2, f_has_key
},
7730 {"haslocaldir", 0, 0, f_haslocaldir
},
7731 {"hasmapto", 1, 3, f_hasmapto
},
7732 {"highlightID", 1, 1, f_hlID
}, /* obsolete */
7733 {"highlight_exists",1, 1, f_hlexists
}, /* obsolete */
7734 {"histadd", 2, 2, f_histadd
},
7735 {"histdel", 1, 2, f_histdel
},
7736 {"histget", 1, 2, f_histget
},
7737 {"histnr", 1, 1, f_histnr
},
7738 {"hlID", 1, 1, f_hlID
},
7739 {"hlexists", 1, 1, f_hlexists
},
7740 {"hostname", 0, 0, f_hostname
},
7741 {"iconv", 3, 3, f_iconv
},
7742 {"indent", 1, 1, f_indent
},
7743 {"index", 2, 4, f_index
},
7744 {"input", 1, 3, f_input
},
7745 {"inputdialog", 1, 3, f_inputdialog
},
7746 {"inputlist", 1, 1, f_inputlist
},
7747 {"inputrestore", 0, 0, f_inputrestore
},
7748 {"inputsave", 0, 0, f_inputsave
},
7749 {"inputsecret", 1, 2, f_inputsecret
},
7750 {"insert", 2, 3, f_insert
},
7751 {"isdirectory", 1, 1, f_isdirectory
},
7752 {"islocked", 1, 1, f_islocked
},
7753 {"items", 1, 1, f_items
},
7754 {"join", 1, 2, f_join
},
7755 {"keys", 1, 1, f_keys
},
7756 {"last_buffer_nr", 0, 0, f_last_buffer_nr
},/* obsolete */
7757 {"len", 1, 1, f_len
},
7758 {"libcall", 3, 3, f_libcall
},
7759 {"libcallnr", 3, 3, f_libcallnr
},
7760 {"line", 1, 1, f_line
},
7761 {"line2byte", 1, 1, f_line2byte
},
7762 {"lispindent", 1, 1, f_lispindent
},
7763 {"localtime", 0, 0, f_localtime
},
7765 {"log", 1, 1, f_log
}, /* WJMc */
7766 {"log10", 1, 1, f_log10
},
7768 {"map", 2, 2, f_map
},
7769 {"maparg", 1, 3, f_maparg
},
7770 {"mapcheck", 1, 3, f_mapcheck
},
7771 {"match", 2, 4, f_match
},
7772 {"matchadd", 2, 4, f_matchadd
},
7773 {"matcharg", 1, 1, f_matcharg
},
7774 {"matchdelete", 1, 1, f_matchdelete
},
7775 {"matchend", 2, 4, f_matchend
},
7776 {"matchlist", 2, 4, f_matchlist
},
7777 {"matchstr", 2, 4, f_matchstr
},
7778 {"max", 1, 1, f_max
},
7779 {"min", 1, 1, f_min
},
7781 {"mkdir", 1, 3, f_mkdir
},
7783 {"mode", 0, 1, f_mode
},
7784 #ifdef FEAT_MZSCHEME
7785 {"mzeval", 1, 1, f_mzeval
},
7787 {"nextnonblank", 1, 1, f_nextnonblank
},
7788 {"nr2char", 1, 1, f_nr2char
},
7789 {"pathshorten", 1, 1, f_pathshorten
},
7791 {"pow", 2, 2, f_pow
},
7793 {"prevnonblank", 1, 1, f_prevnonblank
},
7794 {"printf", 2, 19, f_printf
},
7795 {"pumvisible", 0, 0, f_pumvisible
},
7796 {"range", 1, 3, f_range
},
7797 {"readfile", 1, 3, f_readfile
},
7798 {"reltime", 0, 2, f_reltime
},
7799 {"reltimestr", 1, 1, f_reltimestr
},
7800 {"remote_expr", 2, 3, f_remote_expr
},
7801 {"remote_foreground", 1, 1, f_remote_foreground
},
7802 {"remote_peek", 1, 2, f_remote_peek
},
7803 {"remote_read", 1, 1, f_remote_read
},
7804 {"remote_send", 2, 3, f_remote_send
},
7805 {"remove", 2, 3, f_remove
},
7806 {"rename", 2, 2, f_rename
},
7807 {"repeat", 2, 2, f_repeat
},
7808 {"resolve", 1, 1, f_resolve
},
7809 {"reverse", 1, 1, f_reverse
},
7811 {"round", 1, 1, f_round
},
7813 {"search", 1, 4, f_search
},
7814 {"searchdecl", 1, 3, f_searchdecl
},
7815 {"searchpair", 3, 7, f_searchpair
},
7816 {"searchpairpos", 3, 7, f_searchpairpos
},
7817 {"searchpos", 1, 4, f_searchpos
},
7818 {"server2client", 2, 2, f_server2client
},
7819 {"serverlist", 0, 0, f_serverlist
},
7820 {"setbufvar", 3, 3, f_setbufvar
},
7821 {"setcmdpos", 1, 1, f_setcmdpos
},
7822 {"setline", 2, 2, f_setline
},
7823 {"setloclist", 2, 3, f_setloclist
},
7824 {"setmatches", 1, 1, f_setmatches
},
7825 {"setpos", 2, 2, f_setpos
},
7826 {"setqflist", 1, 2, f_setqflist
},
7827 {"setreg", 2, 3, f_setreg
},
7828 {"settabwinvar", 4, 4, f_settabwinvar
},
7829 {"setwinvar", 3, 3, f_setwinvar
},
7830 {"shellescape", 1, 2, f_shellescape
},
7831 {"simplify", 1, 1, f_simplify
},
7833 {"sin", 1, 1, f_sin
},
7834 {"sinh", 1, 1, f_sinh
}, /* WJMc */
7836 {"sort", 1, 2, f_sort
},
7837 {"soundfold", 1, 1, f_soundfold
},
7838 {"spellbadword", 0, 1, f_spellbadword
},
7839 {"spellsuggest", 1, 3, f_spellsuggest
},
7840 {"split", 1, 3, f_split
},
7842 {"sqrt", 1, 1, f_sqrt
},
7843 {"str2float", 1, 1, f_str2float
},
7845 {"str2nr", 1, 2, f_str2nr
},
7846 #ifdef HAVE_STRFTIME
7847 {"strftime", 1, 2, f_strftime
},
7849 {"stridx", 2, 3, f_stridx
},
7850 {"string", 1, 1, f_string
},
7851 {"strlen", 1, 1, f_strlen
},
7852 {"strpart", 2, 3, f_strpart
},
7853 {"strridx", 2, 3, f_strridx
},
7854 {"strtrans", 1, 1, f_strtrans
},
7855 {"submatch", 1, 1, f_submatch
},
7856 {"substitute", 4, 4, f_substitute
},
7857 {"synID", 3, 3, f_synID
},
7858 {"synIDattr", 2, 3, f_synIDattr
},
7859 {"synIDtrans", 1, 1, f_synIDtrans
},
7860 {"synstack", 2, 2, f_synstack
},
7861 {"system", 1, 2, f_system
},
7862 {"tabpagebuflist", 0, 1, f_tabpagebuflist
},
7863 {"tabpagenr", 0, 1, f_tabpagenr
},
7864 {"tabpagewinnr", 1, 2, f_tabpagewinnr
},
7865 {"tagfiles", 0, 0, f_tagfiles
},
7866 {"taglist", 1, 1, f_taglist
},
7867 {"tan", 1, 1, f_tan
}, /* WJMc */
7868 {"tanh", 1, 1, f_tanh
}, /* WJMc */
7869 {"tempname", 0, 0, f_tempname
},
7870 {"test", 1, 1, f_test
},
7871 {"tolower", 1, 1, f_tolower
},
7872 {"toupper", 1, 1, f_toupper
},
7875 {"trunc", 1, 1, f_trunc
},
7877 {"type", 1, 1, f_type
},
7878 {"values", 1, 1, f_values
},
7879 {"virtcol", 1, 1, f_virtcol
},
7880 {"visualmode", 0, 1, f_visualmode
},
7881 {"winbufnr", 1, 1, f_winbufnr
},
7882 {"wincol", 0, 0, f_wincol
},
7883 {"winheight", 1, 1, f_winheight
},
7884 {"winline", 0, 0, f_winline
},
7885 {"winnr", 0, 1, f_winnr
},
7886 {"winrestcmd", 0, 0, f_winrestcmd
},
7887 {"winrestview", 1, 1, f_winrestview
},
7888 {"winsaveview", 0, 0, f_winsaveview
},
7889 {"winwidth", 1, 1, f_winwidth
},
7890 {"writefile", 2, 3, f_writefile
},
7893 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7896 * Function given to ExpandGeneric() to obtain the list of internal
7897 * or user defined function names.
7900 get_function_name(xp
, idx
)
7904 static int intidx
= -1;
7911 name
= get_user_func_name(xp
, idx
);
7915 if (++intidx
< (int)(sizeof(functions
) / sizeof(struct fst
)))
7917 STRCPY(IObuff
, functions
[intidx
].f_name
);
7918 STRCAT(IObuff
, "(");
7919 if (functions
[intidx
].f_max_argc
== 0)
7920 STRCAT(IObuff
, ")");
7928 * Function given to ExpandGeneric() to obtain the list of internal or
7929 * user defined variable or function names.
7932 get_expr_name(xp
, idx
)
7936 static int intidx
= -1;
7943 name
= get_function_name(xp
, idx
);
7947 return get_user_var_name(xp
, ++intidx
);
7950 #endif /* FEAT_CMDL_COMPL */
7953 * Find internal function in table above.
7954 * Return index, or -1 if not found
7957 find_internal_func(name
)
7958 char_u
*name
; /* name of the function */
7961 int last
= (int)(sizeof(functions
) / sizeof(struct fst
)) - 1;
7966 * Find the function name in the table. Binary search.
7968 while (first
<= last
)
7970 x
= first
+ ((unsigned)(last
- first
) >> 1);
7971 cmp
= STRCMP(name
, functions
[x
].f_name
);
7983 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7984 * name it contains, otherwise return "name".
7987 deref_func_name(name
, lenp
)
7996 v
= find_var(name
, NULL
);
7998 if (v
!= NULL
&& v
->di_tv
.v_type
== VAR_FUNC
)
8000 if (v
->di_tv
.vval
.v_string
== NULL
)
8003 return (char_u
*)""; /* just in case */
8005 *lenp
= (int)STRLEN(v
->di_tv
.vval
.v_string
);
8006 return v
->di_tv
.vval
.v_string
;
8013 * Allocate a variable for the result of a function.
8014 * Return OK or FAIL.
8017 get_func_tv(name
, len
, rettv
, arg
, firstline
, lastline
, doesrange
,
8019 char_u
*name
; /* name of the function */
8020 int len
; /* length of "name" */
8022 char_u
**arg
; /* argument, pointing to the '(' */
8023 linenr_T firstline
; /* first line of range */
8024 linenr_T lastline
; /* last line of range */
8025 int *doesrange
; /* return: function handled range */
8027 dict_T
*selfdict
; /* Dictionary for "self" */
8031 typval_T argvars
[MAX_FUNC_ARGS
+ 1]; /* vars for arguments */
8032 int argcount
= 0; /* number of arguments found */
8035 * Get the arguments.
8038 while (argcount
< MAX_FUNC_ARGS
)
8040 argp
= skipwhite(argp
+ 1); /* skip the '(' or ',' */
8041 if (*argp
== ')' || *argp
== ',' || *argp
== NUL
)
8043 if (eval1(&argp
, &argvars
[argcount
], evaluate
) == FAIL
)
8058 ret
= call_func(name
, len
, rettv
, argcount
, argvars
,
8059 firstline
, lastline
, doesrange
, evaluate
, selfdict
);
8060 else if (!aborting())
8062 if (argcount
== MAX_FUNC_ARGS
)
8063 emsg_funcname(N_("E740: Too many arguments for function %s"), name
);
8065 emsg_funcname(N_("E116: Invalid arguments for function %s"), name
);
8068 while (--argcount
>= 0)
8069 clear_tv(&argvars
[argcount
]);
8071 *arg
= skipwhite(argp
);
8077 * Call a function with its resolved parameters
8078 * Return OK when the function can't be called, FAIL otherwise.
8079 * Also returns OK when an error was encountered while executing the function.
8082 call_func(func_name
, len
, rettv
, argcount
, argvars
, firstline
, lastline
,
8083 doesrange
, evaluate
, selfdict
)
8084 char_u
*func_name
; /* name of the function */
8085 int len
; /* length of "name" */
8086 typval_T
*rettv
; /* return value goes here */
8087 int argcount
; /* number of "argvars" */
8088 typval_T
*argvars
; /* vars for arguments, must have "argcount"
8089 PLUS ONE elements! */
8090 linenr_T firstline
; /* first line of range */
8091 linenr_T lastline
; /* last line of range */
8092 int *doesrange
; /* return: function handled range */
8094 dict_T
*selfdict
; /* Dictionary for "self" */
8097 #define ERROR_UNKNOWN 0
8098 #define ERROR_TOOMANY 1
8099 #define ERROR_TOOFEW 2
8100 #define ERROR_SCRIPT 3
8101 #define ERROR_DICT 4
8102 #define ERROR_NONE 5
8103 #define ERROR_OTHER 6
8104 int error
= ERROR_NONE
;
8108 #define FLEN_FIXED 40
8109 char_u fname_buf
[FLEN_FIXED
+ 1];
8113 /* Make a copy of the name, if it comes from a funcref variable it could
8114 * be changed or deleted in the called function. */
8115 name
= vim_strnsave(func_name
, len
);
8120 * In a script change <SID>name() and s:name() to K_SNR 123_name().
8121 * Change <SNR>123_name() to K_SNR 123_name().
8122 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
8124 llen
= eval_fname_script(name
);
8127 fname_buf
[0] = K_SPECIAL
;
8128 fname_buf
[1] = KS_EXTRA
;
8129 fname_buf
[2] = (int)KE_SNR
;
8131 if (eval_fname_sid(name
)) /* "<SID>" or "s:" */
8133 if (current_SID
<= 0)
8134 error
= ERROR_SCRIPT
;
8137 sprintf((char *)fname_buf
+ 3, "%ld_", (long)current_SID
);
8138 i
= (int)STRLEN(fname_buf
);
8141 if (i
+ STRLEN(name
+ llen
) < FLEN_FIXED
)
8143 STRCPY(fname_buf
+ i
, name
+ llen
);
8148 fname
= alloc((unsigned)(i
+ STRLEN(name
+ llen
) + 1));
8150 error
= ERROR_OTHER
;
8153 mch_memmove(fname
, fname_buf
, (size_t)i
);
8154 STRCPY(fname
+ i
, name
+ llen
);
8164 /* execute the function if no errors detected and executing */
8165 if (evaluate
&& error
== ERROR_NONE
)
8167 rettv
->v_type
= VAR_NUMBER
; /* default rettv is number zero */
8168 rettv
->vval
.v_number
= 0;
8169 error
= ERROR_UNKNOWN
;
8171 if (!builtin_function(fname
))
8174 * User defined function.
8176 fp
= find_func(fname
);
8179 /* Trigger FuncUndefined event, may load the function. */
8181 && apply_autocmds(EVENT_FUNCUNDEFINED
,
8182 fname
, fname
, TRUE
, NULL
)
8185 /* executed an autocommand, search for the function again */
8186 fp
= find_func(fname
);
8189 /* Try loading a package. */
8190 if (fp
== NULL
&& script_autoload(fname
, TRUE
) && !aborting())
8192 /* loaded a package, search for the function again */
8193 fp
= find_func(fname
);
8198 if (fp
->uf_flags
& FC_RANGE
)
8200 if (argcount
< fp
->uf_args
.ga_len
)
8201 error
= ERROR_TOOFEW
;
8202 else if (!fp
->uf_varargs
&& argcount
> fp
->uf_args
.ga_len
)
8203 error
= ERROR_TOOMANY
;
8204 else if ((fp
->uf_flags
& FC_DICT
) && selfdict
== NULL
)
8209 * Call the user function.
8210 * Save and restore search patterns, script variables and
8213 save_search_patterns();
8216 call_user_func(fp
, argcount
, argvars
, rettv
,
8217 firstline
, lastline
,
8218 (fp
->uf_flags
& FC_DICT
) ? selfdict
: NULL
);
8219 if (--fp
->uf_calls
<= 0 && isdigit(*fp
->uf_name
)
8220 && fp
->uf_refcount
<= 0)
8221 /* Function was unreferenced while being used, free it
8225 restore_search_patterns();
8233 * Find the function name in the table, call its implementation.
8235 i
= find_internal_func(fname
);
8238 if (argcount
< functions
[i
].f_min_argc
)
8239 error
= ERROR_TOOFEW
;
8240 else if (argcount
> functions
[i
].f_max_argc
)
8241 error
= ERROR_TOOMANY
;
8244 argvars
[argcount
].v_type
= VAR_UNKNOWN
;
8245 functions
[i
].f_func(argvars
, rettv
);
8251 * The function call (or "FuncUndefined" autocommand sequence) might
8252 * have been aborted by an error, an interrupt, or an explicitly thrown
8253 * exception that has not been caught so far. This situation can be
8254 * tested for by calling aborting(). For an error in an internal
8255 * function or for the "E132" error in call_user_func(), however, the
8256 * throw point at which the "force_abort" flag (temporarily reset by
8257 * emsg()) is normally updated has not been reached yet. We need to
8258 * update that flag first to make aborting() reliable.
8260 update_force_abort();
8262 if (error
== ERROR_NONE
)
8266 * Report an error unless the argument evaluation or function call has been
8267 * cancelled due to an aborting error, an interrupt, or an exception.
8274 emsg_funcname(N_("E117: Unknown function: %s"), name
);
8277 emsg_funcname(e_toomanyarg
, name
);
8280 emsg_funcname(N_("E119: Not enough arguments for function: %s"),
8284 emsg_funcname(N_("E120: Using <SID> not in a script context: %s"),
8288 emsg_funcname(N_("E725: Calling dict function without Dictionary: %s"),
8294 if (fname
!= name
&& fname
!= fname_buf
)
8302 * Give an error message with a function name. Handle <SNR> things.
8303 * "ermsg" is to be passed without translation, use N_() instead of _().
8306 emsg_funcname(ermsg
, name
)
8312 if (*name
== K_SPECIAL
)
8313 p
= concat_str((char_u
*)"<SNR>", name
+ 3);
8322 * Return TRUE for a non-zero Number and a non-empty String.
8325 non_zero_arg(argvars
)
8328 return ((argvars
[0].v_type
== VAR_NUMBER
8329 && argvars
[0].vval
.v_number
!= 0)
8330 || (argvars
[0].v_type
== VAR_STRING
8331 && argvars
[0].vval
.v_string
!= NULL
8332 && *argvars
[0].vval
.v_string
!= NUL
));
8335 /*********************************************
8336 * Implementation of the built-in functions
8341 * "abs(expr)" function
8344 f_abs(argvars
, rettv
)
8348 if (argvars
[0].v_type
== VAR_FLOAT
)
8350 rettv
->v_type
= VAR_FLOAT
;
8351 rettv
->vval
.v_float
= fabs(argvars
[0].vval
.v_float
);
8358 n
= get_tv_number_chk(&argvars
[0], &error
);
8360 rettv
->vval
.v_number
= -1;
8362 rettv
->vval
.v_number
= n
;
8364 rettv
->vval
.v_number
= -n
;
8370 * "add(list, item)" function
8373 f_add(argvars
, rettv
)
8379 rettv
->vval
.v_number
= 1; /* Default: Failed */
8380 if (argvars
[0].v_type
== VAR_LIST
)
8382 if ((l
= argvars
[0].vval
.v_list
) != NULL
8383 && !tv_check_lock(l
->lv_lock
, (char_u
*)"add()")
8384 && list_append_tv(l
, &argvars
[1]) == OK
)
8385 copy_tv(&argvars
[0], rettv
);
8392 * "append(lnum, string/list)" function
8395 f_append(argvars
, rettv
)
8402 listitem_T
*li
= NULL
;
8406 lnum
= get_tv_lnum(argvars
);
8408 && lnum
<= curbuf
->b_ml
.ml_line_count
8409 && u_save(lnum
, lnum
+ 1) == OK
)
8411 if (argvars
[1].v_type
== VAR_LIST
)
8413 l
= argvars
[1].vval
.v_list
;
8421 tv
= &argvars
[1]; /* append a string */
8422 else if (li
== NULL
)
8423 break; /* end of list */
8425 tv
= &li
->li_tv
; /* append item from list */
8426 line
= get_tv_string_chk(tv
);
8427 if (line
== NULL
) /* type error */
8429 rettv
->vval
.v_number
= 1; /* Failed */
8432 ml_append(lnum
+ added
, line
, (colnr_T
)0, FALSE
);
8439 appended_lines_mark(lnum
, added
);
8440 if (curwin
->w_cursor
.lnum
> lnum
)
8441 curwin
->w_cursor
.lnum
+= added
;
8444 rettv
->vval
.v_number
= 1; /* Failed */
8451 f_argc(argvars
, rettv
)
8452 typval_T
*argvars UNUSED
;
8455 rettv
->vval
.v_number
= ARGCOUNT
;
8459 * "argidx()" function
8462 f_argidx(argvars
, rettv
)
8463 typval_T
*argvars UNUSED
;
8466 rettv
->vval
.v_number
= curwin
->w_arg_idx
;
8470 * "argv(nr)" function
8473 f_argv(argvars
, rettv
)
8479 if (argvars
[0].v_type
!= VAR_UNKNOWN
)
8481 idx
= get_tv_number_chk(&argvars
[0], NULL
);
8482 if (idx
>= 0 && idx
< ARGCOUNT
)
8483 rettv
->vval
.v_string
= vim_strsave(alist_name(&ARGLIST
[idx
]));
8485 rettv
->vval
.v_string
= NULL
;
8486 rettv
->v_type
= VAR_STRING
;
8488 else if (rettv_list_alloc(rettv
) == OK
)
8489 for (idx
= 0; idx
< ARGCOUNT
; ++idx
)
8490 list_append_string(rettv
->vval
.v_list
,
8491 alist_name(&ARGLIST
[idx
]), -1);
8495 static int get_float_arg
__ARGS((typval_T
*argvars
, float_T
*f
));
8498 * Get the float value of "argvars[0]" into "f".
8499 * Returns FAIL when the argument is not a Number or Float.
8502 get_float_arg(argvars
, f
)
8506 if (argvars
[0].v_type
== VAR_FLOAT
)
8508 *f
= argvars
[0].vval
.v_float
;
8511 if (argvars
[0].v_type
== VAR_NUMBER
)
8513 *f
= (float_T
)argvars
[0].vval
.v_number
;
8516 EMSG(_("E808: Number or Float required"));
8520 /* The 10 added FP functions are defined immediately before atan() - WJMc */
8526 f_acos(argvars
, rettv
)
8532 rettv
->v_type
= VAR_FLOAT
;
8533 if (get_float_arg(argvars
, &f
) == OK
)
8534 rettv
->vval
.v_float
= acos(f
);
8536 rettv
->vval
.v_float
= 0.0;
8543 f_asin(argvars
, rettv
)
8549 rettv
->v_type
= VAR_FLOAT
;
8550 if (get_float_arg(argvars
, &f
) == OK
)
8551 rettv
->vval
.v_float
= asin(f
);
8553 rettv
->vval
.v_float
= 0.0;
8557 * "atan2()" function
8560 f_atan2(argvars
, rettv
)
8566 rettv
->v_type
= VAR_FLOAT
;
8567 if (get_float_arg(argvars
, &fx
) == OK
8568 && get_float_arg(&argvars
[1], &fy
) == OK
)
8569 rettv
->vval
.v_float
= atan2(fx
, fy
);
8571 rettv
->vval
.v_float
= 0.0;
8578 f_cosh(argvars
, rettv
)
8584 rettv
->v_type
= VAR_FLOAT
;
8585 if (get_float_arg(argvars
, &f
) == OK
)
8586 rettv
->vval
.v_float
= cosh(f
);
8588 rettv
->vval
.v_float
= 0.0;
8595 f_exp(argvars
, rettv
)
8601 rettv
->v_type
= VAR_FLOAT
;
8602 if (get_float_arg(argvars
, &f
) == OK
)
8603 rettv
->vval
.v_float
= exp(f
);
8605 rettv
->vval
.v_float
= 0.0;
8612 f_fmod(argvars
, rettv
)
8618 rettv
->v_type
= VAR_FLOAT
;
8619 if (get_float_arg(argvars
, &fx
) == OK
8620 && get_float_arg(&argvars
[1], &fy
) == OK
)
8621 rettv
->vval
.v_float
= fmod(fx
, fy
);
8623 rettv
->vval
.v_float
= 0.0;
8630 f_log(argvars
, rettv
)
8636 rettv
->v_type
= VAR_FLOAT
;
8637 if (get_float_arg(argvars
, &f
) == OK
)
8638 rettv
->vval
.v_float
= log(f
);
8640 rettv
->vval
.v_float
= 0.0;
8647 f_sinh(argvars
, rettv
)
8653 rettv
->v_type
= VAR_FLOAT
;
8654 if (get_float_arg(argvars
, &f
) == OK
)
8655 rettv
->vval
.v_float
= sinh(f
);
8657 rettv
->vval
.v_float
= 0.0;
8664 f_tan(argvars
, rettv
)
8670 rettv
->v_type
= VAR_FLOAT
;
8671 if (get_float_arg(argvars
, &f
) == OK
)
8672 rettv
->vval
.v_float
= tan(f
);
8674 rettv
->vval
.v_float
= 0.0;
8681 f_tanh(argvars
, rettv
)
8687 rettv
->v_type
= VAR_FLOAT
;
8688 if (get_float_arg(argvars
, &f
) == OK
)
8689 rettv
->vval
.v_float
= tanh(f
);
8691 rettv
->vval
.v_float
= 0.0;
8694 /* End of the 10 added FP functions - WJMc */
8700 f_atan(argvars
, rettv
)
8706 rettv
->v_type
= VAR_FLOAT
;
8707 if (get_float_arg(argvars
, &f
) == OK
)
8708 rettv
->vval
.v_float
= atan(f
);
8710 rettv
->vval
.v_float
= 0.0;
8715 * "browse(save, title, initdir, default)" function
8718 f_browse(argvars
, rettv
)
8719 typval_T
*argvars UNUSED
;
8727 char_u buf
[NUMBUFLEN
];
8728 char_u buf2
[NUMBUFLEN
];
8731 save
= get_tv_number_chk(&argvars
[0], &error
);
8732 title
= get_tv_string_chk(&argvars
[1]);
8733 initdir
= get_tv_string_buf_chk(&argvars
[2], buf
);
8734 defname
= get_tv_string_buf_chk(&argvars
[3], buf2
);
8736 if (error
|| title
== NULL
|| initdir
== NULL
|| defname
== NULL
)
8737 rettv
->vval
.v_string
= NULL
;
8739 rettv
->vval
.v_string
=
8740 do_browse(save
? BROWSE_SAVE
: 0,
8741 title
, defname
, NULL
, initdir
, NULL
, curbuf
);
8743 rettv
->vval
.v_string
= NULL
;
8745 rettv
->v_type
= VAR_STRING
;
8749 * "browsedir(title, initdir)" function
8752 f_browsedir(argvars
, rettv
)
8753 typval_T
*argvars UNUSED
;
8759 char_u buf
[NUMBUFLEN
];
8761 title
= get_tv_string_chk(&argvars
[0]);
8762 initdir
= get_tv_string_buf_chk(&argvars
[1], buf
);
8764 if (title
== NULL
|| initdir
== NULL
)
8765 rettv
->vval
.v_string
= NULL
;
8767 rettv
->vval
.v_string
= do_browse(BROWSE_DIR
,
8768 title
, NULL
, NULL
, initdir
, NULL
, curbuf
);
8770 rettv
->vval
.v_string
= NULL
;
8772 rettv
->v_type
= VAR_STRING
;
8775 static buf_T
*find_buffer
__ARGS((typval_T
*avar
));
8778 * Find a buffer by number or exact name.
8786 if (avar
->v_type
== VAR_NUMBER
)
8787 buf
= buflist_findnr((int)avar
->vval
.v_number
);
8788 else if (avar
->v_type
== VAR_STRING
&& avar
->vval
.v_string
!= NULL
)
8790 buf
= buflist_findname_exp(avar
->vval
.v_string
);
8793 /* No full path name match, try a match with a URL or a "nofile"
8794 * buffer, these don't use the full path. */
8795 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
8796 if (buf
->b_fname
!= NULL
8797 && (path_with_url(buf
->b_fname
)
8798 #ifdef FEAT_QUICKFIX
8802 && STRCMP(buf
->b_fname
, avar
->vval
.v_string
) == 0)
8810 * "bufexists(expr)" function
8813 f_bufexists(argvars
, rettv
)
8817 rettv
->vval
.v_number
= (find_buffer(&argvars
[0]) != NULL
);
8821 * "buflisted(expr)" function
8824 f_buflisted(argvars
, rettv
)
8830 buf
= find_buffer(&argvars
[0]);
8831 rettv
->vval
.v_number
= (buf
!= NULL
&& buf
->b_p_bl
);
8835 * "bufloaded(expr)" function
8838 f_bufloaded(argvars
, rettv
)
8844 buf
= find_buffer(&argvars
[0]);
8845 rettv
->vval
.v_number
= (buf
!= NULL
&& buf
->b_ml
.ml_mfp
!= NULL
);
8848 static buf_T
*get_buf_tv
__ARGS((typval_T
*tv
));
8851 * Get buffer by number or pattern.
8857 char_u
*name
= tv
->vval
.v_string
;
8862 if (tv
->v_type
== VAR_NUMBER
)
8863 return buflist_findnr((int)tv
->vval
.v_number
);
8864 if (tv
->v_type
!= VAR_STRING
)
8866 if (name
== NULL
|| *name
== NUL
)
8868 if (name
[0] == '$' && name
[1] == NUL
)
8871 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8872 save_magic
= p_magic
;
8875 p_cpo
= (char_u
*)"";
8877 buf
= buflist_findnr(buflist_findpat(name
, name
+ STRLEN(name
),
8880 p_magic
= save_magic
;
8883 /* If not found, try expanding the name, like done for bufexists(). */
8885 buf
= find_buffer(tv
);
8891 * "bufname(expr)" function
8894 f_bufname(argvars
, rettv
)
8900 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
8902 buf
= get_buf_tv(&argvars
[0]);
8903 rettv
->v_type
= VAR_STRING
;
8904 if (buf
!= NULL
&& buf
->b_fname
!= NULL
)
8905 rettv
->vval
.v_string
= vim_strsave(buf
->b_fname
);
8907 rettv
->vval
.v_string
= NULL
;
8912 * "bufnr(expr)" function
8915 f_bufnr(argvars
, rettv
)
8923 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
8925 buf
= get_buf_tv(&argvars
[0]);
8928 /* If the buffer isn't found and the second argument is not zero create a
8931 && argvars
[1].v_type
!= VAR_UNKNOWN
8932 && get_tv_number_chk(&argvars
[1], &error
) != 0
8934 && (name
= get_tv_string_chk(&argvars
[0])) != NULL
8936 buf
= buflist_new(name
, NULL
, (linenr_T
)1, 0);
8939 rettv
->vval
.v_number
= buf
->b_fnum
;
8941 rettv
->vval
.v_number
= -1;
8945 * "bufwinnr(nr)" function
8948 f_bufwinnr(argvars
, rettv
)
8958 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
8960 buf
= get_buf_tv(&argvars
[0]);
8962 for (wp
= firstwin
; wp
; wp
= wp
->w_next
)
8965 if (wp
->w_buffer
== buf
)
8968 rettv
->vval
.v_number
= (wp
!= NULL
? winnr
: -1);
8970 rettv
->vval
.v_number
= (curwin
->w_buffer
== buf
? 1 : -1);
8976 * "byte2line(byte)" function
8979 f_byte2line(argvars
, rettv
)
8980 typval_T
*argvars UNUSED
;
8983 #ifndef FEAT_BYTEOFF
8984 rettv
->vval
.v_number
= -1;
8988 boff
= get_tv_number(&argvars
[0]) - 1; /* boff gets -1 on type error */
8990 rettv
->vval
.v_number
= -1;
8992 rettv
->vval
.v_number
= ml_find_line_or_offset(curbuf
,
8993 (linenr_T
)0, &boff
);
8998 * "byteidx()" function
9001 f_byteidx(argvars
, rettv
)
9011 str
= get_tv_string_chk(&argvars
[0]);
9012 idx
= get_tv_number_chk(&argvars
[1], NULL
);
9013 rettv
->vval
.v_number
= -1;
9014 if (str
== NULL
|| idx
< 0)
9019 for ( ; idx
> 0; idx
--)
9021 if (*t
== NUL
) /* EOL reached */
9023 t
+= (*mb_ptr2len
)(t
);
9025 rettv
->vval
.v_number
= (varnumber_T
)(t
- str
);
9027 if ((size_t)idx
<= STRLEN(str
))
9028 rettv
->vval
.v_number
= idx
;
9033 * "call(func, arglist)" function
9036 f_call(argvars
, rettv
)
9041 typval_T argv
[MAX_FUNC_ARGS
+ 1];
9045 dict_T
*selfdict
= NULL
;
9047 if (argvars
[1].v_type
!= VAR_LIST
)
9052 if (argvars
[1].vval
.v_list
== NULL
)
9055 if (argvars
[0].v_type
== VAR_FUNC
)
9056 func
= argvars
[0].vval
.v_string
;
9058 func
= get_tv_string(&argvars
[0]);
9060 return; /* type error or empty name */
9062 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9064 if (argvars
[2].v_type
!= VAR_DICT
)
9069 selfdict
= argvars
[2].vval
.v_dict
;
9072 for (item
= argvars
[1].vval
.v_list
->lv_first
; item
!= NULL
;
9073 item
= item
->li_next
)
9075 if (argc
== MAX_FUNC_ARGS
)
9077 EMSG(_("E699: Too many arguments"));
9080 /* Make a copy of each argument. This is needed to be able to set
9081 * v_lock to VAR_FIXED in the copy without changing the original list.
9083 copy_tv(&item
->li_tv
, &argv
[argc
++]);
9087 (void)call_func(func
, (int)STRLEN(func
), rettv
, argc
, argv
,
9088 curwin
->w_cursor
.lnum
, curwin
->w_cursor
.lnum
,
9089 &dummy
, TRUE
, selfdict
);
9091 /* Free the arguments. */
9093 clear_tv(&argv
[--argc
]);
9098 * "ceil({float})" function
9101 f_ceil(argvars
, rettv
)
9107 rettv
->v_type
= VAR_FLOAT
;
9108 if (get_float_arg(argvars
, &f
) == OK
)
9109 rettv
->vval
.v_float
= ceil(f
);
9111 rettv
->vval
.v_float
= 0.0;
9116 * "changenr()" function
9119 f_changenr(argvars
, rettv
)
9120 typval_T
*argvars UNUSED
;
9123 rettv
->vval
.v_number
= curbuf
->b_u_seq_cur
;
9127 * "char2nr(string)" function
9130 f_char2nr(argvars
, rettv
)
9136 rettv
->vval
.v_number
= (*mb_ptr2char
)(get_tv_string(&argvars
[0]));
9139 rettv
->vval
.v_number
= get_tv_string(&argvars
[0])[0];
9143 * "cindent(lnum)" function
9146 f_cindent(argvars
, rettv
)
9154 pos
= curwin
->w_cursor
;
9155 lnum
= get_tv_lnum(argvars
);
9156 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
)
9158 curwin
->w_cursor
.lnum
= lnum
;
9159 rettv
->vval
.v_number
= get_c_indent();
9160 curwin
->w_cursor
= pos
;
9164 rettv
->vval
.v_number
= -1;
9168 * "clearmatches()" function
9171 f_clearmatches(argvars
, rettv
)
9172 typval_T
*argvars UNUSED
;
9173 typval_T
*rettv UNUSED
;
9175 #ifdef FEAT_SEARCH_EXTRA
9176 clear_matches(curwin
);
9181 * "col(string)" function
9184 f_col(argvars
, rettv
)
9190 int fnum
= curbuf
->b_fnum
;
9192 fp
= var2fpos(&argvars
[0], FALSE
, &fnum
);
9193 if (fp
!= NULL
&& fnum
== curbuf
->b_fnum
)
9195 if (fp
->col
== MAXCOL
)
9197 /* '> can be MAXCOL, get the length of the line then */
9198 if (fp
->lnum
<= curbuf
->b_ml
.ml_line_count
)
9199 col
= (colnr_T
)STRLEN(ml_get(fp
->lnum
)) + 1;
9206 #ifdef FEAT_VIRTUALEDIT
9207 /* col(".") when the cursor is on the NUL at the end of the line
9208 * because of "coladd" can be seen as an extra column. */
9209 if (virtual_active() && fp
== &curwin
->w_cursor
)
9211 char_u
*p
= ml_get_cursor();
9213 if (curwin
->w_cursor
.coladd
>= (colnr_T
)chartabsize(p
,
9214 curwin
->w_virtcol
- curwin
->w_cursor
.coladd
))
9219 if (*p
!= NUL
&& p
[(l
= (*mb_ptr2len
)(p
))] == NUL
)
9222 if (*p
!= NUL
&& p
[1] == NUL
)
9230 rettv
->vval
.v_number
= col
;
9233 #if defined(FEAT_INS_EXPAND)
9235 * "complete()" function
9238 f_complete(argvars
, rettv
)
9240 typval_T
*rettv UNUSED
;
9244 if ((State
& INSERT
) == 0)
9246 EMSG(_("E785: complete() can only be used in Insert mode"));
9250 /* Check for undo allowed here, because if something was already inserted
9251 * the line was already saved for undo and this check isn't done. */
9252 if (!undo_allowed())
9255 if (argvars
[1].v_type
!= VAR_LIST
|| argvars
[1].vval
.v_list
== NULL
)
9261 startcol
= get_tv_number_chk(&argvars
[0], NULL
);
9265 set_completion(startcol
- 1, argvars
[1].vval
.v_list
);
9269 * "complete_add()" function
9272 f_complete_add(argvars
, rettv
)
9276 rettv
->vval
.v_number
= ins_compl_add_tv(&argvars
[0], 0);
9280 * "complete_check()" function
9283 f_complete_check(argvars
, rettv
)
9284 typval_T
*argvars UNUSED
;
9287 int saved
= RedrawingDisabled
;
9289 RedrawingDisabled
= 0;
9290 ins_compl_check_keys(0);
9291 rettv
->vval
.v_number
= compl_interrupted
;
9292 RedrawingDisabled
= saved
;
9297 * "confirm(message, buttons[, default [, type]])" function
9300 f_confirm(argvars
, rettv
)
9301 typval_T
*argvars UNUSED
;
9302 typval_T
*rettv UNUSED
;
9304 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
9306 char_u
*buttons
= NULL
;
9307 char_u buf
[NUMBUFLEN
];
9308 char_u buf2
[NUMBUFLEN
];
9310 int type
= VIM_GENERIC
;
9314 message
= get_tv_string_chk(&argvars
[0]);
9315 if (message
== NULL
)
9317 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
9319 buttons
= get_tv_string_buf_chk(&argvars
[1], buf
);
9320 if (buttons
== NULL
)
9322 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9324 def
= get_tv_number_chk(&argvars
[2], &error
);
9325 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
9327 typestr
= get_tv_string_buf_chk(&argvars
[3], buf2
);
9328 if (typestr
== NULL
)
9332 switch (TOUPPER_ASC(*typestr
))
9334 case 'E': type
= VIM_ERROR
; break;
9335 case 'Q': type
= VIM_QUESTION
; break;
9336 case 'I': type
= VIM_INFO
; break;
9337 case 'W': type
= VIM_WARNING
; break;
9338 case 'G': type
= VIM_GENERIC
; break;
9345 if (buttons
== NULL
|| *buttons
== NUL
)
9346 buttons
= (char_u
*)_("&Ok");
9349 rettv
->vval
.v_number
= do_dialog(type
, NULL
, message
, buttons
,
9358 f_copy(argvars
, rettv
)
9362 item_copy(&argvars
[0], rettv
, FALSE
, 0);
9370 f_cos(argvars
, rettv
)
9376 rettv
->v_type
= VAR_FLOAT
;
9377 if (get_float_arg(argvars
, &f
) == OK
)
9378 rettv
->vval
.v_float
= cos(f
);
9380 rettv
->vval
.v_float
= 0.0;
9385 * "count()" function
9388 f_count(argvars
, rettv
)
9395 if (argvars
[0].v_type
== VAR_LIST
)
9401 if ((l
= argvars
[0].vval
.v_list
) != NULL
)
9404 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9408 ic
= get_tv_number_chk(&argvars
[2], &error
);
9409 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
9411 idx
= get_tv_number_chk(&argvars
[3], &error
);
9414 li
= list_find(l
, idx
);
9416 EMSGN(_(e_listidx
), idx
);
9423 for ( ; li
!= NULL
; li
= li
->li_next
)
9424 if (tv_equal(&li
->li_tv
, &argvars
[1], ic
))
9428 else if (argvars
[0].v_type
== VAR_DICT
)
9434 if ((d
= argvars
[0].vval
.v_dict
) != NULL
)
9438 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9440 ic
= get_tv_number_chk(&argvars
[2], &error
);
9441 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
9445 todo
= error
? 0 : (int)d
->dv_hashtab
.ht_used
;
9446 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
9448 if (!HASHITEM_EMPTY(hi
))
9451 if (tv_equal(&HI2DI(hi
)->di_tv
, &argvars
[1], ic
))
9458 EMSG2(_(e_listdictarg
), "count()");
9459 rettv
->vval
.v_number
= n
;
9463 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
9465 * Checks the existence of a cscope connection.
9468 f_cscope_connection(argvars
, rettv
)
9469 typval_T
*argvars UNUSED
;
9470 typval_T
*rettv UNUSED
;
9474 char_u
*dbpath
= NULL
;
9475 char_u
*prepend
= NULL
;
9476 char_u buf
[NUMBUFLEN
];
9478 if (argvars
[0].v_type
!= VAR_UNKNOWN
9479 && argvars
[1].v_type
!= VAR_UNKNOWN
)
9481 num
= (int)get_tv_number(&argvars
[0]);
9482 dbpath
= get_tv_string(&argvars
[1]);
9483 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9484 prepend
= get_tv_string_buf(&argvars
[2], buf
);
9487 rettv
->vval
.v_number
= cs_connection(num
, dbpath
, prepend
);
9492 * "cursor(lnum, col)" function
9494 * Moves the cursor to the specified line and column.
9495 * Returns 0 when the position could be set, -1 otherwise.
9498 f_cursor(argvars
, rettv
)
9503 #ifdef FEAT_VIRTUALEDIT
9507 rettv
->vval
.v_number
= -1;
9508 if (argvars
[1].v_type
== VAR_UNKNOWN
)
9512 if (list2fpos(argvars
, &pos
, NULL
) == FAIL
)
9516 #ifdef FEAT_VIRTUALEDIT
9517 coladd
= pos
.coladd
;
9522 line
= get_tv_lnum(argvars
);
9523 col
= get_tv_number_chk(&argvars
[1], NULL
);
9524 #ifdef FEAT_VIRTUALEDIT
9525 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9526 coladd
= get_tv_number_chk(&argvars
[2], NULL
);
9529 if (line
< 0 || col
< 0
9530 #ifdef FEAT_VIRTUALEDIT
9534 return; /* type error; errmsg already given */
9536 curwin
->w_cursor
.lnum
= line
;
9538 curwin
->w_cursor
.col
= col
- 1;
9539 #ifdef FEAT_VIRTUALEDIT
9540 curwin
->w_cursor
.coladd
= coladd
;
9543 /* Make sure the cursor is in a valid position. */
9546 /* Correct cursor for multi-byte character. */
9551 curwin
->w_set_curswant
= TRUE
;
9552 rettv
->vval
.v_number
= 0;
9556 * "deepcopy()" function
9559 f_deepcopy(argvars
, rettv
)
9565 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
9566 noref
= get_tv_number_chk(&argvars
[1], NULL
);
9567 if (noref
< 0 || noref
> 1)
9571 current_copyID
+= COPYID_INC
;
9572 item_copy(&argvars
[0], rettv
, TRUE
, noref
== 0 ? current_copyID
: 0);
9577 * "delete()" function
9580 f_delete(argvars
, rettv
)
9584 if (check_restricted() || check_secure())
9585 rettv
->vval
.v_number
= -1;
9587 rettv
->vval
.v_number
= mch_remove(get_tv_string(&argvars
[0]));
9591 * "did_filetype()" function
9594 f_did_filetype(argvars
, rettv
)
9595 typval_T
*argvars UNUSED
;
9596 typval_T
*rettv UNUSED
;
9599 rettv
->vval
.v_number
= did_filetype
;
9604 * "diff_filler()" function
9607 f_diff_filler(argvars
, rettv
)
9608 typval_T
*argvars UNUSED
;
9609 typval_T
*rettv UNUSED
;
9612 rettv
->vval
.v_number
= diff_check_fill(curwin
, get_tv_lnum(argvars
));
9617 * "diff_hlID()" function
9620 f_diff_hlID(argvars
, rettv
)
9621 typval_T
*argvars UNUSED
;
9622 typval_T
*rettv UNUSED
;
9625 linenr_T lnum
= get_tv_lnum(argvars
);
9626 static linenr_T prev_lnum
= 0;
9627 static int changedtick
= 0;
9628 static int fnum
= 0;
9629 static int change_start
= 0;
9630 static int change_end
= 0;
9631 static hlf_T hlID
= (hlf_T
)0;
9635 if (lnum
< 0) /* ignore type error in {lnum} arg */
9637 if (lnum
!= prev_lnum
9638 || changedtick
!= curbuf
->b_changedtick
9639 || fnum
!= curbuf
->b_fnum
)
9641 /* New line, buffer, change: need to get the values. */
9642 filler_lines
= diff_check(curwin
, lnum
);
9643 if (filler_lines
< 0)
9645 if (filler_lines
== -1)
9647 change_start
= MAXCOL
;
9649 if (diff_find_change(curwin
, lnum
, &change_start
, &change_end
))
9650 hlID
= HLF_ADD
; /* added line */
9652 hlID
= HLF_CHD
; /* changed line */
9655 hlID
= HLF_ADD
; /* added line */
9660 changedtick
= curbuf
->b_changedtick
;
9661 fnum
= curbuf
->b_fnum
;
9664 if (hlID
== HLF_CHD
|| hlID
== HLF_TXD
)
9666 col
= get_tv_number(&argvars
[1]) - 1; /* ignore type error in {col} */
9667 if (col
>= change_start
&& col
<= change_end
)
9668 hlID
= HLF_TXD
; /* changed text */
9670 hlID
= HLF_CHD
; /* changed line */
9672 rettv
->vval
.v_number
= hlID
== (hlf_T
)0 ? 0 : (int)hlID
;
9677 * "empty({expr})" function
9680 f_empty(argvars
, rettv
)
9686 switch (argvars
[0].v_type
)
9690 n
= argvars
[0].vval
.v_string
== NULL
9691 || *argvars
[0].vval
.v_string
== NUL
;
9694 n
= argvars
[0].vval
.v_number
== 0;
9698 n
= argvars
[0].vval
.v_float
== 0.0;
9702 n
= argvars
[0].vval
.v_list
== NULL
9703 || argvars
[0].vval
.v_list
->lv_first
== NULL
;
9706 n
= argvars
[0].vval
.v_dict
== NULL
9707 || argvars
[0].vval
.v_dict
->dv_hashtab
.ht_used
== 0;
9710 EMSG2(_(e_intern2
), "f_empty()");
9714 rettv
->vval
.v_number
= n
;
9718 * "escape({string}, {chars})" function
9721 f_escape(argvars
, rettv
)
9725 char_u buf
[NUMBUFLEN
];
9727 rettv
->vval
.v_string
= vim_strsave_escaped(get_tv_string(&argvars
[0]),
9728 get_tv_string_buf(&argvars
[1], buf
));
9729 rettv
->v_type
= VAR_STRING
;
9736 f_eval(argvars
, rettv
)
9742 s
= get_tv_string_chk(&argvars
[0]);
9746 if (s
== NULL
|| eval1(&s
, rettv
, TRUE
) == FAIL
)
9748 rettv
->v_type
= VAR_NUMBER
;
9749 rettv
->vval
.v_number
= 0;
9752 EMSG(_(e_trailing
));
9756 * "eventhandler()" function
9759 f_eventhandler(argvars
, rettv
)
9760 typval_T
*argvars UNUSED
;
9763 rettv
->vval
.v_number
= vgetc_busy
;
9767 * "executable()" function
9770 f_executable(argvars
, rettv
)
9774 rettv
->vval
.v_number
= mch_can_exe(get_tv_string(&argvars
[0]));
9778 * "exists()" function
9781 f_exists(argvars
, rettv
)
9790 p
= get_tv_string(&argvars
[0]);
9791 if (*p
== '$') /* environment variable */
9793 /* first try "normal" environment variables (fast) */
9794 if (mch_getenv(p
+ 1) != NULL
)
9798 /* try expanding things like $VIM and ${HOME} */
9799 p
= expand_env_save(p
);
9800 if (p
!= NULL
&& *p
!= '$')
9805 else if (*p
== '&' || *p
== '+') /* option */
9807 n
= (get_option_tv(&p
, NULL
, TRUE
) == OK
);
9808 if (*skipwhite(p
) != NUL
)
9809 n
= FALSE
; /* trailing garbage */
9811 else if (*p
== '*') /* internal or user defined function */
9813 n
= function_exists(p
+ 1);
9817 n
= cmd_exists(p
+ 1);
9823 n
= autocmd_supported(p
+ 2);
9825 n
= au_exists(p
+ 1);
9828 else /* internal variable */
9833 /* get_name_len() takes care of expanding curly braces */
9835 len
= get_name_len(&p
, &tofree
, TRUE
, FALSE
);
9840 n
= (get_var_tv(name
, len
, &tv
, FALSE
) == OK
);
9843 /* handle d.key, l[idx], f(expr) */
9844 n
= (handle_subscript(&p
, &tv
, TRUE
, FALSE
) == OK
);
9855 rettv
->vval
.v_number
= n
;
9859 * "expand()" function
9862 f_expand(argvars
, rettv
)
9869 int flags
= WILD_SILENT
|WILD_USE_NL
|WILD_LIST_NOTFOUND
;
9873 rettv
->v_type
= VAR_STRING
;
9874 s
= get_tv_string(&argvars
[0]);
9875 if (*s
== '%' || *s
== '#' || *s
== '<')
9878 rettv
->vval
.v_string
= eval_vars(s
, s
, &len
, NULL
, &errormsg
, NULL
);
9883 /* When the optional second argument is non-zero, don't remove matches
9884 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
9885 if (argvars
[1].v_type
!= VAR_UNKNOWN
9886 && get_tv_number_chk(&argvars
[1], &error
))
9887 flags
|= WILD_KEEP_ALL
;
9891 xpc
.xp_context
= EXPAND_FILES
;
9892 rettv
->vval
.v_string
= ExpandOne(&xpc
, s
, NULL
, flags
, WILD_ALL
);
9895 rettv
->vval
.v_string
= NULL
;
9900 * "extend(list, list [, idx])" function
9901 * "extend(dict, dict [, action])" function
9904 f_extend(argvars
, rettv
)
9908 if (argvars
[0].v_type
== VAR_LIST
&& argvars
[1].v_type
== VAR_LIST
)
9915 l1
= argvars
[0].vval
.v_list
;
9916 l2
= argvars
[1].vval
.v_list
;
9917 if (l1
!= NULL
&& !tv_check_lock(l1
->lv_lock
, (char_u
*)"extend()")
9920 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9922 before
= get_tv_number_chk(&argvars
[2], &error
);
9924 return; /* type error; errmsg already given */
9926 if (before
== l1
->lv_len
)
9930 item
= list_find(l1
, before
);
9933 EMSGN(_(e_listidx
), before
);
9940 list_extend(l1
, l2
, item
);
9942 copy_tv(&argvars
[0], rettv
);
9945 else if (argvars
[0].v_type
== VAR_DICT
&& argvars
[1].v_type
== VAR_DICT
)
9954 d1
= argvars
[0].vval
.v_dict
;
9955 d2
= argvars
[1].vval
.v_dict
;
9956 if (d1
!= NULL
&& !tv_check_lock(d1
->dv_lock
, (char_u
*)"extend()")
9959 /* Check the third argument. */
9960 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
9962 static char *(av
[]) = {"keep", "force", "error"};
9964 action
= get_tv_string_chk(&argvars
[2]);
9966 return; /* type error; errmsg already given */
9967 for (i
= 0; i
< 3; ++i
)
9968 if (STRCMP(action
, av
[i
]) == 0)
9972 EMSG2(_(e_invarg2
), action
);
9977 action
= (char_u
*)"force";
9979 /* Go over all entries in the second dict and add them to the
9981 todo
= (int)d2
->dv_hashtab
.ht_used
;
9982 for (hi2
= d2
->dv_hashtab
.ht_array
; todo
> 0; ++hi2
)
9984 if (!HASHITEM_EMPTY(hi2
))
9987 di1
= dict_find(d1
, hi2
->hi_key
, -1);
9990 di1
= dictitem_copy(HI2DI(hi2
));
9991 if (di1
!= NULL
&& dict_add(d1
, di1
) == FAIL
)
9994 else if (*action
== 'e')
9996 EMSG2(_("E737: Key already exists: %s"), hi2
->hi_key
);
9999 else if (*action
== 'f')
10001 clear_tv(&di1
->di_tv
);
10002 copy_tv(&HI2DI(hi2
)->di_tv
, &di1
->di_tv
);
10007 copy_tv(&argvars
[0], rettv
);
10011 EMSG2(_(e_listdictarg
), "extend()");
10015 * "feedkeys()" function
10018 f_feedkeys(argvars
, rettv
)
10020 typval_T
*rettv UNUSED
;
10023 char_u
*keys
, *flags
;
10024 char_u nbuf
[NUMBUFLEN
];
10028 /* This is not allowed in the sandbox. If the commands would still be
10029 * executed in the sandbox it would be OK, but it probably happens later,
10030 * when "sandbox" is no longer set. */
10031 if (check_secure())
10034 keys
= get_tv_string(&argvars
[0]);
10037 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
10039 flags
= get_tv_string_buf(&argvars
[1], nbuf
);
10040 for ( ; *flags
!= NUL
; ++flags
)
10044 case 'n': remap
= FALSE
; break;
10045 case 'm': remap
= TRUE
; break;
10046 case 't': typed
= TRUE
; break;
10051 /* Need to escape K_SPECIAL and CSI before putting the string in the
10052 * typeahead buffer. */
10053 keys_esc
= vim_strsave_escape_csi(keys
);
10054 if (keys_esc
!= NULL
)
10056 ins_typebuf(keys_esc
, (remap
? REMAP_YES
: REMAP_NONE
),
10057 typebuf
.tb_len
, !typed
, FALSE
);
10058 vim_free(keys_esc
);
10060 typebuf_was_filled
= TRUE
;
10066 * "filereadable()" function
10069 f_filereadable(argvars
, rettv
)
10078 # define O_NONBLOCK 0
10080 p
= get_tv_string(&argvars
[0]);
10081 if (*p
&& !mch_isdir(p
) && (fd
= mch_open((char *)p
,
10082 O_RDONLY
| O_NONBLOCK
, 0)) >= 0)
10090 rettv
->vval
.v_number
= n
;
10094 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
10095 * rights to write into.
10098 f_filewritable(argvars
, rettv
)
10102 rettv
->vval
.v_number
= filewritable(get_tv_string(&argvars
[0]));
10105 static void findfilendir
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int find_what
));
10108 findfilendir(argvars
, rettv
, find_what
)
10113 #ifdef FEAT_SEARCHPATH
10115 char_u
*fresult
= NULL
;
10116 char_u
*path
= *curbuf
->b_p_path
== NUL
? p_path
: curbuf
->b_p_path
;
10118 char_u pathbuf
[NUMBUFLEN
];
10124 rettv
->vval
.v_string
= NULL
;
10125 rettv
->v_type
= VAR_STRING
;
10127 #ifdef FEAT_SEARCHPATH
10128 fname
= get_tv_string(&argvars
[0]);
10130 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
10132 p
= get_tv_string_buf_chk(&argvars
[1], pathbuf
);
10140 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
10141 count
= get_tv_number_chk(&argvars
[2], &error
);
10145 if (count
< 0 && rettv_list_alloc(rettv
) == FAIL
)
10148 if (*fname
!= NUL
&& !error
)
10152 if (rettv
->v_type
== VAR_STRING
)
10154 fresult
= find_file_in_path_option(first
? fname
: NULL
,
10155 first
? (int)STRLEN(fname
) : 0,
10159 find_what
== FINDFILE_DIR
10160 ? (char_u
*)"" : curbuf
->b_p_sua
);
10163 if (fresult
!= NULL
&& rettv
->v_type
== VAR_LIST
)
10164 list_append_string(rettv
->vval
.v_list
, fresult
, -1);
10166 } while ((rettv
->v_type
== VAR_LIST
|| --count
> 0) && fresult
!= NULL
);
10169 if (rettv
->v_type
== VAR_STRING
)
10170 rettv
->vval
.v_string
= fresult
;
10174 static void filter_map
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int map
));
10175 static int filter_map_one
__ARGS((typval_T
*tv
, char_u
*expr
, int map
, int *remp
));
10178 * Implementation of map() and filter().
10181 filter_map(argvars
, rettv
, map
)
10186 char_u buf
[NUMBUFLEN
];
10188 listitem_T
*li
, *nli
;
10198 char_u
*ermsg
= map
? (char_u
*)"map()" : (char_u
*)"filter()";
10202 if (argvars
[0].v_type
== VAR_LIST
)
10204 if ((l
= argvars
[0].vval
.v_list
) == NULL
10205 || (map
&& tv_check_lock(l
->lv_lock
, ermsg
)))
10208 else if (argvars
[0].v_type
== VAR_DICT
)
10210 if ((d
= argvars
[0].vval
.v_dict
) == NULL
10211 || (map
&& tv_check_lock(d
->dv_lock
, ermsg
)))
10216 EMSG2(_(e_listdictarg
), ermsg
);
10220 expr
= get_tv_string_buf_chk(&argvars
[1], buf
);
10221 /* On type errors, the preceding call has already displayed an error
10222 * message. Avoid a misleading error message for an empty string that
10223 * was not passed as argument. */
10226 prepare_vimvar(VV_VAL
, &save_val
);
10227 expr
= skipwhite(expr
);
10229 /* We reset "did_emsg" to be able to detect whether an error
10230 * occurred during evaluation of the expression. */
10231 save_did_emsg
= did_emsg
;
10234 prepare_vimvar(VV_KEY
, &save_key
);
10235 if (argvars
[0].v_type
== VAR_DICT
)
10237 vimvars
[VV_KEY
].vv_type
= VAR_STRING
;
10239 ht
= &d
->dv_hashtab
;
10241 todo
= (int)ht
->ht_used
;
10242 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
10244 if (!HASHITEM_EMPTY(hi
))
10248 if (tv_check_lock(di
->di_tv
.v_lock
, ermsg
))
10250 vimvars
[VV_KEY
].vv_str
= vim_strsave(di
->di_key
);
10251 if (filter_map_one(&di
->di_tv
, expr
, map
, &rem
) == FAIL
10255 dictitem_remove(d
, di
);
10256 clear_tv(&vimvars
[VV_KEY
].vv_tv
);
10263 vimvars
[VV_KEY
].vv_type
= VAR_NUMBER
;
10265 for (li
= l
->lv_first
; li
!= NULL
; li
= nli
)
10267 if (tv_check_lock(li
->li_tv
.v_lock
, ermsg
))
10270 vimvars
[VV_KEY
].vv_nr
= index
;
10271 if (filter_map_one(&li
->li_tv
, expr
, map
, &rem
) == FAIL
10275 listitem_remove(l
, li
);
10280 restore_vimvar(VV_KEY
, &save_key
);
10281 restore_vimvar(VV_VAL
, &save_val
);
10283 did_emsg
|= save_did_emsg
;
10286 copy_tv(&argvars
[0], rettv
);
10290 filter_map_one(tv
, expr
, map
, remp
)
10300 copy_tv(tv
, &vimvars
[VV_VAL
].vv_tv
);
10302 if (eval1(&s
, &rettv
, TRUE
) == FAIL
)
10304 if (*s
!= NUL
) /* check for trailing chars after expr */
10306 EMSG2(_(e_invexpr2
), s
);
10311 /* map(): replace the list item value */
10320 /* filter(): when expr is zero remove the item */
10321 *remp
= (get_tv_number_chk(&rettv
, &error
) == 0);
10323 /* On type error, nothing has been removed; return FAIL to stop the
10324 * loop. The error message was given by get_tv_number_chk(). */
10330 clear_tv(&vimvars
[VV_VAL
].vv_tv
);
10335 * "filter()" function
10338 f_filter(argvars
, rettv
)
10342 filter_map(argvars
, rettv
, FALSE
);
10346 * "finddir({fname}[, {path}[, {count}]])" function
10349 f_finddir(argvars
, rettv
)
10353 findfilendir(argvars
, rettv
, FINDFILE_DIR
);
10357 * "findfile({fname}[, {path}[, {count}]])" function
10360 f_findfile(argvars
, rettv
)
10364 findfilendir(argvars
, rettv
, FINDFILE_FILE
);
10369 * "float2nr({float})" function
10372 f_float2nr(argvars
, rettv
)
10378 if (get_float_arg(argvars
, &f
) == OK
)
10380 if (f
< -0x7fffffff)
10381 rettv
->vval
.v_number
= -0x7fffffff;
10382 else if (f
> 0x7fffffff)
10383 rettv
->vval
.v_number
= 0x7fffffff;
10385 rettv
->vval
.v_number
= (varnumber_T
)f
;
10390 * "floor({float})" function
10393 f_floor(argvars
, rettv
)
10399 rettv
->v_type
= VAR_FLOAT
;
10400 if (get_float_arg(argvars
, &f
) == OK
)
10401 rettv
->vval
.v_float
= floor(f
);
10403 rettv
->vval
.v_float
= 0.0;
10408 * "fnameescape({string})" function
10411 f_fnameescape(argvars
, rettv
)
10415 rettv
->vval
.v_string
= vim_strsave_fnameescape(
10416 get_tv_string(&argvars
[0]), FALSE
);
10417 rettv
->v_type
= VAR_STRING
;
10421 * "fnamemodify({fname}, {mods})" function
10424 f_fnamemodify(argvars
, rettv
)
10432 char_u
*fbuf
= NULL
;
10433 char_u buf
[NUMBUFLEN
];
10435 fname
= get_tv_string_chk(&argvars
[0]);
10436 mods
= get_tv_string_buf_chk(&argvars
[1], buf
);
10437 if (fname
== NULL
|| mods
== NULL
)
10441 len
= (int)STRLEN(fname
);
10442 (void)modify_fname(mods
, &usedlen
, &fname
, &fbuf
, &len
);
10445 rettv
->v_type
= VAR_STRING
;
10447 rettv
->vval
.v_string
= NULL
;
10449 rettv
->vval
.v_string
= vim_strnsave(fname
, len
);
10453 static void foldclosed_both
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int end
));
10456 * "foldclosed()" function
10459 foldclosed_both(argvars
, rettv
, end
)
10464 #ifdef FEAT_FOLDING
10466 linenr_T first
, last
;
10468 lnum
= get_tv_lnum(argvars
);
10469 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
)
10471 if (hasFoldingWin(curwin
, lnum
, &first
, &last
, FALSE
, NULL
))
10474 rettv
->vval
.v_number
= (varnumber_T
)last
;
10476 rettv
->vval
.v_number
= (varnumber_T
)first
;
10481 rettv
->vval
.v_number
= -1;
10485 * "foldclosed()" function
10488 f_foldclosed(argvars
, rettv
)
10492 foldclosed_both(argvars
, rettv
, FALSE
);
10496 * "foldclosedend()" function
10499 f_foldclosedend(argvars
, rettv
)
10503 foldclosed_both(argvars
, rettv
, TRUE
);
10507 * "foldlevel()" function
10510 f_foldlevel(argvars
, rettv
)
10514 #ifdef FEAT_FOLDING
10517 lnum
= get_tv_lnum(argvars
);
10518 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
)
10519 rettv
->vval
.v_number
= foldLevel(lnum
);
10524 * "foldtext()" function
10527 f_foldtext(argvars
, rettv
)
10528 typval_T
*argvars UNUSED
;
10531 #ifdef FEAT_FOLDING
10539 rettv
->v_type
= VAR_STRING
;
10540 rettv
->vval
.v_string
= NULL
;
10541 #ifdef FEAT_FOLDING
10542 if ((linenr_T
)vimvars
[VV_FOLDSTART
].vv_nr
> 0
10543 && (linenr_T
)vimvars
[VV_FOLDEND
].vv_nr
10544 <= curbuf
->b_ml
.ml_line_count
10545 && vimvars
[VV_FOLDDASHES
].vv_str
!= NULL
)
10547 /* Find first non-empty line in the fold. */
10548 lnum
= (linenr_T
)vimvars
[VV_FOLDSTART
].vv_nr
;
10549 while (lnum
< (linenr_T
)vimvars
[VV_FOLDEND
].vv_nr
)
10551 if (!linewhite(lnum
))
10556 /* Find interesting text in this line. */
10557 s
= skipwhite(ml_get(lnum
));
10558 /* skip C comment-start */
10559 if (s
[0] == '/' && (s
[1] == '*' || s
[1] == '/'))
10561 s
= skipwhite(s
+ 2);
10562 if (*skipwhite(s
) == NUL
10563 && lnum
+ 1 < (linenr_T
)vimvars
[VV_FOLDEND
].vv_nr
)
10565 s
= skipwhite(ml_get(lnum
+ 1));
10567 s
= skipwhite(s
+ 1);
10570 txt
= _("+-%s%3ld lines: ");
10571 r
= alloc((unsigned)(STRLEN(txt
)
10572 + STRLEN(vimvars
[VV_FOLDDASHES
].vv_str
) /* for %s */
10573 + 20 /* for %3ld */
10574 + STRLEN(s
))); /* concatenated */
10577 sprintf((char *)r
, txt
, vimvars
[VV_FOLDDASHES
].vv_str
,
10578 (long)((linenr_T
)vimvars
[VV_FOLDEND
].vv_nr
10579 - (linenr_T
)vimvars
[VV_FOLDSTART
].vv_nr
+ 1));
10580 len
= (int)STRLEN(r
);
10582 /* remove 'foldmarker' and 'commentstring' */
10583 foldtext_cleanup(r
+ len
);
10584 rettv
->vval
.v_string
= r
;
10591 * "foldtextresult(lnum)" function
10594 f_foldtextresult(argvars
, rettv
)
10595 typval_T
*argvars UNUSED
;
10598 #ifdef FEAT_FOLDING
10602 foldinfo_T foldinfo
;
10606 rettv
->v_type
= VAR_STRING
;
10607 rettv
->vval
.v_string
= NULL
;
10608 #ifdef FEAT_FOLDING
10609 lnum
= get_tv_lnum(argvars
);
10610 /* treat illegal types and illegal string values for {lnum} the same */
10613 fold_count
= foldedCount(curwin
, lnum
, &foldinfo
);
10614 if (fold_count
> 0)
10616 text
= get_foldtext(curwin
, lnum
, lnum
+ fold_count
- 1,
10619 text
= vim_strsave(text
);
10620 rettv
->vval
.v_string
= text
;
10626 * "foreground()" function
10629 f_foreground(argvars
, rettv
)
10630 typval_T
*argvars UNUSED
;
10631 typval_T
*rettv UNUSED
;
10635 gui_mch_set_foreground();
10638 win32_set_foreground();
10644 * "function()" function
10647 f_function(argvars
, rettv
)
10653 s
= get_tv_string(&argvars
[0]);
10654 if (s
== NULL
|| *s
== NUL
|| VIM_ISDIGIT(*s
))
10655 EMSG2(_(e_invarg2
), s
);
10656 /* Don't check an autoload name for existence here. */
10657 else if (vim_strchr(s
, AUTOLOAD_CHAR
) == NULL
&& !function_exists(s
))
10658 EMSG2(_("E700: Unknown function: %s"), s
);
10661 rettv
->vval
.v_string
= vim_strsave(s
);
10662 rettv
->v_type
= VAR_FUNC
;
10667 * "garbagecollect()" function
10670 f_garbagecollect(argvars
, rettv
)
10672 typval_T
*rettv UNUSED
;
10674 /* This is postponed until we are back at the toplevel, because we may be
10675 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10676 want_garbage_collect
= TRUE
;
10678 if (argvars
[0].v_type
!= VAR_UNKNOWN
&& get_tv_number(&argvars
[0]) == 1)
10679 garbage_collect_at_exit
= TRUE
;
10686 f_get(argvars
, rettv
)
10694 typval_T
*tv
= NULL
;
10696 if (argvars
[0].v_type
== VAR_LIST
)
10698 if ((l
= argvars
[0].vval
.v_list
) != NULL
)
10702 li
= list_find(l
, get_tv_number_chk(&argvars
[1], &error
));
10703 if (!error
&& li
!= NULL
)
10707 else if (argvars
[0].v_type
== VAR_DICT
)
10709 if ((d
= argvars
[0].vval
.v_dict
) != NULL
)
10711 di
= dict_find(d
, get_tv_string(&argvars
[1]), -1);
10717 EMSG2(_(e_listdictarg
), "get()");
10721 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
10722 copy_tv(&argvars
[2], rettv
);
10725 copy_tv(tv
, rettv
);
10728 static void get_buffer_lines
__ARGS((buf_T
*buf
, linenr_T start
, linenr_T end
, int retlist
, typval_T
*rettv
));
10731 * Get line or list of lines from buffer "buf" into "rettv".
10732 * Return a range (from start to end) of lines in rettv from the specified
10734 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10737 get_buffer_lines(buf
, start
, end
, retlist
, rettv
)
10746 if (retlist
&& rettv_list_alloc(rettv
) == FAIL
)
10749 if (buf
== NULL
|| buf
->b_ml
.ml_mfp
== NULL
|| start
< 0)
10754 if (start
>= 1 && start
<= buf
->b_ml
.ml_line_count
)
10755 p
= ml_get_buf(buf
, start
, FALSE
);
10759 rettv
->v_type
= VAR_STRING
;
10760 rettv
->vval
.v_string
= vim_strsave(p
);
10769 if (end
> buf
->b_ml
.ml_line_count
)
10770 end
= buf
->b_ml
.ml_line_count
;
10771 while (start
<= end
)
10772 if (list_append_string(rettv
->vval
.v_list
,
10773 ml_get_buf(buf
, start
++, FALSE
), -1) == FAIL
)
10779 * "getbufline()" function
10782 f_getbufline(argvars
, rettv
)
10790 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
10792 buf
= get_buf_tv(&argvars
[0]);
10795 lnum
= get_tv_lnum_buf(&argvars
[1], buf
);
10796 if (argvars
[2].v_type
== VAR_UNKNOWN
)
10799 end
= get_tv_lnum_buf(&argvars
[2], buf
);
10801 get_buffer_lines(buf
, lnum
, end
, TRUE
, rettv
);
10805 * "getbufvar()" function
10808 f_getbufvar(argvars
, rettv
)
10813 buf_T
*save_curbuf
;
10817 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
10818 varname
= get_tv_string_chk(&argvars
[1]);
10820 buf
= get_buf_tv(&argvars
[0]);
10822 rettv
->v_type
= VAR_STRING
;
10823 rettv
->vval
.v_string
= NULL
;
10825 if (buf
!= NULL
&& varname
!= NULL
)
10827 /* set curbuf to be our buf, temporarily */
10828 save_curbuf
= curbuf
;
10831 if (*varname
== '&') /* buffer-local-option */
10832 get_option_tv(&varname
, rettv
, TRUE
);
10835 if (*varname
== NUL
)
10836 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10837 * scope prefix before the NUL byte is required by
10838 * find_var_in_ht(). */
10839 varname
= (char_u
*)"b:" + 2;
10840 /* look up the variable */
10841 v
= find_var_in_ht(&curbuf
->b_vars
.dv_hashtab
, varname
, FALSE
);
10843 copy_tv(&v
->di_tv
, rettv
);
10846 /* restore previous notion of curbuf */
10847 curbuf
= save_curbuf
;
10854 * "getchar()" function
10857 f_getchar(argvars
, rettv
)
10864 /* Position the cursor. Needed after a message that ends in a space. */
10865 windgoto(msg_row
, msg_col
);
10871 if (argvars
[0].v_type
== VAR_UNKNOWN
)
10872 /* getchar(): blocking wait. */
10874 else if (get_tv_number_chk(&argvars
[0], &error
) == 1)
10875 /* getchar(1): only check if char avail */
10877 else if (error
|| vpeekc() == NUL
)
10878 /* illegal argument or getchar(0) and no char avail: return zero */
10881 /* getchar(0) and char avail: return char */
10890 vimvars
[VV_MOUSE_WIN
].vv_nr
= 0;
10891 vimvars
[VV_MOUSE_LNUM
].vv_nr
= 0;
10892 vimvars
[VV_MOUSE_COL
].vv_nr
= 0;
10894 rettv
->vval
.v_number
= n
;
10895 if (IS_SPECIAL(n
) || mod_mask
!= 0)
10897 char_u temp
[10]; /* modifier: 3, mbyte-char: 6, NUL: 1 */
10900 /* Turn a special key into three bytes, plus modifier. */
10903 temp
[i
++] = K_SPECIAL
;
10904 temp
[i
++] = KS_MODIFIER
;
10905 temp
[i
++] = mod_mask
;
10909 temp
[i
++] = K_SPECIAL
;
10910 temp
[i
++] = K_SECOND(n
);
10911 temp
[i
++] = K_THIRD(n
);
10914 else if (has_mbyte
)
10915 i
+= (*mb_char2bytes
)(n
, temp
+ i
);
10920 rettv
->v_type
= VAR_STRING
;
10921 rettv
->vval
.v_string
= vim_strsave(temp
);
10924 if (n
== K_LEFTMOUSE
10925 || n
== K_LEFTMOUSE_NM
10927 || n
== K_LEFTRELEASE
10928 || n
== K_LEFTRELEASE_NM
10929 || n
== K_MIDDLEMOUSE
10930 || n
== K_MIDDLEDRAG
10931 || n
== K_MIDDLERELEASE
10932 || n
== K_RIGHTMOUSE
10933 || n
== K_RIGHTDRAG
10934 || n
== K_RIGHTRELEASE
10937 || n
== K_X1RELEASE
10940 || n
== K_X2RELEASE
10941 || n
== K_MOUSEDOWN
10944 int row
= mouse_row
;
10945 int col
= mouse_col
;
10948 # ifdef FEAT_WINDOWS
10953 if (row
>= 0 && col
>= 0)
10955 /* Find the window at the mouse coordinates and compute the
10956 * text position. */
10957 win
= mouse_find_win(&row
, &col
);
10958 (void)mouse_comp_pos(win
, &row
, &col
, &lnum
);
10959 # ifdef FEAT_WINDOWS
10960 for (wp
= firstwin
; wp
!= win
; wp
= wp
->w_next
)
10963 vimvars
[VV_MOUSE_WIN
].vv_nr
= winnr
;
10964 vimvars
[VV_MOUSE_LNUM
].vv_nr
= lnum
;
10965 vimvars
[VV_MOUSE_COL
].vv_nr
= col
+ 1;
10973 * "getcharmod()" function
10976 f_getcharmod(argvars
, rettv
)
10977 typval_T
*argvars UNUSED
;
10980 rettv
->vval
.v_number
= mod_mask
;
10984 * "getcmdline()" function
10987 f_getcmdline(argvars
, rettv
)
10988 typval_T
*argvars UNUSED
;
10991 rettv
->v_type
= VAR_STRING
;
10992 rettv
->vval
.v_string
= get_cmdline_str();
10996 * "getcmdpos()" function
10999 f_getcmdpos(argvars
, rettv
)
11000 typval_T
*argvars UNUSED
;
11003 rettv
->vval
.v_number
= get_cmdline_pos() + 1;
11007 * "getcmdtype()" function
11010 f_getcmdtype(argvars
, rettv
)
11011 typval_T
*argvars UNUSED
;
11014 rettv
->v_type
= VAR_STRING
;
11015 rettv
->vval
.v_string
= alloc(2);
11016 if (rettv
->vval
.v_string
!= NULL
)
11018 rettv
->vval
.v_string
[0] = get_cmdline_type();
11019 rettv
->vval
.v_string
[1] = NUL
;
11024 * "getcwd()" function
11027 f_getcwd(argvars
, rettv
)
11028 typval_T
*argvars UNUSED
;
11031 char_u cwd
[MAXPATHL
];
11033 rettv
->v_type
= VAR_STRING
;
11034 if (mch_dirname(cwd
, MAXPATHL
) == FAIL
)
11035 rettv
->vval
.v_string
= NULL
;
11038 rettv
->vval
.v_string
= vim_strsave(cwd
);
11039 #ifdef BACKSLASH_IN_FILENAME
11040 if (rettv
->vval
.v_string
!= NULL
)
11041 slash_adjust(rettv
->vval
.v_string
);
11047 * "getfontname()" function
11050 f_getfontname(argvars
, rettv
)
11051 typval_T
*argvars UNUSED
;
11054 rettv
->v_type
= VAR_STRING
;
11055 rettv
->vval
.v_string
= NULL
;
11060 char_u
*name
= NULL
;
11062 if (argvars
[0].v_type
== VAR_UNKNOWN
)
11064 /* Get the "Normal" font. Either the name saved by
11065 * hl_set_font_name() or from the font ID. */
11066 font
= gui
.norm_font
;
11067 name
= hl_get_font_name();
11071 name
= get_tv_string(&argvars
[0]);
11072 if (STRCMP(name
, "*") == 0) /* don't use font dialog */
11074 font
= gui_mch_get_font(name
, FALSE
);
11075 if (font
== NOFONT
)
11076 return; /* Invalid font name, return empty string. */
11078 rettv
->vval
.v_string
= gui_mch_get_fontname(font
, name
);
11079 if (argvars
[0].v_type
!= VAR_UNKNOWN
)
11080 gui_mch_free_font(font
);
11086 * "getfperm({fname})" function
11089 f_getfperm(argvars
, rettv
)
11095 char_u
*perm
= NULL
;
11096 char_u flags
[] = "rwx";
11099 fname
= get_tv_string(&argvars
[0]);
11101 rettv
->v_type
= VAR_STRING
;
11102 if (mch_stat((char *)fname
, &st
) >= 0)
11104 perm
= vim_strsave((char_u
*)"---------");
11107 for (i
= 0; i
< 9; i
++)
11109 if (st
.st_mode
& (1 << (8 - i
)))
11110 perm
[i
] = flags
[i
% 3];
11114 rettv
->vval
.v_string
= perm
;
11118 * "getfsize({fname})" function
11121 f_getfsize(argvars
, rettv
)
11128 fname
= get_tv_string(&argvars
[0]);
11130 rettv
->v_type
= VAR_NUMBER
;
11132 if (mch_stat((char *)fname
, &st
) >= 0)
11134 if (mch_isdir(fname
))
11135 rettv
->vval
.v_number
= 0;
11138 rettv
->vval
.v_number
= (varnumber_T
)st
.st_size
;
11140 /* non-perfect check for overflow */
11141 if ((off_t
)rettv
->vval
.v_number
!= (off_t
)st
.st_size
)
11142 rettv
->vval
.v_number
= -2;
11146 rettv
->vval
.v_number
= -1;
11150 * "getftime({fname})" function
11153 f_getftime(argvars
, rettv
)
11160 fname
= get_tv_string(&argvars
[0]);
11162 if (mch_stat((char *)fname
, &st
) >= 0)
11163 rettv
->vval
.v_number
= (varnumber_T
)st
.st_mtime
;
11165 rettv
->vval
.v_number
= -1;
11169 * "getftype({fname})" function
11172 f_getftype(argvars
, rettv
)
11178 char_u
*type
= NULL
;
11181 fname
= get_tv_string(&argvars
[0]);
11183 rettv
->v_type
= VAR_STRING
;
11184 if (mch_lstat((char *)fname
, &st
) >= 0)
11187 if (S_ISREG(st
.st_mode
))
11189 else if (S_ISDIR(st
.st_mode
))
11192 else if (S_ISLNK(st
.st_mode
))
11196 else if (S_ISBLK(st
.st_mode
))
11200 else if (S_ISCHR(st
.st_mode
))
11204 else if (S_ISFIFO(st
.st_mode
))
11208 else if (S_ISSOCK(st
.st_mode
))
11215 switch (st
.st_mode
& S_IFMT
)
11217 case S_IFREG
: t
= "file"; break;
11218 case S_IFDIR
: t
= "dir"; break;
11220 case S_IFLNK
: t
= "link"; break;
11223 case S_IFBLK
: t
= "bdev"; break;
11226 case S_IFCHR
: t
= "cdev"; break;
11229 case S_IFIFO
: t
= "fifo"; break;
11232 case S_IFSOCK
: t
= "socket"; break;
11234 default: t
= "other";
11237 if (mch_isdir(fname
))
11243 type
= vim_strsave((char_u
*)t
);
11245 rettv
->vval
.v_string
= type
;
11249 * "getline(lnum, [end])" function
11252 f_getline(argvars
, rettv
)
11260 lnum
= get_tv_lnum(argvars
);
11261 if (argvars
[1].v_type
== VAR_UNKNOWN
)
11268 end
= get_tv_lnum(&argvars
[1]);
11272 get_buffer_lines(curbuf
, lnum
, end
, retlist
, rettv
);
11276 * "getmatches()" function
11279 f_getmatches(argvars
, rettv
)
11280 typval_T
*argvars UNUSED
;
11283 #ifdef FEAT_SEARCH_EXTRA
11285 matchitem_T
*cur
= curwin
->w_match_head
;
11287 if (rettv_list_alloc(rettv
) == OK
)
11289 while (cur
!= NULL
)
11291 dict
= dict_alloc();
11294 dict_add_nr_str(dict
, "group", 0L, syn_id2name(cur
->hlg_id
));
11295 dict_add_nr_str(dict
, "pattern", 0L, cur
->pattern
);
11296 dict_add_nr_str(dict
, "priority", (long)cur
->priority
, NULL
);
11297 dict_add_nr_str(dict
, "id", (long)cur
->id
, NULL
);
11298 list_append_dict(rettv
->vval
.v_list
, dict
);
11306 * "getpid()" function
11309 f_getpid(argvars
, rettv
)
11310 typval_T
*argvars UNUSED
;
11313 rettv
->vval
.v_number
= mch_get_pid();
11317 * "getpos(string)" function
11320 f_getpos(argvars
, rettv
)
11328 if (rettv_list_alloc(rettv
) == OK
)
11330 l
= rettv
->vval
.v_list
;
11331 fp
= var2fpos(&argvars
[0], TRUE
, &fnum
);
11333 list_append_number(l
, (varnumber_T
)fnum
);
11335 list_append_number(l
, (varnumber_T
)0);
11336 list_append_number(l
, (fp
!= NULL
) ? (varnumber_T
)fp
->lnum
11338 list_append_number(l
, (fp
!= NULL
)
11339 ? (varnumber_T
)(fp
->col
== MAXCOL
? MAXCOL
: fp
->col
+ 1)
11341 list_append_number(l
,
11342 #ifdef FEAT_VIRTUALEDIT
11343 (fp
!= NULL
) ? (varnumber_T
)fp
->coladd
:
11348 rettv
->vval
.v_number
= FALSE
;
11352 * "getqflist()" and "getloclist()" functions
11355 f_getqflist(argvars
, rettv
)
11356 typval_T
*argvars UNUSED
;
11357 typval_T
*rettv UNUSED
;
11359 #ifdef FEAT_QUICKFIX
11363 #ifdef FEAT_QUICKFIX
11364 if (rettv_list_alloc(rettv
) == OK
)
11367 if (argvars
[0].v_type
!= VAR_UNKNOWN
) /* getloclist() */
11369 wp
= find_win_by_nr(&argvars
[0], NULL
);
11374 (void)get_errorlist(wp
, rettv
->vval
.v_list
);
11380 * "getreg()" function
11383 f_getreg(argvars
, rettv
)
11387 char_u
*strregname
;
11392 if (argvars
[0].v_type
!= VAR_UNKNOWN
)
11394 strregname
= get_tv_string_chk(&argvars
[0]);
11395 error
= strregname
== NULL
;
11396 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
11397 arg2
= get_tv_number_chk(&argvars
[1], &error
);
11400 strregname
= vimvars
[VV_REG
].vv_str
;
11401 regname
= (strregname
== NULL
? '"' : *strregname
);
11405 rettv
->v_type
= VAR_STRING
;
11406 rettv
->vval
.v_string
= error
? NULL
:
11407 get_reg_contents(regname
, TRUE
, arg2
);
11411 * "getregtype()" function
11414 f_getregtype(argvars
, rettv
)
11418 char_u
*strregname
;
11420 char_u buf
[NUMBUFLEN
+ 2];
11423 if (argvars
[0].v_type
!= VAR_UNKNOWN
)
11425 strregname
= get_tv_string_chk(&argvars
[0]);
11426 if (strregname
== NULL
) /* type error; errmsg already given */
11428 rettv
->v_type
= VAR_STRING
;
11429 rettv
->vval
.v_string
= NULL
;
11434 /* Default to v:register */
11435 strregname
= vimvars
[VV_REG
].vv_str
;
11437 regname
= (strregname
== NULL
? '"' : *strregname
);
11443 switch (get_reg_type(regname
, ®len
))
11445 case MLINE
: buf
[0] = 'V'; break;
11446 case MCHAR
: buf
[0] = 'v'; break;
11450 sprintf((char *)buf
+ 1, "%ld", reglen
+ 1);
11454 rettv
->v_type
= VAR_STRING
;
11455 rettv
->vval
.v_string
= vim_strsave(buf
);
11459 * "gettabwinvar()" function
11462 f_gettabwinvar(argvars
, rettv
)
11466 getwinvar(argvars
, rettv
, 1);
11470 * "getwinposx()" function
11473 f_getwinposx(argvars
, rettv
)
11474 typval_T
*argvars UNUSED
;
11477 rettv
->vval
.v_number
= -1;
11483 if (gui_mch_get_winpos(&x
, &y
) == OK
)
11484 rettv
->vval
.v_number
= x
;
11490 * "getwinposy()" function
11493 f_getwinposy(argvars
, rettv
)
11494 typval_T
*argvars UNUSED
;
11497 rettv
->vval
.v_number
= -1;
11503 if (gui_mch_get_winpos(&x
, &y
) == OK
)
11504 rettv
->vval
.v_number
= y
;
11510 * Find window specified by "vp" in tabpage "tp".
11513 find_win_by_nr(vp
, tp
)
11515 tabpage_T
*tp
; /* NULL for current tab page */
11517 #ifdef FEAT_WINDOWS
11522 nr
= get_tv_number_chk(vp
, NULL
);
11524 #ifdef FEAT_WINDOWS
11530 for (wp
= (tp
== NULL
|| tp
== curtab
) ? firstwin
: tp
->tp_firstwin
;
11531 wp
!= NULL
; wp
= wp
->w_next
)
11536 if (nr
== 0 || nr
== 1)
11543 * "getwinvar()" function
11546 f_getwinvar(argvars
, rettv
)
11550 getwinvar(argvars
, rettv
, 0);
11554 * getwinvar() and gettabwinvar()
11557 getwinvar(argvars
, rettv
, off
)
11560 int off
; /* 1 for gettabwinvar() */
11562 win_T
*win
, *oldcurwin
;
11567 #ifdef FEAT_WINDOWS
11569 tp
= find_tabpage((int)get_tv_number_chk(&argvars
[0], NULL
));
11573 win
= find_win_by_nr(&argvars
[off
], tp
);
11574 varname
= get_tv_string_chk(&argvars
[off
+ 1]);
11577 rettv
->v_type
= VAR_STRING
;
11578 rettv
->vval
.v_string
= NULL
;
11580 if (win
!= NULL
&& varname
!= NULL
)
11582 /* Set curwin to be our win, temporarily. Also set curbuf, so
11583 * that we can get buffer-local options. */
11584 oldcurwin
= curwin
;
11586 curbuf
= win
->w_buffer
;
11588 if (*varname
== '&') /* window-local-option */
11589 get_option_tv(&varname
, rettv
, 1);
11592 if (*varname
== NUL
)
11593 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11594 * scope prefix before the NUL byte is required by
11595 * find_var_in_ht(). */
11596 varname
= (char_u
*)"w:" + 2;
11597 /* look up the variable */
11598 v
= find_var_in_ht(&win
->w_vars
.dv_hashtab
, varname
, FALSE
);
11600 copy_tv(&v
->di_tv
, rettv
);
11603 /* restore previous notion of curwin */
11604 curwin
= oldcurwin
;
11605 curbuf
= curwin
->w_buffer
;
11612 * "glob()" function
11615 f_glob(argvars
, rettv
)
11619 int flags
= WILD_SILENT
|WILD_USE_NL
;
11623 /* When the optional second argument is non-zero, don't remove matches
11624 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
11625 if (argvars
[1].v_type
!= VAR_UNKNOWN
11626 && get_tv_number_chk(&argvars
[1], &error
))
11627 flags
|= WILD_KEEP_ALL
;
11628 rettv
->v_type
= VAR_STRING
;
11632 xpc
.xp_context
= EXPAND_FILES
;
11633 rettv
->vval
.v_string
= ExpandOne(&xpc
, get_tv_string(&argvars
[0]),
11634 NULL
, flags
, WILD_ALL
);
11637 rettv
->vval
.v_string
= NULL
;
11641 * "globpath()" function
11644 f_globpath(argvars
, rettv
)
11649 char_u buf1
[NUMBUFLEN
];
11650 char_u
*file
= get_tv_string_buf_chk(&argvars
[1], buf1
);
11653 /* When the optional second argument is non-zero, don't remove matches
11654 * for 'wildignore' and don't put matches for 'suffixes' at the end. */
11655 if (argvars
[2].v_type
!= VAR_UNKNOWN
11656 && get_tv_number_chk(&argvars
[2], &error
))
11657 flags
|= WILD_KEEP_ALL
;
11658 rettv
->v_type
= VAR_STRING
;
11659 if (file
== NULL
|| error
)
11660 rettv
->vval
.v_string
= NULL
;
11662 rettv
->vval
.v_string
= globpath(get_tv_string(&argvars
[0]), file
,
11670 f_has(argvars
, rettv
)
11677 static char *(has_list
[]) =
11698 #if defined(MACOS_X_UNIX)
11722 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11725 #if defined(WIN64) || defined(_WIN64)
11731 #ifndef CASE_INSENSITIVE_FILENAME
11737 #ifdef FEAT_AUTOCMD
11742 # ifndef FEAT_GUI_W32 /* other GUIs always have multiline balloons */
11743 "balloon_multiline",
11746 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11748 # ifdef ALL_BUILTIN_TCAPS
11749 "all_builtin_terms",
11752 #ifdef FEAT_BYTEOFF
11755 #ifdef FEAT_CINDENT
11758 #ifdef FEAT_CLIENTSERVER
11761 #ifdef FEAT_CLIPBOARD
11764 #ifdef FEAT_CMDL_COMPL
11767 #ifdef FEAT_CMDHIST
11770 #ifdef FEAT_COMMENTS
11779 #ifdef CURSOR_SHAPE
11785 #ifdef FEAT_CON_DIALOG
11788 #ifdef FEAT_GUI_DIALOG
11794 #ifdef FEAT_DIGRAPHS
11800 #ifdef FEAT_EMACS_TAGS
11803 "eval", /* always present, of course! */
11804 #ifdef FEAT_EX_EXTRA
11807 #ifdef FEAT_SEARCH_EXTRA
11813 #ifdef FEAT_SEARCHPATH
11816 #if defined(UNIX) && !defined(USE_SYSTEM)
11819 #ifdef FEAT_FIND_ID
11825 #ifdef FEAT_FOLDING
11831 #if !defined(USE_SYSTEM) && defined(UNIX)
11834 #ifdef FEAT_GETTEXT
11840 #ifdef FEAT_GUI_ATHENA
11841 # ifdef FEAT_GUI_NEXTAW
11847 #ifdef FEAT_GUI_GTK
11853 #ifdef FEAT_GUI_GNOME
11856 #ifdef FEAT_GUI_MAC
11859 #ifdef FEAT_GUI_MOTIF
11862 #ifdef FEAT_GUI_PHOTON
11865 #ifdef FEAT_GUI_W16
11868 #ifdef FEAT_GUI_W32
11871 #ifdef FEAT_HANGULIN
11874 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11877 #ifdef FEAT_INS_EXPAND
11880 #ifdef FEAT_JUMPLIST
11886 #ifdef FEAT_LANGMAP
11889 #ifdef FEAT_LIBCALL
11892 #ifdef FEAT_LINEBREAK
11898 #ifdef FEAT_LISTCMDS
11901 #ifdef FEAT_LOCALMAP
11905 # ifndef DYNAMIC_LUA
11912 #ifdef FEAT_SESSION
11915 #ifdef FEAT_MODIFY_FNAME
11921 #ifdef FEAT_MOUSESHAPE
11924 #if defined(UNIX) || defined(VMS)
11925 # ifdef FEAT_MOUSE_DEC
11928 # ifdef FEAT_MOUSE_GPM
11931 # ifdef FEAT_MOUSE_JSB
11934 # ifdef FEAT_MOUSE_NET
11937 # ifdef FEAT_MOUSE_PTERM
11940 # ifdef FEAT_SYSMOUSE
11943 # ifdef FEAT_MOUSE_XTERM
11950 #ifdef FEAT_MBYTE_IME
11953 #ifdef FEAT_MULTI_LANG
11956 #ifdef FEAT_MZSCHEME
11957 #ifndef DYNAMIC_MZSCHEME
11964 #ifdef FEAT_OSFILETYPE
11967 #ifdef FEAT_PATH_EXTRA
11971 #ifndef DYNAMIC_PERL
11975 #ifdef FEAT_PERSISTENT_UNDO
11979 #ifndef DYNAMIC_PYTHON
11983 #ifdef FEAT_POSTSCRIPT
11986 #ifdef FEAT_PRINTER
11989 #ifdef FEAT_PROFILE
11992 #ifdef FEAT_RELTIME
11995 #ifdef FEAT_QUICKFIX
11998 #ifdef FEAT_RIGHTLEFT
12001 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
12004 #ifdef FEAT_SCROLLBIND
12007 #ifdef FEAT_CMDL_INFO
12014 #ifdef FEAT_SMARTINDENT
12023 #ifdef FEAT_STL_OPT
12026 #ifdef FEAT_SUN_WORKSHOP
12029 #ifdef FEAT_NETBEANS_INTG
12038 #if defined(USE_SYSTEM) || !defined(UNIX)
12041 #ifdef FEAT_TAG_BINS
12044 #ifdef FEAT_TAG_OLDSTATIC
12047 #ifdef FEAT_TAG_ANYWHITE
12051 # ifndef DYNAMIC_TCL
12058 #ifdef FEAT_TERMRESPONSE
12061 #ifdef FEAT_TEXTOBJ
12064 #ifdef HAVE_TGETENT
12070 #ifdef FEAT_TOOLBAR
12073 #ifdef FEAT_USR_CMDS
12074 "user-commands", /* was accidentally included in 5.4 */
12077 #ifdef FEAT_VIMINFO
12080 #ifdef FEAT_VARTABS
12083 #ifdef FEAT_VERTSPLIT
12086 #ifdef FEAT_VIRTUALEDIT
12092 #ifdef FEAT_VISUALEXTRA
12095 #ifdef FEAT_VREPLACE
12098 #ifdef FEAT_WILDIGN
12101 #ifdef FEAT_WILDMENU
12104 #ifdef FEAT_WINDOWS
12110 #ifdef FEAT_WRITEBACKUP
12116 #ifdef FEAT_XFONTSET
12122 #ifdef USE_XSMP_INTERACT
12125 #ifdef FEAT_XCLIPBOARD
12128 #ifdef FEAT_XTERM_SAVE
12131 #if defined(UNIX) && defined(FEAT_X11)
12137 name
= get_tv_string(&argvars
[0]);
12138 for (i
= 0; has_list
[i
] != NULL
; ++i
)
12139 if (STRICMP(name
, has_list
[i
]) == 0)
12147 if (STRNICMP(name
, "patch", 5) == 0)
12148 n
= has_patch(atoi((char *)name
+ 5));
12149 else if (STRICMP(name
, "vim_starting") == 0)
12150 n
= (starting
!= 0);
12152 else if (STRICMP(name
, "multi_byte_encoding") == 0)
12155 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
12156 else if (STRICMP(name
, "balloon_multiline") == 0)
12157 n
= multiline_balloon_available();
12160 else if (STRICMP(name
, "tcl") == 0)
12161 n
= tcl_enabled(FALSE
);
12163 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
12164 else if (STRICMP(name
, "iconv") == 0)
12165 n
= iconv_enabled(FALSE
);
12168 else if (STRICMP(name
, "lua") == 0)
12169 n
= lua_enabled(FALSE
);
12171 #ifdef DYNAMIC_MZSCHEME
12172 else if (STRICMP(name
, "mzscheme") == 0)
12173 n
= mzscheme_enabled(FALSE
);
12175 #ifdef DYNAMIC_RUBY
12176 else if (STRICMP(name
, "ruby") == 0)
12177 n
= ruby_enabled(FALSE
);
12179 #ifdef DYNAMIC_PYTHON
12180 else if (STRICMP(name
, "python") == 0)
12181 n
= python_enabled(FALSE
);
12183 #ifdef DYNAMIC_PERL
12184 else if (STRICMP(name
, "perl") == 0)
12185 n
= perl_enabled(FALSE
);
12188 else if (STRICMP(name
, "gui_running") == 0)
12189 n
= (gui
.in_use
|| gui
.starting
);
12190 # ifdef FEAT_GUI_W32
12191 else if (STRICMP(name
, "gui_win32s") == 0)
12192 n
= gui_is_win32s();
12194 # ifdef FEAT_BROWSE
12195 else if (STRICMP(name
, "browse") == 0)
12196 n
= gui
.in_use
; /* gui_mch_browse() works when GUI is running */
12200 else if (STRICMP(name
, "syntax_items") == 0)
12201 n
= syntax_present(curbuf
);
12203 #if defined(WIN3264)
12204 else if (STRICMP(name
, "win95") == 0)
12205 n
= mch_windows95();
12207 #ifdef FEAT_NETBEANS_INTG
12208 else if (STRICMP(name
, "netbeans_enabled") == 0)
12213 rettv
->vval
.v_number
= n
;
12217 * "has_key()" function
12220 f_has_key(argvars
, rettv
)
12224 if (argvars
[0].v_type
!= VAR_DICT
)
12226 EMSG(_(e_dictreq
));
12229 if (argvars
[0].vval
.v_dict
== NULL
)
12232 rettv
->vval
.v_number
= dict_find(argvars
[0].vval
.v_dict
,
12233 get_tv_string(&argvars
[1]), -1) != NULL
;
12237 * "haslocaldir()" function
12240 f_haslocaldir(argvars
, rettv
)
12241 typval_T
*argvars UNUSED
;
12244 rettv
->vval
.v_number
= (curwin
->w_localdir
!= NULL
);
12248 * "hasmapto()" function
12251 f_hasmapto(argvars
, rettv
)
12257 char_u buf
[NUMBUFLEN
];
12260 name
= get_tv_string(&argvars
[0]);
12261 if (argvars
[1].v_type
== VAR_UNKNOWN
)
12262 mode
= (char_u
*)"nvo";
12265 mode
= get_tv_string_buf(&argvars
[1], buf
);
12266 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
12267 abbr
= get_tv_number(&argvars
[2]);
12270 if (map_to_exists(name
, mode
, abbr
))
12271 rettv
->vval
.v_number
= TRUE
;
12273 rettv
->vval
.v_number
= FALSE
;
12277 * "histadd()" function
12280 f_histadd(argvars
, rettv
)
12281 typval_T
*argvars UNUSED
;
12284 #ifdef FEAT_CMDHIST
12287 char_u buf
[NUMBUFLEN
];
12290 rettv
->vval
.v_number
= FALSE
;
12291 if (check_restricted() || check_secure())
12293 #ifdef FEAT_CMDHIST
12294 str
= get_tv_string_chk(&argvars
[0]); /* NULL on type error */
12295 histype
= str
!= NULL
? get_histtype(str
) : -1;
12298 str
= get_tv_string_buf(&argvars
[1], buf
);
12302 add_to_history(histype
, str
, FALSE
, NUL
);
12303 rettv
->vval
.v_number
= TRUE
;
12311 * "histdel()" function
12314 f_histdel(argvars
, rettv
)
12315 typval_T
*argvars UNUSED
;
12316 typval_T
*rettv UNUSED
;
12318 #ifdef FEAT_CMDHIST
12320 char_u buf
[NUMBUFLEN
];
12323 str
= get_tv_string_chk(&argvars
[0]); /* NULL on type error */
12326 else if (argvars
[1].v_type
== VAR_UNKNOWN
)
12327 /* only one argument: clear entire history */
12328 n
= clr_history(get_histtype(str
));
12329 else if (argvars
[1].v_type
== VAR_NUMBER
)
12330 /* index given: remove that entry */
12331 n
= del_history_idx(get_histtype(str
),
12332 (int)get_tv_number(&argvars
[1]));
12334 /* string given: remove all matching entries */
12335 n
= del_history_entry(get_histtype(str
),
12336 get_tv_string_buf(&argvars
[1], buf
));
12337 rettv
->vval
.v_number
= n
;
12342 * "histget()" function
12345 f_histget(argvars
, rettv
)
12346 typval_T
*argvars UNUSED
;
12349 #ifdef FEAT_CMDHIST
12354 str
= get_tv_string_chk(&argvars
[0]); /* NULL on type error */
12356 rettv
->vval
.v_string
= NULL
;
12359 type
= get_histtype(str
);
12360 if (argvars
[1].v_type
== VAR_UNKNOWN
)
12361 idx
= get_history_idx(type
);
12363 idx
= (int)get_tv_number_chk(&argvars
[1], NULL
);
12364 /* -1 on type error */
12365 rettv
->vval
.v_string
= vim_strsave(get_history_entry(type
, idx
));
12368 rettv
->vval
.v_string
= NULL
;
12370 rettv
->v_type
= VAR_STRING
;
12374 * "histnr()" function
12377 f_histnr(argvars
, rettv
)
12378 typval_T
*argvars UNUSED
;
12383 #ifdef FEAT_CMDHIST
12384 char_u
*history
= get_tv_string_chk(&argvars
[0]);
12386 i
= history
== NULL
? HIST_CMD
- 1 : get_histtype(history
);
12387 if (i
>= HIST_CMD
&& i
< HIST_COUNT
)
12388 i
= get_history_idx(i
);
12392 rettv
->vval
.v_number
= i
;
12396 * "highlightID(name)" function
12399 f_hlID(argvars
, rettv
)
12403 rettv
->vval
.v_number
= syn_name2id(get_tv_string(&argvars
[0]));
12407 * "highlight_exists()" function
12410 f_hlexists(argvars
, rettv
)
12414 rettv
->vval
.v_number
= highlight_exists(get_tv_string(&argvars
[0]));
12418 * "hostname()" function
12421 f_hostname(argvars
, rettv
)
12422 typval_T
*argvars UNUSED
;
12425 char_u hostname
[256];
12427 mch_get_host_name(hostname
, 256);
12428 rettv
->v_type
= VAR_STRING
;
12429 rettv
->vval
.v_string
= vim_strsave(hostname
);
12436 f_iconv(argvars
, rettv
)
12437 typval_T
*argvars UNUSED
;
12441 char_u buf1
[NUMBUFLEN
];
12442 char_u buf2
[NUMBUFLEN
];
12443 char_u
*from
, *to
, *str
;
12447 rettv
->v_type
= VAR_STRING
;
12448 rettv
->vval
.v_string
= NULL
;
12451 str
= get_tv_string(&argvars
[0]);
12452 from
= enc_canonize(enc_skip(get_tv_string_buf(&argvars
[1], buf1
)));
12453 to
= enc_canonize(enc_skip(get_tv_string_buf(&argvars
[2], buf2
)));
12454 vimconv
.vc_type
= CONV_NONE
;
12455 convert_setup(&vimconv
, from
, to
);
12457 /* If the encodings are equal, no conversion needed. */
12458 if (vimconv
.vc_type
== CONV_NONE
)
12459 rettv
->vval
.v_string
= vim_strsave(str
);
12461 rettv
->vval
.v_string
= string_convert(&vimconv
, str
, NULL
);
12463 convert_setup(&vimconv
, NULL
, NULL
);
12470 * "indent()" function
12473 f_indent(argvars
, rettv
)
12479 lnum
= get_tv_lnum(argvars
);
12480 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
)
12481 rettv
->vval
.v_number
= get_indent_lnum(lnum
);
12483 rettv
->vval
.v_number
= -1;
12487 * "index()" function
12490 f_index(argvars
, rettv
)
12499 rettv
->vval
.v_number
= -1;
12500 if (argvars
[0].v_type
!= VAR_LIST
)
12502 EMSG(_(e_listreq
));
12505 l
= argvars
[0].vval
.v_list
;
12508 item
= l
->lv_first
;
12509 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
12513 /* Start at specified item. Use the cached index that list_find()
12514 * sets, so that a negative number also works. */
12515 item
= list_find(l
, get_tv_number_chk(&argvars
[2], &error
));
12517 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
12518 ic
= get_tv_number_chk(&argvars
[3], &error
);
12523 for ( ; item
!= NULL
; item
= item
->li_next
, ++idx
)
12524 if (tv_equal(&item
->li_tv
, &argvars
[1], ic
))
12526 rettv
->vval
.v_number
= idx
;
12532 static int inputsecret_flag
= 0;
12534 static void get_user_input
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int inputdialog
));
12537 * This function is used by f_input() and f_inputdialog() functions. The third
12538 * argument to f_input() specifies the type of completion to use at the
12539 * prompt. The third argument to f_inputdialog() specifies the value to return
12540 * when the user cancels the prompt.
12543 get_user_input(argvars
, rettv
, inputdialog
)
12548 char_u
*prompt
= get_tv_string_chk(&argvars
[0]);
12551 char_u buf
[NUMBUFLEN
];
12552 int cmd_silent_save
= cmd_silent
;
12553 char_u
*defstr
= (char_u
*)"";
12554 int xp_type
= EXPAND_NOTHING
;
12555 char_u
*xp_arg
= NULL
;
12557 rettv
->v_type
= VAR_STRING
;
12558 rettv
->vval
.v_string
= NULL
;
12560 #ifdef NO_CONSOLE_INPUT
12561 /* While starting up, there is no place to enter text. */
12562 if (no_console_input())
12566 cmd_silent
= FALSE
; /* Want to see the prompt. */
12567 if (prompt
!= NULL
)
12569 /* Only the part of the message after the last NL is considered as
12570 * prompt for the command line */
12571 p
= vim_strrchr(prompt
, '\n');
12581 msg_puts_attr(prompt
, echo_attr
);
12582 msg_didout
= FALSE
;
12586 cmdline_row
= msg_row
;
12588 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
12590 defstr
= get_tv_string_buf_chk(&argvars
[1], buf
);
12591 if (defstr
!= NULL
)
12592 stuffReadbuffSpec(defstr
);
12594 if (!inputdialog
&& argvars
[2].v_type
!= VAR_UNKNOWN
)
12600 rettv
->vval
.v_string
= NULL
;
12602 xp_name
= get_tv_string_buf_chk(&argvars
[2], buf
);
12603 if (xp_name
== NULL
)
12606 xp_namelen
= (int)STRLEN(xp_name
);
12608 if (parse_compl_arg(xp_name
, xp_namelen
, &xp_type
, &argt
,
12614 if (defstr
!= NULL
)
12615 rettv
->vval
.v_string
=
12616 getcmdline_prompt(inputsecret_flag
? NUL
: '@', p
, echo_attr
,
12621 /* since the user typed this, no need to wait for return */
12622 need_wait_return
= FALSE
;
12623 msg_didout
= FALSE
;
12625 cmd_silent
= cmd_silent_save
;
12629 * "input()" function
12630 * Also handles inputsecret() when inputsecret is set.
12633 f_input(argvars
, rettv
)
12637 get_user_input(argvars
, rettv
, FALSE
);
12641 * "inputdialog()" function
12644 f_inputdialog(argvars
, rettv
)
12648 #if defined(FEAT_GUI_TEXTDIALOG)
12649 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12650 if (gui
.in_use
&& vim_strchr(p_go
, GO_CONDIALOG
) == NULL
)
12653 char_u buf
[NUMBUFLEN
];
12654 char_u
*defstr
= (char_u
*)"";
12656 message
= get_tv_string_chk(&argvars
[0]);
12657 if (argvars
[1].v_type
!= VAR_UNKNOWN
12658 && (defstr
= get_tv_string_buf_chk(&argvars
[1], buf
)) != NULL
)
12659 vim_strncpy(IObuff
, defstr
, IOSIZE
- 1);
12662 if (message
!= NULL
&& defstr
!= NULL
12663 && do_dialog(VIM_QUESTION
, NULL
, message
,
12664 (char_u
*)_("&OK\n&Cancel"), 1, IObuff
) == 1)
12665 rettv
->vval
.v_string
= vim_strsave(IObuff
);
12668 if (message
!= NULL
&& defstr
!= NULL
12669 && argvars
[1].v_type
!= VAR_UNKNOWN
12670 && argvars
[2].v_type
!= VAR_UNKNOWN
)
12671 rettv
->vval
.v_string
= vim_strsave(
12672 get_tv_string_buf(&argvars
[2], buf
));
12674 rettv
->vval
.v_string
= NULL
;
12676 rettv
->v_type
= VAR_STRING
;
12680 get_user_input(argvars
, rettv
, TRUE
);
12684 * "inputlist()" function
12687 f_inputlist(argvars
, rettv
)
12695 #ifdef NO_CONSOLE_INPUT
12696 /* While starting up, there is no place to enter text. */
12697 if (no_console_input())
12700 if (argvars
[0].v_type
!= VAR_LIST
|| argvars
[0].vval
.v_list
== NULL
)
12702 EMSG2(_(e_listarg
), "inputlist()");
12707 msg_row
= Rows
- 1; /* for when 'cmdheight' > 1 */
12708 lines_left
= Rows
; /* avoid more prompt */
12712 for (li
= argvars
[0].vval
.v_list
->lv_first
; li
!= NULL
; li
= li
->li_next
)
12714 msg_puts(get_tv_string(&li
->li_tv
));
12718 /* Ask for choice. */
12719 selected
= prompt_for_number(&mouse_used
);
12721 selected
-= lines_left
;
12723 rettv
->vval
.v_number
= selected
;
12727 static garray_T ga_userinput
= {0, 0, sizeof(tasave_T
), 4, NULL
};
12730 * "inputrestore()" function
12733 f_inputrestore(argvars
, rettv
)
12734 typval_T
*argvars UNUSED
;
12737 if (ga_userinput
.ga_len
> 0)
12739 --ga_userinput
.ga_len
;
12740 restore_typeahead((tasave_T
*)(ga_userinput
.ga_data
)
12741 + ga_userinput
.ga_len
);
12742 /* default return is zero == OK */
12744 else if (p_verbose
> 1)
12746 verb_msg((char_u
*)_("called inputrestore() more often than inputsave()"));
12747 rettv
->vval
.v_number
= 1; /* Failed */
12752 * "inputsave()" function
12755 f_inputsave(argvars
, rettv
)
12756 typval_T
*argvars UNUSED
;
12759 /* Add an entry to the stack of typeahead storage. */
12760 if (ga_grow(&ga_userinput
, 1) == OK
)
12762 save_typeahead((tasave_T
*)(ga_userinput
.ga_data
)
12763 + ga_userinput
.ga_len
);
12764 ++ga_userinput
.ga_len
;
12765 /* default return is zero == OK */
12768 rettv
->vval
.v_number
= 1; /* Failed */
12772 * "inputsecret()" function
12775 f_inputsecret(argvars
, rettv
)
12780 ++inputsecret_flag
;
12781 f_input(argvars
, rettv
);
12783 --inputsecret_flag
;
12787 * "insert()" function
12790 f_insert(argvars
, rettv
)
12799 if (argvars
[0].v_type
!= VAR_LIST
)
12800 EMSG2(_(e_listarg
), "insert()");
12801 else if ((l
= argvars
[0].vval
.v_list
) != NULL
12802 && !tv_check_lock(l
->lv_lock
, (char_u
*)"insert()"))
12804 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
12805 before
= get_tv_number_chk(&argvars
[2], &error
);
12807 return; /* type error; errmsg already given */
12809 if (before
== l
->lv_len
)
12813 item
= list_find(l
, before
);
12816 EMSGN(_(e_listidx
), before
);
12822 list_insert_tv(l
, &argvars
[1], item
);
12823 copy_tv(&argvars
[0], rettv
);
12829 * "isdirectory()" function
12832 f_isdirectory(argvars
, rettv
)
12836 rettv
->vval
.v_number
= mch_isdir(get_tv_string(&argvars
[0]));
12840 * "islocked()" function
12843 f_islocked(argvars
, rettv
)
12851 rettv
->vval
.v_number
= -1;
12852 end
= get_lval(get_tv_string(&argvars
[0]), NULL
, &lv
, FALSE
, FALSE
, FALSE
,
12854 if (end
!= NULL
&& lv
.ll_name
!= NULL
)
12857 EMSG(_(e_trailing
));
12860 if (lv
.ll_tv
== NULL
)
12862 if (check_changedtick(lv
.ll_name
))
12863 rettv
->vval
.v_number
= 1; /* always locked */
12866 di
= find_var(lv
.ll_name
, NULL
);
12869 /* Consider a variable locked when:
12870 * 1. the variable itself is locked
12871 * 2. the value of the variable is locked.
12872 * 3. the List or Dict value is locked.
12874 rettv
->vval
.v_number
= ((di
->di_flags
& DI_FLAGS_LOCK
)
12875 || tv_islocked(&di
->di_tv
));
12879 else if (lv
.ll_range
)
12880 EMSG(_("E786: Range not allowed"));
12881 else if (lv
.ll_newkey
!= NULL
)
12882 EMSG2(_(e_dictkey
), lv
.ll_newkey
);
12883 else if (lv
.ll_list
!= NULL
)
12885 rettv
->vval
.v_number
= tv_islocked(&lv
.ll_li
->li_tv
);
12887 /* Dictionary item. */
12888 rettv
->vval
.v_number
= tv_islocked(&lv
.ll_di
->di_tv
);
12895 static void dict_list
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int what
));
12898 * Turn a dict into a list:
12899 * "what" == 0: list of keys
12900 * "what" == 1: list of values
12901 * "what" == 2: list of items
12904 dict_list(argvars
, rettv
, what
)
12917 if (argvars
[0].v_type
!= VAR_DICT
)
12919 EMSG(_(e_dictreq
));
12922 if ((d
= argvars
[0].vval
.v_dict
) == NULL
)
12925 if (rettv_list_alloc(rettv
) == FAIL
)
12928 todo
= (int)d
->dv_hashtab
.ht_used
;
12929 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
12931 if (!HASHITEM_EMPTY(hi
))
12936 li
= listitem_alloc();
12939 list_append(rettv
->vval
.v_list
, li
);
12944 li
->li_tv
.v_type
= VAR_STRING
;
12945 li
->li_tv
.v_lock
= 0;
12946 li
->li_tv
.vval
.v_string
= vim_strsave(di
->di_key
);
12948 else if (what
== 1)
12951 copy_tv(&di
->di_tv
, &li
->li_tv
);
12957 li
->li_tv
.v_type
= VAR_LIST
;
12958 li
->li_tv
.v_lock
= 0;
12959 li
->li_tv
.vval
.v_list
= l2
;
12964 li2
= listitem_alloc();
12967 list_append(l2
, li2
);
12968 li2
->li_tv
.v_type
= VAR_STRING
;
12969 li2
->li_tv
.v_lock
= 0;
12970 li2
->li_tv
.vval
.v_string
= vim_strsave(di
->di_key
);
12972 li2
= listitem_alloc();
12975 list_append(l2
, li2
);
12976 copy_tv(&di
->di_tv
, &li2
->li_tv
);
12983 * "items(dict)" function
12986 f_items(argvars
, rettv
)
12990 dict_list(argvars
, rettv
, 2);
12994 * "join()" function
12997 f_join(argvars
, rettv
)
13004 if (argvars
[0].v_type
!= VAR_LIST
)
13006 EMSG(_(e_listreq
));
13009 if (argvars
[0].vval
.v_list
== NULL
)
13011 if (argvars
[1].v_type
== VAR_UNKNOWN
)
13012 sep
= (char_u
*)" ";
13014 sep
= get_tv_string_chk(&argvars
[1]);
13016 rettv
->v_type
= VAR_STRING
;
13020 ga_init2(&ga
, (int)sizeof(char), 80);
13021 list_join(&ga
, argvars
[0].vval
.v_list
, sep
, TRUE
, 0);
13022 ga_append(&ga
, NUL
);
13023 rettv
->vval
.v_string
= (char_u
*)ga
.ga_data
;
13026 rettv
->vval
.v_string
= NULL
;
13030 * "keys()" function
13033 f_keys(argvars
, rettv
)
13037 dict_list(argvars
, rettv
, 0);
13041 * "last_buffer_nr()" function.
13044 f_last_buffer_nr(argvars
, rettv
)
13045 typval_T
*argvars UNUSED
;
13051 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
13052 if (n
< buf
->b_fnum
)
13055 rettv
->vval
.v_number
= n
;
13062 f_len(argvars
, rettv
)
13066 switch (argvars
[0].v_type
)
13070 rettv
->vval
.v_number
= (varnumber_T
)STRLEN(
13071 get_tv_string(&argvars
[0]));
13074 rettv
->vval
.v_number
= list_len(argvars
[0].vval
.v_list
);
13077 rettv
->vval
.v_number
= dict_len(argvars
[0].vval
.v_dict
);
13080 EMSG(_("E701: Invalid type for len()"));
13085 static void libcall_common
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int type
));
13088 libcall_common(argvars
, rettv
, type
)
13093 #ifdef FEAT_LIBCALL
13095 char_u
**string_result
;
13099 rettv
->v_type
= type
;
13100 if (type
!= VAR_NUMBER
)
13101 rettv
->vval
.v_string
= NULL
;
13103 if (check_restricted() || check_secure())
13106 #ifdef FEAT_LIBCALL
13107 /* The first two args must be strings, otherwise its meaningless */
13108 if (argvars
[0].v_type
== VAR_STRING
&& argvars
[1].v_type
== VAR_STRING
)
13111 if (argvars
[2].v_type
== VAR_STRING
)
13112 string_in
= argvars
[2].vval
.v_string
;
13113 if (type
== VAR_NUMBER
)
13114 string_result
= NULL
;
13116 string_result
= &rettv
->vval
.v_string
;
13117 if (mch_libcall(argvars
[0].vval
.v_string
,
13118 argvars
[1].vval
.v_string
,
13120 argvars
[2].vval
.v_number
,
13123 && type
== VAR_NUMBER
)
13124 rettv
->vval
.v_number
= nr_result
;
13130 * "libcall()" function
13133 f_libcall(argvars
, rettv
)
13137 libcall_common(argvars
, rettv
, VAR_STRING
);
13141 * "libcallnr()" function
13144 f_libcallnr(argvars
, rettv
)
13148 libcall_common(argvars
, rettv
, VAR_NUMBER
);
13152 * "line(string)" function
13155 f_line(argvars
, rettv
)
13163 fp
= var2fpos(&argvars
[0], TRUE
, &fnum
);
13166 rettv
->vval
.v_number
= lnum
;
13170 * "line2byte(lnum)" function
13173 f_line2byte(argvars
, rettv
)
13174 typval_T
*argvars UNUSED
;
13177 #ifndef FEAT_BYTEOFF
13178 rettv
->vval
.v_number
= -1;
13182 lnum
= get_tv_lnum(argvars
);
13183 if (lnum
< 1 || lnum
> curbuf
->b_ml
.ml_line_count
+ 1)
13184 rettv
->vval
.v_number
= -1;
13186 rettv
->vval
.v_number
= ml_find_line_or_offset(curbuf
, lnum
, NULL
);
13187 if (rettv
->vval
.v_number
>= 0)
13188 ++rettv
->vval
.v_number
;
13193 * "lispindent(lnum)" function
13196 f_lispindent(argvars
, rettv
)
13204 pos
= curwin
->w_cursor
;
13205 lnum
= get_tv_lnum(argvars
);
13206 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
)
13208 curwin
->w_cursor
.lnum
= lnum
;
13209 rettv
->vval
.v_number
= get_lisp_indent();
13210 curwin
->w_cursor
= pos
;
13214 rettv
->vval
.v_number
= -1;
13218 * "localtime()" function
13221 f_localtime(argvars
, rettv
)
13222 typval_T
*argvars UNUSED
;
13225 rettv
->vval
.v_number
= (varnumber_T
)time(NULL
);
13228 static void get_maparg
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int exact
));
13231 get_maparg(argvars
, rettv
, exact
)
13238 char_u buf
[NUMBUFLEN
];
13239 char_u
*keys_buf
= NULL
;
13245 /* return empty string for failure */
13246 rettv
->v_type
= VAR_STRING
;
13247 rettv
->vval
.v_string
= NULL
;
13249 keys
= get_tv_string(&argvars
[0]);
13253 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
13255 which
= get_tv_string_buf_chk(&argvars
[1], buf
);
13256 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
13257 abbr
= get_tv_number(&argvars
[2]);
13260 which
= (char_u
*)"";
13264 mode
= get_map_mode(&which
, 0);
13266 keys
= replace_termcodes(keys
, &keys_buf
, TRUE
, TRUE
, FALSE
);
13267 rhs
= check_map(keys
, mode
, exact
, FALSE
, abbr
);
13268 vim_free(keys_buf
);
13272 ga
.ga_itemsize
= 1;
13273 ga
.ga_growsize
= 40;
13275 while (*rhs
!= NUL
)
13276 ga_concat(&ga
, str2special(&rhs
, FALSE
));
13278 ga_append(&ga
, NUL
);
13279 rettv
->vval
.v_string
= (char_u
*)ga
.ga_data
;
13285 * "log10()" function
13288 f_log10(argvars
, rettv
)
13294 rettv
->v_type
= VAR_FLOAT
;
13295 if (get_float_arg(argvars
, &f
) == OK
)
13296 rettv
->vval
.v_float
= log10(f
);
13298 rettv
->vval
.v_float
= 0.0;
13306 f_map(argvars
, rettv
)
13310 filter_map(argvars
, rettv
, TRUE
);
13314 * "maparg()" function
13317 f_maparg(argvars
, rettv
)
13321 get_maparg(argvars
, rettv
, TRUE
);
13325 * "mapcheck()" function
13328 f_mapcheck(argvars
, rettv
)
13332 get_maparg(argvars
, rettv
, FALSE
);
13335 static void find_some_match
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int start
));
13338 find_some_match(argvars
, rettv
, type
)
13343 char_u
*str
= NULL
;
13344 char_u
*expr
= NULL
;
13346 regmatch_T regmatch
;
13347 char_u patbuf
[NUMBUFLEN
];
13348 char_u strbuf
[NUMBUFLEN
];
13352 colnr_T startcol
= 0;
13355 listitem_T
*li
= NULL
;
13357 char_u
*tofree
= NULL
;
13359 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
13361 p_cpo
= (char_u
*)"";
13363 rettv
->vval
.v_number
= -1;
13366 /* return empty list when there are no matches */
13367 if (rettv_list_alloc(rettv
) == FAIL
)
13370 else if (type
== 2)
13372 rettv
->v_type
= VAR_STRING
;
13373 rettv
->vval
.v_string
= NULL
;
13376 if (argvars
[0].v_type
== VAR_LIST
)
13378 if ((l
= argvars
[0].vval
.v_list
) == NULL
)
13383 expr
= str
= get_tv_string(&argvars
[0]);
13385 pat
= get_tv_string_buf_chk(&argvars
[1], patbuf
);
13389 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
13393 start
= get_tv_number_chk(&argvars
[2], &error
);
13398 li
= list_find(l
, start
);
13401 idx
= l
->lv_idx
; /* use the cached index */
13407 if (start
> (long)STRLEN(str
))
13409 /* When "count" argument is there ignore matches before "start",
13410 * otherwise skip part of the string. Differs when pattern is "^"
13412 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
13418 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
13419 nth
= get_tv_number_chk(&argvars
[3], &error
);
13424 regmatch
.regprog
= vim_regcomp(pat
, RE_MAGIC
+ RE_STRING
);
13425 if (regmatch
.regprog
!= NULL
)
13427 regmatch
.rm_ic
= p_ic
;
13439 str
= echo_string(&li
->li_tv
, &tofree
, strbuf
, 0);
13444 match
= vim_regexec_nl(®match
, str
, (colnr_T
)startcol
);
13446 if (match
&& --nth
<= 0)
13448 if (l
== NULL
&& !match
)
13451 /* Advance to just after the match. */
13460 startcol
= (colnr_T
)(regmatch
.startp
[0]
13461 + (*mb_ptr2len
)(regmatch
.startp
[0]) - str
);
13463 startcol
= regmatch
.startp
[0] + 1 - str
;
13474 /* return list with matched string and submatches */
13475 for (i
= 0; i
< NSUBEXP
; ++i
)
13477 if (regmatch
.endp
[i
] == NULL
)
13479 if (list_append_string(rettv
->vval
.v_list
,
13480 (char_u
*)"", 0) == FAIL
)
13483 else if (list_append_string(rettv
->vval
.v_list
,
13484 regmatch
.startp
[i
],
13485 (int)(regmatch
.endp
[i
] - regmatch
.startp
[i
]))
13490 else if (type
== 2)
13492 /* return matched string */
13494 copy_tv(&li
->li_tv
, rettv
);
13496 rettv
->vval
.v_string
= vim_strnsave(regmatch
.startp
[0],
13497 (int)(regmatch
.endp
[0] - regmatch
.startp
[0]));
13499 else if (l
!= NULL
)
13500 rettv
->vval
.v_number
= idx
;
13504 rettv
->vval
.v_number
=
13505 (varnumber_T
)(regmatch
.startp
[0] - str
);
13507 rettv
->vval
.v_number
=
13508 (varnumber_T
)(regmatch
.endp
[0] - str
);
13509 rettv
->vval
.v_number
+= (varnumber_T
)(str
- expr
);
13512 vim_free(regmatch
.regprog
);
13521 * "match()" function
13524 f_match(argvars
, rettv
)
13528 find_some_match(argvars
, rettv
, 1);
13532 * "matchadd()" function
13535 f_matchadd(argvars
, rettv
)
13539 #ifdef FEAT_SEARCH_EXTRA
13540 char_u buf
[NUMBUFLEN
];
13541 char_u
*grp
= get_tv_string_buf_chk(&argvars
[0], buf
); /* group */
13542 char_u
*pat
= get_tv_string_buf_chk(&argvars
[1], buf
); /* pattern */
13543 int prio
= 10; /* default priority */
13547 rettv
->vval
.v_number
= -1;
13549 if (grp
== NULL
|| pat
== NULL
)
13551 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
13553 prio
= get_tv_number_chk(&argvars
[2], &error
);
13554 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
13555 id
= get_tv_number_chk(&argvars
[3], &error
);
13559 if (id
>= 1 && id
<= 3)
13561 EMSGN("E798: ID is reserved for \":match\": %ld", id
);
13565 rettv
->vval
.v_number
= match_add(curwin
, grp
, pat
, prio
, id
);
13570 * "matcharg()" function
13573 f_matcharg(argvars
, rettv
)
13577 if (rettv_list_alloc(rettv
) == OK
)
13579 #ifdef FEAT_SEARCH_EXTRA
13580 int id
= get_tv_number(&argvars
[0]);
13583 if (id
>= 1 && id
<= 3)
13585 if ((m
= (matchitem_T
*)get_match(curwin
, id
)) != NULL
)
13587 list_append_string(rettv
->vval
.v_list
,
13588 syn_id2name(m
->hlg_id
), -1);
13589 list_append_string(rettv
->vval
.v_list
, m
->pattern
, -1);
13593 list_append_string(rettv
->vval
.v_list
, NUL
, -1);
13594 list_append_string(rettv
->vval
.v_list
, NUL
, -1);
13602 * "matchdelete()" function
13605 f_matchdelete(argvars
, rettv
)
13609 #ifdef FEAT_SEARCH_EXTRA
13610 rettv
->vval
.v_number
= match_delete(curwin
,
13611 (int)get_tv_number(&argvars
[0]), TRUE
);
13616 * "matchend()" function
13619 f_matchend(argvars
, rettv
)
13623 find_some_match(argvars
, rettv
, 0);
13627 * "matchlist()" function
13630 f_matchlist(argvars
, rettv
)
13634 find_some_match(argvars
, rettv
, 3);
13638 * "matchstr()" function
13641 f_matchstr(argvars
, rettv
)
13645 find_some_match(argvars
, rettv
, 2);
13648 static void max_min
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int domax
));
13651 max_min(argvars
, rettv
, domax
)
13660 if (argvars
[0].v_type
== VAR_LIST
)
13665 l
= argvars
[0].vval
.v_list
;
13671 n
= get_tv_number_chk(&li
->li_tv
, &error
);
13677 i
= get_tv_number_chk(&li
->li_tv
, &error
);
13678 if (domax
? i
> n
: i
< n
)
13684 else if (argvars
[0].v_type
== VAR_DICT
)
13691 d
= argvars
[0].vval
.v_dict
;
13694 todo
= (int)d
->dv_hashtab
.ht_used
;
13695 for (hi
= d
->dv_hashtab
.ht_array
; todo
> 0; ++hi
)
13697 if (!HASHITEM_EMPTY(hi
))
13700 i
= get_tv_number_chk(&HI2DI(hi
)->di_tv
, &error
);
13706 else if (domax
? i
> n
: i
< n
)
13713 EMSG(_(e_listdictarg
));
13714 rettv
->vval
.v_number
= error
? 0 : n
;
13721 f_max(argvars
, rettv
)
13725 max_min(argvars
, rettv
, TRUE
);
13732 f_min(argvars
, rettv
)
13736 max_min(argvars
, rettv
, FALSE
);
13739 static int mkdir_recurse
__ARGS((char_u
*dir
, int prot
));
13742 * Create the directory in which "dir" is located, and higher levels when
13746 mkdir_recurse(dir
, prot
)
13754 /* Get end of directory name in "dir".
13755 * We're done when it's "/" or "c:/". */
13756 p
= gettail_sep(dir
);
13757 if (p
<= get_past_head(dir
))
13760 /* If the directory exists we're done. Otherwise: create it.*/
13761 updir
= vim_strnsave(dir
, (int)(p
- dir
));
13764 if (mch_isdir(updir
))
13766 else if (mkdir_recurse(updir
, prot
) == OK
)
13767 r
= vim_mkdir_emsg(updir
, prot
);
13774 * "mkdir()" function
13777 f_mkdir(argvars
, rettv
)
13782 char_u buf
[NUMBUFLEN
];
13785 rettv
->vval
.v_number
= FAIL
;
13786 if (check_restricted() || check_secure())
13789 dir
= get_tv_string_buf(&argvars
[0], buf
);
13790 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
13792 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
13793 prot
= get_tv_number_chk(&argvars
[2], NULL
);
13794 if (prot
!= -1 && STRCMP(get_tv_string(&argvars
[1]), "p") == 0)
13795 mkdir_recurse(dir
, prot
);
13797 rettv
->vval
.v_number
= prot
!= -1 ? vim_mkdir_emsg(dir
, prot
) : 0;
13802 * "mode()" function
13805 f_mode(argvars
, rettv
)
13818 buf
[0] = VIsual_mode
+ 's' - 'v';
13820 buf
[0] = VIsual_mode
;
13824 if (State
== HITRETURN
|| State
== ASKMORE
|| State
== SETWSIZE
13825 || State
== CONFIRM
)
13828 if (State
== ASKMORE
)
13830 else if (State
== CONFIRM
)
13833 else if (State
== EXTERNCMD
)
13835 else if (State
& INSERT
)
13837 #ifdef FEAT_VREPLACE
13838 if (State
& VREPLACE_FLAG
)
13845 if (State
& REPLACE_FLAG
)
13850 else if (State
& CMDLINE
)
13856 else if (exmode_active
)
13868 /* Clear out the minor mode when the argument is not a non-zero number or
13869 * non-empty string. */
13870 if (!non_zero_arg(&argvars
[0]))
13873 rettv
->vval
.v_string
= vim_strsave(buf
);
13874 rettv
->v_type
= VAR_STRING
;
13877 #ifdef FEAT_MZSCHEME
13879 * "mzeval()" function
13882 f_mzeval(argvars
, rettv
)
13887 char_u buf
[NUMBUFLEN
];
13889 str
= get_tv_string_buf(&argvars
[0], buf
);
13890 do_mzeval(str
, rettv
);
13895 * "nextnonblank()" function
13898 f_nextnonblank(argvars
, rettv
)
13904 for (lnum
= get_tv_lnum(argvars
); ; ++lnum
)
13906 if (lnum
< 0 || lnum
> curbuf
->b_ml
.ml_line_count
)
13911 if (*skipwhite(ml_get(lnum
)) != NUL
)
13914 rettv
->vval
.v_number
= lnum
;
13918 * "nr2char()" function
13921 f_nr2char(argvars
, rettv
)
13925 char_u buf
[NUMBUFLEN
];
13929 buf
[(*mb_char2bytes
)((int)get_tv_number(&argvars
[0]), buf
)] = NUL
;
13933 buf
[0] = (char_u
)get_tv_number(&argvars
[0]);
13936 rettv
->v_type
= VAR_STRING
;
13937 rettv
->vval
.v_string
= vim_strsave(buf
);
13941 * "pathshorten()" function
13944 f_pathshorten(argvars
, rettv
)
13950 rettv
->v_type
= VAR_STRING
;
13951 p
= get_tv_string_chk(&argvars
[0]);
13953 rettv
->vval
.v_string
= NULL
;
13956 p
= vim_strsave(p
);
13957 rettv
->vval
.v_string
= p
;
13968 f_pow(argvars
, rettv
)
13974 rettv
->v_type
= VAR_FLOAT
;
13975 if (get_float_arg(argvars
, &fx
) == OK
13976 && get_float_arg(&argvars
[1], &fy
) == OK
)
13977 rettv
->vval
.v_float
= pow(fx
, fy
);
13979 rettv
->vval
.v_float
= 0.0;
13984 * "prevnonblank()" function
13987 f_prevnonblank(argvars
, rettv
)
13993 lnum
= get_tv_lnum(argvars
);
13994 if (lnum
< 1 || lnum
> curbuf
->b_ml
.ml_line_count
)
13997 while (lnum
>= 1 && *skipwhite(ml_get(lnum
)) == NUL
)
13999 rettv
->vval
.v_number
= lnum
;
14002 #ifdef HAVE_STDARG_H
14003 /* This dummy va_list is here because:
14004 * - passing a NULL pointer doesn't work when va_list isn't a pointer
14005 * - locally in the function results in a "used before set" warning
14006 * - using va_start() to initialize it gives "function with fixed args" error */
14011 * "printf()" function
14014 f_printf(argvars
, rettv
)
14018 rettv
->v_type
= VAR_STRING
;
14019 rettv
->vval
.v_string
= NULL
;
14020 #ifdef HAVE_STDARG_H /* only very old compilers can't do this */
14022 char_u buf
[NUMBUFLEN
];
14025 int saved_did_emsg
= did_emsg
;
14028 /* Get the required length, allocate the buffer and do it for real. */
14030 fmt
= (char *)get_tv_string_buf(&argvars
[0], buf
);
14031 len
= vim_vsnprintf(NULL
, 0, fmt
, ap
, argvars
+ 1);
14034 s
= alloc(len
+ 1);
14037 rettv
->vval
.v_string
= s
;
14038 (void)vim_vsnprintf((char *)s
, len
+ 1, fmt
, ap
, argvars
+ 1);
14041 did_emsg
|= saved_did_emsg
;
14047 * "pumvisible()" function
14050 f_pumvisible(argvars
, rettv
)
14051 typval_T
*argvars UNUSED
;
14052 typval_T
*rettv UNUSED
;
14054 #ifdef FEAT_INS_EXPAND
14056 rettv
->vval
.v_number
= 1;
14061 * "range()" function
14064 f_range(argvars
, rettv
)
14074 start
= get_tv_number_chk(&argvars
[0], &error
);
14075 if (argvars
[1].v_type
== VAR_UNKNOWN
)
14082 end
= get_tv_number_chk(&argvars
[1], &error
);
14083 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
14084 stride
= get_tv_number_chk(&argvars
[2], &error
);
14088 return; /* type error; errmsg already given */
14090 EMSG(_("E726: Stride is zero"));
14091 else if (stride
> 0 ? end
+ 1 < start
: end
- 1 > start
)
14092 EMSG(_("E727: Start past end"));
14095 if (rettv_list_alloc(rettv
) == OK
)
14096 for (i
= start
; stride
> 0 ? i
<= end
: i
>= end
; i
+= stride
)
14097 if (list_append_number(rettv
->vval
.v_list
,
14098 (varnumber_T
)i
) == FAIL
)
14104 * "readfile()" function
14107 f_readfile(argvars
, rettv
)
14111 int binary
= FALSE
;
14115 #define FREAD_SIZE 200 /* optimized for text lines */
14116 char_u buf
[FREAD_SIZE
];
14117 int readlen
; /* size of last fread() */
14118 int buflen
; /* nr of valid chars in buf[] */
14119 int filtd
; /* how much in buf[] was NUL -> '\n' filtered */
14120 int tolist
; /* first byte in buf[] still to be put in list */
14121 int chop
; /* how many CR to chop off */
14122 char_u
*prev
= NULL
; /* previously read bytes, if any */
14123 int prevlen
= 0; /* length of "prev" if not NULL */
14126 long maxline
= MAXLNUM
;
14129 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
14131 if (STRCMP(get_tv_string(&argvars
[1]), "b") == 0)
14133 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
14134 maxline
= get_tv_number(&argvars
[2]);
14137 if (rettv_list_alloc(rettv
) == FAIL
)
14140 /* Always open the file in binary mode, library functions have a mind of
14141 * their own about CR-LF conversion. */
14142 fname
= get_tv_string(&argvars
[0]);
14143 if (*fname
== NUL
|| (fd
= mch_fopen((char *)fname
, READBIN
)) == NULL
)
14145 EMSG2(_(e_notopen
), *fname
== NUL
? (char_u
*)_("<empty>") : fname
);
14150 while (cnt
< maxline
|| maxline
< 0)
14152 readlen
= (int)fread(buf
+ filtd
, 1, FREAD_SIZE
- filtd
, fd
);
14153 buflen
= filtd
+ readlen
;
14155 for ( ; filtd
< buflen
|| readlen
<= 0; ++filtd
)
14157 if (buf
[filtd
] == '\n' || readlen
<= 0)
14159 /* Only when in binary mode add an empty list item when the
14160 * last line ends in a '\n'. */
14161 if (!binary
&& readlen
== 0 && filtd
== 0)
14164 /* Found end-of-line or end-of-file: add a text line to the
14168 while (filtd
- chop
- 1 >= tolist
14169 && buf
[filtd
- chop
- 1] == '\r')
14171 len
= filtd
- tolist
- chop
;
14173 s
= vim_strnsave(buf
+ tolist
, len
);
14176 s
= alloc((unsigned)(prevlen
+ len
+ 1));
14179 mch_memmove(s
, prev
, prevlen
);
14182 mch_memmove(s
+ prevlen
, buf
+ tolist
, len
);
14183 s
[prevlen
+ len
] = NUL
;
14186 tolist
= filtd
+ 1;
14188 li
= listitem_alloc();
14194 li
->li_tv
.v_type
= VAR_STRING
;
14195 li
->li_tv
.v_lock
= 0;
14196 li
->li_tv
.vval
.v_string
= s
;
14197 list_append(rettv
->vval
.v_list
, li
);
14199 if (++cnt
>= maxline
&& maxline
>= 0)
14204 else if (buf
[filtd
] == NUL
)
14212 /* "buf" is full, need to move text to an allocated buffer */
14215 prev
= vim_strnsave(buf
, buflen
);
14220 s
= alloc((unsigned)(prevlen
+ buflen
));
14223 mch_memmove(s
, prev
, prevlen
);
14224 mch_memmove(s
+ prevlen
, buf
, buflen
);
14234 mch_memmove(buf
, buf
+ tolist
, buflen
- tolist
);
14240 * For a negative line count use only the lines at the end of the file,
14244 while (cnt
> -maxline
)
14246 listitem_remove(rettv
->vval
.v_list
, rettv
->vval
.v_list
->lv_first
);
14254 #if defined(FEAT_RELTIME)
14255 static int list2proftime
__ARGS((typval_T
*arg
, proftime_T
*tm
));
14258 * Convert a List to proftime_T.
14259 * Return FAIL when there is something wrong.
14262 list2proftime(arg
, tm
)
14269 if (arg
->v_type
!= VAR_LIST
|| arg
->vval
.v_list
== NULL
14270 || arg
->vval
.v_list
->lv_len
!= 2)
14272 n1
= list_find_nr(arg
->vval
.v_list
, 0L, &error
);
14273 n2
= list_find_nr(arg
->vval
.v_list
, 1L, &error
);
14281 return error
? FAIL
: OK
;
14283 #endif /* FEAT_RELTIME */
14286 * "reltime()" function
14289 f_reltime(argvars
, rettv
)
14293 #ifdef FEAT_RELTIME
14297 if (argvars
[0].v_type
== VAR_UNKNOWN
)
14299 /* No arguments: get current time. */
14300 profile_start(&res
);
14302 else if (argvars
[1].v_type
== VAR_UNKNOWN
)
14304 if (list2proftime(&argvars
[0], &res
) == FAIL
)
14310 /* Two arguments: compute the difference. */
14311 if (list2proftime(&argvars
[0], &start
) == FAIL
14312 || list2proftime(&argvars
[1], &res
) == FAIL
)
14314 profile_sub(&res
, &start
);
14317 if (rettv_list_alloc(rettv
) == OK
)
14328 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)n1
);
14329 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)n2
);
14335 * "reltimestr()" function
14338 f_reltimestr(argvars
, rettv
)
14342 #ifdef FEAT_RELTIME
14346 rettv
->v_type
= VAR_STRING
;
14347 rettv
->vval
.v_string
= NULL
;
14348 #ifdef FEAT_RELTIME
14349 if (list2proftime(&argvars
[0], &tm
) == OK
)
14350 rettv
->vval
.v_string
= vim_strsave((char_u
*)profile_msg(&tm
));
14354 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
14355 static void make_connection
__ARGS((void));
14356 static int check_connection
__ARGS((void));
14361 if (X_DISPLAY
== NULL
14367 x_force_connect
= TRUE
;
14369 x_force_connect
= FALSE
;
14377 if (X_DISPLAY
== NULL
)
14379 EMSG(_("E240: No connection to Vim server"));
14386 #ifdef FEAT_CLIENTSERVER
14387 static void remote_common
__ARGS((typval_T
*argvars
, typval_T
*rettv
, int expr
));
14390 remote_common(argvars
, rettv
, expr
)
14395 char_u
*server_name
;
14398 char_u buf
[NUMBUFLEN
];
14405 if (check_restricted() || check_secure())
14409 if (check_connection() == FAIL
)
14413 server_name
= get_tv_string_chk(&argvars
[0]);
14414 if (server_name
== NULL
)
14415 return; /* type error; errmsg already given */
14416 keys
= get_tv_string_buf(&argvars
[1], buf
);
14418 if (serverSendToVim(server_name
, keys
, &r
, &w
, expr
, TRUE
) < 0)
14420 if (serverSendToVim(X_DISPLAY
, server_name
, keys
, &r
, &w
, expr
, 0, TRUE
)
14425 EMSG(r
); /* sending worked but evaluation failed */
14427 EMSG2(_("E241: Unable to send to %s"), server_name
);
14431 rettv
->vval
.v_string
= r
;
14433 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
14439 sprintf((char *)str
, PRINTF_HEX_LONG_U
, (long_u
)w
);
14440 v
.di_tv
.v_type
= VAR_STRING
;
14441 v
.di_tv
.vval
.v_string
= vim_strsave(str
);
14442 idvar
= get_tv_string_chk(&argvars
[2]);
14444 set_var(idvar
, &v
.di_tv
, FALSE
);
14445 vim_free(v
.di_tv
.vval
.v_string
);
14451 * "remote_expr()" function
14454 f_remote_expr(argvars
, rettv
)
14455 typval_T
*argvars UNUSED
;
14458 rettv
->v_type
= VAR_STRING
;
14459 rettv
->vval
.v_string
= NULL
;
14460 #ifdef FEAT_CLIENTSERVER
14461 remote_common(argvars
, rettv
, TRUE
);
14466 * "remote_foreground()" function
14469 f_remote_foreground(argvars
, rettv
)
14470 typval_T
*argvars UNUSED
;
14471 typval_T
*rettv UNUSED
;
14473 #ifdef FEAT_CLIENTSERVER
14475 /* On Win32 it's done in this application. */
14477 char_u
*server_name
= get_tv_string_chk(&argvars
[0]);
14479 if (server_name
!= NULL
)
14480 serverForeground(server_name
);
14483 /* Send a foreground() expression to the server. */
14484 argvars
[1].v_type
= VAR_STRING
;
14485 argvars
[1].vval
.v_string
= vim_strsave((char_u
*)"foreground()");
14486 argvars
[2].v_type
= VAR_UNKNOWN
;
14487 remote_common(argvars
, rettv
, TRUE
);
14488 vim_free(argvars
[1].vval
.v_string
);
14494 f_remote_peek(argvars
, rettv
)
14495 typval_T
*argvars UNUSED
;
14498 #ifdef FEAT_CLIENTSERVER
14506 if (check_restricted() || check_secure())
14508 rettv
->vval
.v_number
= -1;
14511 serverid
= get_tv_string_chk(&argvars
[0]);
14512 if (serverid
== NULL
)
14514 rettv
->vval
.v_number
= -1;
14515 return; /* type error; errmsg already given */
14518 sscanf(serverid
, SCANF_HEX_LONG_U
, &n
);
14520 rettv
->vval
.v_number
= -1;
14523 s
= serverGetReply((HWND
)n
, FALSE
, FALSE
, FALSE
);
14524 rettv
->vval
.v_number
= (s
!= NULL
);
14527 if (check_connection() == FAIL
)
14530 rettv
->vval
.v_number
= serverPeekReply(X_DISPLAY
,
14531 serverStrToWin(serverid
), &s
);
14534 if (argvars
[1].v_type
!= VAR_UNKNOWN
&& rettv
->vval
.v_number
> 0)
14538 v
.di_tv
.v_type
= VAR_STRING
;
14539 v
.di_tv
.vval
.v_string
= vim_strsave(s
);
14540 retvar
= get_tv_string_chk(&argvars
[1]);
14541 if (retvar
!= NULL
)
14542 set_var(retvar
, &v
.di_tv
, FALSE
);
14543 vim_free(v
.di_tv
.vval
.v_string
);
14546 rettv
->vval
.v_number
= -1;
14551 f_remote_read(argvars
, rettv
)
14552 typval_T
*argvars UNUSED
;
14557 #ifdef FEAT_CLIENTSERVER
14558 char_u
*serverid
= get_tv_string_chk(&argvars
[0]);
14560 if (serverid
!= NULL
&& !check_restricted() && !check_secure())
14563 /* The server's HWND is encoded in the 'id' parameter */
14566 sscanf(serverid
, SCANF_HEX_LONG_U
, &n
);
14568 r
= serverGetReply((HWND
)n
, FALSE
, TRUE
, TRUE
);
14571 if (check_connection() == FAIL
|| serverReadReply(X_DISPLAY
,
14572 serverStrToWin(serverid
), &r
, FALSE
) < 0)
14574 EMSG(_("E277: Unable to read a server reply"));
14577 rettv
->v_type
= VAR_STRING
;
14578 rettv
->vval
.v_string
= r
;
14582 * "remote_send()" function
14585 f_remote_send(argvars
, rettv
)
14586 typval_T
*argvars UNUSED
;
14589 rettv
->v_type
= VAR_STRING
;
14590 rettv
->vval
.v_string
= NULL
;
14591 #ifdef FEAT_CLIENTSERVER
14592 remote_common(argvars
, rettv
, FALSE
);
14597 * "remove()" function
14600 f_remove(argvars
, rettv
)
14605 listitem_T
*item
, *item2
;
14613 if (argvars
[0].v_type
== VAR_DICT
)
14615 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
14616 EMSG2(_(e_toomanyarg
), "remove()");
14617 else if ((d
= argvars
[0].vval
.v_dict
) != NULL
14618 && !tv_check_lock(d
->dv_lock
, (char_u
*)"remove() argument"))
14620 key
= get_tv_string_chk(&argvars
[1]);
14623 di
= dict_find(d
, key
, -1);
14625 EMSG2(_(e_dictkey
), key
);
14628 *rettv
= di
->di_tv
;
14629 init_tv(&di
->di_tv
);
14630 dictitem_remove(d
, di
);
14635 else if (argvars
[0].v_type
!= VAR_LIST
)
14636 EMSG2(_(e_listdictarg
), "remove()");
14637 else if ((l
= argvars
[0].vval
.v_list
) != NULL
14638 && !tv_check_lock(l
->lv_lock
, (char_u
*)"remove() argument"))
14642 idx
= get_tv_number_chk(&argvars
[1], &error
);
14644 ; /* type error: do nothing, errmsg already given */
14645 else if ((item
= list_find(l
, idx
)) == NULL
)
14646 EMSGN(_(e_listidx
), idx
);
14649 if (argvars
[2].v_type
== VAR_UNKNOWN
)
14651 /* Remove one item, return its value. */
14652 list_remove(l
, item
, item
);
14653 *rettv
= item
->li_tv
;
14658 /* Remove range of items, return list with values. */
14659 end
= get_tv_number_chk(&argvars
[2], &error
);
14661 ; /* type error: do nothing */
14662 else if ((item2
= list_find(l
, end
)) == NULL
)
14663 EMSGN(_(e_listidx
), end
);
14668 for (li
= item
; li
!= NULL
; li
= li
->li_next
)
14674 if (li
== NULL
) /* didn't find "item2" after "item" */
14675 EMSG(_(e_invrange
));
14678 list_remove(l
, item
, item2
);
14679 if (rettv_list_alloc(rettv
) == OK
)
14681 l
= rettv
->vval
.v_list
;
14682 l
->lv_first
= item
;
14683 l
->lv_last
= item2
;
14684 item
->li_prev
= NULL
;
14685 item2
->li_next
= NULL
;
14696 * "rename({from}, {to})" function
14699 f_rename(argvars
, rettv
)
14703 char_u buf
[NUMBUFLEN
];
14705 if (check_restricted() || check_secure())
14706 rettv
->vval
.v_number
= -1;
14708 rettv
->vval
.v_number
= vim_rename(get_tv_string(&argvars
[0]),
14709 get_tv_string_buf(&argvars
[1], buf
));
14713 * "repeat()" function
14716 f_repeat(argvars
, rettv
)
14727 n
= get_tv_number(&argvars
[1]);
14728 if (argvars
[0].v_type
== VAR_LIST
)
14730 if (rettv_list_alloc(rettv
) == OK
&& argvars
[0].vval
.v_list
!= NULL
)
14732 if (list_extend(rettv
->vval
.v_list
,
14733 argvars
[0].vval
.v_list
, NULL
) == FAIL
)
14738 p
= get_tv_string(&argvars
[0]);
14739 rettv
->v_type
= VAR_STRING
;
14740 rettv
->vval
.v_string
= NULL
;
14742 slen
= (int)STRLEN(p
);
14747 r
= alloc(len
+ 1);
14750 for (i
= 0; i
< n
; i
++)
14751 mch_memmove(r
+ i
* slen
, p
, (size_t)slen
);
14755 rettv
->vval
.v_string
= r
;
14760 * "resolve()" function
14763 f_resolve(argvars
, rettv
)
14769 p
= get_tv_string(&argvars
[0]);
14770 #ifdef FEAT_SHORTCUT
14774 v
= mch_resolve_shortcut(p
);
14776 rettv
->vval
.v_string
= v
;
14778 rettv
->vval
.v_string
= vim_strsave(p
);
14781 # ifdef HAVE_READLINK
14783 char_u buf
[MAXPATHL
+ 1];
14786 char_u
*remain
= NULL
;
14788 int is_relative_to_current
= FALSE
;
14789 int has_trailing_pathsep
= FALSE
;
14792 p
= vim_strsave(p
);
14794 if (p
[0] == '.' && (vim_ispathsep(p
[1])
14795 || (p
[1] == '.' && (vim_ispathsep(p
[2])))))
14796 is_relative_to_current
= TRUE
;
14799 if (len
> 0 && after_pathsep(p
, p
+ len
))
14800 has_trailing_pathsep
= TRUE
;
14802 q
= getnextcomp(p
);
14805 /* Separate the first path component in "p", and keep the
14806 * remainder (beginning with the path separator). */
14807 remain
= vim_strsave(q
- 1);
14815 len
= readlink((char *)p
, (char *)buf
, MAXPATHL
);
14824 EMSG(_("E655: Too many symbolic links (cycle?)"));
14825 rettv
->vval
.v_string
= NULL
;
14829 /* Ensure that the result will have a trailing path separator
14830 * if the argument has one. */
14831 if (remain
== NULL
&& has_trailing_pathsep
)
14834 /* Separate the first path component in the link value and
14835 * concatenate the remainders. */
14836 q
= getnextcomp(vim_ispathsep(*buf
) ? buf
+ 1 : buf
);
14839 if (remain
== NULL
)
14840 remain
= vim_strsave(q
- 1);
14843 cpy
= concat_str(q
- 1, remain
);
14854 if (q
> p
&& *q
== NUL
)
14856 /* Ignore trailing path separator. */
14860 if (q
> p
&& !mch_isFullName(buf
))
14862 /* symlink is relative to directory of argument */
14863 cpy
= alloc((unsigned)(STRLEN(p
) + STRLEN(buf
) + 1));
14867 STRCPY(gettail(cpy
), buf
);
14875 p
= vim_strsave(buf
);
14879 if (remain
== NULL
)
14882 /* Append the first path component of "remain" to "p". */
14883 q
= getnextcomp(remain
+ 1);
14884 len
= q
- remain
- (*q
!= NUL
);
14885 cpy
= vim_strnsave(p
, STRLEN(p
) + len
);
14888 STRNCAT(cpy
, remain
, len
);
14892 /* Shorten "remain". */
14894 STRMOVE(remain
, q
- 1);
14902 /* If the result is a relative path name, make it explicitly relative to
14903 * the current directory if and only if the argument had this form. */
14904 if (!vim_ispathsep(*p
))
14906 if (is_relative_to_current
14910 || vim_ispathsep(p
[1])
14913 || vim_ispathsep(p
[2]))))))
14915 /* Prepend "./". */
14916 cpy
= concat_str((char_u
*)"./", p
);
14923 else if (!is_relative_to_current
)
14925 /* Strip leading "./". */
14927 while (q
[0] == '.' && vim_ispathsep(q
[1]))
14934 /* Ensure that the result will have no trailing path separator
14935 * if the argument had none. But keep "/" or "//". */
14936 if (!has_trailing_pathsep
)
14939 if (after_pathsep(p
, q
))
14940 *gettail_sep(p
) = NUL
;
14943 rettv
->vval
.v_string
= p
;
14946 rettv
->vval
.v_string
= vim_strsave(p
);
14950 simplify_filename(rettv
->vval
.v_string
);
14952 #ifdef HAVE_READLINK
14955 rettv
->v_type
= VAR_STRING
;
14959 * "reverse({list})" function
14962 f_reverse(argvars
, rettv
)
14967 listitem_T
*li
, *ni
;
14969 if (argvars
[0].v_type
!= VAR_LIST
)
14970 EMSG2(_(e_listarg
), "reverse()");
14971 else if ((l
= argvars
[0].vval
.v_list
) != NULL
14972 && !tv_check_lock(l
->lv_lock
, (char_u
*)"reverse()"))
14975 l
->lv_first
= l
->lv_last
= NULL
;
14980 list_append(l
, li
);
14983 rettv
->vval
.v_list
= l
;
14984 rettv
->v_type
= VAR_LIST
;
14986 l
->lv_idx
= l
->lv_len
- l
->lv_idx
- 1;
14990 #define SP_NOMOVE 0x01 /* don't move cursor */
14991 #define SP_REPEAT 0x02 /* repeat to find outer pair */
14992 #define SP_RETCOUNT 0x04 /* return matchcount */
14993 #define SP_SETPCMARK 0x08 /* set previous context mark */
14994 #define SP_START 0x10 /* accept match at start position */
14995 #define SP_SUBPAT 0x20 /* return nr of matching sub-pattern */
14996 #define SP_END 0x40 /* leave cursor at end of match */
14998 static int get_search_arg
__ARGS((typval_T
*varp
, int *flagsp
));
15001 * Get flags for a search function.
15002 * Possibly sets "p_ws".
15003 * Returns BACKWARD, FORWARD or zero (for an error).
15006 get_search_arg(varp
, flagsp
)
15012 char_u nbuf
[NUMBUFLEN
];
15015 if (varp
->v_type
!= VAR_UNKNOWN
)
15017 flags
= get_tv_string_buf_chk(varp
, nbuf
);
15019 return 0; /* type error; errmsg already given */
15020 while (*flags
!= NUL
)
15024 case 'b': dir
= BACKWARD
; break;
15025 case 'w': p_ws
= TRUE
; break;
15026 case 'W': p_ws
= FALSE
; break;
15028 if (flagsp
!= NULL
)
15031 case 'c': mask
= SP_START
; break;
15032 case 'e': mask
= SP_END
; break;
15033 case 'm': mask
= SP_RETCOUNT
; break;
15034 case 'n': mask
= SP_NOMOVE
; break;
15035 case 'p': mask
= SP_SUBPAT
; break;
15036 case 'r': mask
= SP_REPEAT
; break;
15037 case 's': mask
= SP_SETPCMARK
; break;
15041 EMSG2(_(e_invarg2
), flags
);
15056 * Shared by search() and searchpos() functions
15059 search_cmn(argvars
, match_pos
, flagsp
)
15068 int save_p_ws
= p_ws
;
15070 int retval
= 0; /* default: FAIL */
15071 long lnum_stop
= 0;
15073 #ifdef FEAT_RELTIME
15074 long time_limit
= 0;
15076 int options
= SEARCH_KEEP
;
15079 pat
= get_tv_string(&argvars
[0]);
15080 dir
= get_search_arg(&argvars
[1], flagsp
); /* may set p_ws */
15084 if (flags
& SP_START
)
15085 options
|= SEARCH_START
;
15086 if (flags
& SP_END
)
15087 options
|= SEARCH_END
;
15089 /* Optional arguments: line number to stop searching and timeout. */
15090 if (argvars
[1].v_type
!= VAR_UNKNOWN
&& argvars
[2].v_type
!= VAR_UNKNOWN
)
15092 lnum_stop
= get_tv_number_chk(&argvars
[2], NULL
);
15095 #ifdef FEAT_RELTIME
15096 if (argvars
[3].v_type
!= VAR_UNKNOWN
)
15098 time_limit
= get_tv_number_chk(&argvars
[3], NULL
);
15099 if (time_limit
< 0)
15105 #ifdef FEAT_RELTIME
15106 /* Set the time limit, if there is one. */
15107 profile_setlimit(time_limit
, &tm
);
15111 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
15112 * Check to make sure only those flags are set.
15113 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
15114 * flags cannot be set. Check for that condition also.
15116 if (((flags
& (SP_REPEAT
| SP_RETCOUNT
)) != 0)
15117 || ((flags
& SP_NOMOVE
) && (flags
& SP_SETPCMARK
)))
15119 EMSG2(_(e_invarg2
), get_tv_string(&argvars
[1]));
15123 pos
= save_cursor
= curwin
->w_cursor
;
15124 subpatnum
= searchit(curwin
, curbuf
, &pos
, dir
, pat
, 1L,
15125 options
, RE_SEARCH
, (linenr_T
)lnum_stop
, &tm
);
15126 if (subpatnum
!= FAIL
)
15128 if (flags
& SP_SUBPAT
)
15129 retval
= subpatnum
;
15132 if (flags
& SP_SETPCMARK
)
15134 curwin
->w_cursor
= pos
;
15135 if (match_pos
!= NULL
)
15137 /* Store the match cursor position */
15138 match_pos
->lnum
= pos
.lnum
;
15139 match_pos
->col
= pos
.col
+ 1;
15141 /* "/$" will put the cursor after the end of the line, may need to
15142 * correct that here */
15146 /* If 'n' flag is used: restore cursor position. */
15147 if (flags
& SP_NOMOVE
)
15148 curwin
->w_cursor
= save_cursor
;
15150 curwin
->w_set_curswant
= TRUE
;
15159 * "round({float})" function
15162 f_round(argvars
, rettv
)
15168 rettv
->v_type
= VAR_FLOAT
;
15169 if (get_float_arg(argvars
, &f
) == OK
)
15170 /* round() is not in C90, use ceil() or floor() instead. */
15171 rettv
->vval
.v_float
= f
> 0 ? floor(f
+ 0.5) : ceil(f
- 0.5);
15173 rettv
->vval
.v_float
= 0.0;
15178 * "search()" function
15181 f_search(argvars
, rettv
)
15187 rettv
->vval
.v_number
= search_cmn(argvars
, NULL
, &flags
);
15191 * "searchdecl()" function
15194 f_searchdecl(argvars
, rettv
)
15203 rettv
->vval
.v_number
= 1; /* default: FAIL */
15205 name
= get_tv_string_chk(&argvars
[0]);
15206 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
15208 locally
= get_tv_number_chk(&argvars
[1], &error
) == 0;
15209 if (!error
&& argvars
[2].v_type
!= VAR_UNKNOWN
)
15210 thisblock
= get_tv_number_chk(&argvars
[2], &error
) != 0;
15212 if (!error
&& name
!= NULL
)
15213 rettv
->vval
.v_number
= find_decl(name
, (int)STRLEN(name
),
15214 locally
, thisblock
, SEARCH_KEEP
) == FAIL
;
15218 * Used by searchpair() and searchpairpos()
15221 searchpair_cmn(argvars
, match_pos
)
15225 char_u
*spat
, *mpat
, *epat
;
15227 int save_p_ws
= p_ws
;
15230 char_u nbuf1
[NUMBUFLEN
];
15231 char_u nbuf2
[NUMBUFLEN
];
15232 char_u nbuf3
[NUMBUFLEN
];
15233 int retval
= 0; /* default: FAIL */
15234 long lnum_stop
= 0;
15235 long time_limit
= 0;
15237 /* Get the three pattern arguments: start, middle, end. */
15238 spat
= get_tv_string_chk(&argvars
[0]);
15239 mpat
= get_tv_string_buf_chk(&argvars
[1], nbuf1
);
15240 epat
= get_tv_string_buf_chk(&argvars
[2], nbuf2
);
15241 if (spat
== NULL
|| mpat
== NULL
|| epat
== NULL
)
15242 goto theend
; /* type error */
15244 /* Handle the optional fourth argument: flags */
15245 dir
= get_search_arg(&argvars
[3], &flags
); /* may set p_ws */
15249 /* Don't accept SP_END or SP_SUBPAT.
15250 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
15252 if ((flags
& (SP_END
| SP_SUBPAT
)) != 0
15253 || ((flags
& SP_NOMOVE
) && (flags
& SP_SETPCMARK
)))
15255 EMSG2(_(e_invarg2
), get_tv_string(&argvars
[3]));
15259 /* Using 'r' implies 'W', otherwise it doesn't work. */
15260 if (flags
& SP_REPEAT
)
15263 /* Optional fifth argument: skip expression */
15264 if (argvars
[3].v_type
== VAR_UNKNOWN
15265 || argvars
[4].v_type
== VAR_UNKNOWN
)
15266 skip
= (char_u
*)"";
15269 skip
= get_tv_string_buf_chk(&argvars
[4], nbuf3
);
15270 if (argvars
[5].v_type
!= VAR_UNKNOWN
)
15272 lnum_stop
= get_tv_number_chk(&argvars
[5], NULL
);
15275 #ifdef FEAT_RELTIME
15276 if (argvars
[6].v_type
!= VAR_UNKNOWN
)
15278 time_limit
= get_tv_number_chk(&argvars
[6], NULL
);
15279 if (time_limit
< 0)
15286 goto theend
; /* type error */
15288 retval
= do_searchpair(spat
, mpat
, epat
, dir
, skip
, flags
,
15289 match_pos
, lnum_stop
, time_limit
);
15298 * "searchpair()" function
15301 f_searchpair(argvars
, rettv
)
15305 rettv
->vval
.v_number
= searchpair_cmn(argvars
, NULL
);
15309 * "searchpairpos()" function
15312 f_searchpairpos(argvars
, rettv
)
15320 if (rettv_list_alloc(rettv
) == FAIL
)
15323 if (searchpair_cmn(argvars
, &match_pos
) > 0)
15325 lnum
= match_pos
.lnum
;
15326 col
= match_pos
.col
;
15329 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)lnum
);
15330 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)col
);
15334 * Search for a start/middle/end thing.
15335 * Used by searchpair(), see its documentation for the details.
15336 * Returns 0 or -1 for no match,
15339 do_searchpair(spat
, mpat
, epat
, dir
, skip
, flags
, match_pos
,
15340 lnum_stop
, time_limit
)
15341 char_u
*spat
; /* start pattern */
15342 char_u
*mpat
; /* middle pattern */
15343 char_u
*epat
; /* end pattern */
15344 int dir
; /* BACKWARD or FORWARD */
15345 char_u
*skip
; /* skip expression */
15346 int flags
; /* SP_SETPCMARK and other SP_ values */
15348 linenr_T lnum_stop
; /* stop at this line if not zero */
15349 long time_limit
; /* stop after this many msec */
15352 char_u
*pat
, *pat2
= NULL
, *pat3
= NULL
;
15363 int options
= SEARCH_KEEP
;
15366 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15368 p_cpo
= empty_option
;
15370 #ifdef FEAT_RELTIME
15371 /* Set the time limit, if there is one. */
15372 profile_setlimit(time_limit
, &tm
);
15375 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15376 * start/middle/end (pat3, for the top pair). */
15377 pat2
= alloc((unsigned)(STRLEN(spat
) + STRLEN(epat
) + 15));
15378 pat3
= alloc((unsigned)(STRLEN(spat
) + STRLEN(mpat
) + STRLEN(epat
) + 23));
15379 if (pat2
== NULL
|| pat3
== NULL
)
15381 sprintf((char *)pat2
, "\\(%s\\m\\)\\|\\(%s\\m\\)", spat
, epat
);
15383 STRCPY(pat3
, pat2
);
15385 sprintf((char *)pat3
, "\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)",
15387 if (flags
& SP_START
)
15388 options
|= SEARCH_START
;
15390 save_cursor
= curwin
->w_cursor
;
15391 pos
= curwin
->w_cursor
;
15392 clearpos(&firstpos
);
15393 clearpos(&foundpos
);
15397 n
= searchit(curwin
, curbuf
, &pos
, dir
, pat
, 1L,
15398 options
, RE_SEARCH
, lnum_stop
, &tm
);
15399 if (n
== FAIL
|| (firstpos
.lnum
!= 0 && equalpos(pos
, firstpos
)))
15400 /* didn't find it or found the first match again: FAIL */
15403 if (firstpos
.lnum
== 0)
15405 if (equalpos(pos
, foundpos
))
15407 /* Found the same position again. Can happen with a pattern that
15408 * has "\zs" at the end and searching backwards. Advance one
15409 * character and try again. */
15410 if (dir
== BACKWARD
)
15417 /* clear the start flag to avoid getting stuck here */
15418 options
&= ~SEARCH_START
;
15420 /* If the skip pattern matches, ignore this match. */
15423 save_pos
= curwin
->w_cursor
;
15424 curwin
->w_cursor
= pos
;
15425 r
= eval_to_bool(skip
, &err
, NULL
, FALSE
);
15426 curwin
->w_cursor
= save_pos
;
15429 /* Evaluating {skip} caused an error, break here. */
15430 curwin
->w_cursor
= save_cursor
;
15438 if ((dir
== BACKWARD
&& n
== 3) || (dir
== FORWARD
&& n
== 2))
15440 /* Found end when searching backwards or start when searching
15441 * forward: nested pair. */
15443 pat
= pat2
; /* nested, don't search for middle */
15447 /* Found end when searching forward or start when searching
15448 * backward: end of (nested) pair; or found middle in outer pair. */
15450 pat
= pat3
; /* outer level, search for middle */
15455 /* Found the match: return matchcount or line number. */
15456 if (flags
& SP_RETCOUNT
)
15460 if (flags
& SP_SETPCMARK
)
15462 curwin
->w_cursor
= pos
;
15463 if (!(flags
& SP_REPEAT
))
15465 nest
= 1; /* search for next unmatched */
15469 if (match_pos
!= NULL
)
15471 /* Store the match cursor position */
15472 match_pos
->lnum
= curwin
->w_cursor
.lnum
;
15473 match_pos
->col
= curwin
->w_cursor
.col
+ 1;
15476 /* If 'n' flag is used or search failed: restore cursor position. */
15477 if ((flags
& SP_NOMOVE
) || retval
== 0)
15478 curwin
->w_cursor
= save_cursor
;
15483 if (p_cpo
== empty_option
)
15486 /* Darn, evaluating the {skip} expression changed the value. */
15487 free_string_option(save_cpo
);
15493 * "searchpos()" function
15496 f_searchpos(argvars
, rettv
)
15506 if (rettv_list_alloc(rettv
) == FAIL
)
15509 n
= search_cmn(argvars
, &match_pos
, &flags
);
15512 lnum
= match_pos
.lnum
;
15513 col
= match_pos
.col
;
15516 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)lnum
);
15517 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)col
);
15518 if (flags
& SP_SUBPAT
)
15519 list_append_number(rettv
->vval
.v_list
, (varnumber_T
)n
);
15524 f_server2client(argvars
, rettv
)
15525 typval_T
*argvars UNUSED
;
15528 #ifdef FEAT_CLIENTSERVER
15529 char_u buf
[NUMBUFLEN
];
15530 char_u
*server
= get_tv_string_chk(&argvars
[0]);
15531 char_u
*reply
= get_tv_string_buf_chk(&argvars
[1], buf
);
15533 rettv
->vval
.v_number
= -1;
15534 if (server
== NULL
|| reply
== NULL
)
15536 if (check_restricted() || check_secure())
15539 if (check_connection() == FAIL
)
15543 if (serverSendReply(server
, reply
) < 0)
15545 EMSG(_("E258: Unable to send to client"));
15548 rettv
->vval
.v_number
= 0;
15550 rettv
->vval
.v_number
= -1;
15555 f_serverlist(argvars
, rettv
)
15556 typval_T
*argvars UNUSED
;
15561 #ifdef FEAT_CLIENTSERVER
15563 r
= serverGetVimNames();
15566 if (X_DISPLAY
!= NULL
)
15567 r
= serverGetVimNames(X_DISPLAY
);
15570 rettv
->v_type
= VAR_STRING
;
15571 rettv
->vval
.v_string
= r
;
15575 * "setbufvar()" function
15578 f_setbufvar(argvars
, rettv
)
15580 typval_T
*rettv UNUSED
;
15584 char_u
*varname
, *bufvarname
;
15586 char_u nbuf
[NUMBUFLEN
];
15588 if (check_restricted() || check_secure())
15590 (void)get_tv_number(&argvars
[0]); /* issue errmsg if type error */
15591 varname
= get_tv_string_chk(&argvars
[1]);
15592 buf
= get_buf_tv(&argvars
[0]);
15593 varp
= &argvars
[2];
15595 if (buf
!= NULL
&& varname
!= NULL
&& varp
!= NULL
)
15597 /* set curbuf to be our buf, temporarily */
15598 aucmd_prepbuf(&aco
, buf
);
15600 if (*varname
== '&')
15607 numval
= get_tv_number_chk(varp
, &error
);
15608 strval
= get_tv_string_buf_chk(varp
, nbuf
);
15609 if (!error
&& strval
!= NULL
)
15610 set_option_value(varname
, numval
, strval
, OPT_LOCAL
);
15614 bufvarname
= alloc((unsigned)STRLEN(varname
) + 3);
15615 if (bufvarname
!= NULL
)
15617 STRCPY(bufvarname
, "b:");
15618 STRCPY(bufvarname
+ 2, varname
);
15619 set_var(bufvarname
, varp
, TRUE
);
15620 vim_free(bufvarname
);
15624 /* reset notion of buffer */
15625 aucmd_restbuf(&aco
);
15630 * "setcmdpos()" function
15633 f_setcmdpos(argvars
, rettv
)
15637 int pos
= (int)get_tv_number(&argvars
[0]) - 1;
15640 rettv
->vval
.v_number
= set_cmdline_pos(pos
);
15644 * "setline()" function
15647 f_setline(argvars
, rettv
)
15652 char_u
*line
= NULL
;
15654 listitem_T
*li
= NULL
;
15656 linenr_T lcount
= curbuf
->b_ml
.ml_line_count
;
15658 lnum
= get_tv_lnum(&argvars
[0]);
15659 if (argvars
[1].v_type
== VAR_LIST
)
15661 l
= argvars
[1].vval
.v_list
;
15665 line
= get_tv_string_chk(&argvars
[1]);
15667 /* default result is zero == OK */
15672 /* list argument, get next string */
15675 line
= get_tv_string_chk(&li
->li_tv
);
15679 rettv
->vval
.v_number
= 1; /* FAIL */
15680 if (line
== NULL
|| lnum
< 1 || lnum
> curbuf
->b_ml
.ml_line_count
+ 1)
15682 if (lnum
<= curbuf
->b_ml
.ml_line_count
)
15684 /* existing line, replace it */
15685 if (u_savesub(lnum
) == OK
&& ml_replace(lnum
, line
, TRUE
) == OK
)
15687 changed_bytes(lnum
, 0);
15688 if (lnum
== curwin
->w_cursor
.lnum
)
15689 check_cursor_col();
15690 rettv
->vval
.v_number
= 0; /* OK */
15693 else if (added
> 0 || u_save(lnum
- 1, lnum
) == OK
)
15695 /* lnum is one past the last line, append the line */
15697 if (ml_append(lnum
- 1, line
, (colnr_T
)0, FALSE
) == OK
)
15698 rettv
->vval
.v_number
= 0; /* OK */
15701 if (l
== NULL
) /* only one string argument */
15707 appended_lines_mark(lcount
, added
);
15710 static void set_qf_ll_list
__ARGS((win_T
*wp
, typval_T
*list_arg
, typval_T
*action_arg
, typval_T
*rettv
));
15713 * Used by "setqflist()" and "setloclist()" functions
15716 set_qf_ll_list(wp
, list_arg
, action_arg
, rettv
)
15718 typval_T
*list_arg UNUSED
;
15719 typval_T
*action_arg UNUSED
;
15722 #ifdef FEAT_QUICKFIX
15727 rettv
->vval
.v_number
= -1;
15729 #ifdef FEAT_QUICKFIX
15730 if (list_arg
->v_type
!= VAR_LIST
)
15731 EMSG(_(e_listreq
));
15734 list_T
*l
= list_arg
->vval
.v_list
;
15736 if (action_arg
->v_type
== VAR_STRING
)
15738 act
= get_tv_string_chk(action_arg
);
15740 return; /* type error; errmsg already given */
15741 if (*act
== 'a' || *act
== 'r')
15745 if (l
!= NULL
&& set_errorlist(wp
, l
, action
) == OK
)
15746 rettv
->vval
.v_number
= 0;
15752 * "setloclist()" function
15755 f_setloclist(argvars
, rettv
)
15761 rettv
->vval
.v_number
= -1;
15763 win
= find_win_by_nr(&argvars
[0], NULL
);
15765 set_qf_ll_list(win
, &argvars
[1], &argvars
[2], rettv
);
15769 * "setmatches()" function
15772 f_setmatches(argvars
, rettv
)
15776 #ifdef FEAT_SEARCH_EXTRA
15781 rettv
->vval
.v_number
= -1;
15782 if (argvars
[0].v_type
!= VAR_LIST
)
15784 EMSG(_(e_listreq
));
15787 if ((l
= argvars
[0].vval
.v_list
) != NULL
)
15790 /* To some extent make sure that we are dealing with a list from
15791 * "getmatches()". */
15795 if (li
->li_tv
.v_type
!= VAR_DICT
15796 || (d
= li
->li_tv
.vval
.v_dict
) == NULL
)
15801 if (!(dict_find(d
, (char_u
*)"group", -1) != NULL
15802 && dict_find(d
, (char_u
*)"pattern", -1) != NULL
15803 && dict_find(d
, (char_u
*)"priority", -1) != NULL
15804 && dict_find(d
, (char_u
*)"id", -1) != NULL
))
15812 clear_matches(curwin
);
15816 d
= li
->li_tv
.vval
.v_dict
;
15817 match_add(curwin
, get_dict_string(d
, (char_u
*)"group", FALSE
),
15818 get_dict_string(d
, (char_u
*)"pattern", FALSE
),
15819 (int)get_dict_number(d
, (char_u
*)"priority"),
15820 (int)get_dict_number(d
, (char_u
*)"id"));
15823 rettv
->vval
.v_number
= 0;
15829 * "setpos()" function
15832 f_setpos(argvars
, rettv
)
15840 rettv
->vval
.v_number
= -1;
15841 name
= get_tv_string_chk(argvars
);
15844 if (list2fpos(&argvars
[1], &pos
, &fnum
) == OK
)
15848 if (name
[0] == '.' && name
[1] == NUL
)
15851 if (fnum
== curbuf
->b_fnum
)
15853 curwin
->w_cursor
= pos
;
15855 rettv
->vval
.v_number
= 0;
15860 else if (name
[0] == '\'' && name
[1] != NUL
&& name
[2] == NUL
)
15863 if (setmark_pos(name
[1], &pos
, fnum
) == OK
)
15864 rettv
->vval
.v_number
= 0;
15873 * "setqflist()" function
15876 f_setqflist(argvars
, rettv
)
15880 set_qf_ll_list(NULL
, &argvars
[0], &argvars
[1], rettv
);
15884 * "setreg()" function
15887 f_setreg(argvars
, rettv
)
15892 char_u
*strregname
;
15903 strregname
= get_tv_string_chk(argvars
);
15904 rettv
->vval
.v_number
= 1; /* FAIL is default */
15906 if (strregname
== NULL
)
15907 return; /* type error; errmsg already given */
15908 regname
= *strregname
;
15909 if (regname
== 0 || regname
== '@')
15911 else if (regname
== '=')
15914 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
15916 stropt
= get_tv_string_chk(&argvars
[2]);
15917 if (stropt
== NULL
)
15918 return; /* type error */
15919 for (; *stropt
!= NUL
; ++stropt
)
15922 case 'a': case 'A': /* append */
15925 case 'v': case 'c': /* character-wise selection */
15928 case 'V': case 'l': /* line-wise selection */
15932 case 'b': case Ctrl_V
: /* block-wise selection */
15933 yank_type
= MBLOCK
;
15934 if (VIM_ISDIGIT(stropt
[1]))
15937 block_len
= getdigits(&stropt
) - 1;
15945 strval
= get_tv_string_chk(&argvars
[1]);
15946 if (strval
!= NULL
)
15947 write_reg_contents_ex(regname
, strval
, -1,
15948 append
, yank_type
, block_len
);
15949 rettv
->vval
.v_number
= 0;
15953 * "settabwinvar()" function
15956 f_settabwinvar(argvars
, rettv
)
15960 setwinvar(argvars
, rettv
, 1);
15964 * "setwinvar()" function
15967 f_setwinvar(argvars
, rettv
)
15971 setwinvar(argvars
, rettv
, 0);
15975 * "setwinvar()" and "settabwinvar()" functions
15978 setwinvar(argvars
, rettv
, off
)
15980 typval_T
*rettv UNUSED
;
15984 #ifdef FEAT_WINDOWS
15985 win_T
*save_curwin
;
15986 tabpage_T
*save_curtab
;
15988 char_u
*varname
, *winvarname
;
15990 char_u nbuf
[NUMBUFLEN
];
15993 if (check_restricted() || check_secure())
15996 #ifdef FEAT_WINDOWS
15998 tp
= find_tabpage((int)get_tv_number_chk(&argvars
[0], NULL
));
16002 win
= find_win_by_nr(&argvars
[off
], tp
);
16003 varname
= get_tv_string_chk(&argvars
[off
+ 1]);
16004 varp
= &argvars
[off
+ 2];
16006 if (win
!= NULL
&& varname
!= NULL
&& varp
!= NULL
)
16008 #ifdef FEAT_WINDOWS
16009 /* set curwin to be our win, temporarily */
16010 save_curwin
= curwin
;
16011 save_curtab
= curtab
;
16012 goto_tabpage_tp(tp
);
16013 if (!win_valid(win
))
16016 curbuf
= curwin
->w_buffer
;
16019 if (*varname
== '&')
16026 numval
= get_tv_number_chk(varp
, &error
);
16027 strval
= get_tv_string_buf_chk(varp
, nbuf
);
16028 if (!error
&& strval
!= NULL
)
16029 set_option_value(varname
, numval
, strval
, OPT_LOCAL
);
16033 winvarname
= alloc((unsigned)STRLEN(varname
) + 3);
16034 if (winvarname
!= NULL
)
16036 STRCPY(winvarname
, "w:");
16037 STRCPY(winvarname
+ 2, varname
);
16038 set_var(winvarname
, varp
, TRUE
);
16039 vim_free(winvarname
);
16043 #ifdef FEAT_WINDOWS
16044 /* Restore current tabpage and window, if still valid (autocomands can
16045 * make them invalid). */
16046 if (valid_tabpage(save_curtab
))
16047 goto_tabpage_tp(save_curtab
);
16048 if (win_valid(save_curwin
))
16050 curwin
= save_curwin
;
16051 curbuf
= curwin
->w_buffer
;
16058 * "shellescape({string})" function
16061 f_shellescape(argvars
, rettv
)
16065 rettv
->vval
.v_string
= vim_strsave_shellescape(
16066 get_tv_string(&argvars
[0]), non_zero_arg(&argvars
[1]));
16067 rettv
->v_type
= VAR_STRING
;
16071 * "simplify()" function
16074 f_simplify(argvars
, rettv
)
16080 p
= get_tv_string(&argvars
[0]);
16081 rettv
->vval
.v_string
= vim_strsave(p
);
16082 simplify_filename(rettv
->vval
.v_string
); /* simplify in place */
16083 rettv
->v_type
= VAR_STRING
;
16091 f_sin(argvars
, rettv
)
16097 rettv
->v_type
= VAR_FLOAT
;
16098 if (get_float_arg(argvars
, &f
) == OK
)
16099 rettv
->vval
.v_float
= sin(f
);
16101 rettv
->vval
.v_float
= 0.0;
16106 #ifdef __BORLANDC__
16109 item_compare
__ARGS((const void *s1
, const void *s2
));
16111 #ifdef __BORLANDC__
16114 item_compare2
__ARGS((const void *s1
, const void *s2
));
16116 static int item_compare_ic
;
16117 static char_u
*item_compare_func
;
16118 static int item_compare_func_err
;
16119 #define ITEM_COMPARE_FAIL 999
16122 * Compare functions for f_sort() below.
16125 #ifdef __BORLANDC__
16128 item_compare(s1
, s2
)
16133 char_u
*tofree1
, *tofree2
;
16135 char_u numbuf1
[NUMBUFLEN
];
16136 char_u numbuf2
[NUMBUFLEN
];
16138 p1
= tv2string(&(*(listitem_T
**)s1
)->li_tv
, &tofree1
, numbuf1
, 0);
16139 p2
= tv2string(&(*(listitem_T
**)s2
)->li_tv
, &tofree2
, numbuf2
, 0);
16144 if (item_compare_ic
)
16145 res
= STRICMP(p1
, p2
);
16147 res
= STRCMP(p1
, p2
);
16154 #ifdef __BORLANDC__
16157 item_compare2(s1
, s2
)
16166 /* shortcut after failure in previous call; compare all items equal */
16167 if (item_compare_func_err
)
16170 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
16171 * in the copy without changing the original list items. */
16172 copy_tv(&(*(listitem_T
**)s1
)->li_tv
, &argv
[0]);
16173 copy_tv(&(*(listitem_T
**)s2
)->li_tv
, &argv
[1]);
16175 rettv
.v_type
= VAR_UNKNOWN
; /* clear_tv() uses this */
16176 res
= call_func(item_compare_func
, (int)STRLEN(item_compare_func
),
16177 &rettv
, 2, argv
, 0L, 0L, &dummy
, TRUE
, NULL
);
16178 clear_tv(&argv
[0]);
16179 clear_tv(&argv
[1]);
16182 res
= ITEM_COMPARE_FAIL
;
16184 res
= get_tv_number_chk(&rettv
, &item_compare_func_err
);
16185 if (item_compare_func_err
)
16186 res
= ITEM_COMPARE_FAIL
; /* return value has wrong type */
16192 * "sort({list})" function
16195 f_sort(argvars
, rettv
)
16205 if (argvars
[0].v_type
!= VAR_LIST
)
16206 EMSG2(_(e_listarg
), "sort()");
16209 l
= argvars
[0].vval
.v_list
;
16210 if (l
== NULL
|| tv_check_lock(l
->lv_lock
, (char_u
*)"sort()"))
16212 rettv
->vval
.v_list
= l
;
16213 rettv
->v_type
= VAR_LIST
;
16218 return; /* short list sorts pretty quickly */
16220 item_compare_ic
= FALSE
;
16221 item_compare_func
= NULL
;
16222 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
16224 if (argvars
[1].v_type
== VAR_FUNC
)
16225 item_compare_func
= argvars
[1].vval
.v_string
;
16230 i
= get_tv_number_chk(&argvars
[1], &error
);
16232 return; /* type error; errmsg already given */
16234 item_compare_ic
= TRUE
;
16236 item_compare_func
= get_tv_string(&argvars
[1]);
16240 /* Make an array with each entry pointing to an item in the List. */
16241 ptrs
= (listitem_T
**)alloc((int)(len
* sizeof(listitem_T
*)));
16245 for (li
= l
->lv_first
; li
!= NULL
; li
= li
->li_next
)
16248 item_compare_func_err
= FALSE
;
16249 /* test the compare function */
16250 if (item_compare_func
!= NULL
16251 && item_compare2((void *)&ptrs
[0], (void *)&ptrs
[1])
16252 == ITEM_COMPARE_FAIL
)
16253 EMSG(_("E702: Sort compare function failed"));
16256 /* Sort the array with item pointers. */
16257 qsort((void *)ptrs
, (size_t)len
, sizeof(listitem_T
*),
16258 item_compare_func
== NULL
? item_compare
: item_compare2
);
16260 if (!item_compare_func_err
)
16262 /* Clear the List and append the items in the sorted order. */
16263 l
->lv_first
= l
->lv_last
= l
->lv_idx_item
= NULL
;
16265 for (i
= 0; i
< len
; ++i
)
16266 list_append(l
, ptrs
[i
]);
16275 * "soundfold({word})" function
16278 f_soundfold(argvars
, rettv
)
16284 rettv
->v_type
= VAR_STRING
;
16285 s
= get_tv_string(&argvars
[0]);
16287 rettv
->vval
.v_string
= eval_soundfold(s
);
16289 rettv
->vval
.v_string
= vim_strsave(s
);
16294 * "spellbadword()" function
16297 f_spellbadword(argvars
, rettv
)
16298 typval_T
*argvars UNUSED
;
16301 char_u
*word
= (char_u
*)"";
16302 hlf_T attr
= HLF_COUNT
;
16305 if (rettv_list_alloc(rettv
) == FAIL
)
16309 if (argvars
[0].v_type
== VAR_UNKNOWN
)
16311 /* Find the start and length of the badly spelled word. */
16312 len
= spell_move_to(curwin
, FORWARD
, TRUE
, TRUE
, &attr
);
16314 word
= ml_get_cursor();
16316 else if (curwin
->w_p_spell
&& *curbuf
->b_p_spl
!= NUL
)
16318 char_u
*str
= get_tv_string_chk(&argvars
[0]);
16323 /* Check the argument for spelling. */
16324 while (*str
!= NUL
)
16326 len
= spell_check(curwin
, str
, &attr
, &capcol
, FALSE
);
16327 if (attr
!= HLF_COUNT
)
16338 list_append_string(rettv
->vval
.v_list
, word
, len
);
16339 list_append_string(rettv
->vval
.v_list
, (char_u
*)(
16340 attr
== HLF_SPB
? "bad" :
16341 attr
== HLF_SPR
? "rare" :
16342 attr
== HLF_SPL
? "local" :
16343 attr
== HLF_SPC
? "caps" :
16348 * "spellsuggest()" function
16351 f_spellsuggest(argvars
, rettv
)
16352 typval_T
*argvars UNUSED
;
16357 int typeerr
= FALSE
;
16362 int need_capital
= FALSE
;
16365 if (rettv_list_alloc(rettv
) == FAIL
)
16369 if (curwin
->w_p_spell
&& *curbuf
->b_p_spl
!= NUL
)
16371 str
= get_tv_string(&argvars
[0]);
16372 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
16374 maxcount
= get_tv_number_chk(&argvars
[1], &typeerr
);
16377 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16379 need_capital
= get_tv_number_chk(&argvars
[2], &typeerr
);
16387 spell_suggest_list(&ga
, str
, maxcount
, need_capital
, FALSE
);
16389 for (i
= 0; i
< ga
.ga_len
; ++i
)
16391 str
= ((char_u
**)ga
.ga_data
)[i
];
16393 li
= listitem_alloc();
16398 li
->li_tv
.v_type
= VAR_STRING
;
16399 li
->li_tv
.v_lock
= 0;
16400 li
->li_tv
.vval
.v_string
= str
;
16401 list_append(rettv
->vval
.v_list
, li
);
16410 f_split(argvars
, rettv
)
16416 char_u
*pat
= NULL
;
16417 regmatch_T regmatch
;
16418 char_u patbuf
[NUMBUFLEN
];
16422 int keepempty
= FALSE
;
16423 int typeerr
= FALSE
;
16425 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16427 p_cpo
= (char_u
*)"";
16429 str
= get_tv_string(&argvars
[0]);
16430 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
16432 pat
= get_tv_string_buf_chk(&argvars
[1], patbuf
);
16435 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16436 keepempty
= get_tv_number_chk(&argvars
[2], &typeerr
);
16438 if (pat
== NULL
|| *pat
== NUL
)
16439 pat
= (char_u
*)"[\\x01- ]\\+";
16441 if (rettv_list_alloc(rettv
) == FAIL
)
16446 regmatch
.regprog
= vim_regcomp(pat
, RE_MAGIC
+ RE_STRING
);
16447 if (regmatch
.regprog
!= NULL
)
16449 regmatch
.rm_ic
= FALSE
;
16450 while (*str
!= NUL
|| keepempty
)
16453 match
= FALSE
; /* empty item at the end */
16455 match
= vim_regexec_nl(®match
, str
, col
);
16457 end
= regmatch
.startp
[0];
16459 end
= str
+ STRLEN(str
);
16460 if (keepempty
|| end
> str
|| (rettv
->vval
.v_list
->lv_len
> 0
16461 && *str
!= NUL
&& match
&& end
< regmatch
.endp
[0]))
16463 if (list_append_string(rettv
->vval
.v_list
, str
,
16464 (int)(end
- str
)) == FAIL
)
16469 /* Advance to just after the match. */
16470 if (regmatch
.endp
[0] > str
)
16474 /* Don't get stuck at the same match. */
16476 col
= (*mb_ptr2len
)(regmatch
.endp
[0]);
16481 str
= regmatch
.endp
[0];
16484 vim_free(regmatch
.regprog
);
16492 * "sqrt()" function
16495 f_sqrt(argvars
, rettv
)
16501 rettv
->v_type
= VAR_FLOAT
;
16502 if (get_float_arg(argvars
, &f
) == OK
)
16503 rettv
->vval
.v_float
= sqrt(f
);
16505 rettv
->vval
.v_float
= 0.0;
16509 * "str2float()" function
16512 f_str2float(argvars
, rettv
)
16516 char_u
*p
= skipwhite(get_tv_string(&argvars
[0]));
16519 p
= skipwhite(p
+ 1);
16520 (void)string2float(p
, &rettv
->vval
.v_float
);
16521 rettv
->v_type
= VAR_FLOAT
;
16526 * "str2nr()" function
16529 f_str2nr(argvars
, rettv
)
16537 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
16539 base
= get_tv_number(&argvars
[1]);
16540 if (base
!= 8 && base
!= 10 && base
!= 16)
16547 p
= skipwhite(get_tv_string(&argvars
[0]));
16549 p
= skipwhite(p
+ 1);
16550 vim_str2nr(p
, NULL
, NULL
, base
== 8 ? 2 : 0, base
== 16 ? 2 : 0, &n
, NULL
);
16551 rettv
->vval
.v_number
= n
;
16554 #ifdef HAVE_STRFTIME
16556 * "strftime({format}[, {time}])" function
16559 f_strftime(argvars
, rettv
)
16563 char_u result_buf
[256];
16564 struct tm
*curtime
;
16568 rettv
->v_type
= VAR_STRING
;
16570 p
= get_tv_string(&argvars
[0]);
16571 if (argvars
[1].v_type
== VAR_UNKNOWN
)
16572 seconds
= time(NULL
);
16574 seconds
= (time_t)get_tv_number(&argvars
[1]);
16575 curtime
= localtime(&seconds
);
16576 /* MSVC returns NULL for an invalid value of seconds. */
16577 if (curtime
== NULL
)
16578 rettv
->vval
.v_string
= vim_strsave((char_u
*)_("(Invalid)"));
16585 conv
.vc_type
= CONV_NONE
;
16586 enc
= enc_locale();
16587 convert_setup(&conv
, p_enc
, enc
);
16588 if (conv
.vc_type
!= CONV_NONE
)
16589 p
= string_convert(&conv
, p
, NULL
);
16592 (void)strftime((char *)result_buf
, sizeof(result_buf
),
16593 (char *)p
, curtime
);
16595 result_buf
[0] = NUL
;
16598 if (conv
.vc_type
!= CONV_NONE
)
16600 convert_setup(&conv
, enc
, p_enc
);
16601 if (conv
.vc_type
!= CONV_NONE
)
16602 rettv
->vval
.v_string
= string_convert(&conv
, result_buf
, NULL
);
16605 rettv
->vval
.v_string
= vim_strsave(result_buf
);
16608 /* Release conversion descriptors */
16609 convert_setup(&conv
, NULL
, NULL
);
16617 * "stridx()" function
16620 f_stridx(argvars
, rettv
)
16624 char_u buf
[NUMBUFLEN
];
16627 char_u
*save_haystack
;
16631 needle
= get_tv_string_chk(&argvars
[1]);
16632 save_haystack
= haystack
= get_tv_string_buf_chk(&argvars
[0], buf
);
16633 rettv
->vval
.v_number
= -1;
16634 if (needle
== NULL
|| haystack
== NULL
)
16635 return; /* type error; errmsg already given */
16637 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16641 start_idx
= get_tv_number_chk(&argvars
[2], &error
);
16642 if (error
|| start_idx
>= (int)STRLEN(haystack
))
16644 if (start_idx
>= 0)
16645 haystack
+= start_idx
;
16648 pos
= (char_u
*)strstr((char *)haystack
, (char *)needle
);
16650 rettv
->vval
.v_number
= (varnumber_T
)(pos
- save_haystack
);
16654 * "string()" function
16657 f_string(argvars
, rettv
)
16662 char_u numbuf
[NUMBUFLEN
];
16664 rettv
->v_type
= VAR_STRING
;
16665 rettv
->vval
.v_string
= tv2string(&argvars
[0], &tofree
, numbuf
, 0);
16666 /* Make a copy if we have a value but it's not in allocated memory. */
16667 if (rettv
->vval
.v_string
!= NULL
&& tofree
== NULL
)
16668 rettv
->vval
.v_string
= vim_strsave(rettv
->vval
.v_string
);
16672 * "strlen()" function
16675 f_strlen(argvars
, rettv
)
16679 rettv
->vval
.v_number
= (varnumber_T
)(STRLEN(
16680 get_tv_string(&argvars
[0])));
16684 * "strpart()" function
16687 f_strpart(argvars
, rettv
)
16697 p
= get_tv_string(&argvars
[0]);
16698 slen
= (int)STRLEN(p
);
16700 n
= get_tv_number_chk(&argvars
[1], &error
);
16703 else if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16704 len
= get_tv_number(&argvars
[2]);
16706 len
= slen
- n
; /* default len: all bytes that are available. */
16709 * Only return the overlap between the specified part and the actual
16721 else if (n
+ len
> slen
)
16724 rettv
->v_type
= VAR_STRING
;
16725 rettv
->vval
.v_string
= vim_strnsave(p
+ n
, len
);
16729 * "strridx()" function
16732 f_strridx(argvars
, rettv
)
16736 char_u buf
[NUMBUFLEN
];
16740 char_u
*lastmatch
= NULL
;
16741 int haystack_len
, end_idx
;
16743 needle
= get_tv_string_chk(&argvars
[1]);
16744 haystack
= get_tv_string_buf_chk(&argvars
[0], buf
);
16746 rettv
->vval
.v_number
= -1;
16747 if (needle
== NULL
|| haystack
== NULL
)
16748 return; /* type error; errmsg already given */
16750 haystack_len
= (int)STRLEN(haystack
);
16751 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16753 /* Third argument: upper limit for index */
16754 end_idx
= get_tv_number_chk(&argvars
[2], NULL
);
16756 return; /* can never find a match */
16759 end_idx
= haystack_len
;
16761 if (*needle
== NUL
)
16763 /* Empty string matches past the end. */
16764 lastmatch
= haystack
+ end_idx
;
16768 for (rest
= haystack
; *rest
!= '\0'; ++rest
)
16770 rest
= (char_u
*)strstr((char *)rest
, (char *)needle
);
16771 if (rest
== NULL
|| rest
> haystack
+ end_idx
)
16777 if (lastmatch
== NULL
)
16778 rettv
->vval
.v_number
= -1;
16780 rettv
->vval
.v_number
= (varnumber_T
)(lastmatch
- haystack
);
16784 * "strtrans()" function
16787 f_strtrans(argvars
, rettv
)
16791 rettv
->v_type
= VAR_STRING
;
16792 rettv
->vval
.v_string
= transstr(get_tv_string(&argvars
[0]));
16796 * "submatch()" function
16799 f_submatch(argvars
, rettv
)
16803 rettv
->v_type
= VAR_STRING
;
16804 rettv
->vval
.v_string
=
16805 reg_submatch((int)get_tv_number_chk(&argvars
[0], NULL
));
16809 * "substitute()" function
16812 f_substitute(argvars
, rettv
)
16816 char_u patbuf
[NUMBUFLEN
];
16817 char_u subbuf
[NUMBUFLEN
];
16818 char_u flagsbuf
[NUMBUFLEN
];
16820 char_u
*str
= get_tv_string_chk(&argvars
[0]);
16821 char_u
*pat
= get_tv_string_buf_chk(&argvars
[1], patbuf
);
16822 char_u
*sub
= get_tv_string_buf_chk(&argvars
[2], subbuf
);
16823 char_u
*flg
= get_tv_string_buf_chk(&argvars
[3], flagsbuf
);
16825 rettv
->v_type
= VAR_STRING
;
16826 if (str
== NULL
|| pat
== NULL
|| sub
== NULL
|| flg
== NULL
)
16827 rettv
->vval
.v_string
= NULL
;
16829 rettv
->vval
.v_string
= do_string_sub(str
, pat
, sub
, flg
);
16833 * "synID(lnum, col, trans)" function
16836 f_synID(argvars
, rettv
)
16837 typval_T
*argvars UNUSED
;
16845 int transerr
= FALSE
;
16847 lnum
= get_tv_lnum(argvars
); /* -1 on type error */
16848 col
= get_tv_number(&argvars
[1]) - 1; /* -1 on type error */
16849 trans
= get_tv_number_chk(&argvars
[2], &transerr
);
16851 if (!transerr
&& lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
16852 && col
>= 0 && col
< (long)STRLEN(ml_get(lnum
)))
16853 id
= syn_get_id(curwin
, lnum
, (colnr_T
)col
, trans
, NULL
, FALSE
);
16856 rettv
->vval
.v_number
= id
;
16860 * "synIDattr(id, what [, mode])" function
16863 f_synIDattr(argvars
, rettv
)
16864 typval_T
*argvars UNUSED
;
16872 char_u modebuf
[NUMBUFLEN
];
16875 id
= get_tv_number(&argvars
[0]);
16876 what
= get_tv_string(&argvars
[1]);
16877 if (argvars
[2].v_type
!= VAR_UNKNOWN
)
16879 mode
= get_tv_string_buf(&argvars
[2], modebuf
);
16880 modec
= TOLOWER_ASC(mode
[0]);
16881 if (modec
!= 't' && modec
!= 'c'
16886 modec
= 0; /* replace invalid with current */
16902 switch (TOLOWER_ASC(what
[0]))
16905 if (TOLOWER_ASC(what
[1]) == 'g') /* bg[#] */
16906 p
= highlight_color(id
, what
, modec
);
16908 p
= highlight_has_attr(id
, HL_BOLD
, modec
);
16911 case 'f': /* fg[#] or font */
16912 p
= highlight_color(id
, what
, modec
);
16916 if (TOLOWER_ASC(what
[1]) == 'n') /* inverse */
16917 p
= highlight_has_attr(id
, HL_INVERSE
, modec
);
16919 p
= highlight_has_attr(id
, HL_ITALIC
, modec
);
16922 case 'n': /* name */
16923 p
= get_highlight_name(NULL
, id
- 1);
16926 case 'r': /* reverse */
16927 p
= highlight_has_attr(id
, HL_INVERSE
, modec
);
16931 if (TOLOWER_ASC(what
[1]) == 'p') /* sp[#] */
16932 p
= highlight_color(id
, what
, modec
);
16933 else /* standout */
16934 p
= highlight_has_attr(id
, HL_STANDOUT
, modec
);
16938 if (STRLEN(what
) <= 5 || TOLOWER_ASC(what
[5]) != 'c')
16940 p
= highlight_has_attr(id
, HL_UNDERLINE
, modec
);
16943 p
= highlight_has_attr(id
, HL_UNDERCURL
, modec
);
16948 p
= vim_strsave(p
);
16950 rettv
->v_type
= VAR_STRING
;
16951 rettv
->vval
.v_string
= p
;
16955 * "synIDtrans(id)" function
16958 f_synIDtrans(argvars
, rettv
)
16959 typval_T
*argvars UNUSED
;
16965 id
= get_tv_number(&argvars
[0]);
16968 id
= syn_get_final_id(id
);
16973 rettv
->vval
.v_number
= id
;
16977 * "synstack(lnum, col)" function
16980 f_synstack(argvars
, rettv
)
16981 typval_T
*argvars UNUSED
;
16991 rettv
->v_type
= VAR_LIST
;
16992 rettv
->vval
.v_list
= NULL
;
16995 lnum
= get_tv_lnum(argvars
); /* -1 on type error */
16996 col
= get_tv_number(&argvars
[1]) - 1; /* -1 on type error */
16998 if (lnum
>= 1 && lnum
<= curbuf
->b_ml
.ml_line_count
16999 && col
>= 0 && (col
== 0 || col
< (long)STRLEN(ml_get(lnum
)))
17000 && rettv_list_alloc(rettv
) != FAIL
)
17002 (void)syn_get_id(curwin
, lnum
, (colnr_T
)col
, FALSE
, NULL
, TRUE
);
17005 id
= syn_get_stack_item(i
);
17008 if (list_append_number(rettv
->vval
.v_list
, id
) == FAIL
)
17016 * "system()" function
17019 f_system(argvars
, rettv
)
17023 char_u
*res
= NULL
;
17025 char_u
*infile
= NULL
;
17026 char_u buf
[NUMBUFLEN
];
17030 if (check_restricted() || check_secure())
17033 if (argvars
[1].v_type
!= VAR_UNKNOWN
)
17036 * Write the string to a temp file, to be used for input of the shell
17039 if ((infile
= vim_tempname('i')) == NULL
)
17045 fd
= mch_fopen((char *)infile
, WRITEBIN
);
17048 EMSG2(_(e_notopen
), infile
);
17051 p
= get_tv_string_buf_chk(&argvars
[1], buf
);
17055 goto done
; /* type error; errmsg already given */
17057 if (fwrite(p
, STRLEN(p
), 1, fd
) != 1)
17059 if (fclose(fd
) != 0)
17063 EMSG(_("E677: Error writing temp file"));
17068 res
= get_cmd_output(get_tv_string(&argvars
[0]), infile
,
17069 SHELL_SILENT
| SHELL_COOKED
);
17072 /* translate <CR> into <NL> */
17077 for (s
= res
; *s
; ++s
)
17085 /* translate <CR><NL> into <NL> */
17091 for (s
= res
; *s
; ++s
)
17093 if (s
[0] == CAR
&& s
[1] == NL
)
17103 if (infile
!= NULL
)
17105 mch_remove(infile
);
17108 rettv
->v_type
= VAR_STRING
;
17109 rettv
->vval
.v_string
= res
;
17113 * "tabpagebuflist()" function
17116 f_tabpagebuflist(argvars
, rettv
)
17117 typval_T
*argvars UNUSED
;
17118 typval_T
*rettv UNUSED
;
17120 #ifdef FEAT_WINDOWS
17124 if (argvars
[0].v_type
== VAR_UNKNOWN
)
17128 tp
= find_tabpage((int)get_tv_number(&argvars
[0]));
17130 wp
= (tp
== curtab
) ? firstwin
: tp
->tp_firstwin
;
17132 if (wp
!= NULL
&& rettv_list_alloc(rettv
) != FAIL
)
17134 for (; wp
!= NULL
; wp
= wp
->w_next
)
17135 if (list_append_number(rettv
->vval
.v_list
,
17136 wp
->w_buffer
->b_fnum
) == FAIL
)
17144 * "tabpagenr()" function
17147 f_tabpagenr(argvars
, rettv
)
17148 typval_T
*argvars UNUSED
;
17152 #ifdef FEAT_WINDOWS
17155 if (argvars
[0].v_type
!= VAR_UNKNOWN
)
17157 arg
= get_tv_string_chk(&argvars
[0]);
17161 if (STRCMP(arg
, "$") == 0)
17162 nr
= tabpage_index(NULL
) - 1;
17164 EMSG2(_(e_invexpr2
), arg
);
17168 nr
= tabpage_index(curtab
);
17170 rettv
->vval
.v_number
= nr
;
17174 #ifdef FEAT_WINDOWS
17175 static int get_winnr
__ARGS((tabpage_T
*tp
, typval_T
*argvar
));
17178 * Common code for tabpagewinnr() and winnr().
17181 get_winnr(tp
, argvar
)
17190 twin
= (tp
== curtab
) ? curwin
: tp
->tp_curwin
;
17191 if (argvar
->v_type
!= VAR_UNKNOWN
)
17193 arg
= get_tv_string_chk(argvar
);
17195 nr
= 0; /* type error; errmsg already given */
17196 else if (STRCMP(arg
, "$") == 0)
17197 twin
= (tp
== curtab
) ? lastwin
: tp
->tp_lastwin
;
17198 else if (STRCMP(arg
, "#") == 0)
17200 twin
= (tp
== curtab
) ? prevwin
: tp
->tp_prevwin
;
17206 EMSG2(_(e_invexpr2
), arg
);
17212 for (wp
= (tp
== curtab
) ? firstwin
: tp
->tp_firstwin
;
17213 wp
!= twin
; wp
= wp
->w_next
)
17217 /* didn't find it in this tabpage */
17228 * "tabpagewinnr()" function
17231 f_tabpagewinnr(argvars
, rettv
)
17232 typval_T
*argvars UNUSED
;
17236 #ifdef FEAT_WINDOWS
17239 tp
= find_tabpage((int)get_tv_number(&argvars
[0]));
17243 nr
= get_winnr(tp
, &argvars
[1]);
17245 rettv
->vval
.v_number
= nr
;
17250 * "tagfiles()" function
17253 f_tagfiles(argvars
, rettv
)
17254 typval_T
*argvars UNUSED
;
17257 char_u fname
[MAXPATHL
+ 1];
17261 if (rettv_list_alloc(rettv
) == FAIL
)
17264 for (first
= TRUE
; ; first
= FALSE
)
17265 if (get_tagfname(&tn
, first
, fname
) == FAIL
17266 || list_append_string(rettv
->vval
.v_list
, fname
, -1) == FAIL
)
17272 * "taglist()" function
17275 f_taglist(argvars
, rettv
)
17279 char_u
*tag_pattern
;
17281 tag_pattern
= get_tv_string(&argvars
[0]);
17283 rettv
->vval
.v_number
= FALSE
;
17284 if (*tag_pattern
== NUL
)
17287 if (rettv_list_alloc(rettv
) == OK
)
17288 (void)get_tags(rettv
->vval
.v_list
, tag_pattern
);
17292 * "tempname()" function
17295 f_tempname(argvars
, rettv
)
17296 typval_T
*argvars UNUSED
;
17299 static int x
= 'A';
17301 rettv
->v_type
= VAR_STRING
;
17302 rettv
->vval
.v_string
= vim_tempname(x
);
17304 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
17305 * names. Skip 'I' and 'O', they are used for shell redirection. */
17323 } while (x
== 'I' || x
== 'O');
17327 * "test(list)" function: Just checking the walls...
17330 f_test(argvars
, rettv
)
17331 typval_T
*argvars UNUSED
;
17332 typval_T
*rettv UNUSED
;
17334 /* Used for unit testing. Change the code below to your liking. */
17338 char_u
*bad
, *good
;
17340 if (argvars
[0].v_type
!= VAR_LIST
)
17342 l
= argvars
[0].vval
.v_list
;
17348 bad
= get_tv_string(&li
->li_tv
);
17352 good
= get_tv_string(&li
->li_tv
);
17353 rettv
->vval
.v_number
= test_edit_score(bad
, good
);
17358 * "tolower(string)" function
17361 f_tolower(argvars
, rettv
)
17367 p
= vim_strsave(get_tv_string(&argvars
[0]));
17368 rettv
->v_type
= VAR_STRING
;
17369 rettv
->vval
.v_string
= p
;
17381 c
= utf_ptr2char(p
);
17382 lc
= utf_tolower(c
);
17383 l
= utf_ptr2len(p
);
17384 /* TODO: reallocate string when byte count changes. */
17385 if (utf_char2len(lc
) == l
)
17386 utf_char2bytes(lc
, p
);
17389 else if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
17390 p
+= l
; /* skip multi-byte character */
17394 *p
= TOLOWER_LOC(*p
); /* note that tolower() can be a macro */
17401 * "toupper(string)" function
17404 f_toupper(argvars
, rettv
)
17408 rettv
->v_type
= VAR_STRING
;
17409 rettv
->vval
.v_string
= strup_save(get_tv_string(&argvars
[0]));
17413 * "tr(string, fromstr, tostr)" function
17416 f_tr(argvars
, rettv
)
17433 char_u buf
[NUMBUFLEN
];
17434 char_u buf2
[NUMBUFLEN
];
17437 instr
= get_tv_string(&argvars
[0]);
17438 fromstr
= get_tv_string_buf_chk(&argvars
[1], buf
);
17439 tostr
= get_tv_string_buf_chk(&argvars
[2], buf2
);
17441 /* Default return value: empty string. */
17442 rettv
->v_type
= VAR_STRING
;
17443 rettv
->vval
.v_string
= NULL
;
17444 if (fromstr
== NULL
|| tostr
== NULL
)
17445 return; /* type error; errmsg already given */
17446 ga_init2(&ga
, (int)sizeof(char), 80);
17451 /* not multi-byte: fromstr and tostr must be the same length */
17452 if (STRLEN(fromstr
) != STRLEN(tostr
))
17457 EMSG2(_(e_invarg2
), fromstr
);
17462 /* fromstr and tostr have to contain the same number of chars */
17463 while (*instr
!= NUL
)
17468 inlen
= (*mb_ptr2len
)(instr
);
17472 for (p
= fromstr
; *p
!= NUL
; p
+= fromlen
)
17474 fromlen
= (*mb_ptr2len
)(p
);
17475 if (fromlen
== inlen
&& STRNCMP(instr
, p
, inlen
) == 0)
17477 for (p
= tostr
; *p
!= NUL
; p
+= tolen
)
17479 tolen
= (*mb_ptr2len
)(p
);
17487 if (*p
== NUL
) /* tostr is shorter than fromstr */
17494 if (first
&& cpstr
== instr
)
17496 /* Check that fromstr and tostr have the same number of
17497 * (multi-byte) characters. Done only once when a character
17498 * of instr doesn't appear in fromstr. */
17500 for (p
= tostr
; *p
!= NUL
; p
+= tolen
)
17502 tolen
= (*mb_ptr2len
)(p
);
17509 ga_grow(&ga
, cplen
);
17510 mch_memmove((char *)ga
.ga_data
+ ga
.ga_len
, cpstr
, (size_t)cplen
);
17511 ga
.ga_len
+= cplen
;
17518 /* When not using multi-byte chars we can do it faster. */
17519 p
= vim_strchr(fromstr
, *instr
);
17521 ga_append(&ga
, tostr
[p
- fromstr
]);
17523 ga_append(&ga
, *instr
);
17528 /* add a terminating NUL */
17530 ga_append(&ga
, NUL
);
17532 rettv
->vval
.v_string
= ga
.ga_data
;
17537 * "trunc({float})" function
17540 f_trunc(argvars
, rettv
)
17546 rettv
->v_type
= VAR_FLOAT
;
17547 if (get_float_arg(argvars
, &f
) == OK
)
17548 /* trunc() is not in C90, use floor() or ceil() instead. */
17549 rettv
->vval
.v_float
= f
> 0 ? floor(f
) : ceil(f
);
17551 rettv
->vval
.v_float
= 0.0;
17556 * "type(expr)" function
17559 f_type(argvars
, rettv
)
17565 switch (argvars
[0].v_type
)
17567 case VAR_NUMBER
: n
= 0; break;
17568 case VAR_STRING
: n
= 1; break;
17569 case VAR_FUNC
: n
= 2; break;
17570 case VAR_LIST
: n
= 3; break;
17571 case VAR_DICT
: n
= 4; break;
17573 case VAR_FLOAT
: n
= 5; break;
17575 default: EMSG2(_(e_intern2
), "f_type()"); n
= 0; break;
17577 rettv
->vval
.v_number
= n
;
17581 * "values(dict)" function
17584 f_values(argvars
, rettv
)
17588 dict_list(argvars
, rettv
, 1);
17592 * "virtcol(string)" function
17595 f_virtcol(argvars
, rettv
)
17601 int fnum
= curbuf
->b_fnum
;
17603 fp
= var2fpos(&argvars
[0], FALSE
, &fnum
);
17604 if (fp
!= NULL
&& fp
->lnum
<= curbuf
->b_ml
.ml_line_count
17605 && fnum
== curbuf
->b_fnum
)
17607 getvvcol(curwin
, fp
, NULL
, NULL
, &vcol
);
17611 rettv
->vval
.v_number
= vcol
;
17615 * "visualmode()" function
17618 f_visualmode(argvars
, rettv
)
17619 typval_T
*argvars UNUSED
;
17620 typval_T
*rettv UNUSED
;
17625 rettv
->v_type
= VAR_STRING
;
17626 str
[0] = curbuf
->b_visual_mode_eval
;
17628 rettv
->vval
.v_string
= vim_strsave(str
);
17630 /* A non-zero number or non-empty string argument: reset mode. */
17631 if (non_zero_arg(&argvars
[0]))
17632 curbuf
->b_visual_mode_eval
= NUL
;
17637 * "winbufnr(nr)" function
17640 f_winbufnr(argvars
, rettv
)
17646 wp
= find_win_by_nr(&argvars
[0], NULL
);
17648 rettv
->vval
.v_number
= -1;
17650 rettv
->vval
.v_number
= wp
->w_buffer
->b_fnum
;
17654 * "wincol()" function
17657 f_wincol(argvars
, rettv
)
17658 typval_T
*argvars UNUSED
;
17662 rettv
->vval
.v_number
= curwin
->w_wcol
+ 1;
17666 * "winheight(nr)" function
17669 f_winheight(argvars
, rettv
)
17675 wp
= find_win_by_nr(&argvars
[0], NULL
);
17677 rettv
->vval
.v_number
= -1;
17679 rettv
->vval
.v_number
= wp
->w_height
;
17683 * "winline()" function
17686 f_winline(argvars
, rettv
)
17687 typval_T
*argvars UNUSED
;
17691 rettv
->vval
.v_number
= curwin
->w_wrow
+ 1;
17695 * "winnr()" function
17698 f_winnr(argvars
, rettv
)
17699 typval_T
*argvars UNUSED
;
17704 #ifdef FEAT_WINDOWS
17705 nr
= get_winnr(curtab
, &argvars
[0]);
17707 rettv
->vval
.v_number
= nr
;
17711 * "winrestcmd()" function
17714 f_winrestcmd(argvars
, rettv
)
17715 typval_T
*argvars UNUSED
;
17718 #ifdef FEAT_WINDOWS
17724 ga_init2(&ga
, (int)sizeof(char), 70);
17725 for (wp
= firstwin
; wp
!= NULL
; wp
= wp
->w_next
)
17727 sprintf((char *)buf
, "%dresize %d|", winnr
, wp
->w_height
);
17728 ga_concat(&ga
, buf
);
17729 # ifdef FEAT_VERTSPLIT
17730 sprintf((char *)buf
, "vert %dresize %d|", winnr
, wp
->w_width
);
17731 ga_concat(&ga
, buf
);
17735 ga_append(&ga
, NUL
);
17737 rettv
->vval
.v_string
= ga
.ga_data
;
17739 rettv
->vval
.v_string
= NULL
;
17741 rettv
->v_type
= VAR_STRING
;
17745 * "winrestview()" function
17748 f_winrestview(argvars
, rettv
)
17750 typval_T
*rettv UNUSED
;
17754 if (argvars
[0].v_type
!= VAR_DICT
17755 || (dict
= argvars
[0].vval
.v_dict
) == NULL
)
17759 curwin
->w_cursor
.lnum
= get_dict_number(dict
, (char_u
*)"lnum");
17760 curwin
->w_cursor
.col
= get_dict_number(dict
, (char_u
*)"col");
17761 #ifdef FEAT_VIRTUALEDIT
17762 curwin
->w_cursor
.coladd
= get_dict_number(dict
, (char_u
*)"coladd");
17764 curwin
->w_curswant
= get_dict_number(dict
, (char_u
*)"curswant");
17765 curwin
->w_set_curswant
= FALSE
;
17767 set_topline(curwin
, get_dict_number(dict
, (char_u
*)"topline"));
17769 curwin
->w_topfill
= get_dict_number(dict
, (char_u
*)"topfill");
17771 curwin
->w_leftcol
= get_dict_number(dict
, (char_u
*)"leftcol");
17772 curwin
->w_skipcol
= get_dict_number(dict
, (char_u
*)"skipcol");
17775 changed_cline_bef_curs();
17776 invalidate_botline();
17777 redraw_later(VALID
);
17779 if (curwin
->w_topline
== 0)
17780 curwin
->w_topline
= 1;
17781 if (curwin
->w_topline
> curbuf
->b_ml
.ml_line_count
)
17782 curwin
->w_topline
= curbuf
->b_ml
.ml_line_count
;
17784 check_topfill(curwin
, TRUE
);
17790 * "winsaveview()" function
17793 f_winsaveview(argvars
, rettv
)
17794 typval_T
*argvars UNUSED
;
17799 dict
= dict_alloc();
17802 rettv
->v_type
= VAR_DICT
;
17803 rettv
->vval
.v_dict
= dict
;
17804 ++dict
->dv_refcount
;
17806 dict_add_nr_str(dict
, "lnum", (long)curwin
->w_cursor
.lnum
, NULL
);
17807 dict_add_nr_str(dict
, "col", (long)curwin
->w_cursor
.col
, NULL
);
17808 #ifdef FEAT_VIRTUALEDIT
17809 dict_add_nr_str(dict
, "coladd", (long)curwin
->w_cursor
.coladd
, NULL
);
17812 dict_add_nr_str(dict
, "curswant", (long)curwin
->w_curswant
, NULL
);
17814 dict_add_nr_str(dict
, "topline", (long)curwin
->w_topline
, NULL
);
17816 dict_add_nr_str(dict
, "topfill", (long)curwin
->w_topfill
, NULL
);
17818 dict_add_nr_str(dict
, "leftcol", (long)curwin
->w_leftcol
, NULL
);
17819 dict_add_nr_str(dict
, "skipcol", (long)curwin
->w_skipcol
, NULL
);
17823 * "winwidth(nr)" function
17826 f_winwidth(argvars
, rettv
)
17832 wp
= find_win_by_nr(&argvars
[0], NULL
);
17834 rettv
->vval
.v_number
= -1;
17836 #ifdef FEAT_VERTSPLIT
17837 rettv
->vval
.v_number
= wp
->w_width
;
17839 rettv
->vval
.v_number
= Columns
;
17844 * "writefile()" function
17847 f_writefile(argvars
, rettv
)
17851 int binary
= FALSE
;
17859 if (check_restricted() || check_secure())
17862 if (argvars
[0].v_type
!= VAR_LIST
)
17864 EMSG2(_(e_listarg
), "writefile()");
17867 if (argvars
[0].vval
.v_list
== NULL
)
17870 if (argvars
[2].v_type
!= VAR_UNKNOWN
17871 && STRCMP(get_tv_string(&argvars
[2]), "b") == 0)
17874 /* Always open the file in binary mode, library functions have a mind of
17875 * their own about CR-LF conversion. */
17876 fname
= get_tv_string(&argvars
[1]);
17877 if (*fname
== NUL
|| (fd
= mch_fopen((char *)fname
, WRITEBIN
)) == NULL
)
17879 EMSG2(_(e_notcreate
), *fname
== NUL
? (char_u
*)_("<empty>") : fname
);
17884 for (li
= argvars
[0].vval
.v_list
->lv_first
; li
!= NULL
;
17887 for (s
= get_tv_string(&li
->li_tv
); *s
!= NUL
; ++s
)
17899 if (!binary
|| li
->li_next
!= NULL
)
17900 if (putc('\n', fd
) == EOF
)
17914 rettv
->vval
.v_number
= ret
;
17918 * Translate a String variable into a position.
17919 * Returns NULL when there is an error.
17922 var2fpos(varp
, dollar_lnum
, fnum
)
17924 int dollar_lnum
; /* TRUE when $ is last line */
17925 int *fnum
; /* set to fnum for '0, 'A, etc. */
17931 /* Argument can be [lnum, col, coladd]. */
17932 if (varp
->v_type
== VAR_LIST
)
17939 l
= varp
->vval
.v_list
;
17943 /* Get the line number */
17944 pos
.lnum
= list_find_nr(l
, 0L, &error
);
17945 if (error
|| pos
.lnum
<= 0 || pos
.lnum
> curbuf
->b_ml
.ml_line_count
)
17946 return NULL
; /* invalid line number */
17948 /* Get the column number */
17949 pos
.col
= list_find_nr(l
, 1L, &error
);
17952 len
= (long)STRLEN(ml_get(pos
.lnum
));
17954 /* We accept "$" for the column number: last column. */
17955 li
= list_find(l
, 1L);
17956 if (li
!= NULL
&& li
->li_tv
.v_type
== VAR_STRING
17957 && li
->li_tv
.vval
.v_string
!= NULL
17958 && STRCMP(li
->li_tv
.vval
.v_string
, "$") == 0)
17961 /* Accept a position up to the NUL after the line. */
17962 if (pos
.col
== 0 || (int)pos
.col
> len
+ 1)
17963 return NULL
; /* invalid column number */
17966 #ifdef FEAT_VIRTUALEDIT
17967 /* Get the virtual offset. Defaults to zero. */
17968 pos
.coladd
= list_find_nr(l
, 2L, &error
);
17976 name
= get_tv_string_chk(varp
);
17979 if (name
[0] == '.') /* cursor */
17980 return &curwin
->w_cursor
;
17982 if (name
[0] == 'v' && name
[1] == NUL
) /* Visual start */
17986 return &curwin
->w_cursor
;
17989 if (name
[0] == '\'') /* mark */
17991 pp
= getmark_fnum(name
[1], FALSE
, fnum
);
17992 if (pp
== NULL
|| pp
== (pos_T
*)-1 || pp
->lnum
<= 0)
17997 #ifdef FEAT_VIRTUALEDIT
18001 if (name
[0] == 'w' && dollar_lnum
)
18004 if (name
[1] == '0') /* "w0": first visible line */
18007 pos
.lnum
= curwin
->w_topline
;
18010 else if (name
[1] == '$') /* "w$": last visible line */
18012 validate_botline();
18013 pos
.lnum
= curwin
->w_botline
- 1;
18017 else if (name
[0] == '$') /* last column or line */
18021 pos
.lnum
= curbuf
->b_ml
.ml_line_count
;
18026 pos
.lnum
= curwin
->w_cursor
.lnum
;
18027 pos
.col
= (colnr_T
)STRLEN(ml_get_curline());
18035 * Convert list in "arg" into a position and optional file number.
18036 * When "fnump" is NULL there is no file number, only 3 items.
18037 * Note that the column is passed on as-is, the caller may want to decrement
18038 * it to use 1 for the first column.
18039 * Return FAIL when conversion is not possible, doesn't check the position for
18043 list2fpos(arg
, posp
, fnump
)
18048 list_T
*l
= arg
->vval
.v_list
;
18052 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
18053 * when "fnump" isn't NULL and "coladd" is optional. */
18054 if (arg
->v_type
!= VAR_LIST
18056 || l
->lv_len
< (fnump
== NULL
? 2 : 3)
18057 || l
->lv_len
> (fnump
== NULL
? 3 : 4))
18062 n
= list_find_nr(l
, i
++, NULL
); /* fnum */
18066 n
= curbuf
->b_fnum
; /* current buffer */
18070 n
= list_find_nr(l
, i
++, NULL
); /* lnum */
18075 n
= list_find_nr(l
, i
++, NULL
); /* col */
18080 #ifdef FEAT_VIRTUALEDIT
18081 n
= list_find_nr(l
, i
, NULL
);
18092 * Get the length of an environment variable name.
18093 * Advance "arg" to the first character after the name.
18094 * Return 0 for error.
18103 for (p
= *arg
; vim_isIDc(*p
); ++p
)
18105 if (p
== *arg
) /* no name found */
18108 len
= (int)(p
- *arg
);
18114 * Get the length of the name of a function or internal variable.
18115 * "arg" is advanced to the first non-white character after the name.
18116 * Return 0 if something is wrong.
18125 /* Find the end of the name. */
18126 for (p
= *arg
; eval_isnamec(*p
); ++p
)
18128 if (p
== *arg
) /* no name found */
18131 len
= (int)(p
- *arg
);
18132 *arg
= skipwhite(p
);
18138 * Get the length of the name of a variable or function.
18139 * Only the name is recognized, does not handle ".key" or "[idx]".
18140 * "arg" is advanced to the first non-white character after the name.
18141 * Return -1 if curly braces expansion failed.
18142 * Return 0 if something else is wrong.
18143 * If the name contains 'magic' {}'s, expand them and return the
18144 * expanded name in an allocated string via 'alias' - caller must free.
18147 get_name_len(arg
, alias
, evaluate
, verbose
)
18155 char_u
*expr_start
;
18158 *alias
= NULL
; /* default to no alias */
18160 if ((*arg
)[0] == K_SPECIAL
&& (*arg
)[1] == KS_EXTRA
18161 && (*arg
)[2] == (int)KE_SNR
)
18163 /* hard coded <SNR>, already translated */
18165 return get_id_len(arg
) + 3;
18167 len
= eval_fname_script(*arg
);
18170 /* literal "<SID>", "s:" or "<SNR>" */
18175 * Find the end of the name; check for {} construction.
18177 p
= find_name_end(*arg
, &expr_start
, &expr_end
,
18178 len
> 0 ? 0 : FNE_CHECK_START
);
18179 if (expr_start
!= NULL
)
18181 char_u
*temp_string
;
18185 len
+= (int)(p
- *arg
);
18186 *arg
= skipwhite(p
);
18191 * Include any <SID> etc in the expanded string:
18192 * Thus the -len here.
18194 temp_string
= make_expanded_name(*arg
- len
, expr_start
, expr_end
, p
);
18195 if (temp_string
== NULL
)
18197 *alias
= temp_string
;
18198 *arg
= skipwhite(p
);
18199 return (int)STRLEN(temp_string
);
18202 len
+= get_id_len(arg
);
18203 if (len
== 0 && verbose
)
18204 EMSG2(_(e_invexpr2
), *arg
);
18210 * Find the end of a variable or function name, taking care of magic braces.
18211 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
18212 * start and end of the first magic braces item.
18213 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
18214 * Return a pointer to just after the name. Equal to "arg" if there is no
18218 find_name_end(arg
, expr_start
, expr_end
, flags
)
18220 char_u
**expr_start
;
18228 if (expr_start
!= NULL
)
18230 *expr_start
= NULL
;
18234 /* Quick check for valid starting character. */
18235 if ((flags
& FNE_CHECK_START
) && !eval_isnamec1(*arg
) && *arg
!= '{')
18238 for (p
= arg
; *p
!= NUL
18239 && (eval_isnamec(*p
)
18241 || ((flags
& FNE_INCL_BR
) && (*p
== '[' || *p
== '.'))
18243 || br_nest
!= 0); mb_ptr_adv(p
))
18247 /* skip over 'string' to avoid counting [ and ] inside it. */
18248 for (p
= p
+ 1; *p
!= NUL
&& *p
!= '\''; mb_ptr_adv(p
))
18253 else if (*p
== '"')
18255 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
18256 for (p
= p
+ 1; *p
!= NUL
&& *p
!= '"'; mb_ptr_adv(p
))
18257 if (*p
== '\\' && p
[1] != NUL
)
18267 else if (*p
== ']')
18276 if (expr_start
!= NULL
&& *expr_start
== NULL
)
18279 else if (*p
== '}')
18282 if (expr_start
!= NULL
&& mb_nest
== 0 && *expr_end
== NULL
)
18292 * Expands out the 'magic' {}'s in a variable/function name.
18293 * Note that this can call itself recursively, to deal with
18294 * constructs like foo{bar}{baz}{bam}
18295 * The four pointer arguments point to "foo{expre}ss{ion}bar"
18301 * Returns a new allocated string, which the caller must free.
18302 * Returns NULL for failure.
18305 make_expanded_name(in_start
, expr_start
, expr_end
, in_end
)
18307 char_u
*expr_start
;
18312 char_u
*retval
= NULL
;
18313 char_u
*temp_result
;
18314 char_u
*nextcmd
= NULL
;
18316 if (expr_end
== NULL
|| in_end
== NULL
)
18323 temp_result
= eval_to_string(expr_start
+ 1, &nextcmd
, FALSE
);
18324 if (temp_result
!= NULL
&& nextcmd
== NULL
)
18326 retval
= alloc((unsigned)(STRLEN(temp_result
) + (expr_start
- in_start
)
18327 + (in_end
- expr_end
) + 1));
18328 if (retval
!= NULL
)
18330 STRCPY(retval
, in_start
);
18331 STRCAT(retval
, temp_result
);
18332 STRCAT(retval
, expr_end
+ 1);
18335 vim_free(temp_result
);
18337 *in_end
= c1
; /* put char back for error messages */
18341 if (retval
!= NULL
)
18343 temp_result
= find_name_end(retval
, &expr_start
, &expr_end
, 0);
18344 if (expr_start
!= NULL
)
18346 /* Further expansion! */
18347 temp_result
= make_expanded_name(retval
, expr_start
,
18348 expr_end
, temp_result
);
18350 retval
= temp_result
;
18358 * Return TRUE if character "c" can be used in a variable or function name.
18359 * Does not include '{' or '}' for magic braces.
18365 return (ASCII_ISALNUM(c
) || c
== '_' || c
== ':' || c
== AUTOLOAD_CHAR
);
18369 * Return TRUE if character "c" can be used as the first character in a
18370 * variable or function name (excluding '{' and '}').
18376 return (ASCII_ISALPHA(c
) || c
== '_');
18380 * Set number v: variable to "val".
18383 set_vim_var_nr(idx
, val
)
18387 vimvars
[idx
].vv_nr
= val
;
18391 * Get number v: variable value.
18394 get_vim_var_nr(idx
)
18397 return vimvars
[idx
].vv_nr
;
18401 * Get string v: variable value. Uses a static buffer, can only be used once.
18404 get_vim_var_str(idx
)
18407 return get_tv_string(&vimvars
[idx
].vv_tv
);
18411 * Get List v: variable value. Caller must take care of reference count when
18415 get_vim_var_list(idx
)
18418 return vimvars
[idx
].vv_list
;
18422 * Set v:char to character "c".
18425 set_vim_var_char(c
)
18429 char_u buf
[MB_MAXBYTES
];
18436 buf
[(*mb_char2bytes
)(c
, buf
)] = NUL
;
18443 set_vim_var_string(VV_CHAR
, buf
, -1);
18447 * Set v:count to "count" and v:count1 to "count1".
18448 * When "set_prevcount" is TRUE first set v:prevcount from v:count.
18451 set_vcount(count
, count1
, set_prevcount
)
18457 vimvars
[VV_PREVCOUNT
].vv_nr
= vimvars
[VV_COUNT
].vv_nr
;
18458 vimvars
[VV_COUNT
].vv_nr
= count
;
18459 vimvars
[VV_COUNT1
].vv_nr
= count1
;
18463 * Set string v: variable to a copy of "val".
18466 set_vim_var_string(idx
, val
, len
)
18469 int len
; /* length of "val" to use or -1 (whole string) */
18471 /* Need to do this (at least) once, since we can't initialize a union.
18472 * Will always be invoked when "v:progname" is set. */
18473 vimvars
[VV_VERSION
].vv_nr
= VIM_VERSION_100
;
18475 vim_free(vimvars
[idx
].vv_str
);
18477 vimvars
[idx
].vv_str
= NULL
;
18478 else if (len
== -1)
18479 vimvars
[idx
].vv_str
= vim_strsave(val
);
18481 vimvars
[idx
].vv_str
= vim_strnsave(val
, len
);
18485 * Set List v: variable to "val".
18488 set_vim_var_list(idx
, val
)
18492 list_unref(vimvars
[idx
].vv_list
);
18493 vimvars
[idx
].vv_list
= val
;
18495 ++val
->lv_refcount
;
18499 * Set v:register if needed.
18507 if (c
== 0 || c
== ' ')
18511 /* Avoid free/alloc when the value is already right. */
18512 if (vimvars
[VV_REG
].vv_str
== NULL
|| vimvars
[VV_REG
].vv_str
[0] != c
)
18513 set_vim_var_string(VV_REG
, ®name
, 1);
18517 * Get or set v:exception. If "oldval" == NULL, return the current value.
18518 * Otherwise, restore the value to "oldval" and return NULL.
18519 * Must always be called in pairs to save and restore v:exception! Does not
18520 * take care of memory allocations.
18523 v_exception(oldval
)
18526 if (oldval
== NULL
)
18527 return vimvars
[VV_EXCEPTION
].vv_str
;
18529 vimvars
[VV_EXCEPTION
].vv_str
= oldval
;
18534 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18535 * Otherwise, restore the value to "oldval" and return NULL.
18536 * Must always be called in pairs to save and restore v:throwpoint! Does not
18537 * take care of memory allocations.
18540 v_throwpoint(oldval
)
18543 if (oldval
== NULL
)
18544 return vimvars
[VV_THROWPOINT
].vv_str
;
18546 vimvars
[VV_THROWPOINT
].vv_str
= oldval
;
18550 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18553 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18554 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18555 * Must always be called in pairs!
18558 set_cmdarg(eap
, oldarg
)
18566 oldval
= vimvars
[VV_CMDARG
].vv_str
;
18570 vimvars
[VV_CMDARG
].vv_str
= oldarg
;
18574 if (eap
->force_bin
== FORCE_BIN
)
18576 else if (eap
->force_bin
== FORCE_NOBIN
)
18581 if (eap
->read_edit
)
18584 if (eap
->force_ff
!= 0)
18585 len
+= (unsigned)STRLEN(eap
->cmd
+ eap
->force_ff
) + 6;
18587 if (eap
->force_enc
!= 0)
18588 len
+= (unsigned)STRLEN(eap
->cmd
+ eap
->force_enc
) + 7;
18589 if (eap
->bad_char
!= 0)
18590 len
+= 7 + 4; /* " ++bad=" + "keep" or "drop" */
18593 newval
= alloc(len
+ 1);
18594 if (newval
== NULL
)
18597 if (eap
->force_bin
== FORCE_BIN
)
18598 sprintf((char *)newval
, " ++bin");
18599 else if (eap
->force_bin
== FORCE_NOBIN
)
18600 sprintf((char *)newval
, " ++nobin");
18604 if (eap
->read_edit
)
18605 STRCAT(newval
, " ++edit");
18607 if (eap
->force_ff
!= 0)
18608 sprintf((char *)newval
+ STRLEN(newval
), " ++ff=%s",
18609 eap
->cmd
+ eap
->force_ff
);
18611 if (eap
->force_enc
!= 0)
18612 sprintf((char *)newval
+ STRLEN(newval
), " ++enc=%s",
18613 eap
->cmd
+ eap
->force_enc
);
18614 if (eap
->bad_char
== BAD_KEEP
)
18615 STRCPY(newval
+ STRLEN(newval
), " ++bad=keep");
18616 else if (eap
->bad_char
== BAD_DROP
)
18617 STRCPY(newval
+ STRLEN(newval
), " ++bad=drop");
18618 else if (eap
->bad_char
!= 0)
18619 sprintf((char *)newval
+ STRLEN(newval
), " ++bad=%c", eap
->bad_char
);
18621 vimvars
[VV_CMDARG
].vv_str
= newval
;
18627 * Get the value of internal variable "name".
18628 * Return OK or FAIL.
18631 get_var_tv(name
, len
, rettv
, verbose
)
18633 int len
; /* length of "name" */
18634 typval_T
*rettv
; /* NULL when only checking existence */
18635 int verbose
; /* may give error message */
18638 typval_T
*tv
= NULL
;
18643 /* truncate the name, so that we can use strcmp() */
18648 * Check for "b:changedtick".
18650 if (STRCMP(name
, "b:changedtick") == 0)
18652 atv
.v_type
= VAR_NUMBER
;
18653 atv
.vval
.v_number
= curbuf
->b_changedtick
;
18658 * Check for user-defined variables.
18662 v
= find_var(name
, NULL
);
18669 if (rettv
!= NULL
&& verbose
)
18670 EMSG2(_(e_undefvar
), name
);
18673 else if (rettv
!= NULL
)
18674 copy_tv(tv
, rettv
);
18682 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18683 * Also handle function call with Funcref variable: func(expr)
18684 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18687 handle_subscript(arg
, rettv
, evaluate
, verbose
)
18690 int evaluate
; /* do more than finding the end */
18691 int verbose
; /* give error messages */
18694 dict_T
*selfdict
= NULL
;
18701 || (**arg
== '.' && rettv
->v_type
== VAR_DICT
)
18702 || (**arg
== '(' && rettv
->v_type
== VAR_FUNC
))
18703 && !vim_iswhite(*(*arg
- 1)))
18707 /* need to copy the funcref so that we can clear rettv */
18709 rettv
->v_type
= VAR_UNKNOWN
;
18711 /* Invoke the function. Recursive! */
18712 s
= functv
.vval
.v_string
;
18713 ret
= get_func_tv(s
, (int)STRLEN(s
), rettv
, arg
,
18714 curwin
->w_cursor
.lnum
, curwin
->w_cursor
.lnum
,
18715 &len
, evaluate
, selfdict
);
18717 /* Clear the funcref afterwards, so that deleting it while
18718 * evaluating the arguments is possible (see test55). */
18721 /* Stop the expression evaluation when immediately aborting on
18722 * error, or when an interrupt occurred or an exception was thrown
18723 * but not caught. */
18730 dict_unref(selfdict
);
18733 else /* **arg == '[' || **arg == '.' */
18735 dict_unref(selfdict
);
18736 if (rettv
->v_type
== VAR_DICT
)
18738 selfdict
= rettv
->vval
.v_dict
;
18739 if (selfdict
!= NULL
)
18740 ++selfdict
->dv_refcount
;
18744 if (eval_index(arg
, rettv
, evaluate
, verbose
) == FAIL
)
18751 dict_unref(selfdict
);
18756 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18762 return (typval_T
*)alloc_clear((unsigned)sizeof(typval_T
));
18766 * Allocate memory for a variable type-value, and assign a string to it.
18767 * The string "s" must have been allocated, it is consumed.
18768 * Return NULL for out of memory, the variable otherwise.
18776 rettv
= alloc_tv();
18779 rettv
->v_type
= VAR_STRING
;
18780 rettv
->vval
.v_string
= s
;
18788 * Free the memory for a variable type-value.
18796 switch (varp
->v_type
)
18799 func_unref(varp
->vval
.v_string
);
18802 vim_free(varp
->vval
.v_string
);
18805 list_unref(varp
->vval
.v_list
);
18808 dict_unref(varp
->vval
.v_dict
);
18817 EMSG2(_(e_intern2
), "free_tv()");
18825 * Free the memory for a variable value and set the value to NULL or 0.
18833 switch (varp
->v_type
)
18836 func_unref(varp
->vval
.v_string
);
18839 vim_free(varp
->vval
.v_string
);
18840 varp
->vval
.v_string
= NULL
;
18843 list_unref(varp
->vval
.v_list
);
18844 varp
->vval
.v_list
= NULL
;
18847 dict_unref(varp
->vval
.v_dict
);
18848 varp
->vval
.v_dict
= NULL
;
18851 varp
->vval
.v_number
= 0;
18855 varp
->vval
.v_float
= 0.0;
18861 EMSG2(_(e_intern2
), "clear_tv()");
18868 * Set the value of a variable to NULL without freeing items.
18875 vim_memset(varp
, 0, sizeof(typval_T
));
18879 * Get the number value of a variable.
18880 * If it is a String variable, uses vim_str2nr().
18881 * For incompatible types, return 0.
18882 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18883 * caller of incompatible types: it sets *denote to TRUE if "denote"
18884 * is not NULL or returns -1 otherwise.
18887 get_tv_number(varp
)
18892 return get_tv_number_chk(varp
, &error
); /* return 0L on error */
18896 get_tv_number_chk(varp
, denote
)
18902 switch (varp
->v_type
)
18905 return (long)(varp
->vval
.v_number
);
18908 EMSG(_("E805: Using a Float as a Number"));
18912 EMSG(_("E703: Using a Funcref as a Number"));
18915 if (varp
->vval
.v_string
!= NULL
)
18916 vim_str2nr(varp
->vval
.v_string
, NULL
, NULL
,
18917 TRUE
, TRUE
, &n
, NULL
);
18920 EMSG(_("E745: Using a List as a Number"));
18923 EMSG(_("E728: Using a Dictionary as a Number"));
18926 EMSG2(_(e_intern2
), "get_tv_number()");
18929 if (denote
== NULL
) /* useful for values that must be unsigned */
18937 * Get the lnum from the first argument.
18938 * Also accepts ".", "$", etc., but that only works for the current buffer.
18939 * Returns -1 on error.
18942 get_tv_lnum(argvars
)
18948 lnum
= get_tv_number_chk(&argvars
[0], NULL
);
18949 if (lnum
== 0) /* no valid number, try using line() */
18951 rettv
.v_type
= VAR_NUMBER
;
18952 f_line(argvars
, &rettv
);
18953 lnum
= rettv
.vval
.v_number
;
18960 * Get the lnum from the first argument.
18961 * Also accepts "$", then "buf" is used.
18962 * Returns 0 on error.
18965 get_tv_lnum_buf(argvars
, buf
)
18969 if (argvars
[0].v_type
== VAR_STRING
18970 && argvars
[0].vval
.v_string
!= NULL
18971 && argvars
[0].vval
.v_string
[0] == '$'
18973 return buf
->b_ml
.ml_line_count
;
18974 return get_tv_number_chk(&argvars
[0], NULL
);
18978 * Get the string value of a variable.
18979 * If it is a Number variable, the number is converted into a string.
18980 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18981 * get_tv_string_buf() uses a given buffer.
18982 * If the String variable has never been set, return an empty string.
18983 * Never returns NULL;
18984 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18988 get_tv_string(varp
)
18991 static char_u mybuf
[NUMBUFLEN
];
18993 return get_tv_string_buf(varp
, mybuf
);
18997 get_tv_string_buf(varp
, buf
)
19001 char_u
*res
= get_tv_string_buf_chk(varp
, buf
);
19003 return res
!= NULL
? res
: (char_u
*)"";
19007 get_tv_string_chk(varp
)
19010 static char_u mybuf
[NUMBUFLEN
];
19012 return get_tv_string_buf_chk(varp
, mybuf
);
19016 get_tv_string_buf_chk(varp
, buf
)
19020 switch (varp
->v_type
)
19023 sprintf((char *)buf
, "%ld", (long)varp
->vval
.v_number
);
19026 EMSG(_("E729: using Funcref as a String"));
19029 EMSG(_("E730: using List as a String"));
19032 EMSG(_("E731: using Dictionary as a String"));
19036 EMSG(_("E806: using Float as a String"));
19040 if (varp
->vval
.v_string
!= NULL
)
19041 return varp
->vval
.v_string
;
19042 return (char_u
*)"";
19044 EMSG2(_(e_intern2
), "get_tv_string_buf()");
19051 * Find variable "name" in the list of variables.
19052 * Return a pointer to it if found, NULL if not found.
19053 * Careful: "a:0" variables don't have a name.
19054 * When "htp" is not NULL we are writing to the variable, set "htp" to the
19057 static dictitem_T
*
19058 find_var(name
, htp
)
19065 ht
= find_var_ht(name
, &varname
);
19070 return find_var_in_ht(ht
, varname
, htp
!= NULL
);
19074 * Find variable "varname" in hashtab "ht".
19075 * Returns NULL if not found.
19077 static dictitem_T
*
19078 find_var_in_ht(ht
, varname
, writing
)
19085 if (*varname
== NUL
)
19087 /* Must be something like "s:", otherwise "ht" would be NULL. */
19088 switch (varname
[-2])
19090 case 's': return &SCRIPT_SV(current_SID
)->sv_var
;
19091 case 'g': return &globvars_var
;
19092 case 'v': return &vimvars_var
;
19093 case 'b': return &curbuf
->b_bufvar
;
19094 case 'w': return &curwin
->w_winvar
;
19095 #ifdef FEAT_WINDOWS
19096 case 't': return &curtab
->tp_winvar
;
19098 case 'l': return current_funccal
== NULL
19099 ? NULL
: ¤t_funccal
->l_vars_var
;
19100 case 'a': return current_funccal
== NULL
19101 ? NULL
: ¤t_funccal
->l_avars_var
;
19106 hi
= hash_find(ht
, varname
);
19107 if (HASHITEM_EMPTY(hi
))
19109 /* For global variables we may try auto-loading the script. If it
19110 * worked find the variable again. Don't auto-load a script if it was
19111 * loaded already, otherwise it would be loaded every time when
19112 * checking if a function name is a Funcref variable. */
19113 if (ht
== &globvarht
&& !writing
19114 && script_autoload(varname
, FALSE
) && !aborting())
19115 hi
= hash_find(ht
, varname
);
19116 if (HASHITEM_EMPTY(hi
))
19123 * Find the hashtab used for a variable name.
19124 * Set "varname" to the start of name without ':'.
19127 find_var_ht(name
, varname
)
19133 if (name
[1] != ':')
19135 /* The name must not start with a colon or #. */
19136 if (name
[0] == ':' || name
[0] == AUTOLOAD_CHAR
)
19140 /* "version" is "v:version" in all scopes */
19141 hi
= hash_find(&compat_hashtab
, name
);
19142 if (!HASHITEM_EMPTY(hi
))
19143 return &compat_hashtab
;
19145 if (current_funccal
== NULL
)
19146 return &globvarht
; /* global variable */
19147 return ¤t_funccal
->l_vars
.dv_hashtab
; /* l: variable */
19149 *varname
= name
+ 2;
19150 if (*name
== 'g') /* global variable */
19152 /* There must be no ':' or '#' in the rest of the name, unless g: is used
19154 if (vim_strchr(name
+ 2, ':') != NULL
19155 || vim_strchr(name
+ 2, AUTOLOAD_CHAR
) != NULL
)
19157 if (*name
== 'b') /* buffer variable */
19158 return &curbuf
->b_vars
.dv_hashtab
;
19159 if (*name
== 'w') /* window variable */
19160 return &curwin
->w_vars
.dv_hashtab
;
19161 #ifdef FEAT_WINDOWS
19162 if (*name
== 't') /* tab page variable */
19163 return &curtab
->tp_vars
.dv_hashtab
;
19165 if (*name
== 'v') /* v: variable */
19167 if (*name
== 'a' && current_funccal
!= NULL
) /* function argument */
19168 return ¤t_funccal
->l_avars
.dv_hashtab
;
19169 if (*name
== 'l' && current_funccal
!= NULL
) /* local function variable */
19170 return ¤t_funccal
->l_vars
.dv_hashtab
;
19171 if (*name
== 's' /* script variable */
19172 && current_SID
> 0 && current_SID
<= ga_scripts
.ga_len
)
19173 return &SCRIPT_VARS(current_SID
);
19178 * Get the string value of a (global/local) variable.
19179 * Returns NULL when it doesn't exist.
19182 get_var_value(name
)
19187 v
= find_var(name
, NULL
);
19190 return get_tv_string(&v
->di_tv
);
19194 * Allocate a new hashtab for a sourced script. It will be used while
19195 * sourcing this script and when executing functions defined in the script.
19198 new_script_vars(id
)
19205 if (ga_grow(&ga_scripts
, (int)(id
- ga_scripts
.ga_len
)) == OK
)
19207 /* Re-allocating ga_data means that an ht_array pointing to
19208 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
19209 * at its init value. Also reset "v_dict", it's always the same. */
19210 for (i
= 1; i
<= ga_scripts
.ga_len
; ++i
)
19212 ht
= &SCRIPT_VARS(i
);
19213 if (ht
->ht_mask
== HT_INIT_SIZE
- 1)
19214 ht
->ht_array
= ht
->ht_smallarray
;
19216 sv
->sv_var
.di_tv
.vval
.v_dict
= &sv
->sv_dict
;
19219 while (ga_scripts
.ga_len
< id
)
19221 sv
= SCRIPT_SV(ga_scripts
.ga_len
+ 1) =
19222 (scriptvar_T
*)alloc_clear(sizeof(scriptvar_T
));
19223 init_var_dict(&sv
->sv_dict
, &sv
->sv_var
);
19224 ++ga_scripts
.ga_len
;
19230 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
19234 init_var_dict(dict
, dict_var
)
19236 dictitem_T
*dict_var
;
19238 hash_init(&dict
->dv_hashtab
);
19239 dict
->dv_refcount
= DO_NOT_FREE_CNT
;
19240 dict
->dv_copyID
= 0;
19241 dict_var
->di_tv
.vval
.v_dict
= dict
;
19242 dict_var
->di_tv
.v_type
= VAR_DICT
;
19243 dict_var
->di_tv
.v_lock
= VAR_FIXED
;
19244 dict_var
->di_flags
= DI_FLAGS_RO
| DI_FLAGS_FIX
;
19245 dict_var
->di_key
[0] = NUL
;
19249 * Clean up a list of internal variables.
19250 * Frees all allocated variables and the value they contain.
19251 * Clears hashtab "ht", does not free it.
19257 vars_clear_ext(ht
, TRUE
);
19261 * Like vars_clear(), but only free the value if "free_val" is TRUE.
19264 vars_clear_ext(ht
, free_val
)
19273 todo
= (int)ht
->ht_used
;
19274 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
19276 if (!HASHITEM_EMPTY(hi
))
19280 /* Free the variable. Don't remove it from the hashtab,
19281 * ht_array might change then. hash_clear() takes care of it
19285 clear_tv(&v
->di_tv
);
19286 if ((v
->di_flags
& DI_FLAGS_FIX
) == 0)
19295 * Delete a variable from hashtab "ht" at item "hi".
19296 * Clear the variable value and free the dictitem.
19303 dictitem_T
*di
= HI2DI(hi
);
19305 hash_remove(ht
, hi
);
19306 clear_tv(&di
->di_tv
);
19311 * List the value of one internal variable.
19314 list_one_var(v
, prefix
, first
)
19321 char_u numbuf
[NUMBUFLEN
];
19323 current_copyID
+= COPYID_INC
;
19324 s
= echo_string(&v
->di_tv
, &tofree
, numbuf
, current_copyID
);
19325 list_one_var_a(prefix
, v
->di_key
, v
->di_tv
.v_type
,
19326 s
== NULL
? (char_u
*)"" : s
, first
);
19331 list_one_var_a(prefix
, name
, type
, string
, first
)
19336 int *first
; /* when TRUE clear rest of screen and set to FALSE */
19338 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
19341 if (name
!= NULL
) /* "a:" vars don't have a name stored */
19345 if (type
== VAR_NUMBER
)
19347 else if (type
== VAR_FUNC
)
19349 else if (type
== VAR_LIST
)
19352 if (*string
== '[')
19355 else if (type
== VAR_DICT
)
19358 if (*string
== '{')
19364 msg_outtrans(string
);
19366 if (type
== VAR_FUNC
)
19367 msg_puts((char_u
*)"()");
19376 * Set variable "name" to value in "tv".
19377 * If the variable already exists, the value is updated.
19378 * Otherwise the variable is created.
19381 set_var(name
, tv
, copy
)
19384 int copy
; /* make copy of value in "tv" */
19391 ht
= find_var_ht(name
, &varname
);
19392 if (ht
== NULL
|| *varname
== NUL
)
19394 EMSG2(_(e_illvar
), name
);
19397 v
= find_var_in_ht(ht
, varname
, TRUE
);
19399 if (tv
->v_type
== VAR_FUNC
)
19401 if (!(vim_strchr((char_u
*)"wbs", name
[0]) != NULL
&& name
[1] == ':')
19402 && !ASCII_ISUPPER((name
[0] != NUL
&& name
[1] == ':')
19403 ? name
[2] : name
[0]))
19405 EMSG2(_("E704: Funcref variable name must start with a capital: %s"), name
);
19408 /* Don't allow hiding a function. When "v" is not NULL we migth be
19409 * assigning another function to the same var, the type is checked
19411 if (v
== NULL
&& function_exists(name
))
19413 EMSG2(_("E705: Variable name conflicts with existing function: %s"),
19421 /* existing variable, need to clear the value */
19422 if (var_check_ro(v
->di_flags
, name
)
19423 || tv_check_lock(v
->di_tv
.v_lock
, name
))
19425 if (v
->di_tv
.v_type
!= tv
->v_type
19426 && !((v
->di_tv
.v_type
== VAR_STRING
19427 || v
->di_tv
.v_type
== VAR_NUMBER
)
19428 && (tv
->v_type
== VAR_STRING
19429 || tv
->v_type
== VAR_NUMBER
))
19431 && !((v
->di_tv
.v_type
== VAR_NUMBER
19432 || v
->di_tv
.v_type
== VAR_FLOAT
)
19433 && (tv
->v_type
== VAR_NUMBER
19434 || tv
->v_type
== VAR_FLOAT
))
19438 EMSG2(_("E706: Variable type mismatch for: %s"), name
);
19443 * Handle setting internal v: variables separately: we don't change
19446 if (ht
== &vimvarht
)
19448 if (v
->di_tv
.v_type
== VAR_STRING
)
19450 vim_free(v
->di_tv
.vval
.v_string
);
19451 if (copy
|| tv
->v_type
!= VAR_STRING
)
19452 v
->di_tv
.vval
.v_string
= vim_strsave(get_tv_string(tv
));
19455 /* Take over the string to avoid an extra alloc/free. */
19456 v
->di_tv
.vval
.v_string
= tv
->vval
.v_string
;
19457 tv
->vval
.v_string
= NULL
;
19460 else if (v
->di_tv
.v_type
!= VAR_NUMBER
)
19461 EMSG2(_(e_intern2
), "set_var()");
19464 v
->di_tv
.vval
.v_number
= get_tv_number(tv
);
19465 if (STRCMP(varname
, "searchforward") == 0)
19466 set_search_direction(v
->di_tv
.vval
.v_number
? '/' : '?');
19471 clear_tv(&v
->di_tv
);
19473 else /* add a new variable */
19475 /* Can't add "v:" variable. */
19476 if (ht
== &vimvarht
)
19478 EMSG2(_(e_illvar
), name
);
19482 /* Make sure the variable name is valid. */
19483 for (p
= varname
; *p
!= NUL
; ++p
)
19484 if (!eval_isnamec1(*p
) && (p
== varname
|| !VIM_ISDIGIT(*p
))
19485 && *p
!= AUTOLOAD_CHAR
)
19487 EMSG2(_(e_illvar
), varname
);
19491 v
= (dictitem_T
*)alloc((unsigned)(sizeof(dictitem_T
)
19492 + STRLEN(varname
)));
19495 STRCPY(v
->di_key
, varname
);
19496 if (hash_add(ht
, DI2HIKEY(v
)) == FAIL
)
19504 if (copy
|| tv
->v_type
== VAR_NUMBER
|| tv
->v_type
== VAR_FLOAT
)
19505 copy_tv(tv
, &v
->di_tv
);
19509 v
->di_tv
.v_lock
= 0;
19515 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19516 * Also give an error message.
19519 var_check_ro(flags
, name
)
19523 if (flags
& DI_FLAGS_RO
)
19525 EMSG2(_(e_readonlyvar
), name
);
19528 if ((flags
& DI_FLAGS_RO_SBX
) && sandbox
)
19530 EMSG2(_(e_readonlysbx
), name
);
19537 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19538 * Also give an error message.
19541 var_check_fixed(flags
, name
)
19545 if (flags
& DI_FLAGS_FIX
)
19547 EMSG2(_("E795: Cannot delete variable %s"), name
);
19554 * Return TRUE if typeval "tv" is set to be locked (immutable).
19555 * Also give an error message, using "name".
19558 tv_check_lock(lock
, name
)
19562 if (lock
& VAR_LOCKED
)
19564 EMSG2(_("E741: Value is locked: %s"),
19565 name
== NULL
? (char_u
*)_("Unknown") : name
);
19568 if (lock
& VAR_FIXED
)
19570 EMSG2(_("E742: Cannot change value of %s"),
19571 name
== NULL
? (char_u
*)_("Unknown") : name
);
19578 * Copy the values from typval_T "from" to typval_T "to".
19579 * When needed allocates string or increases reference count.
19580 * Does not make a copy of a list or dict but copies the reference!
19581 * It is OK for "from" and "to" to point to the same item. This is used to
19582 * make a copy later.
19589 to
->v_type
= from
->v_type
;
19591 switch (from
->v_type
)
19594 to
->vval
.v_number
= from
->vval
.v_number
;
19598 to
->vval
.v_float
= from
->vval
.v_float
;
19603 if (from
->vval
.v_string
== NULL
)
19604 to
->vval
.v_string
= NULL
;
19607 to
->vval
.v_string
= vim_strsave(from
->vval
.v_string
);
19608 if (from
->v_type
== VAR_FUNC
)
19609 func_ref(to
->vval
.v_string
);
19613 if (from
->vval
.v_list
== NULL
)
19614 to
->vval
.v_list
= NULL
;
19617 to
->vval
.v_list
= from
->vval
.v_list
;
19618 ++to
->vval
.v_list
->lv_refcount
;
19622 if (from
->vval
.v_dict
== NULL
)
19623 to
->vval
.v_dict
= NULL
;
19626 to
->vval
.v_dict
= from
->vval
.v_dict
;
19627 ++to
->vval
.v_dict
->dv_refcount
;
19631 EMSG2(_(e_intern2
), "copy_tv()");
19637 * Make a copy of an item.
19638 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19639 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19640 * reference to an already copied list/dict can be used.
19641 * Returns FAIL or OK.
19644 item_copy(from
, to
, deep
, copyID
)
19650 static int recurse
= 0;
19653 if (recurse
>= DICT_MAXNEST
)
19655 EMSG(_("E698: variable nested too deep for making a copy"));
19660 switch (from
->v_type
)
19671 to
->v_type
= VAR_LIST
;
19673 if (from
->vval
.v_list
== NULL
)
19674 to
->vval
.v_list
= NULL
;
19675 else if (copyID
!= 0 && from
->vval
.v_list
->lv_copyID
== copyID
)
19677 /* use the copy made earlier */
19678 to
->vval
.v_list
= from
->vval
.v_list
->lv_copylist
;
19679 ++to
->vval
.v_list
->lv_refcount
;
19682 to
->vval
.v_list
= list_copy(from
->vval
.v_list
, deep
, copyID
);
19683 if (to
->vval
.v_list
== NULL
)
19687 to
->v_type
= VAR_DICT
;
19689 if (from
->vval
.v_dict
== NULL
)
19690 to
->vval
.v_dict
= NULL
;
19691 else if (copyID
!= 0 && from
->vval
.v_dict
->dv_copyID
== copyID
)
19693 /* use the copy made earlier */
19694 to
->vval
.v_dict
= from
->vval
.v_dict
->dv_copydict
;
19695 ++to
->vval
.v_dict
->dv_refcount
;
19698 to
->vval
.v_dict
= dict_copy(from
->vval
.v_dict
, deep
, copyID
);
19699 if (to
->vval
.v_dict
== NULL
)
19703 EMSG2(_(e_intern2
), "item_copy()");
19711 * ":echo expr1 ..." print each argument separated with a space, add a
19712 * newline at the end.
19713 * ":echon expr1 ..." print each argument plain.
19719 char_u
*arg
= eap
->arg
;
19723 int needclr
= TRUE
;
19724 int atstart
= TRUE
;
19725 char_u numbuf
[NUMBUFLEN
];
19729 while (*arg
!= NUL
&& *arg
!= '|' && *arg
!= '\n' && !got_int
)
19731 /* If eval1() causes an error message the text from the command may
19732 * still need to be cleared. E.g., "echo 22,44". */
19733 need_clr_eos
= needclr
;
19736 if (eval1(&arg
, &rettv
, !eap
->skip
) == FAIL
)
19739 * Report the invalid expression unless the expression evaluation
19740 * has been cancelled due to an aborting error, an interrupt, or an
19744 EMSG2(_(e_invexpr2
), p
);
19745 need_clr_eos
= FALSE
;
19748 need_clr_eos
= FALSE
;
19755 /* Call msg_start() after eval1(), evaluating the expression
19756 * may cause a message to appear. */
19757 if (eap
->cmdidx
== CMD_echo
)
19760 else if (eap
->cmdidx
== CMD_echo
)
19761 msg_puts_attr((char_u
*)" ", echo_attr
);
19762 current_copyID
+= COPYID_INC
;
19763 p
= echo_string(&rettv
, &tofree
, numbuf
, current_copyID
);
19765 for ( ; *p
!= NUL
&& !got_int
; ++p
)
19767 if (*p
== '\n' || *p
== '\r' || *p
== TAB
)
19769 if (*p
!= TAB
&& needclr
)
19771 /* remove any text still there from the command */
19775 msg_putchar_attr(*p
, echo_attr
);
19782 int i
= (*mb_ptr2len
)(p
);
19784 (void)msg_outtrans_len_attr(p
, i
, echo_attr
);
19789 (void)msg_outtrans_len_attr(p
, 1, echo_attr
);
19795 arg
= skipwhite(arg
);
19797 eap
->nextcmd
= check_nextcmd(arg
);
19803 /* remove text that may still be there from the command */
19806 if (eap
->cmdidx
== CMD_echo
)
19812 * ":echohl {name}".
19820 id
= syn_name2id(eap
->arg
);
19824 echo_attr
= syn_id2attr(id
);
19828 * ":execute expr1 ..." execute the result of an expression.
19829 * ":echomsg expr1 ..." Print a message
19830 * ":echoerr expr1 ..." Print an error
19831 * Each gets spaces around each argument and a newline at the end for
19838 char_u
*arg
= eap
->arg
;
19846 ga_init2(&ga
, 1, 80);
19850 while (*arg
!= NUL
&& *arg
!= '|' && *arg
!= '\n')
19853 if (eval1(&arg
, &rettv
, !eap
->skip
) == FAIL
)
19856 * Report the invalid expression unless the expression evaluation
19857 * has been cancelled due to an aborting error, an interrupt, or an
19861 EMSG2(_(e_invexpr2
), p
);
19868 p
= get_tv_string(&rettv
);
19869 len
= (int)STRLEN(p
);
19870 if (ga_grow(&ga
, len
+ 2) == FAIL
)
19877 ((char_u
*)(ga
.ga_data
))[ga
.ga_len
++] = ' ';
19878 STRCPY((char_u
*)(ga
.ga_data
) + ga
.ga_len
, p
);
19883 arg
= skipwhite(arg
);
19886 if (ret
!= FAIL
&& ga
.ga_data
!= NULL
)
19888 if (eap
->cmdidx
== CMD_echomsg
)
19890 MSG_ATTR(ga
.ga_data
, echo_attr
);
19893 else if (eap
->cmdidx
== CMD_echoerr
)
19895 /* We don't want to abort following commands, restore did_emsg. */
19896 save_did_emsg
= did_emsg
;
19897 EMSG((char_u
*)ga
.ga_data
);
19899 did_emsg
= save_did_emsg
;
19901 else if (eap
->cmdidx
== CMD_execute
)
19902 do_cmdline((char_u
*)ga
.ga_data
,
19903 eap
->getline
, eap
->cookie
, DOCMD_NOWAIT
|DOCMD_VERBOSE
);
19911 eap
->nextcmd
= check_nextcmd(arg
);
19915 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19916 * "arg" points to the "&" or '+' when called, to "option" when returning.
19917 * Returns NULL when no option name found. Otherwise pointer to the char
19918 * after the option name.
19921 find_option_end(arg
, opt_flags
)
19928 if (*p
== 'g' && p
[1] == ':')
19930 *opt_flags
= OPT_GLOBAL
;
19933 else if (*p
== 'l' && p
[1] == ':')
19935 *opt_flags
= OPT_LOCAL
;
19941 if (!ASCII_ISALPHA(*p
))
19945 if (p
[0] == 't' && p
[1] == '_' && p
[2] != NUL
&& p
[3] != NUL
)
19946 p
+= 4; /* termcap option */
19948 while (ASCII_ISALPHA(*p
))
19963 int saved_did_emsg
;
19964 char_u
*name
= NULL
;
19967 char_u
*line_arg
= NULL
;
19970 int varargs
= FALSE
;
19971 int mustend
= FALSE
;
19976 char_u
*skip_until
= NULL
;
19979 static int func_nr
= 0; /* number for nameless function */
19984 int sourcing_lnum_off
;
19987 * ":function" without argument: list functions.
19989 if (ends_excmd(*eap
->arg
))
19993 todo
= (int)func_hashtab
.ht_used
;
19994 for (hi
= func_hashtab
.ht_array
; todo
> 0 && !got_int
; ++hi
)
19996 if (!HASHITEM_EMPTY(hi
))
20000 if (!isdigit(*fp
->uf_name
))
20001 list_func_head(fp
, FALSE
);
20005 eap
->nextcmd
= check_nextcmd(eap
->arg
);
20010 * ":function /pat": list functions matching pattern.
20012 if (*eap
->arg
== '/')
20014 p
= skip_regexp(eap
->arg
+ 1, '/', TRUE
, NULL
);
20017 regmatch_T regmatch
;
20021 regmatch
.regprog
= vim_regcomp(eap
->arg
+ 1, RE_MAGIC
);
20023 if (regmatch
.regprog
!= NULL
)
20025 regmatch
.rm_ic
= p_ic
;
20027 todo
= (int)func_hashtab
.ht_used
;
20028 for (hi
= func_hashtab
.ht_array
; todo
> 0 && !got_int
; ++hi
)
20030 if (!HASHITEM_EMPTY(hi
))
20034 if (!isdigit(*fp
->uf_name
)
20035 && vim_regexec(®match
, fp
->uf_name
, 0))
20036 list_func_head(fp
, FALSE
);
20039 vim_free(regmatch
.regprog
);
20044 eap
->nextcmd
= check_nextcmd(p
);
20049 * Get the function name. There are these situations:
20050 * func normal function name
20051 * "name" == func, "fudi.fd_dict" == NULL
20052 * dict.func new dictionary entry
20053 * "name" == NULL, "fudi.fd_dict" set,
20054 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
20055 * dict.func existing dict entry with a Funcref
20056 * "name" == func, "fudi.fd_dict" set,
20057 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
20058 * dict.func existing dict entry that's not a Funcref
20059 * "name" == NULL, "fudi.fd_dict" set,
20060 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
20063 name
= trans_function_name(&p
, eap
->skip
, 0, &fudi
);
20064 paren
= (vim_strchr(p
, '(') != NULL
);
20065 if (name
== NULL
&& (fudi
.fd_dict
== NULL
|| !paren
) && !eap
->skip
)
20068 * Return on an invalid expression in braces, unless the expression
20069 * evaluation has been cancelled due to an aborting error, an
20070 * interrupt, or an exception.
20074 if (!eap
->skip
&& fudi
.fd_newkey
!= NULL
)
20075 EMSG2(_(e_dictkey
), fudi
.fd_newkey
);
20076 vim_free(fudi
.fd_newkey
);
20083 /* An error in a function call during evaluation of an expression in magic
20084 * braces should not cause the function not to be defined. */
20085 saved_did_emsg
= did_emsg
;
20089 * ":function func" with only function name: list function.
20093 if (!ends_excmd(*skipwhite(p
)))
20095 EMSG(_(e_trailing
));
20098 eap
->nextcmd
= check_nextcmd(p
);
20099 if (eap
->nextcmd
!= NULL
)
20101 if (!eap
->skip
&& !got_int
)
20103 fp
= find_func(name
);
20106 list_func_head(fp
, TRUE
);
20107 for (j
= 0; j
< fp
->uf_lines
.ga_len
&& !got_int
; ++j
)
20109 if (FUNCLINE(fp
, j
) == NULL
)
20112 msg_outnum((long)(j
+ 1));
20117 msg_prt_line(FUNCLINE(fp
, j
), FALSE
);
20118 out_flush(); /* show a line at a time */
20124 msg_puts((char_u
*)" endfunction");
20128 emsg_funcname(N_("E123: Undefined function: %s"), name
);
20134 * ":function name(arg1, arg2)" Define function.
20141 EMSG2(_("E124: Missing '(': %s"), eap
->arg
);
20144 /* attempt to continue by skipping some text */
20145 if (vim_strchr(p
, '(') != NULL
)
20146 p
= vim_strchr(p
, '(');
20148 p
= skipwhite(p
+ 1);
20150 ga_init2(&newargs
, (int)sizeof(char_u
*), 3);
20151 ga_init2(&newlines
, (int)sizeof(char_u
*), 3);
20155 /* Check the name of the function. Unless it's a dictionary function
20156 * (that we are overwriting). */
20160 arg
= fudi
.fd_newkey
;
20161 if (arg
!= NULL
&& (fudi
.fd_di
== NULL
20162 || fudi
.fd_di
->di_tv
.v_type
!= VAR_FUNC
))
20164 if (*arg
== K_SPECIAL
)
20168 while (arg
[j
] != NUL
&& (j
== 0 ? eval_isnamec1(arg
[j
])
20169 : eval_isnamec(arg
[j
])))
20172 emsg_funcname((char *)e_invarg2
, arg
);
20177 * Isolate the arguments: "arg1, arg2, ...)"
20181 if (p
[0] == '.' && p
[1] == '.' && p
[2] == '.')
20190 while (ASCII_ISALNUM(*p
) || *p
== '_')
20192 if (arg
== p
|| isdigit(*arg
)
20193 || (p
- arg
== 9 && STRNCMP(arg
, "firstline", 9) == 0)
20194 || (p
- arg
== 8 && STRNCMP(arg
, "lastline", 8) == 0))
20197 EMSG2(_("E125: Illegal argument: %s"), arg
);
20200 if (ga_grow(&newargs
, 1) == FAIL
)
20204 arg
= vim_strsave(arg
);
20207 ((char_u
**)(newargs
.ga_data
))[newargs
.ga_len
] = arg
;
20216 if (mustend
&& *p
!= ')')
20219 EMSG2(_(e_invarg2
), eap
->arg
);
20223 ++p
; /* skip the ')' */
20225 /* find extra arguments "range", "dict" and "abort" */
20229 if (STRNCMP(p
, "range", 5) == 0)
20234 else if (STRNCMP(p
, "dict", 4) == 0)
20239 else if (STRNCMP(p
, "abort", 5) == 0)
20248 /* When there is a line break use what follows for the function body.
20249 * Makes 'exe "func Test()\n...\nendfunc"' work. */
20252 else if (*p
!= NUL
&& *p
!= '"' && !eap
->skip
&& !did_emsg
)
20253 EMSG(_(e_trailing
));
20256 * Read the body of the function, until ":endfunction" is found.
20260 /* Check if the function already exists, don't let the user type the
20261 * whole function before telling him it doesn't work! For a script we
20262 * need to skip the body to be able to find what follows. */
20263 if (!eap
->skip
&& !eap
->forceit
)
20265 if (fudi
.fd_dict
!= NULL
&& fudi
.fd_newkey
== NULL
)
20266 EMSG(_(e_funcdict
));
20267 else if (name
!= NULL
&& find_func(name
) != NULL
)
20268 emsg_funcname(e_funcexts
, name
);
20271 if (!eap
->skip
&& did_emsg
)
20274 msg_putchar('\n'); /* don't overwrite the function name */
20275 cmdline_row
= msg_row
;
20283 need_wait_return
= FALSE
;
20284 sourcing_lnum_off
= sourcing_lnum
;
20286 if (line_arg
!= NULL
)
20288 /* Use eap->arg, split up in parts by line breaks. */
20289 theline
= line_arg
;
20290 p
= vim_strchr(theline
, '\n');
20292 line_arg
+= STRLEN(line_arg
);
20299 else if (eap
->getline
== NULL
)
20300 theline
= getcmdline(':', 0L, indent
);
20302 theline
= eap
->getline(':', eap
->cookie
, indent
);
20304 lines_left
= Rows
- 1;
20305 if (theline
== NULL
)
20307 EMSG(_("E126: Missing :endfunction"));
20311 /* Detect line continuation: sourcing_lnum increased more than one. */
20312 if (sourcing_lnum
> sourcing_lnum_off
+ 1)
20313 sourcing_lnum_off
= sourcing_lnum
- sourcing_lnum_off
- 1;
20315 sourcing_lnum_off
= 0;
20317 if (skip_until
!= NULL
)
20319 /* between ":append" and "." and between ":python <<EOF" and "EOF"
20320 * don't check for ":endfunc". */
20321 if (STRCMP(theline
, skip_until
) == 0)
20323 vim_free(skip_until
);
20329 /* skip ':' and blanks*/
20330 for (p
= theline
; vim_iswhite(*p
) || *p
== ':'; ++p
)
20333 /* Check for "endfunction". */
20334 if (checkforcmd(&p
, "endfunction", 4) && nesting
-- == 0)
20336 if (line_arg
== NULL
)
20341 /* Increase indent inside "if", "while", "for" and "try", decrease
20343 if (indent
> 2 && STRNCMP(p
, "end", 3) == 0)
20345 else if (STRNCMP(p
, "if", 2) == 0
20346 || STRNCMP(p
, "wh", 2) == 0
20347 || STRNCMP(p
, "for", 3) == 0
20348 || STRNCMP(p
, "try", 3) == 0)
20351 /* Check for defining a function inside this function. */
20352 if (checkforcmd(&p
, "function", 2))
20355 p
= skipwhite(p
+ 1);
20356 p
+= eval_fname_script(p
);
20357 if (ASCII_ISALPHA(*p
))
20359 vim_free(trans_function_name(&p
, TRUE
, 0, NULL
));
20360 if (*skipwhite(p
) == '(')
20368 /* Check for ":append" or ":insert". */
20369 p
= skip_range(p
, NULL
);
20370 if ((p
[0] == 'a' && (!ASCII_ISALPHA(p
[1]) || p
[1] == 'p'))
20372 && (!ASCII_ISALPHA(p
[1]) || (p
[1] == 'n'
20373 && (!ASCII_ISALPHA(p
[2]) || (p
[2] == 's'))))))
20374 skip_until
= vim_strsave((char_u
*)".");
20376 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
20377 arg
= skipwhite(skiptowhite(p
));
20378 if (arg
[0] == '<' && arg
[1] =='<'
20379 && ((p
[0] == 'p' && p
[1] == 'y'
20380 && (!ASCII_ISALPHA(p
[2]) || p
[2] == 't'))
20381 || (p
[0] == 'p' && p
[1] == 'e'
20382 && (!ASCII_ISALPHA(p
[2]) || p
[2] == 'r'))
20383 || (p
[0] == 't' && p
[1] == 'c'
20384 && (!ASCII_ISALPHA(p
[2]) || p
[2] == 'l'))
20385 || (p
[0] == 'r' && p
[1] == 'u' && p
[2] == 'b'
20386 && (!ASCII_ISALPHA(p
[3]) || p
[3] == 'y'))
20387 || (p
[0] == 'm' && p
[1] == 'z'
20388 && (!ASCII_ISALPHA(p
[2]) || p
[2] == 's'))
20391 /* ":python <<" continues until a dot, like ":append" */
20392 p
= skipwhite(arg
+ 2);
20394 skip_until
= vim_strsave((char_u
*)".");
20396 skip_until
= vim_strsave(p
);
20400 /* Add the line to the function. */
20401 if (ga_grow(&newlines
, 1 + sourcing_lnum_off
) == FAIL
)
20403 if (line_arg
== NULL
)
20408 /* Copy the line to newly allocated memory. get_one_sourceline()
20409 * allocates 250 bytes per line, this saves 80% on average. The cost
20410 * is an extra alloc/free. */
20411 p
= vim_strsave(theline
);
20414 if (line_arg
== NULL
)
20419 ((char_u
**)(newlines
.ga_data
))[newlines
.ga_len
++] = theline
;
20421 /* Add NULL lines for continuation lines, so that the line count is
20422 * equal to the index in the growarray. */
20423 while (sourcing_lnum_off
-- > 0)
20424 ((char_u
**)(newlines
.ga_data
))[newlines
.ga_len
++] = NULL
;
20426 /* Check for end of eap->arg. */
20427 if (line_arg
!= NULL
&& *line_arg
== NUL
)
20431 /* Don't define the function when skipping commands or when an error was
20433 if (eap
->skip
|| did_emsg
)
20437 * If there are no errors, add the function
20439 if (fudi
.fd_dict
== NULL
)
20441 v
= find_var(name
, &ht
);
20442 if (v
!= NULL
&& v
->di_tv
.v_type
== VAR_FUNC
)
20444 emsg_funcname(N_("E707: Function name conflicts with variable: %s"),
20449 fp
= find_func(name
);
20454 emsg_funcname(e_funcexts
, name
);
20457 if (fp
->uf_calls
> 0)
20459 emsg_funcname(N_("E127: Cannot redefine function %s: It is in use"),
20463 /* redefine existing function */
20464 ga_clear_strings(&(fp
->uf_args
));
20465 ga_clear_strings(&(fp
->uf_lines
));
20475 if (fudi
.fd_newkey
== NULL
&& !eap
->forceit
)
20477 EMSG(_(e_funcdict
));
20480 if (fudi
.fd_di
== NULL
)
20482 /* Can't add a function to a locked dictionary */
20483 if (tv_check_lock(fudi
.fd_dict
->dv_lock
, eap
->arg
))
20486 /* Can't change an existing function if it is locked */
20487 else if (tv_check_lock(fudi
.fd_di
->di_tv
.v_lock
, eap
->arg
))
20490 /* Give the function a sequential number. Can only be used with a
20493 sprintf(numbuf
, "%d", ++func_nr
);
20494 name
= vim_strsave((char_u
*)numbuf
);
20501 if (fudi
.fd_dict
== NULL
&& vim_strchr(name
, AUTOLOAD_CHAR
) != NULL
)
20504 char_u
*scriptname
;
20506 /* Check that the autoload name matches the script name. */
20508 if (sourcing_name
!= NULL
)
20510 scriptname
= autoload_name(name
);
20511 if (scriptname
!= NULL
)
20513 p
= vim_strchr(scriptname
, '/');
20514 plen
= (int)STRLEN(p
);
20515 slen
= (int)STRLEN(sourcing_name
);
20516 if (slen
> plen
&& fnamecmp(p
,
20517 sourcing_name
+ slen
- plen
) == 0)
20519 vim_free(scriptname
);
20524 EMSG2(_("E746: Function name does not match script file name: %s"), name
);
20529 fp
= (ufunc_T
*)alloc((unsigned)(sizeof(ufunc_T
) + STRLEN(name
)));
20533 if (fudi
.fd_dict
!= NULL
)
20535 if (fudi
.fd_di
== NULL
)
20537 /* add new dict entry */
20538 fudi
.fd_di
= dictitem_alloc(fudi
.fd_newkey
);
20539 if (fudi
.fd_di
== NULL
)
20544 if (dict_add(fudi
.fd_dict
, fudi
.fd_di
) == FAIL
)
20546 vim_free(fudi
.fd_di
);
20552 /* overwrite existing dict entry */
20553 clear_tv(&fudi
.fd_di
->di_tv
);
20554 fudi
.fd_di
->di_tv
.v_type
= VAR_FUNC
;
20555 fudi
.fd_di
->di_tv
.v_lock
= 0;
20556 fudi
.fd_di
->di_tv
.vval
.v_string
= vim_strsave(name
);
20557 fp
->uf_refcount
= 1;
20559 /* behave like "dict" was used */
20563 /* insert the new function in the function list */
20564 STRCPY(fp
->uf_name
, name
);
20565 hash_add(&func_hashtab
, UF2HIKEY(fp
));
20567 fp
->uf_args
= newargs
;
20568 fp
->uf_lines
= newlines
;
20569 #ifdef FEAT_PROFILE
20570 fp
->uf_tml_count
= NULL
;
20571 fp
->uf_tml_total
= NULL
;
20572 fp
->uf_tml_self
= NULL
;
20573 fp
->uf_profiling
= FALSE
;
20574 if (prof_def_func())
20575 func_do_profile(fp
);
20577 fp
->uf_varargs
= varargs
;
20578 fp
->uf_flags
= flags
;
20580 fp
->uf_script_ID
= current_SID
;
20584 ga_clear_strings(&newargs
);
20585 ga_clear_strings(&newlines
);
20587 vim_free(skip_until
);
20588 vim_free(fudi
.fd_newkey
);
20590 did_emsg
|= saved_did_emsg
;
20594 * Get a function name, translating "<SID>" and "<SNR>".
20595 * Also handles a Funcref in a List or Dictionary.
20596 * Returns the function name in allocated memory, or NULL for failure.
20598 * TFN_INT: internal function name OK
20599 * TFN_QUIET: be quiet
20600 * Advances "pp" to just after the function name (if no error).
20603 trans_function_name(pp
, skip
, flags
, fdp
)
20605 int skip
; /* only find the end, don't evaluate */
20607 funcdict_T
*fdp
; /* return: info about dictionary used */
20609 char_u
*name
= NULL
;
20613 char_u sid_buf
[20];
20618 vim_memset(fdp
, 0, sizeof(funcdict_T
));
20621 /* Check for hard coded <SNR>: already translated function ID (from a user
20623 if ((*pp
)[0] == K_SPECIAL
&& (*pp
)[1] == KS_EXTRA
20624 && (*pp
)[2] == (int)KE_SNR
)
20627 len
= get_id_len(pp
) + 3;
20628 return vim_strnsave(start
, len
);
20631 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20632 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20633 lead
= eval_fname_script(start
);
20637 end
= get_lval(start
, NULL
, &lv
, FALSE
, skip
, flags
& TFN_QUIET
,
20638 lead
> 2 ? 0 : FNE_CHECK_START
);
20642 EMSG(_("E129: Function name required"));
20645 if (end
== NULL
|| (lv
.ll_tv
!= NULL
&& (lead
> 2 || lv
.ll_range
)))
20648 * Report an invalid expression in braces, unless the expression
20649 * evaluation has been cancelled due to an aborting error, an
20650 * interrupt, or an exception.
20655 EMSG2(_(e_invarg2
), start
);
20658 *pp
= find_name_end(start
, NULL
, NULL
, FNE_INCL_BR
);
20662 if (lv
.ll_tv
!= NULL
)
20666 fdp
->fd_dict
= lv
.ll_dict
;
20667 fdp
->fd_newkey
= lv
.ll_newkey
;
20668 lv
.ll_newkey
= NULL
;
20669 fdp
->fd_di
= lv
.ll_di
;
20671 if (lv
.ll_tv
->v_type
== VAR_FUNC
&& lv
.ll_tv
->vval
.v_string
!= NULL
)
20673 name
= vim_strsave(lv
.ll_tv
->vval
.v_string
);
20678 if (!skip
&& !(flags
& TFN_QUIET
) && (fdp
== NULL
20679 || lv
.ll_dict
== NULL
|| fdp
->fd_newkey
== NULL
))
20680 EMSG(_(e_funcref
));
20688 if (lv
.ll_name
== NULL
)
20690 /* Error found, but continue after the function name. */
20695 /* Check if the name is a Funcref. If so, use the value. */
20696 if (lv
.ll_exp_name
!= NULL
)
20698 len
= (int)STRLEN(lv
.ll_exp_name
);
20699 name
= deref_func_name(lv
.ll_exp_name
, &len
);
20700 if (name
== lv
.ll_exp_name
)
20705 len
= (int)(end
- *pp
);
20706 name
= deref_func_name(*pp
, &len
);
20712 name
= vim_strsave(name
);
20717 if (lv
.ll_exp_name
!= NULL
)
20719 len
= (int)STRLEN(lv
.ll_exp_name
);
20720 if (lead
<= 2 && lv
.ll_name
== lv
.ll_exp_name
20721 && STRNCMP(lv
.ll_name
, "s:", 2) == 0)
20723 /* When there was "s:" already or the name expanded to get a
20724 * leading "s:" then remove it. */
20732 if (lead
== 2) /* skip over "s:" */
20734 len
= (int)(end
- lv
.ll_name
);
20738 * Copy the function name to allocated memory.
20739 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20740 * Accept <SNR>123_name() outside a script.
20743 lead
= 0; /* do nothing */
20747 if ((lv
.ll_exp_name
!= NULL
&& eval_fname_sid(lv
.ll_exp_name
))
20748 || eval_fname_sid(*pp
))
20750 /* It's "s:" or "<SID>" */
20751 if (current_SID
<= 0)
20753 EMSG(_(e_usingsid
));
20756 sprintf((char *)sid_buf
, "%ld_", (long)current_SID
);
20757 lead
+= (int)STRLEN(sid_buf
);
20760 else if (!(flags
& TFN_INT
) && builtin_function(lv
.ll_name
))
20762 EMSG2(_("E128: Function name must start with a capital or contain a colon: %s"), lv
.ll_name
);
20765 name
= alloc((unsigned)(len
+ lead
+ 1));
20770 name
[0] = K_SPECIAL
;
20771 name
[1] = KS_EXTRA
;
20772 name
[2] = (int)KE_SNR
;
20773 if (lead
> 3) /* If it's "<SID>" */
20774 STRCPY(name
+ 3, sid_buf
);
20776 mch_memmove(name
+ lead
, lv
.ll_name
, (size_t)len
);
20777 name
[len
+ lead
] = NUL
;
20787 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20788 * Return 2 if "p" starts with "s:".
20789 * Return 0 otherwise.
20792 eval_fname_script(p
)
20795 if (p
[0] == '<' && (STRNICMP(p
+ 1, "SID>", 4) == 0
20796 || STRNICMP(p
+ 1, "SNR>", 4) == 0))
20798 if (p
[0] == 's' && p
[1] == ':')
20804 * Return TRUE if "p" starts with "<SID>" or "s:".
20805 * Only works if eval_fname_script() returned non-zero for "p"!
20811 return (*p
== 's' || TOUPPER_ASC(p
[2]) == 'I');
20815 * List the head of the function: "name(arg1, arg2)".
20818 list_func_head(fp
, indent
)
20827 MSG_PUTS("function ");
20828 if (fp
->uf_name
[0] == K_SPECIAL
)
20830 MSG_PUTS_ATTR("<SNR>", hl_attr(HLF_8
));
20831 msg_puts(fp
->uf_name
+ 3);
20834 msg_puts(fp
->uf_name
);
20836 for (j
= 0; j
< fp
->uf_args
.ga_len
; ++j
)
20840 msg_puts(FUNCARG(fp
, j
));
20842 if (fp
->uf_varargs
)
20851 last_set_msg(fp
->uf_script_ID
);
20855 * Find a function by name, return pointer to it in ufuncs.
20856 * Return NULL for unknown function.
20864 hi
= hash_find(&func_hashtab
, name
);
20865 if (!HASHITEM_EMPTY(hi
))
20870 #if defined(EXITFREE) || defined(PROTO)
20872 free_all_functions()
20876 /* Need to start all over every time, because func_free() may change the
20878 while (func_hashtab
.ht_used
> 0)
20879 for (hi
= func_hashtab
.ht_array
; ; ++hi
)
20880 if (!HASHITEM_EMPTY(hi
))
20882 func_free(HI2UF(hi
));
20889 * Return TRUE if a function "name" exists.
20892 function_exists(name
)
20899 p
= trans_function_name(&nm
, FALSE
, TFN_INT
|TFN_QUIET
, NULL
);
20900 nm
= skipwhite(nm
);
20902 /* Only accept "funcname", "funcname ", "funcname (..." and
20903 * "funcname(...", not "funcname!...". */
20904 if (p
!= NULL
&& (*nm
== NUL
|| *nm
== '('))
20906 if (builtin_function(p
))
20907 n
= (find_internal_func(p
) >= 0);
20909 n
= (find_func(p
) != NULL
);
20916 * Return TRUE if "name" looks like a builtin function name: starts with a
20917 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20920 builtin_function(name
)
20923 return ASCII_ISLOWER(name
[0]) && vim_strchr(name
, ':') == NULL
20924 && vim_strchr(name
, AUTOLOAD_CHAR
) == NULL
;
20927 #if defined(FEAT_PROFILE) || defined(PROTO)
20929 * Start profiling function "fp".
20932 func_do_profile(fp
)
20935 fp
->uf_tm_count
= 0;
20936 profile_zero(&fp
->uf_tm_self
);
20937 profile_zero(&fp
->uf_tm_total
);
20938 if (fp
->uf_tml_count
== NULL
)
20939 fp
->uf_tml_count
= (int *)alloc_clear((unsigned)
20940 (sizeof(int) * fp
->uf_lines
.ga_len
));
20941 if (fp
->uf_tml_total
== NULL
)
20942 fp
->uf_tml_total
= (proftime_T
*)alloc_clear((unsigned)
20943 (sizeof(proftime_T
) * fp
->uf_lines
.ga_len
));
20944 if (fp
->uf_tml_self
== NULL
)
20945 fp
->uf_tml_self
= (proftime_T
*)alloc_clear((unsigned)
20946 (sizeof(proftime_T
) * fp
->uf_lines
.ga_len
));
20947 fp
->uf_tml_idx
= -1;
20948 if (fp
->uf_tml_count
== NULL
|| fp
->uf_tml_total
== NULL
20949 || fp
->uf_tml_self
== NULL
)
20950 return; /* out of memory */
20952 fp
->uf_profiling
= TRUE
;
20956 * Dump the profiling results for all functions in file "fd".
20959 func_dump_profile(fd
)
20969 todo
= (int)func_hashtab
.ht_used
;
20971 return; /* nothing to dump */
20973 sorttab
= (ufunc_T
**)alloc((unsigned)(sizeof(ufunc_T
) * todo
));
20975 for (hi
= func_hashtab
.ht_array
; todo
> 0; ++hi
)
20977 if (!HASHITEM_EMPTY(hi
))
20981 if (fp
->uf_profiling
)
20983 if (sorttab
!= NULL
)
20984 sorttab
[st_len
++] = fp
;
20986 if (fp
->uf_name
[0] == K_SPECIAL
)
20987 fprintf(fd
, "FUNCTION <SNR>%s()\n", fp
->uf_name
+ 3);
20989 fprintf(fd
, "FUNCTION %s()\n", fp
->uf_name
);
20990 if (fp
->uf_tm_count
== 1)
20991 fprintf(fd
, "Called 1 time\n");
20993 fprintf(fd
, "Called %d times\n", fp
->uf_tm_count
);
20994 fprintf(fd
, "Total time: %s\n", profile_msg(&fp
->uf_tm_total
));
20995 fprintf(fd
, " Self time: %s\n", profile_msg(&fp
->uf_tm_self
));
20997 fprintf(fd
, "count total (s) self (s)\n");
20999 for (i
= 0; i
< fp
->uf_lines
.ga_len
; ++i
)
21001 if (FUNCLINE(fp
, i
) == NULL
)
21003 prof_func_line(fd
, fp
->uf_tml_count
[i
],
21004 &fp
->uf_tml_total
[i
], &fp
->uf_tml_self
[i
], TRUE
);
21005 fprintf(fd
, "%s\n", FUNCLINE(fp
, i
));
21012 if (sorttab
!= NULL
&& st_len
> 0)
21014 qsort((void *)sorttab
, (size_t)st_len
, sizeof(ufunc_T
*),
21016 prof_sort_list(fd
, sorttab
, st_len
, "TOTAL", FALSE
);
21017 qsort((void *)sorttab
, (size_t)st_len
, sizeof(ufunc_T
*),
21019 prof_sort_list(fd
, sorttab
, st_len
, "SELF", TRUE
);
21026 prof_sort_list(fd
, sorttab
, st_len
, title
, prefer_self
)
21031 int prefer_self
; /* when equal print only self time */
21036 fprintf(fd
, "FUNCTIONS SORTED ON %s TIME\n", title
);
21037 fprintf(fd
, "count total (s) self (s) function\n");
21038 for (i
= 0; i
< 20 && i
< st_len
; ++i
)
21041 prof_func_line(fd
, fp
->uf_tm_count
, &fp
->uf_tm_total
, &fp
->uf_tm_self
,
21043 if (fp
->uf_name
[0] == K_SPECIAL
)
21044 fprintf(fd
, " <SNR>%s()\n", fp
->uf_name
+ 3);
21046 fprintf(fd
, " %s()\n", fp
->uf_name
);
21052 * Print the count and times for one function or function line.
21055 prof_func_line(fd
, count
, total
, self
, prefer_self
)
21060 int prefer_self
; /* when equal print only self time */
21064 fprintf(fd
, "%5d ", count
);
21065 if (prefer_self
&& profile_equal(total
, self
))
21068 fprintf(fd
, "%s ", profile_msg(total
));
21069 if (!prefer_self
&& profile_equal(total
, self
))
21072 fprintf(fd
, "%s ", profile_msg(self
));
21079 * Compare function for total time sorting.
21082 #ifdef __BORLANDC__
21085 prof_total_cmp(s1
, s2
)
21091 p1
= *(ufunc_T
**)s1
;
21092 p2
= *(ufunc_T
**)s2
;
21093 return profile_cmp(&p1
->uf_tm_total
, &p2
->uf_tm_total
);
21097 * Compare function for self time sorting.
21100 #ifdef __BORLANDC__
21103 prof_self_cmp(s1
, s2
)
21109 p1
= *(ufunc_T
**)s1
;
21110 p2
= *(ufunc_T
**)s2
;
21111 return profile_cmp(&p1
->uf_tm_self
, &p2
->uf_tm_self
);
21117 * If "name" has a package name try autoloading the script for it.
21118 * Return TRUE if a package was loaded.
21121 script_autoload(name
, reload
)
21123 int reload
; /* load script again when already loaded */
21126 char_u
*scriptname
, *tofree
;
21130 /* If there is no '#' after name[0] there is no package name. */
21131 p
= vim_strchr(name
, AUTOLOAD_CHAR
);
21132 if (p
== NULL
|| p
== name
)
21135 tofree
= scriptname
= autoload_name(name
);
21137 /* Find the name in the list of previously loaded package names. Skip
21138 * "autoload/", it's always the same. */
21139 for (i
= 0; i
< ga_loaded
.ga_len
; ++i
)
21140 if (STRCMP(((char_u
**)ga_loaded
.ga_data
)[i
] + 9, scriptname
+ 9) == 0)
21142 if (!reload
&& i
< ga_loaded
.ga_len
)
21143 ret
= FALSE
; /* was loaded already */
21146 /* Remember the name if it wasn't loaded already. */
21147 if (i
== ga_loaded
.ga_len
&& ga_grow(&ga_loaded
, 1) == OK
)
21149 ((char_u
**)ga_loaded
.ga_data
)[ga_loaded
.ga_len
++] = scriptname
;
21153 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
21154 if (source_runtime(scriptname
, FALSE
) == OK
)
21163 * Return the autoload script name for a function or variable name.
21164 * Returns NULL when out of memory.
21167 autoload_name(name
)
21171 char_u
*scriptname
;
21173 /* Get the script file name: replace '#' with '/', append ".vim". */
21174 scriptname
= alloc((unsigned)(STRLEN(name
) + 14));
21175 if (scriptname
== NULL
)
21177 STRCPY(scriptname
, "autoload/");
21178 STRCAT(scriptname
, name
);
21179 *vim_strrchr(scriptname
, AUTOLOAD_CHAR
) = NUL
;
21180 STRCAT(scriptname
, ".vim");
21181 while ((p
= vim_strchr(scriptname
, AUTOLOAD_CHAR
)) != NULL
)
21186 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
21189 * Function given to ExpandGeneric() to obtain the list of user defined
21193 get_user_func_name(xp
, idx
)
21197 static long_u done
;
21198 static hashitem_T
*hi
;
21204 hi
= func_hashtab
.ht_array
;
21206 if (done
< func_hashtab
.ht_used
)
21210 while (HASHITEM_EMPTY(hi
))
21214 if (STRLEN(fp
->uf_name
) + 4 >= IOSIZE
)
21215 return fp
->uf_name
; /* prevents overflow */
21217 cat_func_name(IObuff
, fp
);
21218 if (xp
->xp_context
!= EXPAND_USER_FUNC
)
21220 STRCAT(IObuff
, "(");
21221 if (!fp
->uf_varargs
&& fp
->uf_args
.ga_len
== 0)
21222 STRCAT(IObuff
, ")");
21229 #endif /* FEAT_CMDL_COMPL */
21232 * Copy the function name of "fp" to buffer "buf".
21233 * "buf" must be able to hold the function name plus three bytes.
21234 * Takes care of script-local function names.
21237 cat_func_name(buf
, fp
)
21241 if (fp
->uf_name
[0] == K_SPECIAL
)
21243 STRCPY(buf
, "<SNR>");
21244 STRCAT(buf
, fp
->uf_name
+ 3);
21247 STRCPY(buf
, fp
->uf_name
);
21251 * ":delfunction {name}"
21254 ex_delfunction(eap
)
21257 ufunc_T
*fp
= NULL
;
21263 name
= trans_function_name(&p
, eap
->skip
, 0, &fudi
);
21264 vim_free(fudi
.fd_newkey
);
21267 if (fudi
.fd_dict
!= NULL
&& !eap
->skip
)
21268 EMSG(_(e_funcref
));
21271 if (!ends_excmd(*skipwhite(p
)))
21274 EMSG(_(e_trailing
));
21277 eap
->nextcmd
= check_nextcmd(p
);
21278 if (eap
->nextcmd
!= NULL
)
21282 fp
= find_func(name
);
21289 EMSG2(_(e_nofunc
), eap
->arg
);
21292 if (fp
->uf_calls
> 0)
21294 EMSG2(_("E131: Cannot delete function %s: It is in use"), eap
->arg
);
21298 if (fudi
.fd_dict
!= NULL
)
21300 /* Delete the dict item that refers to the function, it will
21301 * invoke func_unref() and possibly delete the function. */
21302 dictitem_remove(fudi
.fd_dict
, fudi
.fd_di
);
21310 * Free a function and remove it from the list of functions.
21318 /* clear this function */
21319 ga_clear_strings(&(fp
->uf_args
));
21320 ga_clear_strings(&(fp
->uf_lines
));
21321 #ifdef FEAT_PROFILE
21322 vim_free(fp
->uf_tml_count
);
21323 vim_free(fp
->uf_tml_total
);
21324 vim_free(fp
->uf_tml_self
);
21327 /* remove the function from the function hashtable */
21328 hi
= hash_find(&func_hashtab
, UF2HIKEY(fp
));
21329 if (HASHITEM_EMPTY(hi
))
21330 EMSG2(_(e_intern2
), "func_free()");
21332 hash_remove(&func_hashtab
, hi
);
21338 * Unreference a Function: decrement the reference count and free it when it
21339 * becomes zero. Only for numbered functions.
21347 if (name
!= NULL
&& isdigit(*name
))
21349 fp
= find_func(name
);
21351 EMSG2(_(e_intern2
), "func_unref()");
21352 else if (--fp
->uf_refcount
<= 0)
21354 /* Only delete it when it's not being used. Otherwise it's done
21355 * when "uf_calls" becomes zero. */
21356 if (fp
->uf_calls
== 0)
21363 * Count a reference to a Function.
21371 if (name
!= NULL
&& isdigit(*name
))
21373 fp
= find_func(name
);
21375 EMSG2(_(e_intern2
), "func_ref()");
21382 * Call a user function.
21385 call_user_func(fp
, argcount
, argvars
, rettv
, firstline
, lastline
, selfdict
)
21386 ufunc_T
*fp
; /* pointer to function */
21387 int argcount
; /* nr of args */
21388 typval_T
*argvars
; /* arguments */
21389 typval_T
*rettv
; /* return value */
21390 linenr_T firstline
; /* first line of range */
21391 linenr_T lastline
; /* last line of range */
21392 dict_T
*selfdict
; /* Dictionary for "self" */
21394 char_u
*save_sourcing_name
;
21395 linenr_T save_sourcing_lnum
;
21396 scid_T save_current_SID
;
21399 static int depth
= 0;
21401 int fixvar_idx
= 0; /* index in fixvar[] */
21404 char_u numbuf
[NUMBUFLEN
];
21406 #ifdef FEAT_PROFILE
21407 proftime_T wait_start
;
21408 proftime_T call_start
;
21411 /* If depth of calling is getting too high, don't execute the function */
21412 if (depth
>= p_mfd
)
21414 EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'"));
21415 rettv
->v_type
= VAR_NUMBER
;
21416 rettv
->vval
.v_number
= -1;
21421 line_breakcheck(); /* check for CTRL-C hit */
21423 fc
= (funccall_T
*)alloc(sizeof(funccall_T
));
21424 fc
->caller
= current_funccal
;
21425 current_funccal
= fc
;
21428 rettv
->vval
.v_number
= 0;
21430 fc
->returned
= FALSE
;
21431 fc
->level
= ex_nesting_level
;
21432 /* Check if this function has a breakpoint. */
21433 fc
->breakpoint
= dbg_find_breakpoint(FALSE
, fp
->uf_name
, (linenr_T
)0);
21434 fc
->dbg_tick
= debug_tick
;
21437 * Note about using fc->fixvar[]: This is an array of FIXVAR_CNT variables
21438 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21439 * each argument variable and saves a lot of time.
21442 * Init l: variables.
21444 init_var_dict(&fc
->l_vars
, &fc
->l_vars_var
);
21445 if (selfdict
!= NULL
)
21447 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21448 * some compiler that checks the destination size. */
21449 v
= &fc
->fixvar
[fixvar_idx
++].var
;
21451 STRCPY(name
, "self");
21452 v
->di_flags
= DI_FLAGS_RO
+ DI_FLAGS_FIX
;
21453 hash_add(&fc
->l_vars
.dv_hashtab
, DI2HIKEY(v
));
21454 v
->di_tv
.v_type
= VAR_DICT
;
21455 v
->di_tv
.v_lock
= 0;
21456 v
->di_tv
.vval
.v_dict
= selfdict
;
21457 ++selfdict
->dv_refcount
;
21461 * Init a: variables.
21462 * Set a:0 to "argcount".
21463 * Set a:000 to a list with room for the "..." arguments.
21465 init_var_dict(&fc
->l_avars
, &fc
->l_avars_var
);
21466 add_nr_var(&fc
->l_avars
, &fc
->fixvar
[fixvar_idx
++].var
, "0",
21467 (varnumber_T
)(argcount
- fp
->uf_args
.ga_len
));
21468 /* Use "name" to avoid a warning from some compiler that checks the
21469 * destination size. */
21470 v
= &fc
->fixvar
[fixvar_idx
++].var
;
21472 STRCPY(name
, "000");
21473 v
->di_flags
= DI_FLAGS_RO
| DI_FLAGS_FIX
;
21474 hash_add(&fc
->l_avars
.dv_hashtab
, DI2HIKEY(v
));
21475 v
->di_tv
.v_type
= VAR_LIST
;
21476 v
->di_tv
.v_lock
= VAR_FIXED
;
21477 v
->di_tv
.vval
.v_list
= &fc
->l_varlist
;
21478 vim_memset(&fc
->l_varlist
, 0, sizeof(list_T
));
21479 fc
->l_varlist
.lv_refcount
= DO_NOT_FREE_CNT
;
21480 fc
->l_varlist
.lv_lock
= VAR_FIXED
;
21483 * Set a:firstline to "firstline" and a:lastline to "lastline".
21484 * Set a:name to named arguments.
21485 * Set a:N to the "..." arguments.
21487 add_nr_var(&fc
->l_avars
, &fc
->fixvar
[fixvar_idx
++].var
, "firstline",
21488 (varnumber_T
)firstline
);
21489 add_nr_var(&fc
->l_avars
, &fc
->fixvar
[fixvar_idx
++].var
, "lastline",
21490 (varnumber_T
)lastline
);
21491 for (i
= 0; i
< argcount
; ++i
)
21493 ai
= i
- fp
->uf_args
.ga_len
;
21495 /* named argument a:name */
21496 name
= FUNCARG(fp
, i
);
21499 /* "..." argument a:1, a:2, etc. */
21500 sprintf((char *)numbuf
, "%d", ai
+ 1);
21503 if (fixvar_idx
< FIXVAR_CNT
&& STRLEN(name
) <= VAR_SHORT_LEN
)
21505 v
= &fc
->fixvar
[fixvar_idx
++].var
;
21506 v
->di_flags
= DI_FLAGS_RO
| DI_FLAGS_FIX
;
21510 v
= (dictitem_T
*)alloc((unsigned)(sizeof(dictitem_T
)
21514 v
->di_flags
= DI_FLAGS_RO
;
21516 STRCPY(v
->di_key
, name
);
21517 hash_add(&fc
->l_avars
.dv_hashtab
, DI2HIKEY(v
));
21519 /* Note: the values are copied directly to avoid alloc/free.
21520 * "argvars" must have VAR_FIXED for v_lock. */
21521 v
->di_tv
= argvars
[i
];
21522 v
->di_tv
.v_lock
= VAR_FIXED
;
21524 if (ai
>= 0 && ai
< MAX_FUNC_ARGS
)
21526 list_append(&fc
->l_varlist
, &fc
->l_listitems
[ai
]);
21527 fc
->l_listitems
[ai
].li_tv
= argvars
[i
];
21528 fc
->l_listitems
[ai
].li_tv
.v_lock
= VAR_FIXED
;
21532 /* Don't redraw while executing the function. */
21533 ++RedrawingDisabled
;
21534 save_sourcing_name
= sourcing_name
;
21535 save_sourcing_lnum
= sourcing_lnum
;
21537 sourcing_name
= alloc((unsigned)((save_sourcing_name
== NULL
? 0
21538 : STRLEN(save_sourcing_name
)) + STRLEN(fp
->uf_name
) + 13));
21539 if (sourcing_name
!= NULL
)
21541 if (save_sourcing_name
!= NULL
21542 && STRNCMP(save_sourcing_name
, "function ", 9) == 0)
21543 sprintf((char *)sourcing_name
, "%s..", save_sourcing_name
);
21545 STRCPY(sourcing_name
, "function ");
21546 cat_func_name(sourcing_name
+ STRLEN(sourcing_name
), fp
);
21548 if (p_verbose
>= 12)
21551 verbose_enter_scroll();
21553 smsg((char_u
*)_("calling %s"), sourcing_name
);
21554 if (p_verbose
>= 14)
21556 char_u buf
[MSG_BUF_LEN
];
21557 char_u numbuf2
[NUMBUFLEN
];
21561 msg_puts((char_u
*)"(");
21562 for (i
= 0; i
< argcount
; ++i
)
21565 msg_puts((char_u
*)", ");
21566 if (argvars
[i
].v_type
== VAR_NUMBER
)
21567 msg_outnum((long)argvars
[i
].vval
.v_number
);
21570 s
= tv2string(&argvars
[i
], &tofree
, numbuf2
, 0);
21573 trunc_string(s
, buf
, MSG_BUF_CLEN
);
21579 msg_puts((char_u
*)")");
21581 msg_puts((char_u
*)"\n"); /* don't overwrite this either */
21583 verbose_leave_scroll();
21587 #ifdef FEAT_PROFILE
21588 if (do_profiling
== PROF_YES
)
21590 if (!fp
->uf_profiling
&& has_profiling(FALSE
, fp
->uf_name
, NULL
))
21591 func_do_profile(fp
);
21592 if (fp
->uf_profiling
21593 || (fc
->caller
!= NULL
&& fc
->caller
->func
->uf_profiling
))
21596 profile_start(&call_start
);
21597 profile_zero(&fp
->uf_tm_children
);
21599 script_prof_save(&wait_start
);
21603 save_current_SID
= current_SID
;
21604 current_SID
= fp
->uf_script_ID
;
21605 save_did_emsg
= did_emsg
;
21608 /* call do_cmdline() to execute the lines */
21609 do_cmdline(NULL
, get_func_line
, (void *)fc
,
21610 DOCMD_NOWAIT
|DOCMD_VERBOSE
|DOCMD_REPEAT
);
21612 --RedrawingDisabled
;
21614 /* when the function was aborted because of an error, return -1 */
21615 if ((did_emsg
&& (fp
->uf_flags
& FC_ABORT
)) || rettv
->v_type
== VAR_UNKNOWN
)
21618 rettv
->v_type
= VAR_NUMBER
;
21619 rettv
->vval
.v_number
= -1;
21622 #ifdef FEAT_PROFILE
21623 if (do_profiling
== PROF_YES
&& (fp
->uf_profiling
21624 || (fc
->caller
!= NULL
&& fc
->caller
->func
->uf_profiling
)))
21626 profile_end(&call_start
);
21627 profile_sub_wait(&wait_start
, &call_start
);
21628 profile_add(&fp
->uf_tm_total
, &call_start
);
21629 profile_self(&fp
->uf_tm_self
, &call_start
, &fp
->uf_tm_children
);
21630 if (fc
->caller
!= NULL
&& fc
->caller
->func
->uf_profiling
)
21632 profile_add(&fc
->caller
->func
->uf_tm_children
, &call_start
);
21633 profile_add(&fc
->caller
->func
->uf_tml_children
, &call_start
);
21638 /* when being verbose, mention the return value */
21639 if (p_verbose
>= 12)
21642 verbose_enter_scroll();
21645 smsg((char_u
*)_("%s aborted"), sourcing_name
);
21646 else if (fc
->rettv
->v_type
== VAR_NUMBER
)
21647 smsg((char_u
*)_("%s returning #%ld"), sourcing_name
,
21648 (long)fc
->rettv
->vval
.v_number
);
21651 char_u buf
[MSG_BUF_LEN
];
21652 char_u numbuf2
[NUMBUFLEN
];
21656 /* The value may be very long. Skip the middle part, so that we
21657 * have some idea how it starts and ends. smsg() would always
21658 * truncate it at the end. */
21659 s
= tv2string(fc
->rettv
, &tofree
, numbuf2
, 0);
21662 trunc_string(s
, buf
, MSG_BUF_CLEN
);
21663 smsg((char_u
*)_("%s returning %s"), sourcing_name
, buf
);
21667 msg_puts((char_u
*)"\n"); /* don't overwrite this either */
21669 verbose_leave_scroll();
21673 vim_free(sourcing_name
);
21674 sourcing_name
= save_sourcing_name
;
21675 sourcing_lnum
= save_sourcing_lnum
;
21676 current_SID
= save_current_SID
;
21677 #ifdef FEAT_PROFILE
21678 if (do_profiling
== PROF_YES
)
21679 script_prof_restore(&wait_start
);
21682 if (p_verbose
>= 12 && sourcing_name
!= NULL
)
21685 verbose_enter_scroll();
21687 smsg((char_u
*)_("continuing in %s"), sourcing_name
);
21688 msg_puts((char_u
*)"\n"); /* don't overwrite this either */
21690 verbose_leave_scroll();
21694 did_emsg
|= save_did_emsg
;
21695 current_funccal
= fc
->caller
;
21698 /* If the a:000 list and the l: and a: dicts are not referenced we can
21699 * free the funccall_T and what's in it. */
21700 if (fc
->l_varlist
.lv_refcount
== DO_NOT_FREE_CNT
21701 && fc
->l_vars
.dv_refcount
== DO_NOT_FREE_CNT
21702 && fc
->l_avars
.dv_refcount
== DO_NOT_FREE_CNT
)
21704 free_funccal(fc
, FALSE
);
21712 /* "fc" is still in use. This can happen when returning "a:000" or
21713 * assigning "l:" to a global variable.
21714 * Link "fc" in the list for garbage collection later. */
21715 fc
->caller
= previous_funccal
;
21716 previous_funccal
= fc
;
21718 /* Make a copy of the a: variables, since we didn't do that above. */
21719 todo
= (int)fc
->l_avars
.dv_hashtab
.ht_used
;
21720 for (hi
= fc
->l_avars
.dv_hashtab
.ht_array
; todo
> 0; ++hi
)
21722 if (!HASHITEM_EMPTY(hi
))
21726 copy_tv(&v
->di_tv
, &v
->di_tv
);
21730 /* Make a copy of the a:000 items, since we didn't do that above. */
21731 for (li
= fc
->l_varlist
.lv_first
; li
!= NULL
; li
= li
->li_next
)
21732 copy_tv(&li
->li_tv
, &li
->li_tv
);
21737 * Return TRUE if items in "fc" do not have "copyID". That means they are not
21738 * referenced from anywhere that is in use.
21741 can_free_funccal(fc
, copyID
)
21745 return (fc
->l_varlist
.lv_copyID
!= copyID
21746 && fc
->l_vars
.dv_copyID
!= copyID
21747 && fc
->l_avars
.dv_copyID
!= copyID
);
21751 * Free "fc" and what it contains.
21754 free_funccal(fc
, free_val
)
21756 int free_val
; /* a: vars were allocated */
21760 /* The a: variables typevals may not have been allocated, only free the
21761 * allocated variables. */
21762 vars_clear_ext(&fc
->l_avars
.dv_hashtab
, free_val
);
21764 /* free all l: variables */
21765 vars_clear(&fc
->l_vars
.dv_hashtab
);
21767 /* Free the a:000 variables if they were allocated. */
21769 for (li
= fc
->l_varlist
.lv_first
; li
!= NULL
; li
= li
->li_next
)
21770 clear_tv(&li
->li_tv
);
21776 * Add a number variable "name" to dict "dp" with value "nr".
21779 add_nr_var(dp
, v
, name
, nr
)
21785 STRCPY(v
->di_key
, name
);
21786 v
->di_flags
= DI_FLAGS_RO
| DI_FLAGS_FIX
;
21787 hash_add(&dp
->dv_hashtab
, DI2HIKEY(v
));
21788 v
->di_tv
.v_type
= VAR_NUMBER
;
21789 v
->di_tv
.v_lock
= VAR_FIXED
;
21790 v
->di_tv
.vval
.v_number
= nr
;
21800 char_u
*arg
= eap
->arg
;
21802 int returning
= FALSE
;
21804 if (current_funccal
== NULL
)
21806 EMSG(_("E133: :return not inside a function"));
21813 eap
->nextcmd
= NULL
;
21814 if ((*arg
!= NUL
&& *arg
!= '|' && *arg
!= '\n')
21815 && eval0(arg
, &rettv
, &eap
->nextcmd
, !eap
->skip
) != FAIL
)
21818 returning
= do_return(eap
, FALSE
, TRUE
, &rettv
);
21822 /* It's safer to return also on error. */
21823 else if (!eap
->skip
)
21826 * Return unless the expression evaluation has been cancelled due to an
21827 * aborting error, an interrupt, or an exception.
21830 returning
= do_return(eap
, FALSE
, TRUE
, NULL
);
21833 /* When skipping or the return gets pending, advance to the next command
21834 * in this line (!returning). Otherwise, ignore the rest of the line.
21835 * Following lines will be ignored by get_func_line(). */
21837 eap
->nextcmd
= NULL
;
21838 else if (eap
->nextcmd
== NULL
) /* no argument */
21839 eap
->nextcmd
= check_nextcmd(arg
);
21846 * Return from a function. Possibly makes the return pending. Also called
21847 * for a pending return at the ":endtry" or after returning from an extra
21848 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21849 * when called due to a ":return" command. "rettv" may point to a typval_T
21850 * with the return rettv. Returns TRUE when the return can be carried out,
21851 * FALSE when the return gets pending.
21854 do_return(eap
, reanimate
, is_cmd
, rettv
)
21861 struct condstack
*cstack
= eap
->cstack
;
21864 /* Undo the return. */
21865 current_funccal
->returned
= FALSE
;
21868 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21869 * not in its finally clause (which then is to be executed next) is found.
21870 * In this case, make the ":return" pending for execution at the ":endtry".
21871 * Otherwise, return normally.
21873 idx
= cleanup_conditionals(eap
->cstack
, 0, TRUE
);
21876 cstack
->cs_pending
[idx
] = CSTP_RETURN
;
21878 if (!is_cmd
&& !reanimate
)
21879 /* A pending return again gets pending. "rettv" points to an
21880 * allocated variable with the rettv of the original ":return"'s
21881 * argument if present or is NULL else. */
21882 cstack
->cs_rettv
[idx
] = rettv
;
21885 /* When undoing a return in order to make it pending, get the stored
21888 rettv
= current_funccal
->rettv
;
21892 /* Store the value of the pending return. */
21893 if ((cstack
->cs_rettv
[idx
] = alloc_tv()) != NULL
)
21894 *(typval_T
*)cstack
->cs_rettv
[idx
] = *(typval_T
*)rettv
;
21896 EMSG(_(e_outofmem
));
21899 cstack
->cs_rettv
[idx
] = NULL
;
21903 /* The pending return value could be overwritten by a ":return"
21904 * without argument in a finally clause; reset the default
21906 current_funccal
->rettv
->v_type
= VAR_NUMBER
;
21907 current_funccal
->rettv
->vval
.v_number
= 0;
21910 report_make_pending(CSTP_RETURN
, rettv
);
21914 current_funccal
->returned
= TRUE
;
21916 /* If the return is carried out now, store the return value. For
21917 * a return immediately after reanimation, the value is already
21919 if (!reanimate
&& rettv
!= NULL
)
21921 clear_tv(current_funccal
->rettv
);
21922 *current_funccal
->rettv
= *(typval_T
*)rettv
;
21932 * Free the variable with a pending return value.
21935 discard_pending_return(rettv
)
21938 free_tv((typval_T
*)rettv
);
21942 * Generate a return command for producing the value of "rettv". The result
21943 * is an allocated string. Used by report_pending() for verbose messages.
21946 get_return_cmd(rettv
)
21950 char_u
*tofree
= NULL
;
21951 char_u numbuf
[NUMBUFLEN
];
21954 s
= echo_string((typval_T
*)rettv
, &tofree
, numbuf
, 0);
21958 STRCPY(IObuff
, ":return ");
21959 STRNCPY(IObuff
+ 8, s
, IOSIZE
- 8);
21960 if (STRLEN(s
) + 8 >= IOSIZE
)
21961 STRCPY(IObuff
+ IOSIZE
- 4, "...");
21963 return vim_strsave(IObuff
);
21967 * Get next function line.
21968 * Called by do_cmdline() to get the next line.
21969 * Returns allocated string, or NULL for end of function.
21972 get_func_line(c
, cookie
, indent
)
21977 funccall_T
*fcp
= (funccall_T
*)cookie
;
21978 ufunc_T
*fp
= fcp
->func
;
21980 garray_T
*gap
; /* growarray with function lines */
21982 /* If breakpoints have been added/deleted need to check for it. */
21983 if (fcp
->dbg_tick
!= debug_tick
)
21985 fcp
->breakpoint
= dbg_find_breakpoint(FALSE
, fp
->uf_name
,
21987 fcp
->dbg_tick
= debug_tick
;
21989 #ifdef FEAT_PROFILE
21990 if (do_profiling
== PROF_YES
)
21991 func_line_end(cookie
);
21994 gap
= &fp
->uf_lines
;
21995 if (((fp
->uf_flags
& FC_ABORT
) && did_emsg
&& !aborted_in_try())
22000 /* Skip NULL lines (continuation lines). */
22001 while (fcp
->linenr
< gap
->ga_len
22002 && ((char_u
**)(gap
->ga_data
))[fcp
->linenr
] == NULL
)
22004 if (fcp
->linenr
>= gap
->ga_len
)
22008 retval
= vim_strsave(((char_u
**)(gap
->ga_data
))[fcp
->linenr
++]);
22009 sourcing_lnum
= fcp
->linenr
;
22010 #ifdef FEAT_PROFILE
22011 if (do_profiling
== PROF_YES
)
22012 func_line_start(cookie
);
22017 /* Did we encounter a breakpoint? */
22018 if (fcp
->breakpoint
!= 0 && fcp
->breakpoint
<= sourcing_lnum
)
22020 dbg_breakpoint(fp
->uf_name
, sourcing_lnum
);
22021 /* Find next breakpoint. */
22022 fcp
->breakpoint
= dbg_find_breakpoint(FALSE
, fp
->uf_name
,
22024 fcp
->dbg_tick
= debug_tick
;
22030 #if defined(FEAT_PROFILE) || defined(PROTO)
22032 * Called when starting to read a function line.
22033 * "sourcing_lnum" must be correct!
22034 * When skipping lines it may not actually be executed, but we won't find out
22035 * until later and we need to store the time now.
22038 func_line_start(cookie
)
22041 funccall_T
*fcp
= (funccall_T
*)cookie
;
22042 ufunc_T
*fp
= fcp
->func
;
22044 if (fp
->uf_profiling
&& sourcing_lnum
>= 1
22045 && sourcing_lnum
<= fp
->uf_lines
.ga_len
)
22047 fp
->uf_tml_idx
= sourcing_lnum
- 1;
22048 /* Skip continuation lines. */
22049 while (fp
->uf_tml_idx
> 0 && FUNCLINE(fp
, fp
->uf_tml_idx
) == NULL
)
22051 fp
->uf_tml_execed
= FALSE
;
22052 profile_start(&fp
->uf_tml_start
);
22053 profile_zero(&fp
->uf_tml_children
);
22054 profile_get_wait(&fp
->uf_tml_wait
);
22059 * Called when actually executing a function line.
22062 func_line_exec(cookie
)
22065 funccall_T
*fcp
= (funccall_T
*)cookie
;
22066 ufunc_T
*fp
= fcp
->func
;
22068 if (fp
->uf_profiling
&& fp
->uf_tml_idx
>= 0)
22069 fp
->uf_tml_execed
= TRUE
;
22073 * Called when done with a function line.
22076 func_line_end(cookie
)
22079 funccall_T
*fcp
= (funccall_T
*)cookie
;
22080 ufunc_T
*fp
= fcp
->func
;
22082 if (fp
->uf_profiling
&& fp
->uf_tml_idx
>= 0)
22084 if (fp
->uf_tml_execed
)
22086 ++fp
->uf_tml_count
[fp
->uf_tml_idx
];
22087 profile_end(&fp
->uf_tml_start
);
22088 profile_sub_wait(&fp
->uf_tml_wait
, &fp
->uf_tml_start
);
22089 profile_add(&fp
->uf_tml_total
[fp
->uf_tml_idx
], &fp
->uf_tml_start
);
22090 profile_self(&fp
->uf_tml_self
[fp
->uf_tml_idx
], &fp
->uf_tml_start
,
22091 &fp
->uf_tml_children
);
22093 fp
->uf_tml_idx
= -1;
22099 * Return TRUE if the currently active function should be ended, because a
22100 * return was encountered or an error occurred. Used inside a ":while".
22103 func_has_ended(cookie
)
22106 funccall_T
*fcp
= (funccall_T
*)cookie
;
22108 /* Ignore the "abort" flag if the abortion behavior has been changed due to
22109 * an error inside a try conditional. */
22110 return (((fcp
->func
->uf_flags
& FC_ABORT
) && did_emsg
&& !aborted_in_try())
22115 * return TRUE if cookie indicates a function which "abort"s on errors.
22118 func_has_abort(cookie
)
22121 return ((funccall_T
*)cookie
)->func
->uf_flags
& FC_ABORT
;
22124 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
22127 VAR_FLAVOUR_DEFAULT
, /* doesn't start with uppercase */
22128 VAR_FLAVOUR_SESSION
, /* starts with uppercase, some lower */
22129 VAR_FLAVOUR_VIMINFO
/* all uppercase */
22132 static var_flavour_T var_flavour
__ARGS((char_u
*varname
));
22134 static var_flavour_T
22135 var_flavour(varname
)
22138 char_u
*p
= varname
;
22140 if (ASCII_ISUPPER(*p
))
22143 if (ASCII_ISLOWER(*p
))
22144 return VAR_FLAVOUR_SESSION
;
22145 return VAR_FLAVOUR_VIMINFO
;
22148 return VAR_FLAVOUR_DEFAULT
;
22152 #if defined(FEAT_VIMINFO) || defined(PROTO)
22154 * Restore global vars that start with a capital from the viminfo file
22157 read_viminfo_varlist(virp
, writing
)
22162 int type
= VAR_NUMBER
;
22165 if (!writing
&& (find_viminfo_parameter('!') != NULL
))
22167 tab
= vim_strchr(virp
->vir_line
+ 1, '\t');
22170 *tab
++ = '\0'; /* isolate the variable name */
22171 if (*tab
== 'S') /* string var */
22174 else if (*tab
== 'F')
22178 tab
= vim_strchr(tab
, '\t');
22182 if (type
== VAR_STRING
)
22183 tv
.vval
.v_string
= viminfo_readstring(virp
,
22184 (int)(tab
- virp
->vir_line
+ 1), TRUE
);
22186 else if (type
== VAR_FLOAT
)
22187 (void)string2float(tab
+ 1, &tv
.vval
.v_float
);
22190 tv
.vval
.v_number
= atol((char *)tab
+ 1);
22191 set_var(virp
->vir_line
+ 1, &tv
, FALSE
);
22192 if (type
== VAR_STRING
)
22193 vim_free(tv
.vval
.v_string
);
22198 return viminfo_readline(virp
);
22202 * Write global vars that start with a capital to the viminfo file
22205 write_viminfo_varlist(fp
)
22209 dictitem_T
*this_var
;
22214 char_u numbuf
[NUMBUFLEN
];
22216 if (find_viminfo_parameter('!') == NULL
)
22219 fputs(_("\n# global variables:\n"), fp
);
22221 todo
= (int)globvarht
.ht_used
;
22222 for (hi
= globvarht
.ht_array
; todo
> 0; ++hi
)
22224 if (!HASHITEM_EMPTY(hi
))
22227 this_var
= HI2DI(hi
);
22228 if (var_flavour(this_var
->di_key
) == VAR_FLAVOUR_VIMINFO
)
22230 switch (this_var
->di_tv
.v_type
)
22232 case VAR_STRING
: s
= "STR"; break;
22233 case VAR_NUMBER
: s
= "NUM"; break;
22235 case VAR_FLOAT
: s
= "FLO"; break;
22239 fprintf(fp
, "!%s\t%s\t", this_var
->di_key
, s
);
22240 p
= echo_string(&this_var
->di_tv
, &tofree
, numbuf
, 0);
22242 viminfo_writestring(fp
, p
);
22250 #if defined(FEAT_SESSION) || defined(PROTO)
22252 store_session_globals(fd
)
22256 dictitem_T
*this_var
;
22260 todo
= (int)globvarht
.ht_used
;
22261 for (hi
= globvarht
.ht_array
; todo
> 0; ++hi
)
22263 if (!HASHITEM_EMPTY(hi
))
22266 this_var
= HI2DI(hi
);
22267 if ((this_var
->di_tv
.v_type
== VAR_NUMBER
22268 || this_var
->di_tv
.v_type
== VAR_STRING
)
22269 && var_flavour(this_var
->di_key
) == VAR_FLAVOUR_SESSION
)
22271 /* Escape special characters with a backslash. Turn a LF and
22272 * CR into \n and \r. */
22273 p
= vim_strsave_escaped(get_tv_string(&this_var
->di_tv
),
22274 (char_u
*)"\\\"\n\r");
22275 if (p
== NULL
) /* out of memory */
22277 for (t
= p
; *t
!= NUL
; ++t
)
22280 else if (*t
== '\r')
22282 if ((fprintf(fd
, "let %s = %c%s%c",
22284 (this_var
->di_tv
.v_type
== VAR_STRING
) ? '"'
22287 (this_var
->di_tv
.v_type
== VAR_STRING
) ? '"'
22289 || put_eol(fd
) == FAIL
)
22297 else if (this_var
->di_tv
.v_type
== VAR_FLOAT
22298 && var_flavour(this_var
->di_key
) == VAR_FLAVOUR_SESSION
)
22300 float_T f
= this_var
->di_tv
.vval
.v_float
;
22308 if ((fprintf(fd
, "let %s = %c&%f",
22309 this_var
->di_key
, sign
, f
) < 0)
22310 || put_eol(fd
) == FAIL
)
22321 * Display script name where an item was last set.
22322 * Should only be invoked when 'verbose' is non-zero.
22325 last_set_msg(scriptID
)
22332 p
= home_replace_save(NULL
, get_scriptname(scriptID
));
22336 MSG_PUTS(_("\n\tLast set from "));
22345 * List v:oldfiles in a nice way.
22349 exarg_T
*eap UNUSED
;
22351 list_T
*l
= vimvars
[VV_OLDFILES
].vv_list
;
22356 msg((char_u
*)_("No old files"));
22361 for (li
= l
->lv_first
; li
!= NULL
&& !got_int
; li
= li
->li_next
)
22363 msg_outnum((long)++nr
);
22365 msg_outtrans(get_tv_string(&li
->li_tv
));
22367 out_flush(); /* output one line at a time */
22370 /* Assume "got_int" was set to truncate the listing. */
22373 #ifdef FEAT_BROWSE_CMD
22377 nr
= prompt_for_number(FALSE
);
22381 char_u
*p
= list_find_str(get_vim_var_list(VV_OLDFILES
),
22386 p
= expand_env_save(p
);
22388 eap
->cmdidx
= CMD_edit
;
22389 cmdmod
.browse
= FALSE
;
22390 do_exedit(eap
, NULL
);
22399 #endif /* FEAT_EVAL */
22402 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
22406 * Functions for ":8" filename modifier: get 8.3 version of a filename.
22408 static int get_short_pathname
__ARGS((char_u
**fnamep
, char_u
**bufp
, int *fnamelen
));
22409 static int shortpath_for_invalid_fname
__ARGS((char_u
**fname
, char_u
**bufp
, int *fnamelen
));
22410 static int shortpath_for_partial
__ARGS((char_u
**fnamep
, char_u
**bufp
, int *fnamelen
));
22413 * Get the short path (8.3) for the filename in "fnamep".
22414 * Only works for a valid file name.
22415 * When the path gets longer "fnamep" is changed and the allocated buffer
22416 * is put in "bufp".
22417 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
22418 * Returns OK on success, FAIL on failure.
22421 get_short_pathname(fnamep
, bufp
, fnamelen
)
22430 l
= GetShortPathName(*fnamep
, *fnamep
, len
);
22433 /* If that doesn't work (not enough space), then save the string
22434 * and try again with a new buffer big enough. */
22435 newbuf
= vim_strnsave(*fnamep
, l
);
22436 if (newbuf
== NULL
)
22440 *fnamep
= *bufp
= newbuf
;
22442 /* Really should always succeed, as the buffer is big enough. */
22443 l
= GetShortPathName(*fnamep
, *fnamep
, l
+1);
22451 * Get the short path (8.3) for the filename in "fname". The converted
22452 * path is returned in "bufp".
22454 * Some of the directories specified in "fname" may not exist. This function
22455 * will shorten the existing directories at the beginning of the path and then
22456 * append the remaining non-existing path.
22458 * fname - Pointer to the filename to shorten. On return, contains the
22459 * pointer to the shortened pathname
22460 * bufp - Pointer to an allocated buffer for the filename.
22461 * fnamelen - Length of the filename pointed to by fname
22463 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
22466 shortpath_for_invalid_fname(fname
, bufp
, fnamelen
)
22471 char_u
*short_fname
, *save_fname
, *pbuf_unused
;
22472 char_u
*endp
, *save_endp
;
22475 int new_len
, sfx_len
;
22479 old_len
= *fnamelen
;
22480 save_fname
= vim_strnsave(*fname
, old_len
);
22481 pbuf_unused
= NULL
;
22482 short_fname
= NULL
;
22484 endp
= save_fname
+ old_len
- 1; /* Find the end of the copy */
22488 * Try shortening the supplied path till it succeeds by removing one
22489 * directory at a time from the tail of the path.
22494 /* go back one path-separator */
22495 while (endp
> save_fname
&& !after_pathsep(save_fname
, endp
+ 1))
22497 if (endp
<= save_fname
)
22498 break; /* processed the complete path */
22501 * Replace the path separator with a NUL and try to shorten the
22506 short_fname
= save_fname
;
22507 len
= (int)STRLEN(short_fname
) + 1;
22508 if (get_short_pathname(&short_fname
, &pbuf_unused
, &len
) == FAIL
)
22513 *endp
= ch
; /* preserve the string */
22516 break; /* successfully shortened the path */
22518 /* failed to shorten the path. Skip the path separator */
22525 * Succeeded in shortening the path. Now concatenate the shortened
22526 * path with the remaining path at the tail.
22529 /* Compute the length of the new path. */
22530 sfx_len
= (int)(save_endp
- endp
) + 1;
22531 new_len
= len
+ sfx_len
;
22533 *fnamelen
= new_len
;
22535 if (new_len
> old_len
)
22537 /* There is not enough space in the currently allocated string,
22538 * copy it to a buffer big enough. */
22539 *fname
= *bufp
= vim_strnsave(short_fname
, new_len
);
22540 if (*fname
== NULL
)
22548 /* Transfer short_fname to the main buffer (it's big enough),
22549 * unless get_short_pathname() did its work in-place. */
22550 *fname
= *bufp
= save_fname
;
22551 if (short_fname
!= save_fname
)
22552 vim_strncpy(save_fname
, short_fname
, len
);
22556 /* concat the not-shortened part of the path */
22557 vim_strncpy(*fname
+ len
, endp
, sfx_len
);
22558 (*fname
)[new_len
] = NUL
;
22562 vim_free(pbuf_unused
);
22563 vim_free(save_fname
);
22569 * Get a pathname for a partial path.
22570 * Returns OK for success, FAIL for failure.
22573 shortpath_for_partial(fnamep
, bufp
, fnamelen
)
22578 int sepcount
, len
, tflen
;
22580 char_u
*pbuf
, *tfname
;
22583 /* Count up the path separators from the RHS.. so we know which part
22584 * of the path to return. */
22586 for (p
= *fnamep
; p
< *fnamep
+ *fnamelen
; mb_ptr_adv(p
))
22587 if (vim_ispathsep(*p
))
22590 /* Need full path first (use expand_env() to remove a "~/") */
22591 hasTilde
= (**fnamep
== '~');
22593 pbuf
= tfname
= expand_env_save(*fnamep
);
22595 pbuf
= tfname
= FullName_save(*fnamep
, FALSE
);
22597 len
= tflen
= (int)STRLEN(tfname
);
22599 if (get_short_pathname(&tfname
, &pbuf
, &len
) == FAIL
)
22604 /* Don't have a valid filename, so shorten the rest of the
22605 * path if we can. This CAN give us invalid 8.3 filenames, but
22606 * there's not a lot of point in guessing what it might be.
22609 if (shortpath_for_invalid_fname(&tfname
, &pbuf
, &len
) == FAIL
)
22613 /* Count the paths backward to find the beginning of the desired string. */
22614 for (p
= tfname
+ len
- 1; p
>= tfname
; --p
)
22618 p
-= mb_head_off(tfname
, p
);
22620 if (vim_ispathsep(*p
))
22622 if (sepcount
== 0 || (hasTilde
&& sepcount
== 1))
22639 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22641 *fnamelen
= (int)STRLEN(p
);
22647 #endif /* WIN3264 */
22650 * Adjust a filename, according to a string of modifiers.
22651 * *fnamep must be NUL terminated when called. When returning, the length is
22652 * determined by *fnamelen.
22653 * Returns VALID_ flags or -1 for failure.
22654 * When there is an error, *fnamep is set to NULL.
22657 modify_fname(src
, usedlen
, fnamep
, bufp
, fnamelen
)
22658 char_u
*src
; /* string with modifiers */
22659 int *usedlen
; /* characters after src that are used */
22660 char_u
**fnamep
; /* file name so far */
22661 char_u
**bufp
; /* buffer for allocated file name or NULL */
22662 int *fnamelen
; /* length of fnamep */
22666 char_u
*s
, *p
, *pbuf
;
22667 char_u dirname
[MAXPATHL
];
22669 int has_fullname
= 0;
22671 int has_shortname
= 0;
22675 /* ":p" - full path/file_name */
22676 if (src
[*usedlen
] == ':' && src
[*usedlen
+ 1] == 'p')
22680 valid
|= VALID_PATH
;
22683 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22684 if ((*fnamep
)[0] == '~'
22685 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22686 && ((*fnamep
)[1] == '/'
22687 # ifdef BACKSLASH_IN_FILENAME
22688 || (*fnamep
)[1] == '\\'
22690 || (*fnamep
)[1] == NUL
)
22695 *fnamep
= expand_env_save(*fnamep
);
22696 vim_free(*bufp
); /* free any allocated file name */
22698 if (*fnamep
== NULL
)
22702 /* When "/." or "/.." is used: force expansion to get rid of it. */
22703 for (p
= *fnamep
; *p
!= NUL
; mb_ptr_adv(p
))
22705 if (vim_ispathsep(*p
)
22708 || vim_ispathsep(p
[2])
22710 && (p
[3] == NUL
|| vim_ispathsep(p
[3])))))
22714 /* FullName_save() is slow, don't use it when not needed. */
22715 if (*p
!= NUL
|| !vim_isAbsName(*fnamep
))
22717 *fnamep
= FullName_save(*fnamep
, *p
!= NUL
);
22718 vim_free(*bufp
); /* free any allocated file name */
22720 if (*fnamep
== NULL
)
22724 /* Append a path separator to a directory. */
22725 if (mch_isdir(*fnamep
))
22727 /* Make room for one or two extra characters. */
22728 *fnamep
= vim_strnsave(*fnamep
, (int)STRLEN(*fnamep
) + 2);
22729 vim_free(*bufp
); /* free any allocated file name */
22731 if (*fnamep
== NULL
)
22733 add_pathsep(*fnamep
);
22737 /* ":." - path relative to the current directory */
22738 /* ":~" - path relative to the home directory */
22739 /* ":8" - shortname path - postponed till after */
22740 while (src
[*usedlen
] == ':'
22741 && ((c
= src
[*usedlen
+ 1]) == '.' || c
== '~' || c
== '8'))
22747 has_shortname
= 1; /* Postpone this. */
22752 /* Need full path first (use expand_env() to remove a "~/") */
22755 if (c
== '.' && **fnamep
== '~')
22756 p
= pbuf
= expand_env_save(*fnamep
);
22758 p
= pbuf
= FullName_save(*fnamep
, FALSE
);
22769 mch_dirname(dirname
, MAXPATHL
);
22770 s
= shorten_fname(p
, dirname
);
22776 vim_free(*bufp
); /* free any allocated file name */
22784 home_replace(NULL
, p
, dirname
, MAXPATHL
, TRUE
);
22785 /* Only replace it when it starts with '~' */
22786 if (*dirname
== '~')
22788 s
= vim_strsave(dirname
);
22801 tail
= gettail(*fnamep
);
22802 *fnamelen
= (int)STRLEN(*fnamep
);
22804 /* ":h" - head, remove "/file_name", can be repeated */
22805 /* Don't remove the first "/" or "c:\" */
22806 while (src
[*usedlen
] == ':' && src
[*usedlen
+ 1] == 'h')
22808 valid
|= VALID_HEAD
;
22810 s
= get_past_head(*fnamep
);
22811 while (tail
> s
&& after_pathsep(s
, tail
))
22812 mb_ptr_back(*fnamep
, tail
);
22813 *fnamelen
= (int)(tail
- *fnamep
);
22816 *fnamelen
+= 1; /* the path separator is part of the path */
22818 if (*fnamelen
== 0)
22820 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22821 p
= vim_strsave((char_u
*)".");
22825 *bufp
= *fnamep
= tail
= p
;
22830 while (tail
> s
&& !after_pathsep(s
, tail
))
22831 mb_ptr_back(*fnamep
, tail
);
22835 /* ":8" - shortname */
22836 if (src
[*usedlen
] == ':' && src
[*usedlen
+ 1] == '8')
22845 /* Check shortname after we have done 'heads' and before we do 'tails'
22850 /* Copy the string if it is shortened by :h */
22851 if (*fnamelen
< (int)STRLEN(*fnamep
))
22853 p
= vim_strnsave(*fnamep
, *fnamelen
);
22857 *bufp
= *fnamep
= p
;
22860 /* Split into two implementations - makes it easier. First is where
22861 * there isn't a full name already, second is where there is.
22863 if (!has_fullname
&& !vim_isAbsName(*fnamep
))
22865 if (shortpath_for_partial(fnamep
, bufp
, fnamelen
) == FAIL
)
22872 /* Simple case, already have the full-name
22873 * Nearly always shorter, so try first time. */
22875 if (get_short_pathname(fnamep
, bufp
, &l
) == FAIL
)
22880 /* Couldn't find the filename.. search the paths.
22883 if (shortpath_for_invalid_fname(fnamep
, bufp
, &l
) == FAIL
)
22889 #endif /* WIN3264 */
22891 /* ":t" - tail, just the basename */
22892 if (src
[*usedlen
] == ':' && src
[*usedlen
+ 1] == 't')
22895 *fnamelen
-= (int)(tail
- *fnamep
);
22899 /* ":e" - extension, can be repeated */
22900 /* ":r" - root, without extension, can be repeated */
22901 while (src
[*usedlen
] == ':'
22902 && (src
[*usedlen
+ 1] == 'e' || src
[*usedlen
+ 1] == 'r'))
22904 /* find a '.' in the tail:
22905 * - for second :e: before the current fname
22906 * - otherwise: The last '.'
22908 if (src
[*usedlen
+ 1] == 'e' && *fnamep
> tail
)
22911 s
= *fnamep
+ *fnamelen
- 1;
22912 for ( ; s
> tail
; --s
)
22915 if (src
[*usedlen
+ 1] == 'e') /* :e */
22919 *fnamelen
+= (int)(*fnamep
- (s
+ 1));
22922 /* cut version from the extension */
22923 s
= *fnamep
+ *fnamelen
- 1;
22924 for ( ; s
> *fnamep
; --s
)
22928 *fnamelen
= s
- *fnamep
;
22931 else if (*fnamep
<= tail
)
22936 if (s
> tail
) /* remove one extension */
22937 *fnamelen
= (int)(s
- *fnamep
);
22942 /* ":s?pat?foo?" - substitute */
22943 /* ":gs?pat?foo?" - global substitute */
22944 if (src
[*usedlen
] == ':'
22945 && (src
[*usedlen
+ 1] == 's'
22946 || (src
[*usedlen
+ 1] == 'g' && src
[*usedlen
+ 2] == 's')))
22955 flags
= (char_u
*)"";
22956 s
= src
+ *usedlen
+ 2;
22957 if (src
[*usedlen
+ 1] == 'g')
22959 flags
= (char_u
*)"g";
22966 /* find end of pattern */
22967 p
= vim_strchr(s
, sep
);
22970 pat
= vim_strnsave(s
, (int)(p
- s
));
22974 /* find end of substitution */
22975 p
= vim_strchr(s
, sep
);
22978 sub
= vim_strnsave(s
, (int)(p
- s
));
22979 str
= vim_strnsave(*fnamep
, *fnamelen
);
22980 if (sub
!= NULL
&& str
!= NULL
)
22982 *usedlen
= (int)(p
+ 1 - src
);
22983 s
= do_string_sub(str
, pat
, sub
, flags
);
22987 *fnamelen
= (int)STRLEN(s
);
22999 /* after using ":s", repeat all the modifiers */
23009 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
23010 * "flags" can be "g" to do a global substitute.
23011 * Returns an allocated string, NULL for error.
23014 do_string_sub(str
, pat
, sub
, flags
)
23021 regmatch_T regmatch
;
23029 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
23031 p_cpo
= empty_option
;
23033 ga_init2(&ga
, 1, 200);
23035 do_all
= (flags
[0] == 'g');
23037 regmatch
.rm_ic
= p_ic
;
23038 regmatch
.regprog
= vim_regcomp(pat
, RE_MAGIC
+ RE_STRING
);
23039 if (regmatch
.regprog
!= NULL
)
23042 while (vim_regexec_nl(®match
, str
, (colnr_T
)(tail
- str
)))
23045 * Get some space for a temporary buffer to do the substitution
23046 * into. It will contain:
23047 * - The text up to where the match is.
23048 * - The substituted text.
23049 * - The text after the match.
23051 sublen
= vim_regsub(®match
, sub
, tail
, FALSE
, TRUE
, FALSE
);
23052 if (ga_grow(&ga
, (int)(STRLEN(tail
) + sublen
-
23053 (regmatch
.endp
[0] - regmatch
.startp
[0]))) == FAIL
)
23059 /* copy the text up to where the match is */
23060 i
= (int)(regmatch
.startp
[0] - tail
);
23061 mch_memmove((char_u
*)ga
.ga_data
+ ga
.ga_len
, tail
, (size_t)i
);
23062 /* add the substituted text */
23063 (void)vim_regsub(®match
, sub
, (char_u
*)ga
.ga_data
23064 + ga
.ga_len
+ i
, TRUE
, TRUE
, FALSE
);
23065 ga
.ga_len
+= i
+ sublen
- 1;
23066 /* avoid getting stuck on a match with an empty string */
23067 if (tail
== regmatch
.endp
[0])
23071 *((char_u
*)ga
.ga_data
+ ga
.ga_len
) = *tail
++;
23076 tail
= regmatch
.endp
[0];
23084 if (ga
.ga_data
!= NULL
)
23085 STRCPY((char *)ga
.ga_data
+ ga
.ga_len
, tail
);
23087 vim_free(regmatch
.regprog
);
23090 ret
= vim_strsave(ga
.ga_data
== NULL
? str
: (char_u
*)ga
.ga_data
);
23092 if (p_cpo
== empty_option
)
23095 /* Darn, evaluating {sub} expression changed the value. */
23096 free_string_option(save_cpo
);
23101 #endif /* defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) */