| blob | fe81d74349affa7d38836c1009c61354eab61d5f |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #ifdef AMIGA
21 #endif
23 #ifdef MACOS
25 #endif
27 #ifdef HAVE_FCNTL_H
28 # include <fcntl.h>
29 #endif
31 #if defined(FEAT_EVAL) || defined(PROTO)
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
111 /*
112 * All user-defined global variables are stored in dictionary "globvardict".
113 * "globvars_var" is the variable that is used for "g:".
114 */
117 #define globvarht globvardict.dv_hashtab
119 /*
120 * Old Vim variables such as "v:version" are also available without the "v:".
121 * Also in functions. We need a special hashtable for them.
122 */
125 /*
126 * When recursively copying lists and dicts we need to remember which ones we
127 * have done to avoid endless recursiveness. This unique ID is used for that.
128 */
131 /*
132 * Array to hold the hashtab with variables local to each sourced script.
133 * Each item holds a variable (nameless) that points to the dict_T.
134 */
136 {
137 dictitem_T sv_var;
138 dict_T sv_dict;
142 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
143 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
147 /* Values for trans_function_name() argument: */
151 /*
152 * Structure to hold info for a user function.
153 */
156 struct ufunc
157 {
163 #ifdef FEAT_PROFILE
165 /* profiling the function as a whole */
170 /* profiling the function per line */
179 #endif
181 used for s: variables */
184 start with <SNR>123_ (<SNR> is K_SPECIAL
185 KS_EXTRA KE_SNR) */
186 };
188 /* function flags */
193 /*
194 * All user-defined functions are found in this hashtable.
195 */
198 /* The names of packages that once were loaded are remembered. */
201 /* list heads for garbage collection */
205 /* From user function to hashitem and back. */
207 #define UF2HIKEY(fp) ((fp)->uf_name)
208 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
209 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
211 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
212 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
218 /* structure to hold info for a function that is currently being executed. */
221 struct funccall_S
222 {
227 {
241 #ifdef FEAT_PROFILE
243 #endif
245 };
247 /*
248 * Info used by a ":for" loop.
249 */
251 {
258 /*
259 * Struct used by trans_function_name()
260 */
262 {
269 /*
270 * Array to hold the value of v: variables.
271 * The value is in a dictitem, so that it can also be used in the v: scope.
272 * The reason to use this table anyway is for very quick access to the
273 * variables with the VV_ defines.
274 */
277 /* values for vv_flags: */
282 #define VV_NAME(s, t) s, {{t}}, {0}
284 static struct vimvar
285 {
291 {
292 /*
293 * The order here must match the VV_ defines in vim.h!
294 * Initializing a union does not work, leave tv.vval empty to get zero's.
295 */
348 };
350 /* shorthand */
351 #define vv_type vv_di.di_tv.v_type
352 #define vv_nr vv_di.di_tv.vval.v_number
353 #define vv_str vv_di.di_tv.vval.v_string
354 #define vv_tv vv_di.di_tv
356 /*
357 * The v: variables are stored in dictionary "vimvardict".
358 * "vimvars_var" is the variable that is used for the "l:" scope.
359 */
362 #define vimvarht vimvardict.dv_hashtab
366 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
367 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
368 #endif
369 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
376 #ifdef FEAT_WINDOWS
378 #endif
383 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
385 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
387 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
455 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));
456 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
480 #if defined(FEAT_INS_EXPAND)
484 #endif
590 #ifdef vim_mkdir
592 #endif
639 #ifdef HAVE_STRFTIME
641 #endif
684 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
687 valid character */
688 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
708 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
723 #ifdef FEAT_PROFILE
725 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
726 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
727 static int
728 # ifdef __BORLANDC__
729 _RTLENTRYF
730 # endif
732 static int
733 # ifdef __BORLANDC__
734 _RTLENTRYF
735 # endif
737 #endif
744 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));
752 /* Character used as separated in autoload function/variable names. */
755 /*
756 * Initialize the global and v: variables.
757 */
758 void
760 {
770 {
777 else
780 /* add to v: scope dict, unless the value is not always available */
784 /* add to compat scope dict */
786 }
787 }
789 #if defined(EXITFREE) || defined(PROTO)
790 void
792 {
797 {
800 {
803 }
804 }
808 /* script-local variables */
814 /* global variables */
817 /* functions */
821 /* autoloaded script names */
824 /* unreferenced lists and dicts */
826 }
827 #endif
829 /*
830 * Return the name of the executed function.
831 */
832 char_u *
835 {
837 }
839 /*
840 * Return the address holding the next breakpoint line for a funccall cookie.
841 */
842 linenr_T *
845 {
847 }
849 /*
850 * Return the address holding the debug tick for a funccall cookie.
851 */
855 {
857 }
859 /*
860 * Return the nesting level for a funccall cookie.
861 */
862 int
865 {
867 }
869 /* pointer to funccal for currently active function */
872 /*
873 * Return TRUE when a function was ended by a ":return" command.
874 */
875 int
877 {
879 }
882 /*
883 * Set an internal variable to a string value. Creates the variable if it does
884 * not already exist.
885 */
886 void
890 {
896 {
899 {
902 }
903 }
904 }
911 /*
912 * Start recording command output to a variable
913 * Returns OK if successfully completed the setup. FAIL otherwise.
914 */
915 int
919 {
922 typval_T tv;
924 /* Make sure a valid variable name is specified */
926 {
929 }
937 {
940 }
942 /* The output is stored in growarray "redir_ga" until redirection ends. */
945 /* Parse the variable name (can be a dict or list entry). */
947 FNE_CHECK_START);
949 {
951 /* Trailing characters are present after the variable name */
953 else
957 }
959 /* check if we can write to the variable: set it to or append an empty
960 * string */
967 else
972 {
975 }
977 {
978 /* Dictionary item was created, don't do it again. */
981 }
984 }
986 /*
987 * Append "value[value_len]" to the variable set by var_redir_start().
988 * The actual appending is postponed until redirection ends, because the value
989 * appended may in fact be the string we write to, changing it may cause freed
990 * memory to be used:
991 * :redir => foo
992 * :let foo
993 * :redir END
994 */
995 void
999 {
1007 else
1011 {
1014 }
1015 else
1017 }
1019 /*
1020 * Stop redirecting command output to a variable.
1021 */
1022 void
1024 {
1025 typval_T tv;
1028 {
1029 /* Append the trailing NUL. */
1032 /* Assign the text to the variable. */
1041 }
1044 }
1046 # if defined(FEAT_MBYTE) || defined(PROTO)
1047 int
1053 {
1070 }
1071 # endif
1073 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1074 int
1078 {
1089 {
1092 }
1094 }
1095 # endif
1097 # if defined(FEAT_DIFF) || defined(PROTO)
1098 void
1103 {
1113 }
1115 void
1120 {
1130 }
1131 # endif
1133 /*
1134 * Top level evaluation function, returning a boolean.
1135 * Sets "error" to TRUE if there was an error.
1136 * Return TRUE or FALSE.
1137 */
1138 int
1144 {
1145 typval_T tv;
1152 else
1153 {
1156 {
1159 }
1160 }
1165 }
1167 /*
1168 * Top level evaluation function, returning a string. If "skip" is TRUE,
1169 * only parsing to "nextcmd" is done, without reporting errors. Return
1170 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1171 */
1172 char_u *
1177 {
1178 typval_T tv;
1185 else
1186 {
1189 }
1194 }
1196 /*
1197 * Skip over an expression at "*pp".
1198 * Return FAIL for an error, OK otherwise.
1199 */
1200 int
1203 {
1204 typval_T rettv;
1208 }
1210 /*
1211 * Top level evaluation function, returning a string.
1212 * Return pointer to allocated memory, or NULL for failure.
1213 */
1214 char_u *
1219 {
1220 typval_T tv;
1222 garray_T ga;
1226 else
1227 {
1229 {
1234 }
1235 else
1238 }
1241 }
1243 /*
1244 * Call eval_to_string() without using current local variables and using
1245 * textlock. When "use_sandbox" is TRUE use the sandbox.
1246 */
1247 char_u *
1252 {
1266 }
1268 /*
1269 * Top level evaluation function, returning a number.
1270 * Evaluates "expr" silently.
1271 * Returns -1 for an error.
1272 */
1273 int
1276 {
1277 typval_T rettv;
1285 else
1286 {
1289 }
1293 }
1295 /*
1296 * Prepare v: variable "idx" to be used.
1297 * Save the current typeval in "save_tv".
1298 * When not used yet add the variable to the v: hashtable.
1299 */
1300 static void
1304 {
1308 }
1310 /*
1311 * Restore v: variable "idx" to typeval "save_tv".
1312 * When no longer defined, remove the variable from the v: hashtable.
1313 */
1314 static void
1318 {
1323 {
1327 else
1329 }
1330 }
1332 #if defined(FEAT_SPELL) || defined(PROTO)
1333 /*
1334 * Evaluate an expression to a list with suggestions.
1335 * For the "expr:" part of 'spellsuggest'.
1336 */
1337 list_T *
1341 {
1342 typval_T save_val;
1343 typval_T rettv;
1347 /* Set "v:val" to the bad word. */
1355 {
1358 else
1360 }
1367 }
1369 /*
1370 * "list" is supposed to contain two items: a word and a number. Return the
1371 * word in "pp" and the number as the return value.
1372 * Return -1 if anything isn't right.
1373 * Used to get the good word and score from the eval_spell_expr() result.
1374 */
1375 int
1379 {
1391 }
1392 #endif
1394 /*
1395 * Top level evaluation function.
1396 * Returns an allocated typval_T with the result.
1397 * Returns NULL when there is an error.
1398 */
1399 typval_T *
1403 {
1408 {
1411 }
1414 }
1417 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1418 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1419 /*
1420 * Call some vimL function and return the result in "*rettv".
1421 * Uses argv[argc] for the function arguments.
1422 * Returns OK or FAIL.
1423 */
1424 static int
1431 {
1445 {
1446 /* Pass a NULL or empty argument as an empty string */
1448 {
1452 }
1454 /* Recognize a number argument, the others must be strings. */
1457 {
1460 }
1461 else
1462 {
1465 }
1466 }
1469 {
1472 }
1479 {
1482 }
1489 }
1491 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1492 /*
1493 * Call vimL function "func" and return the result as a string.
1494 * Returns NULL when calling the function fails.
1495 * Uses argv[argc] for the function arguments.
1496 */
1503 {
1504 typval_T rettv;
1513 }
1514 # endif
1516 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1517 /*
1518 * Call vimL function "func" and return the result as a number.
1519 * Returns -1 when calling the function fails.
1520 * Uses argv[argc] for the function arguments.
1521 */
1522 long
1528 {
1529 typval_T rettv;
1538 }
1539 # endif
1541 /*
1542 * Call vimL function "func" and return the result as a list
1543 * Uses argv[argc] for the function arguments.
1544 */
1551 {
1552 typval_T rettv;
1558 {
1561 }
1564 }
1565 #endif
1568 /*
1569 * Save the current function call pointer, and set it to NULL.
1570 * Used when executing autocommands and for ":source".
1571 */
1574 {
1579 }
1581 void
1584 {
1588 }
1590 #if defined(FEAT_PROFILE) || defined(PROTO)
1591 /*
1592 * Prepare profiling for entering a child or something else that is not
1593 * counted for the script/function itself.
1594 * Should always be called in pair with prof_child_exit().
1595 */
1596 void
1599 {
1605 }
1607 /*
1608 * Take care of time spent in a child.
1609 * Should always be called after prof_child_enter().
1610 */
1611 void
1614 {
1618 {
1623 }
1625 }
1626 #endif
1629 #ifdef FEAT_FOLDING
1630 /*
1631 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1632 * it in "*cp". Doesn't give error messages.
1633 */
1634 int
1638 {
1639 typval_T tv;
1643 OPT_LOCAL);
1652 else
1653 {
1654 /* If the result is a number, just return the number. */
1659 else
1660 {
1661 /* If the result is a string, check if there is a non-digit before
1662 * the number. */
1667 }
1669 }
1676 }
1677 #endif
1679 /*
1680 * ":let" list all variable values
1681 * ":let var1 var2" list variable values
1682 * ":let var = expr" assignment command.
1683 * ":let var += expr" assignment command.
1684 * ":let var -= expr" assignment command.
1685 * ":let var .= expr" assignment command.
1686 * ":let [var1, var2] = expr" unpack list.
1687 */
1688 void
1691 {
1694 typval_T rettv;
1709 {
1710 /*
1711 * ":let" without "=": list variables
1712 */
1716 /* ":let var1 var2" */
1719 {
1720 /* ":let" */
1724 #ifdef FEAT_WINDOWS
1726 #endif
1730 }
1732 }
1733 else
1734 {
1738 {
1741 }
1748 {
1752 }
1754 {
1756 op);
1758 }
1759 }
1760 }
1762 /*
1763 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1764 * Handles both "var" with any type and "[var, var; var]" with a list type.
1765 * When "nextchars" is not NULL it points to a string with characters that
1766 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1767 * or concatenate.
1768 * Returns OK or FAIL;
1769 */
1770 static int
1778 {
1783 typval_T ltv;
1786 {
1787 /*
1788 * ":let var = expr" or ":for var in list"
1789 */
1793 }
1795 /*
1796 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1797 */
1799 {
1802 }
1806 {
1809 }
1811 {
1814 }
1818 {
1827 {
1828 /* Put the rest of the list (may be empty) in the var after ';'.
1829 * Create a new list for this. */
1834 {
1837 }
1850 }
1852 {
1855 }
1856 }
1859 }
1861 /*
1862 * Skip over assignable variable "var" or list of variables "[var, var]".
1863 * Used for ":let varvar = expr" and ":for varvar in expr".
1864 * For "[var, var]" increment "*var_count" for each variable.
1865 * for "[var, var; var]" set "semicolon".
1866 * Return NULL for an error.
1867 */
1873 {
1877 {
1878 /* "[var, var]": find the matching ']'. */
1881 {
1885 {
1888 }
1895 {
1897 {
1900 }
1902 }
1904 {
1907 }
1908 }
1910 }
1911 else
1913 }
1915 /*
1916 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1917 * l[idx].
1918 */
1922 {
1927 }
1929 /*
1930 * List variables for hashtab "ht" with prefix "prefix".
1931 * If "empty" is TRUE also list NULL strings as empty strings.
1932 */
1933 static void
1939 {
1946 {
1948 {
1954 }
1955 }
1956 }
1958 /*
1959 * List global variables.
1960 */
1961 static void
1964 {
1966 }
1968 /*
1969 * List buffer variables.
1970 */
1971 static void
1974 {
1983 }
1985 /*
1986 * List window variables.
1987 */
1988 static void
1991 {
1994 }
1996 #ifdef FEAT_WINDOWS
1997 /*
1998 * List tab page variables.
1999 */
2000 static void
2003 {
2006 }
2007 #endif
2009 /*
2010 * List Vim variables.
2011 */
2012 static void
2015 {
2017 }
2019 /*
2020 * List script-local variables, if there is a script.
2021 */
2022 static void
2025 {
2029 }
2031 /*
2032 * List function variables, if there is a function.
2033 */
2034 static void
2037 {
2041 }
2043 /*
2044 * List variables in "arg".
2045 */
2051 {
2058 typval_T tv;
2061 {
2063 {
2066 {
2070 }
2071 }
2072 else
2073 {
2074 /* get_name_len() takes care of expanding curly braces */
2078 {
2079 /* This is mainly to keep test 49 working: when expanding
2080 * curly braces fails overrule the exception error message. */
2082 {
2086 }
2088 }
2089 else
2090 {
2095 else
2096 {
2097 /* handle d.key, l[idx], f(expr) */
2101 else
2102 {
2104 {
2106 {
2110 #ifdef FEAT_WINDOWS
2112 #endif
2118 }
2119 }
2120 else
2121 {
2134 first);
2137 }
2139 }
2140 }
2141 }
2144 }
2147 }
2150 }
2152 /*
2153 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2154 * Returns a pointer to the char just after the var name.
2155 * Returns NULL if there is an error.
2156 */
2164 {
2173 /*
2174 * ":let $VAR = expr": Set environment variable.
2175 */
2177 {
2178 /* Find the end of the name. */
2184 else
2185 {
2191 else
2192 {
2197 {
2202 {
2206 }
2207 }
2209 {
2219 }
2222 }
2223 }
2224 }
2226 /*
2227 * ":let &option = expr": Set option value.
2228 * ":let &l:option = expr": Set local option value.
2229 * ":let &g:option = expr": Set global option value.
2230 */
2232 {
2233 /* Find the end of the name. */
2238 else
2239 {
2252 {
2258 else
2259 {
2261 {
2264 else
2266 }
2268 {
2272 }
2273 }
2274 }
2276 {
2279 }
2282 }
2283 }
2285 /*
2286 * ":let @r = expr": Set register contents.
2287 */
2289 {
2296 else
2297 {
2303 {
2306 {
2309 }
2310 }
2312 {
2315 }
2317 }
2318 }
2320 /*
2321 * ":let var = expr": Set internal variable.
2322 * ":let {expr} = expr": Idem, name made with curly braces
2323 */
2325 {
2326 lval_T lv;
2330 {
2333 else
2334 {
2337 }
2338 }
2340 }
2342 else
2346 }
2348 /*
2349 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2350 */
2351 static int
2354 {
2356 {
2359 }
2361 }
2363 /*
2364 * Get an lval: variable, Dict item or List item that can be assigned a value
2365 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2366 * "name.key", "name.key[expr]" etc.
2367 * Indexing only works if "name" is an existing List or Dictionary.
2368 * "name" points to the start of the name.
2369 * If "rettv" is not NULL it points to the value to be assigned.
2370 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2371 * wrong; must end in space or cmd separator.
2372 *
2373 * Returns a pointer to just after the name, including indexes.
2374 * When an evaluation error occurs "lp->ll_name" is NULL;
2375 * Returns NULL for a parsing error. Still need to free items in "lp"!
2376 */
2386 {
2391 typval_T var1;
2392 typval_T var2;
2399 /* Clear everything in "lp". */
2403 {
2404 /* When skipping just find the end of the name. */
2407 }
2409 /* Find the end of the name. */
2412 {
2413 /* Don't expand the name when we already know there is an error. */
2416 {
2419 }
2423 {
2424 /* Report an invalid expression in braces, unless the
2425 * expression evaluation has been cancelled due to an
2426 * aborting error, an interrupt, or an exception. */
2428 {
2432 }
2433 }
2435 }
2436 else
2439 /* Without [idx] or .key we are done. */
2452 /*
2453 * Loop until no more [idx] or .key is following.
2454 */
2457 {
2461 {
2465 }
2467 {
2471 }
2475 {
2478 ;
2480 {
2484 }
2486 }
2487 else
2488 {
2489 /* Get the index [expr] or the first index [expr: ]. */
2493 else
2494 {
2499 {
2500 /* not a number or string */
2503 }
2504 }
2506 /* Optionally get the second index [ :expr]. */
2508 {
2510 {
2516 }
2519 {
2525 }
2529 else
2530 {
2533 {
2537 }
2539 {
2540 /* not a number or string */
2545 }
2546 }
2548 }
2549 else
2553 {
2561 }
2563 /* Skip to past ']'. */
2565 }
2568 {
2570 {
2571 /* "[key]": get key from "var1" */
2574 {
2579 }
2580 }
2585 {
2586 /* Key does not exist in dict: may need to add it. */
2588 {
2594 }
2597 else
2604 }
2608 }
2609 else
2610 {
2611 /*
2612 * Get the number and item for the only or first index of the List.
2613 */
2616 else
2617 {
2620 }
2625 {
2627 {
2630 }
2631 }
2633 {
2637 }
2639 /*
2640 * May need to find the item or absolute index for the second
2641 * index of a range.
2642 * When no index given: "lp->ll_empty2" is TRUE.
2643 * Otherwise "lp->ll_n2" is set to the second index.
2644 */
2646 {
2650 {
2655 }
2657 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2662 }
2665 }
2666 }
2669 }
2671 /*
2672 * Clear lval "lp" that was filled by get_lval().
2673 */
2674 static void
2677 {
2680 }
2682 /*
2683 * Set a variable that was parsed by get_lval() to "rettv".
2684 * "endp" points to just after the parsed name.
2685 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2686 */
2687 static void
2694 {
2700 {
2702 {
2706 {
2707 typval_T tv;
2709 /* handle +=, -= and .= */
2712 {
2716 }
2717 }
2718 else
2721 }
2722 }
2726 ;
2728 {
2729 /*
2730 * Assign the List values to the list items.
2731 */
2733 {
2736 else
2737 {
2740 }
2745 {
2746 /* Need to add an empty item. */
2748 {
2751 }
2752 }
2755 }
2762 }
2763 else
2764 {
2765 /*
2766 * Assign to a List or Dictionary item.
2767 */
2769 {
2771 {
2774 }
2776 /* Need to add an item to the Dictionary. */
2781 {
2784 }
2786 }
2788 {
2791 }
2792 else
2795 /*
2796 * Assign the value to the variable or list item.
2797 */
2800 else
2801 {
2805 }
2806 }
2807 }
2809 /*
2810 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2811 * Returns OK or FAIL.
2812 */
2813 static int
2818 {
2823 /* Can't do anything with a Funcref or a Dict on the right. */
2825 {
2827 {
2835 /* List += List */
2845 {
2846 /* nr += nr or nr -= nr*/
2850 else
2855 }
2856 else
2857 {
2858 /* str .= str */
2864 }
2866 }
2867 }
2871 }
2873 /*
2874 * Add a watcher to a list.
2875 */
2876 static void
2880 {
2883 }
2885 /*
2886 * Remove a watcher from a list.
2887 * No warning when it isn't found...
2888 */
2889 static void
2893 {
2898 {
2900 {
2903 }
2905 }
2906 }
2908 /*
2909 * Just before removing an item from a list: advance watchers to the next
2910 * item.
2911 */
2912 static void
2916 {
2922 }
2924 /*
2925 * Evaluate the expression used in a ":for var in expr" command.
2926 * "arg" points to "var".
2927 * Set "*errp" to TRUE for an error, FALSE otherwise;
2928 * Return a pointer that holds the info. Null when there is an error.
2929 */
2936 {
2939 typval_T tv;
2954 {
2957 }
2962 {
2965 {
2968 {
2971 }
2972 else
2973 {
2974 /* No need to increment the refcount, it's already set for the
2975 * list being used in "tv". */
2979 }
2980 }
2981 }
2986 }
2988 /*
2989 * Use the first item in a ":for" list. Advance to the next.
2990 * Assign the values to the variable (list). "arg" points to the first one.
2991 * Return TRUE when a valid item was found, FALSE when at end of list or
2992 * something wrong.
2993 */
2994 int
2998 {
3006 else
3007 {
3011 }
3013 }
3015 /*
3016 * Free the structure used to store info used by ":for".
3017 */
3018 void
3021 {
3025 {
3028 }
3030 }
3032 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3034 void
3038 cmdidx_T cmdidx;
3039 {
3045 {
3048 {
3049 /* ":let var1 var2 ...": find last space. */
3051 {
3056 }
3058 }
3059 }
3060 else
3065 {
3068 {
3071 {
3075 }
3077 {
3082 }
3083 }
3085 {
3086 /* environment variable */
3088 }
3090 {
3093 }
3097 {
3098 /* Function name can start with "<SNR>" */
3100 }
3102 {
3104 {
3109 }
3111 {
3112 /* Trick: '' is like stopping and starting a literal string. */
3116 }
3118 {
3120 {
3123 }
3124 else
3126 }
3127 else
3129 }
3130 else
3131 /* Doesn't look like something valid, expand as an expression
3132 * anyway. */
3138 }
3140 }
3144 /*
3145 * ":1,25call func(arg1, arg2)" function call.
3146 */
3147 void
3150 {
3156 typval_T rettv;
3157 linenr_T lnum;
3160 funcdict_T fudi;
3164 {
3165 /* Still need to give an error message for missing key. */
3168 }
3172 /* Increase refcount on dictionary, it could get deleted when evaluating
3173 * the arguments. */
3177 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3181 /* Skip white space to allow ":call func ()". Not good, but required for
3182 * backward compatibility. */
3187 {
3190 }
3192 /*
3193 * When skipping, evaluate the function once, to find the end of the
3194 * arguments.
3195 * When the function takes a range, this is discovered after the first
3196 * call, and the loop is broken.
3197 */
3199 {
3202 }
3203 else
3206 {
3208 {
3211 }
3216 {
3219 }
3221 /* Handle a function returning a Funcref, Dictionary or List. */
3223 {
3226 }
3232 /* Stop when immediately aborting on error, or when an interrupt
3233 * occurred or an exception was thrown but not caught.
3234 * get_func_tv() returned OK, so that the check for trailing
3235 * characters below is executed. */
3238 }
3243 {
3244 /* Check for trailing illegal characters and a following command. */
3246 {
3249 }
3250 else
3252 }
3254 end:
3257 }
3259 /*
3260 * ":unlet[!] var1 ... " command.
3261 */
3262 void
3265 {
3267 }
3269 /*
3270 * ":lockvar" and ":unlockvar" commands
3271 */
3272 void
3275 {
3282 {
3285 }
3288 }
3290 /*
3291 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3292 */
3293 static void
3298 {
3302 lval_T lv;
3304 do
3305 {
3306 /* Parse the name and find the end. */
3308 FNE_CHECK_START);
3313 {
3315 {
3318 }
3322 }
3325 {
3327 {
3330 }
3331 else
3332 {
3336 }
3337 }
3346 }
3348 static int
3353 {
3358 {
3362 /* Normal name or expanded name. */
3368 }
3372 {
3375 /* Delete a range of List items. */
3377 {
3382 }
3383 }
3384 else
3385 {
3387 /* unlet a List item. */
3389 else
3390 /* unlet a Dictionary item. */
3392 }
3395 }
3397 /*
3398 * "unlet" a variable. Return OK if it existed, FAIL if not.
3399 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3400 */
3401 int
3405 {
3412 {
3415 {
3422 }
3423 }
3428 }
3430 /*
3431 * Lock or unlock variable indicated by "lp".
3432 * "deep" is the levels to go (-1 for unlimited);
3433 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3434 */
3435 static int
3441 {
3450 {
3454 /* Normal name or expanded name. */
3457 else
3458 {
3462 else
3463 {
3466 else
3469 }
3470 }
3472 }
3474 {
3477 /* (un)lock a range of List items. */
3479 {
3483 }
3484 }
3486 /* (un)lock a List item. */
3488 else
3489 /* un(lock) a Dictionary item. */
3493 }
3495 /*
3496 * Lock or unlock an item. "deep" is nr of levels to go.
3497 */
3498 static void
3503 {
3512 {
3515 }
3520 /* lock/unlock the item itself */
3523 else
3527 {
3530 {
3533 else
3536 /* recursive: lock/unlock the items the List contains */
3539 }
3543 {
3546 else
3549 {
3550 /* recursive: lock/unlock the items the List contains */
3553 {
3555 {
3558 }
3559 }
3560 }
3561 }
3562 }
3564 }
3566 /*
3567 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3568 * it refers to a List or Dictionary that is locked.
3569 */
3570 static int
3573 {
3581 }
3583 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3584 /*
3585 * Delete all "menutrans_" variables.
3586 */
3587 void
3589 {
3596 {
3598 {
3602 }
3603 }
3605 }
3606 #endif
3608 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3610 /*
3611 * Local string buffer for the next two functions to store a variable name
3612 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3613 * get_user_var_name().
3614 */
3621 /*
3622 * Function to concatenate a prefix and a variable name.
3623 */
3628 {
3633 {
3638 {
3641 }
3643 }
3648 }
3650 /*
3651 * Function given to ExpandGeneric() to obtain the list of user defined
3652 * (global/buffer/window/built-in) variable names.
3653 */
3654 /*ARGSUSED*/
3655 char_u *
3659 {
3663 #ifdef FEAT_WINDOWS
3665 #endif
3671 {
3673 #ifdef FEAT_WINDOWS
3675 #endif
3676 }
3678 /* Global variables */
3680 {
3683 else
3690 }
3692 /* b: variables */
3695 {
3698 else
3703 }
3705 {
3708 }
3710 /* w: variables */
3713 {
3716 else
3721 }
3723 #ifdef FEAT_WINDOWS
3724 /* t: variables */
3727 {
3730 else
3735 }
3736 #endif
3738 /* v: variables */
3746 }
3750 /*
3751 * types for expressions.
3752 */
3754 {
3766 /*
3767 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3768 * executed. The function may return OK, but the rettv will be of type
3769 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3770 */
3772 /*
3773 * Handle zero level expression.
3774 * This calls eval1() and handles error message and nextcmd.
3775 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3776 * Note: "rettv.v_lock" is not set.
3777 * Return OK or FAIL.
3778 */
3779 static int
3785 {
3792 {
3795 /*
3796 * Report the invalid expression unless the expression evaluation has
3797 * been cancelled due to an aborting error, an interrupt, or an
3798 * exception.
3799 */
3803 }
3808 }
3810 /*
3811 * Handle top level expression:
3812 * expr1 ? expr0 : expr0
3813 *
3814 * "arg" must point to the first non-white of the expression.
3815 * "arg" is advanced to the next non-white after the recognized expression.
3816 *
3817 * Note: "rettv.v_lock" is not set.
3818 *
3819 * Return OK or FAIL.
3820 */
3821 static int
3826 {
3828 typval_T var2;
3830 /*
3831 * Get the first variable.
3832 */
3837 {
3840 {
3848 }
3850 /*
3851 * Get the second variable.
3852 */
3857 /*
3858 * Check for the ":".
3859 */
3861 {
3866 }
3868 /*
3869 * Get the third variable.
3870 */
3873 {
3877 }
3880 }
3883 }
3885 /*
3886 * Handle first level expression:
3887 * expr2 || expr2 || expr2 logical OR
3888 *
3889 * "arg" must point to the first non-white of the expression.
3890 * "arg" is advanced to the next non-white after the recognized expression.
3891 *
3892 * Return OK or FAIL.
3893 */
3894 static int
3899 {
3900 typval_T var2;
3905 /*
3906 * Get the first variable.
3907 */
3911 /*
3912 * Repeat until there is no following "||".
3913 */
3917 {
3919 {
3926 }
3928 /*
3929 * Get the second variable.
3930 */
3935 /*
3936 * Compute the result.
3937 */
3939 {
3945 }
3947 {
3950 }
3951 }
3954 }
3956 /*
3957 * Handle second level expression:
3958 * expr3 && expr3 && expr3 logical AND
3959 *
3960 * "arg" must point to the first non-white of the expression.
3961 * "arg" is advanced to the next non-white after the recognized expression.
3962 *
3963 * Return OK or FAIL.
3964 */
3965 static int
3970 {
3971 typval_T var2;
3976 /*
3977 * Get the first variable.
3978 */
3982 /*
3983 * Repeat until there is no following "&&".
3984 */
3988 {
3990 {
3997 }
3999 /*
4000 * Get the second variable.
4001 */
4006 /*
4007 * Compute the result.
4008 */
4010 {
4016 }
4018 {
4021 }
4022 }
4025 }
4027 /*
4028 * Handle third level expression:
4029 * var1 == var2
4030 * var1 =~ var2
4031 * var1 != var2
4032 * var1 !~ var2
4033 * var1 > var2
4034 * var1 >= var2
4035 * var1 < var2
4036 * var1 <= var2
4037 * var1 is var2
4038 * var1 isnot var2
4039 *
4040 * "arg" must point to the first non-white of the expression.
4041 * "arg" is advanced to the next non-white after the recognized expression.
4042 *
4043 * Return OK or FAIL.
4044 */
4045 static int
4050 {
4051 typval_T var2;
4060 regmatch_T regmatch;
4064 /*
4065 * Get the first variable.
4066 */
4072 {
4084 {
4087 }
4088 else
4092 {
4095 }
4096 else
4100 {
4104 {
4107 }
4108 }
4110 }
4112 /*
4113 * If there is a comparitive operator, use it.
4114 */
4116 {
4117 /* extra question mark appended: ignore case */
4119 {
4122 }
4123 /* extra '#' appended: match case */
4125 {
4128 }
4129 /* nothing appened: use 'ignorecase' */
4130 else
4133 /*
4134 * Get the second variable.
4135 */
4138 {
4141 }
4144 {
4146 {
4147 /* For "is" a different type always means FALSE, for "notis"
4148 * it means TRUE. */
4150 }
4152 {
4154 {
4159 }
4162 {
4165 else
4170 }
4171 else
4172 {
4173 /* Compare two Lists for being equal or unequal. */
4177 }
4178 }
4181 {
4183 {
4188 }
4191 {
4194 else
4199 }
4200 else
4201 {
4202 /* Compare two Dictionaries for being equal or unequal. */
4206 }
4207 }
4210 {
4213 {
4216 else
4221 }
4222 else
4223 {
4224 /* Compare two Funcrefs for being equal or unequal. */
4228 else
4233 }
4234 }
4236 /*
4237 * If one of the two variables is a number, compare as a number.
4238 * When using "=~" or "!~", always compare as string.
4239 */
4242 {
4246 {
4256 }
4257 }
4258 else
4259 {
4264 else
4268 {
4278 /* avoid 'l' flag in 'cpoptions' */
4285 {
4290 }
4295 }
4296 }
4301 }
4302 }
4305 }
4307 /*
4308 * Handle fourth level expression:
4309 * + number addition
4310 * - number subtraction
4311 * . string concatenation
4312 *
4313 * "arg" must point to the first non-white of the expression.
4314 * "arg" is advanced to the next non-white after the recognized expression.
4315 *
4316 * Return OK or FAIL.
4317 */
4318 static int
4323 {
4324 typval_T var2;
4325 typval_T var3;
4332 /*
4333 * Get the first variable.
4334 */
4338 /*
4339 * Repeat computing, until no '+', '-' or '.' is following.
4340 */
4342 {
4348 {
4349 /* For "list + ...", an illegal use of the first operand as
4350 * a number cannot be determined before evaluating the 2nd
4351 * operand: if this is also a list, all is ok.
4352 * For "something . ...", "something - ..." or "non-list + ...",
4353 * we know that the first operand needs to be a string or number
4354 * without evaluating the 2nd operand. So check before to avoid
4355 * side effects after an error. */
4357 {
4360 }
4361 }
4363 /*
4364 * Get the second variable.
4365 */
4368 {
4371 }
4374 {
4375 /*
4376 * Compute the result.
4377 */
4379 {
4383 {
4387 }
4392 }
4395 {
4396 /* concatenate Lists */
4399 {
4403 }
4406 }
4407 else
4408 {
4413 {
4414 /* This can only happen for "list + non-list".
4415 * For "non-list + ..." or "something - ...", we returned
4416 * before evaluating the 2nd operand. */
4419 }
4422 {
4426 }
4430 else
4434 }
4436 }
4437 }
4439 }
4441 /*
4442 * Handle fifth level expression:
4443 * * number multiplication
4444 * / number division
4445 * % number modulo
4446 *
4447 * "arg" must point to the first non-white of the expression.
4448 * "arg" is advanced to the next non-white after the recognized expression.
4449 *
4450 * Return OK or FAIL.
4451 */
4452 static int
4457 {
4458 typval_T var2;
4463 /*
4464 * Get the first variable.
4465 */
4469 /*
4470 * Repeat computing, until no '*', '/' or '%' is following.
4471 */
4473 {
4479 {
4484 }
4485 else
4488 /*
4489 * Get the second variable.
4490 */
4496 {
4502 /*
4503 * Compute the result.
4504 */
4508 {
4511 else
4513 }
4514 else
4515 {
4518 else
4520 }
4523 }
4524 }
4527 }
4529 /*
4530 * Handle sixth level expression:
4531 * number number constant
4532 * "string" string constant
4533 * 'string' literal string constant
4534 * &option-name option value
4535 * @r register contents
4536 * identifier variable value
4537 * function() function call
4538 * $VAR environment variable
4539 * (expression) nested expression
4540 * [expr, expr] List
4541 * {key: val, key: val} Dictionary
4542 *
4543 * Also handle:
4544 * ! in front logical NOT
4545 * - in front unary minus
4546 * + in front unary plus (ignored)
4547 * trailing [] subscript in String or List
4548 * trailing .name entry in Dictionary
4549 *
4550 * "arg" must point to the first non-white of the expression.
4551 * "arg" is advanced to the next non-white after the recognized expression.
4552 *
4553 * Return OK or FAIL.
4554 */
4555 static int
4560 {
4569 /*
4570 * Initialise variable so that clear_tv() can't mistake this for a
4571 * string and free a string that isn't there.
4572 */
4575 /*
4576 * Skip '!' and '-' characters. They are handled later.
4577 */
4584 {
4585 /*
4586 * Number constant.
4587 */
4601 {
4604 }
4607 /*
4608 * String constant: "string".
4609 */
4613 /*
4614 * Literal string constant: 'str''ing'.
4615 */
4619 /*
4620 * List: [expr, expr]
4621 */
4625 /*
4626 * Dictionary: {key: val, key: val}
4627 */
4631 /*
4632 * Option value: &name
4633 */
4637 /*
4638 * Environment variable: $VAR.
4639 */
4643 /*
4644 * Register contents: @r.
4645 */
4648 {
4651 }
4656 /*
4657 * nested expression: (expression).
4658 */
4664 {
4668 }
4673 }
4676 {
4677 /*
4678 * Must be a variable or function name.
4679 * Can also be a curly-braces kind of name: {expr}.
4680 */
4688 else
4689 {
4691 {
4692 /* If "s" is the name of a variable of type VAR_FUNC
4693 * use its contents. */
4696 /* Invoke the function. */
4700 /* Stop the expression evaluation when immediately
4701 * aborting on error, or when an interrupt occurred or
4702 * an exception was thrown but not caught. */
4704 {
4708 }
4709 }
4712 else
4714 }
4718 }
4722 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4723 * expr(expr). */
4727 /*
4728 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4729 */
4731 {
4736 {
4739 }
4740 else
4741 {
4743 {
4749 }
4753 }
4754 }
4757 }
4759 /*
4760 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4761 * "*arg" points to the '[' or '.'.
4762 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4763 */
4764 static int
4770 {
4780 {
4784 }
4787 {
4788 /*
4789 * dict.name
4790 */
4793 ;
4797 }
4798 else
4799 {
4800 /*
4801 * something[idx]
4802 *
4803 * Get the (first) variable from inside the [].
4804 */
4811 {
4812 /* not a number or string */
4815 }
4817 /*
4818 * Get the second variable from inside the [:].
4819 */
4821 {
4827 {
4831 }
4833 {
4834 /* not a number or string */
4839 }
4840 }
4842 /* Check for the ']'. */
4844 {
4851 }
4853 }
4856 {
4859 {
4862 }
4864 {
4867 else
4868 {
4871 }
4872 }
4875 {
4881 {
4882 /* The resulting variable is a substring. If the indexes
4883 * are out of range the result is empty. */
4885 {
4889 }
4896 else
4898 }
4899 else
4900 {
4901 /* The resulting variable is a string of a single
4902 * character. If the index is too big or negative the
4903 * result is empty. */
4906 else
4908 }
4919 {
4920 /* For a range we allow invalid values and return an empty
4921 * list. A list index out of range is an error. */
4923 {
4927 }
4929 }
4931 {
4946 {
4948 {
4951 }
4953 }
4958 }
4959 else
4960 {
4964 }
4969 {
4975 }
4976 {
4980 {
4983 {
4988 }
4989 }
5003 }
5005 }
5006 }
5009 }
5011 /*
5012 * Get an option value.
5013 * "arg" points to the '&' or '+' before the option name.
5014 * "arg" is advanced to character after the option name.
5015 * Return OK or FAIL.
5016 */
5017 static int
5022 {
5032 /*
5033 * Isolate the option name and find its value.
5034 */
5037 {
5041 }
5044 {
5047 }
5055 {
5059 }
5061 {
5063 {
5066 }
5068 {
5071 }
5073 {
5076 }
5078 {
5081 }
5082 }
5090 }
5092 /*
5093 * Allocate a variable for a string constant.
5094 * Return OK or FAIL.
5095 */
5096 static int
5101 {
5106 /*
5107 * Find the end of the string, skipping backslashed characters.
5108 */
5110 {
5112 {
5114 /* A "\<x>" form occupies at least 4 characters, and produces up
5115 * to 6 characters: reserve space for 2 extra */
5118 }
5119 }
5122 {
5125 }
5127 /* If only parsing, set *arg and return here */
5129 {
5132 }
5134 /*
5135 * Copy the string into allocated memory, handling backslashed
5136 * characters.
5137 */
5145 {
5147 {
5149 {
5162 {
5168 else
5172 {
5175 }
5177 #ifdef FEAT_MBYTE
5178 /* For "\u" store the number according to
5179 * 'encoding'. */
5182 else
5183 #endif
5185 }
5188 /* octal: "\1", "\12", "\123" */
5198 {
5202 }
5206 /* Special key, e.g.: "\<C-W>" */
5209 {
5212 }
5213 /* FALLTHROUGH */
5217 }
5218 }
5219 else
5222 }
5227 }
5229 /*
5230 * Allocate a variable for a 'str''ing' constant.
5231 * Return OK or FAIL.
5232 */
5233 static int
5238 {
5243 /*
5244 * Find the end of the string, skipping ''.
5245 */
5247 {
5249 {
5254 }
5255 }
5258 {
5261 }
5263 /* If only parsing return after setting "*arg" */
5265 {
5268 }
5270 /*
5271 * Copy the string into allocated memory, handling '' to ' reduction.
5272 */
5280 {
5282 {
5286 }
5288 }
5293 }
5295 /*
5296 * Allocate a variable for a List and fill it from "*arg".
5297 * Return OK or FAIL.
5298 */
5299 static int
5304 {
5306 typval_T tv;
5310 {
5314 }
5318 {
5322 {
5325 {
5329 }
5330 else
5332 }
5337 {
5340 }
5342 }
5345 {
5347 failret:
5351 }
5355 {
5359 }
5362 }
5364 /*
5365 * Allocate an empty header for a list.
5366 * Caller should take care of the reference count.
5367 */
5368 list_T *
5370 {
5375 {
5376 /* Prepend the list to the list of lists for garbage collection. */
5382 }
5384 }
5386 /*
5387 * Allocate an empty list for a return value.
5388 * Returns OK or FAIL.
5389 */
5390 static int
5393 {
5403 }
5405 /*
5406 * Unreference a list: decrement the reference count and free it when it
5407 * becomes zero.
5408 */
5409 void
5412 {
5415 }
5417 /*
5418 * Free a list, including all items it points to.
5419 * Ignores the reference count.
5420 */
5421 void
5425 {
5428 /* Remove the list from the list of lists for garbage collection. */
5431 else
5437 {
5438 /* Remove the item before deleting it. */
5444 }
5446 }
5448 /*
5449 * Allocate a list item.
5450 */
5453 {
5455 }
5457 /*
5458 * Free a list item. Also clears the value. Does not notify watchers.
5459 */
5460 static void
5463 {
5466 }
5468 /*
5469 * Remove a list item from a List and free it. Also clears the value.
5470 */
5471 static void
5475 {
5478 }
5480 /*
5481 * Get the number of items in a list.
5482 */
5483 static long
5486 {
5490 }
5492 /*
5493 * Return TRUE when two lists have exactly the same values.
5494 */
5495 static int
5500 {
5514 }
5516 #if defined(FEAT_PYTHON) || defined(PROTO)
5517 /*
5518 * Return the dictitem that an entry in a hashtable points to.
5519 */
5520 dictitem_T *
5523 {
5525 }
5526 #endif
5528 /*
5529 * Return TRUE when two dictionaries have exactly the same key/values.
5530 */
5531 static int
5536 {
5548 {
5550 {
5557 }
5558 }
5560 }
5562 /*
5563 * Return TRUE if "tv1" and "tv2" have the same value.
5564 * Compares the items just like "==" would compare them, but strings and
5565 * numbers are different.
5566 */
5567 static int
5572 {
5580 /* Catch lists and dicts that have an endless loop by limiting
5581 * recursiveness to 1000. We guess they are equal then. */
5586 {
5611 }
5615 }
5617 /*
5618 * Locate item with index "n" in list "l" and return it.
5619 * A negative index is counted from the end; -1 is the last item.
5620 * Returns NULL when "n" is out of range.
5621 */
5626 {
5633 /* Negative index is relative to the end. */
5637 /* Check for index out of range. */
5641 /* When there is a cached index may start search from there. */
5643 {
5645 {
5646 /* closest to the start of the list */
5649 }
5651 {
5652 /* closest to the end of the list */
5655 }
5656 else
5657 {
5658 /* closest to the cached index */
5661 }
5662 }
5663 else
5664 {
5666 {
5667 /* closest to the start of the list */
5670 }
5671 else
5672 {
5673 /* closest to the end of the list */
5676 }
5677 }
5680 {
5681 /* search forward */
5684 }
5686 {
5687 /* search backward */
5690 }
5692 /* cache the used index */
5697 }
5699 /*
5700 * Get list item "l[idx]" as a number.
5701 */
5702 static long
5707 {
5712 {
5716 }
5718 }
5720 /*
5721 * Locate "item" list "l" and return its index.
5722 * Returns -1 when "item" is not in the list.
5723 */
5724 static long
5728 {
5740 }
5742 /*
5743 * Append item "item" to the end of list "l".
5744 */
5745 static void
5749 {
5751 {
5752 /* empty list */
5756 }
5757 else
5758 {
5762 }
5765 }
5767 /*
5768 * Append typval_T "tv" to the end of list "l".
5769 * Return FAIL when out of memory.
5770 */
5771 static int
5775 {
5783 }
5785 /*
5786 * Add a dictionary to a list. Used by getqflist().
5787 * Return FAIL when out of memory.
5788 */
5789 int
5793 {
5804 }
5806 /*
5807 * Make a copy of "str" and append it as an item to list "l".
5808 * When "len" >= 0 use "str[len]".
5809 * Returns FAIL when out of memory.
5810 */
5811 static int
5816 {
5830 }
5832 /*
5833 * Append "n" to list "l".
5834 * Returns FAIL when out of memory.
5835 */
5836 static int
5839 varnumber_T n;
5840 {
5851 }
5853 /*
5854 * Insert typval_T "tv" in list "l" before "item".
5855 * If "item" is NULL append at the end.
5856 * Return FAIL when out of memory.
5857 */
5858 static int
5863 {
5870 /* Append new item at end of list. */
5872 else
5873 {
5874 /* Insert new item before existing item. */
5878 {
5881 }
5882 else
5883 {
5886 }
5889 }
5891 }
5893 /*
5894 * Extend "l1" with "l2".
5895 * If "bef" is NULL append at the end, otherwise insert before this item.
5896 * Returns FAIL when out of memory.
5897 */
5898 static int
5903 {
5910 }
5912 /*
5913 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5914 * Return FAIL when out of memory.
5915 */
5916 static int
5921 {
5924 /* make a copy of the first list. */
5931 /* append all items from the second list */
5933 }
5935 /*
5936 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5937 * The refcount of the new list is set to 1.
5938 * See item_copy() for "copyID".
5939 * Returns NULL when out of memory.
5940 */
5946 {
5956 {
5958 {
5959 /* Do this before adding the items, because one of the items may
5960 * refer back to this list. */
5963 }
5966 {
5971 {
5973 {
5976 }
5977 }
5978 else
5981 }
5984 {
5987 }
5988 }
5991 }
5993 /*
5994 * Remove items "item" to "item2" from list "l".
5995 * Does not free the listitem or the value!
5996 */
5997 static void
6002 {
6005 /* notify watchers */
6007 {
6012 }
6016 else
6020 else
6023 }
6025 /*
6026 * Return an allocated string with the string representation of a list.
6027 * May return NULL.
6028 */
6033 {
6034 garray_T ga;
6041 {
6044 }
6048 }
6050 /*
6051 * Join list "l" into a string in "*gap", using separator "sep".
6052 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6053 * Return FAIL or OK.
6054 */
6055 static int
6062 {
6070 {
6073 else
6078 else
6085 }
6087 }
6089 /*
6090 * Garbage collection for lists and dictionaries.
6091 *
6092 * We use reference counts to be able to free most items right away when they
6093 * are no longer used. But for composite items it's possible that it becomes
6094 * unused while the reference count is > 0: When there is a recursive
6095 * reference. Example:
6096 * :let l = [1, 2, 3]
6097 * :let d = {9: l}
6098 * :let l[1] = d
6099 *
6100 * Since this is quite unusual we handle this with garbage collection: every
6101 * once in a while find out which lists and dicts are not referenced from any
6102 * variable.
6103 *
6104 * Here is a good reference text about garbage collection (refers to Python
6105 * but it applies to all reference-counting mechanisms):
6106 * http://python.ca/nas/python/gc/
6107 */
6109 /*
6110 * Do garbage collection for lists and dicts.
6111 * Return TRUE if some memory was freed.
6112 */
6113 int
6115 {
6124 #ifdef FEAT_WINDOWS
6126 #endif
6128 /* Only do this once. */
6133 /*
6134 * 1. Go through all accessible variables and mark all lists and dicts
6135 * with copyID.
6136 */
6137 /* script-local variables */
6141 /* buffer-local variables */
6145 /* window-local variables */
6149 #ifdef FEAT_WINDOWS
6150 /* tabpage-local variables */
6153 #endif
6155 /* global variables */
6158 /* function-local variables */
6160 {
6163 }
6165 /*
6166 * 2. Go through the list of dicts and free items without the copyID.
6167 */
6170 {
6171 /* Free the Dictionary and ordinary items it contains, but don't
6172 * recurse into Lists and Dictionaries, they will be in the list
6173 * of dicts or list of lists. */
6177 /* restart, next dict may also have been freed */
6179 }
6180 else
6183 /*
6184 * 3. Go through the list of lists and free items without the copyID.
6185 * But don't free a list that has a watcher (used in a for loop), these
6186 * are not referenced anywhere.
6187 */
6190 {
6191 /* Free the List and ordinary items it contains, but don't recurse
6192 * into Lists and Dictionaries, they will be in the list of dicts
6193 * or list of lists. */
6197 /* restart, next list may also have been freed */
6199 }
6200 else
6204 }
6206 /*
6207 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6208 */
6209 static void
6213 {
6220 {
6223 }
6224 }
6226 /*
6227 * Mark all lists and dicts referenced through list "l" with "copyID".
6228 */
6229 static void
6233 {
6238 }
6240 /*
6241 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6242 */
6243 static void
6247 {
6252 {
6256 {
6257 /* Didn't see this dict yet. */
6260 }
6266 {
6267 /* Didn't see this list yet. */
6270 }
6272 }
6274 }
6276 /*
6277 * Allocate an empty header for a dictionary.
6278 */
6279 dict_T *
6281 {
6286 {
6287 /* Add the list to the list of dicts for garbage collection. */
6298 }
6300 }
6302 /*
6303 * Unreference a Dictionary: decrement the reference count and free it when it
6304 * becomes zero.
6305 */
6306 static void
6309 {
6312 }
6314 /*
6315 * Free a Dictionary, including all items it contains.
6316 * Ignores the reference count.
6317 */
6318 static void
6322 {
6327 /* Remove the dict from the list of dicts for garbage collection. */
6330 else
6335 /* Lock the hashtab, we don't want it to resize while freeing items. */
6339 {
6341 {
6342 /* Remove the item before deleting it, just in case there is
6343 * something recursive causing trouble. */
6351 }
6352 }
6355 }
6357 /*
6358 * Allocate a Dictionary item.
6359 * The "key" is copied to the new item.
6360 * Note that the value of the item "di_tv" still needs to be initialized!
6361 * Returns NULL when out of memory.
6362 */
6366 {
6371 {
6374 }
6376 }
6378 /*
6379 * Make a copy of a Dictionary item.
6380 */
6384 {
6390 {
6394 }
6396 }
6398 /*
6399 * Remove item "item" from Dictionary "dict" and free it.
6400 */
6401 static void
6405 {
6411 else
6414 }
6416 /*
6417 * Free a dict item. Also clears the value.
6418 */
6419 static void
6422 {
6425 }
6427 /*
6428 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6429 * The refcount of the new dict is set to 1.
6430 * See item_copy() for "copyID".
6431 * Returns NULL when out of memory.
6432 */
6438 {
6449 {
6451 {
6454 }
6457 {
6459 {
6466 {
6469 {
6472 }
6473 }
6474 else
6477 {
6480 }
6481 }
6482 }
6486 {
6489 }
6490 }
6493 }
6495 /*
6496 * Add item "item" to Dictionary "d".
6497 * Returns FAIL when out of memory and when key already existed.
6498 */
6499 static int
6503 {
6505 }
6507 /*
6508 * Add a number or string entry to dictionary "d".
6509 * When "str" is NULL use number "nr", otherwise use "str".
6510 * Returns FAIL when out of memory and when key already exists.
6511 */
6512 int
6518 {
6526 {
6529 }
6530 else
6531 {
6534 }
6536 {
6539 }
6541 }
6543 /*
6544 * Get the number of items in a Dictionary.
6545 */
6546 static long
6549 {
6553 }
6555 /*
6556 * Find item "key[len]" in Dictionary "d".
6557 * If "len" is negative use strlen(key).
6558 * Returns NULL when not found.
6559 */
6565 {
6566 #define AKEYLEN 200
6575 {
6579 }
6580 else
6581 {
6582 /* Avoid a malloc/free by using buf[]. */
6585 }
6592 }
6594 /*
6595 * Get a string item from a dictionary.
6596 * When "save" is TRUE allocate memory for it.
6597 * Returns NULL if the entry doesn't exist or out of memory.
6598 */
6599 char_u *
6604 {
6615 }
6617 /*
6618 * Get a number item from a dictionary.
6619 * Returns 0 if the entry doesn't exist or out of memory.
6620 */
6621 long
6625 {
6632 }
6634 /*
6635 * Return an allocated string with the string representation of a Dictionary.
6636 * May return NULL.
6637 */
6642 {
6643 garray_T ga;
6659 {
6661 {
6666 else
6671 {
6674 }
6682 }
6683 }
6685 {
6688 }
6693 }
6695 /*
6696 * Allocate a variable for a Dictionary and fill it from "*arg".
6697 * Return OK or FAIL. Returns NOTDONE for {expr}.
6698 */
6699 static int
6704 {
6706 typval_T tvkey;
6707 typval_T tv;
6713 /*
6714 * First check if it's not a curly-braces thing: {expr}.
6715 * Must do this without evaluating, otherwise a function may be called
6716 * twice. Unfortunately this means we need to call eval1() twice for the
6717 * first item.
6718 * But {} is an empty Dictionary.
6719 */
6721 {
6726 }
6729 {
6733 }
6739 {
6743 {
6747 }
6749 {
6752 {
6753 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6758 }
6759 }
6763 {
6767 }
6769 {
6772 {
6777 }
6781 {
6786 }
6787 }
6792 {
6795 }
6797 }
6800 {
6802 failret:
6806 }
6810 {
6814 }
6817 }
6819 /*
6820 * Return a string with the string representation of a variable.
6821 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6822 * "numbuf" is used for a number.
6823 * Does not put quotes around strings, as ":echo" displays values.
6824 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6825 * May return NULL.
6826 */
6833 {
6838 {
6842 }
6846 {
6854 {
6857 }
6859 {
6862 }
6863 else
6864 {
6868 }
6873 {
6876 }
6878 {
6881 }
6882 else
6883 {
6887 }
6899 }
6903 }
6905 /*
6906 * Return a string with the string representation of a variable.
6907 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6908 * "numbuf" is used for a number.
6909 * Puts quotes around strings, so that they can be parsed back by eval().
6910 * May return NULL.
6911 */
6918 {
6920 {
6933 }
6935 }
6937 /*
6938 * Return string "str" in ' quotes, doubling ' characters.
6939 * If "str" is NULL an empty string is assumed.
6940 * If "function" is TRUE make it function('string').
6941 */
6946 {
6952 {
6957 }
6960 {
6962 {
6965 }
6966 else
6970 {
6974 }
6979 }
6981 }
6983 /*
6984 * Get the value of an environment variable.
6985 * "arg" is pointing to the '$'. It is advanced to after the name.
6986 * If the environment variable was not set, silently assume it is empty.
6987 * Always return OK.
6988 */
6989 static int
6994 {
7005 {
7007 {
7010 /* first try vim_getenv(), fast for normal environment vars */
7013 {
7016 }
7017 else
7018 {
7022 /* next try expanding things like $VIM and ${HOME} */
7025 {
7028 }
7029 }
7031 }
7034 }
7037 }
7039 /*
7040 * Array with names and number of arguments of all internal functions
7041 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7042 */
7043 static struct fst
7044 {
7049 /* implementation of function */
7051 {
7076 #if defined(FEAT_INS_EXPAND)
7080 #endif
7190 #ifdef vim_mkdir
7192 #endif
7239 #ifdef HAVE_STRFTIME
7241 #endif
7278 };
7280 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7282 /*
7283 * Function given to ExpandGeneric() to obtain the list of internal
7284 * or user defined function names.
7285 */
7286 char_u *
7290 {
7297 {
7301 }
7303 {
7309 }
7312 }
7314 /*
7315 * Function given to ExpandGeneric() to obtain the list of internal or
7316 * user defined variable or function names.
7317 */
7318 /*ARGSUSED*/
7319 char_u *
7323 {
7330 {
7334 }
7336 }
7340 /*
7341 * Find internal function in table above.
7342 * Return index, or -1 if not found
7343 */
7344 static int
7347 {
7353 /*
7354 * Find the function name in the table. Binary search.
7355 */
7357 {
7364 else
7366 }
7368 }
7370 /*
7371 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7372 * name it contains, otherwise return "name".
7373 */
7378 {
7387 {
7389 {
7392 }
7395 }
7398 }
7400 /*
7401 * Allocate a variable for the result of a function.
7402 * Return OK or FAIL.
7403 */
7404 static int
7416 {
7422 /*
7423 * Get the arguments.
7424 */
7427 {
7432 {
7435 }
7439 }
7442 else
7449 {
7452 else
7454 }
7461 }
7464 /*
7465 * Call a function with its resolved parameters
7466 * Return OK when the function can't be called, FAIL otherwise.
7467 * Also returns OK when an error was encountered while executing the function.
7468 */
7469 static int
7477 PLUS ONE elements! */
7483 {
7485 #define ERROR_UNKNOWN 0
7486 #define ERROR_TOOMANY 1
7487 #define ERROR_TOOFEW 2
7488 #define ERROR_SCRIPT 3
7489 #define ERROR_DICT 4
7490 #define ERROR_NONE 5
7491 #define ERROR_OTHER 6
7497 #define FLEN_FIXED 40
7501 /*
7502 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7503 * Change <SNR>123_name() to K_SNR 123_name().
7504 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7505 */
7510 {
7516 {
7519 else
7520 {
7523 }
7524 }
7526 {
7529 }
7530 else
7531 {
7535 else
7536 {
7539 }
7540 }
7541 }
7542 else
7548 /* execute the function if no errors detected and executing */
7550 {
7555 {
7556 /*
7557 * User defined function.
7558 */
7561 #ifdef FEAT_AUTOCMD
7562 /* Trigger FuncUndefined event, may load the function. */
7567 {
7568 /* executed an autocommand, search for the function again */
7570 }
7571 #endif
7572 /* Try loading a package. */
7574 {
7575 /* loaded a package, search for the function again */
7577 }
7580 {
7589 else
7590 {
7591 /*
7592 * Call the user function.
7593 * Save and restore search patterns, script variables and
7594 * redo buffer.
7595 */
7604 /* Function was unreferenced while being used, free it
7605 * now. */
7610 }
7611 }
7612 }
7613 else
7614 {
7615 /*
7616 * Find the function name in the table, call its implementation.
7617 */
7620 {
7625 else
7626 {
7630 }
7631 }
7632 }
7633 /*
7634 * The function call (or "FuncUndefined" autocommand sequence) might
7635 * have been aborted by an error, an interrupt, or an explicitly thrown
7636 * exception that has not been caught so far. This situation can be
7637 * tested for by calling aborting(). For an error in an internal
7638 * function or for the "E132" error in call_user_func(), however, the
7639 * throw point at which the "force_abort" flag (temporarily reset by
7640 * emsg()) is normally updated has not been reached yet. We need to
7641 * update that flag first to make aborting() reliable.
7642 */
7644 }
7648 /*
7649 * Report an error unless the argument evaluation or function call has been
7650 * cancelled due to an aborting error, an interrupt, or an exception.
7651 */
7653 {
7655 {
7664 name);
7668 name);
7672 name);
7674 }
7675 }
7682 }
7684 /*
7685 * Give an error message with a function name. Handle <SNR> things.
7686 */
7687 static void
7691 {
7696 else
7701 }
7703 /*********************************************
7704 * Implementation of the built-in functions
7705 */
7707 /*
7708 * "add(list, item)" function
7709 */
7710 static void
7714 {
7719 {
7724 }
7725 else
7727 }
7729 /*
7730 * "append(lnum, string/list)" function
7731 */
7732 static void
7736 {
7748 {
7750 {
7755 }
7758 {
7763 else
7767 {
7770 }
7776 }
7781 }
7782 else
7784 }
7786 /*
7787 * "argc()" function
7788 */
7789 /* ARGSUSED */
7790 static void
7794 {
7796 }
7798 /*
7799 * "argidx()" function
7800 */
7801 /* ARGSUSED */
7802 static void
7806 {
7808 }
7810 /*
7811 * "argv(nr)" function
7812 */
7813 static void
7817 {
7821 {
7825 else
7828 }
7833 }
7835 /*
7836 * "browse(save, title, initdir, default)" function
7837 */
7838 /* ARGSUSED */
7839 static void
7843 {
7844 #ifdef FEAT_BROWSE
7860 else
7864 #else
7866 #endif
7868 }
7870 /*
7871 * "browsedir(title, initdir)" function
7872 */
7873 /* ARGSUSED */
7874 static void
7878 {
7879 #ifdef FEAT_BROWSE
7889 else
7892 #else
7894 #endif
7896 }
7900 /*
7901 * Find a buffer by number or exact name.
7902 */
7906 {
7912 {
7915 {
7916 /* No full path name match, try a match with a URL or a "nofile"
7917 * buffer, these don't use the full path. */
7921 #ifdef FEAT_QUICKFIX
7923 #endif
7924 )
7927 }
7928 }
7930 }
7932 /*
7933 * "bufexists(expr)" function
7934 */
7935 static void
7939 {
7941 }
7943 /*
7944 * "buflisted(expr)" function
7945 */
7946 static void
7950 {
7955 }
7957 /*
7958 * "bufloaded(expr)" function
7959 */
7960 static void
7964 {
7969 }
7973 /*
7974 * Get buffer by number or pattern.
7975 */
7979 {
7994 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8006 /* If not found, try expanding the name, like done for bufexists(). */
8011 }
8013 /*
8014 * "bufname(expr)" function
8015 */
8016 static void
8020 {
8029 else
8032 }
8034 /*
8035 * "bufnr(expr)" function
8036 */
8037 static void
8041 {
8051 /* If the buffer isn't found and the second argument is not zero create a
8052 * new buffer. */
8056 && !error
8063 else
8065 }
8067 /*
8068 * "bufwinnr(nr)" function
8069 */
8070 static void
8074 {
8075 #ifdef FEAT_WINDOWS
8078 #endif
8084 #ifdef FEAT_WINDOWS
8086 {
8090 }
8092 #else
8094 #endif
8096 }
8098 /*
8099 * "byte2line(byte)" function
8100 */
8101 /*ARGSUSED*/
8102 static void
8106 {
8107 #ifndef FEAT_BYTEOFF
8109 #else
8115 else
8118 #endif
8119 }
8121 /*
8122 * "byteidx()" function
8123 */
8124 /*ARGSUSED*/
8125 static void
8129 {
8130 #ifdef FEAT_MBYTE
8132 #endif
8142 #ifdef FEAT_MBYTE
8145 {
8149 }
8151 #else
8154 #endif
8155 }
8157 /*
8158 * "call(func, arglist)" function
8159 */
8160 static void
8164 {
8174 {
8177 }
8183 else
8189 {
8191 {
8194 }
8196 }
8200 {
8202 {
8205 }
8206 /* Make a copy of each argument. This is needed to be able to set
8207 * v_lock to VAR_FIXED in the copy without changing the original list.
8208 */
8210 }
8217 /* Free the arguments. */
8220 }
8222 /*
8223 * "changenr()" function
8224 */
8225 /*ARGSUSED*/
8226 static void
8230 {
8232 }
8234 /*
8235 * "char2nr(string)" function
8236 */
8237 static void
8241 {
8242 #ifdef FEAT_MBYTE
8245 else
8246 #endif
8248 }
8250 /*
8251 * "cindent(lnum)" function
8252 */
8253 static void
8257 {
8258 #ifdef FEAT_CINDENT
8259 pos_T pos;
8260 linenr_T lnum;
8265 {
8269 }
8270 else
8271 #endif
8273 }
8275 /*
8276 * "clearmatches()" function
8277 */
8278 /*ARGSUSED*/
8279 static void
8283 {
8284 #ifdef FEAT_SEARCH_EXTRA
8286 #endif
8287 }
8289 /*
8290 * "col(string)" function
8291 */
8292 static void
8296 {
8303 {
8305 {
8306 /* '> can be MAXCOL, get the length of the line then */
8309 else
8311 }
8312 else
8313 {
8315 #ifdef FEAT_VIRTUALEDIT
8316 /* col(".") when the cursor is on the NUL at the end of the line
8317 * because of "coladd" can be seen as an extra column. */
8319 {
8324 {
8325 # ifdef FEAT_MBYTE
8330 # else
8333 # endif
8334 }
8335 }
8336 #endif
8337 }
8338 }
8340 }
8342 #if defined(FEAT_INS_EXPAND)
8343 /*
8344 * "complete()" function
8345 */
8346 /*ARGSUSED*/
8347 static void
8351 {
8355 {
8358 }
8360 /* Check for undo allowed here, because if something was already inserted
8361 * the line was already saved for undo and this check isn't done. */
8366 {
8369 }
8376 }
8378 /*
8379 * "complete_add()" function
8380 */
8381 /*ARGSUSED*/
8382 static void
8386 {
8388 }
8390 /*
8391 * "complete_check()" function
8392 */
8393 /*ARGSUSED*/
8394 static void
8398 {
8405 }
8406 #endif
8408 /*
8409 * "confirm(message, buttons[, default [, type]])" function
8410 */
8411 /*ARGSUSED*/
8412 static void
8416 {
8417 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8431 {
8436 {
8439 {
8443 else
8444 {
8446 {
8452 }
8453 }
8454 }
8455 }
8456 }
8463 else
8466 #else
8468 #endif
8469 }
8471 /*
8472 * "copy()" function
8473 */
8474 static void
8478 {
8480 }
8482 /*
8483 * "count()" function
8484 */
8485 static void
8489 {
8494 {
8500 {
8503 {
8508 {
8511 {
8515 }
8516 }
8519 }
8524 }
8525 }
8527 {
8533 {
8537 {
8541 }
8545 {
8547 {
8551 }
8552 }
8553 }
8554 }
8555 else
8558 }
8560 /*
8561 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8562 *
8563 * Checks the existence of a cscope connection.
8564 */
8565 /*ARGSUSED*/
8566 static void
8570 {
8571 #ifdef FEAT_CSCOPE
8579 {
8584 }
8587 #else
8589 #endif
8590 }
8592 /*
8593 * "cursor(lnum, col)" function
8594 *
8595 * Moves the cursor to the specified line and column
8596 */
8597 /*ARGSUSED*/
8598 static void
8602 {
8604 #ifdef FEAT_VIRTUALEDIT
8606 #endif
8609 {
8610 pos_T pos;
8616 #ifdef FEAT_VIRTUALEDIT
8618 #endif
8619 }
8620 else
8621 {
8624 #ifdef FEAT_VIRTUALEDIT
8627 #endif
8628 }
8630 #ifdef FEAT_VIRTUALEDIT
8632 #endif
8633 )
8639 #ifdef FEAT_VIRTUALEDIT
8641 #endif
8643 /* Make sure the cursor is in a valid position. */
8645 #ifdef FEAT_MBYTE
8646 /* Correct cursor for multi-byte character. */
8649 #endif
8652 }
8654 /*
8655 * "deepcopy()" function
8656 */
8657 static void
8661 {
8668 else
8670 }
8672 /*
8673 * "delete()" function
8674 */
8675 static void
8679 {
8682 else
8684 }
8686 /*
8687 * "did_filetype()" function
8688 */
8689 /*ARGSUSED*/
8690 static void
8694 {
8695 #ifdef FEAT_AUTOCMD
8697 #else
8699 #endif
8700 }
8702 /*
8703 * "diff_filler()" function
8704 */
8705 /*ARGSUSED*/
8706 static void
8710 {
8711 #ifdef FEAT_DIFF
8713 #endif
8714 }
8716 /*
8717 * "diff_hlID()" function
8718 */
8719 /*ARGSUSED*/
8720 static void
8724 {
8725 #ifdef FEAT_DIFF
8741 {
8742 /* New line, buffer, change: need to get the values. */
8745 {
8747 {
8752 else
8754 }
8755 else
8757 }
8758 else
8763 }
8766 {
8770 else
8772 }
8774 #endif
8775 }
8777 /*
8778 * "empty({expr})" function
8779 */
8780 static void
8784 {
8788 {
8808 }
8811 }
8813 /*
8814 * "escape({string}, {chars})" function
8815 */
8816 static void
8820 {
8826 }
8828 /*
8829 * "eval()" function
8830 */
8831 /*ARGSUSED*/
8832 static void
8836 {
8844 {
8847 }
8850 }
8852 /*
8853 * "eventhandler()" function
8854 */
8855 /*ARGSUSED*/
8856 static void
8860 {
8862 }
8864 /*
8865 * "executable()" function
8866 */
8867 static void
8871 {
8873 }
8875 /*
8876 * "exists()" function
8877 */
8878 static void
8882 {
8890 {
8891 /* first try "normal" environment variables (fast) */
8894 else
8895 {
8896 /* try expanding things like $VIM and ${HOME} */
8901 }
8902 }
8904 {
8908 }
8910 {
8912 }
8914 {
8916 }
8918 {
8919 #ifdef FEAT_AUTOCMD
8922 else
8924 #endif
8925 }
8927 {
8929 typval_T tv;
8931 /* get_name_len() takes care of expanding curly braces */
8935 {
8940 {
8941 /* handle d.key, l[idx], f(expr) */
8945 }
8946 }
8951 }
8954 }
8956 /*
8957 * "expand()" function
8958 */
8959 static void
8963 {
8968 expand_T xpc;
8974 {
8978 }
8979 else
8980 {
8981 /* When the optional second argument is non-zero, don't remove matches
8982 * for 'suffixes' and 'wildignore' */
8987 {
8991 }
8992 else
8994 }
8995 }
8997 /*
8998 * "extend(list, list [, idx])" function
8999 * "extend(dict, dict [, action])" function
9000 */
9001 static void
9005 {
9008 {
9018 {
9020 {
9027 else
9028 {
9031 {
9034 }
9035 }
9036 }
9037 else
9042 }
9043 }
9045 {
9057 {
9058 /* Check the third argument. */
9060 {
9070 {
9073 }
9074 }
9075 else
9078 /* Go over all entries in the second dict and add them to the
9079 * first dict. */
9082 {
9084 {
9088 {
9092 }
9094 {
9097 }
9099 {
9102 }
9103 }
9104 }
9107 }
9108 }
9109 else
9111 }
9113 /*
9114 * "feedkeys()" function
9115 */
9116 /*ARGSUSED*/
9117 static void
9121 {
9128 /* This is not allowed in the sandbox. If the commands would still be
9129 * executed in the sandbox it would be OK, but it probably happens later,
9130 * when "sandbox" is no longer set. */
9137 {
9139 {
9142 {
9144 {
9148 }
9149 }
9150 }
9152 /* Need to escape K_SPECIAL and CSI before putting the string in the
9153 * typeahead buffer. */
9156 {
9162 }
9163 }
9164 }
9166 /*
9167 * "filereadable()" function
9168 */
9169 static void
9173 {
9180 {
9183 }
9184 else
9188 }
9190 /*
9191 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9192 * rights to write into.
9193 */
9194 static void
9198 {
9200 }
9204 static void
9209 {
9210 #ifdef FEAT_SEARCHPATH
9219 #endif
9224 #ifdef FEAT_SEARCHPATH
9228 {
9232 else
9233 {
9239 }
9240 }
9246 {
9247 do
9248 {
9261 }
9265 #endif
9266 }
9271 /*
9272 * Implementation of map() and filter().
9273 */
9274 static void
9279 {
9288 typval_T save_val;
9289 typval_T save_key;
9297 {
9301 }
9303 {
9307 }
9308 else
9309 {
9312 }
9315 /* On type errors, the preceding call has already displayed an error
9316 * message. Avoid a misleading error message for an empty string that
9317 * was not passed as argument. */
9319 {
9323 /* We reset "did_emsg" to be able to detect whether an error
9324 * occurred during evaluation of the expression. */
9329 {
9337 {
9339 {
9351 }
9352 }
9356 }
9357 else
9358 {
9360 {
9369 }
9370 }
9375 }
9378 }
9380 static int
9386 {
9387 typval_T rettv;
9396 {
9399 }
9401 {
9402 /* map(): replace the list item value */
9406 }
9407 else
9408 {
9411 /* filter(): when expr is zero remove the item */
9414 /* On type error, nothing has been removed; return FAIL to stop the
9415 * loop. The error message was given by get_tv_number_chk(). */
9418 }
9420 theend:
9423 }
9425 /*
9426 * "filter()" function
9427 */
9428 static void
9432 {
9434 }
9436 /*
9437 * "finddir({fname}[, {path}[, {count}]])" function
9438 */
9439 static void
9443 {
9445 }
9447 /*
9448 * "findfile({fname}[, {path}[, {count}]])" function
9449 */
9450 static void
9454 {
9456 }
9458 /*
9459 * "fnamemodify({fname}, {mods})" function
9460 */
9461 static void
9465 {
9477 else
9478 {
9481 }
9486 else
9489 }
9493 /*
9494 * "foldclosed()" function
9495 */
9496 static void
9501 {
9502 #ifdef FEAT_FOLDING
9503 linenr_T lnum;
9508 {
9510 {
9513 else
9516 }
9517 }
9518 #endif
9520 }
9522 /*
9523 * "foldclosed()" function
9524 */
9525 static void
9529 {
9531 }
9533 /*
9534 * "foldclosedend()" function
9535 */
9536 static void
9540 {
9542 }
9544 /*
9545 * "foldlevel()" function
9546 */
9547 static void
9551 {
9552 #ifdef FEAT_FOLDING
9553 linenr_T lnum;
9558 else
9559 #endif
9561 }
9563 /*
9564 * "foldtext()" function
9565 */
9566 /*ARGSUSED*/
9567 static void
9571 {
9572 #ifdef FEAT_FOLDING
9573 linenr_T lnum;
9578 #endif
9582 #ifdef FEAT_FOLDING
9587 {
9588 /* Find first non-empty line in the fold. */
9591 {
9595 }
9597 /* Find interesting text in this line. */
9599 /* skip C comment-start */
9601 {
9605 {
9609 }
9610 }
9617 {
9623 /* remove 'foldmarker' and 'commentstring' */
9626 }
9627 }
9628 #endif
9629 }
9631 /*
9632 * "foldtextresult(lnum)" function
9633 */
9634 /*ARGSUSED*/
9635 static void
9639 {
9640 #ifdef FEAT_FOLDING
9641 linenr_T lnum;
9644 foldinfo_T foldinfo;
9646 #endif
9650 #ifdef FEAT_FOLDING
9652 /* treat illegal types and illegal string values for {lnum} the same */
9657 {
9663 }
9664 #endif
9665 }
9667 /*
9668 * "foreground()" function
9669 */
9670 /*ARGSUSED*/
9671 static void
9675 {
9677 #ifdef FEAT_GUI
9680 #else
9681 # ifdef WIN32
9683 # endif
9684 #endif
9685 }
9687 /*
9688 * "function()" function
9689 */
9690 /*ARGSUSED*/
9691 static void
9695 {
9704 else
9705 {
9708 }
9709 }
9711 /*
9712 * "garbagecollect()" function
9713 */
9714 /*ARGSUSED*/
9715 static void
9719 {
9720 /* This is postponed until we are back at the toplevel, because we may be
9721 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9726 }
9728 /*
9729 * "get()" function
9730 */
9731 static void
9735 {
9743 {
9745 {
9751 }
9752 }
9754 {
9756 {
9760 }
9761 }
9762 else
9766 {
9769 else
9771 }
9772 else
9774 }
9776 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9778 /*
9779 * Get line or list of lines from buffer "buf" into "rettv".
9780 * Return a range (from start to end) of lines in rettv from the specified
9781 * buffer.
9782 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9783 */
9784 static void
9787 linenr_T start;
9788 linenr_T end;
9791 {
9795 {
9798 }
9799 else
9806 {
9809 else
9814 }
9815 else
9816 {
9828 }
9829 }
9831 /*
9832 * "getbufline()" function
9833 */
9834 static void
9838 {
9839 linenr_T lnum;
9840 linenr_T end;
9851 else
9855 }
9857 /*
9858 * "getbufvar()" function
9859 */
9860 static void
9864 {
9879 {
9881 {
9882 /* set curbuf to be our buf, temporarily */
9888 /* restore previous notion of curbuf */
9890 }
9891 else
9892 {
9894 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9895 * scope prefix before the NUL byte is required by
9896 * find_var_in_ht(). */
9898 /* look up the variable */
9902 }
9903 }
9906 }
9908 /*
9909 * "getchar()" function
9910 */
9911 static void
9915 {
9916 varnumber_T n;
9919 /* Position the cursor. Needed after a message that ends in a space. */
9925 {
9927 /* getchar(): blocking wait. */
9930 /* getchar(1): only check if char avail */
9933 /* illegal argument or getchar(0) and no char avail: return zero */
9935 else
9936 /* getchar(0) and char avail: return char */
9941 }
9951 {
9955 /* Turn a special key into three bytes, plus modifier. */
9957 {
9961 }
9963 {
9967 }
9968 #ifdef FEAT_MBYTE
9971 #endif
9972 else
9978 #ifdef FEAT_MOUSE
9998 {
10002 linenr_T lnum;
10003 # ifdef FEAT_WINDOWS
10005 # endif
10009 {
10010 /* Find the window at the mouse coordinates and compute the
10011 * text position. */
10014 # ifdef FEAT_WINDOWS
10017 # endif
10021 }
10022 }
10023 #endif
10024 }
10025 }
10027 /*
10028 * "getcharmod()" function
10029 */
10030 /*ARGSUSED*/
10031 static void
10035 {
10037 }
10039 /*
10040 * "getcmdline()" function
10041 */
10042 /*ARGSUSED*/
10043 static void
10047 {
10050 }
10052 /*
10053 * "getcmdpos()" function
10054 */
10055 /*ARGSUSED*/
10056 static void
10060 {
10062 }
10064 /*
10065 * "getcmdtype()" function
10066 */
10067 /*ARGSUSED*/
10068 static void
10072 {
10076 {
10079 }
10080 }
10082 /*
10083 * "getcwd()" function
10084 */
10085 /*ARGSUSED*/
10086 static void
10090 {
10096 else
10097 {
10099 #ifdef BACKSLASH_IN_FILENAME
10102 #endif
10103 }
10104 }
10106 /*
10107 * "getfontname()" function
10108 */
10109 /*ARGSUSED*/
10110 static void
10114 {
10117 #ifdef FEAT_GUI
10119 {
10120 GuiFont font;
10124 {
10125 /* Get the "Normal" font. Either the name saved by
10126 * hl_set_font_name() or from the font ID. */
10129 }
10130 else
10131 {
10138 }
10142 }
10143 #endif
10144 }
10146 /*
10147 * "getfperm({fname})" function
10148 */
10149 static void
10153 {
10164 {
10167 {
10169 {
10172 }
10173 }
10174 }
10176 }
10178 /*
10179 * "getfsize({fname})" function
10180 */
10181 static void
10185 {
10194 {
10197 else
10198 {
10201 /* non-perfect check for overflow */
10204 }
10205 }
10206 else
10208 }
10210 /*
10211 * "getftime({fname})" function
10212 */
10213 static void
10217 {
10225 else
10227 }
10229 /*
10230 * "getftype({fname})" function
10231 */
10232 static void
10236 {
10246 {
10247 #ifdef S_ISREG
10252 # ifdef S_ISLNK
10255 # endif
10256 # ifdef S_ISBLK
10259 # endif
10260 # ifdef S_ISCHR
10263 # endif
10264 # ifdef S_ISFIFO
10267 # endif
10268 # ifdef S_ISSOCK
10271 # endif
10272 else
10274 #else
10275 # ifdef S_IFMT
10277 {
10280 # ifdef S_IFLNK
10282 # endif
10283 # ifdef S_IFBLK
10285 # endif
10286 # ifdef S_IFCHR
10288 # endif
10289 # ifdef S_IFIFO
10291 # endif
10292 # ifdef S_IFSOCK
10294 # endif
10296 }
10297 # else
10300 else
10302 # endif
10303 #endif
10305 }
10307 }
10309 /*
10310 * "getline(lnum, [end])" function
10311 */
10312 static void
10316 {
10317 linenr_T lnum;
10318 linenr_T end;
10323 {
10326 }
10327 else
10328 {
10331 }
10334 }
10336 /*
10337 * "getmatches()" function
10338 */
10339 /*ARGSUSED*/
10340 static void
10344 {
10345 #ifdef FEAT_SEARCH_EXTRA
10352 {
10354 {
10364 }
10365 }
10366 #endif
10367 }
10369 /*
10370 * "getpos(string)" function
10371 */
10372 static void
10376 {
10382 {
10387 else
10395 #ifdef FEAT_VIRTUALEDIT
10397 #endif
10399 }
10400 else
10402 }
10404 /*
10405 * "getqflist()" and "getloclist()" functions
10406 */
10407 /*ARGSUSED*/
10408 static void
10412 {
10413 #ifdef FEAT_QUICKFIX
10415 #endif
10418 #ifdef FEAT_QUICKFIX
10420 {
10423 {
10427 }
10430 }
10431 #endif
10432 }
10434 /*
10435 * "getreg()" function
10436 */
10437 static void
10441 {
10448 {
10453 }
10454 else
10463 }
10465 /*
10466 * "getregtype()" function
10467 */
10468 static void
10472 {
10479 {
10482 {
10486 }
10487 }
10488 else
10489 /* Default to v:register */
10499 {
10502 #ifdef FEAT_VISUAL
10507 #endif
10508 }
10511 }
10513 /*
10514 * "gettabwinvar()" function
10515 */
10516 static void
10520 {
10522 }
10524 /*
10525 * "getwinposx()" function
10526 */
10527 /*ARGSUSED*/
10528 static void
10532 {
10534 #ifdef FEAT_GUI
10536 {
10541 }
10542 #endif
10543 }
10545 /*
10546 * "getwinposy()" function
10547 */
10548 /*ARGSUSED*/
10549 static void
10553 {
10555 #ifdef FEAT_GUI
10557 {
10562 }
10563 #endif
10564 }
10566 /*
10567 * Find window specifed by "vp" in tabpage "tp".
10568 */
10573 {
10574 #ifdef FEAT_WINDOWS
10576 #endif
10581 #ifdef FEAT_WINDOWS
10592 #else
10596 #endif
10597 }
10599 /*
10600 * "getwinvar()" function
10601 */
10602 static void
10606 {
10608 }
10610 /*
10611 * getwinvar() and gettabwinvar()
10612 */
10613 static void
10618 {
10624 #ifdef FEAT_WINDOWS
10627 else
10629 #endif
10638 {
10639 /* Set curwin to be our win, temporarily. Also set curbuf, so
10640 * that we can get buffer-local options. */
10647 else
10648 {
10650 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10651 * scope prefix before the NUL byte is required by
10652 * find_var_in_ht(). */
10654 /* look up the variable */
10658 }
10660 /* restore previous notion of curwin */
10663 }
10666 }
10668 /*
10669 * "glob()" function
10670 */
10671 static void
10675 {
10676 expand_T xpc;
10683 }
10685 /*
10686 * "globpath()" function
10687 */
10688 static void
10692 {
10699 else
10701 }
10703 /*
10704 * "has()" function
10705 */
10706 static void
10710 {
10715 {
10716 #ifdef AMIGA
10718 # ifdef FEAT_ARP
10720 # endif
10721 #endif
10722 #ifdef __BEOS__
10724 #endif
10725 #ifdef MSDOS
10726 # ifdef DJGPP
10728 # else
10730 # endif
10731 #endif
10732 #ifdef MACOS
10734 #endif
10735 #if defined(MACOS_X_UNIX)
10737 #endif
10738 #ifdef OS2
10740 #endif
10741 #ifdef __QNX__
10743 #endif
10744 #ifdef RISCOS
10746 #endif
10747 #ifdef UNIX
10749 #endif
10750 #ifdef VMS
10752 #endif
10753 #ifdef WIN16
10755 #endif
10756 #ifdef WIN32
10758 #endif
10759 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10761 #endif
10762 #ifdef WIN64
10764 #endif
10765 #ifdef EBCDIC
10767 #endif
10768 #ifndef CASE_INSENSITIVE_FILENAME
10770 #endif
10771 #ifdef FEAT_ARABIC
10773 #endif
10774 #ifdef FEAT_AUTOCMD
10776 #endif
10777 #ifdef FEAT_BEVAL
10781 # endif
10782 #endif
10783 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10785 # ifdef ALL_BUILTIN_TCAPS
10787 # endif
10788 #endif
10789 #ifdef FEAT_BYTEOFF
10791 #endif
10792 #ifdef FEAT_CINDENT
10794 #endif
10795 #ifdef FEAT_CLIENTSERVER
10797 #endif
10798 #ifdef FEAT_CLIPBOARD
10800 #endif
10801 #ifdef FEAT_CMDL_COMPL
10803 #endif
10804 #ifdef FEAT_CMDHIST
10806 #endif
10807 #ifdef FEAT_COMMENTS
10809 #endif
10810 #ifdef FEAT_CRYPT
10812 #endif
10813 #ifdef FEAT_CSCOPE
10815 #endif
10816 #ifdef CURSOR_SHAPE
10818 #endif
10819 #ifdef DEBUG
10821 #endif
10822 #ifdef FEAT_CON_DIALOG
10824 #endif
10825 #ifdef FEAT_GUI_DIALOG
10827 #endif
10828 #ifdef FEAT_DIFF
10830 #endif
10831 #ifdef FEAT_DIGRAPHS
10833 #endif
10834 #ifdef FEAT_DND
10836 #endif
10837 #ifdef FEAT_EMACS_TAGS
10839 #endif
10841 #ifdef FEAT_EX_EXTRA
10843 #endif
10844 #ifdef FEAT_SEARCH_EXTRA
10846 #endif
10847 #ifdef FEAT_FKMAP
10849 #endif
10850 #ifdef FEAT_SEARCHPATH
10852 #endif
10853 #if defined(UNIX) && !defined(USE_SYSTEM)
10855 #endif
10856 #ifdef FEAT_FIND_ID
10858 #endif
10859 #ifdef FEAT_FOLDING
10861 #endif
10862 #ifdef FEAT_FOOTER
10864 #endif
10865 #if !defined(USE_SYSTEM) && defined(UNIX)
10867 #endif
10868 #ifdef FEAT_GETTEXT
10870 #endif
10871 #ifdef FEAT_GUI
10873 #endif
10874 #ifdef FEAT_GUI_ATHENA
10875 # ifdef FEAT_GUI_NEXTAW
10877 # else
10879 # endif
10880 #endif
10881 #ifdef FEAT_GUI_GTK
10883 # ifdef HAVE_GTK2
10885 # endif
10886 #endif
10887 #ifdef FEAT_GUI_GNOME
10889 #endif
10890 #ifdef FEAT_GUI_MAC
10892 #endif
10893 #ifdef FEAT_GUI_MACVIM
10895 #endif
10896 #ifdef FEAT_GUI_MOTIF
10898 #endif
10899 #ifdef FEAT_GUI_PHOTON
10901 #endif
10902 #ifdef FEAT_GUI_W16
10904 #endif
10905 #ifdef FEAT_GUI_W32
10907 #endif
10908 #ifdef FEAT_HANGULIN
10910 #endif
10911 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10913 #endif
10914 #ifdef FEAT_INS_EXPAND
10916 #endif
10917 #ifdef FEAT_JUMPLIST
10919 #endif
10920 #ifdef FEAT_KEYMAP
10922 #endif
10923 #ifdef FEAT_LANGMAP
10925 #endif
10926 #ifdef FEAT_LIBCALL
10928 #endif
10929 #ifdef FEAT_LINEBREAK
10931 #endif
10932 #ifdef FEAT_LISP
10934 #endif
10935 #ifdef FEAT_LISTCMDS
10937 #endif
10938 #ifdef FEAT_LOCALMAP
10940 #endif
10941 #ifdef FEAT_MENU
10943 #endif
10944 #ifdef FEAT_SESSION
10946 #endif
10947 #ifdef FEAT_MODIFY_FNAME
10949 #endif
10950 #ifdef FEAT_MOUSE
10952 #endif
10953 #ifdef FEAT_MOUSESHAPE
10955 #endif
10956 #if defined(UNIX) || defined(VMS)
10957 # ifdef FEAT_MOUSE_DEC
10959 # endif
10960 # ifdef FEAT_MOUSE_GPM
10962 # endif
10963 # ifdef FEAT_MOUSE_JSB
10965 # endif
10966 # ifdef FEAT_MOUSE_NET
10968 # endif
10969 # ifdef FEAT_MOUSE_PTERM
10971 # endif
10972 # ifdef FEAT_MOUSE_XTERM
10974 # endif
10975 #endif
10976 #ifdef FEAT_MBYTE
10978 #endif
10979 #ifdef FEAT_MBYTE_IME
10981 #endif
10982 #ifdef FEAT_MULTI_LANG
10984 #endif
10985 #ifdef FEAT_MZSCHEME
10986 #ifndef DYNAMIC_MZSCHEME
10988 #endif
10989 #endif
10990 #ifdef FEAT_OLE
10992 #endif
10993 #ifdef FEAT_OSFILETYPE
10995 #endif
10996 #ifdef FEAT_PATH_EXTRA
10998 #endif
10999 #ifdef FEAT_PERL
11000 #ifndef DYNAMIC_PERL
11002 #endif
11003 #endif
11004 #ifdef FEAT_PYTHON
11005 #ifndef DYNAMIC_PYTHON
11007 #endif
11008 #endif
11009 #ifdef FEAT_POSTSCRIPT
11011 #endif
11012 #ifdef FEAT_PRINTER
11014 #endif
11015 #ifdef FEAT_PROFILE
11017 #endif
11018 #ifdef FEAT_RELTIME
11020 #endif
11021 #ifdef FEAT_QUICKFIX
11023 #endif
11024 #ifdef FEAT_RIGHTLEFT
11026 #endif
11027 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11029 #endif
11030 #ifdef FEAT_SCROLLBIND
11032 #endif
11033 #ifdef FEAT_CMDL_INFO
11036 #endif
11037 #ifdef FEAT_SIGNS
11039 #endif
11040 #ifdef FEAT_SMARTINDENT
11042 #endif
11043 #ifdef FEAT_SNIFF
11045 #endif
11046 #ifdef FEAT_STL_OPT
11048 #endif
11049 #ifdef FEAT_SUN_WORKSHOP
11051 #endif
11052 #ifdef FEAT_NETBEANS_INTG
11054 #endif
11055 #ifdef FEAT_SPELL
11057 #endif
11058 #ifdef FEAT_SYN_HL
11060 #endif
11061 #if defined(USE_SYSTEM) || !defined(UNIX)
11063 #endif
11064 #ifdef FEAT_TAG_BINS
11066 #endif
11067 #ifdef FEAT_TAG_OLDSTATIC
11069 #endif
11070 #ifdef FEAT_TAG_ANYWHITE
11072 #endif
11073 #ifdef FEAT_TCL
11074 # ifndef DYNAMIC_TCL
11076 # endif
11077 #endif
11078 #ifdef TERMINFO
11080 #endif
11081 #ifdef FEAT_TERMRESPONSE
11083 #endif
11084 #ifdef FEAT_TEXTOBJ
11086 #endif
11087 #ifdef HAVE_TGETENT
11089 #endif
11090 #ifdef FEAT_TITLE
11092 #endif
11093 #ifdef FEAT_TOOLBAR
11095 #endif
11096 #ifdef FEAT_USR_CMDS
11099 #endif
11100 #ifdef FEAT_VIMINFO
11102 #endif
11103 #ifdef FEAT_VERTSPLIT
11105 #endif
11106 #ifdef FEAT_VIRTUALEDIT
11108 #endif
11109 #ifdef FEAT_VISUAL
11111 #endif
11112 #ifdef FEAT_VISUALEXTRA
11114 #endif
11115 #ifdef FEAT_VREPLACE
11117 #endif
11118 #ifdef FEAT_WILDIGN
11120 #endif
11121 #ifdef FEAT_WILDMENU
11123 #endif
11124 #ifdef FEAT_WINDOWS
11126 #endif
11127 #ifdef FEAT_WAK
11129 #endif
11130 #ifdef FEAT_WRITEBACKUP
11132 #endif
11133 #ifdef FEAT_XIM
11135 #endif
11136 #ifdef FEAT_XFONTSET
11138 #endif
11139 #ifdef USE_XSMP
11141 #endif
11142 #ifdef USE_XSMP_INTERACT
11144 #endif
11145 #ifdef FEAT_XCLIPBOARD
11147 #endif
11148 #ifdef FEAT_XTERM_SAVE
11150 #endif
11151 #if defined(UNIX) && defined(FEAT_X11)
11153 #endif
11154 NULL
11155 };
11160 {
11163 }
11166 {
11171 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11174 #endif
11175 #ifdef DYNAMIC_TCL
11178 #endif
11179 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11182 #endif
11183 #ifdef DYNAMIC_MZSCHEME
11186 #endif
11187 #ifdef DYNAMIC_RUBY
11190 #endif
11191 #ifdef DYNAMIC_PYTHON
11194 #endif
11195 #ifdef DYNAMIC_PERL
11198 #endif
11199 #ifdef FEAT_GUI
11202 # ifdef FEAT_GUI_W32
11205 # endif
11206 # ifdef FEAT_BROWSE
11209 # endif
11210 #endif
11211 #ifdef FEAT_SYN_HL
11214 #endif
11215 #if defined(WIN3264)
11218 #endif
11219 #ifdef FEAT_NETBEANS_INTG
11222 #endif
11223 }
11226 }
11228 /*
11229 * "has_key()" function
11230 */
11231 static void
11235 {
11238 {
11241 }
11247 }
11249 /*
11250 * "haslocaldir()" function
11251 */
11252 /*ARGSUSED*/
11253 static void
11257 {
11259 }
11261 /*
11262 * "hasmapto()" function
11263 */
11264 static void
11268 {
11277 else
11278 {
11282 }
11286 else
11288 }
11290 /*
11291 * "histadd()" function
11292 */
11293 /*ARGSUSED*/
11294 static void
11298 {
11299 #ifdef FEAT_CMDHIST
11303 #endif
11308 #ifdef FEAT_CMDHIST
11312 {
11315 {
11319 }
11320 }
11321 #endif
11322 }
11324 /*
11325 * "histdel()" function
11326 */
11327 /*ARGSUSED*/
11328 static void
11332 {
11333 #ifdef FEAT_CMDHIST
11342 /* only one argument: clear entire history */
11345 /* index given: remove that entry */
11348 else
11349 /* string given: remove all matching entries */
11353 #else
11355 #endif
11356 }
11358 /*
11359 * "histget()" function
11360 */
11361 /*ARGSUSED*/
11362 static void
11366 {
11367 #ifdef FEAT_CMDHIST
11375 else
11376 {
11380 else
11382 /* -1 on type error */
11384 }
11385 #else
11387 #endif
11389 }
11391 /*
11392 * "histnr()" function
11393 */
11394 /*ARGSUSED*/
11395 static void
11399 {
11402 #ifdef FEAT_CMDHIST
11408 else
11409 #endif
11412 }
11414 /*
11415 * "highlightID(name)" function
11416 */
11417 static void
11421 {
11423 }
11425 /*
11426 * "highlight_exists()" function
11427 */
11428 static void
11432 {
11434 }
11436 /*
11437 * "hostname()" function
11438 */
11439 /*ARGSUSED*/
11440 static void
11444 {
11450 }
11452 /*
11453 * iconv() function
11454 */
11455 /*ARGSUSED*/
11456 static void
11460 {
11461 #ifdef FEAT_MBYTE
11465 vimconv_T vimconv;
11466 #endif
11471 #ifdef FEAT_MBYTE
11478 /* If the encodings are equal, no conversion needed. */
11481 else
11487 #endif
11488 }
11490 /*
11491 * "indent()" function
11492 */
11493 static void
11497 {
11498 linenr_T lnum;
11503 else
11505 }
11507 /*
11508 * "index()" function
11509 */
11510 static void
11514 {
11522 {
11525 }
11528 {
11531 {
11534 /* Start at specified item. Use the cached index that list_find()
11535 * sets, so that a negative number also works. */
11542 }
11546 {
11549 }
11550 }
11551 }
11557 /*
11558 * This function is used by f_input() and f_inputdialog() functions. The third
11559 * argument to f_input() specifies the type of completion to use at the
11560 * prompt. The third argument to f_inputdialog() specifies the value to return
11561 * when the user cancels the prompt.
11562 */
11563 static void
11568 {
11581 #ifdef NO_CONSOLE_INPUT
11582 /* While starting up, there is no place to enter text. */
11585 #endif
11589 {
11590 /* Only the part of the message after the last NL is considered as
11591 * prompt for the command line */
11595 else
11596 {
11606 }
11610 {
11616 {
11632 }
11633 }
11642 /* since the user typed this, no need to wait for return */
11645 }
11647 }
11649 /*
11650 * "input()" function
11651 * Also handles inputsecret() when inputsecret is set.
11652 */
11653 static void
11657 {
11659 }
11661 /*
11662 * "inputdialog()" function
11663 */
11664 static void
11668 {
11669 #if defined(FEAT_GUI_TEXTDIALOG)
11670 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11672 {
11681 else
11687 else
11688 {
11694 else
11696 }
11698 }
11699 else
11700 #endif
11702 }
11704 /*
11705 * "inputlist()" function
11706 */
11707 static void
11711 {
11717 #ifdef NO_CONSOLE_INPUT
11718 /* While starting up, there is no place to enter text. */
11721 #endif
11723 {
11726 }
11735 {
11738 }
11740 /* Ask for choice. */
11746 }
11751 /*
11752 * "inputrestore()" function
11753 */
11754 /*ARGSUSED*/
11755 static void
11759 {
11761 {
11766 }
11768 {
11771 }
11772 }
11774 /*
11775 * "inputsave()" function
11776 */
11777 /*ARGSUSED*/
11778 static void
11782 {
11783 /* Add an entry to the stack of typehead storage. */
11785 {
11790 }
11791 else
11793 }
11795 /*
11796 * "inputsecret()" function
11797 */
11798 static void
11802 {
11808 }
11810 /*
11811 * "insert()" function
11812 */
11813 static void
11817 {
11828 {
11836 else
11837 {
11840 {
11843 }
11844 }
11846 {
11849 }
11850 }
11851 }
11853 /*
11854 * "isdirectory()" function
11855 */
11856 static void
11860 {
11862 }
11864 /*
11865 * "islocked()" function
11866 */
11867 static void
11871 {
11872 lval_T lv;
11878 FNE_CHECK_START);
11880 {
11883 else
11884 {
11886 {
11889 else
11890 {
11893 {
11894 /* Consider a variable locked when:
11895 * 1. the variable itself is locked
11896 * 2. the value of the variable is locked.
11897 * 3. the List or Dict value is locked.
11898 */
11901 }
11902 }
11903 }
11909 /* List item. */
11911 else
11912 /* Dictionary item. */
11914 }
11915 }
11918 }
11922 /*
11923 * Turn a dict into a list:
11924 * "what" == 0: list of keys
11925 * "what" == 1: list of values
11926 * "what" == 2: list of items
11927 */
11928 static void
11933 {
11944 {
11947 }
11956 {
11958 {
11968 {
11969 /* keys() */
11973 }
11975 {
11976 /* values() */
11978 }
11979 else
11980 {
11981 /* items() */
12003 }
12004 }
12005 }
12006 }
12008 /*
12009 * "items(dict)" function
12010 */
12011 static void
12015 {
12017 }
12019 /*
12020 * "join()" function
12021 */
12022 static void
12026 {
12027 garray_T ga;
12032 {
12035 }
12040 else
12046 {
12051 }
12052 else
12054 }
12056 /*
12057 * "keys()" function
12058 */
12059 static void
12063 {
12065 }
12067 /*
12068 * "last_buffer_nr()" function.
12069 */
12070 /*ARGSUSED*/
12071 static void
12075 {
12084 }
12086 /*
12087 * "len()" function
12088 */
12089 static void
12093 {
12095 {
12110 }
12111 }
12115 static void
12120 {
12121 #ifdef FEAT_LIBCALL
12125 #endif
12130 else
12136 #ifdef FEAT_LIBCALL
12137 /* The first two args must be strings, otherwise its meaningless */
12139 {
12145 else
12149 string_in,
12151 string_result,
12155 }
12156 #endif
12157 }
12159 /*
12160 * "libcall()" function
12161 */
12162 static void
12166 {
12168 }
12170 /*
12171 * "libcallnr()" function
12172 */
12173 static void
12177 {
12179 }
12181 /*
12182 * "line(string)" function
12183 */
12184 static void
12188 {
12197 }
12199 /*
12200 * "line2byte(lnum)" function
12201 */
12202 /*ARGSUSED*/
12203 static void
12207 {
12208 #ifndef FEAT_BYTEOFF
12210 #else
12211 linenr_T lnum;
12216 else
12220 #endif
12221 }
12223 /*
12224 * "lispindent(lnum)" function
12225 */
12226 static void
12230 {
12231 #ifdef FEAT_LISP
12232 pos_T pos;
12233 linenr_T lnum;
12238 {
12242 }
12243 else
12244 #endif
12246 }
12248 /*
12249 * "localtime()" function
12250 */
12251 /*ARGSUSED*/
12252 static void
12256 {
12258 }
12262 static void
12267 {
12274 garray_T ga;
12277 /* return empty string for failure */
12286 {
12290 }
12291 else
12302 {
12312 }
12313 }
12315 /*
12316 * "map()" function
12317 */
12318 static void
12322 {
12324 }
12326 /*
12327 * "maparg()" function
12328 */
12329 static void
12333 {
12335 }
12337 /*
12338 * "mapcheck()" function
12339 */
12340 static void
12344 {
12346 }
12350 static void
12355 {
12359 regmatch_T regmatch;
12372 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12378 {
12379 /* return empty list when there are no matches */
12382 }
12384 {
12387 }
12390 {
12394 }
12395 else
12403 {
12410 {
12415 }
12416 else
12417 {
12422 /* When "count" argument is there ignore matches before "start",
12423 * otherwise skip part of the string. Differs when pattern is "^"
12424 * or "\<". */
12427 else
12429 }
12435 }
12439 {
12443 {
12445 {
12447 {
12450 }
12455 }
12464 /* Advance to just after the match. */
12466 {
12469 }
12470 else
12471 {
12472 #ifdef FEAT_MBYTE
12475 #else
12477 #endif
12478 }
12479 }
12482 {
12484 {
12487 /* return list with matched string and submatches */
12489 {
12491 {
12495 }
12501 }
12502 }
12504 {
12505 /* return matched string */
12508 else
12511 }
12514 else
12515 {
12519 else
12523 }
12524 }
12526 }
12528 theend:
12531 }
12533 /*
12534 * "match()" function
12535 */
12536 static void
12540 {
12542 }
12544 /*
12545 * "matchadd()" function
12546 */
12547 static void
12551 {
12552 #ifdef FEAT_SEARCH_EXTRA
12565 {
12569 }
12573 {
12576 }
12579 #endif
12580 }
12582 /*
12583 * "matcharg()" function
12584 */
12585 static void
12589 {
12591 {
12592 #ifdef FEAT_SEARCH_EXTRA
12597 {
12599 {
12603 }
12604 else
12605 {
12608 }
12609 }
12610 #endif
12611 }
12612 }
12614 /*
12615 * "matchdelete()" function
12616 */
12617 static void
12621 {
12622 #ifdef FEAT_SEARCH_EXTRA
12625 #endif
12626 }
12628 /*
12629 * "matchend()" function
12630 */
12631 static void
12635 {
12637 }
12639 /*
12640 * "matchlist()" function
12641 */
12642 static void
12646 {
12648 }
12650 /*
12651 * "matchstr()" function
12652 */
12653 static void
12657 {
12659 }
12663 static void
12668 {
12674 {
12680 {
12683 {
12686 {
12693 }
12694 }
12695 }
12696 }
12698 {
12706 {
12709 {
12711 {
12715 {
12718 }
12721 }
12722 }
12723 }
12724 }
12725 else
12728 }
12730 /*
12731 * "max()" function
12732 */
12733 static void
12737 {
12739 }
12741 /*
12742 * "min()" function
12743 */
12744 static void
12748 {
12750 }
12754 /*
12755 * Create the directory in which "dir" is located, and higher levels when
12756 * needed.
12757 */
12758 static int
12762 {
12767 /* Get end of directory name in "dir".
12768 * We're done when it's "/" or "c:/". */
12773 /* If the directory exists we're done. Otherwise: create it.*/
12783 }
12785 #ifdef vim_mkdir
12786 /*
12787 * "mkdir()" function
12788 */
12789 static void
12793 {
12804 {
12809 }
12811 }
12812 #endif
12814 /*
12815 * "mode()" function
12816 */
12817 /*ARGSUSED*/
12818 static void
12822 {
12825 #ifdef FEAT_VISUAL
12827 {
12830 else
12832 }
12833 else
12834 #endif
12838 {
12841 else
12843 }
12846 else
12852 }
12854 /*
12855 * "nextnonblank()" function
12856 */
12857 static void
12861 {
12862 linenr_T lnum;
12865 {
12867 {
12870 }
12873 }
12875 }
12877 /*
12878 * "nr2char()" function
12879 */
12880 static void
12884 {
12887 #ifdef FEAT_MBYTE
12890 else
12891 #endif
12892 {
12895 }
12898 }
12900 /*
12901 * "pathshorten()" function
12902 */
12903 static void
12907 {
12914 else
12915 {
12920 }
12921 }
12923 /*
12924 * "prevnonblank()" function
12925 */
12926 static void
12930 {
12931 linenr_T lnum;
12936 else
12940 }
12942 #ifdef HAVE_STDARG_H
12943 /* This dummy va_list is here because:
12944 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12945 * - locally in the function results in a "used before set" warning
12946 * - using va_start() to initialize it gives "function with fixed args" error */
12948 #endif
12950 /*
12951 * "printf()" function
12952 */
12953 static void
12957 {
12961 {
12968 /* Get the required length, allocate the buffer and do it for real. */
12973 {
12976 {
12979 }
12980 }
12982 }
12983 #endif
12984 }
12986 /*
12987 * "pumvisible()" function
12988 */
12989 /*ARGSUSED*/
12990 static void
12994 {
12996 #ifdef FEAT_INS_EXPAND
12999 #endif
13000 }
13002 /*
13003 * "range()" function
13004 */
13005 static void
13009 {
13018 {
13021 }
13022 else
13023 {
13027 }
13036 else
13037 {
13043 }
13044 }
13046 /*
13047 * "readfile()" function
13048 */
13049 static void
13053 {
13073 {
13078 }
13083 /* Always open the file in binary mode, library functions have a mind of
13084 * their own about CR-LF conversion. */
13087 {
13090 }
13094 {
13099 {
13101 {
13102 /* Only when in binary mode add an empty list item when the
13103 * last line ends in a '\n'. */
13107 /* Found end-of-line or end-of-file: add a text line to the
13108 * list. */
13117 else
13118 {
13121 {
13127 }
13128 }
13133 {
13136 }
13146 }
13149 }
13154 {
13155 /* "buf" is full, need to move text to an allocated buffer */
13157 {
13160 }
13161 else
13162 {
13165 {
13171 }
13172 }
13174 }
13175 else
13176 {
13179 }
13180 }
13182 /*
13183 * For a negative line count use only the lines at the end of the file,
13184 * free the rest.
13185 */
13188 {
13191 }
13195 }
13197 #if defined(FEAT_RELTIME)
13200 /*
13201 * Convert a List to proftime_T.
13202 * Return FAIL when there is something wrong.
13203 */
13204 static int
13208 {
13217 # ifdef WIN3264
13220 # else
13223 # endif
13225 }
13228 /*
13229 * "reltime()" function
13230 */
13231 static void
13235 {
13236 #ifdef FEAT_RELTIME
13237 proftime_T res;
13238 proftime_T start;
13241 {
13242 /* No arguments: get current time. */
13244 }
13246 {
13250 }
13251 else
13252 {
13253 /* Two arguments: compute the difference. */
13258 }
13261 {
13264 # ifdef WIN3264
13267 # else
13270 # endif
13273 }
13274 #endif
13275 }
13277 /*
13278 * "reltimestr()" function
13279 */
13280 static void
13284 {
13285 #ifdef FEAT_RELTIME
13286 proftime_T tm;
13287 #endif
13291 #ifdef FEAT_RELTIME
13294 #endif
13295 }
13297 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13301 static void
13303 {
13305 # ifdef FEAT_GUI
13307 # endif
13308 )
13309 {
13313 }
13314 }
13316 static int
13318 {
13321 {
13324 }
13326 }
13327 #endif
13329 #ifdef FEAT_CLIENTSERVER
13332 static void
13337 {
13342 # ifdef WIN32
13343 HWND w;
13344 # elif defined(FEAT_X11)
13345 Window w;
13346 # elif defined(MAC_CLIENTSERVER)
13348 # endif
13353 # ifdef FEAT_X11
13356 # endif
13362 # ifdef WIN32
13364 # elif defined(FEAT_X11)
13367 # elif defined(MAC_CLIENTSERVER)
13369 # endif
13370 {
13373 else
13376 }
13381 {
13382 dictitem_T v;
13393 }
13394 }
13395 #endif
13397 /*
13398 * "remote_expr()" function
13399 */
13400 /*ARGSUSED*/
13401 static void
13405 {
13408 #ifdef FEAT_CLIENTSERVER
13410 #endif
13411 }
13413 /*
13414 * "remote_foreground()" function
13415 */
13416 /*ARGSUSED*/
13417 static void
13421 {
13423 #ifdef FEAT_CLIENTSERVER
13424 # ifdef WIN32
13425 /* On Win32 it's done in this application. */
13426 {
13431 }
13432 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
13433 /* Send a foreground() expression to the server. */
13439 # endif
13440 #endif
13441 }
13443 /*ARGSUSED*/
13444 static void
13448 {
13449 #ifdef FEAT_CLIENTSERVER
13450 dictitem_T v;
13452 # ifdef WIN32
13454 # endif
13458 {
13461 }
13464 {
13467 }
13468 # ifdef WIN32
13472 else
13473 {
13476 }
13477 # elif defined(FEAT_X11)
13484 # elif defined(MAC_CLIENTSERVER)
13486 # endif
13489 {
13498 }
13499 #else
13501 #endif
13502 }
13504 /*ARGSUSED*/
13505 static void
13509 {
13512 #ifdef FEAT_CLIENTSERVER
13516 {
13517 # ifdef WIN32
13518 /* The server's HWND is encoded in the 'id' parameter */
13525 # elif defined(FEAT_X11)
13528 # elif defined(MAC_CLIENTSERVER)
13530 # endif
13532 }
13533 #endif
13536 }
13538 /*
13539 * "remote_send()" function
13540 */
13541 /*ARGSUSED*/
13542 static void
13546 {
13549 #ifdef FEAT_CLIENTSERVER
13551 #endif
13552 }
13554 /*
13555 * "remove()" function
13556 */
13557 static void
13561 {
13573 {
13578 {
13581 {
13585 else
13586 {
13590 }
13591 }
13592 }
13593 }
13598 {
13606 else
13607 {
13609 {
13610 /* Remove one item, return its value. */
13614 }
13615 else
13616 {
13617 /* Remove range of items, return list with values. */
13623 else
13624 {
13628 {
13632 }
13635 else
13636 {
13639 {
13646 }
13647 }
13648 }
13649 }
13650 }
13651 }
13652 }
13654 /*
13655 * "rename({from}, {to})" function
13656 */
13657 static void
13661 {
13666 else
13669 }
13671 /*
13672 * "repeat()" function
13673 */
13674 /*ARGSUSED*/
13675 static void
13679 {
13689 {
13695 }
13696 else
13697 {
13709 {
13713 }
13716 }
13717 }
13719 /*
13720 * "resolve()" function
13721 */
13722 static void
13726 {
13730 #ifdef FEAT_SHORTCUT
13731 {
13737 else
13739 }
13740 #else
13741 # ifdef HAVE_READLINK
13742 {
13764 {
13765 /* Separate the first path component in "p", and keep the
13766 * remainder (beginning with the path separator). */
13769 }
13772 {
13774 {
13781 {
13787 }
13789 /* Ensure that the result will have a trailing path separator
13790 * if the argument has one. */
13794 /* Separate the first path component in the link value and
13795 * concatenate the remainders. */
13798 {
13801 else
13802 {
13805 {
13808 }
13809 }
13811 }
13815 {
13816 /* Ignore trailing path separator. */
13819 }
13821 {
13822 /* symlink is relative to directory of argument */
13825 {
13830 }
13831 }
13832 else
13833 {
13836 }
13837 }
13842 /* Append the first path component of "remain" to "p". */
13847 {
13851 }
13852 /* Shorten "remain". */
13855 else
13856 {
13859 }
13860 }
13862 /* If the result is a relative path name, make it explicitly relative to
13863 * the current directory if and only if the argument had this form. */
13865 {
13874 {
13875 /* Prepend "./". */
13878 {
13881 }
13882 }
13884 {
13885 /* Strip leading "./". */
13891 }
13892 }
13894 /* Ensure that the result will have no trailing path separator
13895 * if the argument had none. But keep "/" or "//". */
13897 {
13901 }
13904 }
13905 # else
13907 # endif
13908 #endif
13912 #ifdef HAVE_READLINK
13913 fail:
13914 #endif
13916 }
13918 /*
13919 * "reverse({list})" function
13920 */
13921 static void
13925 {
13934 {
13939 {
13943 }
13947 }
13948 }
13960 /*
13961 * Get flags for a search function.
13962 * Possibly sets "p_ws".
13963 * Returns BACKWARD, FORWARD or zero (for an error).
13964 */
13965 static int
13969 {
13976 {
13981 {
13983 {
13990 {
13998 }
14000 {
14003 }
14004 else
14006 }
14010 }
14011 }
14013 }
14015 /*
14016 * Shared by search() and searchpos() functions
14017 */
14018 static int
14023 {
14026 pos_T pos;
14027 pos_T save_cursor;
14045 /* Optional extra argument: line number to stop searching. */
14048 {
14052 }
14054 /*
14055 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14056 * Check to make sure only those flags are set.
14057 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14058 * flags cannot be set. Check for that condition also.
14059 */
14062 {
14065 }
14071 {
14074 else
14080 {
14081 /* Store the match cursor position */
14084 }
14085 /* "/$" will put the cursor after the end of the line, may need to
14086 * correct that here */
14088 }
14090 /* If 'n' flag is used: restore cursor position. */
14093 else
14095 theend:
14099 }
14101 /*
14102 * "search()" function
14103 */
14104 static void
14108 {
14112 }
14114 /*
14115 * "searchdecl()" function
14116 */
14117 static void
14121 {
14131 {
14135 }
14139 }
14141 /*
14142 * Used by searchpair() and searchpairpos()
14143 */
14144 static int
14148 {
14160 /* Get the three pattern arguments: start, middle, end. */
14167 /* Handle the optional fourth argument: flags */
14172 /* Don't accept SP_END or SP_SUBPAT.
14173 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14174 */
14177 {
14180 }
14182 /* Optional fifth argument: skip expression */
14186 else
14187 {
14190 {
14194 }
14195 }
14202 theend:
14206 }
14208 /*
14209 * "searchpair()" function
14210 */
14211 static void
14215 {
14217 }
14219 /*
14220 * "searchpairpos()" function
14221 */
14222 static void
14226 {
14227 pos_T match_pos;
14237 {
14240 }
14244 }
14246 /*
14247 * Search for a start/middle/end thing.
14248 * Used by searchpair(), see its documentation for the details.
14249 * Returns 0 or -1 for no match,
14250 */
14251 long
14261 {
14265 pos_T pos;
14266 pos_T firstpos;
14267 pos_T foundpos;
14268 pos_T save_cursor;
14269 pos_T save_pos;
14276 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14280 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14281 * start/middle/end (pat3, for the top pair). */
14289 else
14301 {
14305 /* didn't find it or found the first match again: FAIL */
14311 {
14312 /* Found the same position again. Can happen with a pattern that
14313 * has "\zs" at the end and searching backwards. Advance one
14314 * character and try again. */
14317 else
14319 }
14322 /* If the skip pattern matches, ignore this match. */
14324 {
14330 {
14331 /* Evaluating {skip} caused an error, break here. */
14335 }
14338 }
14341 {
14342 /* Found end when searching backwards or start when searching
14343 * forward: nested pair. */
14346 }
14347 else
14348 {
14349 /* Found end when searching forward or start when searching
14350 * backward: end of (nested) pair; or found middle in outer pair. */
14353 }
14356 {
14357 /* Found the match: return matchcount or line number. */
14360 else
14368 }
14369 }
14372 {
14373 /* Store the match cursor position */
14376 }
14378 /* If 'n' flag is used or search failed: restore cursor position. */
14382 theend:
14388 }
14390 /*
14391 * "searchpos()" function
14392 */
14393 static void
14397 {
14398 pos_T match_pos;
14411 {
14414 }
14420 }
14423 /*ARGSUSED*/
14424 static void
14428 {
14429 #ifdef FEAT_CLIENTSERVER
14439 # ifdef FEAT_X11
14442 # endif
14445 {
14448 }
14450 #else
14452 #endif
14453 }
14455 /*ARGSUSED*/
14456 static void
14460 {
14463 #ifdef FEAT_CLIENTSERVER
14464 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
14466 # elif defined(FEAT_X11)
14470 # endif
14471 #endif
14474 }
14476 /*
14477 * "setbufvar()" function
14478 */
14479 /*ARGSUSED*/
14480 static void
14484 {
14486 aco_save_T aco;
14501 {
14502 /* set curbuf to be our buf, temporarily */
14506 {
14516 }
14517 else
14518 {
14521 {
14526 }
14527 }
14529 /* reset notion of buffer */
14531 }
14532 }
14534 /*
14535 * "setcmdpos()" function
14536 */
14537 static void
14541 {
14546 }
14548 /*
14549 * "setline()" function
14550 */
14551 static void
14555 {
14556 linenr_T lnum;
14565 {
14568 }
14569 else
14574 {
14576 {
14577 /* list argument, get next string */
14582 }
14588 {
14589 /* existing line, replace it */
14591 {
14596 }
14597 }
14599 {
14600 /* lnum is one past the last line, append the line */
14604 }
14609 }
14613 }
14615 /*
14616 * Used by "setqflist()" and "setloclist()" functions
14617 */
14618 /*ARGSUSED*/
14619 static void
14625 {
14626 #ifdef FEAT_QUICKFIX
14629 #endif
14633 #ifdef FEAT_QUICKFIX
14636 else
14637 {
14641 {
14647 }
14651 }
14652 #endif
14653 }
14655 /*
14656 * "setloclist()" function
14657 */
14658 /*ARGSUSED*/
14659 static void
14663 {
14671 }
14673 /*
14674 * "setmatches()" function
14675 */
14676 static void
14680 {
14681 #ifdef FEAT_SEARCH_EXTRA
14688 {
14691 }
14693 {
14695 /* To some extent make sure that we are dealing with a list from
14696 * "getmatches()". */
14699 {
14702 {
14705 }
14710 {
14713 }
14715 }
14720 {
14727 }
14729 }
14730 #endif
14731 }
14733 /*
14734 * "setpos()" function
14735 */
14736 /*ARGSUSED*/
14737 static void
14741 {
14742 pos_T pos;
14748 {
14750 {
14753 {
14755 {
14758 }
14759 else
14761 }
14764 else
14766 }
14767 }
14768 }
14770 /*
14771 * "setqflist()" function
14772 */
14773 /*ARGSUSED*/
14774 static void
14778 {
14780 }
14782 /*
14783 * "setreg()" function
14784 */
14785 static void
14789 {
14795 char_u yank_type;
14814 {
14820 {
14830 #ifdef FEAT_VISUAL
14834 {
14838 }
14840 #endif
14841 }
14842 }
14849 }
14851 /*
14852 * "settabwinvar()" function
14853 */
14854 static void
14858 {
14860 }
14862 /*
14863 * "setwinvar()" function
14864 */
14865 static void
14869 {
14871 }
14873 /*
14874 * "setwinvar()" and "settabwinvar()" functions
14875 */
14876 static void
14881 {
14883 #ifdef FEAT_WINDOWS
14886 #endif
14897 #ifdef FEAT_WINDOWS
14900 else
14902 #endif
14908 {
14909 #ifdef FEAT_WINDOWS
14910 /* set curwin to be our win, temporarily */
14918 #endif
14921 {
14931 }
14932 else
14933 {
14936 {
14941 }
14942 }
14944 #ifdef FEAT_WINDOWS
14945 /* Restore current tabpage and window, if still valid (autocomands can
14946 * make them invalid). */
14950 {
14953 }
14954 #endif
14955 }
14956 }
14958 /*
14959 * "shellescape({string})" function
14960 */
14961 static void
14965 {
14968 }
14970 /*
14971 * "simplify()" function
14972 */
14973 static void
14977 {
14984 }
14986 static int
14987 #ifdef __BORLANDC__
14988 _RTLENTRYF
14989 #endif
14991 static int
14992 #ifdef __BORLANDC__
14993 _RTLENTRYF
14994 #endif
15000 #define ITEM_COMPARE_FAIL 999
15002 /*
15003 * Compare functions for f_sort() below.
15004 */
15005 static int
15006 #ifdef __BORLANDC__
15007 _RTLENTRYF
15008 #endif
15012 {
15027 else
15032 }
15034 static int
15035 #ifdef __BORLANDC__
15036 _RTLENTRYF
15037 #endif
15041 {
15043 typval_T rettv;
15047 /* shortcut after failure in previous call; compare all items equal */
15051 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15052 * in the copy without changing the original list items. */
15064 else
15065 /* return value has wrong type */
15071 }
15073 /*
15074 * "sort({list})" function
15075 */
15076 static void
15080 {
15090 else
15091 {
15106 {
15109 else
15110 {
15118 else
15120 }
15121 }
15123 /* Make an array with each entry pointing to an item in the List. */
15132 /* test the compare function */
15137 else
15138 {
15139 /* Sort the array with item pointers. */
15144 {
15145 /* Clear the List and append the items in the sorted order. */
15150 }
15151 }
15154 }
15155 }
15157 /*
15158 * "soundfold({word})" function
15159 */
15160 static void
15164 {
15169 #ifdef FEAT_SPELL
15171 #else
15173 #endif
15174 }
15176 /*
15177 * "spellbadword()" function
15178 */
15179 /* ARGSUSED */
15180 static void
15184 {
15192 #ifdef FEAT_SPELL
15194 {
15195 /* Find the start and length of the badly spelled word. */
15199 }
15201 {
15206 {
15207 /* Check the argument for spelling. */
15209 {
15212 {
15215 }
15217 }
15218 }
15219 }
15220 #endif
15229 }
15231 /*
15232 * "spellsuggest()" function
15233 */
15234 /*ARGSUSED*/
15235 static void
15239 {
15240 #ifdef FEAT_SPELL
15244 garray_T ga;
15248 #endif
15253 #ifdef FEAT_SPELL
15255 {
15258 {
15263 {
15267 }
15268 }
15269 else
15275 {
15281 else
15282 {
15287 }
15288 }
15290 }
15291 #endif
15292 }
15294 static void
15298 {
15302 regmatch_T regmatch;
15310 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15316 {
15322 }
15333 {
15336 {
15339 else
15343 else
15347 {
15351 }
15354 /* Advance to just after the match. */
15357 else
15358 {
15359 /* Don't get stuck at the same match. */
15360 #ifdef FEAT_MBYTE
15362 #else
15364 #endif
15365 }
15367 }
15370 }
15373 }
15375 /*
15376 * "str2nr()" function
15377 */
15378 static void
15382 {
15388 {
15391 {
15394 }
15395 }
15400 }
15402 #ifdef HAVE_STRFTIME
15403 /*
15404 * "strftime({format}[, {time}])" function
15405 */
15406 static void
15410 {
15421 else
15424 /* MSVC returns NULL for an invalid value of seconds. */
15427 else
15428 {
15429 # ifdef FEAT_MBYTE
15430 vimconv_T conv;
15438 # endif
15442 else
15445 # ifdef FEAT_MBYTE
15451 else
15452 # endif
15455 # ifdef FEAT_MBYTE
15456 /* Release conversion descriptors */
15459 # endif
15460 }
15461 }
15462 #endif
15464 /*
15465 * "stridx()" function
15466 */
15467 static void
15471 {
15486 {
15494 }
15499 }
15501 /*
15502 * "string()" function
15503 */
15504 static void
15508 {
15514 /* Make a copy if we have a value but it's not in allocate memory. */
15517 }
15519 /*
15520 * "strlen()" function
15521 */
15522 static void
15526 {
15529 }
15531 /*
15532 * "strpart()" function
15533 */
15534 static void
15538 {
15553 else
15556 /*
15557 * Only return the overlap between the specified part and the actual
15558 * string.
15559 */
15561 {
15564 }
15574 }
15576 /*
15577 * "strridx()" function
15578 */
15579 static void
15583 {
15600 {
15601 /* Third argument: upper limit for index */
15605 }
15606 else
15610 {
15611 /* Empty string matches past the end. */
15613 }
15614 else
15615 {
15617 {
15622 }
15623 }
15627 else
15629 }
15631 /*
15632 * "strtrans()" function
15633 */
15634 static void
15638 {
15641 }
15643 /*
15644 * "submatch()" function
15645 */
15646 static void
15650 {
15654 }
15656 /*
15657 * "substitute()" function
15658 */
15659 static void
15663 {
15676 else
15678 }
15680 /*
15681 * "synID(lnum, col, trans)" function
15682 */
15683 /*ARGSUSED*/
15684 static void
15688 {
15690 #ifdef FEAT_SYN_HL
15703 #endif
15706 }
15708 /*
15709 * "synIDattr(id, what [, mode])" function
15710 */
15711 /*ARGSUSED*/
15712 static void
15716 {
15718 #ifdef FEAT_SYN_HL
15728 {
15732 #ifdef FEAT_GUI
15734 #endif
15735 )
15737 }
15738 else
15739 {
15740 #ifdef FEAT_GUI
15743 else
15744 #endif
15747 else
15749 }
15753 {
15786 /* underline */
15788 else
15789 /* undercurl */
15792 }
15796 #endif
15799 }
15801 /*
15802 * "synIDtrans(id)" function
15803 */
15804 /*ARGSUSED*/
15805 static void
15809 {
15812 #ifdef FEAT_SYN_HL
15817 else
15818 #endif
15822 }
15824 /*
15825 * "system()" function
15826 */
15827 static void
15831 {
15843 {
15844 /*
15845 * Write the string to a temp file, to be used for input of the shell
15846 * command.
15847 */
15849 {
15852 }
15856 {
15859 }
15862 {
15865 }
15871 {
15874 }
15875 }
15880 #ifdef USE_CR
15881 /* translate <CR> into <NL> */
15883 {
15887 {
15890 }
15891 }
15892 #else
15893 # ifdef USE_CRNL
15894 /* translate <CR><NL> into <NL> */
15896 {
15901 {
15905 }
15907 }
15908 # endif
15909 #endif
15911 done:
15913 {
15916 }
15919 }
15921 /*
15922 * "tabpagebuflist()" function
15923 */
15924 /* ARGSUSED */
15925 static void
15929 {
15930 #ifndef FEAT_WINDOWS
15932 #else
15938 else
15939 {
15943 }
15946 else
15947 {
15950 else
15951 {
15956 }
15957 }
15958 #endif
15959 }
15962 /*
15963 * "tabpagenr()" function
15964 */
15965 /* ARGSUSED */
15966 static void
15970 {
15972 #ifdef FEAT_WINDOWS
15976 {
15980 {
15983 else
15985 }
15986 }
15987 else
15989 #endif
15991 }
15994 #ifdef FEAT_WINDOWS
15997 /*
15998 * Common code for tabpagewinnr() and winnr().
15999 */
16000 static int
16004 {
16012 {
16019 {
16023 }
16024 else
16025 {
16028 }
16029 }
16034 {
16036 {
16037 /* didn't find it in this tabpage */
16040 }
16042 }
16044 }
16045 #endif
16047 /*
16048 * "tabpagewinnr()" function
16049 */
16050 /* ARGSUSED */
16051 static void
16055 {
16057 #ifdef FEAT_WINDOWS
16063 else
16065 #endif
16067 }
16070 /*
16071 * "tagfiles()" function
16072 */
16073 /*ARGSUSED*/
16074 static void
16078 {
16080 tagname_T tn;
16084 {
16087 }
16094 }
16096 /*
16097 * "taglist()" function
16098 */
16099 static void
16103 {
16114 }
16116 /*
16117 * "tempname()" function
16118 */
16119 /*ARGSUSED*/
16120 static void
16124 {
16130 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16131 * names. Skip 'I' and 'O', they are used for shell redirection. */
16132 do
16133 {
16138 else
16139 {
16140 #ifdef EBCDIC
16145 else
16146 #endif
16148 }
16150 }
16152 /*
16153 * "test(list)" function: Just checking the walls...
16154 */
16155 /*ARGSUSED*/
16156 static void
16160 {
16161 /* Used for unit testing. Change the code below to your liking. */
16162 #if 0
16181 #endif
16182 }
16184 /*
16185 * "tolower(string)" function
16186 */
16187 static void
16191 {
16200 {
16201 #ifdef FEAT_MBYTE
16205 {
16211 /* TODO: reallocate string when byte count changes. */
16215 }
16218 else
16219 #endif
16220 {
16223 }
16224 }
16225 }
16227 /*
16228 * "toupper(string)" function
16229 */
16230 static void
16234 {
16237 }
16239 /*
16240 * "tr(string, fromstr, tostr)" function
16241 */
16242 static void
16246 {
16251 #ifdef FEAT_MBYTE
16259 #endif
16262 garray_T ga;
16268 /* Default return value: empty string. */
16275 #ifdef FEAT_MBYTE
16277 #endif
16278 /* not multi-byte: fromstr and tostr must be the same length */
16280 {
16281 #ifdef FEAT_MBYTE
16282 error:
16283 #endif
16287 }
16289 /* fromstr and tostr have to contain the same number of chars */
16291 {
16292 #ifdef FEAT_MBYTE
16294 {
16300 {
16303 {
16305 {
16308 {
16312 }
16313 }
16317 }
16319 }
16322 {
16323 /* Check that fromstr and tostr have the same number of
16324 * (multi-byte) characters. Done only once when a character
16325 * of instr doesn't appear in fromstr. */
16328 {
16331 }
16334 }
16341 }
16342 else
16343 #endif
16344 {
16345 /* When not using multi-byte chars we can do it faster. */
16349 else
16352 }
16353 }
16355 /* add a terminating NUL */
16360 }
16362 /*
16363 * "type(expr)" function
16364 */
16365 static void
16369 {
16373 {
16380 }
16382 }
16384 /*
16385 * "values(dict)" function
16386 */
16387 static void
16391 {
16393 }
16395 /*
16396 * "virtcol(string)" function
16397 */
16398 static void
16402 {
16410 {
16413 }
16416 }
16418 /*
16419 * "visualmode()" function
16420 */
16421 /*ARGSUSED*/
16422 static void
16426 {
16427 #ifdef FEAT_VISUAL
16435 /* A non-zero number or non-empty string argument: reset mode. */
16441 #else
16443 #endif
16444 }
16446 /*
16447 * "winbufnr(nr)" function
16448 */
16449 static void
16453 {
16459 else
16461 }
16463 /*
16464 * "wincol()" function
16465 */
16466 /*ARGSUSED*/
16467 static void
16471 {
16474 }
16476 /*
16477 * "winheight(nr)" function
16478 */
16479 static void
16483 {
16489 else
16491 }
16493 /*
16494 * "winline()" function
16495 */
16496 /*ARGSUSED*/
16497 static void
16501 {
16504 }
16506 /*
16507 * "winnr()" function
16508 */
16509 /* ARGSUSED */
16510 static void
16514 {
16517 #ifdef FEAT_WINDOWS
16519 #endif
16521 }
16523 /*
16524 * "winrestcmd()" function
16525 */
16526 /* ARGSUSED */
16527 static void
16531 {
16532 #ifdef FEAT_WINDOWS
16535 garray_T ga;
16540 {
16543 # ifdef FEAT_VERTSPLIT
16546 # endif
16548 }
16552 #else
16554 #endif
16556 }
16558 /*
16559 * "winrestview()" function
16560 */
16561 /* ARGSUSED */
16562 static void
16566 {
16572 else
16573 {
16576 #ifdef FEAT_VIRTUALEDIT
16578 #endif
16583 #ifdef FEAT_DIFF
16585 #endif
16598 #ifdef FEAT_DIFF
16600 #endif
16601 }
16602 }
16604 /*
16605 * "winsaveview()" function
16606 */
16607 /* ARGSUSED */
16608 static void
16612 {
16624 #ifdef FEAT_VIRTUALEDIT
16626 #endif
16631 #ifdef FEAT_DIFF
16633 #endif
16636 }
16638 /*
16639 * "winwidth(nr)" function
16640 */
16641 static void
16645 {
16651 else
16652 #ifdef FEAT_VERTSPLIT
16654 #else
16656 #endif
16657 }
16659 /*
16660 * "writefile()" function
16661 */
16662 static void
16666 {
16679 {
16682 }
16690 /* Always open the file in binary mode, library functions have a mind of
16691 * their own about CR-LF conversion. */
16694 {
16697 }
16698 else
16699 {
16702 {
16704 {
16707 else
16710 {
16713 }
16714 }
16717 {
16720 }
16722 {
16725 }
16726 }
16728 }
16731 }
16733 /*
16734 * Translate a String variable into a position.
16735 * Returns NULL when there is an error.
16736 */
16742 {
16747 /* Argument can be [lnum, col, coladd]. */
16749 {
16759 /* Get the line number */
16764 /* Get the column number */
16770 /* We accept "$" for the column number: last column. */
16777 /* Accept a position up to the NUL after the line. */
16782 #ifdef FEAT_VIRTUALEDIT
16783 /* Get the virtual offset. Defaults to zero. */
16787 #endif
16790 }
16798 {
16803 }
16805 #ifdef FEAT_VIRTUALEDIT
16807 #endif
16810 {
16813 {
16817 }
16819 {
16823 }
16824 }
16826 {
16828 {
16831 }
16832 else
16833 {
16836 }
16838 }
16840 }
16842 /*
16843 * Convert list in "arg" into a position and optional file number.
16844 * When "fnump" is NULL there is no file number, only 3 items.
16845 * Note that the column is passed on as-is, the caller may want to decrement
16846 * it to use 1 for the first column.
16847 * Return FAIL when conversion is not possible, doesn't check the position for
16848 * validity.
16849 */
16850 static int
16855 {
16860 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16861 * when "fnump" isn't NULL and "coladd" is optional. */
16869 {
16876 }
16888 #ifdef FEAT_VIRTUALEDIT
16892 else
16894 #endif
16897 }
16899 /*
16900 * Get the length of an environment variable name.
16901 * Advance "arg" to the first character after the name.
16902 * Return 0 for error.
16903 */
16904 static int
16907 {
16912 ;
16919 }
16921 /*
16922 * Get the length of the name of a function or internal variable.
16923 * "arg" is advanced to the first non-white character after the name.
16924 * Return 0 if something is wrong.
16925 */
16926 static int
16929 {
16933 /* Find the end of the name. */
16935 ;
16943 }
16945 /*
16946 * Get the length of the name of a variable or function.
16947 * Only the name is recognized, does not handle ".key" or "[idx]".
16948 * "arg" is advanced to the first non-white character after the name.
16949 * Return -1 if curly braces expansion failed.
16950 * Return 0 if something else is wrong.
16951 * If the name contains 'magic' {}'s, expand them and return the
16952 * expanded name in an allocated string via 'alias' - caller must free.
16953 */
16954 static int
16960 {
16970 {
16971 /* hard coded <SNR>, already translated */
16974 }
16977 {
16978 /* literal "<SID>", "s:" or "<SNR>" */
16980 }
16982 /*
16983 * Find the end of the name; check for {} construction.
16984 */
16988 {
16992 {
16996 }
16998 /*
16999 * Include any <SID> etc in the expanded string:
17000 * Thus the -len here.
17001 */
17008 }
17015 }
17017 /*
17018 * Find the end of a variable or function name, taking care of magic braces.
17019 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17020 * start and end of the first magic braces item.
17021 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17022 * Return a pointer to just after the name. Equal to "arg" if there is no
17023 * valid name.
17024 */
17031 {
17037 {
17040 }
17042 /* Quick check for valid starting character. */
17052 {
17054 {
17055 /* skip over 'string' to avoid counting [ and ] inside it. */
17057 ;
17060 }
17062 {
17063 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17069 }
17072 {
17077 }
17080 {
17082 {
17083 mb_nest++;
17086 }
17088 {
17089 mb_nest--;
17092 }
17093 }
17094 }
17097 }
17099 /*
17100 * Expands out the 'magic' {}'s in a variable/function name.
17101 * Note that this can call itself recursively, to deal with
17102 * constructs like foo{bar}{baz}{bam}
17103 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17104 * "in_start" ^
17105 * "expr_start" ^
17106 * "expr_end" ^
17107 * "in_end" ^
17108 *
17109 * Returns a new allocated string, which the caller must free.
17110 * Returns NULL for failure.
17111 */
17118 {
17119 char_u c1;
17133 {
17137 {
17141 }
17142 }
17150 {
17153 {
17154 /* Further expansion! */
17159 }
17160 }
17163 }
17165 /*
17166 * Return TRUE if character "c" can be used in a variable or function name.
17167 * Does not include '{' or '}' for magic braces.
17168 */
17169 static int
17172 {
17174 }
17176 /*
17177 * Return TRUE if character "c" can be used as the first character in a
17178 * variable or function name (excluding '{' and '}').
17179 */
17180 static int
17183 {
17185 }
17187 /*
17188 * Set number v: variable to "val".
17189 */
17190 void
17194 {
17196 }
17198 /*
17199 * Get number v: variable value.
17200 */
17201 long
17204 {
17206 }
17208 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17209 /*
17210 * Get string v: variable value. Uses a static buffer, can only be used once.
17211 */
17212 char_u *
17215 {
17217 }
17218 #endif
17220 /*
17221 * Set v:count, v:count1 and v:prevcount.
17222 */
17223 void
17227 {
17231 }
17233 /*
17234 * Set string v: variable to a copy of "val".
17235 */
17236 void
17241 {
17242 /* Need to do this (at least) once, since we can't initialize a union.
17243 * Will always be invoked when "v:progname" is set. */
17251 else
17253 }
17255 /*
17256 * Set v:register if needed.
17257 */
17258 void
17261 {
17262 char_u regname;
17266 else
17268 /* Avoid free/alloc when the value is already right. */
17271 }
17273 /*
17274 * Get or set v:exception. If "oldval" == NULL, return the current value.
17275 * Otherwise, restore the value to "oldval" and return NULL.
17276 * Must always be called in pairs to save and restore v:exception! Does not
17277 * take care of memory allocations.
17278 */
17279 char_u *
17282 {
17288 }
17290 /*
17291 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17292 * Otherwise, restore the value to "oldval" and return NULL.
17293 * Must always be called in pairs to save and restore v:throwpoint! Does not
17294 * take care of memory allocations.
17295 */
17296 char_u *
17299 {
17305 }
17307 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17308 /*
17309 * Set v:cmdarg.
17310 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17311 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17312 * Must always be called in pairs!
17313 */
17314 char_u *
17318 {
17325 {
17329 }
17335 else
17343 # ifdef FEAT_MBYTE
17348 # endif
17358 else
17367 # ifdef FEAT_MBYTE
17374 # endif
17377 }
17378 #endif
17380 /*
17381 * Get the value of internal variable "name".
17382 * Return OK or FAIL.
17383 */
17384 static int
17390 {
17393 typval_T atv;
17397 /* truncate the name, so that we can use strcmp() */
17401 /*
17402 * Check for "b:changedtick".
17403 */
17405 {
17409 }
17411 /*
17412 * Check for user-defined variables.
17413 */
17414 else
17415 {
17419 }
17422 {
17426 }
17433 }
17435 /*
17436 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17437 * Also handle function call with Funcref variable: func(expr)
17438 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17439 */
17440 static int
17446 {
17451 typval_T functv;
17458 {
17460 {
17461 /* need to copy the funcref so that we can clear rettv */
17465 /* Invoke the function. Recursive! */
17471 /* Clear the funcref afterwards, so that deleting it while
17472 * evaluating the arguments is possible (see test55). */
17475 /* Stop the expression evaluation when immediately aborting on
17476 * error, or when an interrupt occurred or an exception was thrown
17477 * but not caught. */
17479 {
17483 }
17486 }
17488 {
17491 {
17495 }
17496 else
17499 {
17502 }
17503 }
17504 }
17507 }
17509 /*
17510 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17511 * value).
17512 */
17515 {
17517 }
17519 /*
17520 * Allocate memory for a variable type-value, and assign a string to it.
17521 * The string "s" must have been allocated, it is consumed.
17522 * Return NULL for out of memory, the variable otherwise.
17523 */
17527 {
17532 {
17535 }
17536 else
17539 }
17541 /*
17542 * Free the memory for a variable type-value.
17543 */
17544 void
17547 {
17549 {
17551 {
17554 /*FALLTHROUGH*/
17570 }
17572 }
17573 }
17575 /*
17576 * Free the memory for a variable value and set the value to NULL or 0.
17577 */
17578 void
17581 {
17583 {
17585 {
17588 /*FALLTHROUGH*/
17608 }
17610 }
17611 }
17613 /*
17614 * Set the value of a variable to NULL without freeing items.
17615 */
17616 static void
17619 {
17622 }
17624 /*
17625 * Get the number value of a variable.
17626 * If it is a String variable, uses vim_str2nr().
17627 * For incompatible types, return 0.
17628 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17629 * caller of incompatible types: it sets *denote to TRUE if "denote"
17630 * is not NULL or returns -1 otherwise.
17631 */
17632 static long
17635 {
17639 }
17641 long
17645 {
17649 {
17669 }
17672 else
17675 }
17677 /*
17678 * Get the lnum from the first argument.
17679 * Also accepts ".", "$", etc., but that only works for the current buffer.
17680 * Returns -1 on error.
17681 */
17682 static linenr_T
17685 {
17686 typval_T rettv;
17687 linenr_T lnum;
17691 {
17696 }
17698 }
17700 /*
17701 * Get the lnum from the first argument.
17702 * Also accepts "$", then "buf" is used.
17703 * Returns 0 on error.
17704 */
17705 static linenr_T
17709 {
17716 }
17718 /*
17719 * Get the string value of a variable.
17720 * If it is a Number variable, the number is converted into a string.
17721 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17722 * get_tv_string_buf() uses a given buffer.
17723 * If the String variable has never been set, return an empty string.
17724 * Never returns NULL;
17725 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17726 * NULL on error.
17727 */
17731 {
17735 }
17741 {
17745 }
17747 char_u *
17750 {
17754 }
17760 {
17762 {
17782 }
17784 }
17786 /*
17787 * Find variable "name" in the list of variables.
17788 * Return a pointer to it if found, NULL if not found.
17789 * Careful: "a:0" variables don't have a name.
17790 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17791 * hashtab_T used.
17792 */
17797 {
17807 }
17809 /*
17810 * Find variable "varname" in hashtab "ht".
17811 * Returns NULL if not found.
17812 */
17818 {
17822 {
17823 /* Must be something like "s:", otherwise "ht" would be NULL. */
17825 {
17831 #ifdef FEAT_WINDOWS
17833 #endif
17838 }
17840 }
17844 {
17845 /* For global variables we may try auto-loading the script. If it
17846 * worked find the variable again. Don't auto-load a script if it was
17847 * loaded already, otherwise it would be loaded every time when
17848 * checking if a function name is a Funcref variable. */
17854 }
17856 }
17858 /*
17859 * Find the hashtab used for a variable name.
17860 * Set "varname" to the start of name without ':'.
17861 */
17866 {
17870 {
17871 /* The name must not start with a colon or #. */
17876 /* "version" is "v:version" in all scopes */
17884 }
17888 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17889 */
17897 #ifdef FEAT_WINDOWS
17900 #endif
17911 }
17913 /*
17914 * Get the string value of a (global/local) variable.
17915 * Returns NULL when it doesn't exist.
17916 */
17917 char_u *
17920 {
17927 }
17929 /*
17930 * Allocate a new hashtab for a sourced script. It will be used while
17931 * sourcing this script and when executing functions defined in the script.
17932 */
17933 void
17935 scid_T id;
17936 {
17942 {
17943 /* Re-allocating ga_data means that an ht_array pointing to
17944 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
17945 * at its init value. Also reset "v_dict", it's always the same. */
17947 {
17953 }
17956 {
17960 }
17961 }
17962 }
17964 /*
17965 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
17966 * point to it.
17967 */
17968 void
17972 {
17980 }
17982 /*
17983 * Clean up a list of internal variables.
17984 * Frees all allocated variables and the value they contain.
17985 * Clears hashtab "ht", does not free it.
17986 */
17987 void
17990 {
17992 }
17994 /*
17995 * Like vars_clear(), but only free the value if "free_val" is TRUE.
17996 */
17997 static void
18001 {
18009 {
18011 {
18014 /* Free the variable. Don't remove it from the hashtab,
18015 * ht_array might change then. hash_clear() takes care of it
18016 * later. */
18022 }
18023 }
18026 }
18028 /*
18029 * Delete a variable from hashtab "ht" at item "hi".
18030 * Clear the variable value and free the dictitem.
18031 */
18032 static void
18036 {
18042 }
18044 /*
18045 * List the value of one internal variable.
18046 */
18047 static void
18052 {
18061 }
18063 static void
18070 {
18071 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18083 {
18087 }
18089 {
18093 }
18094 else
18102 {
18105 }
18106 }
18108 /*
18109 * Set variable "name" to value in "tv".
18110 * If the variable already exists, the value is updated.
18111 * Otherwise the variable is created.
18112 */
18113 static void
18118 {
18125 {
18129 {
18132 }
18134 {
18136 name);
18138 }
18139 }
18143 {
18146 }
18150 {
18151 /* existing variable, need to clear the value */
18160 {
18163 }
18165 /*
18166 * Handle setting internal v: variables separately: we don't change
18167 * the type.
18168 */
18170 {
18172 {
18176 else
18177 {
18178 /* Take over the string to avoid an extra alloc/free. */
18181 }
18182 }
18185 else
18188 }
18191 }
18193 {
18194 /* Can't add "v:" variable. */
18196 {
18199 }
18201 /* Make sure the variable name is valid. */
18205 {
18208 }
18216 {
18219 }
18221 }
18225 else
18226 {
18230 }
18231 }
18233 /*
18234 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18235 * Also give an error message.
18236 */
18237 static int
18241 {
18243 {
18246 }
18248 {
18251 }
18253 }
18255 /*
18256 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18257 * Also give an error message.
18258 */
18259 static int
18263 {
18265 {
18268 }
18270 }
18272 /*
18273 * Return TRUE if typeval "tv" is set to be locked (immutable).
18274 * Also give an error message, using "name".
18275 */
18276 static int
18280 {
18282 {
18286 }
18288 {
18292 }
18294 }
18296 /*
18297 * Copy the values from typval_T "from" to typval_T "to".
18298 * When needed allocates string or increases reference count.
18299 * Does not make a copy of a list or dict but copies the reference!
18300 */
18301 static void
18305 {
18309 {
18317 else
18318 {
18322 }
18327 else
18328 {
18331 }
18336 else
18337 {
18340 }
18345 }
18346 }
18348 /*
18349 * Make a copy of an item.
18350 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18351 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18352 * reference to an already copied list/dict can be used.
18353 * Returns FAIL or OK.
18354 */
18355 static int
18361 {
18366 {
18369 }
18373 {
18385 {
18386 /* use the copy made earlier */
18389 }
18390 else
18401 {
18402 /* use the copy made earlier */
18405 }
18406 else
18414 }
18417 }
18419 /*
18420 * ":echo expr1 ..." print each argument separated with a space, add a
18421 * newline at the end.
18422 * ":echon expr1 ..." print each argument plain.
18423 */
18424 void
18427 {
18429 typval_T rettv;
18439 {
18442 {
18443 /*
18444 * Report the invalid expression unless the expression evaluation
18445 * has been cancelled due to an aborting error, an interrupt, or an
18446 * exception.
18447 */
18451 }
18453 {
18455 {
18457 /* Call msg_start() after eval1(), evaluating the expression
18458 * may cause a message to appear. */
18461 }
18467 {
18469 {
18471 {
18472 /* remove any text still there from the command */
18475 }
18477 }
18478 else
18479 {
18480 #ifdef FEAT_MBYTE
18482 {
18487 }
18488 else
18489 #endif
18491 }
18492 }
18494 }
18497 }
18502 else
18503 {
18504 /* remove text that may still be there from the command */
18509 }
18510 }
18512 /*
18513 * ":echohl {name}".
18514 */
18515 void
18518 {
18524 else
18526 }
18528 /*
18529 * ":execute expr1 ..." execute the result of an expression.
18530 * ":echomsg expr1 ..." Print a message
18531 * ":echoerr expr1 ..." Print an error
18532 * Each gets spaces around each argument and a newline at the end for
18533 * echo commands
18534 */
18535 void
18538 {
18540 typval_T rettv;
18543 garray_T ga;
18552 {
18555 {
18556 /*
18557 * Report the invalid expression unless the expression evaluation
18558 * has been cancelled due to an aborting error, an interrupt, or an
18559 * exception.
18560 */
18565 }
18568 {
18572 {
18576 }
18581 }
18585 }
18588 {
18590 {
18593 }
18595 {
18596 /* We don't want to abort following commands, restore did_emsg. */
18601 }
18605 }
18613 }
18615 /*
18616 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18617 * "arg" points to the "&" or '+' when called, to "option" when returning.
18618 * Returns NULL when no option name found. Otherwise pointer to the char
18619 * after the option name.
18620 */
18625 {
18630 {
18633 }
18635 {
18638 }
18639 else
18648 else
18652 }
18654 /*
18655 * ":function"
18656 */
18657 void
18660 {
18669 garray_T newargs;
18670 garray_T newlines;
18679 funcdict_T fudi;
18687 /*
18688 * ":function" without argument: list functions.
18689 */
18691 {
18693 {
18696 {
18698 {
18703 }
18704 }
18705 }
18708 }
18710 /*
18711 * ":function /pat": list functions matching pattern.
18712 */
18714 {
18717 {
18718 regmatch_T regmatch;
18725 {
18730 {
18732 {
18738 }
18739 }
18740 }
18741 }
18746 }
18748 /*
18749 * Get the function name. There are these situations:
18750 * func normal function name
18751 * "name" == func, "fudi.fd_dict" == NULL
18752 * dict.func new dictionary entry
18753 * "name" == NULL, "fudi.fd_dict" set,
18754 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18755 * dict.func existing dict entry with a Funcref
18756 * "name" == func, "fudi.fd_dict" set,
18757 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18758 * dict.func existing dict entry that's not a Funcref
18759 * "name" == NULL, "fudi.fd_dict" set,
18760 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18761 */
18766 {
18767 /*
18768 * Return on an invalid expression in braces, unless the expression
18769 * evaluation has been cancelled due to an aborting error, an
18770 * interrupt, or an exception.
18771 */
18773 {
18778 }
18779 else
18781 }
18783 /* An error in a function call during evaluation of an expression in magic
18784 * braces should not cause the function not to be defined. */
18788 /*
18789 * ":function func" with only function name: list function.
18790 */
18792 {
18794 {
18797 }
18802 {
18805 {
18808 {
18820 }
18822 {
18825 }
18826 }
18827 else
18829 }
18831 }
18833 /*
18834 * ":function name(arg1, arg2)" Define function.
18835 */
18838 {
18840 {
18843 }
18844 /* attempt to continue by skipping some text */
18847 }
18854 {
18855 /* Check the name of the function. Unless it's a dictionary function
18856 * (that we are overwriting). */
18859 else
18863 {
18866 else
18873 }
18874 }
18876 /*
18877 * Isolate the arguments: "arg1, arg2, ...)"
18878 */
18880 {
18882 {
18886 }
18887 else
18888 {
18895 {
18899 }
18912 else
18914 }
18917 {
18921 }
18922 }
18925 /* find extra arguments "range", "dict" and "abort" */
18927 {
18930 {
18933 }
18935 {
18938 }
18940 {
18943 }
18944 else
18946 }
18948 /* When there is a line break use what follows for the function body.
18949 * Makes 'exe "func Test()\n...\nendfunc"' work. */
18955 /*
18956 * Read the body of the function, until ":endfunction" is found.
18957 */
18959 {
18960 /* Check if the function already exists, don't let the user type the
18961 * whole function before telling him it doesn't work! For a script we
18962 * need to skip the body to be able to find what follows. */
18964 {
18969 }
18976 }
18981 {
18987 {
18988 /* Use eap->arg, split up in parts by line breaks. */
18993 else
18994 {
18997 }
18998 }
19001 else
19006 {
19009 }
19011 /* Detect line continuation: sourcing_lnum increased more than one. */
19014 else
19018 {
19019 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19020 * don't check for ":endfunc". */
19022 {
19025 }
19026 }
19027 else
19028 {
19029 /* skip ':' and blanks*/
19031 ;
19033 /* Check for "endfunction". */
19035 {
19039 }
19041 /* Increase indent inside "if", "while", "for" and "try", decrease
19042 * at "end". */
19051 /* Check for defining a function inside this function. */
19053 {
19058 {
19061 {
19064 }
19065 }
19066 }
19068 /* Check for ":append" or ":insert". */
19076 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19089 ))
19090 {
19091 /* ":python <<" continues until a dot, like ":append" */
19095 else
19097 }
19098 }
19100 /* Add the line to the function. */
19102 {
19106 }
19108 /* Copy the line to newly allocated memory. get_one_sourceline()
19109 * allocates 250 bytes per line, this saves 80% on average. The cost
19110 * is an extra alloc/free. */
19113 {
19117 }
19121 /* Add NULL lines for continuation lines, so that the line count is
19122 * equal to the index in the growarray. */
19126 /* Check for end of eap->arg. */
19129 }
19131 /* Don't define the function when skipping commands or when an error was
19132 * detected. */
19136 /*
19137 * If there are no errors, add the function
19138 */
19140 {
19143 {
19145 name);
19147 }
19151 {
19153 {
19156 }
19158 {
19160 name);
19162 }
19163 /* redefine existing function */
19168 }
19169 }
19170 else
19171 {
19176 {
19179 }
19181 {
19182 /* Can't add a function to a locked dictionary */
19185 }
19186 /* Can't change an existing function if it is locked */
19190 /* Give the function a sequential number. Can only be used with a
19191 * Funcref! */
19197 }
19200 {
19202 {
19206 /* Check that the autoload name matches the script name. */
19209 {
19212 {
19220 }
19221 }
19223 {
19226 }
19227 }
19234 {
19236 {
19237 /* add new dict entry */
19240 {
19243 }
19245 {
19249 }
19250 }
19251 else
19252 /* overwrite existing dict entry */
19259 /* behave like "dict" was used */
19261 }
19263 /* insert the new function in the function list */
19266 }
19269 #ifdef FEAT_PROFILE
19276 #endif
19283 erret:
19286 ret_free:
19291 }
19293 /*
19294 * Get a function name, translating "<SID>" and "<SNR>".
19295 * Also handles a Funcref in a List or Dictionary.
19296 * Returns the function name in allocated memory, or NULL for failure.
19297 * flags:
19298 * TFN_INT: internal function name OK
19299 * TFN_QUIET: be quiet
19300 * Advances "pp" to just after the function name (if no error).
19301 */
19308 {
19315 lval_T lv;
19321 /* Check for hard coded <SNR>: already translated function ID (from a user
19322 * command). */
19325 {
19329 }
19331 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19332 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19340 {
19344 }
19346 {
19347 /*
19348 * Report an invalid expression in braces, unless the expression
19349 * evaluation has been cancelled due to an aborting error, an
19350 * interrupt, or an exception.
19351 */
19353 {
19356 }
19357 else
19360 }
19363 {
19365 {
19370 }
19372 {
19375 }
19376 else
19377 {
19381 else
19384 }
19386 }
19389 {
19390 /* Error found, but continue after the function name. */
19393 }
19395 /* Check if the name is a Funcref. If so, use the value. */
19397 {
19402 }
19403 else
19404 {
19409 }
19411 {
19415 }
19418 {
19422 {
19423 /* When there was "s:" already or the name expanded to get a
19424 * leading "s:" then remove it. */
19428 }
19429 }
19430 else
19431 {
19435 }
19437 /*
19438 * Copy the function name to allocated memory.
19439 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19440 * Accept <SNR>123_name() outside a script.
19441 */
19445 {
19449 {
19450 /* It's "s:" or "<SID>" */
19452 {
19455 }
19458 }
19459 }
19461 {
19464 }
19467 {
19469 {
19475 }
19478 }
19481 theend:
19484 }
19486 /*
19487 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19488 * Return 2 if "p" starts with "s:".
19489 * Return 0 otherwise.
19490 */
19491 static int
19494 {
19501 }
19503 /*
19504 * Return TRUE if "p" starts with "<SID>" or "s:".
19505 * Only works if eval_fname_script() returned non-zero for "p"!
19506 */
19507 static int
19510 {
19512 }
19514 /*
19515 * List the head of the function: "name(arg1, arg2)".
19516 */
19517 static void
19521 {
19529 {
19532 }
19533 else
19537 {
19541 }
19543 {
19547 }
19552 }
19554 /*
19555 * Find a function by name, return pointer to it in ufuncs.
19556 * Return NULL for unknown function.
19557 */
19561 {
19568 }
19570 #if defined(EXITFREE) || defined(PROTO)
19571 void
19573 {
19576 /* Need to start all over every time, because func_free() may change the
19577 * hash table. */
19581 {
19584 }
19585 }
19586 #endif
19588 /*
19589 * Return TRUE if a function "name" exists.
19590 */
19591 static int
19594 {
19602 /* Only accept "funcname", "funcname ", "funcname (..." and
19603 * "funcname(...", not "funcname!...". */
19605 {
19608 else
19610 }
19613 }
19615 /*
19616 * Return TRUE if "name" looks like a builtin function name: starts with a
19617 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19618 */
19619 static int
19622 {
19625 }
19627 #if defined(FEAT_PROFILE) || defined(PROTO)
19628 /*
19629 * Start profiling function "fp".
19630 */
19631 static void
19634 {
19653 }
19655 /*
19656 * Dump the profiling results for all functions in file "fd".
19657 */
19658 void
19661 {
19673 {
19675 {
19679 {
19685 else
19689 else
19697 {
19703 }
19705 }
19706 }
19707 }
19710 {
19712 prof_total_cmp);
19715 prof_self_cmp);
19717 }
19718 }
19720 static void
19727 {
19734 {
19737 prefer_self);
19740 else
19742 }
19744 }
19746 /*
19747 * Print the count and times for one function or function line.
19748 */
19749 static void
19756 {
19758 {
19762 else
19766 else
19768 }
19769 else
19771 }
19773 /*
19774 * Compare function for total time sorting.
19775 */
19776 static int
19777 #ifdef __BORLANDC__
19778 _RTLENTRYF
19779 #endif
19783 {
19789 }
19791 /*
19792 * Compare function for self time sorting.
19793 */
19794 static int
19795 #ifdef __BORLANDC__
19796 _RTLENTRYF
19797 #endif
19801 {
19807 }
19809 #endif
19811 /*
19812 * If "name" has a package name try autoloading the script for it.
19813 * Return TRUE if a package was loaded.
19814 */
19815 static int
19819 {
19825 /* If there is no '#' after name[0] there is no package name. */
19832 /* Find the name in the list of previously loaded package names. Skip
19833 * "autoload/", it's always the same. */
19839 else
19840 {
19841 /* Remember the name if it wasn't loaded already. */
19843 {
19846 }
19848 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19851 }
19855 }
19857 /*
19858 * Return the autoload script name for a function or variable name.
19859 * Returns NULL when out of memory.
19860 */
19864 {
19868 /* Get the script file name: replace '#' with '/', append ".vim". */
19879 }
19881 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19883 /*
19884 * Function given to ExpandGeneric() to obtain the list of user defined
19885 * function names.
19886 */
19887 char_u *
19891 {
19897 {
19900 }
19902 {
19914 {
19918 }
19920 }
19922 }
19926 /*
19927 * Copy the function name of "fp" to buffer "buf".
19928 * "buf" must be able to hold the function name plus three bytes.
19929 * Takes care of script-local function names.
19930 */
19931 static void
19935 {
19937 {
19940 }
19941 else
19943 }
19945 /*
19946 * ":delfunction {name}"
19947 */
19948 void
19951 {
19955 funcdict_T fudi;
19961 {
19965 }
19967 {
19971 }
19981 {
19983 {
19986 }
19988 {
19991 }
19994 {
19995 /* Delete the dict item that refers to the function, it will
19996 * invoke func_unref() and possibly delete the function. */
19998 }
19999 else
20001 }
20002 }
20004 /*
20005 * Free a function and remove it from the list of functions.
20006 */
20007 static void
20010 {
20013 /* clear this function */
20016 #ifdef FEAT_PROFILE
20020 #endif
20022 /* remove the function from the function hashtable */
20026 else
20030 }
20032 /*
20033 * Unreference a Function: decrement the reference count and free it when it
20034 * becomes zero. Only for numbered functions.
20035 */
20036 static void
20039 {
20043 {
20048 {
20049 /* Only delete it when it's not being used. Otherwise it's done
20050 * when "uf_calls" becomes zero. */
20053 }
20054 }
20055 }
20057 /*
20058 * Count a reference to a Function.
20059 */
20060 static void
20063 {
20067 {
20071 else
20073 }
20074 }
20076 /*
20077 * Call a user function.
20078 */
20079 static void
20088 {
20090 linenr_T save_sourcing_lnum;
20091 scid_T save_current_SID;
20092 funccall_T fc;
20101 #ifdef FEAT_PROFILE
20102 proftime_T wait_start;
20103 proftime_T call_start;
20104 #endif
20106 /* If depth of calling is getting too high, don't execute the function */
20108 {
20113 }
20126 /* Check if this function has a breakpoint. */
20130 /*
20131 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20132 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20133 * each argument variable and saves a lot of time.
20134 */
20135 /*
20136 * Init l: variables.
20137 */
20140 {
20141 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20142 * some compiler that checks the destination size. */
20152 }
20154 /*
20155 * Init a: variables.
20156 * Set a:0 to "argcount".
20157 * Set a:000 to a list with room for the "..." arguments.
20158 */
20173 /*
20174 * Set a:firstline to "firstline" and a:lastline to "lastline".
20175 * Set a:name to named arguments.
20176 * Set a:N to the "..." arguments.
20177 */
20183 {
20186 /* named argument a:name */
20188 else
20189 {
20190 /* "..." argument a:1, a:2, etc. */
20193 }
20195 {
20198 }
20199 else
20200 {
20206 }
20210 /* Note: the values are copied directly to avoid alloc/free.
20211 * "argvars" must have VAR_FIXED for v_lock. */
20216 {
20220 }
20221 }
20223 /* Don't redraw while executing the function. */
20231 {
20235 else
20240 {
20246 {
20254 {
20259 else
20260 {
20263 {
20267 }
20268 }
20269 }
20271 }
20276 }
20277 }
20278 #ifdef FEAT_PROFILE
20280 {
20285 {
20289 }
20291 }
20292 #endif
20299 /* call do_cmdline() to execute the lines */
20305 /* when the function was aborted because of an error, return -1 */
20307 {
20311 }
20313 #ifdef FEAT_PROFILE
20316 {
20322 {
20325 }
20326 }
20327 #endif
20329 /* when being verbose, mention the return value */
20331 {
20340 else
20341 {
20347 /* The value may be very long. Skip the middle part, so that we
20348 * have some idea how it starts and ends. smsg() would always
20349 * truncate it at the end. */
20352 {
20356 }
20357 }
20362 }
20368 #ifdef FEAT_PROFILE
20371 #endif
20374 {
20383 }
20388 /* The a: variables typevals were not alloced, only free the allocated
20389 * variables. */
20394 }
20396 /*
20397 * Add a number variable "name" to dict "dp" with value "nr".
20398 */
20399 static void
20404 varnumber_T nr;
20405 {
20412 }
20414 /*
20415 * ":return [expr]"
20416 */
20417 void
20420 {
20422 typval_T rettv;
20426 {
20429 }
20437 {
20440 else
20442 }
20443 /* It's safer to return also on error. */
20445 {
20446 /*
20447 * Return unless the expression evaluation has been cancelled due to an
20448 * aborting error, an interrupt, or an exception.
20449 */
20452 }
20454 /* When skipping or the return gets pending, advance to the next command
20455 * in this line (!returning). Otherwise, ignore the rest of the line.
20456 * Following lines will be ignored by get_func_line(). */
20464 }
20466 /*
20467 * Return from a function. Possibly makes the return pending. Also called
20468 * for a pending return at the ":endtry" or after returning from an extra
20469 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20470 * when called due to a ":return" command. "rettv" may point to a typval_T
20471 * with the return rettv. Returns TRUE when the return can be carried out,
20472 * FALSE when the return gets pending.
20473 */
20474 int
20480 {
20485 /* Undo the return. */
20488 /*
20489 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20490 * not in its finally clause (which then is to be executed next) is found.
20491 * In this case, make the ":return" pending for execution at the ":endtry".
20492 * Otherwise, return normally.
20493 */
20496 {
20500 /* A pending return again gets pending. "rettv" points to an
20501 * allocated variable with the rettv of the original ":return"'s
20502 * argument if present or is NULL else. */
20504 else
20505 {
20506 /* When undoing a return in order to make it pending, get the stored
20507 * return rettv. */
20512 {
20513 /* Store the value of the pending return. */
20516 else
20518 }
20519 else
20523 {
20524 /* The pending return value could be overwritten by a ":return"
20525 * without argument in a finally clause; reset the default
20526 * return value. */
20529 }
20530 }
20532 }
20533 else
20534 {
20537 /* If the return is carried out now, store the return value. For
20538 * a return immediately after reanimation, the value is already
20539 * there. */
20541 {
20546 }
20547 }
20550 }
20552 /*
20553 * Free the variable with a pending return value.
20554 */
20555 void
20558 {
20560 }
20562 /*
20563 * Generate a return command for producing the value of "rettv". The result
20564 * is an allocated string. Used by report_pending() for verbose messages.
20565 */
20566 char_u *
20569 {
20585 }
20587 /*
20588 * Get next function line.
20589 * Called by do_cmdline() to get the next line.
20590 * Returns allocated string, or NULL for end of function.
20591 */
20592 /* ARGSUSED */
20593 char_u *
20598 {
20604 /* If breakpoints have been added/deleted need to check for it. */
20606 {
20608 sourcing_lnum);
20610 }
20611 #ifdef FEAT_PROFILE
20614 #endif
20620 else
20621 {
20622 /* Skip NULL lines (continuation lines). */
20628 else
20629 {
20632 #ifdef FEAT_PROFILE
20635 #endif
20636 }
20637 }
20639 /* Did we encounter a breakpoint? */
20641 {
20643 /* Find next breakpoint. */
20645 sourcing_lnum);
20647 }
20650 }
20652 #if defined(FEAT_PROFILE) || defined(PROTO)
20653 /*
20654 * Called when starting to read a function line.
20655 * "sourcing_lnum" must be correct!
20656 * When skipping lines it may not actually be executed, but we won't find out
20657 * until later and we need to store the time now.
20658 */
20659 void
20662 {
20668 {
20670 /* Skip continuation lines. */
20677 }
20678 }
20680 /*
20681 * Called when actually executing a function line.
20682 */
20683 void
20686 {
20692 }
20694 /*
20695 * Called when done with a function line.
20696 */
20697 void
20700 {
20705 {
20707 {
20714 }
20716 }
20717 }
20718 #endif
20720 /*
20721 * Return TRUE if the currently active function should be ended, because a
20722 * return was encountered or an error occured. Used inside a ":while".
20723 */
20724 int
20727 {
20730 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20731 * an error inside a try conditional. */
20734 }
20736 /*
20737 * return TRUE if cookie indicates a function which "abort"s on errors.
20738 */
20739 int
20742 {
20744 }
20746 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20748 {
20749 VAR_FLAVOUR_DEFAULT,
20750 VAR_FLAVOUR_SESSION,
20751 VAR_FLAVOUR_VIMINFO
20756 static var_flavour_T
20759 {
20763 {
20768 }
20769 else
20771 }
20772 #endif
20774 #if defined(FEAT_VIMINFO) || defined(PROTO)
20775 /*
20776 * Restore global vars that start with a capital from the viminfo file
20777 */
20778 int
20782 {
20785 typval_T tv;
20788 {
20791 {
20798 {
20800 {
20804 }
20805 else
20806 {
20809 }
20813 }
20814 }
20815 }
20818 }
20820 /*
20821 * Write global vars that start with a capital to the viminfo file
20822 */
20823 void
20826 {
20842 {
20844 {
20848 {
20850 {
20854 }
20860 }
20861 }
20862 }
20863 }
20864 #endif
20866 #if defined(FEAT_SESSION) || defined(PROTO)
20867 int
20870 {
20878 {
20880 {
20886 {
20887 /* Escape special characters with a backslash. Turn a LF and
20888 * CR into \n and \r. */
20902 p,
20906 {
20909 }
20911 }
20912 }
20913 }
20915 }
20916 #endif
20918 /*
20919 * Display script name where an item was last set.
20920 * Should only be invoked when 'verbose' is non-zero.
20921 */
20922 void
20924 scid_T scriptID;
20925 {
20929 {
20932 {
20938 }
20939 }
20940 }
20944 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
20947 #ifdef WIN3264
20948 /*
20949 * Functions for ":8" filename modifier: get 8.3 version of a filename.
20950 */
20952 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
20955 /*
20956 * Get the short pathname of a file.
20957 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
20958 */
20959 static int
20964 {
20972 {
20973 /* If that doesn't work (not enough space), then save the string
20974 * and try again with a new buffer big enough
20975 */
20985 /* Really should always succeed, as the buffer is big enough */
20986 }
20990 }
20992 /*
20993 * Create a short path name. Returns the length of the buffer it needs.
20994 * Doesn't copy over the end of the buffer passed in.
20995 */
20996 static int
21001 {
21003 char_u ch;
21006 /* Make a copy */
21016 {
21020 }
21022 do
21023 {
21024 /* Go back one path-separator */
21026 {
21030 }
21034 /* Remember the character that is about to be splatted */
21038 /* Try it in situ */
21041 {
21044 }
21049 {
21050 /* Remember the length of the new string. */
21054 {
21055 /* If there's not enough space in the currently allocated string,
21056 * then copy it to a buffer big enough.
21057 */
21061 }
21062 else
21063 {
21064 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21069 }
21070 /* Concat the next bit */
21073 }
21077 }
21079 /*
21080 * Get a pathname for a partial path.
21081 */
21082 static int
21087 {
21093 /* Count up the path seperators from the RHS.. so we know which part
21094 * of the path to return.
21095 */
21101 /* Need full path first (use expand_env() to remove a "~/") */
21105 else
21114 {
21115 /* Don't have a valid filename, so shorten the rest of the
21116 * path if we can. This CAN give us invalid 8.3 filenames, but
21117 * there's not a lot of point in guessing what it might be.
21118 */
21122 }
21124 /* Count the paths backward to find the beginning of the desired string. */
21126 {
21127 #ifdef FEAT_MBYTE
21130 #endif
21132 {
21135 else
21136 sepcount --;
21137 }
21138 }
21140 {
21144 else
21146 }
21147 else
21150 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21157 }
21160 /*
21161 * Adjust a filename, according to a string of modifiers.
21162 * *fnamep must be NUL terminated when called. When returning, the length is
21163 * determined by *fnamelen.
21164 * Returns valid flags.
21165 * When there is an error, *fnamep is set to NULL.
21166 */
21167 int
21174 {
21181 #ifdef WIN3264
21183 #endif
21185 repeat:
21186 /* ":p" - full path/file_name */
21188 {
21194 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21196 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21198 # ifdef BACKSLASH_IN_FILENAME
21200 # endif
21203 #endif
21204 )
21205 {
21211 }
21213 /* When "/." or "/.." is used: force expansion to get rid of it. */
21215 {
21223 }
21225 /* FullName_save() is slow, don't use it when not needed. */
21227 {
21233 }
21235 /* Append a path separator to a directory. */
21237 {
21238 /* Make room for one or two extra characters. */
21245 }
21246 }
21248 /* ":." - path relative to the current directory */
21249 /* ":~" - path relative to the home directory */
21250 /* ":8" - shortname path - postponed till after */
21253 {
21256 {
21257 #ifdef WIN3264
21259 #endif
21261 }
21263 /* Need full path first (use expand_env() to remove a "~/") */
21265 {
21268 else
21270 }
21271 else
21277 {
21279 {
21283 {
21286 {
21290 }
21291 }
21292 }
21293 else
21294 {
21296 /* Only replace it when it starts with '~' */
21298 {
21301 {
21305 }
21306 }
21307 }
21309 }
21310 }
21315 /* ":h" - head, remove "/file_name", can be repeated */
21316 /* Don't remove the first "/" or "c:\" */
21318 {
21325 #ifdef VMS
21328 #endif
21330 {
21331 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21338 }
21339 else
21340 {
21343 }
21344 }
21346 /* ":8" - shortname */
21348 {
21350 #ifdef WIN3264
21352 #endif
21353 }
21355 #ifdef WIN3264
21356 /* Check shortname after we have done 'heads' and before we do 'tails'
21357 */
21359 {
21361 /* Copy the string if it is shortened by :h */
21363 {
21369 }
21371 /* Split into two implementations - makes it easier. First is where
21372 * there isn't a full name already, second is where there is.
21373 */
21375 {
21378 }
21379 else
21380 {
21383 /* Simple case, already have the full-name
21384 * Nearly always shorter, so try first time. */
21390 {
21391 /* Couldn't find the filename.. search the paths.
21392 */
21396 }
21398 }
21399 }
21402 /* ":t" - tail, just the basename */
21404 {
21408 }
21410 /* ":e" - extension, can be repeated */
21411 /* ":r" - root, without extension, can be repeated */
21414 {
21415 /* find a '.' in the tail:
21416 * - for second :e: before the current fname
21417 * - otherwise: The last '.'
21418 */
21421 else
21427 {
21429 {
21432 #ifdef VMS
21433 /* cut version from the extension */
21440 #endif
21441 }
21444 }
21446 {
21449 }
21451 }
21453 /* ":s?pat?foo?" - substitute */
21454 /* ":gs?pat?foo?" - global substitute */
21458 {
21469 {
21472 }
21476 {
21477 /* find end of pattern */
21480 {
21483 {
21485 /* find end of substitution */
21488 {
21492 {
21496 {
21502 }
21503 }
21506 }
21508 }
21509 }
21510 /* after using ":s", repeat all the modifiers */
21513 }
21514 }
21517 }
21519 /*
21520 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21521 * "flags" can be "g" to do a global substitute.
21522 * Returns an allocated string, NULL for error.
21523 */
21524 char_u *
21530 {
21532 regmatch_T regmatch;
21536 garray_T ga;
21540 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21551 {
21554 {
21555 /*
21556 * Get some space for a temporary buffer to do the substitution
21557 * into. It will contain:
21558 * - The text up to where the match is.
21559 * - The substituted text.
21560 * - The text after the match.
21561 */
21565 {
21568 }
21570 /* copy the text up to where the match is */
21573 /* add the substituted text */
21577 /* avoid getting stuck on a match with an empty string */
21579 {
21584 }
21585 else
21586 {
21590 }
21593 }
21599 }
21606 }