| blob | 77d641374ec494ce3b4a0684d366a5ab4b77412e |
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 {
1324 {
1328 else
1330 }
1331 }
1333 #if defined(FEAT_SPELL) || defined(PROTO)
1334 /*
1335 * Evaluate an expression to a list with suggestions.
1336 * For the "expr:" part of 'spellsuggest'.
1337 */
1338 list_T *
1342 {
1343 typval_T save_val;
1344 typval_T rettv;
1348 /* Set "v:val" to the bad word. */
1356 {
1359 else
1361 }
1369 }
1371 /*
1372 * "list" is supposed to contain two items: a word and a number. Return the
1373 * word in "pp" and the number as the return value.
1374 * Return -1 if anything isn't right.
1375 * Used to get the good word and score from the eval_spell_expr() result.
1376 */
1377 int
1381 {
1393 }
1394 #endif
1396 /*
1397 * Top level evaluation function.
1398 * Returns an allocated typval_T with the result.
1399 * Returns NULL when there is an error.
1400 */
1401 typval_T *
1405 {
1410 {
1413 }
1416 }
1419 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1420 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1421 /*
1422 * Call some vimL function and return the result in "*rettv".
1423 * Uses argv[argc] for the function arguments.
1424 * Returns OK or FAIL.
1425 */
1426 static int
1433 {
1447 {
1448 /* Pass a NULL or empty argument as an empty string */
1450 {
1454 }
1456 /* Recognize a number argument, the others must be strings. */
1459 {
1462 }
1463 else
1464 {
1467 }
1468 }
1471 {
1474 }
1481 {
1484 }
1491 }
1493 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1494 /*
1495 * Call vimL function "func" and return the result as a string.
1496 * Returns NULL when calling the function fails.
1497 * Uses argv[argc] for the function arguments.
1498 */
1505 {
1506 typval_T rettv;
1515 }
1516 # endif
1518 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1519 /*
1520 * Call vimL function "func" and return the result as a number.
1521 * Returns -1 when calling the function fails.
1522 * Uses argv[argc] for the function arguments.
1523 */
1524 long
1530 {
1531 typval_T rettv;
1540 }
1541 # endif
1543 /*
1544 * Call vimL function "func" and return the result as a list
1545 * Uses argv[argc] for the function arguments.
1546 */
1553 {
1554 typval_T rettv;
1560 {
1563 }
1566 }
1567 #endif
1570 /*
1571 * Save the current function call pointer, and set it to NULL.
1572 * Used when executing autocommands and for ":source".
1573 */
1576 {
1581 }
1583 void
1586 {
1590 }
1592 #if defined(FEAT_PROFILE) || defined(PROTO)
1593 /*
1594 * Prepare profiling for entering a child or something else that is not
1595 * counted for the script/function itself.
1596 * Should always be called in pair with prof_child_exit().
1597 */
1598 void
1601 {
1607 }
1609 /*
1610 * Take care of time spent in a child.
1611 * Should always be called after prof_child_enter().
1612 */
1613 void
1616 {
1620 {
1625 }
1627 }
1628 #endif
1631 #ifdef FEAT_FOLDING
1632 /*
1633 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1634 * it in "*cp". Doesn't give error messages.
1635 */
1636 int
1640 {
1641 typval_T tv;
1645 OPT_LOCAL);
1654 else
1655 {
1656 /* If the result is a number, just return the number. */
1661 else
1662 {
1663 /* If the result is a string, check if there is a non-digit before
1664 * the number. */
1669 }
1671 }
1678 }
1679 #endif
1681 /*
1682 * ":let" list all variable values
1683 * ":let var1 var2" list variable values
1684 * ":let var = expr" assignment command.
1685 * ":let var += expr" assignment command.
1686 * ":let var -= expr" assignment command.
1687 * ":let var .= expr" assignment command.
1688 * ":let [var1, var2] = expr" unpack list.
1689 */
1690 void
1693 {
1696 typval_T rettv;
1711 {
1712 /*
1713 * ":let" without "=": list variables
1714 */
1718 /* ":let var1 var2" */
1721 {
1722 /* ":let" */
1726 #ifdef FEAT_WINDOWS
1728 #endif
1732 }
1734 }
1735 else
1736 {
1740 {
1743 }
1750 {
1754 }
1756 {
1758 op);
1760 }
1761 }
1762 }
1764 /*
1765 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1766 * Handles both "var" with any type and "[var, var; var]" with a list type.
1767 * When "nextchars" is not NULL it points to a string with characters that
1768 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1769 * or concatenate.
1770 * Returns OK or FAIL;
1771 */
1772 static int
1780 {
1785 typval_T ltv;
1788 {
1789 /*
1790 * ":let var = expr" or ":for var in list"
1791 */
1795 }
1797 /*
1798 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1799 */
1801 {
1804 }
1808 {
1811 }
1813 {
1816 }
1820 {
1829 {
1830 /* Put the rest of the list (may be empty) in the var after ';'.
1831 * Create a new list for this. */
1836 {
1839 }
1852 }
1854 {
1857 }
1858 }
1861 }
1863 /*
1864 * Skip over assignable variable "var" or list of variables "[var, var]".
1865 * Used for ":let varvar = expr" and ":for varvar in expr".
1866 * For "[var, var]" increment "*var_count" for each variable.
1867 * for "[var, var; var]" set "semicolon".
1868 * Return NULL for an error.
1869 */
1875 {
1879 {
1880 /* "[var, var]": find the matching ']'. */
1883 {
1887 {
1890 }
1897 {
1899 {
1902 }
1904 }
1906 {
1909 }
1910 }
1912 }
1913 else
1915 }
1917 /*
1918 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1919 * l[idx].
1920 */
1924 {
1929 }
1931 /*
1932 * List variables for hashtab "ht" with prefix "prefix".
1933 * If "empty" is TRUE also list NULL strings as empty strings.
1934 */
1935 static void
1941 {
1948 {
1950 {
1956 }
1957 }
1958 }
1960 /*
1961 * List global variables.
1962 */
1963 static void
1966 {
1968 }
1970 /*
1971 * List buffer variables.
1972 */
1973 static void
1976 {
1985 }
1987 /*
1988 * List window variables.
1989 */
1990 static void
1993 {
1996 }
1998 #ifdef FEAT_WINDOWS
1999 /*
2000 * List tab page variables.
2001 */
2002 static void
2005 {
2008 }
2009 #endif
2011 /*
2012 * List Vim variables.
2013 */
2014 static void
2017 {
2019 }
2021 /*
2022 * List script-local variables, if there is a script.
2023 */
2024 static void
2027 {
2031 }
2033 /*
2034 * List function variables, if there is a function.
2035 */
2036 static void
2039 {
2043 }
2045 /*
2046 * List variables in "arg".
2047 */
2053 {
2060 typval_T tv;
2063 {
2065 {
2068 {
2072 }
2073 }
2074 else
2075 {
2076 /* get_name_len() takes care of expanding curly braces */
2080 {
2081 /* This is mainly to keep test 49 working: when expanding
2082 * curly braces fails overrule the exception error message. */
2084 {
2088 }
2090 }
2091 else
2092 {
2097 else
2098 {
2099 /* handle d.key, l[idx], f(expr) */
2103 else
2104 {
2106 {
2108 {
2112 #ifdef FEAT_WINDOWS
2114 #endif
2120 }
2121 }
2122 else
2123 {
2136 first);
2139 }
2141 }
2142 }
2143 }
2146 }
2149 }
2152 }
2154 /*
2155 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2156 * Returns a pointer to the char just after the var name.
2157 * Returns NULL if there is an error.
2158 */
2166 {
2175 /*
2176 * ":let $VAR = expr": Set environment variable.
2177 */
2179 {
2180 /* Find the end of the name. */
2186 else
2187 {
2193 else
2194 {
2199 {
2204 {
2208 }
2209 }
2211 {
2221 }
2224 }
2225 }
2226 }
2228 /*
2229 * ":let &option = expr": Set option value.
2230 * ":let &l:option = expr": Set local option value.
2231 * ":let &g:option = expr": Set global option value.
2232 */
2234 {
2235 /* Find the end of the name. */
2240 else
2241 {
2254 {
2260 else
2261 {
2263 {
2266 else
2268 }
2270 {
2274 }
2275 }
2276 }
2278 {
2281 }
2284 }
2285 }
2287 /*
2288 * ":let @r = expr": Set register contents.
2289 */
2291 {
2298 else
2299 {
2305 {
2308 {
2311 }
2312 }
2314 {
2317 }
2319 }
2320 }
2322 /*
2323 * ":let var = expr": Set internal variable.
2324 * ":let {expr} = expr": Idem, name made with curly braces
2325 */
2327 {
2328 lval_T lv;
2332 {
2335 else
2336 {
2339 }
2340 }
2342 }
2344 else
2348 }
2350 /*
2351 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2352 */
2353 static int
2356 {
2358 {
2361 }
2363 }
2365 /*
2366 * Get an lval: variable, Dict item or List item that can be assigned a value
2367 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2368 * "name.key", "name.key[expr]" etc.
2369 * Indexing only works if "name" is an existing List or Dictionary.
2370 * "name" points to the start of the name.
2371 * If "rettv" is not NULL it points to the value to be assigned.
2372 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2373 * wrong; must end in space or cmd separator.
2374 *
2375 * Returns a pointer to just after the name, including indexes.
2376 * When an evaluation error occurs "lp->ll_name" is NULL;
2377 * Returns NULL for a parsing error. Still need to free items in "lp"!
2378 */
2388 {
2393 typval_T var1;
2394 typval_T var2;
2401 /* Clear everything in "lp". */
2405 {
2406 /* When skipping just find the end of the name. */
2409 }
2411 /* Find the end of the name. */
2414 {
2415 /* Don't expand the name when we already know there is an error. */
2418 {
2421 }
2425 {
2426 /* Report an invalid expression in braces, unless the
2427 * expression evaluation has been cancelled due to an
2428 * aborting error, an interrupt, or an exception. */
2430 {
2434 }
2435 }
2437 }
2438 else
2441 /* Without [idx] or .key we are done. */
2454 /*
2455 * Loop until no more [idx] or .key is following.
2456 */
2459 {
2463 {
2467 }
2469 {
2473 }
2477 {
2480 ;
2482 {
2486 }
2488 }
2489 else
2490 {
2491 /* Get the index [expr] or the first index [expr: ]. */
2495 else
2496 {
2501 {
2502 /* not a number or string */
2505 }
2506 }
2508 /* Optionally get the second index [ :expr]. */
2510 {
2512 {
2518 }
2521 {
2527 }
2531 else
2532 {
2535 {
2539 }
2541 {
2542 /* not a number or string */
2547 }
2548 }
2550 }
2551 else
2555 {
2563 }
2565 /* Skip to past ']'. */
2567 }
2570 {
2572 {
2573 /* "[key]": get key from "var1" */
2576 {
2581 }
2582 }
2587 {
2588 /* Key does not exist in dict: may need to add it. */
2590 {
2596 }
2599 else
2606 }
2610 }
2611 else
2612 {
2613 /*
2614 * Get the number and item for the only or first index of the List.
2615 */
2618 else
2619 {
2622 }
2627 {
2629 {
2632 }
2633 }
2635 {
2639 }
2641 /*
2642 * May need to find the item or absolute index for the second
2643 * index of a range.
2644 * When no index given: "lp->ll_empty2" is TRUE.
2645 * Otherwise "lp->ll_n2" is set to the second index.
2646 */
2648 {
2652 {
2657 }
2659 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2664 }
2667 }
2668 }
2671 }
2673 /*
2674 * Clear lval "lp" that was filled by get_lval().
2675 */
2676 static void
2679 {
2682 }
2684 /*
2685 * Set a variable that was parsed by get_lval() to "rettv".
2686 * "endp" points to just after the parsed name.
2687 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2688 */
2689 static void
2696 {
2702 {
2704 {
2708 {
2709 typval_T tv;
2711 /* handle +=, -= and .= */
2714 {
2718 }
2719 }
2720 else
2723 }
2724 }
2728 ;
2730 {
2731 /*
2732 * Assign the List values to the list items.
2733 */
2735 {
2738 else
2739 {
2742 }
2747 {
2748 /* Need to add an empty item. */
2750 {
2753 }
2754 }
2757 }
2764 }
2765 else
2766 {
2767 /*
2768 * Assign to a List or Dictionary item.
2769 */
2771 {
2773 {
2776 }
2778 /* Need to add an item to the Dictionary. */
2783 {
2786 }
2788 }
2790 {
2793 }
2794 else
2797 /*
2798 * Assign the value to the variable or list item.
2799 */
2802 else
2803 {
2807 }
2808 }
2809 }
2811 /*
2812 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2813 * Returns OK or FAIL.
2814 */
2815 static int
2820 {
2825 /* Can't do anything with a Funcref or a Dict on the right. */
2827 {
2829 {
2837 /* List += List */
2847 {
2848 /* nr += nr or nr -= nr*/
2852 else
2857 }
2858 else
2859 {
2860 /* str .= str */
2866 }
2868 }
2869 }
2873 }
2875 /*
2876 * Add a watcher to a list.
2877 */
2878 static void
2882 {
2885 }
2887 /*
2888 * Remove a watcher from a list.
2889 * No warning when it isn't found...
2890 */
2891 static void
2895 {
2900 {
2902 {
2905 }
2907 }
2908 }
2910 /*
2911 * Just before removing an item from a list: advance watchers to the next
2912 * item.
2913 */
2914 static void
2918 {
2924 }
2926 /*
2927 * Evaluate the expression used in a ":for var in expr" command.
2928 * "arg" points to "var".
2929 * Set "*errp" to TRUE for an error, FALSE otherwise;
2930 * Return a pointer that holds the info. Null when there is an error.
2931 */
2938 {
2941 typval_T tv;
2956 {
2959 }
2964 {
2967 {
2970 {
2973 }
2974 else
2975 {
2976 /* No need to increment the refcount, it's already set for the
2977 * list being used in "tv". */
2981 }
2982 }
2983 }
2988 }
2990 /*
2991 * Use the first item in a ":for" list. Advance to the next.
2992 * Assign the values to the variable (list). "arg" points to the first one.
2993 * Return TRUE when a valid item was found, FALSE when at end of list or
2994 * something wrong.
2995 */
2996 int
3000 {
3008 else
3009 {
3013 }
3015 }
3017 /*
3018 * Free the structure used to store info used by ":for".
3019 */
3020 void
3023 {
3027 {
3030 }
3032 }
3034 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3036 void
3040 cmdidx_T cmdidx;
3041 {
3047 {
3050 {
3051 /* ":let var1 var2 ...": find last space. */
3053 {
3058 }
3060 }
3061 }
3062 else
3067 {
3070 {
3073 {
3077 }
3079 {
3084 }
3085 }
3087 {
3088 /* environment variable */
3090 }
3092 {
3095 }
3099 {
3100 /* Function name can start with "<SNR>" */
3102 }
3104 {
3106 {
3111 }
3113 {
3114 /* Trick: '' is like stopping and starting a literal string. */
3118 }
3120 {
3122 {
3125 }
3126 else
3128 }
3129 else
3131 }
3132 else
3133 /* Doesn't look like something valid, expand as an expression
3134 * anyway. */
3140 }
3142 }
3146 /*
3147 * ":1,25call func(arg1, arg2)" function call.
3148 */
3149 void
3152 {
3158 typval_T rettv;
3159 linenr_T lnum;
3162 funcdict_T fudi;
3166 {
3167 /* Still need to give an error message for missing key. */
3170 }
3174 /* Increase refcount on dictionary, it could get deleted when evaluating
3175 * the arguments. */
3179 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3183 /* Skip white space to allow ":call func ()". Not good, but required for
3184 * backward compatibility. */
3189 {
3192 }
3194 /*
3195 * When skipping, evaluate the function once, to find the end of the
3196 * arguments.
3197 * When the function takes a range, this is discovered after the first
3198 * call, and the loop is broken.
3199 */
3201 {
3204 }
3205 else
3208 {
3210 {
3213 }
3218 {
3221 }
3223 /* Handle a function returning a Funcref, Dictionary or List. */
3225 {
3228 }
3234 /* Stop when immediately aborting on error, or when an interrupt
3235 * occurred or an exception was thrown but not caught.
3236 * get_func_tv() returned OK, so that the check for trailing
3237 * characters below is executed. */
3240 }
3245 {
3246 /* Check for trailing illegal characters and a following command. */
3248 {
3251 }
3252 else
3254 }
3256 end:
3259 }
3261 /*
3262 * ":unlet[!] var1 ... " command.
3263 */
3264 void
3267 {
3269 }
3271 /*
3272 * ":lockvar" and ":unlockvar" commands
3273 */
3274 void
3277 {
3284 {
3287 }
3290 }
3292 /*
3293 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3294 */
3295 static void
3300 {
3304 lval_T lv;
3306 do
3307 {
3308 /* Parse the name and find the end. */
3310 FNE_CHECK_START);
3315 {
3317 {
3320 }
3324 }
3327 {
3329 {
3332 }
3333 else
3334 {
3338 }
3339 }
3348 }
3350 static int
3355 {
3360 {
3364 /* Normal name or expanded name. */
3370 }
3374 {
3377 /* Delete a range of List items. */
3379 {
3384 }
3385 }
3386 else
3387 {
3389 /* unlet a List item. */
3391 else
3392 /* unlet a Dictionary item. */
3394 }
3397 }
3399 /*
3400 * "unlet" a variable. Return OK if it existed, FAIL if not.
3401 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3402 */
3403 int
3407 {
3414 {
3417 {
3424 }
3425 }
3430 }
3432 /*
3433 * Lock or unlock variable indicated by "lp".
3434 * "deep" is the levels to go (-1 for unlimited);
3435 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3436 */
3437 static int
3443 {
3452 {
3456 /* Normal name or expanded name. */
3459 else
3460 {
3464 else
3465 {
3468 else
3471 }
3472 }
3474 }
3476 {
3479 /* (un)lock a range of List items. */
3481 {
3485 }
3486 }
3488 /* (un)lock a List item. */
3490 else
3491 /* un(lock) a Dictionary item. */
3495 }
3497 /*
3498 * Lock or unlock an item. "deep" is nr of levels to go.
3499 */
3500 static void
3505 {
3514 {
3517 }
3522 /* lock/unlock the item itself */
3525 else
3529 {
3532 {
3535 else
3538 /* recursive: lock/unlock the items the List contains */
3541 }
3545 {
3548 else
3551 {
3552 /* recursive: lock/unlock the items the List contains */
3555 {
3557 {
3560 }
3561 }
3562 }
3563 }
3564 }
3566 }
3568 /*
3569 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3570 * it refers to a List or Dictionary that is locked.
3571 */
3572 static int
3575 {
3583 }
3585 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3586 /*
3587 * Delete all "menutrans_" variables.
3588 */
3589 void
3591 {
3598 {
3600 {
3604 }
3605 }
3607 }
3608 #endif
3610 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3612 /*
3613 * Local string buffer for the next two functions to store a variable name
3614 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3615 * get_user_var_name().
3616 */
3623 /*
3624 * Function to concatenate a prefix and a variable name.
3625 */
3630 {
3635 {
3640 {
3643 }
3645 }
3650 }
3652 /*
3653 * Function given to ExpandGeneric() to obtain the list of user defined
3654 * (global/buffer/window/built-in) variable names.
3655 */
3656 /*ARGSUSED*/
3657 char_u *
3661 {
3665 #ifdef FEAT_WINDOWS
3667 #endif
3673 {
3675 #ifdef FEAT_WINDOWS
3677 #endif
3678 }
3680 /* Global variables */
3682 {
3685 else
3692 }
3694 /* b: variables */
3697 {
3700 else
3705 }
3707 {
3710 }
3712 /* w: variables */
3715 {
3718 else
3723 }
3725 #ifdef FEAT_WINDOWS
3726 /* t: variables */
3729 {
3732 else
3737 }
3738 #endif
3740 /* v: variables */
3748 }
3752 /*
3753 * types for expressions.
3754 */
3756 {
3768 /*
3769 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3770 * executed. The function may return OK, but the rettv will be of type
3771 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3772 */
3774 /*
3775 * Handle zero level expression.
3776 * This calls eval1() and handles error message and nextcmd.
3777 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3778 * Note: "rettv.v_lock" is not set.
3779 * Return OK or FAIL.
3780 */
3781 static int
3787 {
3794 {
3797 /*
3798 * Report the invalid expression unless the expression evaluation has
3799 * been cancelled due to an aborting error, an interrupt, or an
3800 * exception.
3801 */
3805 }
3810 }
3812 /*
3813 * Handle top level expression:
3814 * expr1 ? expr0 : expr0
3815 *
3816 * "arg" must point to the first non-white of the expression.
3817 * "arg" is advanced to the next non-white after the recognized expression.
3818 *
3819 * Note: "rettv.v_lock" is not set.
3820 *
3821 * Return OK or FAIL.
3822 */
3823 static int
3828 {
3830 typval_T var2;
3832 /*
3833 * Get the first variable.
3834 */
3839 {
3842 {
3850 }
3852 /*
3853 * Get the second variable.
3854 */
3859 /*
3860 * Check for the ":".
3861 */
3863 {
3868 }
3870 /*
3871 * Get the third variable.
3872 */
3875 {
3879 }
3882 }
3885 }
3887 /*
3888 * Handle first level expression:
3889 * expr2 || expr2 || expr2 logical OR
3890 *
3891 * "arg" must point to the first non-white of the expression.
3892 * "arg" is advanced to the next non-white after the recognized expression.
3893 *
3894 * Return OK or FAIL.
3895 */
3896 static int
3901 {
3902 typval_T var2;
3907 /*
3908 * Get the first variable.
3909 */
3913 /*
3914 * Repeat until there is no following "||".
3915 */
3919 {
3921 {
3928 }
3930 /*
3931 * Get the second variable.
3932 */
3937 /*
3938 * Compute the result.
3939 */
3941 {
3947 }
3949 {
3952 }
3953 }
3956 }
3958 /*
3959 * Handle second level expression:
3960 * expr3 && expr3 && expr3 logical AND
3961 *
3962 * "arg" must point to the first non-white of the expression.
3963 * "arg" is advanced to the next non-white after the recognized expression.
3964 *
3965 * Return OK or FAIL.
3966 */
3967 static int
3972 {
3973 typval_T var2;
3978 /*
3979 * Get the first variable.
3980 */
3984 /*
3985 * Repeat until there is no following "&&".
3986 */
3990 {
3992 {
3999 }
4001 /*
4002 * Get the second variable.
4003 */
4008 /*
4009 * Compute the result.
4010 */
4012 {
4018 }
4020 {
4023 }
4024 }
4027 }
4029 /*
4030 * Handle third level expression:
4031 * var1 == var2
4032 * var1 =~ var2
4033 * var1 != var2
4034 * var1 !~ var2
4035 * var1 > var2
4036 * var1 >= var2
4037 * var1 < var2
4038 * var1 <= var2
4039 * var1 is var2
4040 * var1 isnot var2
4041 *
4042 * "arg" must point to the first non-white of the expression.
4043 * "arg" is advanced to the next non-white after the recognized expression.
4044 *
4045 * Return OK or FAIL.
4046 */
4047 static int
4052 {
4053 typval_T var2;
4062 regmatch_T regmatch;
4066 /*
4067 * Get the first variable.
4068 */
4074 {
4086 {
4089 }
4090 else
4094 {
4097 }
4098 else
4102 {
4106 {
4109 }
4110 }
4112 }
4114 /*
4115 * If there is a comparitive operator, use it.
4116 */
4118 {
4119 /* extra question mark appended: ignore case */
4121 {
4124 }
4125 /* extra '#' appended: match case */
4127 {
4130 }
4131 /* nothing appened: use 'ignorecase' */
4132 else
4135 /*
4136 * Get the second variable.
4137 */
4140 {
4143 }
4146 {
4148 {
4149 /* For "is" a different type always means FALSE, for "notis"
4150 * it means TRUE. */
4152 }
4154 {
4156 {
4161 }
4164 {
4167 else
4172 }
4173 else
4174 {
4175 /* Compare two Lists for being equal or unequal. */
4179 }
4180 }
4183 {
4185 {
4190 }
4193 {
4196 else
4201 }
4202 else
4203 {
4204 /* Compare two Dictionaries for being equal or unequal. */
4208 }
4209 }
4212 {
4215 {
4218 else
4223 }
4224 else
4225 {
4226 /* Compare two Funcrefs for being equal or unequal. */
4230 else
4235 }
4236 }
4238 /*
4239 * If one of the two variables is a number, compare as a number.
4240 * When using "=~" or "!~", always compare as string.
4241 */
4244 {
4248 {
4258 }
4259 }
4260 else
4261 {
4266 else
4270 {
4280 /* avoid 'l' flag in 'cpoptions' */
4287 {
4292 }
4297 }
4298 }
4303 }
4304 }
4307 }
4309 /*
4310 * Handle fourth level expression:
4311 * + number addition
4312 * - number subtraction
4313 * . string concatenation
4314 *
4315 * "arg" must point to the first non-white of the expression.
4316 * "arg" is advanced to the next non-white after the recognized expression.
4317 *
4318 * Return OK or FAIL.
4319 */
4320 static int
4325 {
4326 typval_T var2;
4327 typval_T var3;
4334 /*
4335 * Get the first variable.
4336 */
4340 /*
4341 * Repeat computing, until no '+', '-' or '.' is following.
4342 */
4344 {
4350 {
4351 /* For "list + ...", an illegal use of the first operand as
4352 * a number cannot be determined before evaluating the 2nd
4353 * operand: if this is also a list, all is ok.
4354 * For "something . ...", "something - ..." or "non-list + ...",
4355 * we know that the first operand needs to be a string or number
4356 * without evaluating the 2nd operand. So check before to avoid
4357 * side effects after an error. */
4359 {
4362 }
4363 }
4365 /*
4366 * Get the second variable.
4367 */
4370 {
4373 }
4376 {
4377 /*
4378 * Compute the result.
4379 */
4381 {
4385 {
4389 }
4394 }
4397 {
4398 /* concatenate Lists */
4401 {
4405 }
4408 }
4409 else
4410 {
4415 {
4416 /* This can only happen for "list + non-list".
4417 * For "non-list + ..." or "something - ...", we returned
4418 * before evaluating the 2nd operand. */
4421 }
4424 {
4428 }
4432 else
4436 }
4438 }
4439 }
4441 }
4443 /*
4444 * Handle fifth level expression:
4445 * * number multiplication
4446 * / number division
4447 * % number modulo
4448 *
4449 * "arg" must point to the first non-white of the expression.
4450 * "arg" is advanced to the next non-white after the recognized expression.
4451 *
4452 * Return OK or FAIL.
4453 */
4454 static int
4459 {
4460 typval_T var2;
4465 /*
4466 * Get the first variable.
4467 */
4471 /*
4472 * Repeat computing, until no '*', '/' or '%' is following.
4473 */
4475 {
4481 {
4486 }
4487 else
4490 /*
4491 * Get the second variable.
4492 */
4498 {
4504 /*
4505 * Compute the result.
4506 */
4510 {
4513 else
4515 }
4516 else
4517 {
4520 else
4522 }
4525 }
4526 }
4529 }
4531 /*
4532 * Handle sixth level expression:
4533 * number number constant
4534 * "string" string constant
4535 * 'string' literal string constant
4536 * &option-name option value
4537 * @r register contents
4538 * identifier variable value
4539 * function() function call
4540 * $VAR environment variable
4541 * (expression) nested expression
4542 * [expr, expr] List
4543 * {key: val, key: val} Dictionary
4544 *
4545 * Also handle:
4546 * ! in front logical NOT
4547 * - in front unary minus
4548 * + in front unary plus (ignored)
4549 * trailing [] subscript in String or List
4550 * trailing .name entry in Dictionary
4551 *
4552 * "arg" must point to the first non-white of the expression.
4553 * "arg" is advanced to the next non-white after the recognized expression.
4554 *
4555 * Return OK or FAIL.
4556 */
4557 static int
4562 {
4571 /*
4572 * Initialise variable so that clear_tv() can't mistake this for a
4573 * string and free a string that isn't there.
4574 */
4577 /*
4578 * Skip '!' and '-' characters. They are handled later.
4579 */
4586 {
4587 /*
4588 * Number constant.
4589 */
4603 {
4606 }
4609 /*
4610 * String constant: "string".
4611 */
4615 /*
4616 * Literal string constant: 'str''ing'.
4617 */
4621 /*
4622 * List: [expr, expr]
4623 */
4627 /*
4628 * Dictionary: {key: val, key: val}
4629 */
4633 /*
4634 * Option value: &name
4635 */
4639 /*
4640 * Environment variable: $VAR.
4641 */
4645 /*
4646 * Register contents: @r.
4647 */
4650 {
4653 }
4658 /*
4659 * nested expression: (expression).
4660 */
4666 {
4670 }
4675 }
4678 {
4679 /*
4680 * Must be a variable or function name.
4681 * Can also be a curly-braces kind of name: {expr}.
4682 */
4690 else
4691 {
4693 {
4694 /* If "s" is the name of a variable of type VAR_FUNC
4695 * use its contents. */
4698 /* Invoke the function. */
4702 /* Stop the expression evaluation when immediately
4703 * aborting on error, or when an interrupt occurred or
4704 * an exception was thrown but not caught. */
4706 {
4710 }
4711 }
4714 else
4716 }
4720 }
4724 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4725 * expr(expr). */
4729 /*
4730 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4731 */
4733 {
4738 {
4741 }
4742 else
4743 {
4745 {
4751 }
4755 }
4756 }
4759 }
4761 /*
4762 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4763 * "*arg" points to the '[' or '.'.
4764 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4765 */
4766 static int
4772 {
4782 {
4786 }
4789 {
4790 /*
4791 * dict.name
4792 */
4795 ;
4799 }
4800 else
4801 {
4802 /*
4803 * something[idx]
4804 *
4805 * Get the (first) variable from inside the [].
4806 */
4813 {
4814 /* not a number or string */
4817 }
4819 /*
4820 * Get the second variable from inside the [:].
4821 */
4823 {
4829 {
4833 }
4835 {
4836 /* not a number or string */
4841 }
4842 }
4844 /* Check for the ']'. */
4846 {
4853 }
4855 }
4858 {
4861 {
4864 }
4866 {
4869 else
4870 {
4873 }
4874 }
4877 {
4883 {
4884 /* The resulting variable is a substring. If the indexes
4885 * are out of range the result is empty. */
4887 {
4891 }
4898 else
4900 }
4901 else
4902 {
4903 /* The resulting variable is a string of a single
4904 * character. If the index is too big or negative the
4905 * result is empty. */
4908 else
4910 }
4921 {
4922 /* For a range we allow invalid values and return an empty
4923 * list. A list index out of range is an error. */
4925 {
4929 }
4931 }
4933 {
4948 {
4950 {
4953 }
4955 }
4960 }
4961 else
4962 {
4966 }
4971 {
4977 }
4978 {
4982 {
4985 {
4990 }
4991 }
5005 }
5007 }
5008 }
5011 }
5013 /*
5014 * Get an option value.
5015 * "arg" points to the '&' or '+' before the option name.
5016 * "arg" is advanced to character after the option name.
5017 * Return OK or FAIL.
5018 */
5019 static int
5024 {
5034 /*
5035 * Isolate the option name and find its value.
5036 */
5039 {
5043 }
5046 {
5049 }
5057 {
5061 }
5063 {
5065 {
5068 }
5070 {
5073 }
5075 {
5078 }
5080 {
5083 }
5084 }
5092 }
5094 /*
5095 * Allocate a variable for a string constant.
5096 * Return OK or FAIL.
5097 */
5098 static int
5103 {
5108 /*
5109 * Find the end of the string, skipping backslashed characters.
5110 */
5112 {
5114 {
5116 /* A "\<x>" form occupies at least 4 characters, and produces up
5117 * to 6 characters: reserve space for 2 extra */
5120 }
5121 }
5124 {
5127 }
5129 /* If only parsing, set *arg and return here */
5131 {
5134 }
5136 /*
5137 * Copy the string into allocated memory, handling backslashed
5138 * characters.
5139 */
5147 {
5149 {
5151 {
5164 {
5170 else
5174 {
5177 }
5179 #ifdef FEAT_MBYTE
5180 /* For "\u" store the number according to
5181 * 'encoding'. */
5184 else
5185 #endif
5187 }
5190 /* octal: "\1", "\12", "\123" */
5200 {
5204 }
5208 /* Special key, e.g.: "\<C-W>" */
5211 {
5214 }
5215 /* FALLTHROUGH */
5219 }
5220 }
5221 else
5224 }
5229 }
5231 /*
5232 * Allocate a variable for a 'str''ing' constant.
5233 * Return OK or FAIL.
5234 */
5235 static int
5240 {
5245 /*
5246 * Find the end of the string, skipping ''.
5247 */
5249 {
5251 {
5256 }
5257 }
5260 {
5263 }
5265 /* If only parsing return after setting "*arg" */
5267 {
5270 }
5272 /*
5273 * Copy the string into allocated memory, handling '' to ' reduction.
5274 */
5282 {
5284 {
5288 }
5290 }
5295 }
5297 /*
5298 * Allocate a variable for a List and fill it from "*arg".
5299 * Return OK or FAIL.
5300 */
5301 static int
5306 {
5308 typval_T tv;
5312 {
5316 }
5320 {
5324 {
5327 {
5331 }
5332 else
5334 }
5339 {
5342 }
5344 }
5347 {
5349 failret:
5353 }
5357 {
5361 }
5364 }
5366 /*
5367 * Allocate an empty header for a list.
5368 * Caller should take care of the reference count.
5369 */
5370 list_T *
5372 {
5377 {
5378 /* Prepend the list to the list of lists for garbage collection. */
5384 }
5386 }
5388 /*
5389 * Allocate an empty list for a return value.
5390 * Returns OK or FAIL.
5391 */
5392 static int
5395 {
5405 }
5407 /*
5408 * Unreference a list: decrement the reference count and free it when it
5409 * becomes zero.
5410 */
5411 void
5414 {
5417 }
5419 /*
5420 * Free a list, including all items it points to.
5421 * Ignores the reference count.
5422 */
5423 void
5427 {
5430 /* Remove the list from the list of lists for garbage collection. */
5433 else
5439 {
5440 /* Remove the item before deleting it. */
5446 }
5448 }
5450 /*
5451 * Allocate a list item.
5452 */
5455 {
5457 }
5459 /*
5460 * Free a list item. Also clears the value. Does not notify watchers.
5461 */
5462 static void
5465 {
5468 }
5470 /*
5471 * Remove a list item from a List and free it. Also clears the value.
5472 */
5473 static void
5477 {
5480 }
5482 /*
5483 * Get the number of items in a list.
5484 */
5485 static long
5488 {
5492 }
5494 /*
5495 * Return TRUE when two lists have exactly the same values.
5496 */
5497 static int
5502 {
5516 }
5518 #if defined(FEAT_PYTHON) || defined(PROTO)
5519 /*
5520 * Return the dictitem that an entry in a hashtable points to.
5521 */
5522 dictitem_T *
5525 {
5527 }
5528 #endif
5530 /*
5531 * Return TRUE when two dictionaries have exactly the same key/values.
5532 */
5533 static int
5538 {
5550 {
5552 {
5559 }
5560 }
5562 }
5564 /*
5565 * Return TRUE if "tv1" and "tv2" have the same value.
5566 * Compares the items just like "==" would compare them, but strings and
5567 * numbers are different.
5568 */
5569 static int
5574 {
5582 /* Catch lists and dicts that have an endless loop by limiting
5583 * recursiveness to 1000. We guess they are equal then. */
5588 {
5613 }
5617 }
5619 /*
5620 * Locate item with index "n" in list "l" and return it.
5621 * A negative index is counted from the end; -1 is the last item.
5622 * Returns NULL when "n" is out of range.
5623 */
5628 {
5635 /* Negative index is relative to the end. */
5639 /* Check for index out of range. */
5643 /* When there is a cached index may start search from there. */
5645 {
5647 {
5648 /* closest to the start of the list */
5651 }
5653 {
5654 /* closest to the end of the list */
5657 }
5658 else
5659 {
5660 /* closest to the cached index */
5663 }
5664 }
5665 else
5666 {
5668 {
5669 /* closest to the start of the list */
5672 }
5673 else
5674 {
5675 /* closest to the end of the list */
5678 }
5679 }
5682 {
5683 /* search forward */
5686 }
5688 {
5689 /* search backward */
5692 }
5694 /* cache the used index */
5699 }
5701 /*
5702 * Get list item "l[idx]" as a number.
5703 */
5704 static long
5709 {
5714 {
5718 }
5720 }
5722 /*
5723 * Locate "item" list "l" and return its index.
5724 * Returns -1 when "item" is not in the list.
5725 */
5726 static long
5730 {
5742 }
5744 /*
5745 * Append item "item" to the end of list "l".
5746 */
5747 static void
5751 {
5753 {
5754 /* empty list */
5758 }
5759 else
5760 {
5764 }
5767 }
5769 /*
5770 * Append typval_T "tv" to the end of list "l".
5771 * Return FAIL when out of memory.
5772 */
5773 static int
5777 {
5785 }
5787 /*
5788 * Add a dictionary to a list. Used by getqflist().
5789 * Return FAIL when out of memory.
5790 */
5791 int
5795 {
5806 }
5808 /*
5809 * Make a copy of "str" and append it as an item to list "l".
5810 * When "len" >= 0 use "str[len]".
5811 * Returns FAIL when out of memory.
5812 */
5813 static int
5818 {
5832 }
5834 /*
5835 * Append "n" to list "l".
5836 * Returns FAIL when out of memory.
5837 */
5838 static int
5841 varnumber_T n;
5842 {
5853 }
5855 /*
5856 * Insert typval_T "tv" in list "l" before "item".
5857 * If "item" is NULL append at the end.
5858 * Return FAIL when out of memory.
5859 */
5860 static int
5865 {
5872 /* Append new item at end of list. */
5874 else
5875 {
5876 /* Insert new item before existing item. */
5880 {
5883 }
5884 else
5885 {
5888 }
5891 }
5893 }
5895 /*
5896 * Extend "l1" with "l2".
5897 * If "bef" is NULL append at the end, otherwise insert before this item.
5898 * Returns FAIL when out of memory.
5899 */
5900 static int
5905 {
5912 }
5914 /*
5915 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5916 * Return FAIL when out of memory.
5917 */
5918 static int
5923 {
5926 /* make a copy of the first list. */
5933 /* append all items from the second list */
5935 }
5937 /*
5938 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5939 * The refcount of the new list is set to 1.
5940 * See item_copy() for "copyID".
5941 * Returns NULL when out of memory.
5942 */
5948 {
5958 {
5960 {
5961 /* Do this before adding the items, because one of the items may
5962 * refer back to this list. */
5965 }
5968 {
5973 {
5975 {
5978 }
5979 }
5980 else
5983 }
5986 {
5989 }
5990 }
5993 }
5995 /*
5996 * Remove items "item" to "item2" from list "l".
5997 * Does not free the listitem or the value!
5998 */
5999 static void
6004 {
6007 /* notify watchers */
6009 {
6014 }
6018 else
6022 else
6025 }
6027 /*
6028 * Return an allocated string with the string representation of a list.
6029 * May return NULL.
6030 */
6035 {
6036 garray_T ga;
6043 {
6046 }
6050 }
6052 /*
6053 * Join list "l" into a string in "*gap", using separator "sep".
6054 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6055 * Return FAIL or OK.
6056 */
6057 static int
6064 {
6072 {
6075 else
6080 else
6087 }
6089 }
6091 /*
6092 * Garbage collection for lists and dictionaries.
6093 *
6094 * We use reference counts to be able to free most items right away when they
6095 * are no longer used. But for composite items it's possible that it becomes
6096 * unused while the reference count is > 0: When there is a recursive
6097 * reference. Example:
6098 * :let l = [1, 2, 3]
6099 * :let d = {9: l}
6100 * :let l[1] = d
6101 *
6102 * Since this is quite unusual we handle this with garbage collection: every
6103 * once in a while find out which lists and dicts are not referenced from any
6104 * variable.
6105 *
6106 * Here is a good reference text about garbage collection (refers to Python
6107 * but it applies to all reference-counting mechanisms):
6108 * http://python.ca/nas/python/gc/
6109 */
6111 /*
6112 * Do garbage collection for lists and dicts.
6113 * Return TRUE if some memory was freed.
6114 */
6115 int
6117 {
6126 #ifdef FEAT_WINDOWS
6128 #endif
6130 /* Only do this once. */
6134 /*
6135 * 1. Go through all accessible variables and mark all lists and dicts
6136 * with copyID.
6137 */
6138 /* script-local variables */
6142 /* buffer-local variables */
6146 /* window-local variables */
6150 #ifdef FEAT_WINDOWS
6151 /* tabpage-local variables */
6154 #endif
6156 /* global variables */
6159 /* function-local variables */
6161 {
6164 }
6166 /*
6167 * 2. Go through the list of dicts and free items without the copyID.
6168 */
6171 {
6172 /* Free the Dictionary and ordinary items it contains, but don't
6173 * recurse into Lists and Dictionaries, they will be in the list
6174 * of dicts or list of lists. */
6178 /* restart, next dict may also have been freed */
6180 }
6181 else
6184 /*
6185 * 3. Go through the list of lists and free items without the copyID.
6186 * But don't free a list that has a watcher (used in a for loop), these
6187 * are not referenced anywhere.
6188 */
6191 {
6192 /* Free the List and ordinary items it contains, but don't recurse
6193 * into Lists and Dictionaries, they will be in the list of dicts
6194 * or list of lists. */
6198 /* restart, next list may also have been freed */
6200 }
6201 else
6205 }
6207 /*
6208 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6209 */
6210 static void
6214 {
6221 {
6224 }
6225 }
6227 /*
6228 * Mark all lists and dicts referenced through list "l" with "copyID".
6229 */
6230 static void
6234 {
6239 }
6241 /*
6242 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6243 */
6244 static void
6248 {
6253 {
6257 {
6258 /* Didn't see this dict yet. */
6261 }
6267 {
6268 /* Didn't see this list yet. */
6271 }
6273 }
6275 }
6277 /*
6278 * Allocate an empty header for a dictionary.
6279 */
6280 dict_T *
6282 {
6287 {
6288 /* Add the list to the list of dicts for garbage collection. */
6299 }
6301 }
6303 /*
6304 * Unreference a Dictionary: decrement the reference count and free it when it
6305 * becomes zero.
6306 */
6307 static void
6310 {
6313 }
6315 /*
6316 * Free a Dictionary, including all items it contains.
6317 * Ignores the reference count.
6318 */
6319 static void
6323 {
6328 /* Remove the dict from the list of dicts for garbage collection. */
6331 else
6336 /* Lock the hashtab, we don't want it to resize while freeing items. */
6340 {
6342 {
6343 /* Remove the item before deleting it, just in case there is
6344 * something recursive causing trouble. */
6352 }
6353 }
6356 }
6358 /*
6359 * Allocate a Dictionary item.
6360 * The "key" is copied to the new item.
6361 * Note that the value of the item "di_tv" still needs to be initialized!
6362 * Returns NULL when out of memory.
6363 */
6367 {
6372 {
6375 }
6377 }
6379 /*
6380 * Make a copy of a Dictionary item.
6381 */
6385 {
6391 {
6395 }
6397 }
6399 /*
6400 * Remove item "item" from Dictionary "dict" and free it.
6401 */
6402 static void
6406 {
6412 else
6415 }
6417 /*
6418 * Free a dict item. Also clears the value.
6419 */
6420 static void
6423 {
6426 }
6428 /*
6429 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6430 * The refcount of the new dict is set to 1.
6431 * See item_copy() for "copyID".
6432 * Returns NULL when out of memory.
6433 */
6439 {
6450 {
6452 {
6455 }
6458 {
6460 {
6467 {
6470 {
6473 }
6474 }
6475 else
6478 {
6481 }
6482 }
6483 }
6487 {
6490 }
6491 }
6494 }
6496 /*
6497 * Add item "item" to Dictionary "d".
6498 * Returns FAIL when out of memory and when key already existed.
6499 */
6500 static int
6504 {
6506 }
6508 /*
6509 * Add a number or string entry to dictionary "d".
6510 * When "str" is NULL use number "nr", otherwise use "str".
6511 * Returns FAIL when out of memory and when key already exists.
6512 */
6513 int
6519 {
6527 {
6530 }
6531 else
6532 {
6535 }
6537 {
6540 }
6542 }
6544 /*
6545 * Get the number of items in a Dictionary.
6546 */
6547 static long
6550 {
6554 }
6556 /*
6557 * Find item "key[len]" in Dictionary "d".
6558 * If "len" is negative use strlen(key).
6559 * Returns NULL when not found.
6560 */
6566 {
6567 #define AKEYLEN 200
6576 {
6580 }
6581 else
6582 {
6583 /* Avoid a malloc/free by using buf[]. */
6586 }
6593 }
6595 /*
6596 * Get a string item from a dictionary.
6597 * When "save" is TRUE allocate memory for it.
6598 * Returns NULL if the entry doesn't exist or out of memory.
6599 */
6600 char_u *
6605 {
6616 }
6618 /*
6619 * Get a number item from a dictionary.
6620 * Returns 0 if the entry doesn't exist or out of memory.
6621 */
6622 long
6626 {
6633 }
6635 /*
6636 * Return an allocated string with the string representation of a Dictionary.
6637 * May return NULL.
6638 */
6643 {
6644 garray_T ga;
6660 {
6662 {
6667 else
6672 {
6675 }
6683 }
6684 }
6686 {
6689 }
6694 }
6696 /*
6697 * Allocate a variable for a Dictionary and fill it from "*arg".
6698 * Return OK or FAIL. Returns NOTDONE for {expr}.
6699 */
6700 static int
6705 {
6707 typval_T tvkey;
6708 typval_T tv;
6714 /*
6715 * First check if it's not a curly-braces thing: {expr}.
6716 * Must do this without evaluating, otherwise a function may be called
6717 * twice. Unfortunately this means we need to call eval1() twice for the
6718 * first item.
6719 * But {} is an empty Dictionary.
6720 */
6722 {
6727 }
6730 {
6734 }
6740 {
6744 {
6748 }
6751 {
6752 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6757 }
6761 {
6764 }
6766 {
6769 {
6774 }
6778 {
6783 }
6784 }
6789 {
6792 }
6794 }
6797 {
6799 failret:
6803 }
6807 {
6811 }
6814 }
6816 /*
6817 * Return a string with the string representation of a variable.
6818 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6819 * "numbuf" is used for a number.
6820 * Does not put quotes around strings, as ":echo" displays values.
6821 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6822 * May return NULL.
6823 */
6830 {
6835 {
6839 }
6843 {
6851 {
6854 }
6856 {
6859 }
6860 else
6861 {
6865 }
6870 {
6873 }
6875 {
6878 }
6879 else
6880 {
6884 }
6896 }
6900 }
6902 /*
6903 * Return a string with the string representation of a variable.
6904 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6905 * "numbuf" is used for a number.
6906 * Puts quotes around strings, so that they can be parsed back by eval().
6907 * May return NULL.
6908 */
6915 {
6917 {
6930 }
6932 }
6934 /*
6935 * Return string "str" in ' quotes, doubling ' characters.
6936 * If "str" is NULL an empty string is assumed.
6937 * If "function" is TRUE make it function('string').
6938 */
6943 {
6949 {
6954 }
6957 {
6959 {
6962 }
6963 else
6967 {
6971 }
6976 }
6978 }
6980 /*
6981 * Get the value of an environment variable.
6982 * "arg" is pointing to the '$'. It is advanced to after the name.
6983 * If the environment variable was not set, silently assume it is empty.
6984 * Always return OK.
6985 */
6986 static int
6991 {
7002 {
7004 {
7007 /* first try vim_getenv(), fast for normal environment vars */
7010 {
7013 }
7014 else
7015 {
7019 /* next try expanding things like $VIM and ${HOME} */
7022 {
7025 }
7026 }
7028 }
7031 }
7034 }
7036 /*
7037 * Array with names and number of arguments of all internal functions
7038 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7039 */
7040 static struct fst
7041 {
7046 /* implementation of function */
7048 {
7073 #if defined(FEAT_INS_EXPAND)
7077 #endif
7187 #ifdef vim_mkdir
7189 #endif
7236 #ifdef HAVE_STRFTIME
7238 #endif
7275 };
7277 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7279 /*
7280 * Function given to ExpandGeneric() to obtain the list of internal
7281 * or user defined function names.
7282 */
7283 char_u *
7287 {
7294 {
7298 }
7300 {
7306 }
7309 }
7311 /*
7312 * Function given to ExpandGeneric() to obtain the list of internal or
7313 * user defined variable or function names.
7314 */
7315 /*ARGSUSED*/
7316 char_u *
7320 {
7327 {
7331 }
7333 }
7337 /*
7338 * Find internal function in table above.
7339 * Return index, or -1 if not found
7340 */
7341 static int
7344 {
7350 /*
7351 * Find the function name in the table. Binary search.
7352 */
7354 {
7361 else
7363 }
7365 }
7367 /*
7368 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7369 * name it contains, otherwise return "name".
7370 */
7375 {
7384 {
7386 {
7389 }
7392 }
7395 }
7397 /*
7398 * Allocate a variable for the result of a function.
7399 * Return OK or FAIL.
7400 */
7401 static int
7413 {
7419 /*
7420 * Get the arguments.
7421 */
7424 {
7429 {
7432 }
7436 }
7439 else
7446 {
7449 else
7451 }
7458 }
7461 /*
7462 * Call a function with its resolved parameters
7463 * Return OK when the function can't be called, FAIL otherwise.
7464 * Also returns OK when an error was encountered while executing the function.
7465 */
7466 static int
7474 PLUS ONE elements! */
7480 {
7482 #define ERROR_UNKNOWN 0
7483 #define ERROR_TOOMANY 1
7484 #define ERROR_TOOFEW 2
7485 #define ERROR_SCRIPT 3
7486 #define ERROR_DICT 4
7487 #define ERROR_NONE 5
7488 #define ERROR_OTHER 6
7494 #define FLEN_FIXED 40
7498 /*
7499 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7500 * Change <SNR>123_name() to K_SNR 123_name().
7501 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7502 */
7507 {
7513 {
7516 else
7517 {
7520 }
7521 }
7523 {
7526 }
7527 else
7528 {
7532 else
7533 {
7536 }
7537 }
7538 }
7539 else
7545 /* execute the function if no errors detected and executing */
7547 {
7552 {
7553 /*
7554 * User defined function.
7555 */
7558 #ifdef FEAT_AUTOCMD
7559 /* Trigger FuncUndefined event, may load the function. */
7564 {
7565 /* executed an autocommand, search for the function again */
7567 }
7568 #endif
7569 /* Try loading a package. */
7571 {
7572 /* loaded a package, search for the function again */
7574 }
7577 {
7586 else
7587 {
7588 /*
7589 * Call the user function.
7590 * Save and restore search patterns, script variables and
7591 * redo buffer.
7592 */
7601 /* Function was unreferenced while being used, free it
7602 * now. */
7607 }
7608 }
7609 }
7610 else
7611 {
7612 /*
7613 * Find the function name in the table, call its implementation.
7614 */
7617 {
7622 else
7623 {
7627 }
7628 }
7629 }
7630 /*
7631 * The function call (or "FuncUndefined" autocommand sequence) might
7632 * have been aborted by an error, an interrupt, or an explicitly thrown
7633 * exception that has not been caught so far. This situation can be
7634 * tested for by calling aborting(). For an error in an internal
7635 * function or for the "E132" error in call_user_func(), however, the
7636 * throw point at which the "force_abort" flag (temporarily reset by
7637 * emsg()) is normally updated has not been reached yet. We need to
7638 * update that flag first to make aborting() reliable.
7639 */
7641 }
7645 /*
7646 * Report an error unless the argument evaluation or function call has been
7647 * cancelled due to an aborting error, an interrupt, or an exception.
7648 */
7650 {
7652 {
7661 name);
7665 name);
7669 name);
7671 }
7672 }
7679 }
7681 /*
7682 * Give an error message with a function name. Handle <SNR> things.
7683 */
7684 static void
7688 {
7693 else
7698 }
7700 /*********************************************
7701 * Implementation of the built-in functions
7702 */
7704 /*
7705 * "add(list, item)" function
7706 */
7707 static void
7711 {
7716 {
7721 }
7722 else
7724 }
7726 /*
7727 * "append(lnum, string/list)" function
7728 */
7729 static void
7733 {
7745 {
7747 {
7752 }
7755 {
7760 else
7764 {
7767 }
7773 }
7778 }
7779 else
7781 }
7783 /*
7784 * "argc()" function
7785 */
7786 /* ARGSUSED */
7787 static void
7791 {
7793 }
7795 /*
7796 * "argidx()" function
7797 */
7798 /* ARGSUSED */
7799 static void
7803 {
7805 }
7807 /*
7808 * "argv(nr)" function
7809 */
7810 static void
7814 {
7818 {
7822 else
7825 }
7830 }
7832 /*
7833 * "browse(save, title, initdir, default)" function
7834 */
7835 /* ARGSUSED */
7836 static void
7840 {
7841 #ifdef FEAT_BROWSE
7857 else
7861 #else
7863 #endif
7865 }
7867 /*
7868 * "browsedir(title, initdir)" function
7869 */
7870 /* ARGSUSED */
7871 static void
7875 {
7876 #ifdef FEAT_BROWSE
7886 else
7889 #else
7891 #endif
7893 }
7897 /*
7898 * Find a buffer by number or exact name.
7899 */
7903 {
7909 {
7912 {
7913 /* No full path name match, try a match with a URL or a "nofile"
7914 * buffer, these don't use the full path. */
7918 #ifdef FEAT_QUICKFIX
7920 #endif
7921 )
7924 }
7925 }
7927 }
7929 /*
7930 * "bufexists(expr)" function
7931 */
7932 static void
7936 {
7938 }
7940 /*
7941 * "buflisted(expr)" function
7942 */
7943 static void
7947 {
7952 }
7954 /*
7955 * "bufloaded(expr)" function
7956 */
7957 static void
7961 {
7966 }
7970 /*
7971 * Get buffer by number or pattern.
7972 */
7976 {
7991 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8003 /* If not found, try expanding the name, like done for bufexists(). */
8008 }
8010 /*
8011 * "bufname(expr)" function
8012 */
8013 static void
8017 {
8026 else
8029 }
8031 /*
8032 * "bufnr(expr)" function
8033 */
8034 static void
8038 {
8048 /* If the buffer isn't found and the second argument is not zero create a
8049 * new buffer. */
8053 && !error
8060 else
8062 }
8064 /*
8065 * "bufwinnr(nr)" function
8066 */
8067 static void
8071 {
8072 #ifdef FEAT_WINDOWS
8075 #endif
8081 #ifdef FEAT_WINDOWS
8083 {
8087 }
8089 #else
8091 #endif
8093 }
8095 /*
8096 * "byte2line(byte)" function
8097 */
8098 /*ARGSUSED*/
8099 static void
8103 {
8104 #ifndef FEAT_BYTEOFF
8106 #else
8112 else
8115 #endif
8116 }
8118 /*
8119 * "byteidx()" function
8120 */
8121 /*ARGSUSED*/
8122 static void
8126 {
8127 #ifdef FEAT_MBYTE
8129 #endif
8139 #ifdef FEAT_MBYTE
8142 {
8146 }
8148 #else
8151 #endif
8152 }
8154 /*
8155 * "call(func, arglist)" function
8156 */
8157 static void
8161 {
8171 {
8174 }
8180 else
8186 {
8188 {
8191 }
8193 }
8197 {
8199 {
8202 }
8203 /* Make a copy of each argument. This is needed to be able to set
8204 * v_lock to VAR_FIXED in the copy without changing the original list.
8205 */
8207 }
8214 /* Free the arguments. */
8217 }
8219 /*
8220 * "changenr()" function
8221 */
8222 /*ARGSUSED*/
8223 static void
8227 {
8229 }
8231 /*
8232 * "char2nr(string)" function
8233 */
8234 static void
8238 {
8239 #ifdef FEAT_MBYTE
8242 else
8243 #endif
8245 }
8247 /*
8248 * "cindent(lnum)" function
8249 */
8250 static void
8254 {
8255 #ifdef FEAT_CINDENT
8256 pos_T pos;
8257 linenr_T lnum;
8262 {
8266 }
8267 else
8268 #endif
8270 }
8272 /*
8273 * "clearmatches()" function
8274 */
8275 /*ARGSUSED*/
8276 static void
8280 {
8281 #ifdef FEAT_SEARCH_EXTRA
8283 #endif
8284 }
8286 /*
8287 * "col(string)" function
8288 */
8289 static void
8293 {
8300 {
8302 {
8303 /* '> can be MAXCOL, get the length of the line then */
8306 else
8308 }
8309 else
8310 {
8312 #ifdef FEAT_VIRTUALEDIT
8313 /* col(".") when the cursor is on the NUL at the end of the line
8314 * because of "coladd" can be seen as an extra column. */
8316 {
8321 {
8322 # ifdef FEAT_MBYTE
8327 # else
8330 # endif
8331 }
8332 }
8333 #endif
8334 }
8335 }
8337 }
8339 #if defined(FEAT_INS_EXPAND)
8340 /*
8341 * "complete()" function
8342 */
8343 /*ARGSUSED*/
8344 static void
8348 {
8352 {
8355 }
8357 /* Check for undo allowed here, because if something was already inserted
8358 * the line was already saved for undo and this check isn't done. */
8363 {
8366 }
8373 }
8375 /*
8376 * "complete_add()" function
8377 */
8378 /*ARGSUSED*/
8379 static void
8383 {
8385 }
8387 /*
8388 * "complete_check()" function
8389 */
8390 /*ARGSUSED*/
8391 static void
8395 {
8402 }
8403 #endif
8405 /*
8406 * "confirm(message, buttons[, default [, type]])" function
8407 */
8408 /*ARGSUSED*/
8409 static void
8413 {
8414 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8428 {
8433 {
8436 {
8440 else
8441 {
8443 {
8449 }
8450 }
8451 }
8452 }
8453 }
8460 else
8463 #else
8465 #endif
8466 }
8468 /*
8469 * "copy()" function
8470 */
8471 static void
8475 {
8477 }
8479 /*
8480 * "count()" function
8481 */
8482 static void
8486 {
8491 {
8497 {
8500 {
8505 {
8508 {
8512 }
8513 }
8516 }
8521 }
8522 }
8524 {
8530 {
8534 {
8538 }
8542 {
8544 {
8548 }
8549 }
8550 }
8551 }
8552 else
8555 }
8557 /*
8558 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8559 *
8560 * Checks the existence of a cscope connection.
8561 */
8562 /*ARGSUSED*/
8563 static void
8567 {
8568 #ifdef FEAT_CSCOPE
8576 {
8581 }
8584 #else
8586 #endif
8587 }
8589 /*
8590 * "cursor(lnum, col)" function
8591 *
8592 * Moves the cursor to the specified line and column
8593 */
8594 /*ARGSUSED*/
8595 static void
8599 {
8601 #ifdef FEAT_VIRTUALEDIT
8603 #endif
8606 {
8607 pos_T pos;
8613 #ifdef FEAT_VIRTUALEDIT
8615 #endif
8616 }
8617 else
8618 {
8621 #ifdef FEAT_VIRTUALEDIT
8624 #endif
8625 }
8627 #ifdef FEAT_VIRTUALEDIT
8629 #endif
8630 )
8636 #ifdef FEAT_VIRTUALEDIT
8638 #endif
8640 /* Make sure the cursor is in a valid position. */
8642 #ifdef FEAT_MBYTE
8643 /* Correct cursor for multi-byte character. */
8646 #endif
8649 }
8651 /*
8652 * "deepcopy()" function
8653 */
8654 static void
8658 {
8665 else
8667 }
8669 /*
8670 * "delete()" function
8671 */
8672 static void
8676 {
8679 else
8681 }
8683 /*
8684 * "did_filetype()" function
8685 */
8686 /*ARGSUSED*/
8687 static void
8691 {
8692 #ifdef FEAT_AUTOCMD
8694 #else
8696 #endif
8697 }
8699 /*
8700 * "diff_filler()" function
8701 */
8702 /*ARGSUSED*/
8703 static void
8707 {
8708 #ifdef FEAT_DIFF
8710 #endif
8711 }
8713 /*
8714 * "diff_hlID()" function
8715 */
8716 /*ARGSUSED*/
8717 static void
8721 {
8722 #ifdef FEAT_DIFF
8738 {
8739 /* New line, buffer, change: need to get the values. */
8742 {
8744 {
8749 else
8751 }
8752 else
8754 }
8755 else
8760 }
8763 {
8767 else
8769 }
8771 #endif
8772 }
8774 /*
8775 * "empty({expr})" function
8776 */
8777 static void
8781 {
8785 {
8805 }
8808 }
8810 /*
8811 * "escape({string}, {chars})" function
8812 */
8813 static void
8817 {
8823 }
8825 /*
8826 * "eval()" function
8827 */
8828 /*ARGSUSED*/
8829 static void
8833 {
8841 {
8844 }
8847 }
8849 /*
8850 * "eventhandler()" function
8851 */
8852 /*ARGSUSED*/
8853 static void
8857 {
8859 }
8861 /*
8862 * "executable()" function
8863 */
8864 static void
8868 {
8870 }
8872 /*
8873 * "exists()" function
8874 */
8875 static void
8879 {
8887 {
8888 /* first try "normal" environment variables (fast) */
8891 else
8892 {
8893 /* try expanding things like $VIM and ${HOME} */
8898 }
8899 }
8901 {
8905 }
8907 {
8909 }
8911 {
8913 }
8915 {
8916 #ifdef FEAT_AUTOCMD
8919 else
8921 #endif
8922 }
8924 {
8926 typval_T tv;
8928 /* get_name_len() takes care of expanding curly braces */
8932 {
8937 {
8938 /* handle d.key, l[idx], f(expr) */
8942 }
8943 }
8948 }
8951 }
8953 /*
8954 * "expand()" function
8955 */
8956 static void
8960 {
8965 expand_T xpc;
8971 {
8975 }
8976 else
8977 {
8978 /* When the optional second argument is non-zero, don't remove matches
8979 * for 'suffixes' and 'wildignore' */
8984 {
8988 }
8989 else
8991 }
8992 }
8994 /*
8995 * "extend(list, list [, idx])" function
8996 * "extend(dict, dict [, action])" function
8997 */
8998 static void
9002 {
9005 {
9015 {
9017 {
9024 else
9025 {
9028 {
9031 }
9032 }
9033 }
9034 else
9039 }
9040 }
9042 {
9054 {
9055 /* Check the third argument. */
9057 {
9067 {
9070 }
9071 }
9072 else
9075 /* Go over all entries in the second dict and add them to the
9076 * first dict. */
9079 {
9081 {
9085 {
9089 }
9091 {
9094 }
9096 {
9099 }
9100 }
9101 }
9104 }
9105 }
9106 else
9108 }
9110 /*
9111 * "feedkeys()" function
9112 */
9113 /*ARGSUSED*/
9114 static void
9118 {
9125 /* This is not allowed in the sandbox. If the commands would still be
9126 * executed in the sandbox it would be OK, but it probably happens later,
9127 * when "sandbox" is no longer set. */
9134 {
9136 {
9139 {
9141 {
9145 }
9146 }
9147 }
9149 /* Need to escape K_SPECIAL and CSI before putting the string in the
9150 * typeahead buffer. */
9153 {
9159 }
9160 }
9161 }
9163 /*
9164 * "filereadable()" function
9165 */
9166 static void
9170 {
9177 {
9180 }
9181 else
9185 }
9187 /*
9188 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9189 * rights to write into.
9190 */
9191 static void
9195 {
9197 }
9201 static void
9206 {
9207 #ifdef FEAT_SEARCHPATH
9216 #endif
9221 #ifdef FEAT_SEARCHPATH
9225 {
9229 else
9230 {
9236 }
9237 }
9243 {
9244 do
9245 {
9258 }
9262 #endif
9263 }
9268 /*
9269 * Implementation of map() and filter().
9270 */
9271 static void
9276 {
9285 typval_T save_val;
9286 typval_T save_key;
9294 {
9298 }
9300 {
9304 }
9305 else
9306 {
9309 }
9312 /* On type errors, the preceding call has already displayed an error
9313 * message. Avoid a misleading error message for an empty string that
9314 * was not passed as argument. */
9316 {
9320 /* We reset "did_emsg" to be able to detect whether an error
9321 * occurred during evaluation of the expression. */
9326 {
9334 {
9336 {
9348 }
9349 }
9353 }
9354 else
9355 {
9357 {
9366 }
9367 }
9372 }
9375 }
9377 static int
9383 {
9384 typval_T rettv;
9392 {
9395 }
9397 {
9398 /* map(): replace the list item value */
9402 }
9403 else
9404 {
9407 /* filter(): when expr is zero remove the item */
9410 /* On type error, nothing has been removed; return FAIL to stop the
9411 * loop. The error message was given by get_tv_number_chk(). */
9414 }
9417 }
9419 /*
9420 * "filter()" function
9421 */
9422 static void
9426 {
9428 }
9430 /*
9431 * "finddir({fname}[, {path}[, {count}]])" function
9432 */
9433 static void
9437 {
9439 }
9441 /*
9442 * "findfile({fname}[, {path}[, {count}]])" function
9443 */
9444 static void
9448 {
9450 }
9452 /*
9453 * "fnamemodify({fname}, {mods})" function
9454 */
9455 static void
9459 {
9471 else
9472 {
9475 }
9480 else
9483 }
9487 /*
9488 * "foldclosed()" function
9489 */
9490 static void
9495 {
9496 #ifdef FEAT_FOLDING
9497 linenr_T lnum;
9502 {
9504 {
9507 else
9510 }
9511 }
9512 #endif
9514 }
9516 /*
9517 * "foldclosed()" function
9518 */
9519 static void
9523 {
9525 }
9527 /*
9528 * "foldclosedend()" function
9529 */
9530 static void
9534 {
9536 }
9538 /*
9539 * "foldlevel()" function
9540 */
9541 static void
9545 {
9546 #ifdef FEAT_FOLDING
9547 linenr_T lnum;
9552 else
9553 #endif
9555 }
9557 /*
9558 * "foldtext()" function
9559 */
9560 /*ARGSUSED*/
9561 static void
9565 {
9566 #ifdef FEAT_FOLDING
9567 linenr_T lnum;
9572 #endif
9576 #ifdef FEAT_FOLDING
9581 {
9582 /* Find first non-empty line in the fold. */
9585 {
9589 }
9591 /* Find interesting text in this line. */
9593 /* skip C comment-start */
9595 {
9599 {
9603 }
9604 }
9611 {
9617 /* remove 'foldmarker' and 'commentstring' */
9620 }
9621 }
9622 #endif
9623 }
9625 /*
9626 * "foldtextresult(lnum)" function
9627 */
9628 /*ARGSUSED*/
9629 static void
9633 {
9634 #ifdef FEAT_FOLDING
9635 linenr_T lnum;
9638 foldinfo_T foldinfo;
9640 #endif
9644 #ifdef FEAT_FOLDING
9646 /* treat illegal types and illegal string values for {lnum} the same */
9651 {
9657 }
9658 #endif
9659 }
9661 /*
9662 * "foreground()" function
9663 */
9664 /*ARGSUSED*/
9665 static void
9669 {
9671 #ifdef FEAT_GUI
9674 #else
9675 # ifdef WIN32
9677 # endif
9678 #endif
9679 }
9681 /*
9682 * "function()" function
9683 */
9684 /*ARGSUSED*/
9685 static void
9689 {
9698 else
9699 {
9702 }
9703 }
9705 /*
9706 * "garbagecollect()" function
9707 */
9708 /*ARGSUSED*/
9709 static void
9713 {
9714 /* This is postponed until we are back at the toplevel, because we may be
9715 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9717 }
9719 /*
9720 * "get()" function
9721 */
9722 static void
9726 {
9734 {
9736 {
9742 }
9743 }
9745 {
9747 {
9751 }
9752 }
9753 else
9757 {
9760 else
9762 }
9763 else
9765 }
9767 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9769 /*
9770 * Get line or list of lines from buffer "buf" into "rettv".
9771 * Return a range (from start to end) of lines in rettv from the specified
9772 * buffer.
9773 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9774 */
9775 static void
9778 linenr_T start;
9779 linenr_T end;
9782 {
9786 {
9789 }
9790 else
9797 {
9800 else
9805 }
9806 else
9807 {
9819 }
9820 }
9822 /*
9823 * "getbufline()" function
9824 */
9825 static void
9829 {
9830 linenr_T lnum;
9831 linenr_T end;
9842 else
9846 }
9848 /*
9849 * "getbufvar()" function
9850 */
9851 static void
9855 {
9870 {
9872 {
9873 /* set curbuf to be our buf, temporarily */
9879 /* restore previous notion of curbuf */
9881 }
9882 else
9883 {
9885 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9886 * scope prefix before the NUL byte is required by
9887 * find_var_in_ht(). */
9889 /* look up the variable */
9893 }
9894 }
9897 }
9899 /*
9900 * "getchar()" function
9901 */
9902 static void
9906 {
9907 varnumber_T n;
9910 /* Position the cursor. Needed after a message that ends in a space. */
9916 {
9918 /* getchar(): blocking wait. */
9921 /* getchar(1): only check if char avail */
9924 /* illegal argument or getchar(0) and no char avail: return zero */
9926 else
9927 /* getchar(0) and char avail: return char */
9932 }
9942 {
9946 /* Turn a special key into three bytes, plus modifier. */
9948 {
9952 }
9954 {
9958 }
9959 #ifdef FEAT_MBYTE
9962 #endif
9963 else
9969 #ifdef FEAT_MOUSE
9989 {
9993 linenr_T lnum;
9994 # ifdef FEAT_WINDOWS
9996 # endif
10000 {
10001 /* Find the window at the mouse coordinates and compute the
10002 * text position. */
10005 # ifdef FEAT_WINDOWS
10008 # endif
10012 }
10013 }
10014 #endif
10015 }
10016 }
10018 /*
10019 * "getcharmod()" function
10020 */
10021 /*ARGSUSED*/
10022 static void
10026 {
10028 }
10030 /*
10031 * "getcmdline()" function
10032 */
10033 /*ARGSUSED*/
10034 static void
10038 {
10041 }
10043 /*
10044 * "getcmdpos()" function
10045 */
10046 /*ARGSUSED*/
10047 static void
10051 {
10053 }
10055 /*
10056 * "getcmdtype()" function
10057 */
10058 /*ARGSUSED*/
10059 static void
10063 {
10067 {
10070 }
10071 }
10073 /*
10074 * "getcwd()" function
10075 */
10076 /*ARGSUSED*/
10077 static void
10081 {
10087 else
10088 {
10090 #ifdef BACKSLASH_IN_FILENAME
10093 #endif
10094 }
10095 }
10097 /*
10098 * "getfontname()" function
10099 */
10100 /*ARGSUSED*/
10101 static void
10105 {
10108 #ifdef FEAT_GUI
10110 {
10111 GuiFont font;
10115 {
10116 /* Get the "Normal" font. Either the name saved by
10117 * hl_set_font_name() or from the font ID. */
10120 }
10121 else
10122 {
10129 }
10133 }
10134 #endif
10135 }
10137 /*
10138 * "getfperm({fname})" function
10139 */
10140 static void
10144 {
10155 {
10158 {
10160 {
10163 }
10164 }
10165 }
10167 }
10169 /*
10170 * "getfsize({fname})" function
10171 */
10172 static void
10176 {
10185 {
10188 else
10189 {
10192 /* non-perfect check for overflow */
10195 }
10196 }
10197 else
10199 }
10201 /*
10202 * "getftime({fname})" function
10203 */
10204 static void
10208 {
10216 else
10218 }
10220 /*
10221 * "getftype({fname})" function
10222 */
10223 static void
10227 {
10237 {
10238 #ifdef S_ISREG
10243 # ifdef S_ISLNK
10246 # endif
10247 # ifdef S_ISBLK
10250 # endif
10251 # ifdef S_ISCHR
10254 # endif
10255 # ifdef S_ISFIFO
10258 # endif
10259 # ifdef S_ISSOCK
10262 # endif
10263 else
10265 #else
10266 # ifdef S_IFMT
10268 {
10271 # ifdef S_IFLNK
10273 # endif
10274 # ifdef S_IFBLK
10276 # endif
10277 # ifdef S_IFCHR
10279 # endif
10280 # ifdef S_IFIFO
10282 # endif
10283 # ifdef S_IFSOCK
10285 # endif
10287 }
10288 # else
10291 else
10293 # endif
10294 #endif
10296 }
10298 }
10300 /*
10301 * "getline(lnum, [end])" function
10302 */
10303 static void
10307 {
10308 linenr_T lnum;
10309 linenr_T end;
10314 {
10317 }
10318 else
10319 {
10322 }
10325 }
10327 /*
10328 * "getmatches()" function
10329 */
10330 /*ARGSUSED*/
10331 static void
10335 {
10336 #ifdef FEAT_SEARCH_EXTRA
10343 {
10345 {
10356 }
10357 }
10358 #endif
10359 }
10361 /*
10362 * "getpos(string)" function
10363 */
10364 static void
10368 {
10374 {
10379 else
10386 #ifdef FEAT_VIRTUALEDIT
10388 #endif
10390 }
10391 else
10393 }
10395 /*
10396 * "getqflist()" and "getloclist()" functions
10397 */
10398 /*ARGSUSED*/
10399 static void
10403 {
10404 #ifdef FEAT_QUICKFIX
10406 #endif
10409 #ifdef FEAT_QUICKFIX
10411 {
10414 {
10418 }
10421 }
10422 #endif
10423 }
10425 /*
10426 * "getreg()" function
10427 */
10428 static void
10432 {
10439 {
10444 }
10445 else
10454 }
10456 /*
10457 * "getregtype()" function
10458 */
10459 static void
10463 {
10470 {
10473 {
10477 }
10478 }
10479 else
10480 /* Default to v:register */
10490 {
10493 #ifdef FEAT_VISUAL
10498 #endif
10499 }
10502 }
10504 /*
10505 * "gettabwinvar()" function
10506 */
10507 static void
10511 {
10513 }
10515 /*
10516 * "getwinposx()" function
10517 */
10518 /*ARGSUSED*/
10519 static void
10523 {
10525 #ifdef FEAT_GUI
10527 {
10532 }
10533 #endif
10534 }
10536 /*
10537 * "getwinposy()" function
10538 */
10539 /*ARGSUSED*/
10540 static void
10544 {
10546 #ifdef FEAT_GUI
10548 {
10553 }
10554 #endif
10555 }
10557 /*
10558 * Find window specifed by "vp" in tabpage "tp".
10559 */
10564 {
10565 #ifdef FEAT_WINDOWS
10567 #endif
10572 #ifdef FEAT_WINDOWS
10583 #else
10587 #endif
10588 }
10590 /*
10591 * "getwinvar()" function
10592 */
10593 static void
10597 {
10599 }
10601 /*
10602 * getwinvar() and gettabwinvar()
10603 */
10604 static void
10609 {
10615 #ifdef FEAT_WINDOWS
10618 else
10620 #endif
10629 {
10630 /* Set curwin to be our win, temporarily. Also set curbuf, so
10631 * that we can get buffer-local options. */
10638 else
10639 {
10641 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10642 * scope prefix before the NUL byte is required by
10643 * find_var_in_ht(). */
10645 /* look up the variable */
10649 }
10651 /* restore previous notion of curwin */
10654 }
10657 }
10659 /*
10660 * "glob()" function
10661 */
10662 static void
10666 {
10667 expand_T xpc;
10674 }
10676 /*
10677 * "globpath()" function
10678 */
10679 static void
10683 {
10690 else
10692 }
10694 /*
10695 * "has()" function
10696 */
10697 static void
10701 {
10706 {
10707 #ifdef AMIGA
10709 # ifdef FEAT_ARP
10711 # endif
10712 #endif
10713 #ifdef __BEOS__
10715 #endif
10716 #ifdef MSDOS
10717 # ifdef DJGPP
10719 # else
10721 # endif
10722 #endif
10723 #ifdef MACOS
10725 #endif
10726 #if defined(MACOS_X_UNIX)
10728 #endif
10729 #ifdef OS2
10731 #endif
10732 #ifdef __QNX__
10734 #endif
10735 #ifdef RISCOS
10737 #endif
10738 #ifdef UNIX
10740 #endif
10741 #ifdef VMS
10743 #endif
10744 #ifdef WIN16
10746 #endif
10747 #ifdef WIN32
10749 #endif
10750 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10752 #endif
10753 #ifdef WIN64
10755 #endif
10756 #ifdef EBCDIC
10758 #endif
10759 #ifndef CASE_INSENSITIVE_FILENAME
10761 #endif
10762 #ifdef FEAT_ARABIC
10764 #endif
10765 #ifdef FEAT_AUTOCMD
10767 #endif
10768 #ifdef FEAT_BEVAL
10772 # endif
10773 #endif
10774 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10776 # ifdef ALL_BUILTIN_TCAPS
10778 # endif
10779 #endif
10780 #ifdef FEAT_BYTEOFF
10782 #endif
10783 #ifdef FEAT_CINDENT
10785 #endif
10786 #ifdef FEAT_CLIENTSERVER
10788 #endif
10789 #ifdef FEAT_CLIPBOARD
10791 #endif
10792 #ifdef FEAT_CMDL_COMPL
10794 #endif
10795 #ifdef FEAT_CMDHIST
10797 #endif
10798 #ifdef FEAT_COMMENTS
10800 #endif
10801 #ifdef FEAT_CRYPT
10803 #endif
10804 #ifdef FEAT_CSCOPE
10806 #endif
10807 #ifdef CURSOR_SHAPE
10809 #endif
10810 #ifdef DEBUG
10812 #endif
10813 #ifdef FEAT_CON_DIALOG
10815 #endif
10816 #ifdef FEAT_GUI_DIALOG
10818 #endif
10819 #ifdef FEAT_DIFF
10821 #endif
10822 #ifdef FEAT_DIGRAPHS
10824 #endif
10825 #ifdef FEAT_DND
10827 #endif
10828 #ifdef FEAT_EMACS_TAGS
10830 #endif
10832 #ifdef FEAT_EX_EXTRA
10834 #endif
10835 #ifdef FEAT_SEARCH_EXTRA
10837 #endif
10838 #ifdef FEAT_FKMAP
10840 #endif
10841 #ifdef FEAT_SEARCHPATH
10843 #endif
10844 #if defined(UNIX) && !defined(USE_SYSTEM)
10846 #endif
10847 #ifdef FEAT_FIND_ID
10849 #endif
10850 #ifdef FEAT_FOLDING
10852 #endif
10853 #ifdef FEAT_FOOTER
10855 #endif
10856 #if !defined(USE_SYSTEM) && defined(UNIX)
10858 #endif
10859 #ifdef FEAT_GETTEXT
10861 #endif
10862 #ifdef FEAT_GUI
10864 #endif
10865 #ifdef FEAT_GUI_ATHENA
10866 # ifdef FEAT_GUI_NEXTAW
10868 # else
10870 # endif
10871 #endif
10872 #ifdef FEAT_GUI_GTK
10874 # ifdef HAVE_GTK2
10876 # endif
10877 #endif
10878 #ifdef FEAT_GUI_MAC
10880 #endif
10881 #ifdef FEAT_GUI_MOTIF
10883 #endif
10884 #ifdef FEAT_GUI_PHOTON
10886 #endif
10887 #ifdef FEAT_GUI_W16
10889 #endif
10890 #ifdef FEAT_GUI_W32
10892 #endif
10893 #ifdef FEAT_HANGULIN
10895 #endif
10896 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10898 #endif
10899 #ifdef FEAT_INS_EXPAND
10901 #endif
10902 #ifdef FEAT_JUMPLIST
10904 #endif
10905 #ifdef FEAT_KEYMAP
10907 #endif
10908 #ifdef FEAT_LANGMAP
10910 #endif
10911 #ifdef FEAT_LIBCALL
10913 #endif
10914 #ifdef FEAT_LINEBREAK
10916 #endif
10917 #ifdef FEAT_LISP
10919 #endif
10920 #ifdef FEAT_LISTCMDS
10922 #endif
10923 #ifdef FEAT_LOCALMAP
10925 #endif
10926 #ifdef FEAT_MENU
10928 #endif
10929 #ifdef FEAT_SESSION
10931 #endif
10932 #ifdef FEAT_MODIFY_FNAME
10934 #endif
10935 #ifdef FEAT_MOUSE
10937 #endif
10938 #ifdef FEAT_MOUSESHAPE
10940 #endif
10941 #if defined(UNIX) || defined(VMS)
10942 # ifdef FEAT_MOUSE_DEC
10944 # endif
10945 # ifdef FEAT_MOUSE_GPM
10947 # endif
10948 # ifdef FEAT_MOUSE_JSB
10950 # endif
10951 # ifdef FEAT_MOUSE_NET
10953 # endif
10954 # ifdef FEAT_MOUSE_PTERM
10956 # endif
10957 # ifdef FEAT_MOUSE_XTERM
10959 # endif
10960 #endif
10961 #ifdef FEAT_MBYTE
10963 #endif
10964 #ifdef FEAT_MBYTE_IME
10966 #endif
10967 #ifdef FEAT_MULTI_LANG
10969 #endif
10970 #ifdef FEAT_MZSCHEME
10971 #ifndef DYNAMIC_MZSCHEME
10973 #endif
10974 #endif
10975 #ifdef FEAT_OLE
10977 #endif
10978 #ifdef FEAT_OSFILETYPE
10980 #endif
10981 #ifdef FEAT_PATH_EXTRA
10983 #endif
10984 #ifdef FEAT_PERL
10985 #ifndef DYNAMIC_PERL
10987 #endif
10988 #endif
10989 #ifdef FEAT_PYTHON
10990 #ifndef DYNAMIC_PYTHON
10992 #endif
10993 #endif
10994 #ifdef FEAT_POSTSCRIPT
10996 #endif
10997 #ifdef FEAT_PRINTER
10999 #endif
11000 #ifdef FEAT_PROFILE
11002 #endif
11003 #ifdef FEAT_RELTIME
11005 #endif
11006 #ifdef FEAT_QUICKFIX
11008 #endif
11009 #ifdef FEAT_RIGHTLEFT
11011 #endif
11012 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11014 #endif
11015 #ifdef FEAT_SCROLLBIND
11017 #endif
11018 #ifdef FEAT_CMDL_INFO
11021 #endif
11022 #ifdef FEAT_SIGNS
11024 #endif
11025 #ifdef FEAT_SMARTINDENT
11027 #endif
11028 #ifdef FEAT_SNIFF
11030 #endif
11031 #ifdef FEAT_STL_OPT
11033 #endif
11034 #ifdef FEAT_SUN_WORKSHOP
11036 #endif
11037 #ifdef FEAT_NETBEANS_INTG
11039 #endif
11040 #ifdef FEAT_SPELL
11042 #endif
11043 #ifdef FEAT_SYN_HL
11045 #endif
11046 #if defined(USE_SYSTEM) || !defined(UNIX)
11048 #endif
11049 #ifdef FEAT_TAG_BINS
11051 #endif
11052 #ifdef FEAT_TAG_OLDSTATIC
11054 #endif
11055 #ifdef FEAT_TAG_ANYWHITE
11057 #endif
11058 #ifdef FEAT_TCL
11059 # ifndef DYNAMIC_TCL
11061 # endif
11062 #endif
11063 #ifdef TERMINFO
11065 #endif
11066 #ifdef FEAT_TERMRESPONSE
11068 #endif
11069 #ifdef FEAT_TEXTOBJ
11071 #endif
11072 #ifdef HAVE_TGETENT
11074 #endif
11075 #ifdef FEAT_TITLE
11077 #endif
11078 #ifdef FEAT_TOOLBAR
11080 #endif
11081 #ifdef FEAT_USR_CMDS
11084 #endif
11085 #ifdef FEAT_VIMINFO
11087 #endif
11088 #ifdef FEAT_VERTSPLIT
11090 #endif
11091 #ifdef FEAT_VIRTUALEDIT
11093 #endif
11094 #ifdef FEAT_VISUAL
11096 #endif
11097 #ifdef FEAT_VISUALEXTRA
11099 #endif
11100 #ifdef FEAT_VREPLACE
11102 #endif
11103 #ifdef FEAT_WILDIGN
11105 #endif
11106 #ifdef FEAT_WILDMENU
11108 #endif
11109 #ifdef FEAT_WINDOWS
11111 #endif
11112 #ifdef FEAT_WAK
11114 #endif
11115 #ifdef FEAT_WRITEBACKUP
11117 #endif
11118 #ifdef FEAT_XIM
11120 #endif
11121 #ifdef FEAT_XFONTSET
11123 #endif
11124 #ifdef USE_XSMP
11126 #endif
11127 #ifdef USE_XSMP_INTERACT
11129 #endif
11130 #ifdef FEAT_XCLIPBOARD
11132 #endif
11133 #ifdef FEAT_XTERM_SAVE
11135 #endif
11136 #if defined(UNIX) && defined(FEAT_X11)
11138 #endif
11139 NULL
11140 };
11145 {
11148 }
11151 {
11156 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11159 #endif
11160 #ifdef DYNAMIC_TCL
11163 #endif
11164 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11167 #endif
11168 #ifdef DYNAMIC_MZSCHEME
11171 #endif
11172 #ifdef DYNAMIC_RUBY
11175 #endif
11176 #ifdef DYNAMIC_PYTHON
11179 #endif
11180 #ifdef DYNAMIC_PERL
11183 #endif
11184 #ifdef FEAT_GUI
11187 # ifdef FEAT_GUI_W32
11190 # endif
11191 # ifdef FEAT_BROWSE
11194 # endif
11195 #endif
11196 #ifdef FEAT_SYN_HL
11199 #endif
11200 #if defined(WIN3264)
11203 #endif
11204 #ifdef FEAT_NETBEANS_INTG
11207 #endif
11208 }
11211 }
11213 /*
11214 * "has_key()" function
11215 */
11216 static void
11220 {
11223 {
11226 }
11232 }
11234 /*
11235 * "haslocaldir()" function
11236 */
11237 /*ARGSUSED*/
11238 static void
11242 {
11244 }
11246 /*
11247 * "hasmapto()" function
11248 */
11249 static void
11253 {
11262 else
11263 {
11267 }
11271 else
11273 }
11275 /*
11276 * "histadd()" function
11277 */
11278 /*ARGSUSED*/
11279 static void
11283 {
11284 #ifdef FEAT_CMDHIST
11288 #endif
11293 #ifdef FEAT_CMDHIST
11297 {
11300 {
11304 }
11305 }
11306 #endif
11307 }
11309 /*
11310 * "histdel()" function
11311 */
11312 /*ARGSUSED*/
11313 static void
11317 {
11318 #ifdef FEAT_CMDHIST
11327 /* only one argument: clear entire history */
11330 /* index given: remove that entry */
11333 else
11334 /* string given: remove all matching entries */
11338 #else
11340 #endif
11341 }
11343 /*
11344 * "histget()" function
11345 */
11346 /*ARGSUSED*/
11347 static void
11351 {
11352 #ifdef FEAT_CMDHIST
11360 else
11361 {
11365 else
11367 /* -1 on type error */
11369 }
11370 #else
11372 #endif
11374 }
11376 /*
11377 * "histnr()" function
11378 */
11379 /*ARGSUSED*/
11380 static void
11384 {
11387 #ifdef FEAT_CMDHIST
11393 else
11394 #endif
11397 }
11399 /*
11400 * "highlightID(name)" function
11401 */
11402 static void
11406 {
11408 }
11410 /*
11411 * "highlight_exists()" function
11412 */
11413 static void
11417 {
11419 }
11421 /*
11422 * "hostname()" function
11423 */
11424 /*ARGSUSED*/
11425 static void
11429 {
11435 }
11437 /*
11438 * iconv() function
11439 */
11440 /*ARGSUSED*/
11441 static void
11445 {
11446 #ifdef FEAT_MBYTE
11450 vimconv_T vimconv;
11451 #endif
11456 #ifdef FEAT_MBYTE
11463 /* If the encodings are equal, no conversion needed. */
11466 else
11472 #endif
11473 }
11475 /*
11476 * "indent()" function
11477 */
11478 static void
11482 {
11483 linenr_T lnum;
11488 else
11490 }
11492 /*
11493 * "index()" function
11494 */
11495 static void
11499 {
11507 {
11510 }
11513 {
11516 {
11519 /* Start at specified item. Use the cached index that list_find()
11520 * sets, so that a negative number also works. */
11527 }
11531 {
11534 }
11535 }
11536 }
11542 /*
11543 * This function is used by f_input() and f_inputdialog() functions. The third
11544 * argument to f_input() specifies the type of completion to use at the
11545 * prompt. The third argument to f_inputdialog() specifies the value to return
11546 * when the user cancels the prompt.
11547 */
11548 static void
11553 {
11565 #ifdef NO_CONSOLE_INPUT
11566 /* While starting up, there is no place to enter text. */
11568 {
11571 }
11572 #endif
11576 {
11577 /* Only the part of the message after the last NL is considered as
11578 * prompt for the command line */
11582 else
11583 {
11593 }
11597 {
11603 {
11619 }
11620 }
11629 /* since the user typed this, no need to wait for return */
11632 }
11634 }
11636 /*
11637 * "input()" function
11638 * Also handles inputsecret() when inputsecret is set.
11639 */
11640 static void
11644 {
11646 }
11648 /*
11649 * "inputdialog()" function
11650 */
11651 static void
11655 {
11656 #if defined(FEAT_GUI_TEXTDIALOG)
11657 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11659 {
11668 else
11674 else
11675 {
11681 else
11683 }
11685 }
11686 else
11687 #endif
11689 }
11691 /*
11692 * "inputlist()" function
11693 */
11694 static void
11698 {
11704 #ifdef NO_CONSOLE_INPUT
11705 /* While starting up, there is no place to enter text. */
11708 #endif
11710 {
11713 }
11722 {
11725 }
11727 /* Ask for choice. */
11733 }
11738 /*
11739 * "inputrestore()" function
11740 */
11741 /*ARGSUSED*/
11742 static void
11746 {
11748 {
11753 }
11755 {
11758 }
11759 }
11761 /*
11762 * "inputsave()" function
11763 */
11764 /*ARGSUSED*/
11765 static void
11769 {
11770 /* Add an entry to the stack of typehead storage. */
11772 {
11777 }
11778 else
11780 }
11782 /*
11783 * "inputsecret()" function
11784 */
11785 static void
11789 {
11795 }
11797 /*
11798 * "insert()" function
11799 */
11800 static void
11804 {
11815 {
11823 else
11824 {
11827 {
11830 }
11831 }
11833 {
11836 }
11837 }
11838 }
11840 /*
11841 * "isdirectory()" function
11842 */
11843 static void
11847 {
11849 }
11851 /*
11852 * "islocked()" function
11853 */
11854 static void
11858 {
11859 lval_T lv;
11865 FNE_CHECK_START);
11867 {
11870 else
11871 {
11873 {
11876 else
11877 {
11880 {
11881 /* Consider a variable locked when:
11882 * 1. the variable itself is locked
11883 * 2. the value of the variable is locked.
11884 * 3. the List or Dict value is locked.
11885 */
11888 }
11889 }
11890 }
11896 /* List item. */
11898 else
11899 /* Dictionary item. */
11901 }
11902 }
11905 }
11909 /*
11910 * Turn a dict into a list:
11911 * "what" == 0: list of keys
11912 * "what" == 1: list of values
11913 * "what" == 2: list of items
11914 */
11915 static void
11920 {
11931 {
11934 }
11943 {
11945 {
11955 {
11956 /* keys() */
11960 }
11962 {
11963 /* values() */
11965 }
11966 else
11967 {
11968 /* items() */
11990 }
11991 }
11992 }
11993 }
11995 /*
11996 * "items(dict)" function
11997 */
11998 static void
12002 {
12004 }
12006 /*
12007 * "join()" function
12008 */
12009 static void
12013 {
12014 garray_T ga;
12019 {
12022 }
12027 else
12033 {
12038 }
12039 else
12041 }
12043 /*
12044 * "keys()" function
12045 */
12046 static void
12050 {
12052 }
12054 /*
12055 * "last_buffer_nr()" function.
12056 */
12057 /*ARGSUSED*/
12058 static void
12062 {
12071 }
12073 /*
12074 * "len()" function
12075 */
12076 static void
12080 {
12082 {
12097 }
12098 }
12102 static void
12107 {
12108 #ifdef FEAT_LIBCALL
12112 #endif
12117 else
12123 #ifdef FEAT_LIBCALL
12124 /* The first two args must be strings, otherwise its meaningless */
12126 {
12132 else
12136 string_in,
12138 string_result,
12142 }
12143 #endif
12144 }
12146 /*
12147 * "libcall()" function
12148 */
12149 static void
12153 {
12155 }
12157 /*
12158 * "libcallnr()" function
12159 */
12160 static void
12164 {
12166 }
12168 /*
12169 * "line(string)" function
12170 */
12171 static void
12175 {
12184 }
12186 /*
12187 * "line2byte(lnum)" function
12188 */
12189 /*ARGSUSED*/
12190 static void
12194 {
12195 #ifndef FEAT_BYTEOFF
12197 #else
12198 linenr_T lnum;
12203 else
12207 #endif
12208 }
12210 /*
12211 * "lispindent(lnum)" function
12212 */
12213 static void
12217 {
12218 #ifdef FEAT_LISP
12219 pos_T pos;
12220 linenr_T lnum;
12225 {
12229 }
12230 else
12231 #endif
12233 }
12235 /*
12236 * "localtime()" function
12237 */
12238 /*ARGSUSED*/
12239 static void
12243 {
12245 }
12249 static void
12254 {
12261 garray_T ga;
12264 /* return empty string for failure */
12273 {
12277 }
12278 else
12289 {
12299 }
12300 }
12302 /*
12303 * "map()" function
12304 */
12305 static void
12309 {
12311 }
12313 /*
12314 * "maparg()" function
12315 */
12316 static void
12320 {
12322 }
12324 /*
12325 * "mapcheck()" function
12326 */
12327 static void
12331 {
12333 }
12337 static void
12342 {
12346 regmatch_T regmatch;
12359 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12365 {
12366 /* return empty list when there are no matches */
12369 }
12371 {
12374 }
12377 {
12381 }
12382 else
12390 {
12397 {
12402 }
12403 else
12404 {
12409 /* When "count" argument is there ignore matches before "start",
12410 * otherwise skip part of the string. Differs when pattern is "^"
12411 * or "\<". */
12414 else
12416 }
12422 }
12426 {
12430 {
12432 {
12434 {
12437 }
12442 }
12451 /* Advance to just after the match. */
12453 {
12456 }
12457 else
12458 {
12459 #ifdef FEAT_MBYTE
12462 #else
12464 #endif
12465 }
12466 }
12469 {
12471 {
12474 /* return list with matched string and submatches */
12476 {
12478 {
12482 }
12488 }
12489 }
12491 {
12492 /* return matched string */
12495 else
12498 }
12501 else
12502 {
12506 else
12510 }
12511 }
12513 }
12515 theend:
12518 }
12520 /*
12521 * "match()" function
12522 */
12523 static void
12527 {
12529 }
12531 /*
12532 * "matchadd()" function
12533 */
12534 static void
12538 {
12539 #ifdef FEAT_SEARCH_EXTRA
12552 {
12556 }
12560 {
12563 }
12566 #endif
12567 }
12569 /*
12570 * "matcharg()" function
12571 */
12572 static void
12576 {
12578 {
12579 #ifdef FEAT_SEARCH_EXTRA
12584 {
12586 {
12590 }
12591 else
12592 {
12595 }
12596 }
12597 #endif
12598 }
12599 }
12601 /*
12602 * "matchdelete()" function
12603 */
12604 static void
12608 {
12609 #ifdef FEAT_SEARCH_EXTRA
12612 #endif
12613 }
12615 /*
12616 * "matchend()" function
12617 */
12618 static void
12622 {
12624 }
12626 /*
12627 * "matchlist()" function
12628 */
12629 static void
12633 {
12635 }
12637 /*
12638 * "matchstr()" function
12639 */
12640 static void
12644 {
12646 }
12650 static void
12655 {
12661 {
12667 {
12670 {
12673 {
12680 }
12681 }
12682 }
12683 }
12685 {
12693 {
12696 {
12698 {
12702 {
12705 }
12708 }
12709 }
12710 }
12711 }
12712 else
12715 }
12717 /*
12718 * "max()" function
12719 */
12720 static void
12724 {
12726 }
12728 /*
12729 * "min()" function
12730 */
12731 static void
12735 {
12737 }
12741 /*
12742 * Create the directory in which "dir" is located, and higher levels when
12743 * needed.
12744 */
12745 static int
12749 {
12754 /* Get end of directory name in "dir".
12755 * We're done when it's "/" or "c:/". */
12760 /* If the directory exists we're done. Otherwise: create it.*/
12770 }
12772 #ifdef vim_mkdir
12773 /*
12774 * "mkdir()" function
12775 */
12776 static void
12780 {
12791 {
12796 }
12798 }
12799 #endif
12801 /*
12802 * "mode()" function
12803 */
12804 /*ARGSUSED*/
12805 static void
12809 {
12812 #ifdef FEAT_VISUAL
12814 {
12817 else
12819 }
12820 else
12821 #endif
12825 {
12828 else
12830 }
12833 else
12839 }
12841 /*
12842 * "nextnonblank()" function
12843 */
12844 static void
12848 {
12849 linenr_T lnum;
12852 {
12854 {
12857 }
12860 }
12862 }
12864 /*
12865 * "nr2char()" function
12866 */
12867 static void
12871 {
12874 #ifdef FEAT_MBYTE
12877 else
12878 #endif
12879 {
12882 }
12885 }
12887 /*
12888 * "pathshorten()" function
12889 */
12890 static void
12894 {
12901 else
12902 {
12907 }
12908 }
12910 /*
12911 * "prevnonblank()" function
12912 */
12913 static void
12917 {
12918 linenr_T lnum;
12923 else
12927 }
12929 #ifdef HAVE_STDARG_H
12930 /* This dummy va_list is here because:
12931 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12932 * - locally in the function results in a "used before set" warning
12933 * - using va_start() to initialize it gives "function with fixed args" error */
12935 #endif
12937 /*
12938 * "printf()" function
12939 */
12940 static void
12944 {
12948 {
12955 /* Get the required length, allocate the buffer and do it for real. */
12960 {
12963 {
12966 }
12967 }
12969 }
12970 #endif
12971 }
12973 /*
12974 * "pumvisible()" function
12975 */
12976 /*ARGSUSED*/
12977 static void
12981 {
12983 #ifdef FEAT_INS_EXPAND
12986 #endif
12987 }
12989 /*
12990 * "range()" function
12991 */
12992 static void
12996 {
13005 {
13008 }
13009 else
13010 {
13014 }
13023 else
13024 {
13030 }
13031 }
13033 /*
13034 * "readfile()" function
13035 */
13036 static void
13040 {
13060 {
13065 }
13070 /* Always open the file in binary mode, library functions have a mind of
13071 * their own about CR-LF conversion. */
13074 {
13077 }
13081 {
13086 {
13088 {
13089 /* Only when in binary mode add an empty list item when the
13090 * last line ends in a '\n'. */
13094 /* Found end-of-line or end-of-file: add a text line to the
13095 * list. */
13104 else
13105 {
13108 {
13114 }
13115 }
13120 {
13123 }
13133 }
13136 }
13141 {
13142 /* "buf" is full, need to move text to an allocated buffer */
13144 {
13147 }
13148 else
13149 {
13152 {
13158 }
13159 }
13161 }
13162 else
13163 {
13166 }
13167 }
13169 /*
13170 * For a negative line count use only the lines at the end of the file,
13171 * free the rest.
13172 */
13175 {
13178 }
13182 }
13184 #if defined(FEAT_RELTIME)
13187 /*
13188 * Convert a List to proftime_T.
13189 * Return FAIL when there is something wrong.
13190 */
13191 static int
13195 {
13204 # ifdef WIN3264
13207 # else
13210 # endif
13212 }
13215 /*
13216 * "reltime()" function
13217 */
13218 static void
13222 {
13223 #ifdef FEAT_RELTIME
13224 proftime_T res;
13225 proftime_T start;
13228 {
13229 /* No arguments: get current time. */
13231 }
13233 {
13237 }
13238 else
13239 {
13240 /* Two arguments: compute the difference. */
13245 }
13248 {
13251 # ifdef WIN3264
13254 # else
13257 # endif
13260 }
13261 #endif
13262 }
13264 /*
13265 * "reltimestr()" function
13266 */
13267 static void
13271 {
13272 #ifdef FEAT_RELTIME
13273 proftime_T tm;
13274 #endif
13278 #ifdef FEAT_RELTIME
13281 #endif
13282 }
13284 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13288 static void
13290 {
13292 # ifdef FEAT_GUI
13294 # endif
13295 )
13296 {
13300 }
13301 }
13303 static int
13305 {
13308 {
13311 }
13313 }
13314 #endif
13316 #ifdef FEAT_CLIENTSERVER
13319 static void
13324 {
13329 # ifdef WIN32
13330 HWND w;
13331 # else
13332 Window w;
13333 # endif
13338 # ifdef FEAT_X11
13341 # endif
13347 # ifdef WIN32
13349 # else
13352 # endif
13353 {
13356 else
13359 }
13364 {
13365 dictitem_T v;
13376 }
13377 }
13378 #endif
13380 /*
13381 * "remote_expr()" function
13382 */
13383 /*ARGSUSED*/
13384 static void
13388 {
13391 #ifdef FEAT_CLIENTSERVER
13393 #endif
13394 }
13396 /*
13397 * "remote_foreground()" function
13398 */
13399 /*ARGSUSED*/
13400 static void
13404 {
13406 #ifdef FEAT_CLIENTSERVER
13407 # ifdef WIN32
13408 /* On Win32 it's done in this application. */
13409 {
13414 }
13415 # else
13416 /* Send a foreground() expression to the server. */
13422 # endif
13423 #endif
13424 }
13426 /*ARGSUSED*/
13427 static void
13431 {
13432 #ifdef FEAT_CLIENTSERVER
13433 dictitem_T v;
13435 # ifdef WIN32
13437 # endif
13441 {
13444 }
13447 {
13450 }
13451 # ifdef WIN32
13455 else
13456 {
13459 }
13460 # else
13467 # endif
13470 {
13479 }
13480 #else
13482 #endif
13483 }
13485 /*ARGSUSED*/
13486 static void
13490 {
13493 #ifdef FEAT_CLIENTSERVER
13497 {
13498 # ifdef WIN32
13499 /* The server's HWND is encoded in the 'id' parameter */
13506 # else
13509 # endif
13511 }
13512 #endif
13515 }
13517 /*
13518 * "remote_send()" function
13519 */
13520 /*ARGSUSED*/
13521 static void
13525 {
13528 #ifdef FEAT_CLIENTSERVER
13530 #endif
13531 }
13533 /*
13534 * "remove()" function
13535 */
13536 static void
13540 {
13552 {
13557 {
13560 {
13564 else
13565 {
13569 }
13570 }
13571 }
13572 }
13577 {
13585 else
13586 {
13588 {
13589 /* Remove one item, return its value. */
13593 }
13594 else
13595 {
13596 /* Remove range of items, return list with values. */
13602 else
13603 {
13607 {
13611 }
13614 else
13615 {
13618 {
13625 }
13626 }
13627 }
13628 }
13629 }
13630 }
13631 }
13633 /*
13634 * "rename({from}, {to})" function
13635 */
13636 static void
13640 {
13645 else
13648 }
13650 /*
13651 * "repeat()" function
13652 */
13653 /*ARGSUSED*/
13654 static void
13658 {
13668 {
13674 }
13675 else
13676 {
13688 {
13692 }
13695 }
13696 }
13698 /*
13699 * "resolve()" function
13700 */
13701 static void
13705 {
13709 #ifdef FEAT_SHORTCUT
13710 {
13716 else
13718 }
13719 #else
13720 # ifdef HAVE_READLINK
13721 {
13743 {
13744 /* Separate the first path component in "p", and keep the
13745 * remainder (beginning with the path separator). */
13748 }
13751 {
13753 {
13760 {
13766 }
13768 /* Ensure that the result will have a trailing path separator
13769 * if the argument has one. */
13773 /* Separate the first path component in the link value and
13774 * concatenate the remainders. */
13777 {
13780 else
13781 {
13784 {
13787 }
13788 }
13790 }
13794 {
13795 /* Ignore trailing path separator. */
13798 }
13800 {
13801 /* symlink is relative to directory of argument */
13804 {
13809 }
13810 }
13811 else
13812 {
13815 }
13816 }
13821 /* Append the first path component of "remain" to "p". */
13826 {
13830 }
13831 /* Shorten "remain". */
13834 else
13835 {
13838 }
13839 }
13841 /* If the result is a relative path name, make it explicitly relative to
13842 * the current directory if and only if the argument had this form. */
13844 {
13853 {
13854 /* Prepend "./". */
13857 {
13860 }
13861 }
13863 {
13864 /* Strip leading "./". */
13870 }
13871 }
13873 /* Ensure that the result will have no trailing path separator
13874 * if the argument had none. But keep "/" or "//". */
13876 {
13880 }
13883 }
13884 # else
13886 # endif
13887 #endif
13891 #ifdef HAVE_READLINK
13892 fail:
13893 #endif
13895 }
13897 /*
13898 * "reverse({list})" function
13899 */
13900 static void
13904 {
13913 {
13918 {
13922 }
13926 }
13927 }
13939 /*
13940 * Get flags for a search function.
13941 * Possibly sets "p_ws".
13942 * Returns BACKWARD, FORWARD or zero (for an error).
13943 */
13944 static int
13948 {
13955 {
13960 {
13962 {
13969 {
13977 }
13979 {
13982 }
13983 else
13985 }
13989 }
13990 }
13992 }
13994 /*
13995 * Shared by search() and searchpos() functions
13996 */
13997 static int
14002 {
14005 pos_T pos;
14006 pos_T save_cursor;
14024 /* Optional extra argument: line number to stop searching. */
14027 {
14031 }
14033 /*
14034 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14035 * Check to make sure only those flags are set.
14036 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14037 * flags cannot be set. Check for that condition also.
14038 */
14041 {
14044 }
14050 {
14053 else
14059 {
14060 /* Store the match cursor position */
14063 }
14064 /* "/$" will put the cursor after the end of the line, may need to
14065 * correct that here */
14067 }
14069 /* If 'n' flag is used: restore cursor position. */
14072 else
14074 theend:
14078 }
14080 /*
14081 * "search()" function
14082 */
14083 static void
14087 {
14091 }
14093 /*
14094 * "searchdecl()" function
14095 */
14096 static void
14100 {
14110 {
14114 }
14118 }
14120 /*
14121 * Used by searchpair() and searchpairpos()
14122 */
14123 static int
14127 {
14139 /* Get the three pattern arguments: start, middle, end. */
14146 /* Handle the optional fourth argument: flags */
14151 /* Don't accept SP_END or SP_SUBPAT.
14152 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14153 */
14156 {
14159 }
14161 /* Optional fifth argument: skip expression */
14165 else
14166 {
14169 {
14173 }
14174 }
14181 theend:
14185 }
14187 /*
14188 * "searchpair()" function
14189 */
14190 static void
14194 {
14196 }
14198 /*
14199 * "searchpairpos()" function
14200 */
14201 static void
14205 {
14206 pos_T match_pos;
14216 {
14219 }
14223 }
14225 /*
14226 * Search for a start/middle/end thing.
14227 * Used by searchpair(), see its documentation for the details.
14228 * Returns 0 or -1 for no match,
14229 */
14230 long
14240 {
14244 pos_T pos;
14245 pos_T firstpos;
14246 pos_T foundpos;
14247 pos_T save_cursor;
14248 pos_T save_pos;
14255 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14259 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14260 * start/middle/end (pat3, for the top pair). */
14268 else
14280 {
14284 /* didn't find it or found the first match again: FAIL */
14290 {
14291 /* Found the same position again. Can happen with a pattern that
14292 * has "\zs" at the end and searching backwards. Advance one
14293 * character and try again. */
14296 else
14298 }
14301 /* If the skip pattern matches, ignore this match. */
14303 {
14309 {
14310 /* Evaluating {skip} caused an error, break here. */
14314 }
14317 }
14320 {
14321 /* Found end when searching backwards or start when searching
14322 * forward: nested pair. */
14325 }
14326 else
14327 {
14328 /* Found end when searching forward or start when searching
14329 * backward: end of (nested) pair; or found middle in outer pair. */
14332 }
14335 {
14336 /* Found the match: return matchcount or line number. */
14339 else
14347 }
14348 }
14351 {
14352 /* Store the match cursor position */
14355 }
14357 /* If 'n' flag is used or search failed: restore cursor position. */
14361 theend:
14367 }
14369 /*
14370 * "searchpos()" function
14371 */
14372 static void
14376 {
14377 pos_T match_pos;
14390 {
14393 }
14399 }
14402 /*ARGSUSED*/
14403 static void
14407 {
14408 #ifdef FEAT_CLIENTSERVER
14418 # ifdef FEAT_X11
14421 # endif
14424 {
14427 }
14429 #else
14431 #endif
14432 }
14434 /*ARGSUSED*/
14435 static void
14439 {
14442 #ifdef FEAT_CLIENTSERVER
14443 # ifdef WIN32
14445 # else
14449 # endif
14450 #endif
14453 }
14455 /*
14456 * "setbufvar()" function
14457 */
14458 /*ARGSUSED*/
14459 static void
14463 {
14465 aco_save_T aco;
14480 {
14481 /* set curbuf to be our buf, temporarily */
14485 {
14495 }
14496 else
14497 {
14500 {
14505 }
14506 }
14508 /* reset notion of buffer */
14510 }
14511 }
14513 /*
14514 * "setcmdpos()" function
14515 */
14516 static void
14520 {
14525 }
14527 /*
14528 * "setline()" function
14529 */
14530 static void
14534 {
14535 linenr_T lnum;
14544 {
14547 }
14548 else
14553 {
14555 {
14556 /* list argument, get next string */
14561 }
14567 {
14568 /* existing line, replace it */
14570 {
14575 }
14576 }
14578 {
14579 /* lnum is one past the last line, append the line */
14583 }
14588 }
14592 }
14594 /*
14595 * Used by "setqflist()" and "setloclist()" functions
14596 */
14597 /*ARGSUSED*/
14598 static void
14604 {
14605 #ifdef FEAT_QUICKFIX
14608 #endif
14612 #ifdef FEAT_QUICKFIX
14615 else
14616 {
14620 {
14626 }
14630 }
14631 #endif
14632 }
14634 /*
14635 * "setloclist()" function
14636 */
14637 /*ARGSUSED*/
14638 static void
14642 {
14650 }
14652 /*
14653 * "setmatches()" function
14654 */
14655 static void
14659 {
14660 #ifdef FEAT_SEARCH_EXTRA
14667 {
14670 }
14672 {
14674 /* To some extent make sure that we are dealing with a list from
14675 * "getmatches()". */
14678 {
14681 {
14684 }
14689 {
14692 }
14694 }
14699 {
14706 }
14708 }
14709 #endif
14710 }
14712 /*
14713 * "setpos()" function
14714 */
14715 /*ARGSUSED*/
14716 static void
14720 {
14721 pos_T pos;
14727 {
14729 {
14732 {
14734 {
14737 }
14738 else
14740 }
14743 else
14745 }
14746 }
14747 }
14749 /*
14750 * "setqflist()" function
14751 */
14752 /*ARGSUSED*/
14753 static void
14757 {
14759 }
14761 /*
14762 * "setreg()" function
14763 */
14764 static void
14768 {
14774 char_u yank_type;
14793 {
14799 {
14809 #ifdef FEAT_VISUAL
14813 {
14817 }
14819 #endif
14820 }
14821 }
14828 }
14830 /*
14831 * "settabwinvar()" function
14832 */
14833 static void
14837 {
14839 }
14841 /*
14842 * "setwinvar()" function
14843 */
14844 static void
14848 {
14850 }
14852 /*
14853 * "setwinvar()" and "settabwinvar()" functions
14854 */
14855 static void
14860 {
14862 #ifdef FEAT_WINDOWS
14865 #endif
14876 #ifdef FEAT_WINDOWS
14879 else
14881 #endif
14887 {
14888 #ifdef FEAT_WINDOWS
14889 /* set curwin to be our win, temporarily */
14897 #endif
14900 {
14910 }
14911 else
14912 {
14915 {
14920 }
14921 }
14923 #ifdef FEAT_WINDOWS
14924 /* Restore current tabpage and window, if still valid (autocomands can
14925 * make them invalid). */
14929 {
14932 }
14933 #endif
14934 }
14935 }
14937 /*
14938 * "shellescape({string})" function
14939 */
14940 static void
14944 {
14947 }
14949 /*
14950 * "simplify()" function
14951 */
14952 static void
14956 {
14963 }
14965 static int
14966 #ifdef __BORLANDC__
14967 _RTLENTRYF
14968 #endif
14970 static int
14971 #ifdef __BORLANDC__
14972 _RTLENTRYF
14973 #endif
14979 #define ITEM_COMPARE_FAIL 999
14981 /*
14982 * Compare functions for f_sort() below.
14983 */
14984 static int
14985 #ifdef __BORLANDC__
14986 _RTLENTRYF
14987 #endif
14991 {
15006 else
15011 }
15013 static int
15014 #ifdef __BORLANDC__
15015 _RTLENTRYF
15016 #endif
15020 {
15022 typval_T rettv;
15026 /* shortcut after failure in previous call; compare all items equal */
15030 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15031 * in the copy without changing the original list items. */
15043 else
15044 /* return value has wrong type */
15050 }
15052 /*
15053 * "sort({list})" function
15054 */
15055 static void
15059 {
15069 else
15070 {
15085 {
15088 else
15089 {
15097 else
15099 }
15100 }
15102 /* Make an array with each entry pointing to an item in the List. */
15111 /* test the compare function */
15116 else
15117 {
15118 /* Sort the array with item pointers. */
15123 {
15124 /* Clear the List and append the items in the sorted order. */
15129 }
15130 }
15133 }
15134 }
15136 /*
15137 * "soundfold({word})" function
15138 */
15139 static void
15143 {
15148 #ifdef FEAT_SPELL
15150 #else
15152 #endif
15153 }
15155 /*
15156 * "spellbadword()" function
15157 */
15158 /* ARGSUSED */
15159 static void
15163 {
15171 #ifdef FEAT_SPELL
15173 {
15174 /* Find the start and length of the badly spelled word. */
15178 }
15180 {
15185 {
15186 /* Check the argument for spelling. */
15188 {
15191 {
15194 }
15196 }
15197 }
15198 }
15199 #endif
15208 }
15210 /*
15211 * "spellsuggest()" function
15212 */
15213 /*ARGSUSED*/
15214 static void
15218 {
15219 #ifdef FEAT_SPELL
15223 garray_T ga;
15227 #endif
15232 #ifdef FEAT_SPELL
15234 {
15237 {
15242 {
15246 }
15247 }
15248 else
15254 {
15260 else
15261 {
15266 }
15267 }
15269 }
15270 #endif
15271 }
15273 static void
15277 {
15281 regmatch_T regmatch;
15289 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15295 {
15301 }
15312 {
15315 {
15318 else
15322 else
15326 {
15330 }
15333 /* Advance to just after the match. */
15336 else
15337 {
15338 /* Don't get stuck at the same match. */
15339 #ifdef FEAT_MBYTE
15341 #else
15343 #endif
15344 }
15346 }
15349 }
15352 }
15354 /*
15355 * "str2nr()" function
15356 */
15357 static void
15361 {
15367 {
15370 {
15373 }
15374 }
15379 }
15381 #ifdef HAVE_STRFTIME
15382 /*
15383 * "strftime({format}[, {time}])" function
15384 */
15385 static void
15389 {
15400 else
15403 /* MSVC returns NULL for an invalid value of seconds. */
15406 else
15407 {
15408 # ifdef FEAT_MBYTE
15409 vimconv_T conv;
15417 # endif
15421 else
15424 # ifdef FEAT_MBYTE
15430 else
15431 # endif
15434 # ifdef FEAT_MBYTE
15435 /* Release conversion descriptors */
15438 # endif
15439 }
15440 }
15441 #endif
15443 /*
15444 * "stridx()" function
15445 */
15446 static void
15450 {
15465 {
15473 }
15478 }
15480 /*
15481 * "string()" function
15482 */
15483 static void
15487 {
15493 /* Make a copy if we have a value but it's not in allocate memory. */
15496 }
15498 /*
15499 * "strlen()" function
15500 */
15501 static void
15505 {
15508 }
15510 /*
15511 * "strpart()" function
15512 */
15513 static void
15517 {
15532 else
15535 /*
15536 * Only return the overlap between the specified part and the actual
15537 * string.
15538 */
15540 {
15543 }
15553 }
15555 /*
15556 * "strridx()" function
15557 */
15558 static void
15562 {
15579 {
15580 /* Third argument: upper limit for index */
15584 }
15585 else
15589 {
15590 /* Empty string matches past the end. */
15592 }
15593 else
15594 {
15596 {
15601 }
15602 }
15606 else
15608 }
15610 /*
15611 * "strtrans()" function
15612 */
15613 static void
15617 {
15620 }
15622 /*
15623 * "submatch()" function
15624 */
15625 static void
15629 {
15633 }
15635 /*
15636 * "substitute()" function
15637 */
15638 static void
15642 {
15655 else
15657 }
15659 /*
15660 * "synID(lnum, col, trans)" function
15661 */
15662 /*ARGSUSED*/
15663 static void
15667 {
15669 #ifdef FEAT_SYN_HL
15682 #endif
15685 }
15687 /*
15688 * "synIDattr(id, what [, mode])" function
15689 */
15690 /*ARGSUSED*/
15691 static void
15695 {
15697 #ifdef FEAT_SYN_HL
15707 {
15711 #ifdef FEAT_GUI
15713 #endif
15714 )
15716 }
15717 else
15718 {
15719 #ifdef FEAT_GUI
15722 else
15723 #endif
15726 else
15728 }
15732 {
15765 /* underline */
15767 else
15768 /* undercurl */
15771 }
15775 #endif
15778 }
15780 /*
15781 * "synIDtrans(id)" function
15782 */
15783 /*ARGSUSED*/
15784 static void
15788 {
15791 #ifdef FEAT_SYN_HL
15796 else
15797 #endif
15801 }
15803 /*
15804 * "system()" function
15805 */
15806 static void
15810 {
15822 {
15823 /*
15824 * Write the string to a temp file, to be used for input of the shell
15825 * command.
15826 */
15828 {
15831 }
15835 {
15838 }
15841 {
15844 }
15850 {
15853 }
15854 }
15859 #ifdef USE_CR
15860 /* translate <CR> into <NL> */
15862 {
15866 {
15869 }
15870 }
15871 #else
15872 # ifdef USE_CRNL
15873 /* translate <CR><NL> into <NL> */
15875 {
15880 {
15884 }
15886 }
15887 # endif
15888 #endif
15890 done:
15892 {
15895 }
15898 }
15900 /*
15901 * "tabpagebuflist()" function
15902 */
15903 /* ARGSUSED */
15904 static void
15908 {
15909 #ifndef FEAT_WINDOWS
15911 #else
15917 else
15918 {
15922 }
15925 else
15926 {
15929 else
15930 {
15935 }
15936 }
15937 #endif
15938 }
15941 /*
15942 * "tabpagenr()" function
15943 */
15944 /* ARGSUSED */
15945 static void
15949 {
15951 #ifdef FEAT_WINDOWS
15955 {
15959 {
15962 else
15964 }
15965 }
15966 else
15968 #endif
15970 }
15973 #ifdef FEAT_WINDOWS
15976 /*
15977 * Common code for tabpagewinnr() and winnr().
15978 */
15979 static int
15983 {
15991 {
15998 {
16002 }
16003 else
16004 {
16007 }
16008 }
16013 {
16015 {
16016 /* didn't find it in this tabpage */
16019 }
16021 }
16023 }
16024 #endif
16026 /*
16027 * "tabpagewinnr()" function
16028 */
16029 /* ARGSUSED */
16030 static void
16034 {
16036 #ifdef FEAT_WINDOWS
16042 else
16044 #endif
16046 }
16049 /*
16050 * "tagfiles()" function
16051 */
16052 /*ARGSUSED*/
16053 static void
16057 {
16059 tagname_T tn;
16063 {
16066 }
16073 }
16075 /*
16076 * "taglist()" function
16077 */
16078 static void
16082 {
16093 }
16095 /*
16096 * "tempname()" function
16097 */
16098 /*ARGSUSED*/
16099 static void
16103 {
16109 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16110 * names. Skip 'I' and 'O', they are used for shell redirection. */
16111 do
16112 {
16117 else
16118 {
16119 #ifdef EBCDIC
16124 else
16125 #endif
16127 }
16129 }
16131 /*
16132 * "test(list)" function: Just checking the walls...
16133 */
16134 /*ARGSUSED*/
16135 static void
16139 {
16140 /* Used for unit testing. Change the code below to your liking. */
16141 #if 0
16160 #endif
16161 }
16163 /*
16164 * "tolower(string)" function
16165 */
16166 static void
16170 {
16179 {
16180 #ifdef FEAT_MBYTE
16184 {
16190 /* TODO: reallocate string when byte count changes. */
16194 }
16197 else
16198 #endif
16199 {
16202 }
16203 }
16204 }
16206 /*
16207 * "toupper(string)" function
16208 */
16209 static void
16213 {
16216 }
16218 /*
16219 * "tr(string, fromstr, tostr)" function
16220 */
16221 static void
16225 {
16230 #ifdef FEAT_MBYTE
16238 #endif
16241 garray_T ga;
16247 /* Default return value: empty string. */
16254 #ifdef FEAT_MBYTE
16256 #endif
16257 /* not multi-byte: fromstr and tostr must be the same length */
16259 {
16260 #ifdef FEAT_MBYTE
16261 error:
16262 #endif
16266 }
16268 /* fromstr and tostr have to contain the same number of chars */
16270 {
16271 #ifdef FEAT_MBYTE
16273 {
16279 {
16282 {
16284 {
16287 {
16291 }
16292 }
16296 }
16298 }
16301 {
16302 /* Check that fromstr and tostr have the same number of
16303 * (multi-byte) characters. Done only once when a character
16304 * of instr doesn't appear in fromstr. */
16307 {
16310 }
16313 }
16320 }
16321 else
16322 #endif
16323 {
16324 /* When not using multi-byte chars we can do it faster. */
16328 else
16331 }
16332 }
16334 /* add a terminating NUL */
16339 }
16341 /*
16342 * "type(expr)" function
16343 */
16344 static void
16348 {
16352 {
16359 }
16361 }
16363 /*
16364 * "values(dict)" function
16365 */
16366 static void
16370 {
16372 }
16374 /*
16375 * "virtcol(string)" function
16376 */
16377 static void
16381 {
16389 {
16392 }
16395 }
16397 /*
16398 * "visualmode()" function
16399 */
16400 /*ARGSUSED*/
16401 static void
16405 {
16406 #ifdef FEAT_VISUAL
16414 /* A non-zero number or non-empty string argument: reset mode. */
16420 #else
16422 #endif
16423 }
16425 /*
16426 * "winbufnr(nr)" function
16427 */
16428 static void
16432 {
16438 else
16440 }
16442 /*
16443 * "wincol()" function
16444 */
16445 /*ARGSUSED*/
16446 static void
16450 {
16453 }
16455 /*
16456 * "winheight(nr)" function
16457 */
16458 static void
16462 {
16468 else
16470 }
16472 /*
16473 * "winline()" function
16474 */
16475 /*ARGSUSED*/
16476 static void
16480 {
16483 }
16485 /*
16486 * "winnr()" function
16487 */
16488 /* ARGSUSED */
16489 static void
16493 {
16496 #ifdef FEAT_WINDOWS
16498 #endif
16500 }
16502 /*
16503 * "winrestcmd()" function
16504 */
16505 /* ARGSUSED */
16506 static void
16510 {
16511 #ifdef FEAT_WINDOWS
16514 garray_T ga;
16519 {
16522 # ifdef FEAT_VERTSPLIT
16525 # endif
16527 }
16531 #else
16533 #endif
16535 }
16537 /*
16538 * "winrestview()" function
16539 */
16540 /* ARGSUSED */
16541 static void
16545 {
16551 else
16552 {
16555 #ifdef FEAT_VIRTUALEDIT
16557 #endif
16562 #ifdef FEAT_DIFF
16564 #endif
16577 #ifdef FEAT_DIFF
16579 #endif
16580 }
16581 }
16583 /*
16584 * "winsaveview()" function
16585 */
16586 /* ARGSUSED */
16587 static void
16591 {
16603 #ifdef FEAT_VIRTUALEDIT
16605 #endif
16610 #ifdef FEAT_DIFF
16612 #endif
16615 }
16617 /*
16618 * "winwidth(nr)" function
16619 */
16620 static void
16624 {
16630 else
16631 #ifdef FEAT_VERTSPLIT
16633 #else
16635 #endif
16636 }
16638 /*
16639 * "writefile()" function
16640 */
16641 static void
16645 {
16658 {
16661 }
16669 /* Always open the file in binary mode, library functions have a mind of
16670 * their own about CR-LF conversion. */
16673 {
16676 }
16677 else
16678 {
16681 {
16683 {
16686 else
16689 {
16692 }
16693 }
16696 {
16699 }
16701 {
16704 }
16705 }
16707 }
16710 }
16712 /*
16713 * Translate a String variable into a position.
16714 * Returns NULL when there is an error.
16715 */
16721 {
16726 /* Argument can be [lnum, col, coladd]. */
16728 {
16738 /* Get the line number */
16743 /* Get the column number */
16749 /* We accept "$" for the column number: last column. */
16756 /* Accept a position up to the NUL after the line. */
16761 #ifdef FEAT_VIRTUALEDIT
16762 /* Get the virtual offset. Defaults to zero. */
16766 #endif
16769 }
16777 {
16782 }
16784 #ifdef FEAT_VIRTUALEDIT
16786 #endif
16789 {
16792 {
16796 }
16798 {
16802 }
16803 }
16805 {
16807 {
16810 }
16811 else
16812 {
16815 }
16817 }
16819 }
16821 /*
16822 * Convert list in "arg" into a position and optional file number.
16823 * When "fnump" is NULL there is no file number, only 3 items.
16824 * Note that the column is passed on as-is, the caller may want to decrement
16825 * it to use 1 for the first column.
16826 * Return FAIL when conversion is not possible, doesn't check the position for
16827 * validity.
16828 */
16829 static int
16834 {
16839 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16840 * when "fnump" isn't NULL and "coladd" is optional. */
16848 {
16855 }
16867 #ifdef FEAT_VIRTUALEDIT
16871 else
16873 #endif
16876 }
16878 /*
16879 * Get the length of an environment variable name.
16880 * Advance "arg" to the first character after the name.
16881 * Return 0 for error.
16882 */
16883 static int
16886 {
16891 ;
16898 }
16900 /*
16901 * Get the length of the name of a function or internal variable.
16902 * "arg" is advanced to the first non-white character after the name.
16903 * Return 0 if something is wrong.
16904 */
16905 static int
16908 {
16912 /* Find the end of the name. */
16914 ;
16922 }
16924 /*
16925 * Get the length of the name of a variable or function.
16926 * Only the name is recognized, does not handle ".key" or "[idx]".
16927 * "arg" is advanced to the first non-white character after the name.
16928 * Return -1 if curly braces expansion failed.
16929 * Return 0 if something else is wrong.
16930 * If the name contains 'magic' {}'s, expand them and return the
16931 * expanded name in an allocated string via 'alias' - caller must free.
16932 */
16933 static int
16939 {
16949 {
16950 /* hard coded <SNR>, already translated */
16953 }
16956 {
16957 /* literal "<SID>", "s:" or "<SNR>" */
16959 }
16961 /*
16962 * Find the end of the name; check for {} construction.
16963 */
16967 {
16971 {
16975 }
16977 /*
16978 * Include any <SID> etc in the expanded string:
16979 * Thus the -len here.
16980 */
16987 }
16994 }
16996 /*
16997 * Find the end of a variable or function name, taking care of magic braces.
16998 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
16999 * start and end of the first magic braces item.
17000 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17001 * Return a pointer to just after the name. Equal to "arg" if there is no
17002 * valid name.
17003 */
17010 {
17016 {
17019 }
17021 /* Quick check for valid starting character. */
17031 {
17033 {
17034 /* skip over 'string' to avoid counting [ and ] inside it. */
17036 ;
17039 }
17041 {
17042 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17048 }
17051 {
17056 }
17059 {
17061 {
17062 mb_nest++;
17065 }
17067 {
17068 mb_nest--;
17071 }
17072 }
17073 }
17076 }
17078 /*
17079 * Expands out the 'magic' {}'s in a variable/function name.
17080 * Note that this can call itself recursively, to deal with
17081 * constructs like foo{bar}{baz}{bam}
17082 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17083 * "in_start" ^
17084 * "expr_start" ^
17085 * "expr_end" ^
17086 * "in_end" ^
17087 *
17088 * Returns a new allocated string, which the caller must free.
17089 * Returns NULL for failure.
17090 */
17097 {
17098 char_u c1;
17112 {
17116 {
17120 }
17121 }
17129 {
17132 {
17133 /* Further expansion! */
17138 }
17139 }
17142 }
17144 /*
17145 * Return TRUE if character "c" can be used in a variable or function name.
17146 * Does not include '{' or '}' for magic braces.
17147 */
17148 static int
17151 {
17153 }
17155 /*
17156 * Return TRUE if character "c" can be used as the first character in a
17157 * variable or function name (excluding '{' and '}').
17158 */
17159 static int
17162 {
17164 }
17166 /*
17167 * Set number v: variable to "val".
17168 */
17169 void
17173 {
17175 }
17177 /*
17178 * Get number v: variable value.
17179 */
17180 long
17183 {
17185 }
17187 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17188 /*
17189 * Get string v: variable value. Uses a static buffer, can only be used once.
17190 */
17191 char_u *
17194 {
17196 }
17197 #endif
17199 /*
17200 * Set v:count, v:count1 and v:prevcount.
17201 */
17202 void
17206 {
17210 }
17212 /*
17213 * Set string v: variable to a copy of "val".
17214 */
17215 void
17220 {
17221 /* Need to do this (at least) once, since we can't initialize a union.
17222 * Will always be invoked when "v:progname" is set. */
17230 else
17232 }
17234 /*
17235 * Set v:register if needed.
17236 */
17237 void
17240 {
17241 char_u regname;
17245 else
17247 /* Avoid free/alloc when the value is already right. */
17250 }
17252 /*
17253 * Get or set v:exception. If "oldval" == NULL, return the current value.
17254 * Otherwise, restore the value to "oldval" and return NULL.
17255 * Must always be called in pairs to save and restore v:exception! Does not
17256 * take care of memory allocations.
17257 */
17258 char_u *
17261 {
17267 }
17269 /*
17270 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17271 * Otherwise, restore the value to "oldval" and return NULL.
17272 * Must always be called in pairs to save and restore v:throwpoint! Does not
17273 * take care of memory allocations.
17274 */
17275 char_u *
17278 {
17284 }
17286 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17287 /*
17288 * Set v:cmdarg.
17289 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17290 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17291 * Must always be called in pairs!
17292 */
17293 char_u *
17297 {
17304 {
17308 }
17314 else
17322 # ifdef FEAT_MBYTE
17327 # endif
17337 else
17346 # ifdef FEAT_MBYTE
17353 # endif
17356 }
17357 #endif
17359 /*
17360 * Get the value of internal variable "name".
17361 * Return OK or FAIL.
17362 */
17363 static int
17369 {
17372 typval_T atv;
17376 /* truncate the name, so that we can use strcmp() */
17380 /*
17381 * Check for "b:changedtick".
17382 */
17384 {
17388 }
17390 /*
17391 * Check for user-defined variables.
17392 */
17393 else
17394 {
17398 }
17401 {
17405 }
17412 }
17414 /*
17415 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17416 * Also handle function call with Funcref variable: func(expr)
17417 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17418 */
17419 static int
17425 {
17430 typval_T functv;
17437 {
17439 {
17440 /* need to copy the funcref so that we can clear rettv */
17444 /* Invoke the function. Recursive! */
17450 /* Clear the funcref afterwards, so that deleting it while
17451 * evaluating the arguments is possible (see test55). */
17454 /* Stop the expression evaluation when immediately aborting on
17455 * error, or when an interrupt occurred or an exception was thrown
17456 * but not caught. */
17458 {
17462 }
17465 }
17467 {
17470 {
17474 }
17475 else
17478 {
17481 }
17482 }
17483 }
17486 }
17488 /*
17489 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17490 * value).
17491 */
17494 {
17496 }
17498 /*
17499 * Allocate memory for a variable type-value, and assign a string to it.
17500 * The string "s" must have been allocated, it is consumed.
17501 * Return NULL for out of memory, the variable otherwise.
17502 */
17506 {
17511 {
17514 }
17515 else
17518 }
17520 /*
17521 * Free the memory for a variable type-value.
17522 */
17523 void
17526 {
17528 {
17530 {
17533 /*FALLTHROUGH*/
17549 }
17551 }
17552 }
17554 /*
17555 * Free the memory for a variable value and set the value to NULL or 0.
17556 */
17557 void
17560 {
17562 {
17564 {
17567 /*FALLTHROUGH*/
17587 }
17589 }
17590 }
17592 /*
17593 * Set the value of a variable to NULL without freeing items.
17594 */
17595 static void
17598 {
17601 }
17603 /*
17604 * Get the number value of a variable.
17605 * If it is a String variable, uses vim_str2nr().
17606 * For incompatible types, return 0.
17607 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17608 * caller of incompatible types: it sets *denote to TRUE if "denote"
17609 * is not NULL or returns -1 otherwise.
17610 */
17611 static long
17614 {
17618 }
17620 long
17624 {
17628 {
17648 }
17651 else
17654 }
17656 /*
17657 * Get the lnum from the first argument.
17658 * Also accepts ".", "$", etc., but that only works for the current buffer.
17659 * Returns -1 on error.
17660 */
17661 static linenr_T
17664 {
17665 typval_T rettv;
17666 linenr_T lnum;
17670 {
17675 }
17677 }
17679 /*
17680 * Get the lnum from the first argument.
17681 * Also accepts "$", then "buf" is used.
17682 * Returns 0 on error.
17683 */
17684 static linenr_T
17688 {
17695 }
17697 /*
17698 * Get the string value of a variable.
17699 * If it is a Number variable, the number is converted into a string.
17700 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17701 * get_tv_string_buf() uses a given buffer.
17702 * If the String variable has never been set, return an empty string.
17703 * Never returns NULL;
17704 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17705 * NULL on error.
17706 */
17710 {
17714 }
17720 {
17724 }
17726 char_u *
17729 {
17733 }
17739 {
17741 {
17761 }
17763 }
17765 /*
17766 * Find variable "name" in the list of variables.
17767 * Return a pointer to it if found, NULL if not found.
17768 * Careful: "a:0" variables don't have a name.
17769 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17770 * hashtab_T used.
17771 */
17776 {
17786 }
17788 /*
17789 * Find variable "varname" in hashtab "ht".
17790 * Returns NULL if not found.
17791 */
17797 {
17801 {
17802 /* Must be something like "s:", otherwise "ht" would be NULL. */
17804 {
17810 #ifdef FEAT_WINDOWS
17812 #endif
17817 }
17819 }
17823 {
17824 /* For global variables we may try auto-loading the script. If it
17825 * worked find the variable again. Don't auto-load a script if it was
17826 * loaded already, otherwise it would be loaded every time when
17827 * checking if a function name is a Funcref variable. */
17833 }
17835 }
17837 /*
17838 * Find the hashtab used for a variable name.
17839 * Set "varname" to the start of name without ':'.
17840 */
17845 {
17849 {
17850 /* The name must not start with a colon or #. */
17855 /* "version" is "v:version" in all scopes */
17863 }
17867 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17868 */
17876 #ifdef FEAT_WINDOWS
17879 #endif
17890 }
17892 /*
17893 * Get the string value of a (global/local) variable.
17894 * Returns NULL when it doesn't exist.
17895 */
17896 char_u *
17899 {
17906 }
17908 /*
17909 * Allocate a new hashtab for a sourced script. It will be used while
17910 * sourcing this script and when executing functions defined in the script.
17911 */
17912 void
17914 scid_T id;
17915 {
17921 {
17922 /* Re-allocating ga_data means that an ht_array pointing to
17923 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
17924 * at its init value. Also reset "v_dict", it's always the same. */
17926 {
17932 }
17935 {
17939 }
17940 }
17941 }
17943 /*
17944 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
17945 * point to it.
17946 */
17947 void
17951 {
17959 }
17961 /*
17962 * Clean up a list of internal variables.
17963 * Frees all allocated variables and the value they contain.
17964 * Clears hashtab "ht", does not free it.
17965 */
17966 void
17969 {
17971 }
17973 /*
17974 * Like vars_clear(), but only free the value if "free_val" is TRUE.
17975 */
17976 static void
17980 {
17988 {
17990 {
17993 /* Free the variable. Don't remove it from the hashtab,
17994 * ht_array might change then. hash_clear() takes care of it
17995 * later. */
18001 }
18002 }
18005 }
18007 /*
18008 * Delete a variable from hashtab "ht" at item "hi".
18009 * Clear the variable value and free the dictitem.
18010 */
18011 static void
18015 {
18021 }
18023 /*
18024 * List the value of one internal variable.
18025 */
18026 static void
18031 {
18040 }
18042 static void
18049 {
18050 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18062 {
18066 }
18068 {
18072 }
18073 else
18081 {
18084 }
18085 }
18087 /*
18088 * Set variable "name" to value in "tv".
18089 * If the variable already exists, the value is updated.
18090 * Otherwise the variable is created.
18091 */
18092 static void
18097 {
18104 {
18108 {
18111 }
18113 {
18115 name);
18117 }
18118 }
18122 {
18125 }
18129 {
18130 /* existing variable, need to clear the value */
18139 {
18142 }
18144 /*
18145 * Handle setting internal v: variables separately: we don't change
18146 * the type.
18147 */
18149 {
18151 {
18155 else
18156 {
18157 /* Take over the string to avoid an extra alloc/free. */
18160 }
18161 }
18164 else
18167 }
18170 }
18172 {
18173 /* Can't add "v:" variable. */
18175 {
18178 }
18180 /* Make sure the variable name is valid. */
18184 {
18187 }
18195 {
18198 }
18200 }
18204 else
18205 {
18209 }
18210 }
18212 /*
18213 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18214 * Also give an error message.
18215 */
18216 static int
18220 {
18222 {
18225 }
18227 {
18230 }
18232 }
18234 /*
18235 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18236 * Also give an error message.
18237 */
18238 static int
18242 {
18244 {
18247 }
18249 }
18251 /*
18252 * Return TRUE if typeval "tv" is set to be locked (immutable).
18253 * Also give an error message, using "name".
18254 */
18255 static int
18259 {
18261 {
18265 }
18267 {
18271 }
18273 }
18275 /*
18276 * Copy the values from typval_T "from" to typval_T "to".
18277 * When needed allocates string or increases reference count.
18278 * Does not make a copy of a list or dict but copies the reference!
18279 */
18280 static void
18284 {
18288 {
18296 else
18297 {
18301 }
18306 else
18307 {
18310 }
18315 else
18316 {
18319 }
18324 }
18325 }
18327 /*
18328 * Make a copy of an item.
18329 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18330 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18331 * reference to an already copied list/dict can be used.
18332 * Returns FAIL or OK.
18333 */
18334 static int
18340 {
18345 {
18348 }
18352 {
18364 {
18365 /* use the copy made earlier */
18368 }
18369 else
18380 {
18381 /* use the copy made earlier */
18384 }
18385 else
18393 }
18396 }
18398 /*
18399 * ":echo expr1 ..." print each argument separated with a space, add a
18400 * newline at the end.
18401 * ":echon expr1 ..." print each argument plain.
18402 */
18403 void
18406 {
18408 typval_T rettv;
18418 {
18421 {
18422 /*
18423 * Report the invalid expression unless the expression evaluation
18424 * has been cancelled due to an aborting error, an interrupt, or an
18425 * exception.
18426 */
18430 }
18432 {
18434 {
18436 /* Call msg_start() after eval1(), evaluating the expression
18437 * may cause a message to appear. */
18440 }
18446 {
18448 {
18450 {
18451 /* remove any text still there from the command */
18454 }
18456 }
18457 else
18458 {
18459 #ifdef FEAT_MBYTE
18461 {
18466 }
18467 else
18468 #endif
18470 }
18471 }
18473 }
18476 }
18481 else
18482 {
18483 /* remove text that may still be there from the command */
18488 }
18489 }
18491 /*
18492 * ":echohl {name}".
18493 */
18494 void
18497 {
18503 else
18505 }
18507 /*
18508 * ":execute expr1 ..." execute the result of an expression.
18509 * ":echomsg expr1 ..." Print a message
18510 * ":echoerr expr1 ..." Print an error
18511 * Each gets spaces around each argument and a newline at the end for
18512 * echo commands
18513 */
18514 void
18517 {
18519 typval_T rettv;
18522 garray_T ga;
18531 {
18534 {
18535 /*
18536 * Report the invalid expression unless the expression evaluation
18537 * has been cancelled due to an aborting error, an interrupt, or an
18538 * exception.
18539 */
18544 }
18547 {
18551 {
18555 }
18560 }
18564 }
18567 {
18569 {
18572 }
18574 {
18575 /* We don't want to abort following commands, restore did_emsg. */
18580 }
18584 }
18592 }
18594 /*
18595 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18596 * "arg" points to the "&" or '+' when called, to "option" when returning.
18597 * Returns NULL when no option name found. Otherwise pointer to the char
18598 * after the option name.
18599 */
18604 {
18609 {
18612 }
18614 {
18617 }
18618 else
18627 else
18631 }
18633 /*
18634 * ":function"
18635 */
18636 void
18639 {
18648 garray_T newargs;
18649 garray_T newlines;
18658 funcdict_T fudi;
18666 /*
18667 * ":function" without argument: list functions.
18668 */
18670 {
18672 {
18675 {
18677 {
18682 }
18683 }
18684 }
18687 }
18689 /*
18690 * ":function /pat": list functions matching pattern.
18691 */
18693 {
18696 {
18697 regmatch_T regmatch;
18704 {
18709 {
18711 {
18717 }
18718 }
18719 }
18720 }
18725 }
18727 /*
18728 * Get the function name. There are these situations:
18729 * func normal function name
18730 * "name" == func, "fudi.fd_dict" == NULL
18731 * dict.func new dictionary entry
18732 * "name" == NULL, "fudi.fd_dict" set,
18733 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18734 * dict.func existing dict entry with a Funcref
18735 * "name" == func, "fudi.fd_dict" set,
18736 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18737 * dict.func existing dict entry that's not a Funcref
18738 * "name" == NULL, "fudi.fd_dict" set,
18739 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18740 */
18745 {
18746 /*
18747 * Return on an invalid expression in braces, unless the expression
18748 * evaluation has been cancelled due to an aborting error, an
18749 * interrupt, or an exception.
18750 */
18752 {
18757 }
18758 else
18760 }
18762 /* An error in a function call during evaluation of an expression in magic
18763 * braces should not cause the function not to be defined. */
18767 /*
18768 * ":function func" with only function name: list function.
18769 */
18771 {
18773 {
18776 }
18781 {
18784 {
18787 {
18799 }
18801 {
18804 }
18805 }
18806 else
18808 }
18810 }
18812 /*
18813 * ":function name(arg1, arg2)" Define function.
18814 */
18817 {
18819 {
18822 }
18823 /* attempt to continue by skipping some text */
18826 }
18833 {
18834 /* Check the name of the function. Unless it's a dictionary function
18835 * (that we are overwriting). */
18838 else
18842 {
18845 else
18852 }
18853 }
18855 /*
18856 * Isolate the arguments: "arg1, arg2, ...)"
18857 */
18859 {
18861 {
18865 }
18866 else
18867 {
18874 {
18878 }
18891 else
18893 }
18896 {
18900 }
18901 }
18904 /* find extra arguments "range", "dict" and "abort" */
18906 {
18909 {
18912 }
18914 {
18917 }
18919 {
18922 }
18923 else
18925 }
18927 /* When there is a line break use what follows for the function body.
18928 * Makes 'exe "func Test()\n...\nendfunc"' work. */
18934 /*
18935 * Read the body of the function, until ":endfunction" is found.
18936 */
18938 {
18939 /* Check if the function already exists, don't let the user type the
18940 * whole function before telling him it doesn't work! For a script we
18941 * need to skip the body to be able to find what follows. */
18943 {
18948 }
18955 }
18960 {
18966 {
18967 /* Use eap->arg, split up in parts by line breaks. */
18972 else
18973 {
18976 }
18977 }
18980 else
18985 {
18988 }
18990 /* Detect line continuation: sourcing_lnum increased more than one. */
18993 else
18997 {
18998 /* between ":append" and "." and between ":python <<EOF" and "EOF"
18999 * don't check for ":endfunc". */
19001 {
19004 }
19005 }
19006 else
19007 {
19008 /* skip ':' and blanks*/
19010 ;
19012 /* Check for "endfunction". */
19014 {
19018 }
19020 /* Increase indent inside "if", "while", "for" and "try", decrease
19021 * at "end". */
19030 /* Check for defining a function inside this function. */
19032 {
19037 {
19040 {
19043 }
19044 }
19045 }
19047 /* Check for ":append" or ":insert". */
19055 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19068 ))
19069 {
19070 /* ":python <<" continues until a dot, like ":append" */
19074 else
19076 }
19077 }
19079 /* Add the line to the function. */
19081 {
19085 }
19087 /* Copy the line to newly allocated memory. get_one_sourceline()
19088 * allocates 250 bytes per line, this saves 80% on average. The cost
19089 * is an extra alloc/free. */
19092 {
19096 }
19100 /* Add NULL lines for continuation lines, so that the line count is
19101 * equal to the index in the growarray. */
19105 /* Check for end of eap->arg. */
19108 }
19110 /* Don't define the function when skipping commands or when an error was
19111 * detected. */
19115 /*
19116 * If there are no errors, add the function
19117 */
19119 {
19122 {
19124 name);
19126 }
19130 {
19132 {
19135 }
19137 {
19139 name);
19141 }
19142 /* redefine existing function */
19147 }
19148 }
19149 else
19150 {
19155 {
19158 }
19160 {
19161 /* Can't add a function to a locked dictionary */
19164 }
19165 /* Can't change an existing function if it is locked */
19169 /* Give the function a sequential number. Can only be used with a
19170 * Funcref! */
19176 }
19179 {
19181 {
19185 /* Check that the autoload name matches the script name. */
19188 {
19191 {
19199 }
19200 }
19202 {
19205 }
19206 }
19213 {
19215 {
19216 /* add new dict entry */
19219 {
19222 }
19224 {
19228 }
19229 }
19230 else
19231 /* overwrite existing dict entry */
19238 /* behave like "dict" was used */
19240 }
19242 /* insert the new function in the function list */
19245 }
19248 #ifdef FEAT_PROFILE
19255 #endif
19262 erret:
19265 ret_free:
19270 }
19272 /*
19273 * Get a function name, translating "<SID>" and "<SNR>".
19274 * Also handles a Funcref in a List or Dictionary.
19275 * Returns the function name in allocated memory, or NULL for failure.
19276 * flags:
19277 * TFN_INT: internal function name OK
19278 * TFN_QUIET: be quiet
19279 * Advances "pp" to just after the function name (if no error).
19280 */
19287 {
19294 lval_T lv;
19300 /* Check for hard coded <SNR>: already translated function ID (from a user
19301 * command). */
19304 {
19308 }
19310 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19311 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19319 {
19323 }
19325 {
19326 /*
19327 * Report an invalid expression in braces, unless the expression
19328 * evaluation has been cancelled due to an aborting error, an
19329 * interrupt, or an exception.
19330 */
19332 {
19335 }
19336 else
19339 }
19342 {
19344 {
19349 }
19351 {
19354 }
19355 else
19356 {
19360 else
19363 }
19365 }
19368 {
19369 /* Error found, but continue after the function name. */
19372 }
19375 {
19379 {
19380 /* When there was "s:" already or the name expanded to get a
19381 * leading "s:" then remove it. */
19385 }
19386 }
19387 else
19388 {
19392 }
19394 /*
19395 * Copy the function name to allocated memory.
19396 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19397 * Accept <SNR>123_name() outside a script.
19398 */
19402 {
19406 {
19407 /* It's "s:" or "<SID>" */
19409 {
19412 }
19415 }
19416 }
19418 {
19421 }
19424 {
19426 {
19432 }
19435 }
19438 theend:
19441 }
19443 /*
19444 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19445 * Return 2 if "p" starts with "s:".
19446 * Return 0 otherwise.
19447 */
19448 static int
19451 {
19458 }
19460 /*
19461 * Return TRUE if "p" starts with "<SID>" or "s:".
19462 * Only works if eval_fname_script() returned non-zero for "p"!
19463 */
19464 static int
19467 {
19469 }
19471 /*
19472 * List the head of the function: "name(arg1, arg2)".
19473 */
19474 static void
19478 {
19486 {
19489 }
19490 else
19494 {
19498 }
19500 {
19504 }
19509 }
19511 /*
19512 * Find a function by name, return pointer to it in ufuncs.
19513 * Return NULL for unknown function.
19514 */
19518 {
19525 }
19527 #if defined(EXITFREE) || defined(PROTO)
19528 void
19530 {
19533 /* Need to start all over every time, because func_free() may change the
19534 * hash table. */
19538 {
19541 }
19542 }
19543 #endif
19545 /*
19546 * Return TRUE if a function "name" exists.
19547 */
19548 static int
19551 {
19559 /* Only accept "funcname", "funcname ", "funcname (..." and
19560 * "funcname(...", not "funcname!...". */
19562 {
19565 else
19567 }
19570 }
19572 /*
19573 * Return TRUE if "name" looks like a builtin function name: starts with a
19574 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19575 */
19576 static int
19579 {
19582 }
19584 #if defined(FEAT_PROFILE) || defined(PROTO)
19585 /*
19586 * Start profiling function "fp".
19587 */
19588 static void
19591 {
19610 }
19612 /*
19613 * Dump the profiling results for all functions in file "fd".
19614 */
19615 void
19618 {
19630 {
19632 {
19636 {
19642 else
19646 else
19654 {
19660 }
19662 }
19663 }
19664 }
19667 {
19669 prof_total_cmp);
19672 prof_self_cmp);
19674 }
19675 }
19677 static void
19684 {
19691 {
19694 prefer_self);
19697 else
19699 }
19701 }
19703 /*
19704 * Print the count and times for one function or function line.
19705 */
19706 static void
19713 {
19715 {
19719 else
19723 else
19725 }
19726 else
19728 }
19730 /*
19731 * Compare function for total time sorting.
19732 */
19733 static int
19734 #ifdef __BORLANDC__
19735 _RTLENTRYF
19736 #endif
19740 {
19746 }
19748 /*
19749 * Compare function for self time sorting.
19750 */
19751 static int
19752 #ifdef __BORLANDC__
19753 _RTLENTRYF
19754 #endif
19758 {
19764 }
19766 #endif
19768 /*
19769 * If "name" has a package name try autoloading the script for it.
19770 * Return TRUE if a package was loaded.
19771 */
19772 static int
19776 {
19782 /* If there is no '#' after name[0] there is no package name. */
19789 /* Find the name in the list of previously loaded package names. Skip
19790 * "autoload/", it's always the same. */
19796 else
19797 {
19798 /* Remember the name if it wasn't loaded already. */
19800 {
19803 }
19805 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19808 }
19812 }
19814 /*
19815 * Return the autoload script name for a function or variable name.
19816 * Returns NULL when out of memory.
19817 */
19821 {
19825 /* Get the script file name: replace '#' with '/', append ".vim". */
19836 }
19838 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19840 /*
19841 * Function given to ExpandGeneric() to obtain the list of user defined
19842 * function names.
19843 */
19844 char_u *
19848 {
19854 {
19857 }
19859 {
19871 {
19875 }
19877 }
19879 }
19883 /*
19884 * Copy the function name of "fp" to buffer "buf".
19885 * "buf" must be able to hold the function name plus three bytes.
19886 * Takes care of script-local function names.
19887 */
19888 static void
19892 {
19894 {
19897 }
19898 else
19900 }
19902 /*
19903 * ":delfunction {name}"
19904 */
19905 void
19908 {
19912 funcdict_T fudi;
19918 {
19922 }
19924 {
19928 }
19938 {
19940 {
19943 }
19945 {
19948 }
19951 {
19952 /* Delete the dict item that refers to the function, it will
19953 * invoke func_unref() and possibly delete the function. */
19955 }
19956 else
19958 }
19959 }
19961 /*
19962 * Free a function and remove it from the list of functions.
19963 */
19964 static void
19967 {
19970 /* clear this function */
19973 #ifdef FEAT_PROFILE
19977 #endif
19979 /* remove the function from the function hashtable */
19983 else
19987 }
19989 /*
19990 * Unreference a Function: decrement the reference count and free it when it
19991 * becomes zero. Only for numbered functions.
19992 */
19993 static void
19996 {
20000 {
20005 {
20006 /* Only delete it when it's not being used. Otherwise it's done
20007 * when "uf_calls" becomes zero. */
20010 }
20011 }
20012 }
20014 /*
20015 * Count a reference to a Function.
20016 */
20017 static void
20020 {
20024 {
20028 else
20030 }
20031 }
20033 /*
20034 * Call a user function.
20035 */
20036 static void
20045 {
20047 linenr_T save_sourcing_lnum;
20048 scid_T save_current_SID;
20049 funccall_T fc;
20058 #ifdef FEAT_PROFILE
20059 proftime_T wait_start;
20060 proftime_T call_start;
20061 #endif
20063 /* If depth of calling is getting too high, don't execute the function */
20065 {
20070 }
20083 /* Check if this function has a breakpoint. */
20087 /*
20088 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20089 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20090 * each argument variable and saves a lot of time.
20091 */
20092 /*
20093 * Init l: variables.
20094 */
20097 {
20098 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20099 * some compiler that checks the destination size. */
20109 }
20111 /*
20112 * Init a: variables.
20113 * Set a:0 to "argcount".
20114 * Set a:000 to a list with room for the "..." arguments.
20115 */
20130 /*
20131 * Set a:firstline to "firstline" and a:lastline to "lastline".
20132 * Set a:name to named arguments.
20133 * Set a:N to the "..." arguments.
20134 */
20140 {
20143 /* named argument a:name */
20145 else
20146 {
20147 /* "..." argument a:1, a:2, etc. */
20150 }
20152 {
20155 }
20156 else
20157 {
20163 }
20167 /* Note: the values are copied directly to avoid alloc/free.
20168 * "argvars" must have VAR_FIXED for v_lock. */
20173 {
20177 }
20178 }
20180 /* Don't redraw while executing the function. */
20188 {
20192 else
20197 {
20203 {
20211 {
20216 else
20217 {
20220 {
20224 }
20225 }
20226 }
20228 }
20233 }
20234 }
20235 #ifdef FEAT_PROFILE
20237 {
20242 {
20246 }
20248 }
20249 #endif
20256 /* call do_cmdline() to execute the lines */
20262 /* when the function was aborted because of an error, return -1 */
20264 {
20268 }
20270 #ifdef FEAT_PROFILE
20273 {
20279 {
20282 }
20283 }
20284 #endif
20286 /* when being verbose, mention the return value */
20288 {
20297 else
20298 {
20304 /* The value may be very long. Skip the middle part, so that we
20305 * have some idea how it starts and ends. smsg() would always
20306 * truncate it at the end. */
20309 {
20313 }
20314 }
20319 }
20325 #ifdef FEAT_PROFILE
20328 #endif
20331 {
20340 }
20345 /* The a: variables typevals were not alloced, only free the allocated
20346 * variables. */
20351 }
20353 /*
20354 * Add a number variable "name" to dict "dp" with value "nr".
20355 */
20356 static void
20361 varnumber_T nr;
20362 {
20369 }
20371 /*
20372 * ":return [expr]"
20373 */
20374 void
20377 {
20379 typval_T rettv;
20383 {
20386 }
20394 {
20397 else
20399 }
20400 /* It's safer to return also on error. */
20402 {
20403 /*
20404 * Return unless the expression evaluation has been cancelled due to an
20405 * aborting error, an interrupt, or an exception.
20406 */
20409 }
20411 /* When skipping or the return gets pending, advance to the next command
20412 * in this line (!returning). Otherwise, ignore the rest of the line.
20413 * Following lines will be ignored by get_func_line(). */
20421 }
20423 /*
20424 * Return from a function. Possibly makes the return pending. Also called
20425 * for a pending return at the ":endtry" or after returning from an extra
20426 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20427 * when called due to a ":return" command. "rettv" may point to a typval_T
20428 * with the return rettv. Returns TRUE when the return can be carried out,
20429 * FALSE when the return gets pending.
20430 */
20431 int
20437 {
20442 /* Undo the return. */
20445 /*
20446 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20447 * not in its finally clause (which then is to be executed next) is found.
20448 * In this case, make the ":return" pending for execution at the ":endtry".
20449 * Otherwise, return normally.
20450 */
20453 {
20457 /* A pending return again gets pending. "rettv" points to an
20458 * allocated variable with the rettv of the original ":return"'s
20459 * argument if present or is NULL else. */
20461 else
20462 {
20463 /* When undoing a return in order to make it pending, get the stored
20464 * return rettv. */
20469 {
20470 /* Store the value of the pending return. */
20473 else
20475 }
20476 else
20480 {
20481 /* The pending return value could be overwritten by a ":return"
20482 * without argument in a finally clause; reset the default
20483 * return value. */
20486 }
20487 }
20489 }
20490 else
20491 {
20494 /* If the return is carried out now, store the return value. For
20495 * a return immediately after reanimation, the value is already
20496 * there. */
20498 {
20503 }
20504 }
20507 }
20509 /*
20510 * Free the variable with a pending return value.
20511 */
20512 void
20515 {
20517 }
20519 /*
20520 * Generate a return command for producing the value of "rettv". The result
20521 * is an allocated string. Used by report_pending() for verbose messages.
20522 */
20523 char_u *
20526 {
20542 }
20544 /*
20545 * Get next function line.
20546 * Called by do_cmdline() to get the next line.
20547 * Returns allocated string, or NULL for end of function.
20548 */
20549 /* ARGSUSED */
20550 char_u *
20555 {
20561 /* If breakpoints have been added/deleted need to check for it. */
20563 {
20565 sourcing_lnum);
20567 }
20568 #ifdef FEAT_PROFILE
20571 #endif
20577 else
20578 {
20579 /* Skip NULL lines (continuation lines). */
20585 else
20586 {
20589 #ifdef FEAT_PROFILE
20592 #endif
20593 }
20594 }
20596 /* Did we encounter a breakpoint? */
20598 {
20600 /* Find next breakpoint. */
20602 sourcing_lnum);
20604 }
20607 }
20609 #if defined(FEAT_PROFILE) || defined(PROTO)
20610 /*
20611 * Called when starting to read a function line.
20612 * "sourcing_lnum" must be correct!
20613 * When skipping lines it may not actually be executed, but we won't find out
20614 * until later and we need to store the time now.
20615 */
20616 void
20619 {
20625 {
20627 /* Skip continuation lines. */
20634 }
20635 }
20637 /*
20638 * Called when actually executing a function line.
20639 */
20640 void
20643 {
20649 }
20651 /*
20652 * Called when done with a function line.
20653 */
20654 void
20657 {
20662 {
20664 {
20671 }
20673 }
20674 }
20675 #endif
20677 /*
20678 * Return TRUE if the currently active function should be ended, because a
20679 * return was encountered or an error occured. Used inside a ":while".
20680 */
20681 int
20684 {
20687 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20688 * an error inside a try conditional. */
20691 }
20693 /*
20694 * return TRUE if cookie indicates a function which "abort"s on errors.
20695 */
20696 int
20699 {
20701 }
20703 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20705 {
20706 VAR_FLAVOUR_DEFAULT,
20707 VAR_FLAVOUR_SESSION,
20708 VAR_FLAVOUR_VIMINFO
20713 static var_flavour_T
20716 {
20720 {
20725 }
20726 else
20728 }
20729 #endif
20731 #if defined(FEAT_VIMINFO) || defined(PROTO)
20732 /*
20733 * Restore global vars that start with a capital from the viminfo file
20734 */
20735 int
20739 {
20742 typval_T tv;
20745 {
20748 {
20755 {
20757 {
20761 }
20762 else
20763 {
20766 }
20770 }
20771 }
20772 }
20775 }
20777 /*
20778 * Write global vars that start with a capital to the viminfo file
20779 */
20780 void
20783 {
20799 {
20801 {
20805 {
20807 {
20811 }
20817 }
20818 }
20819 }
20820 }
20821 #endif
20823 #if defined(FEAT_SESSION) || defined(PROTO)
20824 int
20827 {
20835 {
20837 {
20843 {
20844 /* Escape special characters with a backslash. Turn a LF and
20845 * CR into \n and \r. */
20859 p,
20863 {
20866 }
20868 }
20869 }
20870 }
20872 }
20873 #endif
20875 /*
20876 * Display script name where an item was last set.
20877 * Should only be invoked when 'verbose' is non-zero.
20878 */
20879 void
20881 scid_T scriptID;
20882 {
20886 {
20889 {
20895 }
20896 }
20897 }
20901 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
20904 #ifdef WIN3264
20905 /*
20906 * Functions for ":8" filename modifier: get 8.3 version of a filename.
20907 */
20909 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
20912 /*
20913 * Get the short pathname of a file.
20914 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
20915 */
20916 static int
20921 {
20929 {
20930 /* If that doesn't work (not enough space), then save the string
20931 * and try again with a new buffer big enough
20932 */
20942 /* Really should always succeed, as the buffer is big enough */
20943 }
20947 }
20949 /*
20950 * Create a short path name. Returns the length of the buffer it needs.
20951 * Doesn't copy over the end of the buffer passed in.
20952 */
20953 static int
20958 {
20960 char_u ch;
20963 /* Make a copy */
20973 {
20977 }
20979 do
20980 {
20981 /* Go back one path-separator */
20983 {
20987 }
20991 /* Remember the character that is about to be splatted */
20995 /* Try it in situ */
20998 {
21001 }
21006 {
21007 /* Remember the length of the new string. */
21011 {
21012 /* If there's not enough space in the currently allocated string,
21013 * then copy it to a buffer big enough.
21014 */
21018 }
21019 else
21020 {
21021 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21026 }
21027 /* Concat the next bit */
21030 }
21034 }
21036 /*
21037 * Get a pathname for a partial path.
21038 */
21039 static int
21044 {
21050 /* Count up the path seperators from the RHS.. so we know which part
21051 * of the path to return.
21052 */
21058 /* Need full path first (use expand_env() to remove a "~/") */
21062 else
21071 {
21072 /* Don't have a valid filename, so shorten the rest of the
21073 * path if we can. This CAN give us invalid 8.3 filenames, but
21074 * there's not a lot of point in guessing what it might be.
21075 */
21079 }
21081 /* Count the paths backward to find the beginning of the desired string. */
21083 {
21084 #ifdef FEAT_MBYTE
21087 #endif
21089 {
21092 else
21093 sepcount --;
21094 }
21095 }
21097 {
21101 else
21103 }
21104 else
21107 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21114 }
21117 /*
21118 * Adjust a filename, according to a string of modifiers.
21119 * *fnamep must be NUL terminated when called. When returning, the length is
21120 * determined by *fnamelen.
21121 * Returns valid flags.
21122 * When there is an error, *fnamep is set to NULL.
21123 */
21124 int
21131 {
21138 #ifdef WIN3264
21140 #endif
21142 repeat:
21143 /* ":p" - full path/file_name */
21145 {
21151 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21153 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21155 # ifdef BACKSLASH_IN_FILENAME
21157 # endif
21160 #endif
21161 )
21162 {
21168 }
21170 /* When "/." or "/.." is used: force expansion to get rid of it. */
21172 {
21180 }
21182 /* FullName_save() is slow, don't use it when not needed. */
21184 {
21190 }
21192 /* Append a path separator to a directory. */
21194 {
21195 /* Make room for one or two extra characters. */
21202 }
21203 }
21205 /* ":." - path relative to the current directory */
21206 /* ":~" - path relative to the home directory */
21207 /* ":8" - shortname path - postponed till after */
21210 {
21213 {
21214 #ifdef WIN3264
21216 #endif
21218 }
21220 /* Need full path first (use expand_env() to remove a "~/") */
21222 {
21225 else
21227 }
21228 else
21234 {
21236 {
21240 {
21243 {
21247 }
21248 }
21249 }
21250 else
21251 {
21253 /* Only replace it when it starts with '~' */
21255 {
21258 {
21262 }
21263 }
21264 }
21266 }
21267 }
21272 /* ":h" - head, remove "/file_name", can be repeated */
21273 /* Don't remove the first "/" or "c:\" */
21275 {
21282 #ifdef VMS
21285 #endif
21288 }
21290 /* ":8" - shortname */
21292 {
21294 #ifdef WIN3264
21296 #endif
21297 }
21299 #ifdef WIN3264
21300 /* Check shortname after we have done 'heads' and before we do 'tails'
21301 */
21303 {
21305 /* Copy the string if it is shortened by :h */
21307 {
21313 }
21315 /* Split into two implementations - makes it easier. First is where
21316 * there isn't a full name already, second is where there is.
21317 */
21319 {
21322 }
21323 else
21324 {
21327 /* Simple case, already have the full-name
21328 * Nearly always shorter, so try first time. */
21334 {
21335 /* Couldn't find the filename.. search the paths.
21336 */
21340 }
21342 }
21343 }
21346 /* ":t" - tail, just the basename */
21348 {
21352 }
21354 /* ":e" - extension, can be repeated */
21355 /* ":r" - root, without extension, can be repeated */
21358 {
21359 /* find a '.' in the tail:
21360 * - for second :e: before the current fname
21361 * - otherwise: The last '.'
21362 */
21365 else
21371 {
21373 {
21376 #ifdef VMS
21377 /* cut version from the extension */
21384 #endif
21385 }
21388 }
21390 {
21393 }
21395 }
21397 /* ":s?pat?foo?" - substitute */
21398 /* ":gs?pat?foo?" - global substitute */
21402 {
21413 {
21416 }
21420 {
21421 /* find end of pattern */
21424 {
21427 {
21429 /* find end of substitution */
21432 {
21436 {
21440 {
21446 }
21447 }
21450 }
21452 }
21453 }
21454 /* after using ":s", repeat all the modifiers */
21457 }
21458 }
21461 }
21463 /*
21464 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21465 * "flags" can be "g" to do a global substitute.
21466 * Returns an allocated string, NULL for error.
21467 */
21468 char_u *
21474 {
21476 regmatch_T regmatch;
21480 garray_T ga;
21484 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21495 {
21498 {
21499 /*
21500 * Get some space for a temporary buffer to do the substitution
21501 * into. It will contain:
21502 * - The text up to where the match is.
21503 * - The substituted text.
21504 * - The text after the match.
21505 */
21509 {
21512 }
21514 /* copy the text up to where the match is */
21517 /* add the substituted text */
21521 /* avoid getting stuck on a match with an empty string */
21523 {
21528 }
21529 else
21530 {
21534 }
21537 }
21543 }
21550 }