| blob | ca9e2dcc13ef94c5238196bf98d8de89f4230a21 |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #ifdef AMIGA
21 #endif
23 #ifdef MACOS
25 #endif
27 #ifdef HAVE_FCNTL_H
28 # include <fcntl.h>
29 #endif
31 #if defined(FEAT_EVAL) || defined(PROTO)
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
111 /*
112 * All user-defined global variables are stored in dictionary "globvardict".
113 * "globvars_var" is the variable that is used for "g:".
114 */
117 #define globvarht globvardict.dv_hashtab
119 /*
120 * Old Vim variables such as "v:version" are also available without the "v:".
121 * Also in functions. We need a special hashtable for them.
122 */
125 /*
126 * When recursively copying lists and dicts we need to remember which ones we
127 * have done to avoid endless recursiveness. This unique ID is used for that.
128 */
131 /*
132 * Array to hold the hashtab with variables local to each sourced script.
133 * Each item holds a variable (nameless) that points to the dict_T.
134 */
136 {
137 dictitem_T sv_var;
138 dict_T sv_dict;
142 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
143 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
147 /* Values for trans_function_name() argument: */
151 /*
152 * Structure to hold info for a user function.
153 */
156 struct ufunc
157 {
163 #ifdef FEAT_PROFILE
165 /* profiling the function as a whole */
170 /* profiling the function per line */
179 #endif
181 used for s: variables */
184 start with <SNR>123_ (<SNR> is K_SPECIAL
185 KS_EXTRA KE_SNR) */
186 };
188 /* function flags */
193 /*
194 * All user-defined functions are found in this hashtable.
195 */
198 /* The names of packages that once were loaded are remembered. */
201 /* list heads for garbage collection */
205 /* From user function to hashitem and back. */
207 #define UF2HIKEY(fp) ((fp)->uf_name)
208 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
209 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
211 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
212 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
218 /* structure to hold info for a function that is currently being executed. */
221 struct funccall_S
222 {
227 {
241 #ifdef FEAT_PROFILE
243 #endif
245 };
247 /*
248 * Info used by a ":for" loop.
249 */
251 {
258 /*
259 * Struct used by trans_function_name()
260 */
262 {
269 /*
270 * Array to hold the value of v: variables.
271 * The value is in a dictitem, so that it can also be used in the v: scope.
272 * The reason to use this table anyway is for very quick access to the
273 * variables with the VV_ defines.
274 */
277 /* values for vv_flags: */
282 #define VV_NAME(s, t) s, {{t}}, {0}
284 static struct vimvar
285 {
291 {
292 /*
293 * The order here must match the VV_ defines in vim.h!
294 * Initializing a union does not work, leave tv.vval empty to get zero's.
295 */
348 };
350 /* shorthand */
351 #define vv_type vv_di.di_tv.v_type
352 #define vv_nr vv_di.di_tv.vval.v_number
353 #define vv_str vv_di.di_tv.vval.v_string
354 #define vv_tv vv_di.di_tv
356 /*
357 * The v: variables are stored in dictionary "vimvardict".
358 * "vimvars_var" is the variable that is used for the "l:" scope.
359 */
362 #define vimvarht vimvardict.dv_hashtab
366 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
367 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
368 #endif
369 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
376 #ifdef FEAT_WINDOWS
378 #endif
383 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
385 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
387 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
455 static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
456 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
480 #if defined(FEAT_INS_EXPAND)
484 #endif
590 #ifdef vim_mkdir
592 #endif
639 #ifdef HAVE_STRFTIME
641 #endif
684 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
687 valid character */
688 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
708 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
723 #ifdef FEAT_PROFILE
725 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
726 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
727 static int
728 # ifdef __BORLANDC__
729 _RTLENTRYF
730 # endif
732 static int
733 # ifdef __BORLANDC__
734 _RTLENTRYF
735 # endif
737 #endif
744 static void call_user_func __ARGS((ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rettv, linenr_T firstline, linenr_T lastline, dict_T *selfdict));
752 /* Character used as separated in autoload function/variable names. */
755 /*
756 * Initialize the global and v: variables.
757 */
758 void
760 {
770 {
777 else
780 /* add to v: scope dict, unless the value is not always available */
784 /* add to compat scope dict */
786 }
787 }
789 #if defined(EXITFREE) || defined(PROTO)
790 void
792 {
797 {
800 {
803 }
804 }
808 /* script-local variables */
814 /* global variables */
817 /* functions */
821 /* autoloaded script names */
824 /* unreferenced lists and dicts */
826 }
827 #endif
829 /*
830 * Return the name of the executed function.
831 */
832 char_u *
835 {
837 }
839 /*
840 * Return the address holding the next breakpoint line for a funccall cookie.
841 */
842 linenr_T *
845 {
847 }
849 /*
850 * Return the address holding the debug tick for a funccall cookie.
851 */
855 {
857 }
859 /*
860 * Return the nesting level for a funccall cookie.
861 */
862 int
865 {
867 }
869 /* pointer to funccal for currently active function */
872 /*
873 * Return TRUE when a function was ended by a ":return" command.
874 */
875 int
877 {
879 }
882 /*
883 * Set an internal variable to a string value. Creates the variable if it does
884 * not already exist.
885 */
886 void
890 {
896 {
899 {
902 }
903 }
904 }
911 /*
912 * Start recording command output to a variable
913 * Returns OK if successfully completed the setup. FAIL otherwise.
914 */
915 int
919 {
922 typval_T tv;
924 /* Make sure a valid variable name is specified */
926 {
929 }
937 {
940 }
942 /* The output is stored in growarray "redir_ga" until redirection ends. */
945 /* Parse the variable name (can be a dict or list entry). */
947 FNE_CHECK_START);
949 {
951 /* Trailing characters are present after the variable name */
953 else
957 }
959 /* check if we can write to the variable: set it to or append an empty
960 * string */
967 else
972 {
975 }
977 {
978 /* Dictionary item was created, don't do it again. */
981 }
984 }
986 /*
987 * Append "value[value_len]" to the variable set by var_redir_start().
988 * The actual appending is postponed until redirection ends, because the value
989 * appended may in fact be the string we write to, changing it may cause freed
990 * memory to be used:
991 * :redir => foo
992 * :let foo
993 * :redir END
994 */
995 void
999 {
1007 else
1011 {
1014 }
1015 else
1017 }
1019 /*
1020 * Stop redirecting command output to a variable.
1021 */
1022 void
1024 {
1025 typval_T tv;
1028 {
1029 /* Append the trailing NUL. */
1032 /* Assign the text to the variable. */
1041 }
1044 }
1046 # if defined(FEAT_MBYTE) || defined(PROTO)
1047 int
1053 {
1070 }
1071 # endif
1073 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1074 int
1078 {
1089 {
1092 }
1094 }
1095 # endif
1097 # if defined(FEAT_DIFF) || defined(PROTO)
1098 void
1103 {
1113 }
1115 void
1120 {
1130 }
1131 # endif
1133 /*
1134 * Top level evaluation function, returning a boolean.
1135 * Sets "error" to TRUE if there was an error.
1136 * Return TRUE or FALSE.
1137 */
1138 int
1144 {
1145 typval_T tv;
1152 else
1153 {
1156 {
1159 }
1160 }
1165 }
1167 /*
1168 * Top level evaluation function, returning a string. If "skip" is TRUE,
1169 * only parsing to "nextcmd" is done, without reporting errors. Return
1170 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1171 */
1172 char_u *
1177 {
1178 typval_T tv;
1185 else
1186 {
1189 }
1194 }
1196 /*
1197 * Skip over an expression at "*pp".
1198 * Return FAIL for an error, OK otherwise.
1199 */
1200 int
1203 {
1204 typval_T rettv;
1208 }
1210 /*
1211 * Top level evaluation function, returning a string.
1212 * Return pointer to allocated memory, or NULL for failure.
1213 */
1214 char_u *
1219 {
1220 typval_T tv;
1222 garray_T ga;
1226 else
1227 {
1229 {
1234 }
1235 else
1238 }
1241 }
1243 /*
1244 * Call eval_to_string() without using current local variables and using
1245 * textlock. When "use_sandbox" is TRUE use the sandbox.
1246 */
1247 char_u *
1252 {
1266 }
1268 /*
1269 * Top level evaluation function, returning a number.
1270 * Evaluates "expr" silently.
1271 * Returns -1 for an error.
1272 */
1273 int
1276 {
1277 typval_T rettv;
1285 else
1286 {
1289 }
1293 }
1295 /*
1296 * Prepare v: variable "idx" to be used.
1297 * Save the current typeval in "save_tv".
1298 * When not used yet add the variable to the v: hashtable.
1299 */
1300 static void
1304 {
1308 }
1310 /*
1311 * Restore v: variable "idx" to typeval "save_tv".
1312 * When no longer defined, remove the variable from the v: hashtable.
1313 */
1314 static void
1318 {
1323 {
1327 else
1329 }
1330 }
1332 #if defined(FEAT_SPELL) || defined(PROTO)
1333 /*
1334 * Evaluate an expression to a list with suggestions.
1335 * For the "expr:" part of 'spellsuggest'.
1336 */
1337 list_T *
1341 {
1342 typval_T save_val;
1343 typval_T rettv;
1347 /* Set "v:val" to the bad word. */
1355 {
1358 else
1360 }
1367 }
1369 /*
1370 * "list" is supposed to contain two items: a word and a number. Return the
1371 * word in "pp" and the number as the return value.
1372 * Return -1 if anything isn't right.
1373 * Used to get the good word and score from the eval_spell_expr() result.
1374 */
1375 int
1379 {
1391 }
1392 #endif
1394 /*
1395 * Top level evaluation function.
1396 * Returns an allocated typval_T with the result.
1397 * Returns NULL when there is an error.
1398 */
1399 typval_T *
1403 {
1408 {
1411 }
1414 }
1417 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1418 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1419 /*
1420 * Call some vimL function and return the result in "*rettv".
1421 * Uses argv[argc] for the function arguments.
1422 * Returns OK or FAIL.
1423 */
1424 static int
1431 {
1445 {
1446 /* Pass a NULL or empty argument as an empty string */
1448 {
1452 }
1454 /* Recognize a number argument, the others must be strings. */
1457 {
1460 }
1461 else
1462 {
1465 }
1466 }
1469 {
1472 }
1479 {
1482 }
1489 }
1491 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1492 /*
1493 * Call vimL function "func" and return the result as a string.
1494 * Returns NULL when calling the function fails.
1495 * Uses argv[argc] for the function arguments.
1496 */
1503 {
1504 typval_T rettv;
1513 }
1514 # endif
1516 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1517 /*
1518 * Call vimL function "func" and return the result as a number.
1519 * Returns -1 when calling the function fails.
1520 * Uses argv[argc] for the function arguments.
1521 */
1522 long
1528 {
1529 typval_T rettv;
1538 }
1539 # endif
1541 /*
1542 * Call vimL function "func" and return the result as a list
1543 * Uses argv[argc] for the function arguments.
1544 */
1551 {
1552 typval_T rettv;
1558 {
1561 }
1564 }
1565 #endif
1568 /*
1569 * Save the current function call pointer, and set it to NULL.
1570 * Used when executing autocommands and for ":source".
1571 */
1574 {
1579 }
1581 void
1584 {
1588 }
1590 #if defined(FEAT_PROFILE) || defined(PROTO)
1591 /*
1592 * Prepare profiling for entering a child or something else that is not
1593 * counted for the script/function itself.
1594 * Should always be called in pair with prof_child_exit().
1595 */
1596 void
1599 {
1605 }
1607 /*
1608 * Take care of time spent in a child.
1609 * Should always be called after prof_child_enter().
1610 */
1611 void
1614 {
1618 {
1623 }
1625 }
1626 #endif
1629 #ifdef FEAT_FOLDING
1630 /*
1631 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1632 * it in "*cp". Doesn't give error messages.
1633 */
1634 int
1638 {
1639 typval_T tv;
1643 OPT_LOCAL);
1652 else
1653 {
1654 /* If the result is a number, just return the number. */
1659 else
1660 {
1661 /* If the result is a string, check if there is a non-digit before
1662 * the number. */
1667 }
1669 }
1676 }
1677 #endif
1679 /*
1680 * ":let" list all variable values
1681 * ":let var1 var2" list variable values
1682 * ":let var = expr" assignment command.
1683 * ":let var += expr" assignment command.
1684 * ":let var -= expr" assignment command.
1685 * ":let var .= expr" assignment command.
1686 * ":let [var1, var2] = expr" unpack list.
1687 */
1688 void
1691 {
1694 typval_T rettv;
1709 {
1710 /*
1711 * ":let" without "=": list variables
1712 */
1716 /* ":let var1 var2" */
1719 {
1720 /* ":let" */
1724 #ifdef FEAT_WINDOWS
1726 #endif
1730 }
1732 }
1733 else
1734 {
1738 {
1741 }
1748 {
1752 }
1754 {
1756 op);
1758 }
1759 }
1760 }
1762 /*
1763 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1764 * Handles both "var" with any type and "[var, var; var]" with a list type.
1765 * When "nextchars" is not NULL it points to a string with characters that
1766 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1767 * or concatenate.
1768 * Returns OK or FAIL;
1769 */
1770 static int
1778 {
1783 typval_T ltv;
1786 {
1787 /*
1788 * ":let var = expr" or ":for var in list"
1789 */
1793 }
1795 /*
1796 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1797 */
1799 {
1802 }
1806 {
1809 }
1811 {
1814 }
1818 {
1827 {
1828 /* Put the rest of the list (may be empty) in the var after ';'.
1829 * Create a new list for this. */
1834 {
1837 }
1850 }
1852 {
1855 }
1856 }
1859 }
1861 /*
1862 * Skip over assignable variable "var" or list of variables "[var, var]".
1863 * Used for ":let varvar = expr" and ":for varvar in expr".
1864 * For "[var, var]" increment "*var_count" for each variable.
1865 * for "[var, var; var]" set "semicolon".
1866 * Return NULL for an error.
1867 */
1873 {
1877 {
1878 /* "[var, var]": find the matching ']'. */
1881 {
1885 {
1888 }
1895 {
1897 {
1900 }
1902 }
1904 {
1907 }
1908 }
1910 }
1911 else
1913 }
1915 /*
1916 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1917 * l[idx].
1918 */
1922 {
1927 }
1929 /*
1930 * List variables for hashtab "ht" with prefix "prefix".
1931 * If "empty" is TRUE also list NULL strings as empty strings.
1932 */
1933 static void
1939 {
1946 {
1948 {
1954 }
1955 }
1956 }
1958 /*
1959 * List global variables.
1960 */
1961 static void
1964 {
1966 }
1968 /*
1969 * List buffer variables.
1970 */
1971 static void
1974 {
1983 }
1985 /*
1986 * List window variables.
1987 */
1988 static void
1991 {
1994 }
1996 #ifdef FEAT_WINDOWS
1997 /*
1998 * List tab page variables.
1999 */
2000 static void
2003 {
2006 }
2007 #endif
2009 /*
2010 * List Vim variables.
2011 */
2012 static void
2015 {
2017 }
2019 /*
2020 * List script-local variables, if there is a script.
2021 */
2022 static void
2025 {
2029 }
2031 /*
2032 * List function variables, if there is a function.
2033 */
2034 static void
2037 {
2041 }
2043 /*
2044 * List variables in "arg".
2045 */
2051 {
2058 typval_T tv;
2061 {
2063 {
2066 {
2070 }
2071 }
2072 else
2073 {
2074 /* get_name_len() takes care of expanding curly braces */
2078 {
2079 /* This is mainly to keep test 49 working: when expanding
2080 * curly braces fails overrule the exception error message. */
2082 {
2086 }
2088 }
2089 else
2090 {
2095 else
2096 {
2097 /* handle d.key, l[idx], f(expr) */
2101 else
2102 {
2104 {
2106 {
2110 #ifdef FEAT_WINDOWS
2112 #endif
2118 }
2119 }
2120 else
2121 {
2134 first);
2137 }
2139 }
2140 }
2141 }
2144 }
2147 }
2150 }
2152 /*
2153 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2154 * Returns a pointer to the char just after the var name.
2155 * Returns NULL if there is an error.
2156 */
2164 {
2173 /*
2174 * ":let $VAR = expr": Set environment variable.
2175 */
2177 {
2178 /* Find the end of the name. */
2184 else
2185 {
2191 else
2192 {
2197 {
2202 {
2206 }
2207 }
2209 {
2219 }
2222 }
2223 }
2224 }
2226 /*
2227 * ":let &option = expr": Set option value.
2228 * ":let &l:option = expr": Set local option value.
2229 * ":let &g:option = expr": Set global option value.
2230 */
2232 {
2233 /* Find the end of the name. */
2238 else
2239 {
2252 {
2258 else
2259 {
2261 {
2264 else
2266 }
2268 {
2272 }
2273 }
2274 }
2276 {
2279 }
2282 }
2283 }
2285 /*
2286 * ":let @r = expr": Set register contents.
2287 */
2289 {
2296 else
2297 {
2303 {
2306 {
2309 }
2310 }
2312 {
2315 }
2317 }
2318 }
2320 /*
2321 * ":let var = expr": Set internal variable.
2322 * ":let {expr} = expr": Idem, name made with curly braces
2323 */
2325 {
2326 lval_T lv;
2330 {
2333 else
2334 {
2337 }
2338 }
2340 }
2342 else
2346 }
2348 /*
2349 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2350 */
2351 static int
2354 {
2356 {
2359 }
2361 }
2363 /*
2364 * Get an lval: variable, Dict item or List item that can be assigned a value
2365 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2366 * "name.key", "name.key[expr]" etc.
2367 * Indexing only works if "name" is an existing List or Dictionary.
2368 * "name" points to the start of the name.
2369 * If "rettv" is not NULL it points to the value to be assigned.
2370 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2371 * wrong; must end in space or cmd separator.
2372 *
2373 * Returns a pointer to just after the name, including indexes.
2374 * When an evaluation error occurs "lp->ll_name" is NULL;
2375 * Returns NULL for a parsing error. Still need to free items in "lp"!
2376 */
2386 {
2391 typval_T var1;
2392 typval_T var2;
2399 /* Clear everything in "lp". */
2403 {
2404 /* When skipping just find the end of the name. */
2407 }
2409 /* Find the end of the name. */
2412 {
2413 /* Don't expand the name when we already know there is an error. */
2416 {
2419 }
2423 {
2424 /* Report an invalid expression in braces, unless the
2425 * expression evaluation has been cancelled due to an
2426 * aborting error, an interrupt, or an exception. */
2428 {
2432 }
2433 }
2435 }
2436 else
2439 /* Without [idx] or .key we are done. */
2452 /*
2453 * Loop until no more [idx] or .key is following.
2454 */
2457 {
2461 {
2465 }
2467 {
2471 }
2475 {
2478 ;
2480 {
2484 }
2486 }
2487 else
2488 {
2489 /* Get the index [expr] or the first index [expr: ]. */
2493 else
2494 {
2499 {
2500 /* not a number or string */
2503 }
2504 }
2506 /* Optionally get the second index [ :expr]. */
2508 {
2510 {
2516 }
2519 {
2525 }
2529 else
2530 {
2533 {
2537 }
2539 {
2540 /* not a number or string */
2545 }
2546 }
2548 }
2549 else
2553 {
2561 }
2563 /* Skip to past ']'. */
2565 }
2568 {
2570 {
2571 /* "[key]": get key from "var1" */
2574 {
2579 }
2580 }
2585 {
2586 /* Key does not exist in dict: may need to add it. */
2588 {
2594 }
2597 else
2604 }
2608 }
2609 else
2610 {
2611 /*
2612 * Get the number and item for the only or first index of the List.
2613 */
2616 else
2617 {
2620 }
2625 {
2627 {
2630 }
2631 }
2633 {
2637 }
2639 /*
2640 * May need to find the item or absolute index for the second
2641 * index of a range.
2642 * When no index given: "lp->ll_empty2" is TRUE.
2643 * Otherwise "lp->ll_n2" is set to the second index.
2644 */
2646 {
2650 {
2655 }
2657 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2662 }
2665 }
2666 }
2669 }
2671 /*
2672 * Clear lval "lp" that was filled by get_lval().
2673 */
2674 static void
2677 {
2680 }
2682 /*
2683 * Set a variable that was parsed by get_lval() to "rettv".
2684 * "endp" points to just after the parsed name.
2685 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2686 */
2687 static void
2694 {
2700 {
2702 {
2706 {
2707 typval_T tv;
2709 /* handle +=, -= and .= */
2712 {
2716 }
2717 }
2718 else
2721 }
2722 }
2726 ;
2728 {
2729 /*
2730 * Assign the List values to the list items.
2731 */
2733 {
2736 else
2737 {
2740 }
2745 {
2746 /* Need to add an empty item. */
2748 {
2751 }
2752 }
2755 }
2762 }
2763 else
2764 {
2765 /*
2766 * Assign to a List or Dictionary item.
2767 */
2769 {
2771 {
2774 }
2776 /* Need to add an item to the Dictionary. */
2781 {
2784 }
2786 }
2788 {
2791 }
2792 else
2795 /*
2796 * Assign the value to the variable or list item.
2797 */
2800 else
2801 {
2805 }
2806 }
2807 }
2809 /*
2810 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2811 * Returns OK or FAIL.
2812 */
2813 static int
2818 {
2823 /* Can't do anything with a Funcref or a Dict on the right. */
2825 {
2827 {
2835 /* List += List */
2845 {
2846 /* nr += nr or nr -= nr*/
2850 else
2855 }
2856 else
2857 {
2858 /* str .= str */
2864 }
2866 }
2867 }
2871 }
2873 /*
2874 * Add a watcher to a list.
2875 */
2876 static void
2880 {
2883 }
2885 /*
2886 * Remove a watcher from a list.
2887 * No warning when it isn't found...
2888 */
2889 static void
2893 {
2898 {
2900 {
2903 }
2905 }
2906 }
2908 /*
2909 * Just before removing an item from a list: advance watchers to the next
2910 * item.
2911 */
2912 static void
2916 {
2922 }
2924 /*
2925 * Evaluate the expression used in a ":for var in expr" command.
2926 * "arg" points to "var".
2927 * Set "*errp" to TRUE for an error, FALSE otherwise;
2928 * Return a pointer that holds the info. Null when there is an error.
2929 */
2936 {
2939 typval_T tv;
2954 {
2957 }
2962 {
2965 {
2968 {
2971 }
2972 else
2973 {
2974 /* No need to increment the refcount, it's already set for the
2975 * list being used in "tv". */
2979 }
2980 }
2981 }
2986 }
2988 /*
2989 * Use the first item in a ":for" list. Advance to the next.
2990 * Assign the values to the variable (list). "arg" points to the first one.
2991 * Return TRUE when a valid item was found, FALSE when at end of list or
2992 * something wrong.
2993 */
2994 int
2998 {
3006 else
3007 {
3011 }
3013 }
3015 /*
3016 * Free the structure used to store info used by ":for".
3017 */
3018 void
3021 {
3025 {
3028 }
3030 }
3032 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3034 void
3038 cmdidx_T cmdidx;
3039 {
3045 {
3048 {
3049 /* ":let var1 var2 ...": find last space. */
3051 {
3056 }
3058 }
3059 }
3060 else
3065 {
3068 {
3071 {
3075 }
3077 {
3082 }
3083 }
3085 {
3086 /* environment variable */
3088 }
3090 {
3093 }
3097 {
3098 /* Function name can start with "<SNR>" */
3100 }
3102 {
3104 {
3109 }
3111 {
3112 /* Trick: '' is like stopping and starting a literal string. */
3116 }
3118 {
3120 {
3123 }
3124 else
3126 }
3127 else
3129 }
3130 else
3131 /* Doesn't look like something valid, expand as an expression
3132 * anyway. */
3138 }
3140 }
3144 /*
3145 * ":1,25call func(arg1, arg2)" function call.
3146 */
3147 void
3150 {
3156 typval_T rettv;
3157 linenr_T lnum;
3160 funcdict_T fudi;
3164 {
3165 /* Still need to give an error message for missing key. */
3168 }
3172 /* Increase refcount on dictionary, it could get deleted when evaluating
3173 * the arguments. */
3177 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3181 /* Skip white space to allow ":call func ()". Not good, but required for
3182 * backward compatibility. */
3187 {
3190 }
3192 /*
3193 * When skipping, evaluate the function once, to find the end of the
3194 * arguments.
3195 * When the function takes a range, this is discovered after the first
3196 * call, and the loop is broken.
3197 */
3199 {
3202 }
3203 else
3206 {
3208 {
3211 }
3216 {
3219 }
3221 /* Handle a function returning a Funcref, Dictionary or List. */
3223 {
3226 }
3232 /* Stop when immediately aborting on error, or when an interrupt
3233 * occurred or an exception was thrown but not caught.
3234 * get_func_tv() returned OK, so that the check for trailing
3235 * characters below is executed. */
3238 }
3243 {
3244 /* Check for trailing illegal characters and a following command. */
3246 {
3249 }
3250 else
3252 }
3254 end:
3257 }
3259 /*
3260 * ":unlet[!] var1 ... " command.
3261 */
3262 void
3265 {
3267 }
3269 /*
3270 * ":lockvar" and ":unlockvar" commands
3271 */
3272 void
3275 {
3282 {
3285 }
3288 }
3290 /*
3291 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3292 */
3293 static void
3298 {
3302 lval_T lv;
3304 do
3305 {
3306 /* Parse the name and find the end. */
3308 FNE_CHECK_START);
3313 {
3315 {
3318 }
3322 }
3325 {
3327 {
3330 }
3331 else
3332 {
3336 }
3337 }
3346 }
3348 static int
3353 {
3358 {
3362 /* Normal name or expanded name. */
3368 }
3372 {
3375 /* Delete a range of List items. */
3377 {
3382 }
3383 }
3384 else
3385 {
3387 /* unlet a List item. */
3389 else
3390 /* unlet a Dictionary item. */
3392 }
3395 }
3397 /*
3398 * "unlet" a variable. Return OK if it existed, FAIL if not.
3399 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3400 */
3401 int
3405 {
3412 {
3415 {
3422 }
3423 }
3428 }
3430 /*
3431 * Lock or unlock variable indicated by "lp".
3432 * "deep" is the levels to go (-1 for unlimited);
3433 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3434 */
3435 static int
3441 {
3450 {
3454 /* Normal name or expanded name. */
3457 else
3458 {
3462 else
3463 {
3466 else
3469 }
3470 }
3472 }
3474 {
3477 /* (un)lock a range of List items. */
3479 {
3483 }
3484 }
3486 /* (un)lock a List item. */
3488 else
3489 /* un(lock) a Dictionary item. */
3493 }
3495 /*
3496 * Lock or unlock an item. "deep" is nr of levels to go.
3497 */
3498 static void
3503 {
3512 {
3515 }
3520 /* lock/unlock the item itself */
3523 else
3527 {
3530 {
3533 else
3536 /* recursive: lock/unlock the items the List contains */
3539 }
3543 {
3546 else
3549 {
3550 /* recursive: lock/unlock the items the List contains */
3553 {
3555 {
3558 }
3559 }
3560 }
3561 }
3562 }
3564 }
3566 /*
3567 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3568 * it refers to a List or Dictionary that is locked.
3569 */
3570 static int
3573 {
3581 }
3583 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3584 /*
3585 * Delete all "menutrans_" variables.
3586 */
3587 void
3589 {
3596 {
3598 {
3602 }
3603 }
3605 }
3606 #endif
3608 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3610 /*
3611 * Local string buffer for the next two functions to store a variable name
3612 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3613 * get_user_var_name().
3614 */
3621 /*
3622 * Function to concatenate a prefix and a variable name.
3623 */
3628 {
3633 {
3638 {
3641 }
3643 }
3648 }
3650 /*
3651 * Function given to ExpandGeneric() to obtain the list of user defined
3652 * (global/buffer/window/built-in) variable names.
3653 */
3654 /*ARGSUSED*/
3655 char_u *
3659 {
3663 #ifdef FEAT_WINDOWS
3665 #endif
3671 {
3673 #ifdef FEAT_WINDOWS
3675 #endif
3676 }
3678 /* Global variables */
3680 {
3683 else
3690 }
3692 /* b: variables */
3695 {
3698 else
3703 }
3705 {
3708 }
3710 /* w: variables */
3713 {
3716 else
3721 }
3723 #ifdef FEAT_WINDOWS
3724 /* t: variables */
3727 {
3730 else
3735 }
3736 #endif
3738 /* v: variables */
3746 }
3750 /*
3751 * types for expressions.
3752 */
3754 {
3766 /*
3767 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3768 * executed. The function may return OK, but the rettv will be of type
3769 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3770 */
3772 /*
3773 * Handle zero level expression.
3774 * This calls eval1() and handles error message and nextcmd.
3775 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3776 * Note: "rettv.v_lock" is not set.
3777 * Return OK or FAIL.
3778 */
3779 static int
3785 {
3792 {
3795 /*
3796 * Report the invalid expression unless the expression evaluation has
3797 * been cancelled due to an aborting error, an interrupt, or an
3798 * exception.
3799 */
3803 }
3808 }
3810 /*
3811 * Handle top level expression:
3812 * expr1 ? expr0 : expr0
3813 *
3814 * "arg" must point to the first non-white of the expression.
3815 * "arg" is advanced to the next non-white after the recognized expression.
3816 *
3817 * Note: "rettv.v_lock" is not set.
3818 *
3819 * Return OK or FAIL.
3820 */
3821 static int
3826 {
3828 typval_T var2;
3830 /*
3831 * Get the first variable.
3832 */
3837 {
3840 {
3848 }
3850 /*
3851 * Get the second variable.
3852 */
3857 /*
3858 * Check for the ":".
3859 */
3861 {
3866 }
3868 /*
3869 * Get the third variable.
3870 */
3873 {
3877 }
3880 }
3883 }
3885 /*
3886 * Handle first level expression:
3887 * expr2 || expr2 || expr2 logical OR
3888 *
3889 * "arg" must point to the first non-white of the expression.
3890 * "arg" is advanced to the next non-white after the recognized expression.
3891 *
3892 * Return OK or FAIL.
3893 */
3894 static int
3899 {
3900 typval_T var2;
3905 /*
3906 * Get the first variable.
3907 */
3911 /*
3912 * Repeat until there is no following "||".
3913 */
3917 {
3919 {
3926 }
3928 /*
3929 * Get the second variable.
3930 */
3935 /*
3936 * Compute the result.
3937 */
3939 {
3945 }
3947 {
3950 }
3951 }
3954 }
3956 /*
3957 * Handle second level expression:
3958 * expr3 && expr3 && expr3 logical AND
3959 *
3960 * "arg" must point to the first non-white of the expression.
3961 * "arg" is advanced to the next non-white after the recognized expression.
3962 *
3963 * Return OK or FAIL.
3964 */
3965 static int
3970 {
3971 typval_T var2;
3976 /*
3977 * Get the first variable.
3978 */
3982 /*
3983 * Repeat until there is no following "&&".
3984 */
3988 {
3990 {
3997 }
3999 /*
4000 * Get the second variable.
4001 */
4006 /*
4007 * Compute the result.
4008 */
4010 {
4016 }
4018 {
4021 }
4022 }
4025 }
4027 /*
4028 * Handle third level expression:
4029 * var1 == var2
4030 * var1 =~ var2
4031 * var1 != var2
4032 * var1 !~ var2
4033 * var1 > var2
4034 * var1 >= var2
4035 * var1 < var2
4036 * var1 <= var2
4037 * var1 is var2
4038 * var1 isnot var2
4039 *
4040 * "arg" must point to the first non-white of the expression.
4041 * "arg" is advanced to the next non-white after the recognized expression.
4042 *
4043 * Return OK or FAIL.
4044 */
4045 static int
4050 {
4051 typval_T var2;
4060 regmatch_T regmatch;
4064 /*
4065 * Get the first variable.
4066 */
4072 {
4084 {
4087 }
4088 else
4092 {
4095 }
4096 else
4100 {
4104 {
4107 }
4108 }
4110 }
4112 /*
4113 * If there is a comparitive operator, use it.
4114 */
4116 {
4117 /* extra question mark appended: ignore case */
4119 {
4122 }
4123 /* extra '#' appended: match case */
4125 {
4128 }
4129 /* nothing appened: use 'ignorecase' */
4130 else
4133 /*
4134 * Get the second variable.
4135 */
4138 {
4141 }
4144 {
4146 {
4147 /* For "is" a different type always means FALSE, for "notis"
4148 * it means TRUE. */
4150 }
4152 {
4154 {
4159 }
4162 {
4165 else
4170 }
4171 else
4172 {
4173 /* Compare two Lists for being equal or unequal. */
4177 }
4178 }
4181 {
4183 {
4188 }
4191 {
4194 else
4199 }
4200 else
4201 {
4202 /* Compare two Dictionaries for being equal or unequal. */
4206 }
4207 }
4210 {
4213 {
4216 else
4221 }
4222 else
4223 {
4224 /* Compare two Funcrefs for being equal or unequal. */
4228 else
4233 }
4234 }
4236 /*
4237 * If one of the two variables is a number, compare as a number.
4238 * When using "=~" or "!~", always compare as string.
4239 */
4242 {
4246 {
4256 }
4257 }
4258 else
4259 {
4264 else
4268 {
4278 /* avoid 'l' flag in 'cpoptions' */
4285 {
4290 }
4295 }
4296 }
4301 }
4302 }
4305 }
4307 /*
4308 * Handle fourth level expression:
4309 * + number addition
4310 * - number subtraction
4311 * . string concatenation
4312 *
4313 * "arg" must point to the first non-white of the expression.
4314 * "arg" is advanced to the next non-white after the recognized expression.
4315 *
4316 * Return OK or FAIL.
4317 */
4318 static int
4323 {
4324 typval_T var2;
4325 typval_T var3;
4332 /*
4333 * Get the first variable.
4334 */
4338 /*
4339 * Repeat computing, until no '+', '-' or '.' is following.
4340 */
4342 {
4348 {
4349 /* For "list + ...", an illegal use of the first operand as
4350 * a number cannot be determined before evaluating the 2nd
4351 * operand: if this is also a list, all is ok.
4352 * For "something . ...", "something - ..." or "non-list + ...",
4353 * we know that the first operand needs to be a string or number
4354 * without evaluating the 2nd operand. So check before to avoid
4355 * side effects after an error. */
4357 {
4360 }
4361 }
4363 /*
4364 * Get the second variable.
4365 */
4368 {
4371 }
4374 {
4375 /*
4376 * Compute the result.
4377 */
4379 {
4383 {
4387 }
4392 }
4395 {
4396 /* concatenate Lists */
4399 {
4403 }
4406 }
4407 else
4408 {
4413 {
4414 /* This can only happen for "list + non-list".
4415 * For "non-list + ..." or "something - ...", we returned
4416 * before evaluating the 2nd operand. */
4419 }
4422 {
4426 }
4430 else
4434 }
4436 }
4437 }
4439 }
4441 /*
4442 * Handle fifth level expression:
4443 * * number multiplication
4444 * / number division
4445 * % number modulo
4446 *
4447 * "arg" must point to the first non-white of the expression.
4448 * "arg" is advanced to the next non-white after the recognized expression.
4449 *
4450 * Return OK or FAIL.
4451 */
4452 static int
4457 {
4458 typval_T var2;
4463 /*
4464 * Get the first variable.
4465 */
4469 /*
4470 * Repeat computing, until no '*', '/' or '%' is following.
4471 */
4473 {
4479 {
4484 }
4485 else
4488 /*
4489 * Get the second variable.
4490 */
4496 {
4502 /*
4503 * Compute the result.
4504 */
4508 {
4511 else
4513 }
4514 else
4515 {
4518 else
4520 }
4523 }
4524 }
4527 }
4529 /*
4530 * Handle sixth level expression:
4531 * number number constant
4532 * "string" string constant
4533 * 'string' literal string constant
4534 * &option-name option value
4535 * @r register contents
4536 * identifier variable value
4537 * function() function call
4538 * $VAR environment variable
4539 * (expression) nested expression
4540 * [expr, expr] List
4541 * {key: val, key: val} Dictionary
4542 *
4543 * Also handle:
4544 * ! in front logical NOT
4545 * - in front unary minus
4546 * + in front unary plus (ignored)
4547 * trailing [] subscript in String or List
4548 * trailing .name entry in Dictionary
4549 *
4550 * "arg" must point to the first non-white of the expression.
4551 * "arg" is advanced to the next non-white after the recognized expression.
4552 *
4553 * Return OK or FAIL.
4554 */
4555 static int
4560 {
4569 /*
4570 * Initialise variable so that clear_tv() can't mistake this for a
4571 * string and free a string that isn't there.
4572 */
4575 /*
4576 * Skip '!' and '-' characters. They are handled later.
4577 */
4584 {
4585 /*
4586 * Number constant.
4587 */
4601 {
4604 }
4607 /*
4608 * String constant: "string".
4609 */
4613 /*
4614 * Literal string constant: 'str''ing'.
4615 */
4619 /*
4620 * List: [expr, expr]
4621 */
4625 /*
4626 * Dictionary: {key: val, key: val}
4627 */
4631 /*
4632 * Option value: &name
4633 */
4637 /*
4638 * Environment variable: $VAR.
4639 */
4643 /*
4644 * Register contents: @r.
4645 */
4648 {
4651 }
4656 /*
4657 * nested expression: (expression).
4658 */
4664 {
4668 }
4673 }
4676 {
4677 /*
4678 * Must be a variable or function name.
4679 * Can also be a curly-braces kind of name: {expr}.
4680 */
4688 else
4689 {
4691 {
4692 /* If "s" is the name of a variable of type VAR_FUNC
4693 * use its contents. */
4696 /* Invoke the function. */
4700 /* Stop the expression evaluation when immediately
4701 * aborting on error, or when an interrupt occurred or
4702 * an exception was thrown but not caught. */
4704 {
4708 }
4709 }
4712 else
4714 }
4718 }
4722 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4723 * expr(expr). */
4727 /*
4728 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4729 */
4731 {
4736 {
4739 }
4740 else
4741 {
4743 {
4749 }
4753 }
4754 }
4757 }
4759 /*
4760 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4761 * "*arg" points to the '[' or '.'.
4762 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4763 */
4764 static int
4770 {
4780 {
4784 }
4787 {
4788 /*
4789 * dict.name
4790 */
4793 ;
4797 }
4798 else
4799 {
4800 /*
4801 * something[idx]
4802 *
4803 * Get the (first) variable from inside the [].
4804 */
4811 {
4812 /* not a number or string */
4815 }
4817 /*
4818 * Get the second variable from inside the [:].
4819 */
4821 {
4827 {
4831 }
4833 {
4834 /* not a number or string */
4839 }
4840 }
4842 /* Check for the ']'. */
4844 {
4851 }
4853 }
4856 {
4859 {
4862 }
4864 {
4867 else
4868 {
4871 }
4872 }
4875 {
4881 {
4882 /* The resulting variable is a substring. If the indexes
4883 * are out of range the result is empty. */
4885 {
4889 }
4896 else
4898 }
4899 else
4900 {
4901 /* The resulting variable is a string of a single
4902 * character. If the index is too big or negative the
4903 * result is empty. */
4906 else
4908 }
4919 {
4920 /* For a range we allow invalid values and return an empty
4921 * list. A list index out of range is an error. */
4923 {
4927 }
4929 }
4931 {
4946 {
4948 {
4951 }
4953 }
4958 }
4959 else
4960 {
4964 }
4969 {
4975 }
4976 {
4980 {
4983 {
4988 }
4989 }
5003 }
5005 }
5006 }
5009 }
5011 /*
5012 * Get an option value.
5013 * "arg" points to the '&' or '+' before the option name.
5014 * "arg" is advanced to character after the option name.
5015 * Return OK or FAIL.
5016 */
5017 static int
5022 {
5032 /*
5033 * Isolate the option name and find its value.
5034 */
5037 {
5041 }
5044 {
5047 }
5055 {
5059 }
5061 {
5063 {
5066 }
5068 {
5071 }
5073 {
5076 }
5078 {
5081 }
5082 }
5090 }
5092 /*
5093 * Allocate a variable for a string constant.
5094 * Return OK or FAIL.
5095 */
5096 static int
5101 {
5106 /*
5107 * Find the end of the string, skipping backslashed characters.
5108 */
5110 {
5112 {
5114 /* A "\<x>" form occupies at least 4 characters, and produces up
5115 * to 6 characters: reserve space for 2 extra */
5118 }
5119 }
5122 {
5125 }
5127 /* If only parsing, set *arg and return here */
5129 {
5132 }
5134 /*
5135 * Copy the string into allocated memory, handling backslashed
5136 * characters.
5137 */
5145 {
5147 {
5149 {
5162 {
5168 else
5172 {
5175 }
5177 #ifdef FEAT_MBYTE
5178 /* For "\u" store the number according to
5179 * 'encoding'. */
5182 else
5183 #endif
5185 }
5188 /* octal: "\1", "\12", "\123" */
5198 {
5202 }
5206 /* Special key, e.g.: "\<C-W>" */
5209 {
5212 }
5213 /* FALLTHROUGH */
5217 }
5218 }
5219 else
5222 }
5227 }
5229 /*
5230 * Allocate a variable for a 'str''ing' constant.
5231 * Return OK or FAIL.
5232 */
5233 static int
5238 {
5243 /*
5244 * Find the end of the string, skipping ''.
5245 */
5247 {
5249 {
5254 }
5255 }
5258 {
5261 }
5263 /* If only parsing return after setting "*arg" */
5265 {
5268 }
5270 /*
5271 * Copy the string into allocated memory, handling '' to ' reduction.
5272 */
5280 {
5282 {
5286 }
5288 }
5293 }
5295 /*
5296 * Allocate a variable for a List and fill it from "*arg".
5297 * Return OK or FAIL.
5298 */
5299 static int
5304 {
5306 typval_T tv;
5310 {
5314 }
5318 {
5322 {
5325 {
5329 }
5330 else
5332 }
5337 {
5340 }
5342 }
5345 {
5347 failret:
5351 }
5355 {
5359 }
5362 }
5364 /*
5365 * Allocate an empty header for a list.
5366 * Caller should take care of the reference count.
5367 */
5368 list_T *
5370 {
5375 {
5376 /* Prepend the list to the list of lists for garbage collection. */
5382 }
5384 }
5386 /*
5387 * Allocate an empty list for a return value.
5388 * Returns OK or FAIL.
5389 */
5390 static int
5393 {
5403 }
5405 /*
5406 * Unreference a list: decrement the reference count and free it when it
5407 * becomes zero.
5408 */
5409 void
5412 {
5415 }
5417 /*
5418 * Free a list, including all items it points to.
5419 * Ignores the reference count.
5420 */
5421 void
5425 {
5428 /* Remove the list from the list of lists for garbage collection. */
5431 else
5437 {
5438 /* Remove the item before deleting it. */
5444 }
5446 }
5448 /*
5449 * Allocate a list item.
5450 */
5453 {
5455 }
5457 /*
5458 * Free a list item. Also clears the value. Does not notify watchers.
5459 */
5460 static void
5463 {
5466 }
5468 /*
5469 * Remove a list item from a List and free it. Also clears the value.
5470 */
5471 static void
5475 {
5478 }
5480 /*
5481 * Get the number of items in a list.
5482 */
5483 static long
5486 {
5490 }
5492 /*
5493 * Return TRUE when two lists have exactly the same values.
5494 */
5495 static int
5500 {
5514 }
5516 #if defined(FEAT_PYTHON) || defined(PROTO)
5517 /*
5518 * Return the dictitem that an entry in a hashtable points to.
5519 */
5520 dictitem_T *
5523 {
5525 }
5526 #endif
5528 /*
5529 * Return TRUE when two dictionaries have exactly the same key/values.
5530 */
5531 static int
5536 {
5548 {
5550 {
5557 }
5558 }
5560 }
5562 /*
5563 * Return TRUE if "tv1" and "tv2" have the same value.
5564 * Compares the items just like "==" would compare them, but strings and
5565 * numbers are different.
5566 */
5567 static int
5572 {
5580 /* Catch lists and dicts that have an endless loop by limiting
5581 * recursiveness to 1000. We guess they are equal then. */
5586 {
5611 }
5615 }
5617 /*
5618 * Locate item with index "n" in list "l" and return it.
5619 * A negative index is counted from the end; -1 is the last item.
5620 * Returns NULL when "n" is out of range.
5621 */
5626 {
5633 /* Negative index is relative to the end. */
5637 /* Check for index out of range. */
5641 /* When there is a cached index may start search from there. */
5643 {
5645 {
5646 /* closest to the start of the list */
5649 }
5651 {
5652 /* closest to the end of the list */
5655 }
5656 else
5657 {
5658 /* closest to the cached index */
5661 }
5662 }
5663 else
5664 {
5666 {
5667 /* closest to the start of the list */
5670 }
5671 else
5672 {
5673 /* closest to the end of the list */
5676 }
5677 }
5680 {
5681 /* search forward */
5684 }
5686 {
5687 /* search backward */
5690 }
5692 /* cache the used index */
5697 }
5699 /*
5700 * Get list item "l[idx]" as a number.
5701 */
5702 static long
5707 {
5712 {
5716 }
5718 }
5720 /*
5721 * Locate "item" list "l" and return its index.
5722 * Returns -1 when "item" is not in the list.
5723 */
5724 static long
5728 {
5740 }
5742 /*
5743 * Append item "item" to the end of list "l".
5744 */
5745 static void
5749 {
5751 {
5752 /* empty list */
5756 }
5757 else
5758 {
5762 }
5765 }
5767 /*
5768 * Append typval_T "tv" to the end of list "l".
5769 * Return FAIL when out of memory.
5770 */
5771 static int
5775 {
5783 }
5785 /*
5786 * Add a dictionary to a list. Used by getqflist().
5787 * Return FAIL when out of memory.
5788 */
5789 int
5793 {
5804 }
5806 /*
5807 * Make a copy of "str" and append it as an item to list "l".
5808 * When "len" >= 0 use "str[len]".
5809 * Returns FAIL when out of memory.
5810 */
5811 static int
5816 {
5830 }
5832 /*
5833 * Append "n" to list "l".
5834 * Returns FAIL when out of memory.
5835 */
5836 static int
5839 varnumber_T n;
5840 {
5851 }
5853 /*
5854 * Insert typval_T "tv" in list "l" before "item".
5855 * If "item" is NULL append at the end.
5856 * Return FAIL when out of memory.
5857 */
5858 static int
5863 {
5870 /* Append new item at end of list. */
5872 else
5873 {
5874 /* Insert new item before existing item. */
5878 {
5881 }
5882 else
5883 {
5886 }
5889 }
5891 }
5893 /*
5894 * Extend "l1" with "l2".
5895 * If "bef" is NULL append at the end, otherwise insert before this item.
5896 * Returns FAIL when out of memory.
5897 */
5898 static int
5903 {
5910 }
5912 /*
5913 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5914 * Return FAIL when out of memory.
5915 */
5916 static int
5921 {
5924 /* make a copy of the first list. */
5931 /* append all items from the second list */
5933 }
5935 /*
5936 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5937 * The refcount of the new list is set to 1.
5938 * See item_copy() for "copyID".
5939 * Returns NULL when out of memory.
5940 */
5946 {
5956 {
5958 {
5959 /* Do this before adding the items, because one of the items may
5960 * refer back to this list. */
5963 }
5966 {
5971 {
5973 {
5976 }
5977 }
5978 else
5981 }
5984 {
5987 }
5988 }
5991 }
5993 /*
5994 * Remove items "item" to "item2" from list "l".
5995 * Does not free the listitem or the value!
5996 */
5997 static void
6002 {
6005 /* notify watchers */
6007 {
6012 }
6016 else
6020 else
6023 }
6025 /*
6026 * Return an allocated string with the string representation of a list.
6027 * May return NULL.
6028 */
6033 {
6034 garray_T ga;
6041 {
6044 }
6048 }
6050 /*
6051 * Join list "l" into a string in "*gap", using separator "sep".
6052 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6053 * Return FAIL or OK.
6054 */
6055 static int
6062 {
6070 {
6073 else
6078 else
6085 }
6087 }
6089 /*
6090 * Garbage collection for lists and dictionaries.
6091 *
6092 * We use reference counts to be able to free most items right away when they
6093 * are no longer used. But for composite items it's possible that it becomes
6094 * unused while the reference count is > 0: When there is a recursive
6095 * reference. Example:
6096 * :let l = [1, 2, 3]
6097 * :let d = {9: l}
6098 * :let l[1] = d
6099 *
6100 * Since this is quite unusual we handle this with garbage collection: every
6101 * once in a while find out which lists and dicts are not referenced from any
6102 * variable.
6103 *
6104 * Here is a good reference text about garbage collection (refers to Python
6105 * but it applies to all reference-counting mechanisms):
6106 * http://python.ca/nas/python/gc/
6107 */
6109 /*
6110 * Do garbage collection for lists and dicts.
6111 * Return TRUE if some memory was freed.
6112 */
6113 int
6115 {
6124 #ifdef FEAT_WINDOWS
6126 #endif
6128 /* Only do this once. */
6133 /*
6134 * 1. Go through all accessible variables and mark all lists and dicts
6135 * with copyID.
6136 */
6137 /* script-local variables */
6141 /* buffer-local variables */
6145 /* window-local variables */
6149 #ifdef FEAT_WINDOWS
6150 /* tabpage-local variables */
6153 #endif
6155 /* global variables */
6158 /* function-local variables */
6160 {
6163 }
6165 /*
6166 * 2. Go through the list of dicts and free items without the copyID.
6167 */
6170 {
6171 /* Free the Dictionary and ordinary items it contains, but don't
6172 * recurse into Lists and Dictionaries, they will be in the list
6173 * of dicts or list of lists. */
6177 /* restart, next dict may also have been freed */
6179 }
6180 else
6183 /*
6184 * 3. Go through the list of lists and free items without the copyID.
6185 * But don't free a list that has a watcher (used in a for loop), these
6186 * are not referenced anywhere.
6187 */
6190 {
6191 /* Free the List and ordinary items it contains, but don't recurse
6192 * into Lists and Dictionaries, they will be in the list of dicts
6193 * or list of lists. */
6197 /* restart, next list may also have been freed */
6199 }
6200 else
6204 }
6206 /*
6207 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6208 */
6209 static void
6213 {
6220 {
6223 }
6224 }
6226 /*
6227 * Mark all lists and dicts referenced through list "l" with "copyID".
6228 */
6229 static void
6233 {
6238 }
6240 /*
6241 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6242 */
6243 static void
6247 {
6252 {
6256 {
6257 /* Didn't see this dict yet. */
6260 }
6266 {
6267 /* Didn't see this list yet. */
6270 }
6272 }
6274 }
6276 /*
6277 * Allocate an empty header for a dictionary.
6278 */
6279 dict_T *
6281 {
6286 {
6287 /* Add the list to the list of dicts for garbage collection. */
6298 }
6300 }
6302 /*
6303 * Unreference a Dictionary: decrement the reference count and free it when it
6304 * becomes zero.
6305 */
6306 static void
6309 {
6312 }
6314 /*
6315 * Free a Dictionary, including all items it contains.
6316 * Ignores the reference count.
6317 */
6318 static void
6322 {
6327 /* Remove the dict from the list of dicts for garbage collection. */
6330 else
6335 /* Lock the hashtab, we don't want it to resize while freeing items. */
6339 {
6341 {
6342 /* Remove the item before deleting it, just in case there is
6343 * something recursive causing trouble. */
6351 }
6352 }
6355 }
6357 /*
6358 * Allocate a Dictionary item.
6359 * The "key" is copied to the new item.
6360 * Note that the value of the item "di_tv" still needs to be initialized!
6361 * Returns NULL when out of memory.
6362 */
6366 {
6371 {
6374 }
6376 }
6378 /*
6379 * Make a copy of a Dictionary item.
6380 */
6384 {
6390 {
6394 }
6396 }
6398 /*
6399 * Remove item "item" from Dictionary "dict" and free it.
6400 */
6401 static void
6405 {
6411 else
6414 }
6416 /*
6417 * Free a dict item. Also clears the value.
6418 */
6419 static void
6422 {
6425 }
6427 /*
6428 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6429 * The refcount of the new dict is set to 1.
6430 * See item_copy() for "copyID".
6431 * Returns NULL when out of memory.
6432 */
6438 {
6449 {
6451 {
6454 }
6457 {
6459 {
6466 {
6469 {
6472 }
6473 }
6474 else
6477 {
6480 }
6481 }
6482 }
6486 {
6489 }
6490 }
6493 }
6495 /*
6496 * Add item "item" to Dictionary "d".
6497 * Returns FAIL when out of memory and when key already existed.
6498 */
6499 static int
6503 {
6505 }
6507 /*
6508 * Add a number or string entry to dictionary "d".
6509 * When "str" is NULL use number "nr", otherwise use "str".
6510 * Returns FAIL when out of memory and when key already exists.
6511 */
6512 int
6518 {
6526 {
6529 }
6530 else
6531 {
6534 }
6536 {
6539 }
6541 }
6543 /*
6544 * Get the number of items in a Dictionary.
6545 */
6546 static long
6549 {
6553 }
6555 /*
6556 * Find item "key[len]" in Dictionary "d".
6557 * If "len" is negative use strlen(key).
6558 * Returns NULL when not found.
6559 */
6565 {
6566 #define AKEYLEN 200
6575 {
6579 }
6580 else
6581 {
6582 /* Avoid a malloc/free by using buf[]. */
6585 }
6592 }
6594 /*
6595 * Get a string item from a dictionary.
6596 * When "save" is TRUE allocate memory for it.
6597 * Returns NULL if the entry doesn't exist or out of memory.
6598 */
6599 char_u *
6604 {
6615 }
6617 /*
6618 * Get a number item from a dictionary.
6619 * Returns 0 if the entry doesn't exist or out of memory.
6620 */
6621 long
6625 {
6632 }
6634 /*
6635 * Return an allocated string with the string representation of a Dictionary.
6636 * May return NULL.
6637 */
6642 {
6643 garray_T ga;
6659 {
6661 {
6666 else
6671 {
6674 }
6682 }
6683 }
6685 {
6688 }
6693 }
6695 /*
6696 * Allocate a variable for a Dictionary and fill it from "*arg".
6697 * Return OK or FAIL. Returns NOTDONE for {expr}.
6698 */
6699 static int
6704 {
6706 typval_T tvkey;
6707 typval_T tv;
6713 /*
6714 * First check if it's not a curly-braces thing: {expr}.
6715 * Must do this without evaluating, otherwise a function may be called
6716 * twice. Unfortunately this means we need to call eval1() twice for the
6717 * first item.
6718 * But {} is an empty Dictionary.
6719 */
6721 {
6726 }
6729 {
6733 }
6739 {
6743 {
6747 }
6749 {
6752 {
6753 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6758 }
6759 }
6763 {
6767 }
6769 {
6772 {
6777 }
6781 {
6786 }
6787 }
6792 {
6795 }
6797 }
6800 {
6802 failret:
6806 }
6810 {
6814 }
6817 }
6819 /*
6820 * Return a string with the string representation of a variable.
6821 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6822 * "numbuf" is used for a number.
6823 * Does not put quotes around strings, as ":echo" displays values.
6824 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6825 * May return NULL.
6826 */
6833 {
6838 {
6842 }
6846 {
6854 {
6857 }
6859 {
6862 }
6863 else
6864 {
6868 }
6873 {
6876 }
6878 {
6881 }
6882 else
6883 {
6887 }
6899 }
6903 }
6905 /*
6906 * Return a string with the string representation of a variable.
6907 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6908 * "numbuf" is used for a number.
6909 * Puts quotes around strings, so that they can be parsed back by eval().
6910 * May return NULL.
6911 */
6918 {
6920 {
6933 }
6935 }
6937 /*
6938 * Return string "str" in ' quotes, doubling ' characters.
6939 * If "str" is NULL an empty string is assumed.
6940 * If "function" is TRUE make it function('string').
6941 */
6946 {
6952 {
6957 }
6960 {
6962 {
6965 }
6966 else
6970 {
6974 }
6979 }
6981 }
6983 /*
6984 * Get the value of an environment variable.
6985 * "arg" is pointing to the '$'. It is advanced to after the name.
6986 * If the environment variable was not set, silently assume it is empty.
6987 * Always return OK.
6988 */
6989 static int
6994 {
7005 {
7007 {
7010 /* first try vim_getenv(), fast for normal environment vars */
7013 {
7016 }
7017 else
7018 {
7022 /* next try expanding things like $VIM and ${HOME} */
7025 {
7028 }
7029 }
7031 }
7034 }
7037 }
7039 /*
7040 * Array with names and number of arguments of all internal functions
7041 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7042 */
7043 static struct fst
7044 {
7049 /* implementation of function */
7051 {
7076 #if defined(FEAT_INS_EXPAND)
7080 #endif
7190 #ifdef vim_mkdir
7192 #endif
7239 #ifdef HAVE_STRFTIME
7241 #endif
7278 };
7280 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7282 /*
7283 * Function given to ExpandGeneric() to obtain the list of internal
7284 * or user defined function names.
7285 */
7286 char_u *
7290 {
7297 {
7301 }
7303 {
7309 }
7312 }
7314 /*
7315 * Function given to ExpandGeneric() to obtain the list of internal or
7316 * user defined variable or function names.
7317 */
7318 /*ARGSUSED*/
7319 char_u *
7323 {
7330 {
7334 }
7336 }
7340 /*
7341 * Find internal function in table above.
7342 * Return index, or -1 if not found
7343 */
7344 static int
7347 {
7353 /*
7354 * Find the function name in the table. Binary search.
7355 */
7357 {
7364 else
7366 }
7368 }
7370 /*
7371 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7372 * name it contains, otherwise return "name".
7373 */
7378 {
7387 {
7389 {
7392 }
7395 }
7398 }
7400 /*
7401 * Allocate a variable for the result of a function.
7402 * Return OK or FAIL.
7403 */
7404 static int
7416 {
7422 /*
7423 * Get the arguments.
7424 */
7427 {
7432 {
7435 }
7439 }
7442 else
7449 {
7452 else
7454 }
7461 }
7464 /*
7465 * Call a function with its resolved parameters
7466 * Return OK when the function can't be called, FAIL otherwise.
7467 * Also returns OK when an error was encountered while executing the function.
7468 */
7469 static int
7477 PLUS ONE elements! */
7483 {
7485 #define ERROR_UNKNOWN 0
7486 #define ERROR_TOOMANY 1
7487 #define ERROR_TOOFEW 2
7488 #define ERROR_SCRIPT 3
7489 #define ERROR_DICT 4
7490 #define ERROR_NONE 5
7491 #define ERROR_OTHER 6
7497 #define FLEN_FIXED 40
7501 /*
7502 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7503 * Change <SNR>123_name() to K_SNR 123_name().
7504 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7505 */
7510 {
7516 {
7519 else
7520 {
7523 }
7524 }
7526 {
7529 }
7530 else
7531 {
7535 else
7536 {
7539 }
7540 }
7541 }
7542 else
7548 /* execute the function if no errors detected and executing */
7550 {
7555 {
7556 /*
7557 * User defined function.
7558 */
7561 #ifdef FEAT_AUTOCMD
7562 /* Trigger FuncUndefined event, may load the function. */
7567 {
7568 /* executed an autocommand, search for the function again */
7570 }
7571 #endif
7572 /* Try loading a package. */
7574 {
7575 /* loaded a package, search for the function again */
7577 }
7580 {
7589 else
7590 {
7591 /*
7592 * Call the user function.
7593 * Save and restore search patterns, script variables and
7594 * redo buffer.
7595 */
7604 /* Function was unreferenced while being used, free it
7605 * now. */
7610 }
7611 }
7612 }
7613 else
7614 {
7615 /*
7616 * Find the function name in the table, call its implementation.
7617 */
7620 {
7625 else
7626 {
7630 }
7631 }
7632 }
7633 /*
7634 * The function call (or "FuncUndefined" autocommand sequence) might
7635 * have been aborted by an error, an interrupt, or an explicitly thrown
7636 * exception that has not been caught so far. This situation can be
7637 * tested for by calling aborting(). For an error in an internal
7638 * function or for the "E132" error in call_user_func(), however, the
7639 * throw point at which the "force_abort" flag (temporarily reset by
7640 * emsg()) is normally updated has not been reached yet. We need to
7641 * update that flag first to make aborting() reliable.
7642 */
7644 }
7648 /*
7649 * Report an error unless the argument evaluation or function call has been
7650 * cancelled due to an aborting error, an interrupt, or an exception.
7651 */
7653 {
7655 {
7664 name);
7668 name);
7672 name);
7674 }
7675 }
7682 }
7684 /*
7685 * Give an error message with a function name. Handle <SNR> things.
7686 */
7687 static void
7691 {
7696 else
7701 }
7703 /*********************************************
7704 * Implementation of the built-in functions
7705 */
7707 /*
7708 * "add(list, item)" function
7709 */
7710 static void
7714 {
7719 {
7724 }
7725 else
7727 }
7729 /*
7730 * "append(lnum, string/list)" function
7731 */
7732 static void
7736 {
7748 {
7750 {
7755 }
7758 {
7763 else
7767 {
7770 }
7776 }
7781 }
7782 else
7784 }
7786 /*
7787 * "argc()" function
7788 */
7789 /* ARGSUSED */
7790 static void
7794 {
7796 }
7798 /*
7799 * "argidx()" function
7800 */
7801 /* ARGSUSED */
7802 static void
7806 {
7808 }
7810 /*
7811 * "argv(nr)" function
7812 */
7813 static void
7817 {
7821 {
7825 else
7828 }
7833 }
7835 /*
7836 * "browse(save, title, initdir, default)" function
7837 */
7838 /* ARGSUSED */
7839 static void
7843 {
7844 #ifdef FEAT_BROWSE
7860 else
7864 #else
7866 #endif
7868 }
7870 /*
7871 * "browsedir(title, initdir)" function
7872 */
7873 /* ARGSUSED */
7874 static void
7878 {
7879 #ifdef FEAT_BROWSE
7889 else
7892 #else
7894 #endif
7896 }
7900 /*
7901 * Find a buffer by number or exact name.
7902 */
7906 {
7912 {
7915 {
7916 /* No full path name match, try a match with a URL or a "nofile"
7917 * buffer, these don't use the full path. */
7921 #ifdef FEAT_QUICKFIX
7923 #endif
7924 )
7927 }
7928 }
7930 }
7932 /*
7933 * "bufexists(expr)" function
7934 */
7935 static void
7939 {
7941 }
7943 /*
7944 * "buflisted(expr)" function
7945 */
7946 static void
7950 {
7955 }
7957 /*
7958 * "bufloaded(expr)" function
7959 */
7960 static void
7964 {
7969 }
7973 /*
7974 * Get buffer by number or pattern.
7975 */
7979 {
7994 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8006 /* If not found, try expanding the name, like done for bufexists(). */
8011 }
8013 /*
8014 * "bufname(expr)" function
8015 */
8016 static void
8020 {
8029 else
8032 }
8034 /*
8035 * "bufnr(expr)" function
8036 */
8037 static void
8041 {
8051 /* If the buffer isn't found and the second argument is not zero create a
8052 * new buffer. */
8056 && !error
8063 else
8065 }
8067 /*
8068 * "bufwinnr(nr)" function
8069 */
8070 static void
8074 {
8075 #ifdef FEAT_WINDOWS
8078 #endif
8084 #ifdef FEAT_WINDOWS
8086 {
8090 }
8092 #else
8094 #endif
8096 }
8098 /*
8099 * "byte2line(byte)" function
8100 */
8101 /*ARGSUSED*/
8102 static void
8106 {
8107 #ifndef FEAT_BYTEOFF
8109 #else
8115 else
8118 #endif
8119 }
8121 /*
8122 * "byteidx()" function
8123 */
8124 /*ARGSUSED*/
8125 static void
8129 {
8130 #ifdef FEAT_MBYTE
8132 #endif
8142 #ifdef FEAT_MBYTE
8145 {
8149 }
8151 #else
8154 #endif
8155 }
8157 /*
8158 * "call(func, arglist)" function
8159 */
8160 static void
8164 {
8174 {
8177 }
8183 else
8189 {
8191 {
8194 }
8196 }
8200 {
8202 {
8205 }
8206 /* Make a copy of each argument. This is needed to be able to set
8207 * v_lock to VAR_FIXED in the copy without changing the original list.
8208 */
8210 }
8217 /* Free the arguments. */
8220 }
8222 /*
8223 * "changenr()" function
8224 */
8225 /*ARGSUSED*/
8226 static void
8230 {
8232 }
8234 /*
8235 * "char2nr(string)" function
8236 */
8237 static void
8241 {
8242 #ifdef FEAT_MBYTE
8245 else
8246 #endif
8248 }
8250 /*
8251 * "cindent(lnum)" function
8252 */
8253 static void
8257 {
8258 #ifdef FEAT_CINDENT
8259 pos_T pos;
8260 linenr_T lnum;
8265 {
8269 }
8270 else
8271 #endif
8273 }
8275 /*
8276 * "clearmatches()" function
8277 */
8278 /*ARGSUSED*/
8279 static void
8283 {
8284 #ifdef FEAT_SEARCH_EXTRA
8286 #endif
8287 }
8289 /*
8290 * "col(string)" function
8291 */
8292 static void
8296 {
8303 {
8305 {
8306 /* '> can be MAXCOL, get the length of the line then */
8309 else
8311 }
8312 else
8313 {
8315 #ifdef FEAT_VIRTUALEDIT
8316 /* col(".") when the cursor is on the NUL at the end of the line
8317 * because of "coladd" can be seen as an extra column. */
8319 {
8324 {
8325 # ifdef FEAT_MBYTE
8330 # else
8333 # endif
8334 }
8335 }
8336 #endif
8337 }
8338 }
8340 }
8342 #if defined(FEAT_INS_EXPAND)
8343 /*
8344 * "complete()" function
8345 */
8346 /*ARGSUSED*/
8347 static void
8351 {
8355 {
8358 }
8360 /* Check for undo allowed here, because if something was already inserted
8361 * the line was already saved for undo and this check isn't done. */
8366 {
8369 }
8376 }
8378 /*
8379 * "complete_add()" function
8380 */
8381 /*ARGSUSED*/
8382 static void
8386 {
8388 }
8390 /*
8391 * "complete_check()" function
8392 */
8393 /*ARGSUSED*/
8394 static void
8398 {
8405 }
8406 #endif
8408 /*
8409 * "confirm(message, buttons[, default [, type]])" function
8410 */
8411 /*ARGSUSED*/
8412 static void
8416 {
8417 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8431 {
8436 {
8439 {
8443 else
8444 {
8446 {
8452 }
8453 }
8454 }
8455 }
8456 }
8463 else
8466 #else
8468 #endif
8469 }
8471 /*
8472 * "copy()" function
8473 */
8474 static void
8478 {
8480 }
8482 /*
8483 * "count()" function
8484 */
8485 static void
8489 {
8494 {
8500 {
8503 {
8508 {
8511 {
8515 }
8516 }
8519 }
8524 }
8525 }
8527 {
8533 {
8537 {
8541 }
8545 {
8547 {
8551 }
8552 }
8553 }
8554 }
8555 else
8558 }
8560 /*
8561 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8562 *
8563 * Checks the existence of a cscope connection.
8564 */
8565 /*ARGSUSED*/
8566 static void
8570 {
8571 #ifdef FEAT_CSCOPE
8579 {
8584 }
8587 #else
8589 #endif
8590 }
8592 /*
8593 * "cursor(lnum, col)" function
8594 *
8595 * Moves the cursor to the specified line and column
8596 */
8597 /*ARGSUSED*/
8598 static void
8602 {
8604 #ifdef FEAT_VIRTUALEDIT
8606 #endif
8609 {
8610 pos_T pos;
8616 #ifdef FEAT_VIRTUALEDIT
8618 #endif
8619 }
8620 else
8621 {
8624 #ifdef FEAT_VIRTUALEDIT
8627 #endif
8628 }
8630 #ifdef FEAT_VIRTUALEDIT
8632 #endif
8633 )
8639 #ifdef FEAT_VIRTUALEDIT
8641 #endif
8643 /* Make sure the cursor is in a valid position. */
8645 #ifdef FEAT_MBYTE
8646 /* Correct cursor for multi-byte character. */
8649 #endif
8652 }
8654 /*
8655 * "deepcopy()" function
8656 */
8657 static void
8661 {
8668 else
8670 }
8672 /*
8673 * "delete()" function
8674 */
8675 static void
8679 {
8682 else
8684 }
8686 /*
8687 * "did_filetype()" function
8688 */
8689 /*ARGSUSED*/
8690 static void
8694 {
8695 #ifdef FEAT_AUTOCMD
8697 #else
8699 #endif
8700 }
8702 /*
8703 * "diff_filler()" function
8704 */
8705 /*ARGSUSED*/
8706 static void
8710 {
8711 #ifdef FEAT_DIFF
8713 #endif
8714 }
8716 /*
8717 * "diff_hlID()" function
8718 */
8719 /*ARGSUSED*/
8720 static void
8724 {
8725 #ifdef FEAT_DIFF
8741 {
8742 /* New line, buffer, change: need to get the values. */
8745 {
8747 {
8752 else
8754 }
8755 else
8757 }
8758 else
8763 }
8766 {
8770 else
8772 }
8774 #endif
8775 }
8777 /*
8778 * "empty({expr})" function
8779 */
8780 static void
8784 {
8788 {
8808 }
8811 }
8813 /*
8814 * "escape({string}, {chars})" function
8815 */
8816 static void
8820 {
8826 }
8828 /*
8829 * "eval()" function
8830 */
8831 /*ARGSUSED*/
8832 static void
8836 {
8844 {
8847 }
8850 }
8852 /*
8853 * "eventhandler()" function
8854 */
8855 /*ARGSUSED*/
8856 static void
8860 {
8862 }
8864 /*
8865 * "executable()" function
8866 */
8867 static void
8871 {
8873 }
8875 /*
8876 * "exists()" function
8877 */
8878 static void
8882 {
8890 {
8891 /* first try "normal" environment variables (fast) */
8894 else
8895 {
8896 /* try expanding things like $VIM and ${HOME} */
8901 }
8902 }
8904 {
8908 }
8910 {
8912 }
8914 {
8916 }
8918 {
8919 #ifdef FEAT_AUTOCMD
8922 else
8924 #endif
8925 }
8927 {
8929 typval_T tv;
8931 /* get_name_len() takes care of expanding curly braces */
8935 {
8940 {
8941 /* handle d.key, l[idx], f(expr) */
8945 }
8946 }
8951 }
8954 }
8956 /*
8957 * "expand()" function
8958 */
8959 static void
8963 {
8968 expand_T xpc;
8974 {
8978 }
8979 else
8980 {
8981 /* When the optional second argument is non-zero, don't remove matches
8982 * for 'suffixes' and 'wildignore' */
8987 {
8991 }
8992 else
8994 }
8995 }
8997 /*
8998 * "extend(list, list [, idx])" function
8999 * "extend(dict, dict [, action])" function
9000 */
9001 static void
9005 {
9008 {
9018 {
9020 {
9027 else
9028 {
9031 {
9034 }
9035 }
9036 }
9037 else
9042 }
9043 }
9045 {
9057 {
9058 /* Check the third argument. */
9060 {
9070 {
9073 }
9074 }
9075 else
9078 /* Go over all entries in the second dict and add them to the
9079 * first dict. */
9082 {
9084 {
9088 {
9092 }
9094 {
9097 }
9099 {
9102 }
9103 }
9104 }
9107 }
9108 }
9109 else
9111 }
9113 /*
9114 * "feedkeys()" function
9115 */
9116 /*ARGSUSED*/
9117 static void
9121 {
9128 /* This is not allowed in the sandbox. If the commands would still be
9129 * executed in the sandbox it would be OK, but it probably happens later,
9130 * when "sandbox" is no longer set. */
9137 {
9139 {
9142 {
9144 {
9148 }
9149 }
9150 }
9152 /* Need to escape K_SPECIAL and CSI before putting the string in the
9153 * typeahead buffer. */
9156 {
9162 }
9163 }
9164 }
9166 /*
9167 * "filereadable()" function
9168 */
9169 static void
9173 {
9180 {
9183 }
9184 else
9188 }
9190 /*
9191 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9192 * rights to write into.
9193 */
9194 static void
9198 {
9200 }
9204 static void
9209 {
9210 #ifdef FEAT_SEARCHPATH
9219 #endif
9224 #ifdef FEAT_SEARCHPATH
9228 {
9232 else
9233 {
9239 }
9240 }
9246 {
9247 do
9248 {
9261 }
9265 #endif
9266 }
9271 /*
9272 * Implementation of map() and filter().
9273 */
9274 static void
9279 {
9288 typval_T save_val;
9289 typval_T save_key;
9297 {
9301 }
9303 {
9307 }
9308 else
9309 {
9312 }
9315 /* On type errors, the preceding call has already displayed an error
9316 * message. Avoid a misleading error message for an empty string that
9317 * was not passed as argument. */
9319 {
9323 /* We reset "did_emsg" to be able to detect whether an error
9324 * occurred during evaluation of the expression. */
9329 {
9337 {
9339 {
9351 }
9352 }
9356 }
9357 else
9358 {
9360 {
9369 }
9370 }
9375 }
9378 }
9380 static int
9386 {
9387 typval_T rettv;
9396 {
9399 }
9401 {
9402 /* map(): replace the list item value */
9406 }
9407 else
9408 {
9411 /* filter(): when expr is zero remove the item */
9414 /* On type error, nothing has been removed; return FAIL to stop the
9415 * loop. The error message was given by get_tv_number_chk(). */
9418 }
9420 theend:
9423 }
9425 /*
9426 * "filter()" function
9427 */
9428 static void
9432 {
9434 }
9436 /*
9437 * "finddir({fname}[, {path}[, {count}]])" function
9438 */
9439 static void
9443 {
9445 }
9447 /*
9448 * "findfile({fname}[, {path}[, {count}]])" function
9449 */
9450 static void
9454 {
9456 }
9458 /*
9459 * "fnamemodify({fname}, {mods})" function
9460 */
9461 static void
9465 {
9477 else
9478 {
9481 }
9486 else
9489 }
9493 /*
9494 * "foldclosed()" function
9495 */
9496 static void
9501 {
9502 #ifdef FEAT_FOLDING
9503 linenr_T lnum;
9508 {
9510 {
9513 else
9516 }
9517 }
9518 #endif
9520 }
9522 /*
9523 * "foldclosed()" function
9524 */
9525 static void
9529 {
9531 }
9533 /*
9534 * "foldclosedend()" function
9535 */
9536 static void
9540 {
9542 }
9544 /*
9545 * "foldlevel()" function
9546 */
9547 static void
9551 {
9552 #ifdef FEAT_FOLDING
9553 linenr_T lnum;
9558 else
9559 #endif
9561 }
9563 /*
9564 * "foldtext()" function
9565 */
9566 /*ARGSUSED*/
9567 static void
9571 {
9572 #ifdef FEAT_FOLDING
9573 linenr_T lnum;
9578 #endif
9582 #ifdef FEAT_FOLDING
9587 {
9588 /* Find first non-empty line in the fold. */
9591 {
9595 }
9597 /* Find interesting text in this line. */
9599 /* skip C comment-start */
9601 {
9605 {
9609 }
9610 }
9617 {
9623 /* remove 'foldmarker' and 'commentstring' */
9626 }
9627 }
9628 #endif
9629 }
9631 /*
9632 * "foldtextresult(lnum)" function
9633 */
9634 /*ARGSUSED*/
9635 static void
9639 {
9640 #ifdef FEAT_FOLDING
9641 linenr_T lnum;
9644 foldinfo_T foldinfo;
9646 #endif
9650 #ifdef FEAT_FOLDING
9652 /* treat illegal types and illegal string values for {lnum} the same */
9657 {
9663 }
9664 #endif
9665 }
9667 /*
9668 * "foreground()" function
9669 */
9670 /*ARGSUSED*/
9671 static void
9675 {
9677 #ifdef FEAT_GUI
9680 #else
9681 # ifdef WIN32
9683 # endif
9684 #endif
9685 }
9687 /*
9688 * "function()" function
9689 */
9690 /*ARGSUSED*/
9691 static void
9695 {
9704 else
9705 {
9708 }
9709 }
9711 /*
9712 * "garbagecollect()" function
9713 */
9714 /*ARGSUSED*/
9715 static void
9719 {
9720 /* This is postponed until we are back at the toplevel, because we may be
9721 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9726 }
9728 /*
9729 * "get()" function
9730 */
9731 static void
9735 {
9743 {
9745 {
9751 }
9752 }
9754 {
9756 {
9760 }
9761 }
9762 else
9766 {
9769 else
9771 }
9772 else
9774 }
9776 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9778 /*
9779 * Get line or list of lines from buffer "buf" into "rettv".
9780 * Return a range (from start to end) of lines in rettv from the specified
9781 * buffer.
9782 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9783 */
9784 static void
9787 linenr_T start;
9788 linenr_T end;
9791 {
9795 {
9798 }
9799 else
9806 {
9809 else
9814 }
9815 else
9816 {
9828 }
9829 }
9831 /*
9832 * "getbufline()" function
9833 */
9834 static void
9838 {
9839 linenr_T lnum;
9840 linenr_T end;
9851 else
9855 }
9857 /*
9858 * "getbufvar()" function
9859 */
9860 static void
9864 {
9879 {
9881 {
9882 /* set curbuf to be our buf, temporarily */
9888 /* restore previous notion of curbuf */
9890 }
9891 else
9892 {
9894 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9895 * scope prefix before the NUL byte is required by
9896 * find_var_in_ht(). */
9898 /* look up the variable */
9902 }
9903 }
9906 }
9908 /*
9909 * "getchar()" function
9910 */
9911 static void
9915 {
9916 varnumber_T n;
9919 /* Position the cursor. Needed after a message that ends in a space. */
9925 {
9927 /* getchar(): blocking wait. */
9930 /* getchar(1): only check if char avail */
9933 /* illegal argument or getchar(0) and no char avail: return zero */
9935 else
9936 /* getchar(0) and char avail: return char */
9941 }
9951 {
9955 /* Turn a special key into three bytes, plus modifier. */
9957 {
9961 }
9963 {
9967 }
9968 #ifdef FEAT_MBYTE
9971 #endif
9972 else
9978 #ifdef FEAT_MOUSE
9998 {
10002 linenr_T lnum;
10003 # ifdef FEAT_WINDOWS
10005 # endif
10009 {
10010 /* Find the window at the mouse coordinates and compute the
10011 * text position. */
10014 # ifdef FEAT_WINDOWS
10017 # endif
10021 }
10022 }
10023 #endif
10024 }
10025 }
10027 /*
10028 * "getcharmod()" function
10029 */
10030 /*ARGSUSED*/
10031 static void
10035 {
10037 }
10039 /*
10040 * "getcmdline()" function
10041 */
10042 /*ARGSUSED*/
10043 static void
10047 {
10050 }
10052 /*
10053 * "getcmdpos()" function
10054 */
10055 /*ARGSUSED*/
10056 static void
10060 {
10062 }
10064 /*
10065 * "getcmdtype()" function
10066 */
10067 /*ARGSUSED*/
10068 static void
10072 {
10076 {
10079 }
10080 }
10082 /*
10083 * "getcwd()" function
10084 */
10085 /*ARGSUSED*/
10086 static void
10090 {
10096 else
10097 {
10099 #ifdef BACKSLASH_IN_FILENAME
10102 #endif
10103 }
10104 }
10106 /*
10107 * "getfontname()" function
10108 */
10109 /*ARGSUSED*/
10110 static void
10114 {
10117 #ifdef FEAT_GUI
10119 {
10120 GuiFont font;
10124 {
10125 /* Get the "Normal" font. Either the name saved by
10126 * hl_set_font_name() or from the font ID. */
10129 }
10130 else
10131 {
10138 }
10142 }
10143 #endif
10144 }
10146 /*
10147 * "getfperm({fname})" function
10148 */
10149 static void
10153 {
10164 {
10167 {
10169 {
10172 }
10173 }
10174 }
10176 }
10178 /*
10179 * "getfsize({fname})" function
10180 */
10181 static void
10185 {
10194 {
10197 else
10198 {
10201 /* non-perfect check for overflow */
10204 }
10205 }
10206 else
10208 }
10210 /*
10211 * "getftime({fname})" function
10212 */
10213 static void
10217 {
10225 else
10227 }
10229 /*
10230 * "getftype({fname})" function
10231 */
10232 static void
10236 {
10246 {
10247 #ifdef S_ISREG
10252 # ifdef S_ISLNK
10255 # endif
10256 # ifdef S_ISBLK
10259 # endif
10260 # ifdef S_ISCHR
10263 # endif
10264 # ifdef S_ISFIFO
10267 # endif
10268 # ifdef S_ISSOCK
10271 # endif
10272 else
10274 #else
10275 # ifdef S_IFMT
10277 {
10280 # ifdef S_IFLNK
10282 # endif
10283 # ifdef S_IFBLK
10285 # endif
10286 # ifdef S_IFCHR
10288 # endif
10289 # ifdef S_IFIFO
10291 # endif
10292 # ifdef S_IFSOCK
10294 # endif
10296 }
10297 # else
10300 else
10302 # endif
10303 #endif
10305 }
10307 }
10309 /*
10310 * "getline(lnum, [end])" function
10311 */
10312 static void
10316 {
10317 linenr_T lnum;
10318 linenr_T end;
10323 {
10326 }
10327 else
10328 {
10331 }
10334 }
10336 /*
10337 * "getmatches()" function
10338 */
10339 /*ARGSUSED*/
10340 static void
10344 {
10345 #ifdef FEAT_SEARCH_EXTRA
10352 {
10354 {
10364 }
10365 }
10366 #endif
10367 }
10369 /*
10370 * "getpos(string)" function
10371 */
10372 static void
10376 {
10382 {
10387 else
10395 #ifdef FEAT_VIRTUALEDIT
10397 #endif
10399 }
10400 else
10402 }
10404 /*
10405 * "getqflist()" and "getloclist()" functions
10406 */
10407 /*ARGSUSED*/
10408 static void
10412 {
10413 #ifdef FEAT_QUICKFIX
10415 #endif
10418 #ifdef FEAT_QUICKFIX
10420 {
10423 {
10427 }
10430 }
10431 #endif
10432 }
10434 /*
10435 * "getreg()" function
10436 */
10437 static void
10441 {
10448 {
10453 }
10454 else
10463 }
10465 /*
10466 * "getregtype()" function
10467 */
10468 static void
10472 {
10479 {
10482 {
10486 }
10487 }
10488 else
10489 /* Default to v:register */
10499 {
10502 #ifdef FEAT_VISUAL
10507 #endif
10508 }
10511 }
10513 /*
10514 * "gettabwinvar()" function
10515 */
10516 static void
10520 {
10522 }
10524 /*
10525 * "getwinposx()" function
10526 */
10527 /*ARGSUSED*/
10528 static void
10532 {
10534 #ifdef FEAT_GUI
10536 {
10541 }
10542 #endif
10543 }
10545 /*
10546 * "getwinposy()" function
10547 */
10548 /*ARGSUSED*/
10549 static void
10553 {
10555 #ifdef FEAT_GUI
10557 {
10562 }
10563 #endif
10564 }
10566 /*
10567 * Find window specifed by "vp" in tabpage "tp".
10568 */
10573 {
10574 #ifdef FEAT_WINDOWS
10576 #endif
10581 #ifdef FEAT_WINDOWS
10592 #else
10596 #endif
10597 }
10599 /*
10600 * "getwinvar()" function
10601 */
10602 static void
10606 {
10608 }
10610 /*
10611 * getwinvar() and gettabwinvar()
10612 */
10613 static void
10618 {
10624 #ifdef FEAT_WINDOWS
10627 else
10629 #endif
10638 {
10639 /* Set curwin to be our win, temporarily. Also set curbuf, so
10640 * that we can get buffer-local options. */
10647 else
10648 {
10650 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10651 * scope prefix before the NUL byte is required by
10652 * find_var_in_ht(). */
10654 /* look up the variable */
10658 }
10660 /* restore previous notion of curwin */
10663 }
10666 }
10668 /*
10669 * "glob()" function
10670 */
10671 static void
10675 {
10676 expand_T xpc;
10683 }
10685 /*
10686 * "globpath()" function
10687 */
10688 static void
10692 {
10699 else
10701 }
10703 /*
10704 * "has()" function
10705 */
10706 static void
10710 {
10715 {
10716 #ifdef AMIGA
10718 # ifdef FEAT_ARP
10720 # endif
10721 #endif
10722 #ifdef __BEOS__
10724 #endif
10725 #ifdef MSDOS
10726 # ifdef DJGPP
10728 # else
10730 # endif
10731 #endif
10732 #ifdef MACOS
10734 #endif
10735 #if defined(MACOS_X_UNIX)
10737 #endif
10738 #ifdef OS2
10740 #endif
10741 #ifdef __QNX__
10743 #endif
10744 #ifdef RISCOS
10746 #endif
10747 #ifdef UNIX
10749 #endif
10750 #ifdef VMS
10752 #endif
10753 #ifdef WIN16
10755 #endif
10756 #ifdef WIN32
10758 #endif
10759 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10761 #endif
10762 #ifdef WIN64
10764 #endif
10765 #ifdef EBCDIC
10767 #endif
10768 #ifndef CASE_INSENSITIVE_FILENAME
10770 #endif
10771 #ifdef FEAT_ARABIC
10773 #endif
10774 #ifdef FEAT_AUTOCMD
10776 #endif
10777 #ifdef FEAT_BEVAL
10781 # endif
10782 #endif
10783 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10785 # ifdef ALL_BUILTIN_TCAPS
10787 # endif
10788 #endif
10789 #ifdef FEAT_BYTEOFF
10791 #endif
10792 #ifdef FEAT_CINDENT
10794 #endif
10795 #ifdef FEAT_CLIENTSERVER
10797 #endif
10798 #ifdef FEAT_CLIPBOARD
10800 #endif
10801 #ifdef FEAT_CMDL_COMPL
10803 #endif
10804 #ifdef FEAT_CMDHIST
10806 #endif
10807 #ifdef FEAT_COMMENTS
10809 #endif
10810 #ifdef FEAT_CRYPT
10812 #endif
10813 #ifdef FEAT_CSCOPE
10815 #endif
10816 #ifdef CURSOR_SHAPE
10818 #endif
10819 #ifdef DEBUG
10821 #endif
10822 #ifdef FEAT_CON_DIALOG
10824 #endif
10825 #ifdef FEAT_GUI_DIALOG
10827 #endif
10828 #ifdef FEAT_DIFF
10830 #endif
10831 #ifdef FEAT_DIGRAPHS
10833 #endif
10834 #ifdef FEAT_DND
10836 #endif
10837 #ifdef FEAT_EMACS_TAGS
10839 #endif
10841 #ifdef FEAT_EX_EXTRA
10843 #endif
10844 #ifdef FEAT_SEARCH_EXTRA
10846 #endif
10847 #ifdef FEAT_FKMAP
10849 #endif
10850 #ifdef FEAT_SEARCHPATH
10852 #endif
10853 #if defined(UNIX) && !defined(USE_SYSTEM)
10855 #endif
10856 #ifdef FEAT_FIND_ID
10858 #endif
10859 #ifdef FEAT_FOLDING
10861 #endif
10862 #ifdef FEAT_FOOTER
10864 #endif
10865 #if !defined(USE_SYSTEM) && defined(UNIX)
10867 #endif
10868 #ifdef FEAT_GETTEXT
10870 #endif
10871 #ifdef FEAT_GUI
10873 #endif
10874 #ifdef FEAT_GUI_ATHENA
10875 # ifdef FEAT_GUI_NEXTAW
10877 # else
10879 # endif
10880 #endif
10881 #ifdef FEAT_GUI_GTK
10883 # ifdef HAVE_GTK2
10885 # endif
10886 #endif
10887 #ifdef FEAT_GUI_GNOME
10889 #endif
10890 #ifdef FEAT_GUI_MAC
10892 #endif
10893 #ifdef FEAT_GUI_MOTIF
10895 #endif
10896 #ifdef FEAT_GUI_PHOTON
10898 #endif
10899 #ifdef FEAT_GUI_W16
10901 #endif
10902 #ifdef FEAT_GUI_W32
10904 #endif
10905 #ifdef FEAT_HANGULIN
10907 #endif
10908 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10910 #endif
10911 #ifdef FEAT_INS_EXPAND
10913 #endif
10914 #ifdef FEAT_JUMPLIST
10916 #endif
10917 #ifdef FEAT_KEYMAP
10919 #endif
10920 #ifdef FEAT_LANGMAP
10922 #endif
10923 #ifdef FEAT_LIBCALL
10925 #endif
10926 #ifdef FEAT_LINEBREAK
10928 #endif
10929 #ifdef FEAT_LISP
10931 #endif
10932 #ifdef FEAT_LISTCMDS
10934 #endif
10935 #ifdef FEAT_LOCALMAP
10937 #endif
10938 #ifdef FEAT_MENU
10940 #endif
10941 #ifdef FEAT_SESSION
10943 #endif
10944 #ifdef FEAT_MODIFY_FNAME
10946 #endif
10947 #ifdef FEAT_MOUSE
10949 #endif
10950 #ifdef FEAT_MOUSESHAPE
10952 #endif
10953 #if defined(UNIX) || defined(VMS)
10954 # ifdef FEAT_MOUSE_DEC
10956 # endif
10957 # ifdef FEAT_MOUSE_GPM
10959 # endif
10960 # ifdef FEAT_MOUSE_JSB
10962 # endif
10963 # ifdef FEAT_MOUSE_NET
10965 # endif
10966 # ifdef FEAT_MOUSE_PTERM
10968 # endif
10969 # ifdef FEAT_MOUSE_XTERM
10971 # endif
10972 #endif
10973 #ifdef FEAT_MBYTE
10975 #endif
10976 #ifdef FEAT_MBYTE_IME
10978 #endif
10979 #ifdef FEAT_MULTI_LANG
10981 #endif
10982 #ifdef FEAT_MZSCHEME
10983 #ifndef DYNAMIC_MZSCHEME
10985 #endif
10986 #endif
10987 #ifdef FEAT_OLE
10989 #endif
10990 #ifdef FEAT_OSFILETYPE
10992 #endif
10993 #ifdef FEAT_PATH_EXTRA
10995 #endif
10996 #ifdef FEAT_PERL
10997 #ifndef DYNAMIC_PERL
10999 #endif
11000 #endif
11001 #ifdef FEAT_PYTHON
11002 #ifndef DYNAMIC_PYTHON
11004 #endif
11005 #endif
11006 #ifdef FEAT_POSTSCRIPT
11008 #endif
11009 #ifdef FEAT_PRINTER
11011 #endif
11012 #ifdef FEAT_PROFILE
11014 #endif
11015 #ifdef FEAT_RELTIME
11017 #endif
11018 #ifdef FEAT_QUICKFIX
11020 #endif
11021 #ifdef FEAT_RIGHTLEFT
11023 #endif
11024 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11026 #endif
11027 #ifdef FEAT_SCROLLBIND
11029 #endif
11030 #ifdef FEAT_CMDL_INFO
11033 #endif
11034 #ifdef FEAT_SIGNS
11036 #endif
11037 #ifdef FEAT_SMARTINDENT
11039 #endif
11040 #ifdef FEAT_SNIFF
11042 #endif
11043 #ifdef FEAT_STL_OPT
11045 #endif
11046 #ifdef FEAT_SUN_WORKSHOP
11048 #endif
11049 #ifdef FEAT_NETBEANS_INTG
11051 #endif
11052 #ifdef FEAT_SPELL
11054 #endif
11055 #ifdef FEAT_SYN_HL
11057 #endif
11058 #if defined(USE_SYSTEM) || !defined(UNIX)
11060 #endif
11061 #ifdef FEAT_TAG_BINS
11063 #endif
11064 #ifdef FEAT_TAG_OLDSTATIC
11066 #endif
11067 #ifdef FEAT_TAG_ANYWHITE
11069 #endif
11070 #ifdef FEAT_TCL
11071 # ifndef DYNAMIC_TCL
11073 # endif
11074 #endif
11075 #ifdef TERMINFO
11077 #endif
11078 #ifdef FEAT_TERMRESPONSE
11080 #endif
11081 #ifdef FEAT_TEXTOBJ
11083 #endif
11084 #ifdef HAVE_TGETENT
11086 #endif
11087 #ifdef FEAT_TITLE
11089 #endif
11090 #ifdef FEAT_TOOLBAR
11092 #endif
11093 #ifdef FEAT_USR_CMDS
11096 #endif
11097 #ifdef FEAT_VIMINFO
11099 #endif
11100 #ifdef FEAT_VERTSPLIT
11102 #endif
11103 #ifdef FEAT_VIRTUALEDIT
11105 #endif
11106 #ifdef FEAT_VISUAL
11108 #endif
11109 #ifdef FEAT_VISUALEXTRA
11111 #endif
11112 #ifdef FEAT_VREPLACE
11114 #endif
11115 #ifdef FEAT_WILDIGN
11117 #endif
11118 #ifdef FEAT_WILDMENU
11120 #endif
11121 #ifdef FEAT_WINDOWS
11123 #endif
11124 #ifdef FEAT_WAK
11126 #endif
11127 #ifdef FEAT_WRITEBACKUP
11129 #endif
11130 #ifdef FEAT_XIM
11132 #endif
11133 #ifdef FEAT_XFONTSET
11135 #endif
11136 #ifdef USE_XSMP
11138 #endif
11139 #ifdef USE_XSMP_INTERACT
11141 #endif
11142 #ifdef FEAT_XCLIPBOARD
11144 #endif
11145 #ifdef FEAT_XTERM_SAVE
11147 #endif
11148 #if defined(UNIX) && defined(FEAT_X11)
11150 #endif
11151 NULL
11152 };
11157 {
11160 }
11163 {
11168 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11171 #endif
11172 #ifdef DYNAMIC_TCL
11175 #endif
11176 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11179 #endif
11180 #ifdef DYNAMIC_MZSCHEME
11183 #endif
11184 #ifdef DYNAMIC_RUBY
11187 #endif
11188 #ifdef DYNAMIC_PYTHON
11191 #endif
11192 #ifdef DYNAMIC_PERL
11195 #endif
11196 #ifdef FEAT_GUI
11199 # ifdef FEAT_GUI_W32
11202 # endif
11203 # ifdef FEAT_BROWSE
11206 # endif
11207 #endif
11208 #ifdef FEAT_SYN_HL
11211 #endif
11212 #if defined(WIN3264)
11215 #endif
11216 #ifdef FEAT_NETBEANS_INTG
11219 #endif
11220 }
11223 }
11225 /*
11226 * "has_key()" function
11227 */
11228 static void
11232 {
11235 {
11238 }
11244 }
11246 /*
11247 * "haslocaldir()" function
11248 */
11249 /*ARGSUSED*/
11250 static void
11254 {
11256 }
11258 /*
11259 * "hasmapto()" function
11260 */
11261 static void
11265 {
11274 else
11275 {
11279 }
11283 else
11285 }
11287 /*
11288 * "histadd()" function
11289 */
11290 /*ARGSUSED*/
11291 static void
11295 {
11296 #ifdef FEAT_CMDHIST
11300 #endif
11305 #ifdef FEAT_CMDHIST
11309 {
11312 {
11316 }
11317 }
11318 #endif
11319 }
11321 /*
11322 * "histdel()" function
11323 */
11324 /*ARGSUSED*/
11325 static void
11329 {
11330 #ifdef FEAT_CMDHIST
11339 /* only one argument: clear entire history */
11342 /* index given: remove that entry */
11345 else
11346 /* string given: remove all matching entries */
11350 #else
11352 #endif
11353 }
11355 /*
11356 * "histget()" function
11357 */
11358 /*ARGSUSED*/
11359 static void
11363 {
11364 #ifdef FEAT_CMDHIST
11372 else
11373 {
11377 else
11379 /* -1 on type error */
11381 }
11382 #else
11384 #endif
11386 }
11388 /*
11389 * "histnr()" function
11390 */
11391 /*ARGSUSED*/
11392 static void
11396 {
11399 #ifdef FEAT_CMDHIST
11405 else
11406 #endif
11409 }
11411 /*
11412 * "highlightID(name)" function
11413 */
11414 static void
11418 {
11420 }
11422 /*
11423 * "highlight_exists()" function
11424 */
11425 static void
11429 {
11431 }
11433 /*
11434 * "hostname()" function
11435 */
11436 /*ARGSUSED*/
11437 static void
11441 {
11447 }
11449 /*
11450 * iconv() function
11451 */
11452 /*ARGSUSED*/
11453 static void
11457 {
11458 #ifdef FEAT_MBYTE
11462 vimconv_T vimconv;
11463 #endif
11468 #ifdef FEAT_MBYTE
11475 /* If the encodings are equal, no conversion needed. */
11478 else
11484 #endif
11485 }
11487 /*
11488 * "indent()" function
11489 */
11490 static void
11494 {
11495 linenr_T lnum;
11500 else
11502 }
11504 /*
11505 * "index()" function
11506 */
11507 static void
11511 {
11519 {
11522 }
11525 {
11528 {
11531 /* Start at specified item. Use the cached index that list_find()
11532 * sets, so that a negative number also works. */
11539 }
11543 {
11546 }
11547 }
11548 }
11554 /*
11555 * This function is used by f_input() and f_inputdialog() functions. The third
11556 * argument to f_input() specifies the type of completion to use at the
11557 * prompt. The third argument to f_inputdialog() specifies the value to return
11558 * when the user cancels the prompt.
11559 */
11560 static void
11565 {
11578 #ifdef NO_CONSOLE_INPUT
11579 /* While starting up, there is no place to enter text. */
11582 #endif
11586 {
11587 /* Only the part of the message after the last NL is considered as
11588 * prompt for the command line */
11592 else
11593 {
11603 }
11607 {
11613 {
11629 }
11630 }
11639 /* since the user typed this, no need to wait for return */
11642 }
11644 }
11646 /*
11647 * "input()" function
11648 * Also handles inputsecret() when inputsecret is set.
11649 */
11650 static void
11654 {
11656 }
11658 /*
11659 * "inputdialog()" function
11660 */
11661 static void
11665 {
11666 #if defined(FEAT_GUI_TEXTDIALOG)
11667 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11669 {
11678 else
11684 else
11685 {
11691 else
11693 }
11695 }
11696 else
11697 #endif
11699 }
11701 /*
11702 * "inputlist()" function
11703 */
11704 static void
11708 {
11714 #ifdef NO_CONSOLE_INPUT
11715 /* While starting up, there is no place to enter text. */
11718 #endif
11720 {
11723 }
11732 {
11735 }
11737 /* Ask for choice. */
11743 }
11748 /*
11749 * "inputrestore()" function
11750 */
11751 /*ARGSUSED*/
11752 static void
11756 {
11758 {
11763 }
11765 {
11768 }
11769 }
11771 /*
11772 * "inputsave()" function
11773 */
11774 /*ARGSUSED*/
11775 static void
11779 {
11780 /* Add an entry to the stack of typehead storage. */
11782 {
11787 }
11788 else
11790 }
11792 /*
11793 * "inputsecret()" function
11794 */
11795 static void
11799 {
11805 }
11807 /*
11808 * "insert()" function
11809 */
11810 static void
11814 {
11825 {
11833 else
11834 {
11837 {
11840 }
11841 }
11843 {
11846 }
11847 }
11848 }
11850 /*
11851 * "isdirectory()" function
11852 */
11853 static void
11857 {
11859 }
11861 /*
11862 * "islocked()" function
11863 */
11864 static void
11868 {
11869 lval_T lv;
11875 FNE_CHECK_START);
11877 {
11880 else
11881 {
11883 {
11886 else
11887 {
11890 {
11891 /* Consider a variable locked when:
11892 * 1. the variable itself is locked
11893 * 2. the value of the variable is locked.
11894 * 3. the List or Dict value is locked.
11895 */
11898 }
11899 }
11900 }
11906 /* List item. */
11908 else
11909 /* Dictionary item. */
11911 }
11912 }
11915 }
11919 /*
11920 * Turn a dict into a list:
11921 * "what" == 0: list of keys
11922 * "what" == 1: list of values
11923 * "what" == 2: list of items
11924 */
11925 static void
11930 {
11941 {
11944 }
11953 {
11955 {
11965 {
11966 /* keys() */
11970 }
11972 {
11973 /* values() */
11975 }
11976 else
11977 {
11978 /* items() */
12000 }
12001 }
12002 }
12003 }
12005 /*
12006 * "items(dict)" function
12007 */
12008 static void
12012 {
12014 }
12016 /*
12017 * "join()" function
12018 */
12019 static void
12023 {
12024 garray_T ga;
12029 {
12032 }
12037 else
12043 {
12048 }
12049 else
12051 }
12053 /*
12054 * "keys()" function
12055 */
12056 static void
12060 {
12062 }
12064 /*
12065 * "last_buffer_nr()" function.
12066 */
12067 /*ARGSUSED*/
12068 static void
12072 {
12081 }
12083 /*
12084 * "len()" function
12085 */
12086 static void
12090 {
12092 {
12107 }
12108 }
12112 static void
12117 {
12118 #ifdef FEAT_LIBCALL
12122 #endif
12127 else
12133 #ifdef FEAT_LIBCALL
12134 /* The first two args must be strings, otherwise its meaningless */
12136 {
12142 else
12146 string_in,
12148 string_result,
12152 }
12153 #endif
12154 }
12156 /*
12157 * "libcall()" function
12158 */
12159 static void
12163 {
12165 }
12167 /*
12168 * "libcallnr()" function
12169 */
12170 static void
12174 {
12176 }
12178 /*
12179 * "line(string)" function
12180 */
12181 static void
12185 {
12194 }
12196 /*
12197 * "line2byte(lnum)" function
12198 */
12199 /*ARGSUSED*/
12200 static void
12204 {
12205 #ifndef FEAT_BYTEOFF
12207 #else
12208 linenr_T lnum;
12213 else
12217 #endif
12218 }
12220 /*
12221 * "lispindent(lnum)" function
12222 */
12223 static void
12227 {
12228 #ifdef FEAT_LISP
12229 pos_T pos;
12230 linenr_T lnum;
12235 {
12239 }
12240 else
12241 #endif
12243 }
12245 /*
12246 * "localtime()" function
12247 */
12248 /*ARGSUSED*/
12249 static void
12253 {
12255 }
12259 static void
12264 {
12271 garray_T ga;
12274 /* return empty string for failure */
12283 {
12287 }
12288 else
12299 {
12309 }
12310 }
12312 /*
12313 * "map()" function
12314 */
12315 static void
12319 {
12321 }
12323 /*
12324 * "maparg()" function
12325 */
12326 static void
12330 {
12332 }
12334 /*
12335 * "mapcheck()" function
12336 */
12337 static void
12341 {
12343 }
12347 static void
12352 {
12356 regmatch_T regmatch;
12369 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12375 {
12376 /* return empty list when there are no matches */
12379 }
12381 {
12384 }
12387 {
12391 }
12392 else
12400 {
12407 {
12412 }
12413 else
12414 {
12419 /* When "count" argument is there ignore matches before "start",
12420 * otherwise skip part of the string. Differs when pattern is "^"
12421 * or "\<". */
12424 else
12426 }
12432 }
12436 {
12440 {
12442 {
12444 {
12447 }
12452 }
12461 /* Advance to just after the match. */
12463 {
12466 }
12467 else
12468 {
12469 #ifdef FEAT_MBYTE
12472 #else
12474 #endif
12475 }
12476 }
12479 {
12481 {
12484 /* return list with matched string and submatches */
12486 {
12488 {
12492 }
12498 }
12499 }
12501 {
12502 /* return matched string */
12505 else
12508 }
12511 else
12512 {
12516 else
12520 }
12521 }
12523 }
12525 theend:
12528 }
12530 /*
12531 * "match()" function
12532 */
12533 static void
12537 {
12539 }
12541 /*
12542 * "matchadd()" function
12543 */
12544 static void
12548 {
12549 #ifdef FEAT_SEARCH_EXTRA
12562 {
12566 }
12570 {
12573 }
12576 #endif
12577 }
12579 /*
12580 * "matcharg()" function
12581 */
12582 static void
12586 {
12588 {
12589 #ifdef FEAT_SEARCH_EXTRA
12594 {
12596 {
12600 }
12601 else
12602 {
12605 }
12606 }
12607 #endif
12608 }
12609 }
12611 /*
12612 * "matchdelete()" function
12613 */
12614 static void
12618 {
12619 #ifdef FEAT_SEARCH_EXTRA
12622 #endif
12623 }
12625 /*
12626 * "matchend()" function
12627 */
12628 static void
12632 {
12634 }
12636 /*
12637 * "matchlist()" function
12638 */
12639 static void
12643 {
12645 }
12647 /*
12648 * "matchstr()" function
12649 */
12650 static void
12654 {
12656 }
12660 static void
12665 {
12671 {
12677 {
12680 {
12683 {
12690 }
12691 }
12692 }
12693 }
12695 {
12703 {
12706 {
12708 {
12712 {
12715 }
12718 }
12719 }
12720 }
12721 }
12722 else
12725 }
12727 /*
12728 * "max()" function
12729 */
12730 static void
12734 {
12736 }
12738 /*
12739 * "min()" function
12740 */
12741 static void
12745 {
12747 }
12751 /*
12752 * Create the directory in which "dir" is located, and higher levels when
12753 * needed.
12754 */
12755 static int
12759 {
12764 /* Get end of directory name in "dir".
12765 * We're done when it's "/" or "c:/". */
12770 /* If the directory exists we're done. Otherwise: create it.*/
12780 }
12782 #ifdef vim_mkdir
12783 /*
12784 * "mkdir()" function
12785 */
12786 static void
12790 {
12801 {
12806 }
12808 }
12809 #endif
12811 /*
12812 * "mode()" function
12813 */
12814 /*ARGSUSED*/
12815 static void
12819 {
12822 #ifdef FEAT_VISUAL
12824 {
12827 else
12829 }
12830 else
12831 #endif
12835 {
12838 else
12840 }
12843 else
12849 }
12851 /*
12852 * "nextnonblank()" function
12853 */
12854 static void
12858 {
12859 linenr_T lnum;
12862 {
12864 {
12867 }
12870 }
12872 }
12874 /*
12875 * "nr2char()" function
12876 */
12877 static void
12881 {
12884 #ifdef FEAT_MBYTE
12887 else
12888 #endif
12889 {
12892 }
12895 }
12897 /*
12898 * "pathshorten()" function
12899 */
12900 static void
12904 {
12911 else
12912 {
12917 }
12918 }
12920 /*
12921 * "prevnonblank()" function
12922 */
12923 static void
12927 {
12928 linenr_T lnum;
12933 else
12937 }
12939 #ifdef HAVE_STDARG_H
12940 /* This dummy va_list is here because:
12941 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12942 * - locally in the function results in a "used before set" warning
12943 * - using va_start() to initialize it gives "function with fixed args" error */
12945 #endif
12947 /*
12948 * "printf()" function
12949 */
12950 static void
12954 {
12958 {
12965 /* Get the required length, allocate the buffer and do it for real. */
12970 {
12973 {
12976 }
12977 }
12979 }
12980 #endif
12981 }
12983 /*
12984 * "pumvisible()" function
12985 */
12986 /*ARGSUSED*/
12987 static void
12991 {
12993 #ifdef FEAT_INS_EXPAND
12996 #endif
12997 }
12999 /*
13000 * "range()" function
13001 */
13002 static void
13006 {
13015 {
13018 }
13019 else
13020 {
13024 }
13033 else
13034 {
13040 }
13041 }
13043 /*
13044 * "readfile()" function
13045 */
13046 static void
13050 {
13070 {
13075 }
13080 /* Always open the file in binary mode, library functions have a mind of
13081 * their own about CR-LF conversion. */
13084 {
13087 }
13091 {
13096 {
13098 {
13099 /* Only when in binary mode add an empty list item when the
13100 * last line ends in a '\n'. */
13104 /* Found end-of-line or end-of-file: add a text line to the
13105 * list. */
13114 else
13115 {
13118 {
13124 }
13125 }
13130 {
13133 }
13143 }
13146 }
13151 {
13152 /* "buf" is full, need to move text to an allocated buffer */
13154 {
13157 }
13158 else
13159 {
13162 {
13168 }
13169 }
13171 }
13172 else
13173 {
13176 }
13177 }
13179 /*
13180 * For a negative line count use only the lines at the end of the file,
13181 * free the rest.
13182 */
13185 {
13188 }
13192 }
13194 #if defined(FEAT_RELTIME)
13197 /*
13198 * Convert a List to proftime_T.
13199 * Return FAIL when there is something wrong.
13200 */
13201 static int
13205 {
13214 # ifdef WIN3264
13217 # else
13220 # endif
13222 }
13225 /*
13226 * "reltime()" function
13227 */
13228 static void
13232 {
13233 #ifdef FEAT_RELTIME
13234 proftime_T res;
13235 proftime_T start;
13238 {
13239 /* No arguments: get current time. */
13241 }
13243 {
13247 }
13248 else
13249 {
13250 /* Two arguments: compute the difference. */
13255 }
13258 {
13261 # ifdef WIN3264
13264 # else
13267 # endif
13270 }
13271 #endif
13272 }
13274 /*
13275 * "reltimestr()" function
13276 */
13277 static void
13281 {
13282 #ifdef FEAT_RELTIME
13283 proftime_T tm;
13284 #endif
13288 #ifdef FEAT_RELTIME
13291 #endif
13292 }
13294 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13298 static void
13300 {
13302 # ifdef FEAT_GUI
13304 # endif
13305 )
13306 {
13310 }
13311 }
13313 static int
13315 {
13318 {
13321 }
13323 }
13324 #endif
13326 #ifdef FEAT_CLIENTSERVER
13329 static void
13334 {
13339 # ifdef WIN32
13340 HWND w;
13341 # else
13342 Window w;
13343 # endif
13348 # ifdef FEAT_X11
13351 # endif
13357 # ifdef WIN32
13359 # else
13362 # endif
13363 {
13366 else
13369 }
13374 {
13375 dictitem_T v;
13386 }
13387 }
13388 #endif
13390 /*
13391 * "remote_expr()" function
13392 */
13393 /*ARGSUSED*/
13394 static void
13398 {
13401 #ifdef FEAT_CLIENTSERVER
13403 #endif
13404 }
13406 /*
13407 * "remote_foreground()" function
13408 */
13409 /*ARGSUSED*/
13410 static void
13414 {
13416 #ifdef FEAT_CLIENTSERVER
13417 # ifdef WIN32
13418 /* On Win32 it's done in this application. */
13419 {
13424 }
13425 # else
13426 /* Send a foreground() expression to the server. */
13432 # endif
13433 #endif
13434 }
13436 /*ARGSUSED*/
13437 static void
13441 {
13442 #ifdef FEAT_CLIENTSERVER
13443 dictitem_T v;
13445 # ifdef WIN32
13447 # endif
13451 {
13454 }
13457 {
13460 }
13461 # ifdef WIN32
13465 else
13466 {
13469 }
13470 # else
13477 # endif
13480 {
13489 }
13490 #else
13492 #endif
13493 }
13495 /*ARGSUSED*/
13496 static void
13500 {
13503 #ifdef FEAT_CLIENTSERVER
13507 {
13508 # ifdef WIN32
13509 /* The server's HWND is encoded in the 'id' parameter */
13516 # else
13519 # endif
13521 }
13522 #endif
13525 }
13527 /*
13528 * "remote_send()" function
13529 */
13530 /*ARGSUSED*/
13531 static void
13535 {
13538 #ifdef FEAT_CLIENTSERVER
13540 #endif
13541 }
13543 /*
13544 * "remove()" function
13545 */
13546 static void
13550 {
13562 {
13567 {
13570 {
13574 else
13575 {
13579 }
13580 }
13581 }
13582 }
13587 {
13595 else
13596 {
13598 {
13599 /* Remove one item, return its value. */
13603 }
13604 else
13605 {
13606 /* Remove range of items, return list with values. */
13612 else
13613 {
13617 {
13621 }
13624 else
13625 {
13628 {
13635 }
13636 }
13637 }
13638 }
13639 }
13640 }
13641 }
13643 /*
13644 * "rename({from}, {to})" function
13645 */
13646 static void
13650 {
13655 else
13658 }
13660 /*
13661 * "repeat()" function
13662 */
13663 /*ARGSUSED*/
13664 static void
13668 {
13678 {
13684 }
13685 else
13686 {
13698 {
13702 }
13705 }
13706 }
13708 /*
13709 * "resolve()" function
13710 */
13711 static void
13715 {
13719 #ifdef FEAT_SHORTCUT
13720 {
13726 else
13728 }
13729 #else
13730 # ifdef HAVE_READLINK
13731 {
13753 {
13754 /* Separate the first path component in "p", and keep the
13755 * remainder (beginning with the path separator). */
13758 }
13761 {
13763 {
13770 {
13776 }
13778 /* Ensure that the result will have a trailing path separator
13779 * if the argument has one. */
13783 /* Separate the first path component in the link value and
13784 * concatenate the remainders. */
13787 {
13790 else
13791 {
13794 {
13797 }
13798 }
13800 }
13804 {
13805 /* Ignore trailing path separator. */
13808 }
13810 {
13811 /* symlink is relative to directory of argument */
13814 {
13819 }
13820 }
13821 else
13822 {
13825 }
13826 }
13831 /* Append the first path component of "remain" to "p". */
13836 {
13840 }
13841 /* Shorten "remain". */
13844 else
13845 {
13848 }
13849 }
13851 /* If the result is a relative path name, make it explicitly relative to
13852 * the current directory if and only if the argument had this form. */
13854 {
13863 {
13864 /* Prepend "./". */
13867 {
13870 }
13871 }
13873 {
13874 /* Strip leading "./". */
13880 }
13881 }
13883 /* Ensure that the result will have no trailing path separator
13884 * if the argument had none. But keep "/" or "//". */
13886 {
13890 }
13893 }
13894 # else
13896 # endif
13897 #endif
13901 #ifdef HAVE_READLINK
13902 fail:
13903 #endif
13905 }
13907 /*
13908 * "reverse({list})" function
13909 */
13910 static void
13914 {
13923 {
13928 {
13932 }
13936 }
13937 }
13949 /*
13950 * Get flags for a search function.
13951 * Possibly sets "p_ws".
13952 * Returns BACKWARD, FORWARD or zero (for an error).
13953 */
13954 static int
13958 {
13965 {
13970 {
13972 {
13979 {
13987 }
13989 {
13992 }
13993 else
13995 }
13999 }
14000 }
14002 }
14004 /*
14005 * Shared by search() and searchpos() functions
14006 */
14007 static int
14012 {
14015 pos_T pos;
14016 pos_T save_cursor;
14034 /* Optional extra argument: line number to stop searching. */
14037 {
14041 }
14043 /*
14044 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14045 * Check to make sure only those flags are set.
14046 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14047 * flags cannot be set. Check for that condition also.
14048 */
14051 {
14054 }
14060 {
14063 else
14069 {
14070 /* Store the match cursor position */
14073 }
14074 /* "/$" will put the cursor after the end of the line, may need to
14075 * correct that here */
14077 }
14079 /* If 'n' flag is used: restore cursor position. */
14082 else
14084 theend:
14088 }
14090 /*
14091 * "search()" function
14092 */
14093 static void
14097 {
14101 }
14103 /*
14104 * "searchdecl()" function
14105 */
14106 static void
14110 {
14120 {
14124 }
14128 }
14130 /*
14131 * Used by searchpair() and searchpairpos()
14132 */
14133 static int
14137 {
14149 /* Get the three pattern arguments: start, middle, end. */
14156 /* Handle the optional fourth argument: flags */
14161 /* Don't accept SP_END or SP_SUBPAT.
14162 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14163 */
14166 {
14169 }
14171 /* Optional fifth argument: skip expression */
14175 else
14176 {
14179 {
14183 }
14184 }
14191 theend:
14195 }
14197 /*
14198 * "searchpair()" function
14199 */
14200 static void
14204 {
14206 }
14208 /*
14209 * "searchpairpos()" function
14210 */
14211 static void
14215 {
14216 pos_T match_pos;
14226 {
14229 }
14233 }
14235 /*
14236 * Search for a start/middle/end thing.
14237 * Used by searchpair(), see its documentation for the details.
14238 * Returns 0 or -1 for no match,
14239 */
14240 long
14250 {
14254 pos_T pos;
14255 pos_T firstpos;
14256 pos_T foundpos;
14257 pos_T save_cursor;
14258 pos_T save_pos;
14265 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14269 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14270 * start/middle/end (pat3, for the top pair). */
14278 else
14290 {
14294 /* didn't find it or found the first match again: FAIL */
14300 {
14301 /* Found the same position again. Can happen with a pattern that
14302 * has "\zs" at the end and searching backwards. Advance one
14303 * character and try again. */
14306 else
14308 }
14311 /* If the skip pattern matches, ignore this match. */
14313 {
14319 {
14320 /* Evaluating {skip} caused an error, break here. */
14324 }
14327 }
14330 {
14331 /* Found end when searching backwards or start when searching
14332 * forward: nested pair. */
14335 }
14336 else
14337 {
14338 /* Found end when searching forward or start when searching
14339 * backward: end of (nested) pair; or found middle in outer pair. */
14342 }
14345 {
14346 /* Found the match: return matchcount or line number. */
14349 else
14357 }
14358 }
14361 {
14362 /* Store the match cursor position */
14365 }
14367 /* If 'n' flag is used or search failed: restore cursor position. */
14371 theend:
14377 }
14379 /*
14380 * "searchpos()" function
14381 */
14382 static void
14386 {
14387 pos_T match_pos;
14400 {
14403 }
14409 }
14412 /*ARGSUSED*/
14413 static void
14417 {
14418 #ifdef FEAT_CLIENTSERVER
14428 # ifdef FEAT_X11
14431 # endif
14434 {
14437 }
14439 #else
14441 #endif
14442 }
14444 /*ARGSUSED*/
14445 static void
14449 {
14452 #ifdef FEAT_CLIENTSERVER
14453 # ifdef WIN32
14455 # else
14459 # endif
14460 #endif
14463 }
14465 /*
14466 * "setbufvar()" function
14467 */
14468 /*ARGSUSED*/
14469 static void
14473 {
14475 aco_save_T aco;
14490 {
14491 /* set curbuf to be our buf, temporarily */
14495 {
14505 }
14506 else
14507 {
14510 {
14515 }
14516 }
14518 /* reset notion of buffer */
14520 }
14521 }
14523 /*
14524 * "setcmdpos()" function
14525 */
14526 static void
14530 {
14535 }
14537 /*
14538 * "setline()" function
14539 */
14540 static void
14544 {
14545 linenr_T lnum;
14554 {
14557 }
14558 else
14563 {
14565 {
14566 /* list argument, get next string */
14571 }
14577 {
14578 /* existing line, replace it */
14580 {
14585 }
14586 }
14588 {
14589 /* lnum is one past the last line, append the line */
14593 }
14598 }
14602 }
14604 /*
14605 * Used by "setqflist()" and "setloclist()" functions
14606 */
14607 /*ARGSUSED*/
14608 static void
14614 {
14615 #ifdef FEAT_QUICKFIX
14618 #endif
14622 #ifdef FEAT_QUICKFIX
14625 else
14626 {
14630 {
14636 }
14640 }
14641 #endif
14642 }
14644 /*
14645 * "setloclist()" function
14646 */
14647 /*ARGSUSED*/
14648 static void
14652 {
14660 }
14662 /*
14663 * "setmatches()" function
14664 */
14665 static void
14669 {
14670 #ifdef FEAT_SEARCH_EXTRA
14677 {
14680 }
14682 {
14684 /* To some extent make sure that we are dealing with a list from
14685 * "getmatches()". */
14688 {
14691 {
14694 }
14699 {
14702 }
14704 }
14709 {
14716 }
14718 }
14719 #endif
14720 }
14722 /*
14723 * "setpos()" function
14724 */
14725 /*ARGSUSED*/
14726 static void
14730 {
14731 pos_T pos;
14737 {
14739 {
14742 {
14744 {
14747 }
14748 else
14750 }
14753 else
14755 }
14756 }
14757 }
14759 /*
14760 * "setqflist()" function
14761 */
14762 /*ARGSUSED*/
14763 static void
14767 {
14769 }
14771 /*
14772 * "setreg()" function
14773 */
14774 static void
14778 {
14784 char_u yank_type;
14803 {
14809 {
14819 #ifdef FEAT_VISUAL
14823 {
14827 }
14829 #endif
14830 }
14831 }
14838 }
14840 /*
14841 * "settabwinvar()" function
14842 */
14843 static void
14847 {
14849 }
14851 /*
14852 * "setwinvar()" function
14853 */
14854 static void
14858 {
14860 }
14862 /*
14863 * "setwinvar()" and "settabwinvar()" functions
14864 */
14865 static void
14870 {
14872 #ifdef FEAT_WINDOWS
14875 #endif
14886 #ifdef FEAT_WINDOWS
14889 else
14891 #endif
14897 {
14898 #ifdef FEAT_WINDOWS
14899 /* set curwin to be our win, temporarily */
14907 #endif
14910 {
14920 }
14921 else
14922 {
14925 {
14930 }
14931 }
14933 #ifdef FEAT_WINDOWS
14934 /* Restore current tabpage and window, if still valid (autocomands can
14935 * make them invalid). */
14939 {
14942 }
14943 #endif
14944 }
14945 }
14947 /*
14948 * "shellescape({string})" function
14949 */
14950 static void
14954 {
14957 }
14959 /*
14960 * "simplify()" function
14961 */
14962 static void
14966 {
14973 }
14975 static int
14976 #ifdef __BORLANDC__
14977 _RTLENTRYF
14978 #endif
14980 static int
14981 #ifdef __BORLANDC__
14982 _RTLENTRYF
14983 #endif
14989 #define ITEM_COMPARE_FAIL 999
14991 /*
14992 * Compare functions for f_sort() below.
14993 */
14994 static int
14995 #ifdef __BORLANDC__
14996 _RTLENTRYF
14997 #endif
15001 {
15016 else
15021 }
15023 static int
15024 #ifdef __BORLANDC__
15025 _RTLENTRYF
15026 #endif
15030 {
15032 typval_T rettv;
15036 /* shortcut after failure in previous call; compare all items equal */
15040 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15041 * in the copy without changing the original list items. */
15053 else
15054 /* return value has wrong type */
15060 }
15062 /*
15063 * "sort({list})" function
15064 */
15065 static void
15069 {
15079 else
15080 {
15095 {
15098 else
15099 {
15107 else
15109 }
15110 }
15112 /* Make an array with each entry pointing to an item in the List. */
15121 /* test the compare function */
15126 else
15127 {
15128 /* Sort the array with item pointers. */
15133 {
15134 /* Clear the List and append the items in the sorted order. */
15139 }
15140 }
15143 }
15144 }
15146 /*
15147 * "soundfold({word})" function
15148 */
15149 static void
15153 {
15158 #ifdef FEAT_SPELL
15160 #else
15162 #endif
15163 }
15165 /*
15166 * "spellbadword()" function
15167 */
15168 /* ARGSUSED */
15169 static void
15173 {
15181 #ifdef FEAT_SPELL
15183 {
15184 /* Find the start and length of the badly spelled word. */
15188 }
15190 {
15195 {
15196 /* Check the argument for spelling. */
15198 {
15201 {
15204 }
15206 }
15207 }
15208 }
15209 #endif
15218 }
15220 /*
15221 * "spellsuggest()" function
15222 */
15223 /*ARGSUSED*/
15224 static void
15228 {
15229 #ifdef FEAT_SPELL
15233 garray_T ga;
15237 #endif
15242 #ifdef FEAT_SPELL
15244 {
15247 {
15252 {
15256 }
15257 }
15258 else
15264 {
15270 else
15271 {
15276 }
15277 }
15279 }
15280 #endif
15281 }
15283 static void
15287 {
15291 regmatch_T regmatch;
15299 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15305 {
15311 }
15322 {
15325 {
15328 else
15332 else
15336 {
15340 }
15343 /* Advance to just after the match. */
15346 else
15347 {
15348 /* Don't get stuck at the same match. */
15349 #ifdef FEAT_MBYTE
15351 #else
15353 #endif
15354 }
15356 }
15359 }
15362 }
15364 /*
15365 * "str2nr()" function
15366 */
15367 static void
15371 {
15377 {
15380 {
15383 }
15384 }
15389 }
15391 #ifdef HAVE_STRFTIME
15392 /*
15393 * "strftime({format}[, {time}])" function
15394 */
15395 static void
15399 {
15410 else
15413 /* MSVC returns NULL for an invalid value of seconds. */
15416 else
15417 {
15418 # ifdef FEAT_MBYTE
15419 vimconv_T conv;
15427 # endif
15431 else
15434 # ifdef FEAT_MBYTE
15440 else
15441 # endif
15444 # ifdef FEAT_MBYTE
15445 /* Release conversion descriptors */
15448 # endif
15449 }
15450 }
15451 #endif
15453 /*
15454 * "stridx()" function
15455 */
15456 static void
15460 {
15475 {
15483 }
15488 }
15490 /*
15491 * "string()" function
15492 */
15493 static void
15497 {
15503 /* Make a copy if we have a value but it's not in allocate memory. */
15506 }
15508 /*
15509 * "strlen()" function
15510 */
15511 static void
15515 {
15518 }
15520 /*
15521 * "strpart()" function
15522 */
15523 static void
15527 {
15542 else
15545 /*
15546 * Only return the overlap between the specified part and the actual
15547 * string.
15548 */
15550 {
15553 }
15563 }
15565 /*
15566 * "strridx()" function
15567 */
15568 static void
15572 {
15589 {
15590 /* Third argument: upper limit for index */
15594 }
15595 else
15599 {
15600 /* Empty string matches past the end. */
15602 }
15603 else
15604 {
15606 {
15611 }
15612 }
15616 else
15618 }
15620 /*
15621 * "strtrans()" function
15622 */
15623 static void
15627 {
15630 }
15632 /*
15633 * "submatch()" function
15634 */
15635 static void
15639 {
15643 }
15645 /*
15646 * "substitute()" function
15647 */
15648 static void
15652 {
15665 else
15667 }
15669 /*
15670 * "synID(lnum, col, trans)" function
15671 */
15672 /*ARGSUSED*/
15673 static void
15677 {
15679 #ifdef FEAT_SYN_HL
15692 #endif
15695 }
15697 /*
15698 * "synIDattr(id, what [, mode])" function
15699 */
15700 /*ARGSUSED*/
15701 static void
15705 {
15707 #ifdef FEAT_SYN_HL
15717 {
15721 #ifdef FEAT_GUI
15723 #endif
15724 )
15726 }
15727 else
15728 {
15729 #ifdef FEAT_GUI
15732 else
15733 #endif
15736 else
15738 }
15742 {
15775 /* underline */
15777 else
15778 /* undercurl */
15781 }
15785 #endif
15788 }
15790 /*
15791 * "synIDtrans(id)" function
15792 */
15793 /*ARGSUSED*/
15794 static void
15798 {
15801 #ifdef FEAT_SYN_HL
15806 else
15807 #endif
15811 }
15813 /*
15814 * "system()" function
15815 */
15816 static void
15820 {
15832 {
15833 /*
15834 * Write the string to a temp file, to be used for input of the shell
15835 * command.
15836 */
15838 {
15841 }
15845 {
15848 }
15851 {
15854 }
15860 {
15863 }
15864 }
15869 #ifdef USE_CR
15870 /* translate <CR> into <NL> */
15872 {
15876 {
15879 }
15880 }
15881 #else
15882 # ifdef USE_CRNL
15883 /* translate <CR><NL> into <NL> */
15885 {
15890 {
15894 }
15896 }
15897 # endif
15898 #endif
15900 done:
15902 {
15905 }
15908 }
15910 /*
15911 * "tabpagebuflist()" function
15912 */
15913 /* ARGSUSED */
15914 static void
15918 {
15919 #ifndef FEAT_WINDOWS
15921 #else
15927 else
15928 {
15932 }
15935 else
15936 {
15939 else
15940 {
15945 }
15946 }
15947 #endif
15948 }
15951 /*
15952 * "tabpagenr()" function
15953 */
15954 /* ARGSUSED */
15955 static void
15959 {
15961 #ifdef FEAT_WINDOWS
15965 {
15969 {
15972 else
15974 }
15975 }
15976 else
15978 #endif
15980 }
15983 #ifdef FEAT_WINDOWS
15986 /*
15987 * Common code for tabpagewinnr() and winnr().
15988 */
15989 static int
15993 {
16001 {
16008 {
16012 }
16013 else
16014 {
16017 }
16018 }
16023 {
16025 {
16026 /* didn't find it in this tabpage */
16029 }
16031 }
16033 }
16034 #endif
16036 /*
16037 * "tabpagewinnr()" function
16038 */
16039 /* ARGSUSED */
16040 static void
16044 {
16046 #ifdef FEAT_WINDOWS
16052 else
16054 #endif
16056 }
16059 /*
16060 * "tagfiles()" function
16061 */
16062 /*ARGSUSED*/
16063 static void
16067 {
16069 tagname_T tn;
16073 {
16076 }
16083 }
16085 /*
16086 * "taglist()" function
16087 */
16088 static void
16092 {
16103 }
16105 /*
16106 * "tempname()" function
16107 */
16108 /*ARGSUSED*/
16109 static void
16113 {
16119 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16120 * names. Skip 'I' and 'O', they are used for shell redirection. */
16121 do
16122 {
16127 else
16128 {
16129 #ifdef EBCDIC
16134 else
16135 #endif
16137 }
16139 }
16141 /*
16142 * "test(list)" function: Just checking the walls...
16143 */
16144 /*ARGSUSED*/
16145 static void
16149 {
16150 /* Used for unit testing. Change the code below to your liking. */
16151 #if 0
16170 #endif
16171 }
16173 /*
16174 * "tolower(string)" function
16175 */
16176 static void
16180 {
16189 {
16190 #ifdef FEAT_MBYTE
16194 {
16200 /* TODO: reallocate string when byte count changes. */
16204 }
16207 else
16208 #endif
16209 {
16212 }
16213 }
16214 }
16216 /*
16217 * "toupper(string)" function
16218 */
16219 static void
16223 {
16226 }
16228 /*
16229 * "tr(string, fromstr, tostr)" function
16230 */
16231 static void
16235 {
16240 #ifdef FEAT_MBYTE
16248 #endif
16251 garray_T ga;
16257 /* Default return value: empty string. */
16264 #ifdef FEAT_MBYTE
16266 #endif
16267 /* not multi-byte: fromstr and tostr must be the same length */
16269 {
16270 #ifdef FEAT_MBYTE
16271 error:
16272 #endif
16276 }
16278 /* fromstr and tostr have to contain the same number of chars */
16280 {
16281 #ifdef FEAT_MBYTE
16283 {
16289 {
16292 {
16294 {
16297 {
16301 }
16302 }
16306 }
16308 }
16311 {
16312 /* Check that fromstr and tostr have the same number of
16313 * (multi-byte) characters. Done only once when a character
16314 * of instr doesn't appear in fromstr. */
16317 {
16320 }
16323 }
16330 }
16331 else
16332 #endif
16333 {
16334 /* When not using multi-byte chars we can do it faster. */
16338 else
16341 }
16342 }
16344 /* add a terminating NUL */
16349 }
16351 /*
16352 * "type(expr)" function
16353 */
16354 static void
16358 {
16362 {
16369 }
16371 }
16373 /*
16374 * "values(dict)" function
16375 */
16376 static void
16380 {
16382 }
16384 /*
16385 * "virtcol(string)" function
16386 */
16387 static void
16391 {
16399 {
16402 }
16405 }
16407 /*
16408 * "visualmode()" function
16409 */
16410 /*ARGSUSED*/
16411 static void
16415 {
16416 #ifdef FEAT_VISUAL
16424 /* A non-zero number or non-empty string argument: reset mode. */
16430 #else
16432 #endif
16433 }
16435 /*
16436 * "winbufnr(nr)" function
16437 */
16438 static void
16442 {
16448 else
16450 }
16452 /*
16453 * "wincol()" function
16454 */
16455 /*ARGSUSED*/
16456 static void
16460 {
16463 }
16465 /*
16466 * "winheight(nr)" function
16467 */
16468 static void
16472 {
16478 else
16480 }
16482 /*
16483 * "winline()" function
16484 */
16485 /*ARGSUSED*/
16486 static void
16490 {
16493 }
16495 /*
16496 * "winnr()" function
16497 */
16498 /* ARGSUSED */
16499 static void
16503 {
16506 #ifdef FEAT_WINDOWS
16508 #endif
16510 }
16512 /*
16513 * "winrestcmd()" function
16514 */
16515 /* ARGSUSED */
16516 static void
16520 {
16521 #ifdef FEAT_WINDOWS
16524 garray_T ga;
16529 {
16532 # ifdef FEAT_VERTSPLIT
16535 # endif
16537 }
16541 #else
16543 #endif
16545 }
16547 /*
16548 * "winrestview()" function
16549 */
16550 /* ARGSUSED */
16551 static void
16555 {
16561 else
16562 {
16565 #ifdef FEAT_VIRTUALEDIT
16567 #endif
16572 #ifdef FEAT_DIFF
16574 #endif
16587 #ifdef FEAT_DIFF
16589 #endif
16590 }
16591 }
16593 /*
16594 * "winsaveview()" function
16595 */
16596 /* ARGSUSED */
16597 static void
16601 {
16613 #ifdef FEAT_VIRTUALEDIT
16615 #endif
16620 #ifdef FEAT_DIFF
16622 #endif
16625 }
16627 /*
16628 * "winwidth(nr)" function
16629 */
16630 static void
16634 {
16640 else
16641 #ifdef FEAT_VERTSPLIT
16643 #else
16645 #endif
16646 }
16648 /*
16649 * "writefile()" function
16650 */
16651 static void
16655 {
16668 {
16671 }
16679 /* Always open the file in binary mode, library functions have a mind of
16680 * their own about CR-LF conversion. */
16683 {
16686 }
16687 else
16688 {
16691 {
16693 {
16696 else
16699 {
16702 }
16703 }
16706 {
16709 }
16711 {
16714 }
16715 }
16717 }
16720 }
16722 /*
16723 * Translate a String variable into a position.
16724 * Returns NULL when there is an error.
16725 */
16731 {
16736 /* Argument can be [lnum, col, coladd]. */
16738 {
16748 /* Get the line number */
16753 /* Get the column number */
16759 /* We accept "$" for the column number: last column. */
16766 /* Accept a position up to the NUL after the line. */
16771 #ifdef FEAT_VIRTUALEDIT
16772 /* Get the virtual offset. Defaults to zero. */
16776 #endif
16779 }
16787 {
16792 }
16794 #ifdef FEAT_VIRTUALEDIT
16796 #endif
16799 {
16802 {
16806 }
16808 {
16812 }
16813 }
16815 {
16817 {
16820 }
16821 else
16822 {
16825 }
16827 }
16829 }
16831 /*
16832 * Convert list in "arg" into a position and optional file number.
16833 * When "fnump" is NULL there is no file number, only 3 items.
16834 * Note that the column is passed on as-is, the caller may want to decrement
16835 * it to use 1 for the first column.
16836 * Return FAIL when conversion is not possible, doesn't check the position for
16837 * validity.
16838 */
16839 static int
16844 {
16849 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16850 * when "fnump" isn't NULL and "coladd" is optional. */
16858 {
16865 }
16877 #ifdef FEAT_VIRTUALEDIT
16881 else
16883 #endif
16886 }
16888 /*
16889 * Get the length of an environment variable name.
16890 * Advance "arg" to the first character after the name.
16891 * Return 0 for error.
16892 */
16893 static int
16896 {
16901 ;
16908 }
16910 /*
16911 * Get the length of the name of a function or internal variable.
16912 * "arg" is advanced to the first non-white character after the name.
16913 * Return 0 if something is wrong.
16914 */
16915 static int
16918 {
16922 /* Find the end of the name. */
16924 ;
16932 }
16934 /*
16935 * Get the length of the name of a variable or function.
16936 * Only the name is recognized, does not handle ".key" or "[idx]".
16937 * "arg" is advanced to the first non-white character after the name.
16938 * Return -1 if curly braces expansion failed.
16939 * Return 0 if something else is wrong.
16940 * If the name contains 'magic' {}'s, expand them and return the
16941 * expanded name in an allocated string via 'alias' - caller must free.
16942 */
16943 static int
16949 {
16959 {
16960 /* hard coded <SNR>, already translated */
16963 }
16966 {
16967 /* literal "<SID>", "s:" or "<SNR>" */
16969 }
16971 /*
16972 * Find the end of the name; check for {} construction.
16973 */
16977 {
16981 {
16985 }
16987 /*
16988 * Include any <SID> etc in the expanded string:
16989 * Thus the -len here.
16990 */
16997 }
17004 }
17006 /*
17007 * Find the end of a variable or function name, taking care of magic braces.
17008 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17009 * start and end of the first magic braces item.
17010 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17011 * Return a pointer to just after the name. Equal to "arg" if there is no
17012 * valid name.
17013 */
17020 {
17026 {
17029 }
17031 /* Quick check for valid starting character. */
17041 {
17043 {
17044 /* skip over 'string' to avoid counting [ and ] inside it. */
17046 ;
17049 }
17051 {
17052 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17058 }
17061 {
17066 }
17069 {
17071 {
17072 mb_nest++;
17075 }
17077 {
17078 mb_nest--;
17081 }
17082 }
17083 }
17086 }
17088 /*
17089 * Expands out the 'magic' {}'s in a variable/function name.
17090 * Note that this can call itself recursively, to deal with
17091 * constructs like foo{bar}{baz}{bam}
17092 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17093 * "in_start" ^
17094 * "expr_start" ^
17095 * "expr_end" ^
17096 * "in_end" ^
17097 *
17098 * Returns a new allocated string, which the caller must free.
17099 * Returns NULL for failure.
17100 */
17107 {
17108 char_u c1;
17122 {
17126 {
17130 }
17131 }
17139 {
17142 {
17143 /* Further expansion! */
17148 }
17149 }
17152 }
17154 /*
17155 * Return TRUE if character "c" can be used in a variable or function name.
17156 * Does not include '{' or '}' for magic braces.
17157 */
17158 static int
17161 {
17163 }
17165 /*
17166 * Return TRUE if character "c" can be used as the first character in a
17167 * variable or function name (excluding '{' and '}').
17168 */
17169 static int
17172 {
17174 }
17176 /*
17177 * Set number v: variable to "val".
17178 */
17179 void
17183 {
17185 }
17187 /*
17188 * Get number v: variable value.
17189 */
17190 long
17193 {
17195 }
17197 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17198 /*
17199 * Get string v: variable value. Uses a static buffer, can only be used once.
17200 */
17201 char_u *
17204 {
17206 }
17207 #endif
17209 /*
17210 * Set v:count, v:count1 and v:prevcount.
17211 */
17212 void
17216 {
17220 }
17222 /*
17223 * Set string v: variable to a copy of "val".
17224 */
17225 void
17230 {
17231 /* Need to do this (at least) once, since we can't initialize a union.
17232 * Will always be invoked when "v:progname" is set. */
17240 else
17242 }
17244 /*
17245 * Set v:register if needed.
17246 */
17247 void
17250 {
17251 char_u regname;
17255 else
17257 /* Avoid free/alloc when the value is already right. */
17260 }
17262 /*
17263 * Get or set v:exception. If "oldval" == NULL, return the current value.
17264 * Otherwise, restore the value to "oldval" and return NULL.
17265 * Must always be called in pairs to save and restore v:exception! Does not
17266 * take care of memory allocations.
17267 */
17268 char_u *
17271 {
17277 }
17279 /*
17280 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17281 * Otherwise, restore the value to "oldval" and return NULL.
17282 * Must always be called in pairs to save and restore v:throwpoint! Does not
17283 * take care of memory allocations.
17284 */
17285 char_u *
17288 {
17294 }
17296 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17297 /*
17298 * Set v:cmdarg.
17299 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17300 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17301 * Must always be called in pairs!
17302 */
17303 char_u *
17307 {
17314 {
17318 }
17324 else
17332 # ifdef FEAT_MBYTE
17337 # endif
17347 else
17356 # ifdef FEAT_MBYTE
17363 # endif
17366 }
17367 #endif
17369 /*
17370 * Get the value of internal variable "name".
17371 * Return OK or FAIL.
17372 */
17373 static int
17379 {
17382 typval_T atv;
17386 /* truncate the name, so that we can use strcmp() */
17390 /*
17391 * Check for "b:changedtick".
17392 */
17394 {
17398 }
17400 /*
17401 * Check for user-defined variables.
17402 */
17403 else
17404 {
17408 }
17411 {
17415 }
17422 }
17424 /*
17425 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17426 * Also handle function call with Funcref variable: func(expr)
17427 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17428 */
17429 static int
17435 {
17440 typval_T functv;
17447 {
17449 {
17450 /* need to copy the funcref so that we can clear rettv */
17454 /* Invoke the function. Recursive! */
17460 /* Clear the funcref afterwards, so that deleting it while
17461 * evaluating the arguments is possible (see test55). */
17464 /* Stop the expression evaluation when immediately aborting on
17465 * error, or when an interrupt occurred or an exception was thrown
17466 * but not caught. */
17468 {
17472 }
17475 }
17477 {
17480 {
17484 }
17485 else
17488 {
17491 }
17492 }
17493 }
17496 }
17498 /*
17499 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17500 * value).
17501 */
17504 {
17506 }
17508 /*
17509 * Allocate memory for a variable type-value, and assign a string to it.
17510 * The string "s" must have been allocated, it is consumed.
17511 * Return NULL for out of memory, the variable otherwise.
17512 */
17516 {
17521 {
17524 }
17525 else
17528 }
17530 /*
17531 * Free the memory for a variable type-value.
17532 */
17533 void
17536 {
17538 {
17540 {
17543 /*FALLTHROUGH*/
17559 }
17561 }
17562 }
17564 /*
17565 * Free the memory for a variable value and set the value to NULL or 0.
17566 */
17567 void
17570 {
17572 {
17574 {
17577 /*FALLTHROUGH*/
17597 }
17599 }
17600 }
17602 /*
17603 * Set the value of a variable to NULL without freeing items.
17604 */
17605 static void
17608 {
17611 }
17613 /*
17614 * Get the number value of a variable.
17615 * If it is a String variable, uses vim_str2nr().
17616 * For incompatible types, return 0.
17617 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17618 * caller of incompatible types: it sets *denote to TRUE if "denote"
17619 * is not NULL or returns -1 otherwise.
17620 */
17621 static long
17624 {
17628 }
17630 long
17634 {
17638 {
17658 }
17661 else
17664 }
17666 /*
17667 * Get the lnum from the first argument.
17668 * Also accepts ".", "$", etc., but that only works for the current buffer.
17669 * Returns -1 on error.
17670 */
17671 static linenr_T
17674 {
17675 typval_T rettv;
17676 linenr_T lnum;
17680 {
17685 }
17687 }
17689 /*
17690 * Get the lnum from the first argument.
17691 * Also accepts "$", then "buf" is used.
17692 * Returns 0 on error.
17693 */
17694 static linenr_T
17698 {
17705 }
17707 /*
17708 * Get the string value of a variable.
17709 * If it is a Number variable, the number is converted into a string.
17710 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17711 * get_tv_string_buf() uses a given buffer.
17712 * If the String variable has never been set, return an empty string.
17713 * Never returns NULL;
17714 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17715 * NULL on error.
17716 */
17720 {
17724 }
17730 {
17734 }
17736 char_u *
17739 {
17743 }
17749 {
17751 {
17771 }
17773 }
17775 /*
17776 * Find variable "name" in the list of variables.
17777 * Return a pointer to it if found, NULL if not found.
17778 * Careful: "a:0" variables don't have a name.
17779 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17780 * hashtab_T used.
17781 */
17786 {
17796 }
17798 /*
17799 * Find variable "varname" in hashtab "ht".
17800 * Returns NULL if not found.
17801 */
17807 {
17811 {
17812 /* Must be something like "s:", otherwise "ht" would be NULL. */
17814 {
17820 #ifdef FEAT_WINDOWS
17822 #endif
17827 }
17829 }
17833 {
17834 /* For global variables we may try auto-loading the script. If it
17835 * worked find the variable again. Don't auto-load a script if it was
17836 * loaded already, otherwise it would be loaded every time when
17837 * checking if a function name is a Funcref variable. */
17843 }
17845 }
17847 /*
17848 * Find the hashtab used for a variable name.
17849 * Set "varname" to the start of name without ':'.
17850 */
17855 {
17859 {
17860 /* The name must not start with a colon or #. */
17865 /* "version" is "v:version" in all scopes */
17873 }
17877 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17878 */
17886 #ifdef FEAT_WINDOWS
17889 #endif
17900 }
17902 /*
17903 * Get the string value of a (global/local) variable.
17904 * Returns NULL when it doesn't exist.
17905 */
17906 char_u *
17909 {
17916 }
17918 /*
17919 * Allocate a new hashtab for a sourced script. It will be used while
17920 * sourcing this script and when executing functions defined in the script.
17921 */
17922 void
17924 scid_T id;
17925 {
17931 {
17932 /* Re-allocating ga_data means that an ht_array pointing to
17933 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
17934 * at its init value. Also reset "v_dict", it's always the same. */
17936 {
17942 }
17945 {
17949 }
17950 }
17951 }
17953 /*
17954 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
17955 * point to it.
17956 */
17957 void
17961 {
17969 }
17971 /*
17972 * Clean up a list of internal variables.
17973 * Frees all allocated variables and the value they contain.
17974 * Clears hashtab "ht", does not free it.
17975 */
17976 void
17979 {
17981 }
17983 /*
17984 * Like vars_clear(), but only free the value if "free_val" is TRUE.
17985 */
17986 static void
17990 {
17998 {
18000 {
18003 /* Free the variable. Don't remove it from the hashtab,
18004 * ht_array might change then. hash_clear() takes care of it
18005 * later. */
18011 }
18012 }
18015 }
18017 /*
18018 * Delete a variable from hashtab "ht" at item "hi".
18019 * Clear the variable value and free the dictitem.
18020 */
18021 static void
18025 {
18031 }
18033 /*
18034 * List the value of one internal variable.
18035 */
18036 static void
18041 {
18050 }
18052 static void
18059 {
18060 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18072 {
18076 }
18078 {
18082 }
18083 else
18091 {
18094 }
18095 }
18097 /*
18098 * Set variable "name" to value in "tv".
18099 * If the variable already exists, the value is updated.
18100 * Otherwise the variable is created.
18101 */
18102 static void
18107 {
18114 {
18118 {
18121 }
18123 {
18125 name);
18127 }
18128 }
18132 {
18135 }
18139 {
18140 /* existing variable, need to clear the value */
18149 {
18152 }
18154 /*
18155 * Handle setting internal v: variables separately: we don't change
18156 * the type.
18157 */
18159 {
18161 {
18165 else
18166 {
18167 /* Take over the string to avoid an extra alloc/free. */
18170 }
18171 }
18174 else
18177 }
18180 }
18182 {
18183 /* Can't add "v:" variable. */
18185 {
18188 }
18190 /* Make sure the variable name is valid. */
18194 {
18197 }
18205 {
18208 }
18210 }
18214 else
18215 {
18219 }
18220 }
18222 /*
18223 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18224 * Also give an error message.
18225 */
18226 static int
18230 {
18232 {
18235 }
18237 {
18240 }
18242 }
18244 /*
18245 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18246 * Also give an error message.
18247 */
18248 static int
18252 {
18254 {
18257 }
18259 }
18261 /*
18262 * Return TRUE if typeval "tv" is set to be locked (immutable).
18263 * Also give an error message, using "name".
18264 */
18265 static int
18269 {
18271 {
18275 }
18277 {
18281 }
18283 }
18285 /*
18286 * Copy the values from typval_T "from" to typval_T "to".
18287 * When needed allocates string or increases reference count.
18288 * Does not make a copy of a list or dict but copies the reference!
18289 */
18290 static void
18294 {
18298 {
18306 else
18307 {
18311 }
18316 else
18317 {
18320 }
18325 else
18326 {
18329 }
18334 }
18335 }
18337 /*
18338 * Make a copy of an item.
18339 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18340 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18341 * reference to an already copied list/dict can be used.
18342 * Returns FAIL or OK.
18343 */
18344 static int
18350 {
18355 {
18358 }
18362 {
18374 {
18375 /* use the copy made earlier */
18378 }
18379 else
18390 {
18391 /* use the copy made earlier */
18394 }
18395 else
18403 }
18406 }
18408 /*
18409 * ":echo expr1 ..." print each argument separated with a space, add a
18410 * newline at the end.
18411 * ":echon expr1 ..." print each argument plain.
18412 */
18413 void
18416 {
18418 typval_T rettv;
18428 {
18431 {
18432 /*
18433 * Report the invalid expression unless the expression evaluation
18434 * has been cancelled due to an aborting error, an interrupt, or an
18435 * exception.
18436 */
18440 }
18442 {
18444 {
18446 /* Call msg_start() after eval1(), evaluating the expression
18447 * may cause a message to appear. */
18450 }
18456 {
18458 {
18460 {
18461 /* remove any text still there from the command */
18464 }
18466 }
18467 else
18468 {
18469 #ifdef FEAT_MBYTE
18471 {
18476 }
18477 else
18478 #endif
18480 }
18481 }
18483 }
18486 }
18491 else
18492 {
18493 /* remove text that may still be there from the command */
18498 }
18499 }
18501 /*
18502 * ":echohl {name}".
18503 */
18504 void
18507 {
18513 else
18515 }
18517 /*
18518 * ":execute expr1 ..." execute the result of an expression.
18519 * ":echomsg expr1 ..." Print a message
18520 * ":echoerr expr1 ..." Print an error
18521 * Each gets spaces around each argument and a newline at the end for
18522 * echo commands
18523 */
18524 void
18527 {
18529 typval_T rettv;
18532 garray_T ga;
18541 {
18544 {
18545 /*
18546 * Report the invalid expression unless the expression evaluation
18547 * has been cancelled due to an aborting error, an interrupt, or an
18548 * exception.
18549 */
18554 }
18557 {
18561 {
18565 }
18570 }
18574 }
18577 {
18579 {
18582 }
18584 {
18585 /* We don't want to abort following commands, restore did_emsg. */
18590 }
18594 }
18602 }
18604 /*
18605 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18606 * "arg" points to the "&" or '+' when called, to "option" when returning.
18607 * Returns NULL when no option name found. Otherwise pointer to the char
18608 * after the option name.
18609 */
18614 {
18619 {
18622 }
18624 {
18627 }
18628 else
18637 else
18641 }
18643 /*
18644 * ":function"
18645 */
18646 void
18649 {
18658 garray_T newargs;
18659 garray_T newlines;
18668 funcdict_T fudi;
18676 /*
18677 * ":function" without argument: list functions.
18678 */
18680 {
18682 {
18685 {
18687 {
18692 }
18693 }
18694 }
18697 }
18699 /*
18700 * ":function /pat": list functions matching pattern.
18701 */
18703 {
18706 {
18707 regmatch_T regmatch;
18714 {
18719 {
18721 {
18727 }
18728 }
18729 }
18730 }
18735 }
18737 /*
18738 * Get the function name. There are these situations:
18739 * func normal function name
18740 * "name" == func, "fudi.fd_dict" == NULL
18741 * dict.func new dictionary entry
18742 * "name" == NULL, "fudi.fd_dict" set,
18743 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18744 * dict.func existing dict entry with a Funcref
18745 * "name" == func, "fudi.fd_dict" set,
18746 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18747 * dict.func existing dict entry that's not a Funcref
18748 * "name" == NULL, "fudi.fd_dict" set,
18749 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18750 */
18755 {
18756 /*
18757 * Return on an invalid expression in braces, unless the expression
18758 * evaluation has been cancelled due to an aborting error, an
18759 * interrupt, or an exception.
18760 */
18762 {
18767 }
18768 else
18770 }
18772 /* An error in a function call during evaluation of an expression in magic
18773 * braces should not cause the function not to be defined. */
18777 /*
18778 * ":function func" with only function name: list function.
18779 */
18781 {
18783 {
18786 }
18791 {
18794 {
18797 {
18809 }
18811 {
18814 }
18815 }
18816 else
18818 }
18820 }
18822 /*
18823 * ":function name(arg1, arg2)" Define function.
18824 */
18827 {
18829 {
18832 }
18833 /* attempt to continue by skipping some text */
18836 }
18843 {
18844 /* Check the name of the function. Unless it's a dictionary function
18845 * (that we are overwriting). */
18848 else
18852 {
18855 else
18862 }
18863 }
18865 /*
18866 * Isolate the arguments: "arg1, arg2, ...)"
18867 */
18869 {
18871 {
18875 }
18876 else
18877 {
18884 {
18888 }
18901 else
18903 }
18906 {
18910 }
18911 }
18914 /* find extra arguments "range", "dict" and "abort" */
18916 {
18919 {
18922 }
18924 {
18927 }
18929 {
18932 }
18933 else
18935 }
18937 /* When there is a line break use what follows for the function body.
18938 * Makes 'exe "func Test()\n...\nendfunc"' work. */
18944 /*
18945 * Read the body of the function, until ":endfunction" is found.
18946 */
18948 {
18949 /* Check if the function already exists, don't let the user type the
18950 * whole function before telling him it doesn't work! For a script we
18951 * need to skip the body to be able to find what follows. */
18953 {
18958 }
18965 }
18970 {
18976 {
18977 /* Use eap->arg, split up in parts by line breaks. */
18982 else
18983 {
18986 }
18987 }
18990 else
18995 {
18998 }
19000 /* Detect line continuation: sourcing_lnum increased more than one. */
19003 else
19007 {
19008 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19009 * don't check for ":endfunc". */
19011 {
19014 }
19015 }
19016 else
19017 {
19018 /* skip ':' and blanks*/
19020 ;
19022 /* Check for "endfunction". */
19024 {
19028 }
19030 /* Increase indent inside "if", "while", "for" and "try", decrease
19031 * at "end". */
19040 /* Check for defining a function inside this function. */
19042 {
19047 {
19050 {
19053 }
19054 }
19055 }
19057 /* Check for ":append" or ":insert". */
19065 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19078 ))
19079 {
19080 /* ":python <<" continues until a dot, like ":append" */
19084 else
19086 }
19087 }
19089 /* Add the line to the function. */
19091 {
19095 }
19097 /* Copy the line to newly allocated memory. get_one_sourceline()
19098 * allocates 250 bytes per line, this saves 80% on average. The cost
19099 * is an extra alloc/free. */
19102 {
19106 }
19110 /* Add NULL lines for continuation lines, so that the line count is
19111 * equal to the index in the growarray. */
19115 /* Check for end of eap->arg. */
19118 }
19120 /* Don't define the function when skipping commands or when an error was
19121 * detected. */
19125 /*
19126 * If there are no errors, add the function
19127 */
19129 {
19132 {
19134 name);
19136 }
19140 {
19142 {
19145 }
19147 {
19149 name);
19151 }
19152 /* redefine existing function */
19157 }
19158 }
19159 else
19160 {
19165 {
19168 }
19170 {
19171 /* Can't add a function to a locked dictionary */
19174 }
19175 /* Can't change an existing function if it is locked */
19179 /* Give the function a sequential number. Can only be used with a
19180 * Funcref! */
19186 }
19189 {
19191 {
19195 /* Check that the autoload name matches the script name. */
19198 {
19201 {
19209 }
19210 }
19212 {
19215 }
19216 }
19223 {
19225 {
19226 /* add new dict entry */
19229 {
19232 }
19234 {
19238 }
19239 }
19240 else
19241 /* overwrite existing dict entry */
19248 /* behave like "dict" was used */
19250 }
19252 /* insert the new function in the function list */
19255 }
19258 #ifdef FEAT_PROFILE
19265 #endif
19272 erret:
19275 ret_free:
19280 }
19282 /*
19283 * Get a function name, translating "<SID>" and "<SNR>".
19284 * Also handles a Funcref in a List or Dictionary.
19285 * Returns the function name in allocated memory, or NULL for failure.
19286 * flags:
19287 * TFN_INT: internal function name OK
19288 * TFN_QUIET: be quiet
19289 * Advances "pp" to just after the function name (if no error).
19290 */
19297 {
19304 lval_T lv;
19310 /* Check for hard coded <SNR>: already translated function ID (from a user
19311 * command). */
19314 {
19318 }
19320 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19321 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19329 {
19333 }
19335 {
19336 /*
19337 * Report an invalid expression in braces, unless the expression
19338 * evaluation has been cancelled due to an aborting error, an
19339 * interrupt, or an exception.
19340 */
19342 {
19345 }
19346 else
19349 }
19352 {
19354 {
19359 }
19361 {
19364 }
19365 else
19366 {
19370 else
19373 }
19375 }
19378 {
19379 /* Error found, but continue after the function name. */
19382 }
19384 /* Check if the name is a Funcref. If so, use the value. */
19386 {
19391 }
19392 else
19393 {
19398 }
19400 {
19404 }
19407 {
19411 {
19412 /* When there was "s:" already or the name expanded to get a
19413 * leading "s:" then remove it. */
19417 }
19418 }
19419 else
19420 {
19424 }
19426 /*
19427 * Copy the function name to allocated memory.
19428 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19429 * Accept <SNR>123_name() outside a script.
19430 */
19434 {
19438 {
19439 /* It's "s:" or "<SID>" */
19441 {
19444 }
19447 }
19448 }
19450 {
19453 }
19456 {
19458 {
19464 }
19467 }
19470 theend:
19473 }
19475 /*
19476 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19477 * Return 2 if "p" starts with "s:".
19478 * Return 0 otherwise.
19479 */
19480 static int
19483 {
19490 }
19492 /*
19493 * Return TRUE if "p" starts with "<SID>" or "s:".
19494 * Only works if eval_fname_script() returned non-zero for "p"!
19495 */
19496 static int
19499 {
19501 }
19503 /*
19504 * List the head of the function: "name(arg1, arg2)".
19505 */
19506 static void
19510 {
19518 {
19521 }
19522 else
19526 {
19530 }
19532 {
19536 }
19541 }
19543 /*
19544 * Find a function by name, return pointer to it in ufuncs.
19545 * Return NULL for unknown function.
19546 */
19550 {
19557 }
19559 #if defined(EXITFREE) || defined(PROTO)
19560 void
19562 {
19565 /* Need to start all over every time, because func_free() may change the
19566 * hash table. */
19570 {
19573 }
19574 }
19575 #endif
19577 /*
19578 * Return TRUE if a function "name" exists.
19579 */
19580 static int
19583 {
19591 /* Only accept "funcname", "funcname ", "funcname (..." and
19592 * "funcname(...", not "funcname!...". */
19594 {
19597 else
19599 }
19602 }
19604 /*
19605 * Return TRUE if "name" looks like a builtin function name: starts with a
19606 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19607 */
19608 static int
19611 {
19614 }
19616 #if defined(FEAT_PROFILE) || defined(PROTO)
19617 /*
19618 * Start profiling function "fp".
19619 */
19620 static void
19623 {
19642 }
19644 /*
19645 * Dump the profiling results for all functions in file "fd".
19646 */
19647 void
19650 {
19662 {
19664 {
19668 {
19674 else
19678 else
19686 {
19692 }
19694 }
19695 }
19696 }
19699 {
19701 prof_total_cmp);
19704 prof_self_cmp);
19706 }
19707 }
19709 static void
19716 {
19723 {
19726 prefer_self);
19729 else
19731 }
19733 }
19735 /*
19736 * Print the count and times for one function or function line.
19737 */
19738 static void
19745 {
19747 {
19751 else
19755 else
19757 }
19758 else
19760 }
19762 /*
19763 * Compare function for total time sorting.
19764 */
19765 static int
19766 #ifdef __BORLANDC__
19767 _RTLENTRYF
19768 #endif
19772 {
19778 }
19780 /*
19781 * Compare function for self time sorting.
19782 */
19783 static int
19784 #ifdef __BORLANDC__
19785 _RTLENTRYF
19786 #endif
19790 {
19796 }
19798 #endif
19800 /*
19801 * If "name" has a package name try autoloading the script for it.
19802 * Return TRUE if a package was loaded.
19803 */
19804 static int
19808 {
19814 /* If there is no '#' after name[0] there is no package name. */
19821 /* Find the name in the list of previously loaded package names. Skip
19822 * "autoload/", it's always the same. */
19828 else
19829 {
19830 /* Remember the name if it wasn't loaded already. */
19832 {
19835 }
19837 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19840 }
19844 }
19846 /*
19847 * Return the autoload script name for a function or variable name.
19848 * Returns NULL when out of memory.
19849 */
19853 {
19857 /* Get the script file name: replace '#' with '/', append ".vim". */
19868 }
19870 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19872 /*
19873 * Function given to ExpandGeneric() to obtain the list of user defined
19874 * function names.
19875 */
19876 char_u *
19880 {
19886 {
19889 }
19891 {
19903 {
19907 }
19909 }
19911 }
19915 /*
19916 * Copy the function name of "fp" to buffer "buf".
19917 * "buf" must be able to hold the function name plus three bytes.
19918 * Takes care of script-local function names.
19919 */
19920 static void
19924 {
19926 {
19929 }
19930 else
19932 }
19934 /*
19935 * ":delfunction {name}"
19936 */
19937 void
19940 {
19944 funcdict_T fudi;
19950 {
19954 }
19956 {
19960 }
19970 {
19972 {
19975 }
19977 {
19980 }
19983 {
19984 /* Delete the dict item that refers to the function, it will
19985 * invoke func_unref() and possibly delete the function. */
19987 }
19988 else
19990 }
19991 }
19993 /*
19994 * Free a function and remove it from the list of functions.
19995 */
19996 static void
19999 {
20002 /* clear this function */
20005 #ifdef FEAT_PROFILE
20009 #endif
20011 /* remove the function from the function hashtable */
20015 else
20019 }
20021 /*
20022 * Unreference a Function: decrement the reference count and free it when it
20023 * becomes zero. Only for numbered functions.
20024 */
20025 static void
20028 {
20032 {
20037 {
20038 /* Only delete it when it's not being used. Otherwise it's done
20039 * when "uf_calls" becomes zero. */
20042 }
20043 }
20044 }
20046 /*
20047 * Count a reference to a Function.
20048 */
20049 static void
20052 {
20056 {
20060 else
20062 }
20063 }
20065 /*
20066 * Call a user function.
20067 */
20068 static void
20077 {
20079 linenr_T save_sourcing_lnum;
20080 scid_T save_current_SID;
20081 funccall_T fc;
20090 #ifdef FEAT_PROFILE
20091 proftime_T wait_start;
20092 proftime_T call_start;
20093 #endif
20095 /* If depth of calling is getting too high, don't execute the function */
20097 {
20102 }
20115 /* Check if this function has a breakpoint. */
20119 /*
20120 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20121 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20122 * each argument variable and saves a lot of time.
20123 */
20124 /*
20125 * Init l: variables.
20126 */
20129 {
20130 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20131 * some compiler that checks the destination size. */
20141 }
20143 /*
20144 * Init a: variables.
20145 * Set a:0 to "argcount".
20146 * Set a:000 to a list with room for the "..." arguments.
20147 */
20162 /*
20163 * Set a:firstline to "firstline" and a:lastline to "lastline".
20164 * Set a:name to named arguments.
20165 * Set a:N to the "..." arguments.
20166 */
20172 {
20175 /* named argument a:name */
20177 else
20178 {
20179 /* "..." argument a:1, a:2, etc. */
20182 }
20184 {
20187 }
20188 else
20189 {
20195 }
20199 /* Note: the values are copied directly to avoid alloc/free.
20200 * "argvars" must have VAR_FIXED for v_lock. */
20205 {
20209 }
20210 }
20212 /* Don't redraw while executing the function. */
20220 {
20224 else
20229 {
20235 {
20243 {
20248 else
20249 {
20252 {
20256 }
20257 }
20258 }
20260 }
20265 }
20266 }
20267 #ifdef FEAT_PROFILE
20269 {
20274 {
20278 }
20280 }
20281 #endif
20288 /* call do_cmdline() to execute the lines */
20294 /* when the function was aborted because of an error, return -1 */
20296 {
20300 }
20302 #ifdef FEAT_PROFILE
20305 {
20311 {
20314 }
20315 }
20316 #endif
20318 /* when being verbose, mention the return value */
20320 {
20329 else
20330 {
20336 /* The value may be very long. Skip the middle part, so that we
20337 * have some idea how it starts and ends. smsg() would always
20338 * truncate it at the end. */
20341 {
20345 }
20346 }
20351 }
20357 #ifdef FEAT_PROFILE
20360 #endif
20363 {
20372 }
20377 /* The a: variables typevals were not alloced, only free the allocated
20378 * variables. */
20383 }
20385 /*
20386 * Add a number variable "name" to dict "dp" with value "nr".
20387 */
20388 static void
20393 varnumber_T nr;
20394 {
20401 }
20403 /*
20404 * ":return [expr]"
20405 */
20406 void
20409 {
20411 typval_T rettv;
20415 {
20418 }
20426 {
20429 else
20431 }
20432 /* It's safer to return also on error. */
20434 {
20435 /*
20436 * Return unless the expression evaluation has been cancelled due to an
20437 * aborting error, an interrupt, or an exception.
20438 */
20441 }
20443 /* When skipping or the return gets pending, advance to the next command
20444 * in this line (!returning). Otherwise, ignore the rest of the line.
20445 * Following lines will be ignored by get_func_line(). */
20453 }
20455 /*
20456 * Return from a function. Possibly makes the return pending. Also called
20457 * for a pending return at the ":endtry" or after returning from an extra
20458 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20459 * when called due to a ":return" command. "rettv" may point to a typval_T
20460 * with the return rettv. Returns TRUE when the return can be carried out,
20461 * FALSE when the return gets pending.
20462 */
20463 int
20469 {
20474 /* Undo the return. */
20477 /*
20478 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20479 * not in its finally clause (which then is to be executed next) is found.
20480 * In this case, make the ":return" pending for execution at the ":endtry".
20481 * Otherwise, return normally.
20482 */
20485 {
20489 /* A pending return again gets pending. "rettv" points to an
20490 * allocated variable with the rettv of the original ":return"'s
20491 * argument if present or is NULL else. */
20493 else
20494 {
20495 /* When undoing a return in order to make it pending, get the stored
20496 * return rettv. */
20501 {
20502 /* Store the value of the pending return. */
20505 else
20507 }
20508 else
20512 {
20513 /* The pending return value could be overwritten by a ":return"
20514 * without argument in a finally clause; reset the default
20515 * return value. */
20518 }
20519 }
20521 }
20522 else
20523 {
20526 /* If the return is carried out now, store the return value. For
20527 * a return immediately after reanimation, the value is already
20528 * there. */
20530 {
20535 }
20536 }
20539 }
20541 /*
20542 * Free the variable with a pending return value.
20543 */
20544 void
20547 {
20549 }
20551 /*
20552 * Generate a return command for producing the value of "rettv". The result
20553 * is an allocated string. Used by report_pending() for verbose messages.
20554 */
20555 char_u *
20558 {
20574 }
20576 /*
20577 * Get next function line.
20578 * Called by do_cmdline() to get the next line.
20579 * Returns allocated string, or NULL for end of function.
20580 */
20581 /* ARGSUSED */
20582 char_u *
20587 {
20593 /* If breakpoints have been added/deleted need to check for it. */
20595 {
20597 sourcing_lnum);
20599 }
20600 #ifdef FEAT_PROFILE
20603 #endif
20609 else
20610 {
20611 /* Skip NULL lines (continuation lines). */
20617 else
20618 {
20621 #ifdef FEAT_PROFILE
20624 #endif
20625 }
20626 }
20628 /* Did we encounter a breakpoint? */
20630 {
20632 /* Find next breakpoint. */
20634 sourcing_lnum);
20636 }
20639 }
20641 #if defined(FEAT_PROFILE) || defined(PROTO)
20642 /*
20643 * Called when starting to read a function line.
20644 * "sourcing_lnum" must be correct!
20645 * When skipping lines it may not actually be executed, but we won't find out
20646 * until later and we need to store the time now.
20647 */
20648 void
20651 {
20657 {
20659 /* Skip continuation lines. */
20666 }
20667 }
20669 /*
20670 * Called when actually executing a function line.
20671 */
20672 void
20675 {
20681 }
20683 /*
20684 * Called when done with a function line.
20685 */
20686 void
20689 {
20694 {
20696 {
20703 }
20705 }
20706 }
20707 #endif
20709 /*
20710 * Return TRUE if the currently active function should be ended, because a
20711 * return was encountered or an error occured. Used inside a ":while".
20712 */
20713 int
20716 {
20719 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20720 * an error inside a try conditional. */
20723 }
20725 /*
20726 * return TRUE if cookie indicates a function which "abort"s on errors.
20727 */
20728 int
20731 {
20733 }
20735 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20737 {
20738 VAR_FLAVOUR_DEFAULT,
20739 VAR_FLAVOUR_SESSION,
20740 VAR_FLAVOUR_VIMINFO
20745 static var_flavour_T
20748 {
20752 {
20757 }
20758 else
20760 }
20761 #endif
20763 #if defined(FEAT_VIMINFO) || defined(PROTO)
20764 /*
20765 * Restore global vars that start with a capital from the viminfo file
20766 */
20767 int
20771 {
20774 typval_T tv;
20777 {
20780 {
20787 {
20789 {
20793 }
20794 else
20795 {
20798 }
20802 }
20803 }
20804 }
20807 }
20809 /*
20810 * Write global vars that start with a capital to the viminfo file
20811 */
20812 void
20815 {
20831 {
20833 {
20837 {
20839 {
20843 }
20849 }
20850 }
20851 }
20852 }
20853 #endif
20855 #if defined(FEAT_SESSION) || defined(PROTO)
20856 int
20859 {
20867 {
20869 {
20875 {
20876 /* Escape special characters with a backslash. Turn a LF and
20877 * CR into \n and \r. */
20891 p,
20895 {
20898 }
20900 }
20901 }
20902 }
20904 }
20905 #endif
20907 /*
20908 * Display script name where an item was last set.
20909 * Should only be invoked when 'verbose' is non-zero.
20910 */
20911 void
20913 scid_T scriptID;
20914 {
20918 {
20921 {
20927 }
20928 }
20929 }
20933 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
20936 #ifdef WIN3264
20937 /*
20938 * Functions for ":8" filename modifier: get 8.3 version of a filename.
20939 */
20941 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
20944 /*
20945 * Get the short pathname of a file.
20946 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
20947 */
20948 static int
20953 {
20961 {
20962 /* If that doesn't work (not enough space), then save the string
20963 * and try again with a new buffer big enough
20964 */
20974 /* Really should always succeed, as the buffer is big enough */
20975 }
20979 }
20981 /*
20982 * Create a short path name. Returns the length of the buffer it needs.
20983 * Doesn't copy over the end of the buffer passed in.
20984 */
20985 static int
20990 {
20992 char_u ch;
20995 /* Make a copy */
21005 {
21009 }
21011 do
21012 {
21013 /* Go back one path-separator */
21015 {
21019 }
21023 /* Remember the character that is about to be splatted */
21027 /* Try it in situ */
21030 {
21033 }
21038 {
21039 /* Remember the length of the new string. */
21043 {
21044 /* If there's not enough space in the currently allocated string,
21045 * then copy it to a buffer big enough.
21046 */
21050 }
21051 else
21052 {
21053 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21058 }
21059 /* Concat the next bit */
21062 }
21066 }
21068 /*
21069 * Get a pathname for a partial path.
21070 */
21071 static int
21076 {
21082 /* Count up the path seperators from the RHS.. so we know which part
21083 * of the path to return.
21084 */
21090 /* Need full path first (use expand_env() to remove a "~/") */
21094 else
21103 {
21104 /* Don't have a valid filename, so shorten the rest of the
21105 * path if we can. This CAN give us invalid 8.3 filenames, but
21106 * there's not a lot of point in guessing what it might be.
21107 */
21111 }
21113 /* Count the paths backward to find the beginning of the desired string. */
21115 {
21116 #ifdef FEAT_MBYTE
21119 #endif
21121 {
21124 else
21125 sepcount --;
21126 }
21127 }
21129 {
21133 else
21135 }
21136 else
21139 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21146 }
21149 /*
21150 * Adjust a filename, according to a string of modifiers.
21151 * *fnamep must be NUL terminated when called. When returning, the length is
21152 * determined by *fnamelen.
21153 * Returns valid flags.
21154 * When there is an error, *fnamep is set to NULL.
21155 */
21156 int
21163 {
21170 #ifdef WIN3264
21172 #endif
21174 repeat:
21175 /* ":p" - full path/file_name */
21177 {
21183 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21185 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21187 # ifdef BACKSLASH_IN_FILENAME
21189 # endif
21192 #endif
21193 )
21194 {
21200 }
21202 /* When "/." or "/.." is used: force expansion to get rid of it. */
21204 {
21212 }
21214 /* FullName_save() is slow, don't use it when not needed. */
21216 {
21222 }
21224 /* Append a path separator to a directory. */
21226 {
21227 /* Make room for one or two extra characters. */
21234 }
21235 }
21237 /* ":." - path relative to the current directory */
21238 /* ":~" - path relative to the home directory */
21239 /* ":8" - shortname path - postponed till after */
21242 {
21245 {
21246 #ifdef WIN3264
21248 #endif
21250 }
21252 /* Need full path first (use expand_env() to remove a "~/") */
21254 {
21257 else
21259 }
21260 else
21266 {
21268 {
21272 {
21275 {
21279 }
21280 }
21281 }
21282 else
21283 {
21285 /* Only replace it when it starts with '~' */
21287 {
21290 {
21294 }
21295 }
21296 }
21298 }
21299 }
21304 /* ":h" - head, remove "/file_name", can be repeated */
21305 /* Don't remove the first "/" or "c:\" */
21307 {
21314 #ifdef VMS
21317 #endif
21319 {
21320 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21327 }
21328 else
21329 {
21332 }
21333 }
21335 /* ":8" - shortname */
21337 {
21339 #ifdef WIN3264
21341 #endif
21342 }
21344 #ifdef WIN3264
21345 /* Check shortname after we have done 'heads' and before we do 'tails'
21346 */
21348 {
21350 /* Copy the string if it is shortened by :h */
21352 {
21358 }
21360 /* Split into two implementations - makes it easier. First is where
21361 * there isn't a full name already, second is where there is.
21362 */
21364 {
21367 }
21368 else
21369 {
21372 /* Simple case, already have the full-name
21373 * Nearly always shorter, so try first time. */
21379 {
21380 /* Couldn't find the filename.. search the paths.
21381 */
21385 }
21387 }
21388 }
21391 /* ":t" - tail, just the basename */
21393 {
21397 }
21399 /* ":e" - extension, can be repeated */
21400 /* ":r" - root, without extension, can be repeated */
21403 {
21404 /* find a '.' in the tail:
21405 * - for second :e: before the current fname
21406 * - otherwise: The last '.'
21407 */
21410 else
21416 {
21418 {
21421 #ifdef VMS
21422 /* cut version from the extension */
21429 #endif
21430 }
21433 }
21435 {
21438 }
21440 }
21442 /* ":s?pat?foo?" - substitute */
21443 /* ":gs?pat?foo?" - global substitute */
21447 {
21458 {
21461 }
21465 {
21466 /* find end of pattern */
21469 {
21472 {
21474 /* find end of substitution */
21477 {
21481 {
21485 {
21491 }
21492 }
21495 }
21497 }
21498 }
21499 /* after using ":s", repeat all the modifiers */
21502 }
21503 }
21506 }
21508 /*
21509 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21510 * "flags" can be "g" to do a global substitute.
21511 * Returns an allocated string, NULL for error.
21512 */
21513 char_u *
21519 {
21521 regmatch_T regmatch;
21525 garray_T ga;
21529 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21540 {
21543 {
21544 /*
21545 * Get some space for a temporary buffer to do the substitution
21546 * into. It will contain:
21547 * - The text up to where the match is.
21548 * - The substituted text.
21549 * - The text after the match.
21550 */
21554 {
21557 }
21559 /* copy the text up to where the match is */
21562 /* add the substituted text */
21566 /* avoid getting stuck on a match with an empty string */
21568 {
21573 }
21574 else
21575 {
21579 }
21582 }
21588 }
21595 }