| blob | 11d700366a94b01b426828a0530b2efaf1d2ac6d |
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_FULLSCREEN
10870 #endif
10871 #ifdef FEAT_GETTEXT
10873 #endif
10874 #ifdef FEAT_GUI
10876 #endif
10877 #ifdef FEAT_GUI_ATHENA
10878 # ifdef FEAT_GUI_NEXTAW
10880 # else
10882 # endif
10883 #endif
10884 #ifdef FEAT_GUI_GTK
10886 # ifdef HAVE_GTK2
10888 # endif
10889 #endif
10890 #ifdef FEAT_GUI_GNOME
10892 #endif
10893 #ifdef FEAT_GUI_MAC
10895 #endif
10896 #ifdef FEAT_GUI_MACVIM
10898 #endif
10899 #ifdef FEAT_GUI_MOTIF
10901 #endif
10902 #ifdef FEAT_GUI_PHOTON
10904 #endif
10905 #ifdef FEAT_GUI_W16
10907 #endif
10908 #ifdef FEAT_GUI_W32
10910 #endif
10911 #ifdef FEAT_HANGULIN
10913 #endif
10914 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10916 #endif
10917 #ifdef FEAT_INS_EXPAND
10919 #endif
10920 #ifdef FEAT_JUMPLIST
10922 #endif
10923 #ifdef FEAT_KEYMAP
10925 #endif
10926 #ifdef FEAT_LANGMAP
10928 #endif
10929 #ifdef FEAT_LIBCALL
10931 #endif
10932 #ifdef FEAT_LINEBREAK
10934 #endif
10935 #ifdef FEAT_LISP
10937 #endif
10938 #ifdef FEAT_LISTCMDS
10940 #endif
10941 #ifdef FEAT_LOCALMAP
10943 #endif
10944 #ifdef FEAT_MENU
10946 #endif
10947 #ifdef FEAT_SESSION
10949 #endif
10950 #ifdef FEAT_MODIFY_FNAME
10952 #endif
10953 #ifdef FEAT_MOUSE
10955 #endif
10956 #ifdef FEAT_MOUSESHAPE
10958 #endif
10959 #if defined(UNIX) || defined(VMS)
10960 # ifdef FEAT_MOUSE_DEC
10962 # endif
10963 # ifdef FEAT_MOUSE_GPM
10965 # endif
10966 # ifdef FEAT_MOUSE_JSB
10968 # endif
10969 # ifdef FEAT_MOUSE_NET
10971 # endif
10972 # ifdef FEAT_MOUSE_PTERM
10974 # endif
10975 # ifdef FEAT_MOUSE_XTERM
10977 # endif
10978 #endif
10979 #ifdef FEAT_MBYTE
10981 #endif
10982 #ifdef FEAT_MBYTE_IME
10984 #endif
10985 #ifdef FEAT_MULTI_LANG
10987 #endif
10988 #ifdef FEAT_MZSCHEME
10989 #ifndef DYNAMIC_MZSCHEME
10991 #endif
10992 #endif
10993 #ifdef FEAT_OLE
10995 #endif
10996 #ifdef FEAT_OSFILETYPE
10998 #endif
10999 #ifdef FEAT_PATH_EXTRA
11001 #endif
11002 #ifdef FEAT_PERL
11003 #ifndef DYNAMIC_PERL
11005 #endif
11006 #endif
11007 #ifdef FEAT_PYTHON
11008 #ifndef DYNAMIC_PYTHON
11010 #endif
11011 #endif
11012 #ifdef FEAT_POSTSCRIPT
11014 #endif
11015 #ifdef FEAT_PRINTER
11017 #endif
11018 #ifdef FEAT_PROFILE
11020 #endif
11021 #ifdef FEAT_RELTIME
11023 #endif
11024 #ifdef FEAT_QUICKFIX
11026 #endif
11027 #ifdef FEAT_RIGHTLEFT
11029 #endif
11030 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11032 #endif
11033 #ifdef FEAT_SCROLLBIND
11035 #endif
11036 #ifdef FEAT_CMDL_INFO
11039 #endif
11040 #ifdef FEAT_SIGNS
11042 #endif
11043 #ifdef FEAT_SMARTINDENT
11045 #endif
11046 #ifdef FEAT_SNIFF
11048 #endif
11049 #ifdef FEAT_STL_OPT
11051 #endif
11052 #ifdef FEAT_SUN_WORKSHOP
11054 #endif
11055 #ifdef FEAT_NETBEANS_INTG
11057 #endif
11058 #ifdef FEAT_ODB_EDITOR
11060 #endif
11061 #ifdef FEAT_SPELL
11063 #endif
11064 #ifdef FEAT_SYN_HL
11066 #endif
11067 #if defined(USE_SYSTEM) || !defined(UNIX)
11069 #endif
11070 #ifdef FEAT_TAG_BINS
11072 #endif
11073 #ifdef FEAT_TAG_OLDSTATIC
11075 #endif
11076 #ifdef FEAT_TAG_ANYWHITE
11078 #endif
11079 #ifdef FEAT_TCL
11080 # ifndef DYNAMIC_TCL
11082 # endif
11083 #endif
11084 #ifdef TERMINFO
11086 #endif
11087 #ifdef FEAT_TERMRESPONSE
11089 #endif
11090 #ifdef FEAT_TEXTOBJ
11092 #endif
11093 #ifdef HAVE_TGETENT
11095 #endif
11096 #ifdef FEAT_TITLE
11098 #endif
11099 #ifdef FEAT_TOOLBAR
11101 #endif
11102 #ifdef FEAT_TRANSPARENCY
11104 #endif
11105 #ifdef FEAT_USR_CMDS
11108 #endif
11109 #ifdef FEAT_VIMINFO
11111 #endif
11112 #ifdef FEAT_VERTSPLIT
11114 #endif
11115 #ifdef FEAT_VIRTUALEDIT
11117 #endif
11118 #ifdef FEAT_VISUAL
11120 #endif
11121 #ifdef FEAT_VISUALEXTRA
11123 #endif
11124 #ifdef FEAT_VREPLACE
11126 #endif
11127 #ifdef FEAT_WILDIGN
11129 #endif
11130 #ifdef FEAT_WILDMENU
11132 #endif
11133 #ifdef FEAT_WINDOWS
11135 #endif
11136 #ifdef FEAT_WAK
11138 #endif
11139 #ifdef FEAT_WRITEBACKUP
11141 #endif
11142 #ifdef FEAT_XIM
11144 #endif
11145 #ifdef FEAT_XFONTSET
11147 #endif
11148 #ifdef USE_XSMP
11150 #endif
11151 #ifdef USE_XSMP_INTERACT
11153 #endif
11154 #ifdef FEAT_XCLIPBOARD
11156 #endif
11157 #ifdef FEAT_XTERM_SAVE
11159 #endif
11160 #if defined(UNIX) && defined(FEAT_X11)
11162 #endif
11163 NULL
11164 };
11169 {
11172 }
11175 {
11180 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11183 #endif
11184 #ifdef DYNAMIC_TCL
11187 #endif
11188 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11191 #endif
11192 #ifdef DYNAMIC_MZSCHEME
11195 #endif
11196 #ifdef DYNAMIC_RUBY
11199 #endif
11200 #ifdef DYNAMIC_PYTHON
11203 #endif
11204 #ifdef DYNAMIC_PERL
11207 #endif
11208 #ifdef FEAT_GUI
11211 # ifdef FEAT_GUI_W32
11214 # endif
11215 # ifdef FEAT_BROWSE
11218 # endif
11219 #endif
11220 #ifdef FEAT_SYN_HL
11223 #endif
11224 #if defined(WIN3264)
11227 #endif
11228 #ifdef FEAT_NETBEANS_INTG
11231 #endif
11232 }
11235 }
11237 /*
11238 * "has_key()" function
11239 */
11240 static void
11244 {
11247 {
11250 }
11256 }
11258 /*
11259 * "haslocaldir()" function
11260 */
11261 /*ARGSUSED*/
11262 static void
11266 {
11268 }
11270 /*
11271 * "hasmapto()" function
11272 */
11273 static void
11277 {
11286 else
11287 {
11291 }
11295 else
11297 }
11299 /*
11300 * "histadd()" function
11301 */
11302 /*ARGSUSED*/
11303 static void
11307 {
11308 #ifdef FEAT_CMDHIST
11312 #endif
11317 #ifdef FEAT_CMDHIST
11321 {
11324 {
11328 }
11329 }
11330 #endif
11331 }
11333 /*
11334 * "histdel()" function
11335 */
11336 /*ARGSUSED*/
11337 static void
11341 {
11342 #ifdef FEAT_CMDHIST
11351 /* only one argument: clear entire history */
11354 /* index given: remove that entry */
11357 else
11358 /* string given: remove all matching entries */
11362 #else
11364 #endif
11365 }
11367 /*
11368 * "histget()" function
11369 */
11370 /*ARGSUSED*/
11371 static void
11375 {
11376 #ifdef FEAT_CMDHIST
11384 else
11385 {
11389 else
11391 /* -1 on type error */
11393 }
11394 #else
11396 #endif
11398 }
11400 /*
11401 * "histnr()" function
11402 */
11403 /*ARGSUSED*/
11404 static void
11408 {
11411 #ifdef FEAT_CMDHIST
11417 else
11418 #endif
11421 }
11423 /*
11424 * "highlightID(name)" function
11425 */
11426 static void
11430 {
11432 }
11434 /*
11435 * "highlight_exists()" function
11436 */
11437 static void
11441 {
11443 }
11445 /*
11446 * "hostname()" function
11447 */
11448 /*ARGSUSED*/
11449 static void
11453 {
11459 }
11461 /*
11462 * iconv() function
11463 */
11464 /*ARGSUSED*/
11465 static void
11469 {
11470 #ifdef FEAT_MBYTE
11474 vimconv_T vimconv;
11475 #endif
11480 #ifdef FEAT_MBYTE
11487 /* If the encodings are equal, no conversion needed. */
11490 else
11496 #endif
11497 }
11499 /*
11500 * "indent()" function
11501 */
11502 static void
11506 {
11507 linenr_T lnum;
11512 else
11514 }
11516 /*
11517 * "index()" function
11518 */
11519 static void
11523 {
11531 {
11534 }
11537 {
11540 {
11543 /* Start at specified item. Use the cached index that list_find()
11544 * sets, so that a negative number also works. */
11551 }
11555 {
11558 }
11559 }
11560 }
11566 /*
11567 * This function is used by f_input() and f_inputdialog() functions. The third
11568 * argument to f_input() specifies the type of completion to use at the
11569 * prompt. The third argument to f_inputdialog() specifies the value to return
11570 * when the user cancels the prompt.
11571 */
11572 static void
11577 {
11590 #ifdef NO_CONSOLE_INPUT
11591 /* While starting up, there is no place to enter text. */
11594 #endif
11598 {
11599 /* Only the part of the message after the last NL is considered as
11600 * prompt for the command line */
11604 else
11605 {
11615 }
11619 {
11625 {
11641 }
11642 }
11651 /* since the user typed this, no need to wait for return */
11654 }
11656 }
11658 /*
11659 * "input()" function
11660 * Also handles inputsecret() when inputsecret is set.
11661 */
11662 static void
11666 {
11668 }
11670 /*
11671 * "inputdialog()" function
11672 */
11673 static void
11677 {
11678 #if defined(FEAT_GUI_TEXTDIALOG)
11679 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11681 {
11690 else
11696 else
11697 {
11703 else
11705 }
11707 }
11708 else
11709 #endif
11711 }
11713 /*
11714 * "inputlist()" function
11715 */
11716 static void
11720 {
11726 #ifdef NO_CONSOLE_INPUT
11727 /* While starting up, there is no place to enter text. */
11730 #endif
11732 {
11735 }
11744 {
11747 }
11749 /* Ask for choice. */
11755 }
11760 /*
11761 * "inputrestore()" function
11762 */
11763 /*ARGSUSED*/
11764 static void
11768 {
11770 {
11775 }
11777 {
11780 }
11781 }
11783 /*
11784 * "inputsave()" function
11785 */
11786 /*ARGSUSED*/
11787 static void
11791 {
11792 /* Add an entry to the stack of typehead storage. */
11794 {
11799 }
11800 else
11802 }
11804 /*
11805 * "inputsecret()" function
11806 */
11807 static void
11811 {
11817 }
11819 /*
11820 * "insert()" function
11821 */
11822 static void
11826 {
11837 {
11845 else
11846 {
11849 {
11852 }
11853 }
11855 {
11858 }
11859 }
11860 }
11862 /*
11863 * "isdirectory()" function
11864 */
11865 static void
11869 {
11871 }
11873 /*
11874 * "islocked()" function
11875 */
11876 static void
11880 {
11881 lval_T lv;
11887 FNE_CHECK_START);
11889 {
11892 else
11893 {
11895 {
11898 else
11899 {
11902 {
11903 /* Consider a variable locked when:
11904 * 1. the variable itself is locked
11905 * 2. the value of the variable is locked.
11906 * 3. the List or Dict value is locked.
11907 */
11910 }
11911 }
11912 }
11918 /* List item. */
11920 else
11921 /* Dictionary item. */
11923 }
11924 }
11927 }
11931 /*
11932 * Turn a dict into a list:
11933 * "what" == 0: list of keys
11934 * "what" == 1: list of values
11935 * "what" == 2: list of items
11936 */
11937 static void
11942 {
11953 {
11956 }
11965 {
11967 {
11977 {
11978 /* keys() */
11982 }
11984 {
11985 /* values() */
11987 }
11988 else
11989 {
11990 /* items() */
12012 }
12013 }
12014 }
12015 }
12017 /*
12018 * "items(dict)" function
12019 */
12020 static void
12024 {
12026 }
12028 /*
12029 * "join()" function
12030 */
12031 static void
12035 {
12036 garray_T ga;
12041 {
12044 }
12049 else
12055 {
12060 }
12061 else
12063 }
12065 /*
12066 * "keys()" function
12067 */
12068 static void
12072 {
12074 }
12076 /*
12077 * "last_buffer_nr()" function.
12078 */
12079 /*ARGSUSED*/
12080 static void
12084 {
12093 }
12095 /*
12096 * "len()" function
12097 */
12098 static void
12102 {
12104 {
12119 }
12120 }
12124 static void
12129 {
12130 #ifdef FEAT_LIBCALL
12134 #endif
12139 else
12145 #ifdef FEAT_LIBCALL
12146 /* The first two args must be strings, otherwise its meaningless */
12148 {
12154 else
12158 string_in,
12160 string_result,
12164 }
12165 #endif
12166 }
12168 /*
12169 * "libcall()" function
12170 */
12171 static void
12175 {
12177 }
12179 /*
12180 * "libcallnr()" function
12181 */
12182 static void
12186 {
12188 }
12190 /*
12191 * "line(string)" function
12192 */
12193 static void
12197 {
12206 }
12208 /*
12209 * "line2byte(lnum)" function
12210 */
12211 /*ARGSUSED*/
12212 static void
12216 {
12217 #ifndef FEAT_BYTEOFF
12219 #else
12220 linenr_T lnum;
12225 else
12229 #endif
12230 }
12232 /*
12233 * "lispindent(lnum)" function
12234 */
12235 static void
12239 {
12240 #ifdef FEAT_LISP
12241 pos_T pos;
12242 linenr_T lnum;
12247 {
12251 }
12252 else
12253 #endif
12255 }
12257 /*
12258 * "localtime()" function
12259 */
12260 /*ARGSUSED*/
12261 static void
12265 {
12267 }
12271 static void
12276 {
12283 garray_T ga;
12286 /* return empty string for failure */
12295 {
12299 }
12300 else
12311 {
12321 }
12322 }
12324 /*
12325 * "map()" function
12326 */
12327 static void
12331 {
12333 }
12335 /*
12336 * "maparg()" function
12337 */
12338 static void
12342 {
12344 }
12346 /*
12347 * "mapcheck()" function
12348 */
12349 static void
12353 {
12355 }
12359 static void
12364 {
12368 regmatch_T regmatch;
12381 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12387 {
12388 /* return empty list when there are no matches */
12391 }
12393 {
12396 }
12399 {
12403 }
12404 else
12412 {
12419 {
12424 }
12425 else
12426 {
12431 /* When "count" argument is there ignore matches before "start",
12432 * otherwise skip part of the string. Differs when pattern is "^"
12433 * or "\<". */
12436 else
12438 }
12444 }
12448 {
12452 {
12454 {
12456 {
12459 }
12464 }
12473 /* Advance to just after the match. */
12475 {
12478 }
12479 else
12480 {
12481 #ifdef FEAT_MBYTE
12484 #else
12486 #endif
12487 }
12488 }
12491 {
12493 {
12496 /* return list with matched string and submatches */
12498 {
12500 {
12504 }
12510 }
12511 }
12513 {
12514 /* return matched string */
12517 else
12520 }
12523 else
12524 {
12528 else
12532 }
12533 }
12535 }
12537 theend:
12540 }
12542 /*
12543 * "match()" function
12544 */
12545 static void
12549 {
12551 }
12553 /*
12554 * "matchadd()" function
12555 */
12556 static void
12560 {
12561 #ifdef FEAT_SEARCH_EXTRA
12574 {
12578 }
12582 {
12585 }
12588 #endif
12589 }
12591 /*
12592 * "matcharg()" function
12593 */
12594 static void
12598 {
12600 {
12601 #ifdef FEAT_SEARCH_EXTRA
12606 {
12608 {
12612 }
12613 else
12614 {
12617 }
12618 }
12619 #endif
12620 }
12621 }
12623 /*
12624 * "matchdelete()" function
12625 */
12626 static void
12630 {
12631 #ifdef FEAT_SEARCH_EXTRA
12634 #endif
12635 }
12637 /*
12638 * "matchend()" function
12639 */
12640 static void
12644 {
12646 }
12648 /*
12649 * "matchlist()" function
12650 */
12651 static void
12655 {
12657 }
12659 /*
12660 * "matchstr()" function
12661 */
12662 static void
12666 {
12668 }
12672 static void
12677 {
12683 {
12689 {
12692 {
12695 {
12702 }
12703 }
12704 }
12705 }
12707 {
12715 {
12718 {
12720 {
12724 {
12727 }
12730 }
12731 }
12732 }
12733 }
12734 else
12737 }
12739 /*
12740 * "max()" function
12741 */
12742 static void
12746 {
12748 }
12750 /*
12751 * "min()" function
12752 */
12753 static void
12757 {
12759 }
12763 /*
12764 * Create the directory in which "dir" is located, and higher levels when
12765 * needed.
12766 */
12767 static int
12771 {
12776 /* Get end of directory name in "dir".
12777 * We're done when it's "/" or "c:/". */
12782 /* If the directory exists we're done. Otherwise: create it.*/
12792 }
12794 #ifdef vim_mkdir
12795 /*
12796 * "mkdir()" function
12797 */
12798 static void
12802 {
12813 {
12818 }
12820 }
12821 #endif
12823 /*
12824 * "mode()" function
12825 */
12826 /*ARGSUSED*/
12827 static void
12831 {
12834 #ifdef FEAT_VISUAL
12836 {
12839 else
12841 }
12842 else
12843 #endif
12847 {
12850 else
12852 }
12855 else
12861 }
12863 /*
12864 * "nextnonblank()" function
12865 */
12866 static void
12870 {
12871 linenr_T lnum;
12874 {
12876 {
12879 }
12882 }
12884 }
12886 /*
12887 * "nr2char()" function
12888 */
12889 static void
12893 {
12896 #ifdef FEAT_MBYTE
12899 else
12900 #endif
12901 {
12904 }
12907 }
12909 /*
12910 * "pathshorten()" function
12911 */
12912 static void
12916 {
12923 else
12924 {
12929 }
12930 }
12932 /*
12933 * "prevnonblank()" function
12934 */
12935 static void
12939 {
12940 linenr_T lnum;
12945 else
12949 }
12951 #ifdef HAVE_STDARG_H
12952 /* This dummy va_list is here because:
12953 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12954 * - locally in the function results in a "used before set" warning
12955 * - using va_start() to initialize it gives "function with fixed args" error */
12957 #endif
12959 /*
12960 * "printf()" function
12961 */
12962 static void
12966 {
12970 {
12977 /* Get the required length, allocate the buffer and do it for real. */
12982 {
12985 {
12988 }
12989 }
12991 }
12992 #endif
12993 }
12995 /*
12996 * "pumvisible()" function
12997 */
12998 /*ARGSUSED*/
12999 static void
13003 {
13005 #ifdef FEAT_INS_EXPAND
13008 #endif
13009 }
13011 /*
13012 * "range()" function
13013 */
13014 static void
13018 {
13027 {
13030 }
13031 else
13032 {
13036 }
13045 else
13046 {
13052 }
13053 }
13055 /*
13056 * "readfile()" function
13057 */
13058 static void
13062 {
13082 {
13087 }
13092 /* Always open the file in binary mode, library functions have a mind of
13093 * their own about CR-LF conversion. */
13096 {
13099 }
13103 {
13108 {
13110 {
13111 /* Only when in binary mode add an empty list item when the
13112 * last line ends in a '\n'. */
13116 /* Found end-of-line or end-of-file: add a text line to the
13117 * list. */
13126 else
13127 {
13130 {
13136 }
13137 }
13142 {
13145 }
13155 }
13158 }
13163 {
13164 /* "buf" is full, need to move text to an allocated buffer */
13166 {
13169 }
13170 else
13171 {
13174 {
13180 }
13181 }
13183 }
13184 else
13185 {
13188 }
13189 }
13191 /*
13192 * For a negative line count use only the lines at the end of the file,
13193 * free the rest.
13194 */
13197 {
13200 }
13204 }
13206 #if defined(FEAT_RELTIME)
13209 /*
13210 * Convert a List to proftime_T.
13211 * Return FAIL when there is something wrong.
13212 */
13213 static int
13217 {
13226 # ifdef WIN3264
13229 # else
13232 # endif
13234 }
13237 /*
13238 * "reltime()" function
13239 */
13240 static void
13244 {
13245 #ifdef FEAT_RELTIME
13246 proftime_T res;
13247 proftime_T start;
13250 {
13251 /* No arguments: get current time. */
13253 }
13255 {
13259 }
13260 else
13261 {
13262 /* Two arguments: compute the difference. */
13267 }
13270 {
13273 # ifdef WIN3264
13276 # else
13279 # endif
13282 }
13283 #endif
13284 }
13286 /*
13287 * "reltimestr()" function
13288 */
13289 static void
13293 {
13294 #ifdef FEAT_RELTIME
13295 proftime_T tm;
13296 #endif
13300 #ifdef FEAT_RELTIME
13303 #endif
13304 }
13306 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13310 static void
13312 {
13314 # ifdef FEAT_GUI
13316 # endif
13317 )
13318 {
13322 }
13323 }
13325 static int
13327 {
13330 {
13333 }
13335 }
13336 #endif
13338 #ifdef FEAT_CLIENTSERVER
13341 static void
13346 {
13351 # ifdef WIN32
13352 HWND w;
13353 # elif defined(FEAT_X11)
13354 Window w;
13355 # elif defined(MAC_CLIENTSERVER)
13357 # endif
13362 # ifdef FEAT_X11
13365 # endif
13371 # ifdef WIN32
13373 # elif defined(FEAT_X11)
13376 # elif defined(MAC_CLIENTSERVER)
13378 # endif
13379 {
13382 else
13385 }
13390 {
13391 dictitem_T v;
13402 }
13403 }
13404 #endif
13406 /*
13407 * "remote_expr()" function
13408 */
13409 /*ARGSUSED*/
13410 static void
13414 {
13417 #ifdef FEAT_CLIENTSERVER
13419 #endif
13420 }
13422 /*
13423 * "remote_foreground()" function
13424 */
13425 /*ARGSUSED*/
13426 static void
13430 {
13432 #ifdef FEAT_CLIENTSERVER
13433 # ifdef WIN32
13434 /* On Win32 it's done in this application. */
13435 {
13440 }
13441 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
13442 /* Send a foreground() expression to the server. */
13448 # endif
13449 #endif
13450 }
13452 /*ARGSUSED*/
13453 static void
13457 {
13458 #ifdef FEAT_CLIENTSERVER
13459 dictitem_T v;
13461 # ifdef WIN32
13463 # endif
13467 {
13470 }
13473 {
13476 }
13477 # ifdef WIN32
13481 else
13482 {
13485 }
13486 # elif defined(FEAT_X11)
13493 # elif defined(MAC_CLIENTSERVER)
13495 # endif
13498 {
13507 }
13508 #else
13510 #endif
13511 }
13513 /*ARGSUSED*/
13514 static void
13518 {
13521 #ifdef FEAT_CLIENTSERVER
13525 {
13526 # ifdef WIN32
13527 /* The server's HWND is encoded in the 'id' parameter */
13534 # elif defined(FEAT_X11)
13537 # elif defined(MAC_CLIENTSERVER)
13539 # endif
13541 }
13542 #endif
13545 }
13547 /*
13548 * "remote_send()" function
13549 */
13550 /*ARGSUSED*/
13551 static void
13555 {
13558 #ifdef FEAT_CLIENTSERVER
13560 #endif
13561 }
13563 /*
13564 * "remove()" function
13565 */
13566 static void
13570 {
13582 {
13587 {
13590 {
13594 else
13595 {
13599 }
13600 }
13601 }
13602 }
13607 {
13615 else
13616 {
13618 {
13619 /* Remove one item, return its value. */
13623 }
13624 else
13625 {
13626 /* Remove range of items, return list with values. */
13632 else
13633 {
13637 {
13641 }
13644 else
13645 {
13648 {
13655 }
13656 }
13657 }
13658 }
13659 }
13660 }
13661 }
13663 /*
13664 * "rename({from}, {to})" function
13665 */
13666 static void
13670 {
13675 else
13678 }
13680 /*
13681 * "repeat()" function
13682 */
13683 /*ARGSUSED*/
13684 static void
13688 {
13698 {
13704 }
13705 else
13706 {
13718 {
13722 }
13725 }
13726 }
13728 /*
13729 * "resolve()" function
13730 */
13731 static void
13735 {
13739 #ifdef FEAT_SHORTCUT
13740 {
13746 else
13748 }
13749 #else
13750 # ifdef HAVE_READLINK
13751 {
13773 {
13774 /* Separate the first path component in "p", and keep the
13775 * remainder (beginning with the path separator). */
13778 }
13781 {
13783 {
13790 {
13796 }
13798 /* Ensure that the result will have a trailing path separator
13799 * if the argument has one. */
13803 /* Separate the first path component in the link value and
13804 * concatenate the remainders. */
13807 {
13810 else
13811 {
13814 {
13817 }
13818 }
13820 }
13824 {
13825 /* Ignore trailing path separator. */
13828 }
13830 {
13831 /* symlink is relative to directory of argument */
13834 {
13839 }
13840 }
13841 else
13842 {
13845 }
13846 }
13851 /* Append the first path component of "remain" to "p". */
13856 {
13860 }
13861 /* Shorten "remain". */
13864 else
13865 {
13868 }
13869 }
13871 /* If the result is a relative path name, make it explicitly relative to
13872 * the current directory if and only if the argument had this form. */
13874 {
13883 {
13884 /* Prepend "./". */
13887 {
13890 }
13891 }
13893 {
13894 /* Strip leading "./". */
13900 }
13901 }
13903 /* Ensure that the result will have no trailing path separator
13904 * if the argument had none. But keep "/" or "//". */
13906 {
13910 }
13913 }
13914 # else
13916 # endif
13917 #endif
13921 #ifdef HAVE_READLINK
13922 fail:
13923 #endif
13925 }
13927 /*
13928 * "reverse({list})" function
13929 */
13930 static void
13934 {
13943 {
13948 {
13952 }
13956 }
13957 }
13969 /*
13970 * Get flags for a search function.
13971 * Possibly sets "p_ws".
13972 * Returns BACKWARD, FORWARD or zero (for an error).
13973 */
13974 static int
13978 {
13985 {
13990 {
13992 {
13999 {
14007 }
14009 {
14012 }
14013 else
14015 }
14019 }
14020 }
14022 }
14024 /*
14025 * Shared by search() and searchpos() functions
14026 */
14027 static int
14032 {
14035 pos_T pos;
14036 pos_T save_cursor;
14054 /* Optional extra argument: line number to stop searching. */
14057 {
14061 }
14063 /*
14064 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14065 * Check to make sure only those flags are set.
14066 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14067 * flags cannot be set. Check for that condition also.
14068 */
14071 {
14074 }
14080 {
14083 else
14089 {
14090 /* Store the match cursor position */
14093 }
14094 /* "/$" will put the cursor after the end of the line, may need to
14095 * correct that here */
14097 }
14099 /* If 'n' flag is used: restore cursor position. */
14102 else
14104 theend:
14108 }
14110 /*
14111 * "search()" function
14112 */
14113 static void
14117 {
14121 }
14123 /*
14124 * "searchdecl()" function
14125 */
14126 static void
14130 {
14140 {
14144 }
14148 }
14150 /*
14151 * Used by searchpair() and searchpairpos()
14152 */
14153 static int
14157 {
14169 /* Get the three pattern arguments: start, middle, end. */
14176 /* Handle the optional fourth argument: flags */
14181 /* Don't accept SP_END or SP_SUBPAT.
14182 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14183 */
14186 {
14189 }
14191 /* Optional fifth argument: skip expression */
14195 else
14196 {
14199 {
14203 }
14204 }
14211 theend:
14215 }
14217 /*
14218 * "searchpair()" function
14219 */
14220 static void
14224 {
14226 }
14228 /*
14229 * "searchpairpos()" function
14230 */
14231 static void
14235 {
14236 pos_T match_pos;
14246 {
14249 }
14253 }
14255 /*
14256 * Search for a start/middle/end thing.
14257 * Used by searchpair(), see its documentation for the details.
14258 * Returns 0 or -1 for no match,
14259 */
14260 long
14270 {
14274 pos_T pos;
14275 pos_T firstpos;
14276 pos_T foundpos;
14277 pos_T save_cursor;
14278 pos_T save_pos;
14285 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14289 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14290 * start/middle/end (pat3, for the top pair). */
14298 else
14310 {
14314 /* didn't find it or found the first match again: FAIL */
14320 {
14321 /* Found the same position again. Can happen with a pattern that
14322 * has "\zs" at the end and searching backwards. Advance one
14323 * character and try again. */
14326 else
14328 }
14331 /* If the skip pattern matches, ignore this match. */
14333 {
14339 {
14340 /* Evaluating {skip} caused an error, break here. */
14344 }
14347 }
14350 {
14351 /* Found end when searching backwards or start when searching
14352 * forward: nested pair. */
14355 }
14356 else
14357 {
14358 /* Found end when searching forward or start when searching
14359 * backward: end of (nested) pair; or found middle in outer pair. */
14362 }
14365 {
14366 /* Found the match: return matchcount or line number. */
14369 else
14377 }
14378 }
14381 {
14382 /* Store the match cursor position */
14385 }
14387 /* If 'n' flag is used or search failed: restore cursor position. */
14391 theend:
14397 }
14399 /*
14400 * "searchpos()" function
14401 */
14402 static void
14406 {
14407 pos_T match_pos;
14420 {
14423 }
14429 }
14432 /*ARGSUSED*/
14433 static void
14437 {
14438 #ifdef FEAT_CLIENTSERVER
14448 # ifdef FEAT_X11
14451 # endif
14454 {
14457 }
14459 #else
14461 #endif
14462 }
14464 /*ARGSUSED*/
14465 static void
14469 {
14472 #ifdef FEAT_CLIENTSERVER
14473 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
14475 # elif defined(FEAT_X11)
14479 # endif
14480 #endif
14483 }
14485 /*
14486 * "setbufvar()" function
14487 */
14488 /*ARGSUSED*/
14489 static void
14493 {
14495 aco_save_T aco;
14510 {
14511 /* set curbuf to be our buf, temporarily */
14515 {
14525 }
14526 else
14527 {
14530 {
14535 }
14536 }
14538 /* reset notion of buffer */
14540 }
14541 }
14543 /*
14544 * "setcmdpos()" function
14545 */
14546 static void
14550 {
14555 }
14557 /*
14558 * "setline()" function
14559 */
14560 static void
14564 {
14565 linenr_T lnum;
14574 {
14577 }
14578 else
14583 {
14585 {
14586 /* list argument, get next string */
14591 }
14597 {
14598 /* existing line, replace it */
14600 {
14605 }
14606 }
14608 {
14609 /* lnum is one past the last line, append the line */
14613 }
14618 }
14622 }
14624 /*
14625 * Used by "setqflist()" and "setloclist()" functions
14626 */
14627 /*ARGSUSED*/
14628 static void
14634 {
14635 #ifdef FEAT_QUICKFIX
14638 #endif
14642 #ifdef FEAT_QUICKFIX
14645 else
14646 {
14650 {
14656 }
14660 }
14661 #endif
14662 }
14664 /*
14665 * "setloclist()" function
14666 */
14667 /*ARGSUSED*/
14668 static void
14672 {
14680 }
14682 /*
14683 * "setmatches()" function
14684 */
14685 static void
14689 {
14690 #ifdef FEAT_SEARCH_EXTRA
14697 {
14700 }
14702 {
14704 /* To some extent make sure that we are dealing with a list from
14705 * "getmatches()". */
14708 {
14711 {
14714 }
14719 {
14722 }
14724 }
14729 {
14736 }
14738 }
14739 #endif
14740 }
14742 /*
14743 * "setpos()" function
14744 */
14745 /*ARGSUSED*/
14746 static void
14750 {
14751 pos_T pos;
14757 {
14759 {
14762 {
14764 {
14767 }
14768 else
14770 }
14773 else
14775 }
14776 }
14777 }
14779 /*
14780 * "setqflist()" function
14781 */
14782 /*ARGSUSED*/
14783 static void
14787 {
14789 }
14791 /*
14792 * "setreg()" function
14793 */
14794 static void
14798 {
14804 char_u yank_type;
14823 {
14829 {
14839 #ifdef FEAT_VISUAL
14843 {
14847 }
14849 #endif
14850 }
14851 }
14858 }
14860 /*
14861 * "settabwinvar()" function
14862 */
14863 static void
14867 {
14869 }
14871 /*
14872 * "setwinvar()" function
14873 */
14874 static void
14878 {
14880 }
14882 /*
14883 * "setwinvar()" and "settabwinvar()" functions
14884 */
14885 static void
14890 {
14892 #ifdef FEAT_WINDOWS
14895 #endif
14906 #ifdef FEAT_WINDOWS
14909 else
14911 #endif
14917 {
14918 #ifdef FEAT_WINDOWS
14919 /* set curwin to be our win, temporarily */
14927 #endif
14930 {
14940 }
14941 else
14942 {
14945 {
14950 }
14951 }
14953 #ifdef FEAT_WINDOWS
14954 /* Restore current tabpage and window, if still valid (autocomands can
14955 * make them invalid). */
14959 {
14962 }
14963 #endif
14964 }
14965 }
14967 /*
14968 * "shellescape({string})" function
14969 */
14970 static void
14974 {
14977 }
14979 /*
14980 * "simplify()" function
14981 */
14982 static void
14986 {
14993 }
14995 static int
14996 #ifdef __BORLANDC__
14997 _RTLENTRYF
14998 #endif
15000 static int
15001 #ifdef __BORLANDC__
15002 _RTLENTRYF
15003 #endif
15009 #define ITEM_COMPARE_FAIL 999
15011 /*
15012 * Compare functions for f_sort() below.
15013 */
15014 static int
15015 #ifdef __BORLANDC__
15016 _RTLENTRYF
15017 #endif
15021 {
15036 else
15041 }
15043 static int
15044 #ifdef __BORLANDC__
15045 _RTLENTRYF
15046 #endif
15050 {
15052 typval_T rettv;
15056 /* shortcut after failure in previous call; compare all items equal */
15060 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15061 * in the copy without changing the original list items. */
15073 else
15074 /* return value has wrong type */
15080 }
15082 /*
15083 * "sort({list})" function
15084 */
15085 static void
15089 {
15099 else
15100 {
15115 {
15118 else
15119 {
15127 else
15129 }
15130 }
15132 /* Make an array with each entry pointing to an item in the List. */
15141 /* test the compare function */
15146 else
15147 {
15148 /* Sort the array with item pointers. */
15153 {
15154 /* Clear the List and append the items in the sorted order. */
15159 }
15160 }
15163 }
15164 }
15166 /*
15167 * "soundfold({word})" function
15168 */
15169 static void
15173 {
15178 #ifdef FEAT_SPELL
15180 #else
15182 #endif
15183 }
15185 /*
15186 * "spellbadword()" function
15187 */
15188 /* ARGSUSED */
15189 static void
15193 {
15201 #ifdef FEAT_SPELL
15203 {
15204 /* Find the start and length of the badly spelled word. */
15208 }
15210 {
15215 {
15216 /* Check the argument for spelling. */
15218 {
15221 {
15224 }
15226 }
15227 }
15228 }
15229 #endif
15238 }
15240 /*
15241 * "spellsuggest()" function
15242 */
15243 /*ARGSUSED*/
15244 static void
15248 {
15249 #ifdef FEAT_SPELL
15253 garray_T ga;
15257 #endif
15262 #ifdef FEAT_SPELL
15264 {
15267 {
15272 {
15276 }
15277 }
15278 else
15284 {
15290 else
15291 {
15296 }
15297 }
15299 }
15300 #endif
15301 }
15303 static void
15307 {
15311 regmatch_T regmatch;
15319 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15325 {
15331 }
15342 {
15345 {
15348 else
15352 else
15356 {
15360 }
15363 /* Advance to just after the match. */
15366 else
15367 {
15368 /* Don't get stuck at the same match. */
15369 #ifdef FEAT_MBYTE
15371 #else
15373 #endif
15374 }
15376 }
15379 }
15382 }
15384 /*
15385 * "str2nr()" function
15386 */
15387 static void
15391 {
15397 {
15400 {
15403 }
15404 }
15409 }
15411 #ifdef HAVE_STRFTIME
15412 /*
15413 * "strftime({format}[, {time}])" function
15414 */
15415 static void
15419 {
15430 else
15433 /* MSVC returns NULL for an invalid value of seconds. */
15436 else
15437 {
15438 # ifdef FEAT_MBYTE
15439 vimconv_T conv;
15447 # endif
15451 else
15454 # ifdef FEAT_MBYTE
15460 else
15461 # endif
15464 # ifdef FEAT_MBYTE
15465 /* Release conversion descriptors */
15468 # endif
15469 }
15470 }
15471 #endif
15473 /*
15474 * "stridx()" function
15475 */
15476 static void
15480 {
15495 {
15503 }
15508 }
15510 /*
15511 * "string()" function
15512 */
15513 static void
15517 {
15523 /* Make a copy if we have a value but it's not in allocate memory. */
15526 }
15528 /*
15529 * "strlen()" function
15530 */
15531 static void
15535 {
15538 }
15540 /*
15541 * "strpart()" function
15542 */
15543 static void
15547 {
15562 else
15565 /*
15566 * Only return the overlap between the specified part and the actual
15567 * string.
15568 */
15570 {
15573 }
15583 }
15585 /*
15586 * "strridx()" function
15587 */
15588 static void
15592 {
15609 {
15610 /* Third argument: upper limit for index */
15614 }
15615 else
15619 {
15620 /* Empty string matches past the end. */
15622 }
15623 else
15624 {
15626 {
15631 }
15632 }
15636 else
15638 }
15640 /*
15641 * "strtrans()" function
15642 */
15643 static void
15647 {
15650 }
15652 /*
15653 * "submatch()" function
15654 */
15655 static void
15659 {
15663 }
15665 /*
15666 * "substitute()" function
15667 */
15668 static void
15672 {
15685 else
15687 }
15689 /*
15690 * "synID(lnum, col, trans)" function
15691 */
15692 /*ARGSUSED*/
15693 static void
15697 {
15699 #ifdef FEAT_SYN_HL
15712 #endif
15715 }
15717 /*
15718 * "synIDattr(id, what [, mode])" function
15719 */
15720 /*ARGSUSED*/
15721 static void
15725 {
15727 #ifdef FEAT_SYN_HL
15737 {
15741 #ifdef FEAT_GUI
15743 #endif
15744 )
15746 }
15747 else
15748 {
15749 #ifdef FEAT_GUI
15752 else
15753 #endif
15756 else
15758 }
15762 {
15795 /* underline */
15797 else
15798 /* undercurl */
15801 }
15805 #endif
15808 }
15810 /*
15811 * "synIDtrans(id)" function
15812 */
15813 /*ARGSUSED*/
15814 static void
15818 {
15821 #ifdef FEAT_SYN_HL
15826 else
15827 #endif
15831 }
15833 /*
15834 * "system()" function
15835 */
15836 static void
15840 {
15852 {
15853 /*
15854 * Write the string to a temp file, to be used for input of the shell
15855 * command.
15856 */
15858 {
15861 }
15865 {
15868 }
15871 {
15874 }
15880 {
15883 }
15884 }
15889 #ifdef USE_CR
15890 /* translate <CR> into <NL> */
15892 {
15896 {
15899 }
15900 }
15901 #else
15902 # ifdef USE_CRNL
15903 /* translate <CR><NL> into <NL> */
15905 {
15910 {
15914 }
15916 }
15917 # endif
15918 #endif
15920 done:
15922 {
15925 }
15928 }
15930 /*
15931 * "tabpagebuflist()" function
15932 */
15933 /* ARGSUSED */
15934 static void
15938 {
15939 #ifndef FEAT_WINDOWS
15941 #else
15947 else
15948 {
15952 }
15955 else
15956 {
15959 else
15960 {
15965 }
15966 }
15967 #endif
15968 }
15971 /*
15972 * "tabpagenr()" function
15973 */
15974 /* ARGSUSED */
15975 static void
15979 {
15981 #ifdef FEAT_WINDOWS
15985 {
15989 {
15992 else
15994 }
15995 }
15996 else
15998 #endif
16000 }
16003 #ifdef FEAT_WINDOWS
16006 /*
16007 * Common code for tabpagewinnr() and winnr().
16008 */
16009 static int
16013 {
16021 {
16028 {
16032 }
16033 else
16034 {
16037 }
16038 }
16043 {
16045 {
16046 /* didn't find it in this tabpage */
16049 }
16051 }
16053 }
16054 #endif
16056 /*
16057 * "tabpagewinnr()" function
16058 */
16059 /* ARGSUSED */
16060 static void
16064 {
16066 #ifdef FEAT_WINDOWS
16072 else
16074 #endif
16076 }
16079 /*
16080 * "tagfiles()" function
16081 */
16082 /*ARGSUSED*/
16083 static void
16087 {
16089 tagname_T tn;
16093 {
16096 }
16103 }
16105 /*
16106 * "taglist()" function
16107 */
16108 static void
16112 {
16123 }
16125 /*
16126 * "tempname()" function
16127 */
16128 /*ARGSUSED*/
16129 static void
16133 {
16139 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16140 * names. Skip 'I' and 'O', they are used for shell redirection. */
16141 do
16142 {
16147 else
16148 {
16149 #ifdef EBCDIC
16154 else
16155 #endif
16157 }
16159 }
16161 /*
16162 * "test(list)" function: Just checking the walls...
16163 */
16164 /*ARGSUSED*/
16165 static void
16169 {
16170 /* Used for unit testing. Change the code below to your liking. */
16171 #if 0
16190 #endif
16191 }
16193 /*
16194 * "tolower(string)" function
16195 */
16196 static void
16200 {
16209 {
16210 #ifdef FEAT_MBYTE
16214 {
16220 /* TODO: reallocate string when byte count changes. */
16224 }
16227 else
16228 #endif
16229 {
16232 }
16233 }
16234 }
16236 /*
16237 * "toupper(string)" function
16238 */
16239 static void
16243 {
16246 }
16248 /*
16249 * "tr(string, fromstr, tostr)" function
16250 */
16251 static void
16255 {
16260 #ifdef FEAT_MBYTE
16268 #endif
16271 garray_T ga;
16277 /* Default return value: empty string. */
16284 #ifdef FEAT_MBYTE
16286 #endif
16287 /* not multi-byte: fromstr and tostr must be the same length */
16289 {
16290 #ifdef FEAT_MBYTE
16291 error:
16292 #endif
16296 }
16298 /* fromstr and tostr have to contain the same number of chars */
16300 {
16301 #ifdef FEAT_MBYTE
16303 {
16309 {
16312 {
16314 {
16317 {
16321 }
16322 }
16326 }
16328 }
16331 {
16332 /* Check that fromstr and tostr have the same number of
16333 * (multi-byte) characters. Done only once when a character
16334 * of instr doesn't appear in fromstr. */
16337 {
16340 }
16343 }
16350 }
16351 else
16352 #endif
16353 {
16354 /* When not using multi-byte chars we can do it faster. */
16358 else
16361 }
16362 }
16364 /* add a terminating NUL */
16369 }
16371 /*
16372 * "type(expr)" function
16373 */
16374 static void
16378 {
16382 {
16389 }
16391 }
16393 /*
16394 * "values(dict)" function
16395 */
16396 static void
16400 {
16402 }
16404 /*
16405 * "virtcol(string)" function
16406 */
16407 static void
16411 {
16419 {
16422 }
16425 }
16427 /*
16428 * "visualmode()" function
16429 */
16430 /*ARGSUSED*/
16431 static void
16435 {
16436 #ifdef FEAT_VISUAL
16444 /* A non-zero number or non-empty string argument: reset mode. */
16450 #else
16452 #endif
16453 }
16455 /*
16456 * "winbufnr(nr)" function
16457 */
16458 static void
16462 {
16468 else
16470 }
16472 /*
16473 * "wincol()" function
16474 */
16475 /*ARGSUSED*/
16476 static void
16480 {
16483 }
16485 /*
16486 * "winheight(nr)" function
16487 */
16488 static void
16492 {
16498 else
16500 }
16502 /*
16503 * "winline()" function
16504 */
16505 /*ARGSUSED*/
16506 static void
16510 {
16513 }
16515 /*
16516 * "winnr()" function
16517 */
16518 /* ARGSUSED */
16519 static void
16523 {
16526 #ifdef FEAT_WINDOWS
16528 #endif
16530 }
16532 /*
16533 * "winrestcmd()" function
16534 */
16535 /* ARGSUSED */
16536 static void
16540 {
16541 #ifdef FEAT_WINDOWS
16544 garray_T ga;
16549 {
16552 # ifdef FEAT_VERTSPLIT
16555 # endif
16557 }
16561 #else
16563 #endif
16565 }
16567 /*
16568 * "winrestview()" function
16569 */
16570 /* ARGSUSED */
16571 static void
16575 {
16581 else
16582 {
16585 #ifdef FEAT_VIRTUALEDIT
16587 #endif
16592 #ifdef FEAT_DIFF
16594 #endif
16607 #ifdef FEAT_DIFF
16609 #endif
16610 }
16611 }
16613 /*
16614 * "winsaveview()" function
16615 */
16616 /* ARGSUSED */
16617 static void
16621 {
16633 #ifdef FEAT_VIRTUALEDIT
16635 #endif
16640 #ifdef FEAT_DIFF
16642 #endif
16645 }
16647 /*
16648 * "winwidth(nr)" function
16649 */
16650 static void
16654 {
16660 else
16661 #ifdef FEAT_VERTSPLIT
16663 #else
16665 #endif
16666 }
16668 /*
16669 * "writefile()" function
16670 */
16671 static void
16675 {
16688 {
16691 }
16699 /* Always open the file in binary mode, library functions have a mind of
16700 * their own about CR-LF conversion. */
16703 {
16706 }
16707 else
16708 {
16711 {
16713 {
16716 else
16719 {
16722 }
16723 }
16726 {
16729 }
16731 {
16734 }
16735 }
16737 }
16740 }
16742 /*
16743 * Translate a String variable into a position.
16744 * Returns NULL when there is an error.
16745 */
16751 {
16756 /* Argument can be [lnum, col, coladd]. */
16758 {
16768 /* Get the line number */
16773 /* Get the column number */
16779 /* We accept "$" for the column number: last column. */
16786 /* Accept a position up to the NUL after the line. */
16791 #ifdef FEAT_VIRTUALEDIT
16792 /* Get the virtual offset. Defaults to zero. */
16796 #endif
16799 }
16807 {
16812 }
16814 #ifdef FEAT_VIRTUALEDIT
16816 #endif
16819 {
16822 {
16826 }
16828 {
16832 }
16833 }
16835 {
16837 {
16840 }
16841 else
16842 {
16845 }
16847 }
16849 }
16851 /*
16852 * Convert list in "arg" into a position and optional file number.
16853 * When "fnump" is NULL there is no file number, only 3 items.
16854 * Note that the column is passed on as-is, the caller may want to decrement
16855 * it to use 1 for the first column.
16856 * Return FAIL when conversion is not possible, doesn't check the position for
16857 * validity.
16858 */
16859 static int
16864 {
16869 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16870 * when "fnump" isn't NULL and "coladd" is optional. */
16878 {
16885 }
16897 #ifdef FEAT_VIRTUALEDIT
16901 else
16903 #endif
16906 }
16908 /*
16909 * Get the length of an environment variable name.
16910 * Advance "arg" to the first character after the name.
16911 * Return 0 for error.
16912 */
16913 static int
16916 {
16921 ;
16928 }
16930 /*
16931 * Get the length of the name of a function or internal variable.
16932 * "arg" is advanced to the first non-white character after the name.
16933 * Return 0 if something is wrong.
16934 */
16935 static int
16938 {
16942 /* Find the end of the name. */
16944 ;
16952 }
16954 /*
16955 * Get the length of the name of a variable or function.
16956 * Only the name is recognized, does not handle ".key" or "[idx]".
16957 * "arg" is advanced to the first non-white character after the name.
16958 * Return -1 if curly braces expansion failed.
16959 * Return 0 if something else is wrong.
16960 * If the name contains 'magic' {}'s, expand them and return the
16961 * expanded name in an allocated string via 'alias' - caller must free.
16962 */
16963 static int
16969 {
16979 {
16980 /* hard coded <SNR>, already translated */
16983 }
16986 {
16987 /* literal "<SID>", "s:" or "<SNR>" */
16989 }
16991 /*
16992 * Find the end of the name; check for {} construction.
16993 */
16997 {
17001 {
17005 }
17007 /*
17008 * Include any <SID> etc in the expanded string:
17009 * Thus the -len here.
17010 */
17017 }
17024 }
17026 /*
17027 * Find the end of a variable or function name, taking care of magic braces.
17028 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17029 * start and end of the first magic braces item.
17030 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17031 * Return a pointer to just after the name. Equal to "arg" if there is no
17032 * valid name.
17033 */
17040 {
17046 {
17049 }
17051 /* Quick check for valid starting character. */
17061 {
17063 {
17064 /* skip over 'string' to avoid counting [ and ] inside it. */
17066 ;
17069 }
17071 {
17072 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17078 }
17081 {
17086 }
17089 {
17091 {
17092 mb_nest++;
17095 }
17097 {
17098 mb_nest--;
17101 }
17102 }
17103 }
17106 }
17108 /*
17109 * Expands out the 'magic' {}'s in a variable/function name.
17110 * Note that this can call itself recursively, to deal with
17111 * constructs like foo{bar}{baz}{bam}
17112 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17113 * "in_start" ^
17114 * "expr_start" ^
17115 * "expr_end" ^
17116 * "in_end" ^
17117 *
17118 * Returns a new allocated string, which the caller must free.
17119 * Returns NULL for failure.
17120 */
17127 {
17128 char_u c1;
17142 {
17146 {
17150 }
17151 }
17159 {
17162 {
17163 /* Further expansion! */
17168 }
17169 }
17172 }
17174 /*
17175 * Return TRUE if character "c" can be used in a variable or function name.
17176 * Does not include '{' or '}' for magic braces.
17177 */
17178 static int
17181 {
17183 }
17185 /*
17186 * Return TRUE if character "c" can be used as the first character in a
17187 * variable or function name (excluding '{' and '}').
17188 */
17189 static int
17192 {
17194 }
17196 /*
17197 * Set number v: variable to "val".
17198 */
17199 void
17203 {
17205 }
17207 /*
17208 * Get number v: variable value.
17209 */
17210 long
17213 {
17215 }
17217 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17218 /*
17219 * Get string v: variable value. Uses a static buffer, can only be used once.
17220 */
17221 char_u *
17224 {
17226 }
17227 #endif
17229 /*
17230 * Set v:count, v:count1 and v:prevcount.
17231 */
17232 void
17236 {
17240 }
17242 /*
17243 * Set string v: variable to a copy of "val".
17244 */
17245 void
17250 {
17251 /* Need to do this (at least) once, since we can't initialize a union.
17252 * Will always be invoked when "v:progname" is set. */
17260 else
17262 }
17264 /*
17265 * Set v:register if needed.
17266 */
17267 void
17270 {
17271 char_u regname;
17275 else
17277 /* Avoid free/alloc when the value is already right. */
17280 }
17282 /*
17283 * Get or set v:exception. If "oldval" == NULL, return the current value.
17284 * Otherwise, restore the value to "oldval" and return NULL.
17285 * Must always be called in pairs to save and restore v:exception! Does not
17286 * take care of memory allocations.
17287 */
17288 char_u *
17291 {
17297 }
17299 /*
17300 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17301 * Otherwise, restore the value to "oldval" and return NULL.
17302 * Must always be called in pairs to save and restore v:throwpoint! Does not
17303 * take care of memory allocations.
17304 */
17305 char_u *
17308 {
17314 }
17316 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17317 /*
17318 * Set v:cmdarg.
17319 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17320 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17321 * Must always be called in pairs!
17322 */
17323 char_u *
17327 {
17334 {
17338 }
17344 else
17352 # ifdef FEAT_MBYTE
17357 # endif
17367 else
17376 # ifdef FEAT_MBYTE
17383 # endif
17386 }
17387 #endif
17389 /*
17390 * Get the value of internal variable "name".
17391 * Return OK or FAIL.
17392 */
17393 static int
17399 {
17402 typval_T atv;
17406 /* truncate the name, so that we can use strcmp() */
17410 /*
17411 * Check for "b:changedtick".
17412 */
17414 {
17418 }
17420 /*
17421 * Check for user-defined variables.
17422 */
17423 else
17424 {
17428 }
17431 {
17435 }
17442 }
17444 /*
17445 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17446 * Also handle function call with Funcref variable: func(expr)
17447 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17448 */
17449 static int
17455 {
17460 typval_T functv;
17467 {
17469 {
17470 /* need to copy the funcref so that we can clear rettv */
17474 /* Invoke the function. Recursive! */
17480 /* Clear the funcref afterwards, so that deleting it while
17481 * evaluating the arguments is possible (see test55). */
17484 /* Stop the expression evaluation when immediately aborting on
17485 * error, or when an interrupt occurred or an exception was thrown
17486 * but not caught. */
17488 {
17492 }
17495 }
17497 {
17500 {
17504 }
17505 else
17508 {
17511 }
17512 }
17513 }
17516 }
17518 /*
17519 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17520 * value).
17521 */
17524 {
17526 }
17528 /*
17529 * Allocate memory for a variable type-value, and assign a string to it.
17530 * The string "s" must have been allocated, it is consumed.
17531 * Return NULL for out of memory, the variable otherwise.
17532 */
17536 {
17541 {
17544 }
17545 else
17548 }
17550 /*
17551 * Free the memory for a variable type-value.
17552 */
17553 void
17556 {
17558 {
17560 {
17563 /*FALLTHROUGH*/
17579 }
17581 }
17582 }
17584 /*
17585 * Free the memory for a variable value and set the value to NULL or 0.
17586 */
17587 void
17590 {
17592 {
17594 {
17597 /*FALLTHROUGH*/
17617 }
17619 }
17620 }
17622 /*
17623 * Set the value of a variable to NULL without freeing items.
17624 */
17625 static void
17628 {
17631 }
17633 /*
17634 * Get the number value of a variable.
17635 * If it is a String variable, uses vim_str2nr().
17636 * For incompatible types, return 0.
17637 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17638 * caller of incompatible types: it sets *denote to TRUE if "denote"
17639 * is not NULL or returns -1 otherwise.
17640 */
17641 static long
17644 {
17648 }
17650 long
17654 {
17658 {
17678 }
17681 else
17684 }
17686 /*
17687 * Get the lnum from the first argument.
17688 * Also accepts ".", "$", etc., but that only works for the current buffer.
17689 * Returns -1 on error.
17690 */
17691 static linenr_T
17694 {
17695 typval_T rettv;
17696 linenr_T lnum;
17700 {
17705 }
17707 }
17709 /*
17710 * Get the lnum from the first argument.
17711 * Also accepts "$", then "buf" is used.
17712 * Returns 0 on error.
17713 */
17714 static linenr_T
17718 {
17725 }
17727 /*
17728 * Get the string value of a variable.
17729 * If it is a Number variable, the number is converted into a string.
17730 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17731 * get_tv_string_buf() uses a given buffer.
17732 * If the String variable has never been set, return an empty string.
17733 * Never returns NULL;
17734 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17735 * NULL on error.
17736 */
17740 {
17744 }
17750 {
17754 }
17756 char_u *
17759 {
17763 }
17769 {
17771 {
17791 }
17793 }
17795 /*
17796 * Find variable "name" in the list of variables.
17797 * Return a pointer to it if found, NULL if not found.
17798 * Careful: "a:0" variables don't have a name.
17799 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17800 * hashtab_T used.
17801 */
17806 {
17816 }
17818 /*
17819 * Find variable "varname" in hashtab "ht".
17820 * Returns NULL if not found.
17821 */
17827 {
17831 {
17832 /* Must be something like "s:", otherwise "ht" would be NULL. */
17834 {
17840 #ifdef FEAT_WINDOWS
17842 #endif
17847 }
17849 }
17853 {
17854 /* For global variables we may try auto-loading the script. If it
17855 * worked find the variable again. Don't auto-load a script if it was
17856 * loaded already, otherwise it would be loaded every time when
17857 * checking if a function name is a Funcref variable. */
17863 }
17865 }
17867 /*
17868 * Find the hashtab used for a variable name.
17869 * Set "varname" to the start of name without ':'.
17870 */
17875 {
17879 {
17880 /* The name must not start with a colon or #. */
17885 /* "version" is "v:version" in all scopes */
17893 }
17897 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17898 */
17906 #ifdef FEAT_WINDOWS
17909 #endif
17920 }
17922 /*
17923 * Get the string value of a (global/local) variable.
17924 * Returns NULL when it doesn't exist.
17925 */
17926 char_u *
17929 {
17936 }
17938 /*
17939 * Allocate a new hashtab for a sourced script. It will be used while
17940 * sourcing this script and when executing functions defined in the script.
17941 */
17942 void
17944 scid_T id;
17945 {
17951 {
17952 /* Re-allocating ga_data means that an ht_array pointing to
17953 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
17954 * at its init value. Also reset "v_dict", it's always the same. */
17956 {
17962 }
17965 {
17969 }
17970 }
17971 }
17973 /*
17974 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
17975 * point to it.
17976 */
17977 void
17981 {
17989 }
17991 /*
17992 * Clean up a list of internal variables.
17993 * Frees all allocated variables and the value they contain.
17994 * Clears hashtab "ht", does not free it.
17995 */
17996 void
17999 {
18001 }
18003 /*
18004 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18005 */
18006 static void
18010 {
18018 {
18020 {
18023 /* Free the variable. Don't remove it from the hashtab,
18024 * ht_array might change then. hash_clear() takes care of it
18025 * later. */
18031 }
18032 }
18035 }
18037 /*
18038 * Delete a variable from hashtab "ht" at item "hi".
18039 * Clear the variable value and free the dictitem.
18040 */
18041 static void
18045 {
18051 }
18053 /*
18054 * List the value of one internal variable.
18055 */
18056 static void
18061 {
18070 }
18072 static void
18079 {
18080 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18092 {
18096 }
18098 {
18102 }
18103 else
18111 {
18114 }
18115 }
18117 /*
18118 * Set variable "name" to value in "tv".
18119 * If the variable already exists, the value is updated.
18120 * Otherwise the variable is created.
18121 */
18122 static void
18127 {
18134 {
18138 {
18141 }
18143 {
18145 name);
18147 }
18148 }
18152 {
18155 }
18159 {
18160 /* existing variable, need to clear the value */
18169 {
18172 }
18174 /*
18175 * Handle setting internal v: variables separately: we don't change
18176 * the type.
18177 */
18179 {
18181 {
18185 else
18186 {
18187 /* Take over the string to avoid an extra alloc/free. */
18190 }
18191 }
18194 else
18197 }
18200 }
18202 {
18203 /* Can't add "v:" variable. */
18205 {
18208 }
18210 /* Make sure the variable name is valid. */
18214 {
18217 }
18225 {
18228 }
18230 }
18234 else
18235 {
18239 }
18240 }
18242 /*
18243 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18244 * Also give an error message.
18245 */
18246 static int
18250 {
18252 {
18255 }
18257 {
18260 }
18262 }
18264 /*
18265 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18266 * Also give an error message.
18267 */
18268 static int
18272 {
18274 {
18277 }
18279 }
18281 /*
18282 * Return TRUE if typeval "tv" is set to be locked (immutable).
18283 * Also give an error message, using "name".
18284 */
18285 static int
18289 {
18291 {
18295 }
18297 {
18301 }
18303 }
18305 /*
18306 * Copy the values from typval_T "from" to typval_T "to".
18307 * When needed allocates string or increases reference count.
18308 * Does not make a copy of a list or dict but copies the reference!
18309 */
18310 static void
18314 {
18318 {
18326 else
18327 {
18331 }
18336 else
18337 {
18340 }
18345 else
18346 {
18349 }
18354 }
18355 }
18357 /*
18358 * Make a copy of an item.
18359 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18360 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18361 * reference to an already copied list/dict can be used.
18362 * Returns FAIL or OK.
18363 */
18364 static int
18370 {
18375 {
18378 }
18382 {
18394 {
18395 /* use the copy made earlier */
18398 }
18399 else
18410 {
18411 /* use the copy made earlier */
18414 }
18415 else
18423 }
18426 }
18428 /*
18429 * ":echo expr1 ..." print each argument separated with a space, add a
18430 * newline at the end.
18431 * ":echon expr1 ..." print each argument plain.
18432 */
18433 void
18436 {
18438 typval_T rettv;
18448 {
18451 {
18452 /*
18453 * Report the invalid expression unless the expression evaluation
18454 * has been cancelled due to an aborting error, an interrupt, or an
18455 * exception.
18456 */
18460 }
18462 {
18464 {
18466 /* Call msg_start() after eval1(), evaluating the expression
18467 * may cause a message to appear. */
18470 }
18476 {
18478 {
18480 {
18481 /* remove any text still there from the command */
18484 }
18486 }
18487 else
18488 {
18489 #ifdef FEAT_MBYTE
18491 {
18496 }
18497 else
18498 #endif
18500 }
18501 }
18503 }
18506 }
18511 else
18512 {
18513 /* remove text that may still be there from the command */
18518 }
18519 }
18521 /*
18522 * ":echohl {name}".
18523 */
18524 void
18527 {
18533 else
18535 }
18537 /*
18538 * ":execute expr1 ..." execute the result of an expression.
18539 * ":echomsg expr1 ..." Print a message
18540 * ":echoerr expr1 ..." Print an error
18541 * Each gets spaces around each argument and a newline at the end for
18542 * echo commands
18543 */
18544 void
18547 {
18549 typval_T rettv;
18552 garray_T ga;
18561 {
18564 {
18565 /*
18566 * Report the invalid expression unless the expression evaluation
18567 * has been cancelled due to an aborting error, an interrupt, or an
18568 * exception.
18569 */
18574 }
18577 {
18581 {
18585 }
18590 }
18594 }
18597 {
18599 {
18602 }
18604 {
18605 /* We don't want to abort following commands, restore did_emsg. */
18610 }
18614 }
18622 }
18624 /*
18625 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18626 * "arg" points to the "&" or '+' when called, to "option" when returning.
18627 * Returns NULL when no option name found. Otherwise pointer to the char
18628 * after the option name.
18629 */
18634 {
18639 {
18642 }
18644 {
18647 }
18648 else
18657 else
18661 }
18663 /*
18664 * ":function"
18665 */
18666 void
18669 {
18678 garray_T newargs;
18679 garray_T newlines;
18688 funcdict_T fudi;
18696 /*
18697 * ":function" without argument: list functions.
18698 */
18700 {
18702 {
18705 {
18707 {
18712 }
18713 }
18714 }
18717 }
18719 /*
18720 * ":function /pat": list functions matching pattern.
18721 */
18723 {
18726 {
18727 regmatch_T regmatch;
18734 {
18739 {
18741 {
18747 }
18748 }
18749 }
18750 }
18755 }
18757 /*
18758 * Get the function name. There are these situations:
18759 * func normal function name
18760 * "name" == func, "fudi.fd_dict" == NULL
18761 * dict.func new dictionary entry
18762 * "name" == NULL, "fudi.fd_dict" set,
18763 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18764 * dict.func existing dict entry with a Funcref
18765 * "name" == func, "fudi.fd_dict" set,
18766 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18767 * dict.func existing dict entry that's not a Funcref
18768 * "name" == NULL, "fudi.fd_dict" set,
18769 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18770 */
18775 {
18776 /*
18777 * Return on an invalid expression in braces, unless the expression
18778 * evaluation has been cancelled due to an aborting error, an
18779 * interrupt, or an exception.
18780 */
18782 {
18787 }
18788 else
18790 }
18792 /* An error in a function call during evaluation of an expression in magic
18793 * braces should not cause the function not to be defined. */
18797 /*
18798 * ":function func" with only function name: list function.
18799 */
18801 {
18803 {
18806 }
18811 {
18814 {
18817 {
18829 }
18831 {
18834 }
18835 }
18836 else
18838 }
18840 }
18842 /*
18843 * ":function name(arg1, arg2)" Define function.
18844 */
18847 {
18849 {
18852 }
18853 /* attempt to continue by skipping some text */
18856 }
18863 {
18864 /* Check the name of the function. Unless it's a dictionary function
18865 * (that we are overwriting). */
18868 else
18872 {
18875 else
18882 }
18883 }
18885 /*
18886 * Isolate the arguments: "arg1, arg2, ...)"
18887 */
18889 {
18891 {
18895 }
18896 else
18897 {
18904 {
18908 }
18921 else
18923 }
18926 {
18930 }
18931 }
18934 /* find extra arguments "range", "dict" and "abort" */
18936 {
18939 {
18942 }
18944 {
18947 }
18949 {
18952 }
18953 else
18955 }
18957 /* When there is a line break use what follows for the function body.
18958 * Makes 'exe "func Test()\n...\nendfunc"' work. */
18964 /*
18965 * Read the body of the function, until ":endfunction" is found.
18966 */
18968 {
18969 /* Check if the function already exists, don't let the user type the
18970 * whole function before telling him it doesn't work! For a script we
18971 * need to skip the body to be able to find what follows. */
18973 {
18978 }
18985 }
18990 {
18996 {
18997 /* Use eap->arg, split up in parts by line breaks. */
19002 else
19003 {
19006 }
19007 }
19010 else
19015 {
19018 }
19020 /* Detect line continuation: sourcing_lnum increased more than one. */
19023 else
19027 {
19028 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19029 * don't check for ":endfunc". */
19031 {
19034 }
19035 }
19036 else
19037 {
19038 /* skip ':' and blanks*/
19040 ;
19042 /* Check for "endfunction". */
19044 {
19048 }
19050 /* Increase indent inside "if", "while", "for" and "try", decrease
19051 * at "end". */
19060 /* Check for defining a function inside this function. */
19062 {
19067 {
19070 {
19073 }
19074 }
19075 }
19077 /* Check for ":append" or ":insert". */
19085 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19098 ))
19099 {
19100 /* ":python <<" continues until a dot, like ":append" */
19104 else
19106 }
19107 }
19109 /* Add the line to the function. */
19111 {
19115 }
19117 /* Copy the line to newly allocated memory. get_one_sourceline()
19118 * allocates 250 bytes per line, this saves 80% on average. The cost
19119 * is an extra alloc/free. */
19122 {
19126 }
19130 /* Add NULL lines for continuation lines, so that the line count is
19131 * equal to the index in the growarray. */
19135 /* Check for end of eap->arg. */
19138 }
19140 /* Don't define the function when skipping commands or when an error was
19141 * detected. */
19145 /*
19146 * If there are no errors, add the function
19147 */
19149 {
19152 {
19154 name);
19156 }
19160 {
19162 {
19165 }
19167 {
19169 name);
19171 }
19172 /* redefine existing function */
19177 }
19178 }
19179 else
19180 {
19185 {
19188 }
19190 {
19191 /* Can't add a function to a locked dictionary */
19194 }
19195 /* Can't change an existing function if it is locked */
19199 /* Give the function a sequential number. Can only be used with a
19200 * Funcref! */
19206 }
19209 {
19211 {
19215 /* Check that the autoload name matches the script name. */
19218 {
19221 {
19229 }
19230 }
19232 {
19235 }
19236 }
19243 {
19245 {
19246 /* add new dict entry */
19249 {
19252 }
19254 {
19258 }
19259 }
19260 else
19261 /* overwrite existing dict entry */
19268 /* behave like "dict" was used */
19270 }
19272 /* insert the new function in the function list */
19275 }
19278 #ifdef FEAT_PROFILE
19285 #endif
19292 erret:
19295 ret_free:
19300 }
19302 /*
19303 * Get a function name, translating "<SID>" and "<SNR>".
19304 * Also handles a Funcref in a List or Dictionary.
19305 * Returns the function name in allocated memory, or NULL for failure.
19306 * flags:
19307 * TFN_INT: internal function name OK
19308 * TFN_QUIET: be quiet
19309 * Advances "pp" to just after the function name (if no error).
19310 */
19317 {
19324 lval_T lv;
19330 /* Check for hard coded <SNR>: already translated function ID (from a user
19331 * command). */
19334 {
19338 }
19340 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19341 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19349 {
19353 }
19355 {
19356 /*
19357 * Report an invalid expression in braces, unless the expression
19358 * evaluation has been cancelled due to an aborting error, an
19359 * interrupt, or an exception.
19360 */
19362 {
19365 }
19366 else
19369 }
19372 {
19374 {
19379 }
19381 {
19384 }
19385 else
19386 {
19390 else
19393 }
19395 }
19398 {
19399 /* Error found, but continue after the function name. */
19402 }
19404 /* Check if the name is a Funcref. If so, use the value. */
19406 {
19411 }
19412 else
19413 {
19418 }
19420 {
19424 }
19427 {
19431 {
19432 /* When there was "s:" already or the name expanded to get a
19433 * leading "s:" then remove it. */
19437 }
19438 }
19439 else
19440 {
19444 }
19446 /*
19447 * Copy the function name to allocated memory.
19448 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19449 * Accept <SNR>123_name() outside a script.
19450 */
19454 {
19458 {
19459 /* It's "s:" or "<SID>" */
19461 {
19464 }
19467 }
19468 }
19470 {
19473 }
19476 {
19478 {
19484 }
19487 }
19490 theend:
19493 }
19495 /*
19496 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19497 * Return 2 if "p" starts with "s:".
19498 * Return 0 otherwise.
19499 */
19500 static int
19503 {
19510 }
19512 /*
19513 * Return TRUE if "p" starts with "<SID>" or "s:".
19514 * Only works if eval_fname_script() returned non-zero for "p"!
19515 */
19516 static int
19519 {
19521 }
19523 /*
19524 * List the head of the function: "name(arg1, arg2)".
19525 */
19526 static void
19530 {
19538 {
19541 }
19542 else
19546 {
19550 }
19552 {
19556 }
19561 }
19563 /*
19564 * Find a function by name, return pointer to it in ufuncs.
19565 * Return NULL for unknown function.
19566 */
19570 {
19577 }
19579 #if defined(EXITFREE) || defined(PROTO)
19580 void
19582 {
19585 /* Need to start all over every time, because func_free() may change the
19586 * hash table. */
19590 {
19593 }
19594 }
19595 #endif
19597 /*
19598 * Return TRUE if a function "name" exists.
19599 */
19600 static int
19603 {
19611 /* Only accept "funcname", "funcname ", "funcname (..." and
19612 * "funcname(...", not "funcname!...". */
19614 {
19617 else
19619 }
19622 }
19624 /*
19625 * Return TRUE if "name" looks like a builtin function name: starts with a
19626 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19627 */
19628 static int
19631 {
19634 }
19636 #if defined(FEAT_PROFILE) || defined(PROTO)
19637 /*
19638 * Start profiling function "fp".
19639 */
19640 static void
19643 {
19662 }
19664 /*
19665 * Dump the profiling results for all functions in file "fd".
19666 */
19667 void
19670 {
19682 {
19684 {
19688 {
19694 else
19698 else
19706 {
19712 }
19714 }
19715 }
19716 }
19719 {
19721 prof_total_cmp);
19724 prof_self_cmp);
19726 }
19727 }
19729 static void
19736 {
19743 {
19746 prefer_self);
19749 else
19751 }
19753 }
19755 /*
19756 * Print the count and times for one function or function line.
19757 */
19758 static void
19765 {
19767 {
19771 else
19775 else
19777 }
19778 else
19780 }
19782 /*
19783 * Compare function for total time sorting.
19784 */
19785 static int
19786 #ifdef __BORLANDC__
19787 _RTLENTRYF
19788 #endif
19792 {
19798 }
19800 /*
19801 * Compare function for self time sorting.
19802 */
19803 static int
19804 #ifdef __BORLANDC__
19805 _RTLENTRYF
19806 #endif
19810 {
19816 }
19818 #endif
19820 /*
19821 * If "name" has a package name try autoloading the script for it.
19822 * Return TRUE if a package was loaded.
19823 */
19824 static int
19828 {
19834 /* If there is no '#' after name[0] there is no package name. */
19841 /* Find the name in the list of previously loaded package names. Skip
19842 * "autoload/", it's always the same. */
19848 else
19849 {
19850 /* Remember the name if it wasn't loaded already. */
19852 {
19855 }
19857 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19860 }
19864 }
19866 /*
19867 * Return the autoload script name for a function or variable name.
19868 * Returns NULL when out of memory.
19869 */
19873 {
19877 /* Get the script file name: replace '#' with '/', append ".vim". */
19888 }
19890 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19892 /*
19893 * Function given to ExpandGeneric() to obtain the list of user defined
19894 * function names.
19895 */
19896 char_u *
19900 {
19906 {
19909 }
19911 {
19923 {
19927 }
19929 }
19931 }
19935 /*
19936 * Copy the function name of "fp" to buffer "buf".
19937 * "buf" must be able to hold the function name plus three bytes.
19938 * Takes care of script-local function names.
19939 */
19940 static void
19944 {
19946 {
19949 }
19950 else
19952 }
19954 /*
19955 * ":delfunction {name}"
19956 */
19957 void
19960 {
19964 funcdict_T fudi;
19970 {
19974 }
19976 {
19980 }
19990 {
19992 {
19995 }
19997 {
20000 }
20003 {
20004 /* Delete the dict item that refers to the function, it will
20005 * invoke func_unref() and possibly delete the function. */
20007 }
20008 else
20010 }
20011 }
20013 /*
20014 * Free a function and remove it from the list of functions.
20015 */
20016 static void
20019 {
20022 /* clear this function */
20025 #ifdef FEAT_PROFILE
20029 #endif
20031 /* remove the function from the function hashtable */
20035 else
20039 }
20041 /*
20042 * Unreference a Function: decrement the reference count and free it when it
20043 * becomes zero. Only for numbered functions.
20044 */
20045 static void
20048 {
20052 {
20057 {
20058 /* Only delete it when it's not being used. Otherwise it's done
20059 * when "uf_calls" becomes zero. */
20062 }
20063 }
20064 }
20066 /*
20067 * Count a reference to a Function.
20068 */
20069 static void
20072 {
20076 {
20080 else
20082 }
20083 }
20085 /*
20086 * Call a user function.
20087 */
20088 static void
20097 {
20099 linenr_T save_sourcing_lnum;
20100 scid_T save_current_SID;
20101 funccall_T fc;
20110 #ifdef FEAT_PROFILE
20111 proftime_T wait_start;
20112 proftime_T call_start;
20113 #endif
20115 /* If depth of calling is getting too high, don't execute the function */
20117 {
20122 }
20135 /* Check if this function has a breakpoint. */
20139 /*
20140 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20141 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20142 * each argument variable and saves a lot of time.
20143 */
20144 /*
20145 * Init l: variables.
20146 */
20149 {
20150 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20151 * some compiler that checks the destination size. */
20161 }
20163 /*
20164 * Init a: variables.
20165 * Set a:0 to "argcount".
20166 * Set a:000 to a list with room for the "..." arguments.
20167 */
20182 /*
20183 * Set a:firstline to "firstline" and a:lastline to "lastline".
20184 * Set a:name to named arguments.
20185 * Set a:N to the "..." arguments.
20186 */
20192 {
20195 /* named argument a:name */
20197 else
20198 {
20199 /* "..." argument a:1, a:2, etc. */
20202 }
20204 {
20207 }
20208 else
20209 {
20215 }
20219 /* Note: the values are copied directly to avoid alloc/free.
20220 * "argvars" must have VAR_FIXED for v_lock. */
20225 {
20229 }
20230 }
20232 /* Don't redraw while executing the function. */
20240 {
20244 else
20249 {
20255 {
20263 {
20268 else
20269 {
20272 {
20276 }
20277 }
20278 }
20280 }
20285 }
20286 }
20287 #ifdef FEAT_PROFILE
20289 {
20294 {
20298 }
20300 }
20301 #endif
20308 /* call do_cmdline() to execute the lines */
20314 /* when the function was aborted because of an error, return -1 */
20316 {
20320 }
20322 #ifdef FEAT_PROFILE
20325 {
20331 {
20334 }
20335 }
20336 #endif
20338 /* when being verbose, mention the return value */
20340 {
20349 else
20350 {
20356 /* The value may be very long. Skip the middle part, so that we
20357 * have some idea how it starts and ends. smsg() would always
20358 * truncate it at the end. */
20361 {
20365 }
20366 }
20371 }
20377 #ifdef FEAT_PROFILE
20380 #endif
20383 {
20392 }
20397 /* The a: variables typevals were not alloced, only free the allocated
20398 * variables. */
20403 }
20405 /*
20406 * Add a number variable "name" to dict "dp" with value "nr".
20407 */
20408 static void
20413 varnumber_T nr;
20414 {
20421 }
20423 /*
20424 * ":return [expr]"
20425 */
20426 void
20429 {
20431 typval_T rettv;
20435 {
20438 }
20446 {
20449 else
20451 }
20452 /* It's safer to return also on error. */
20454 {
20455 /*
20456 * Return unless the expression evaluation has been cancelled due to an
20457 * aborting error, an interrupt, or an exception.
20458 */
20461 }
20463 /* When skipping or the return gets pending, advance to the next command
20464 * in this line (!returning). Otherwise, ignore the rest of the line.
20465 * Following lines will be ignored by get_func_line(). */
20473 }
20475 /*
20476 * Return from a function. Possibly makes the return pending. Also called
20477 * for a pending return at the ":endtry" or after returning from an extra
20478 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20479 * when called due to a ":return" command. "rettv" may point to a typval_T
20480 * with the return rettv. Returns TRUE when the return can be carried out,
20481 * FALSE when the return gets pending.
20482 */
20483 int
20489 {
20494 /* Undo the return. */
20497 /*
20498 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20499 * not in its finally clause (which then is to be executed next) is found.
20500 * In this case, make the ":return" pending for execution at the ":endtry".
20501 * Otherwise, return normally.
20502 */
20505 {
20509 /* A pending return again gets pending. "rettv" points to an
20510 * allocated variable with the rettv of the original ":return"'s
20511 * argument if present or is NULL else. */
20513 else
20514 {
20515 /* When undoing a return in order to make it pending, get the stored
20516 * return rettv. */
20521 {
20522 /* Store the value of the pending return. */
20525 else
20527 }
20528 else
20532 {
20533 /* The pending return value could be overwritten by a ":return"
20534 * without argument in a finally clause; reset the default
20535 * return value. */
20538 }
20539 }
20541 }
20542 else
20543 {
20546 /* If the return is carried out now, store the return value. For
20547 * a return immediately after reanimation, the value is already
20548 * there. */
20550 {
20555 }
20556 }
20559 }
20561 /*
20562 * Free the variable with a pending return value.
20563 */
20564 void
20567 {
20569 }
20571 /*
20572 * Generate a return command for producing the value of "rettv". The result
20573 * is an allocated string. Used by report_pending() for verbose messages.
20574 */
20575 char_u *
20578 {
20594 }
20596 /*
20597 * Get next function line.
20598 * Called by do_cmdline() to get the next line.
20599 * Returns allocated string, or NULL for end of function.
20600 */
20601 /* ARGSUSED */
20602 char_u *
20607 {
20613 /* If breakpoints have been added/deleted need to check for it. */
20615 {
20617 sourcing_lnum);
20619 }
20620 #ifdef FEAT_PROFILE
20623 #endif
20629 else
20630 {
20631 /* Skip NULL lines (continuation lines). */
20637 else
20638 {
20641 #ifdef FEAT_PROFILE
20644 #endif
20645 }
20646 }
20648 /* Did we encounter a breakpoint? */
20650 {
20652 /* Find next breakpoint. */
20654 sourcing_lnum);
20656 }
20659 }
20661 #if defined(FEAT_PROFILE) || defined(PROTO)
20662 /*
20663 * Called when starting to read a function line.
20664 * "sourcing_lnum" must be correct!
20665 * When skipping lines it may not actually be executed, but we won't find out
20666 * until later and we need to store the time now.
20667 */
20668 void
20671 {
20677 {
20679 /* Skip continuation lines. */
20686 }
20687 }
20689 /*
20690 * Called when actually executing a function line.
20691 */
20692 void
20695 {
20701 }
20703 /*
20704 * Called when done with a function line.
20705 */
20706 void
20709 {
20714 {
20716 {
20723 }
20725 }
20726 }
20727 #endif
20729 /*
20730 * Return TRUE if the currently active function should be ended, because a
20731 * return was encountered or an error occured. Used inside a ":while".
20732 */
20733 int
20736 {
20739 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20740 * an error inside a try conditional. */
20743 }
20745 /*
20746 * return TRUE if cookie indicates a function which "abort"s on errors.
20747 */
20748 int
20751 {
20753 }
20755 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20757 {
20758 VAR_FLAVOUR_DEFAULT,
20759 VAR_FLAVOUR_SESSION,
20760 VAR_FLAVOUR_VIMINFO
20765 static var_flavour_T
20768 {
20772 {
20777 }
20778 else
20780 }
20781 #endif
20783 #if defined(FEAT_VIMINFO) || defined(PROTO)
20784 /*
20785 * Restore global vars that start with a capital from the viminfo file
20786 */
20787 int
20791 {
20794 typval_T tv;
20797 {
20800 {
20807 {
20809 {
20813 }
20814 else
20815 {
20818 }
20822 }
20823 }
20824 }
20827 }
20829 /*
20830 * Write global vars that start with a capital to the viminfo file
20831 */
20832 void
20835 {
20851 {
20853 {
20857 {
20859 {
20863 }
20869 }
20870 }
20871 }
20872 }
20873 #endif
20875 #if defined(FEAT_SESSION) || defined(PROTO)
20876 int
20879 {
20887 {
20889 {
20895 {
20896 /* Escape special characters with a backslash. Turn a LF and
20897 * CR into \n and \r. */
20911 p,
20915 {
20918 }
20920 }
20921 }
20922 }
20924 }
20925 #endif
20927 /*
20928 * Display script name where an item was last set.
20929 * Should only be invoked when 'verbose' is non-zero.
20930 */
20931 void
20933 scid_T scriptID;
20934 {
20938 {
20941 {
20947 }
20948 }
20949 }
20953 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
20956 #ifdef WIN3264
20957 /*
20958 * Functions for ":8" filename modifier: get 8.3 version of a filename.
20959 */
20961 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
20964 /*
20965 * Get the short pathname of a file.
20966 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
20967 */
20968 static int
20973 {
20981 {
20982 /* If that doesn't work (not enough space), then save the string
20983 * and try again with a new buffer big enough
20984 */
20994 /* Really should always succeed, as the buffer is big enough */
20995 }
20999 }
21001 /*
21002 * Create a short path name. Returns the length of the buffer it needs.
21003 * Doesn't copy over the end of the buffer passed in.
21004 */
21005 static int
21010 {
21012 char_u ch;
21015 /* Make a copy */
21025 {
21029 }
21031 do
21032 {
21033 /* Go back one path-separator */
21035 {
21039 }
21043 /* Remember the character that is about to be splatted */
21047 /* Try it in situ */
21050 {
21053 }
21058 {
21059 /* Remember the length of the new string. */
21063 {
21064 /* If there's not enough space in the currently allocated string,
21065 * then copy it to a buffer big enough.
21066 */
21070 }
21071 else
21072 {
21073 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21078 }
21079 /* Concat the next bit */
21082 }
21086 }
21088 /*
21089 * Get a pathname for a partial path.
21090 */
21091 static int
21096 {
21102 /* Count up the path seperators from the RHS.. so we know which part
21103 * of the path to return.
21104 */
21110 /* Need full path first (use expand_env() to remove a "~/") */
21114 else
21123 {
21124 /* Don't have a valid filename, so shorten the rest of the
21125 * path if we can. This CAN give us invalid 8.3 filenames, but
21126 * there's not a lot of point in guessing what it might be.
21127 */
21131 }
21133 /* Count the paths backward to find the beginning of the desired string. */
21135 {
21136 #ifdef FEAT_MBYTE
21139 #endif
21141 {
21144 else
21145 sepcount --;
21146 }
21147 }
21149 {
21153 else
21155 }
21156 else
21159 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21166 }
21169 /*
21170 * Adjust a filename, according to a string of modifiers.
21171 * *fnamep must be NUL terminated when called. When returning, the length is
21172 * determined by *fnamelen.
21173 * Returns valid flags.
21174 * When there is an error, *fnamep is set to NULL.
21175 */
21176 int
21183 {
21190 #ifdef WIN3264
21192 #endif
21194 repeat:
21195 /* ":p" - full path/file_name */
21197 {
21203 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21205 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21207 # ifdef BACKSLASH_IN_FILENAME
21209 # endif
21212 #endif
21213 )
21214 {
21220 }
21222 /* When "/." or "/.." is used: force expansion to get rid of it. */
21224 {
21232 }
21234 /* FullName_save() is slow, don't use it when not needed. */
21236 {
21242 }
21244 /* Append a path separator to a directory. */
21246 {
21247 /* Make room for one or two extra characters. */
21254 }
21255 }
21257 /* ":." - path relative to the current directory */
21258 /* ":~" - path relative to the home directory */
21259 /* ":8" - shortname path - postponed till after */
21262 {
21265 {
21266 #ifdef WIN3264
21268 #endif
21270 }
21272 /* Need full path first (use expand_env() to remove a "~/") */
21274 {
21277 else
21279 }
21280 else
21286 {
21288 {
21292 {
21295 {
21299 }
21300 }
21301 }
21302 else
21303 {
21305 /* Only replace it when it starts with '~' */
21307 {
21310 {
21314 }
21315 }
21316 }
21318 }
21319 }
21324 /* ":h" - head, remove "/file_name", can be repeated */
21325 /* Don't remove the first "/" or "c:\" */
21327 {
21334 #ifdef VMS
21337 #endif
21339 {
21340 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21347 }
21348 else
21349 {
21352 }
21353 }
21355 /* ":8" - shortname */
21357 {
21359 #ifdef WIN3264
21361 #endif
21362 }
21364 #ifdef WIN3264
21365 /* Check shortname after we have done 'heads' and before we do 'tails'
21366 */
21368 {
21370 /* Copy the string if it is shortened by :h */
21372 {
21378 }
21380 /* Split into two implementations - makes it easier. First is where
21381 * there isn't a full name already, second is where there is.
21382 */
21384 {
21387 }
21388 else
21389 {
21392 /* Simple case, already have the full-name
21393 * Nearly always shorter, so try first time. */
21399 {
21400 /* Couldn't find the filename.. search the paths.
21401 */
21405 }
21407 }
21408 }
21411 /* ":t" - tail, just the basename */
21413 {
21417 }
21419 /* ":e" - extension, can be repeated */
21420 /* ":r" - root, without extension, can be repeated */
21423 {
21424 /* find a '.' in the tail:
21425 * - for second :e: before the current fname
21426 * - otherwise: The last '.'
21427 */
21430 else
21436 {
21438 {
21441 #ifdef VMS
21442 /* cut version from the extension */
21449 #endif
21450 }
21453 }
21455 {
21458 }
21460 }
21462 /* ":s?pat?foo?" - substitute */
21463 /* ":gs?pat?foo?" - global substitute */
21467 {
21478 {
21481 }
21485 {
21486 /* find end of pattern */
21489 {
21492 {
21494 /* find end of substitution */
21497 {
21501 {
21505 {
21511 }
21512 }
21515 }
21517 }
21518 }
21519 /* after using ":s", repeat all the modifiers */
21522 }
21523 }
21526 }
21528 /*
21529 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21530 * "flags" can be "g" to do a global substitute.
21531 * Returns an allocated string, NULL for error.
21532 */
21533 char_u *
21539 {
21541 regmatch_T regmatch;
21545 garray_T ga;
21549 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21560 {
21563 {
21564 /*
21565 * Get some space for a temporary buffer to do the substitution
21566 * into. It will contain:
21567 * - The text up to where the match is.
21568 * - The substituted text.
21569 * - The text after the match.
21570 */
21574 {
21577 }
21579 /* copy the text up to where the match is */
21582 /* add the substituted text */
21586 /* avoid getting stuck on a match with an empty string */
21588 {
21593 }
21594 else
21595 {
21599 }
21602 }
21608 }
21615 }