| blob | 34263544cb66bf7075efa6ea5c9ed6deda0dbfc0 |
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 */
349 };
351 /* shorthand */
352 #define vv_type vv_di.di_tv.v_type
353 #define vv_nr vv_di.di_tv.vval.v_number
354 #define vv_str vv_di.di_tv.vval.v_string
355 #define vv_tv vv_di.di_tv
357 /*
358 * The v: variables are stored in dictionary "vimvardict".
359 * "vimvars_var" is the variable that is used for the "l:" scope.
360 */
363 #define vimvarht vimvardict.dv_hashtab
367 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
368 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
369 #endif
370 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
377 #ifdef FEAT_WINDOWS
379 #endif
384 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
386 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
388 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
456 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));
457 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));
481 #if defined(FEAT_INS_EXPAND)
485 #endif
593 #ifdef vim_mkdir
595 #endif
642 #ifdef HAVE_STRFTIME
644 #endif
688 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
691 valid character */
692 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
712 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
727 #ifdef FEAT_PROFILE
729 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
730 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
731 static int
732 # ifdef __BORLANDC__
733 _RTLENTRYF
734 # endif
736 static int
737 # ifdef __BORLANDC__
738 _RTLENTRYF
739 # endif
741 #endif
748 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));
756 /* Character used as separated in autoload function/variable names. */
759 /*
760 * Initialize the global and v: variables.
761 */
762 void
764 {
774 {
781 else
784 /* add to v: scope dict, unless the value is not always available */
788 /* add to compat scope dict */
790 }
791 }
793 #if defined(EXITFREE) || defined(PROTO)
794 void
796 {
801 {
804 {
807 }
808 }
812 /* script-local variables */
818 /* global variables */
821 /* functions */
825 /* autoloaded script names */
828 /* unreferenced lists and dicts */
830 }
831 #endif
833 /*
834 * Return the name of the executed function.
835 */
836 char_u *
839 {
841 }
843 /*
844 * Return the address holding the next breakpoint line for a funccall cookie.
845 */
846 linenr_T *
849 {
851 }
853 /*
854 * Return the address holding the debug tick for a funccall cookie.
855 */
859 {
861 }
863 /*
864 * Return the nesting level for a funccall cookie.
865 */
866 int
869 {
871 }
873 /* pointer to funccal for currently active function */
876 /*
877 * Return TRUE when a function was ended by a ":return" command.
878 */
879 int
881 {
883 }
886 /*
887 * Set an internal variable to a string value. Creates the variable if it does
888 * not already exist.
889 */
890 void
894 {
900 {
903 {
906 }
907 }
908 }
915 /*
916 * Start recording command output to a variable
917 * Returns OK if successfully completed the setup. FAIL otherwise.
918 */
919 int
923 {
926 typval_T tv;
928 /* Make sure a valid variable name is specified */
930 {
933 }
941 {
944 }
946 /* The output is stored in growarray "redir_ga" until redirection ends. */
949 /* Parse the variable name (can be a dict or list entry). */
951 FNE_CHECK_START);
953 {
955 /* Trailing characters are present after the variable name */
957 else
961 }
963 /* check if we can write to the variable: set it to or append an empty
964 * string */
971 else
976 {
979 }
981 {
982 /* Dictionary item was created, don't do it again. */
985 }
988 }
990 /*
991 * Append "value[value_len]" to the variable set by var_redir_start().
992 * The actual appending is postponed until redirection ends, because the value
993 * appended may in fact be the string we write to, changing it may cause freed
994 * memory to be used:
995 * :redir => foo
996 * :let foo
997 * :redir END
998 */
999 void
1003 {
1011 else
1015 {
1018 }
1019 else
1021 }
1023 /*
1024 * Stop redirecting command output to a variable.
1025 */
1026 void
1028 {
1029 typval_T tv;
1032 {
1033 /* Append the trailing NUL. */
1036 /* Assign the text to the variable. */
1045 }
1048 }
1050 # if defined(FEAT_MBYTE) || defined(PROTO)
1051 int
1057 {
1074 }
1075 # endif
1077 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1078 int
1082 {
1093 {
1096 }
1098 }
1099 # endif
1101 # if defined(FEAT_DIFF) || defined(PROTO)
1102 void
1107 {
1117 }
1119 void
1124 {
1134 }
1135 # endif
1137 /*
1138 * Top level evaluation function, returning a boolean.
1139 * Sets "error" to TRUE if there was an error.
1140 * Return TRUE or FALSE.
1141 */
1142 int
1148 {
1149 typval_T tv;
1156 else
1157 {
1160 {
1163 }
1164 }
1169 }
1171 /*
1172 * Top level evaluation function, returning a string. If "skip" is TRUE,
1173 * only parsing to "nextcmd" is done, without reporting errors. Return
1174 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1175 */
1176 char_u *
1181 {
1182 typval_T tv;
1189 else
1190 {
1193 }
1198 }
1200 /*
1201 * Skip over an expression at "*pp".
1202 * Return FAIL for an error, OK otherwise.
1203 */
1204 int
1207 {
1208 typval_T rettv;
1212 }
1214 /*
1215 * Top level evaluation function, returning a string.
1216 * Return pointer to allocated memory, or NULL for failure.
1217 */
1218 char_u *
1223 {
1224 typval_T tv;
1226 garray_T ga;
1230 else
1231 {
1233 {
1238 }
1239 else
1242 }
1245 }
1247 /*
1248 * Call eval_to_string() without using current local variables and using
1249 * textlock. When "use_sandbox" is TRUE use the sandbox.
1250 */
1251 char_u *
1256 {
1270 }
1272 /*
1273 * Top level evaluation function, returning a number.
1274 * Evaluates "expr" silently.
1275 * Returns -1 for an error.
1276 */
1277 int
1280 {
1281 typval_T rettv;
1289 else
1290 {
1293 }
1297 }
1299 /*
1300 * Prepare v: variable "idx" to be used.
1301 * Save the current typeval in "save_tv".
1302 * When not used yet add the variable to the v: hashtable.
1303 */
1304 static void
1308 {
1312 }
1314 /*
1315 * Restore v: variable "idx" to typeval "save_tv".
1316 * When no longer defined, remove the variable from the v: hashtable.
1317 */
1318 static void
1322 {
1327 {
1331 else
1333 }
1334 }
1336 #if defined(FEAT_SPELL) || defined(PROTO)
1337 /*
1338 * Evaluate an expression to a list with suggestions.
1339 * For the "expr:" part of 'spellsuggest'.
1340 */
1341 list_T *
1345 {
1346 typval_T save_val;
1347 typval_T rettv;
1351 /* Set "v:val" to the bad word. */
1359 {
1362 else
1364 }
1371 }
1373 /*
1374 * "list" is supposed to contain two items: a word and a number. Return the
1375 * word in "pp" and the number as the return value.
1376 * Return -1 if anything isn't right.
1377 * Used to get the good word and score from the eval_spell_expr() result.
1378 */
1379 int
1383 {
1395 }
1396 #endif
1398 /*
1399 * Top level evaluation function.
1400 * Returns an allocated typval_T with the result.
1401 * Returns NULL when there is an error.
1402 */
1403 typval_T *
1407 {
1412 {
1415 }
1418 }
1421 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1422 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1423 /*
1424 * Call some vimL function and return the result in "*rettv".
1425 * Uses argv[argc] for the function arguments.
1426 * Returns OK or FAIL.
1427 */
1428 static int
1435 {
1449 {
1450 /* Pass a NULL or empty argument as an empty string */
1452 {
1456 }
1458 /* Recognize a number argument, the others must be strings. */
1461 {
1464 }
1465 else
1466 {
1469 }
1470 }
1473 {
1476 }
1483 {
1486 }
1493 }
1495 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1496 /*
1497 * Call vimL function "func" and return the result as a string.
1498 * Returns NULL when calling the function fails.
1499 * Uses argv[argc] for the function arguments.
1500 */
1507 {
1508 typval_T rettv;
1517 }
1518 # endif
1520 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1521 /*
1522 * Call vimL function "func" and return the result as a number.
1523 * Returns -1 when calling the function fails.
1524 * Uses argv[argc] for the function arguments.
1525 */
1526 long
1532 {
1533 typval_T rettv;
1542 }
1543 # endif
1545 /*
1546 * Call vimL function "func" and return the result as a list
1547 * Uses argv[argc] for the function arguments.
1548 */
1555 {
1556 typval_T rettv;
1562 {
1565 }
1568 }
1569 #endif
1572 /*
1573 * Save the current function call pointer, and set it to NULL.
1574 * Used when executing autocommands and for ":source".
1575 */
1578 {
1583 }
1585 void
1588 {
1592 }
1594 #if defined(FEAT_PROFILE) || defined(PROTO)
1595 /*
1596 * Prepare profiling for entering a child or something else that is not
1597 * counted for the script/function itself.
1598 * Should always be called in pair with prof_child_exit().
1599 */
1600 void
1603 {
1609 }
1611 /*
1612 * Take care of time spent in a child.
1613 * Should always be called after prof_child_enter().
1614 */
1615 void
1618 {
1622 {
1627 }
1629 }
1630 #endif
1633 #ifdef FEAT_FOLDING
1634 /*
1635 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1636 * it in "*cp". Doesn't give error messages.
1637 */
1638 int
1642 {
1643 typval_T tv;
1647 OPT_LOCAL);
1656 else
1657 {
1658 /* If the result is a number, just return the number. */
1663 else
1664 {
1665 /* If the result is a string, check if there is a non-digit before
1666 * the number. */
1671 }
1673 }
1680 }
1681 #endif
1683 /*
1684 * ":let" list all variable values
1685 * ":let var1 var2" list variable values
1686 * ":let var = expr" assignment command.
1687 * ":let var += expr" assignment command.
1688 * ":let var -= expr" assignment command.
1689 * ":let var .= expr" assignment command.
1690 * ":let [var1, var2] = expr" unpack list.
1691 */
1692 void
1695 {
1698 typval_T rettv;
1713 {
1714 /*
1715 * ":let" without "=": list variables
1716 */
1720 /* ":let var1 var2" */
1723 {
1724 /* ":let" */
1728 #ifdef FEAT_WINDOWS
1730 #endif
1734 }
1736 }
1737 else
1738 {
1742 {
1745 }
1752 {
1756 }
1758 {
1760 op);
1762 }
1763 }
1764 }
1766 /*
1767 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1768 * Handles both "var" with any type and "[var, var; var]" with a list type.
1769 * When "nextchars" is not NULL it points to a string with characters that
1770 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1771 * or concatenate.
1772 * Returns OK or FAIL;
1773 */
1774 static int
1782 {
1787 typval_T ltv;
1790 {
1791 /*
1792 * ":let var = expr" or ":for var in list"
1793 */
1797 }
1799 /*
1800 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1801 */
1803 {
1806 }
1810 {
1813 }
1815 {
1818 }
1822 {
1831 {
1832 /* Put the rest of the list (may be empty) in the var after ';'.
1833 * Create a new list for this. */
1838 {
1841 }
1854 }
1856 {
1859 }
1860 }
1863 }
1865 /*
1866 * Skip over assignable variable "var" or list of variables "[var, var]".
1867 * Used for ":let varvar = expr" and ":for varvar in expr".
1868 * For "[var, var]" increment "*var_count" for each variable.
1869 * for "[var, var; var]" set "semicolon".
1870 * Return NULL for an error.
1871 */
1877 {
1881 {
1882 /* "[var, var]": find the matching ']'. */
1885 {
1889 {
1892 }
1899 {
1901 {
1904 }
1906 }
1908 {
1911 }
1912 }
1914 }
1915 else
1917 }
1919 /*
1920 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1921 * l[idx].
1922 */
1926 {
1931 }
1933 /*
1934 * List variables for hashtab "ht" with prefix "prefix".
1935 * If "empty" is TRUE also list NULL strings as empty strings.
1936 */
1937 static void
1943 {
1950 {
1952 {
1958 }
1959 }
1960 }
1962 /*
1963 * List global variables.
1964 */
1965 static void
1968 {
1970 }
1972 /*
1973 * List buffer variables.
1974 */
1975 static void
1978 {
1987 }
1989 /*
1990 * List window variables.
1991 */
1992 static void
1995 {
1998 }
2000 #ifdef FEAT_WINDOWS
2001 /*
2002 * List tab page variables.
2003 */
2004 static void
2007 {
2010 }
2011 #endif
2013 /*
2014 * List Vim variables.
2015 */
2016 static void
2019 {
2021 }
2023 /*
2024 * List script-local variables, if there is a script.
2025 */
2026 static void
2029 {
2033 }
2035 /*
2036 * List function variables, if there is a function.
2037 */
2038 static void
2041 {
2045 }
2047 /*
2048 * List variables in "arg".
2049 */
2055 {
2062 typval_T tv;
2065 {
2067 {
2070 {
2074 }
2075 }
2076 else
2077 {
2078 /* get_name_len() takes care of expanding curly braces */
2082 {
2083 /* This is mainly to keep test 49 working: when expanding
2084 * curly braces fails overrule the exception error message. */
2086 {
2090 }
2092 }
2093 else
2094 {
2099 else
2100 {
2101 /* handle d.key, l[idx], f(expr) */
2105 else
2106 {
2108 {
2110 {
2114 #ifdef FEAT_WINDOWS
2116 #endif
2122 }
2123 }
2124 else
2125 {
2138 first);
2141 }
2143 }
2144 }
2145 }
2148 }
2151 }
2154 }
2156 /*
2157 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2158 * Returns a pointer to the char just after the var name.
2159 * Returns NULL if there is an error.
2160 */
2168 {
2177 /*
2178 * ":let $VAR = expr": Set environment variable.
2179 */
2181 {
2182 /* Find the end of the name. */
2188 else
2189 {
2195 else
2196 {
2201 {
2206 {
2210 }
2211 }
2213 {
2223 }
2226 }
2227 }
2228 }
2230 /*
2231 * ":let &option = expr": Set option value.
2232 * ":let &l:option = expr": Set local option value.
2233 * ":let &g:option = expr": Set global option value.
2234 */
2236 {
2237 /* Find the end of the name. */
2242 else
2243 {
2256 {
2262 else
2263 {
2265 {
2268 else
2270 }
2272 {
2276 }
2277 }
2278 }
2280 {
2283 }
2286 }
2287 }
2289 /*
2290 * ":let @r = expr": Set register contents.
2291 */
2293 {
2300 else
2301 {
2307 {
2310 {
2313 }
2314 }
2316 {
2319 }
2321 }
2322 }
2324 /*
2325 * ":let var = expr": Set internal variable.
2326 * ":let {expr} = expr": Idem, name made with curly braces
2327 */
2329 {
2330 lval_T lv;
2334 {
2337 else
2338 {
2341 }
2342 }
2344 }
2346 else
2350 }
2352 /*
2353 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2354 */
2355 static int
2358 {
2360 {
2363 }
2365 }
2367 /*
2368 * Get an lval: variable, Dict item or List item that can be assigned a value
2369 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2370 * "name.key", "name.key[expr]" etc.
2371 * Indexing only works if "name" is an existing List or Dictionary.
2372 * "name" points to the start of the name.
2373 * If "rettv" is not NULL it points to the value to be assigned.
2374 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2375 * wrong; must end in space or cmd separator.
2376 *
2377 * Returns a pointer to just after the name, including indexes.
2378 * When an evaluation error occurs "lp->ll_name" is NULL;
2379 * Returns NULL for a parsing error. Still need to free items in "lp"!
2380 */
2390 {
2395 typval_T var1;
2396 typval_T var2;
2403 /* Clear everything in "lp". */
2407 {
2408 /* When skipping just find the end of the name. */
2411 }
2413 /* Find the end of the name. */
2416 {
2417 /* Don't expand the name when we already know there is an error. */
2420 {
2423 }
2427 {
2428 /* Report an invalid expression in braces, unless the
2429 * expression evaluation has been cancelled due to an
2430 * aborting error, an interrupt, or an exception. */
2432 {
2436 }
2437 }
2439 }
2440 else
2443 /* Without [idx] or .key we are done. */
2456 /*
2457 * Loop until no more [idx] or .key is following.
2458 */
2461 {
2465 {
2469 }
2471 {
2475 }
2479 {
2482 ;
2484 {
2488 }
2490 }
2491 else
2492 {
2493 /* Get the index [expr] or the first index [expr: ]. */
2497 else
2498 {
2503 {
2504 /* not a number or string */
2507 }
2508 }
2510 /* Optionally get the second index [ :expr]. */
2512 {
2514 {
2520 }
2523 {
2529 }
2533 else
2534 {
2537 {
2541 }
2543 {
2544 /* not a number or string */
2549 }
2550 }
2552 }
2553 else
2557 {
2565 }
2567 /* Skip to past ']'. */
2569 }
2572 {
2574 {
2575 /* "[key]": get key from "var1" */
2578 {
2583 }
2584 }
2589 {
2590 /* Key does not exist in dict: may need to add it. */
2592 {
2598 }
2601 else
2608 }
2612 }
2613 else
2614 {
2615 /*
2616 * Get the number and item for the only or first index of the List.
2617 */
2620 else
2621 {
2624 }
2629 {
2631 {
2634 }
2635 }
2637 {
2641 }
2643 /*
2644 * May need to find the item or absolute index for the second
2645 * index of a range.
2646 * When no index given: "lp->ll_empty2" is TRUE.
2647 * Otherwise "lp->ll_n2" is set to the second index.
2648 */
2650 {
2654 {
2659 }
2661 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2666 }
2669 }
2670 }
2673 }
2675 /*
2676 * Clear lval "lp" that was filled by get_lval().
2677 */
2678 static void
2681 {
2684 }
2686 /*
2687 * Set a variable that was parsed by get_lval() to "rettv".
2688 * "endp" points to just after the parsed name.
2689 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2690 */
2691 static void
2698 {
2704 {
2706 {
2710 {
2711 typval_T tv;
2713 /* handle +=, -= and .= */
2716 {
2720 }
2721 }
2722 else
2725 }
2726 }
2730 ;
2732 {
2733 /*
2734 * Assign the List values to the list items.
2735 */
2737 {
2740 else
2741 {
2744 }
2749 {
2750 /* Need to add an empty item. */
2752 {
2755 }
2756 }
2759 }
2766 }
2767 else
2768 {
2769 /*
2770 * Assign to a List or Dictionary item.
2771 */
2773 {
2775 {
2778 }
2780 /* Need to add an item to the Dictionary. */
2785 {
2788 }
2790 }
2792 {
2795 }
2796 else
2799 /*
2800 * Assign the value to the variable or list item.
2801 */
2804 else
2805 {
2809 }
2810 }
2811 }
2813 /*
2814 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2815 * Returns OK or FAIL.
2816 */
2817 static int
2822 {
2827 /* Can't do anything with a Funcref or a Dict on the right. */
2829 {
2831 {
2839 /* List += List */
2849 {
2850 /* nr += nr or nr -= nr*/
2854 else
2859 }
2860 else
2861 {
2862 /* str .= str */
2868 }
2870 }
2871 }
2875 }
2877 /*
2878 * Add a watcher to a list.
2879 */
2880 static void
2884 {
2887 }
2889 /*
2890 * Remove a watcher from a list.
2891 * No warning when it isn't found...
2892 */
2893 static void
2897 {
2902 {
2904 {
2907 }
2909 }
2910 }
2912 /*
2913 * Just before removing an item from a list: advance watchers to the next
2914 * item.
2915 */
2916 static void
2920 {
2926 }
2928 /*
2929 * Evaluate the expression used in a ":for var in expr" command.
2930 * "arg" points to "var".
2931 * Set "*errp" to TRUE for an error, FALSE otherwise;
2932 * Return a pointer that holds the info. Null when there is an error.
2933 */
2940 {
2943 typval_T tv;
2958 {
2961 }
2966 {
2969 {
2972 {
2975 }
2976 else
2977 {
2978 /* No need to increment the refcount, it's already set for the
2979 * list being used in "tv". */
2983 }
2984 }
2985 }
2990 }
2992 /*
2993 * Use the first item in a ":for" list. Advance to the next.
2994 * Assign the values to the variable (list). "arg" points to the first one.
2995 * Return TRUE when a valid item was found, FALSE when at end of list or
2996 * something wrong.
2997 */
2998 int
3002 {
3010 else
3011 {
3015 }
3017 }
3019 /*
3020 * Free the structure used to store info used by ":for".
3021 */
3022 void
3025 {
3029 {
3032 }
3034 }
3036 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3038 void
3042 cmdidx_T cmdidx;
3043 {
3049 {
3052 {
3053 /* ":let var1 var2 ...": find last space. */
3055 {
3060 }
3062 }
3063 }
3064 else
3069 {
3072 {
3075 {
3079 }
3081 {
3086 }
3087 }
3089 {
3090 /* environment variable */
3092 }
3094 {
3097 }
3101 {
3102 /* Function name can start with "<SNR>" */
3104 }
3106 {
3108 {
3113 }
3115 {
3116 /* Trick: '' is like stopping and starting a literal string. */
3120 }
3122 {
3124 {
3127 }
3128 else
3130 }
3131 else
3133 }
3134 else
3135 /* Doesn't look like something valid, expand as an expression
3136 * anyway. */
3142 }
3144 }
3148 /*
3149 * ":1,25call func(arg1, arg2)" function call.
3150 */
3151 void
3154 {
3160 typval_T rettv;
3161 linenr_T lnum;
3164 funcdict_T fudi;
3168 {
3169 /* Still need to give an error message for missing key. */
3172 }
3176 /* Increase refcount on dictionary, it could get deleted when evaluating
3177 * the arguments. */
3181 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3185 /* Skip white space to allow ":call func ()". Not good, but required for
3186 * backward compatibility. */
3191 {
3194 }
3196 /*
3197 * When skipping, evaluate the function once, to find the end of the
3198 * arguments.
3199 * When the function takes a range, this is discovered after the first
3200 * call, and the loop is broken.
3201 */
3203 {
3206 }
3207 else
3210 {
3212 {
3215 }
3220 {
3223 }
3225 /* Handle a function returning a Funcref, Dictionary or List. */
3227 {
3230 }
3236 /* Stop when immediately aborting on error, or when an interrupt
3237 * occurred or an exception was thrown but not caught.
3238 * get_func_tv() returned OK, so that the check for trailing
3239 * characters below is executed. */
3242 }
3247 {
3248 /* Check for trailing illegal characters and a following command. */
3250 {
3253 }
3254 else
3256 }
3258 end:
3261 }
3263 /*
3264 * ":unlet[!] var1 ... " command.
3265 */
3266 void
3269 {
3271 }
3273 /*
3274 * ":lockvar" and ":unlockvar" commands
3275 */
3276 void
3279 {
3286 {
3289 }
3292 }
3294 /*
3295 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3296 */
3297 static void
3302 {
3306 lval_T lv;
3308 do
3309 {
3310 /* Parse the name and find the end. */
3312 FNE_CHECK_START);
3317 {
3319 {
3322 }
3326 }
3329 {
3331 {
3334 }
3335 else
3336 {
3340 }
3341 }
3350 }
3352 static int
3357 {
3362 {
3366 /* Normal name or expanded name. */
3372 }
3376 {
3379 /* Delete a range of List items. */
3381 {
3386 }
3387 }
3388 else
3389 {
3391 /* unlet a List item. */
3393 else
3394 /* unlet a Dictionary item. */
3396 }
3399 }
3401 /*
3402 * "unlet" a variable. Return OK if it existed, FAIL if not.
3403 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3404 */
3405 int
3409 {
3417 {
3420 {
3427 }
3428 }
3433 }
3435 /*
3436 * Lock or unlock variable indicated by "lp".
3437 * "deep" is the levels to go (-1 for unlimited);
3438 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3439 */
3440 static int
3446 {
3455 {
3459 /* Normal name or expanded name. */
3462 else
3463 {
3467 else
3468 {
3471 else
3474 }
3475 }
3477 }
3479 {
3482 /* (un)lock a range of List items. */
3484 {
3488 }
3489 }
3491 /* (un)lock a List item. */
3493 else
3494 /* un(lock) a Dictionary item. */
3498 }
3500 /*
3501 * Lock or unlock an item. "deep" is nr of levels to go.
3502 */
3503 static void
3508 {
3517 {
3520 }
3525 /* lock/unlock the item itself */
3528 else
3532 {
3535 {
3538 else
3541 /* recursive: lock/unlock the items the List contains */
3544 }
3548 {
3551 else
3554 {
3555 /* recursive: lock/unlock the items the List contains */
3558 {
3560 {
3563 }
3564 }
3565 }
3566 }
3567 }
3569 }
3571 /*
3572 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3573 * it refers to a List or Dictionary that is locked.
3574 */
3575 static int
3578 {
3586 }
3588 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3589 /*
3590 * Delete all "menutrans_" variables.
3591 */
3592 void
3594 {
3601 {
3603 {
3607 }
3608 }
3610 }
3611 #endif
3613 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3615 /*
3616 * Local string buffer for the next two functions to store a variable name
3617 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3618 * get_user_var_name().
3619 */
3626 /*
3627 * Function to concatenate a prefix and a variable name.
3628 */
3633 {
3638 {
3643 {
3646 }
3648 }
3653 }
3655 /*
3656 * Function given to ExpandGeneric() to obtain the list of user defined
3657 * (global/buffer/window/built-in) variable names.
3658 */
3659 /*ARGSUSED*/
3660 char_u *
3664 {
3668 #ifdef FEAT_WINDOWS
3670 #endif
3676 {
3678 #ifdef FEAT_WINDOWS
3680 #endif
3681 }
3683 /* Global variables */
3685 {
3688 else
3695 }
3697 /* b: variables */
3700 {
3703 else
3708 }
3710 {
3713 }
3715 /* w: variables */
3718 {
3721 else
3726 }
3728 #ifdef FEAT_WINDOWS
3729 /* t: variables */
3732 {
3735 else
3740 }
3741 #endif
3743 /* v: variables */
3751 }
3755 /*
3756 * types for expressions.
3757 */
3759 {
3771 /*
3772 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3773 * executed. The function may return OK, but the rettv will be of type
3774 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3775 */
3777 /*
3778 * Handle zero level expression.
3779 * This calls eval1() and handles error message and nextcmd.
3780 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3781 * Note: "rettv.v_lock" is not set.
3782 * Return OK or FAIL.
3783 */
3784 static int
3790 {
3797 {
3800 /*
3801 * Report the invalid expression unless the expression evaluation has
3802 * been cancelled due to an aborting error, an interrupt, or an
3803 * exception.
3804 */
3808 }
3813 }
3815 /*
3816 * Handle top level expression:
3817 * expr1 ? expr0 : expr0
3818 *
3819 * "arg" must point to the first non-white of the expression.
3820 * "arg" is advanced to the next non-white after the recognized expression.
3821 *
3822 * Note: "rettv.v_lock" is not set.
3823 *
3824 * Return OK or FAIL.
3825 */
3826 static int
3831 {
3833 typval_T var2;
3835 /*
3836 * Get the first variable.
3837 */
3842 {
3845 {
3853 }
3855 /*
3856 * Get the second variable.
3857 */
3862 /*
3863 * Check for the ":".
3864 */
3866 {
3871 }
3873 /*
3874 * Get the third variable.
3875 */
3878 {
3882 }
3885 }
3888 }
3890 /*
3891 * Handle first level expression:
3892 * expr2 || expr2 || expr2 logical OR
3893 *
3894 * "arg" must point to the first non-white of the expression.
3895 * "arg" is advanced to the next non-white after the recognized expression.
3896 *
3897 * Return OK or FAIL.
3898 */
3899 static int
3904 {
3905 typval_T var2;
3910 /*
3911 * Get the first variable.
3912 */
3916 /*
3917 * Repeat until there is no following "||".
3918 */
3922 {
3924 {
3931 }
3933 /*
3934 * Get the second variable.
3935 */
3940 /*
3941 * Compute the result.
3942 */
3944 {
3950 }
3952 {
3955 }
3956 }
3959 }
3961 /*
3962 * Handle second level expression:
3963 * expr3 && expr3 && expr3 logical AND
3964 *
3965 * "arg" must point to the first non-white of the expression.
3966 * "arg" is advanced to the next non-white after the recognized expression.
3967 *
3968 * Return OK or FAIL.
3969 */
3970 static int
3975 {
3976 typval_T var2;
3981 /*
3982 * Get the first variable.
3983 */
3987 /*
3988 * Repeat until there is no following "&&".
3989 */
3993 {
3995 {
4002 }
4004 /*
4005 * Get the second variable.
4006 */
4011 /*
4012 * Compute the result.
4013 */
4015 {
4021 }
4023 {
4026 }
4027 }
4030 }
4032 /*
4033 * Handle third level expression:
4034 * var1 == var2
4035 * var1 =~ var2
4036 * var1 != var2
4037 * var1 !~ var2
4038 * var1 > var2
4039 * var1 >= var2
4040 * var1 < var2
4041 * var1 <= var2
4042 * var1 is var2
4043 * var1 isnot var2
4044 *
4045 * "arg" must point to the first non-white of the expression.
4046 * "arg" is advanced to the next non-white after the recognized expression.
4047 *
4048 * Return OK or FAIL.
4049 */
4050 static int
4055 {
4056 typval_T var2;
4065 regmatch_T regmatch;
4069 /*
4070 * Get the first variable.
4071 */
4077 {
4089 {
4092 }
4093 else
4097 {
4100 }
4101 else
4105 {
4109 {
4112 }
4113 }
4115 }
4117 /*
4118 * If there is a comparitive operator, use it.
4119 */
4121 {
4122 /* extra question mark appended: ignore case */
4124 {
4127 }
4128 /* extra '#' appended: match case */
4130 {
4133 }
4134 /* nothing appened: use 'ignorecase' */
4135 else
4138 /*
4139 * Get the second variable.
4140 */
4143 {
4146 }
4149 {
4151 {
4152 /* For "is" a different type always means FALSE, for "notis"
4153 * it means TRUE. */
4155 }
4157 {
4159 {
4164 }
4167 {
4170 else
4175 }
4176 else
4177 {
4178 /* Compare two Lists for being equal or unequal. */
4182 }
4183 }
4186 {
4188 {
4193 }
4196 {
4199 else
4204 }
4205 else
4206 {
4207 /* Compare two Dictionaries for being equal or unequal. */
4211 }
4212 }
4215 {
4218 {
4221 else
4226 }
4227 else
4228 {
4229 /* Compare two Funcrefs for being equal or unequal. */
4233 else
4238 }
4239 }
4241 /*
4242 * If one of the two variables is a number, compare as a number.
4243 * When using "=~" or "!~", always compare as string.
4244 */
4247 {
4251 {
4261 }
4262 }
4263 else
4264 {
4269 else
4273 {
4283 /* avoid 'l' flag in 'cpoptions' */
4290 {
4295 }
4300 }
4301 }
4306 }
4307 }
4310 }
4312 /*
4313 * Handle fourth level expression:
4314 * + number addition
4315 * - number subtraction
4316 * . string concatenation
4317 *
4318 * "arg" must point to the first non-white of the expression.
4319 * "arg" is advanced to the next non-white after the recognized expression.
4320 *
4321 * Return OK or FAIL.
4322 */
4323 static int
4328 {
4329 typval_T var2;
4330 typval_T var3;
4337 /*
4338 * Get the first variable.
4339 */
4343 /*
4344 * Repeat computing, until no '+', '-' or '.' is following.
4345 */
4347 {
4353 {
4354 /* For "list + ...", an illegal use of the first operand as
4355 * a number cannot be determined before evaluating the 2nd
4356 * operand: if this is also a list, all is ok.
4357 * For "something . ...", "something - ..." or "non-list + ...",
4358 * we know that the first operand needs to be a string or number
4359 * without evaluating the 2nd operand. So check before to avoid
4360 * side effects after an error. */
4362 {
4365 }
4366 }
4368 /*
4369 * Get the second variable.
4370 */
4373 {
4376 }
4379 {
4380 /*
4381 * Compute the result.
4382 */
4384 {
4388 {
4392 }
4397 }
4400 {
4401 /* concatenate Lists */
4404 {
4408 }
4411 }
4412 else
4413 {
4418 {
4419 /* This can only happen for "list + non-list".
4420 * For "non-list + ..." or "something - ...", we returned
4421 * before evaluating the 2nd operand. */
4424 }
4427 {
4431 }
4435 else
4439 }
4441 }
4442 }
4444 }
4446 /*
4447 * Handle fifth level expression:
4448 * * number multiplication
4449 * / number division
4450 * % number modulo
4451 *
4452 * "arg" must point to the first non-white of the expression.
4453 * "arg" is advanced to the next non-white after the recognized expression.
4454 *
4455 * Return OK or FAIL.
4456 */
4457 static int
4462 {
4463 typval_T var2;
4468 /*
4469 * Get the first variable.
4470 */
4474 /*
4475 * Repeat computing, until no '*', '/' or '%' is following.
4476 */
4478 {
4484 {
4489 }
4490 else
4493 /*
4494 * Get the second variable.
4495 */
4501 {
4507 /*
4508 * Compute the result.
4509 */
4513 {
4516 else
4518 }
4519 else
4520 {
4523 else
4525 }
4528 }
4529 }
4532 }
4534 /*
4535 * Handle sixth level expression:
4536 * number number constant
4537 * "string" string constant
4538 * 'string' literal string constant
4539 * &option-name option value
4540 * @r register contents
4541 * identifier variable value
4542 * function() function call
4543 * $VAR environment variable
4544 * (expression) nested expression
4545 * [expr, expr] List
4546 * {key: val, key: val} Dictionary
4547 *
4548 * Also handle:
4549 * ! in front logical NOT
4550 * - in front unary minus
4551 * + in front unary plus (ignored)
4552 * trailing [] subscript in String or List
4553 * trailing .name entry in Dictionary
4554 *
4555 * "arg" must point to the first non-white of the expression.
4556 * "arg" is advanced to the next non-white after the recognized expression.
4557 *
4558 * Return OK or FAIL.
4559 */
4560 static int
4565 {
4574 /*
4575 * Initialise variable so that clear_tv() can't mistake this for a
4576 * string and free a string that isn't there.
4577 */
4580 /*
4581 * Skip '!' and '-' characters. They are handled later.
4582 */
4589 {
4590 /*
4591 * Number constant.
4592 */
4606 {
4609 }
4612 /*
4613 * String constant: "string".
4614 */
4618 /*
4619 * Literal string constant: 'str''ing'.
4620 */
4624 /*
4625 * List: [expr, expr]
4626 */
4630 /*
4631 * Dictionary: {key: val, key: val}
4632 */
4636 /*
4637 * Option value: &name
4638 */
4642 /*
4643 * Environment variable: $VAR.
4644 */
4648 /*
4649 * Register contents: @r.
4650 */
4653 {
4656 }
4661 /*
4662 * nested expression: (expression).
4663 */
4669 {
4673 }
4678 }
4681 {
4682 /*
4683 * Must be a variable or function name.
4684 * Can also be a curly-braces kind of name: {expr}.
4685 */
4693 else
4694 {
4696 {
4697 /* If "s" is the name of a variable of type VAR_FUNC
4698 * use its contents. */
4701 /* Invoke the function. */
4705 /* Stop the expression evaluation when immediately
4706 * aborting on error, or when an interrupt occurred or
4707 * an exception was thrown but not caught. */
4709 {
4713 }
4714 }
4717 else
4719 }
4723 }
4727 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4728 * expr(expr). */
4732 /*
4733 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4734 */
4736 {
4741 {
4744 }
4745 else
4746 {
4748 {
4754 }
4758 }
4759 }
4762 }
4764 /*
4765 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4766 * "*arg" points to the '[' or '.'.
4767 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4768 */
4769 static int
4775 {
4785 {
4789 }
4792 {
4793 /*
4794 * dict.name
4795 */
4798 ;
4802 }
4803 else
4804 {
4805 /*
4806 * something[idx]
4807 *
4808 * Get the (first) variable from inside the [].
4809 */
4816 {
4817 /* not a number or string */
4820 }
4822 /*
4823 * Get the second variable from inside the [:].
4824 */
4826 {
4832 {
4836 }
4838 {
4839 /* not a number or string */
4844 }
4845 }
4847 /* Check for the ']'. */
4849 {
4856 }
4858 }
4861 {
4864 {
4867 }
4869 {
4872 else
4873 {
4876 }
4877 }
4880 {
4886 {
4887 /* The resulting variable is a substring. If the indexes
4888 * are out of range the result is empty. */
4890 {
4894 }
4901 else
4903 }
4904 else
4905 {
4906 /* The resulting variable is a string of a single
4907 * character. If the index is too big or negative the
4908 * result is empty. */
4911 else
4913 }
4924 {
4925 /* For a range we allow invalid values and return an empty
4926 * list. A list index out of range is an error. */
4928 {
4932 }
4934 }
4936 {
4951 {
4953 {
4956 }
4958 }
4963 }
4964 else
4965 {
4969 }
4974 {
4980 }
4981 {
4985 {
4988 {
4993 }
4994 }
5008 }
5010 }
5011 }
5014 }
5016 /*
5017 * Get an option value.
5018 * "arg" points to the '&' or '+' before the option name.
5019 * "arg" is advanced to character after the option name.
5020 * Return OK or FAIL.
5021 */
5022 static int
5027 {
5037 /*
5038 * Isolate the option name and find its value.
5039 */
5042 {
5046 }
5049 {
5052 }
5060 {
5064 }
5066 {
5068 {
5071 }
5073 {
5076 }
5078 {
5081 }
5083 {
5086 }
5087 }
5095 }
5097 /*
5098 * Allocate a variable for a string constant.
5099 * Return OK or FAIL.
5100 */
5101 static int
5106 {
5111 /*
5112 * Find the end of the string, skipping backslashed characters.
5113 */
5115 {
5117 {
5119 /* A "\<x>" form occupies at least 4 characters, and produces up
5120 * to 6 characters: reserve space for 2 extra */
5123 }
5124 }
5127 {
5130 }
5132 /* If only parsing, set *arg and return here */
5134 {
5137 }
5139 /*
5140 * Copy the string into allocated memory, handling backslashed
5141 * characters.
5142 */
5150 {
5152 {
5154 {
5167 {
5173 else
5177 {
5180 }
5182 #ifdef FEAT_MBYTE
5183 /* For "\u" store the number according to
5184 * 'encoding'. */
5187 else
5188 #endif
5190 }
5193 /* octal: "\1", "\12", "\123" */
5203 {
5207 }
5211 /* Special key, e.g.: "\<C-W>" */
5214 {
5217 }
5218 /* FALLTHROUGH */
5222 }
5223 }
5224 else
5227 }
5232 }
5234 /*
5235 * Allocate a variable for a 'str''ing' constant.
5236 * Return OK or FAIL.
5237 */
5238 static int
5243 {
5248 /*
5249 * Find the end of the string, skipping ''.
5250 */
5252 {
5254 {
5259 }
5260 }
5263 {
5266 }
5268 /* If only parsing return after setting "*arg" */
5270 {
5273 }
5275 /*
5276 * Copy the string into allocated memory, handling '' to ' reduction.
5277 */
5285 {
5287 {
5291 }
5293 }
5298 }
5300 /*
5301 * Allocate a variable for a List and fill it from "*arg".
5302 * Return OK or FAIL.
5303 */
5304 static int
5309 {
5311 typval_T tv;
5315 {
5319 }
5323 {
5327 {
5330 {
5334 }
5335 else
5337 }
5342 {
5345 }
5347 }
5350 {
5352 failret:
5356 }
5360 {
5364 }
5367 }
5369 /*
5370 * Allocate an empty header for a list.
5371 * Caller should take care of the reference count.
5372 */
5373 list_T *
5375 {
5380 {
5381 /* Prepend the list to the list of lists for garbage collection. */
5387 }
5389 }
5391 /*
5392 * Allocate an empty list for a return value.
5393 * Returns OK or FAIL.
5394 */
5395 static int
5398 {
5408 }
5410 /*
5411 * Unreference a list: decrement the reference count and free it when it
5412 * becomes zero.
5413 */
5414 void
5417 {
5420 }
5422 /*
5423 * Free a list, including all items it points to.
5424 * Ignores the reference count.
5425 */
5426 void
5430 {
5433 /* Remove the list from the list of lists for garbage collection. */
5436 else
5442 {
5443 /* Remove the item before deleting it. */
5449 }
5451 }
5453 /*
5454 * Allocate a list item.
5455 */
5458 {
5460 }
5462 /*
5463 * Free a list item. Also clears the value. Does not notify watchers.
5464 */
5465 static void
5468 {
5471 }
5473 /*
5474 * Remove a list item from a List and free it. Also clears the value.
5475 */
5476 static void
5480 {
5483 }
5485 /*
5486 * Get the number of items in a list.
5487 */
5488 static long
5491 {
5495 }
5497 /*
5498 * Return TRUE when two lists have exactly the same values.
5499 */
5500 static int
5505 {
5519 }
5521 #if defined(FEAT_PYTHON) || defined(PROTO)
5522 /*
5523 * Return the dictitem that an entry in a hashtable points to.
5524 */
5525 dictitem_T *
5528 {
5530 }
5531 #endif
5533 /*
5534 * Return TRUE when two dictionaries have exactly the same key/values.
5535 */
5536 static int
5541 {
5553 {
5555 {
5562 }
5563 }
5565 }
5567 /*
5568 * Return TRUE if "tv1" and "tv2" have the same value.
5569 * Compares the items just like "==" would compare them, but strings and
5570 * numbers are different.
5571 */
5572 static int
5577 {
5585 /* Catch lists and dicts that have an endless loop by limiting
5586 * recursiveness to 1000. We guess they are equal then. */
5591 {
5616 }
5620 }
5622 /*
5623 * Locate item with index "n" in list "l" and return it.
5624 * A negative index is counted from the end; -1 is the last item.
5625 * Returns NULL when "n" is out of range.
5626 */
5631 {
5638 /* Negative index is relative to the end. */
5642 /* Check for index out of range. */
5646 /* When there is a cached index may start search from there. */
5648 {
5650 {
5651 /* closest to the start of the list */
5654 }
5656 {
5657 /* closest to the end of the list */
5660 }
5661 else
5662 {
5663 /* closest to the cached index */
5666 }
5667 }
5668 else
5669 {
5671 {
5672 /* closest to the start of the list */
5675 }
5676 else
5677 {
5678 /* closest to the end of the list */
5681 }
5682 }
5685 {
5686 /* search forward */
5689 }
5691 {
5692 /* search backward */
5695 }
5697 /* cache the used index */
5702 }
5704 /*
5705 * Get list item "l[idx]" as a number.
5706 */
5707 static long
5712 {
5717 {
5721 }
5723 }
5725 /*
5726 * Locate "item" list "l" and return its index.
5727 * Returns -1 when "item" is not in the list.
5728 */
5729 static long
5733 {
5745 }
5747 /*
5748 * Append item "item" to the end of list "l".
5749 */
5750 static void
5754 {
5756 {
5757 /* empty list */
5761 }
5762 else
5763 {
5767 }
5770 }
5772 /*
5773 * Append typval_T "tv" to the end of list "l".
5774 * Return FAIL when out of memory.
5775 */
5776 static int
5780 {
5788 }
5790 /*
5791 * Add a dictionary to a list. Used by getqflist().
5792 * Return FAIL when out of memory.
5793 */
5794 int
5798 {
5809 }
5811 /*
5812 * Make a copy of "str" and append it as an item to list "l".
5813 * When "len" >= 0 use "str[len]".
5814 * Returns FAIL when out of memory.
5815 */
5816 static int
5821 {
5835 }
5837 /*
5838 * Append "n" to list "l".
5839 * Returns FAIL when out of memory.
5840 */
5841 static int
5844 varnumber_T n;
5845 {
5856 }
5858 /*
5859 * Insert typval_T "tv" in list "l" before "item".
5860 * If "item" is NULL append at the end.
5861 * Return FAIL when out of memory.
5862 */
5863 static int
5868 {
5875 /* Append new item at end of list. */
5877 else
5878 {
5879 /* Insert new item before existing item. */
5883 {
5886 }
5887 else
5888 {
5891 }
5894 }
5896 }
5898 /*
5899 * Extend "l1" with "l2".
5900 * If "bef" is NULL append at the end, otherwise insert before this item.
5901 * Returns FAIL when out of memory.
5902 */
5903 static int
5908 {
5915 }
5917 /*
5918 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5919 * Return FAIL when out of memory.
5920 */
5921 static int
5926 {
5929 /* make a copy of the first list. */
5936 /* append all items from the second list */
5938 }
5940 /*
5941 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5942 * The refcount of the new list is set to 1.
5943 * See item_copy() for "copyID".
5944 * Returns NULL when out of memory.
5945 */
5951 {
5961 {
5963 {
5964 /* Do this before adding the items, because one of the items may
5965 * refer back to this list. */
5968 }
5971 {
5976 {
5978 {
5981 }
5982 }
5983 else
5986 }
5989 {
5992 }
5993 }
5996 }
5998 /*
5999 * Remove items "item" to "item2" from list "l".
6000 * Does not free the listitem or the value!
6001 */
6002 static void
6007 {
6010 /* notify watchers */
6012 {
6017 }
6021 else
6025 else
6028 }
6030 /*
6031 * Return an allocated string with the string representation of a list.
6032 * May return NULL.
6033 */
6038 {
6039 garray_T ga;
6046 {
6049 }
6053 }
6055 /*
6056 * Join list "l" into a string in "*gap", using separator "sep".
6057 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6058 * Return FAIL or OK.
6059 */
6060 static int
6067 {
6075 {
6078 else
6083 else
6090 }
6092 }
6094 /*
6095 * Garbage collection for lists and dictionaries.
6096 *
6097 * We use reference counts to be able to free most items right away when they
6098 * are no longer used. But for composite items it's possible that it becomes
6099 * unused while the reference count is > 0: When there is a recursive
6100 * reference. Example:
6101 * :let l = [1, 2, 3]
6102 * :let d = {9: l}
6103 * :let l[1] = d
6104 *
6105 * Since this is quite unusual we handle this with garbage collection: every
6106 * once in a while find out which lists and dicts are not referenced from any
6107 * variable.
6108 *
6109 * Here is a good reference text about garbage collection (refers to Python
6110 * but it applies to all reference-counting mechanisms):
6111 * http://python.ca/nas/python/gc/
6112 */
6114 /*
6115 * Do garbage collection for lists and dicts.
6116 * Return TRUE if some memory was freed.
6117 */
6118 int
6120 {
6129 #ifdef FEAT_WINDOWS
6131 #endif
6133 /* Only do this once. */
6138 /*
6139 * 1. Go through all accessible variables and mark all lists and dicts
6140 * with copyID.
6141 */
6142 /* script-local variables */
6146 /* buffer-local variables */
6150 /* window-local variables */
6154 #ifdef FEAT_WINDOWS
6155 /* tabpage-local variables */
6158 #endif
6160 /* global variables */
6163 /* function-local variables */
6165 {
6168 }
6170 /*
6171 * 2. Go through the list of dicts and free items without the copyID.
6172 */
6175 {
6176 /* Free the Dictionary and ordinary items it contains, but don't
6177 * recurse into Lists and Dictionaries, they will be in the list
6178 * of dicts or list of lists. */
6182 /* restart, next dict may also have been freed */
6184 }
6185 else
6188 /*
6189 * 3. Go through the list of lists and free items without the copyID.
6190 * But don't free a list that has a watcher (used in a for loop), these
6191 * are not referenced anywhere.
6192 */
6195 {
6196 /* Free the List and ordinary items it contains, but don't recurse
6197 * into Lists and Dictionaries, they will be in the list of dicts
6198 * or list of lists. */
6202 /* restart, next list may also have been freed */
6204 }
6205 else
6209 }
6211 /*
6212 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6213 */
6214 static void
6218 {
6225 {
6228 }
6229 }
6231 /*
6232 * Mark all lists and dicts referenced through list "l" with "copyID".
6233 */
6234 static void
6238 {
6243 }
6245 /*
6246 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6247 */
6248 static void
6252 {
6257 {
6261 {
6262 /* Didn't see this dict yet. */
6265 }
6271 {
6272 /* Didn't see this list yet. */
6275 }
6277 }
6279 }
6281 /*
6282 * Allocate an empty header for a dictionary.
6283 */
6284 dict_T *
6286 {
6291 {
6292 /* Add the list to the list of dicts for garbage collection. */
6303 }
6305 }
6307 /*
6308 * Unreference a Dictionary: decrement the reference count and free it when it
6309 * becomes zero.
6310 */
6311 static void
6314 {
6317 }
6319 /*
6320 * Free a Dictionary, including all items it contains.
6321 * Ignores the reference count.
6322 */
6323 static void
6327 {
6332 /* Remove the dict from the list of dicts for garbage collection. */
6335 else
6340 /* Lock the hashtab, we don't want it to resize while freeing items. */
6344 {
6346 {
6347 /* Remove the item before deleting it, just in case there is
6348 * something recursive causing trouble. */
6356 }
6357 }
6360 }
6362 /*
6363 * Allocate a Dictionary item.
6364 * The "key" is copied to the new item.
6365 * Note that the value of the item "di_tv" still needs to be initialized!
6366 * Returns NULL when out of memory.
6367 */
6371 {
6376 {
6379 }
6381 }
6383 /*
6384 * Make a copy of a Dictionary item.
6385 */
6389 {
6395 {
6399 }
6401 }
6403 /*
6404 * Remove item "item" from Dictionary "dict" and free it.
6405 */
6406 static void
6410 {
6416 else
6419 }
6421 /*
6422 * Free a dict item. Also clears the value.
6423 */
6424 static void
6427 {
6430 }
6432 /*
6433 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6434 * The refcount of the new dict is set to 1.
6435 * See item_copy() for "copyID".
6436 * Returns NULL when out of memory.
6437 */
6443 {
6454 {
6456 {
6459 }
6462 {
6464 {
6471 {
6474 {
6477 }
6478 }
6479 else
6482 {
6485 }
6486 }
6487 }
6491 {
6494 }
6495 }
6498 }
6500 /*
6501 * Add item "item" to Dictionary "d".
6502 * Returns FAIL when out of memory and when key already existed.
6503 */
6504 static int
6508 {
6510 }
6512 /*
6513 * Add a number or string entry to dictionary "d".
6514 * When "str" is NULL use number "nr", otherwise use "str".
6515 * Returns FAIL when out of memory and when key already exists.
6516 */
6517 int
6523 {
6531 {
6534 }
6535 else
6536 {
6539 }
6541 {
6544 }
6546 }
6548 /*
6549 * Get the number of items in a Dictionary.
6550 */
6551 static long
6554 {
6558 }
6560 /*
6561 * Find item "key[len]" in Dictionary "d".
6562 * If "len" is negative use strlen(key).
6563 * Returns NULL when not found.
6564 */
6570 {
6571 #define AKEYLEN 200
6580 {
6584 }
6585 else
6586 {
6587 /* Avoid a malloc/free by using buf[]. */
6590 }
6597 }
6599 /*
6600 * Get a string item from a dictionary.
6601 * When "save" is TRUE allocate memory for it.
6602 * Returns NULL if the entry doesn't exist or out of memory.
6603 */
6604 char_u *
6609 {
6620 }
6622 /*
6623 * Get a number item from a dictionary.
6624 * Returns 0 if the entry doesn't exist or out of memory.
6625 */
6626 long
6630 {
6637 }
6639 /*
6640 * Return an allocated string with the string representation of a Dictionary.
6641 * May return NULL.
6642 */
6647 {
6648 garray_T ga;
6664 {
6666 {
6671 else
6676 {
6679 }
6687 }
6688 }
6690 {
6693 }
6698 }
6700 /*
6701 * Allocate a variable for a Dictionary and fill it from "*arg".
6702 * Return OK or FAIL. Returns NOTDONE for {expr}.
6703 */
6704 static int
6709 {
6711 typval_T tvkey;
6712 typval_T tv;
6718 /*
6719 * First check if it's not a curly-braces thing: {expr}.
6720 * Must do this without evaluating, otherwise a function may be called
6721 * twice. Unfortunately this means we need to call eval1() twice for the
6722 * first item.
6723 * But {} is an empty Dictionary.
6724 */
6726 {
6731 }
6734 {
6738 }
6744 {
6748 {
6752 }
6754 {
6757 {
6758 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6763 }
6764 }
6768 {
6772 }
6774 {
6777 {
6782 }
6786 {
6791 }
6792 }
6797 {
6800 }
6802 }
6805 {
6807 failret:
6811 }
6815 {
6819 }
6822 }
6824 /*
6825 * Return a string with the string representation of a variable.
6826 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6827 * "numbuf" is used for a number.
6828 * Does not put quotes around strings, as ":echo" displays values.
6829 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6830 * May return NULL.
6831 */
6838 {
6843 {
6847 }
6851 {
6859 {
6862 }
6864 {
6867 }
6868 else
6869 {
6873 }
6878 {
6881 }
6883 {
6886 }
6887 else
6888 {
6892 }
6904 }
6908 }
6910 /*
6911 * Return a string with the string representation of a variable.
6912 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6913 * "numbuf" is used for a number.
6914 * Puts quotes around strings, so that they can be parsed back by eval().
6915 * May return NULL.
6916 */
6923 {
6925 {
6938 }
6940 }
6942 /*
6943 * Return string "str" in ' quotes, doubling ' characters.
6944 * If "str" is NULL an empty string is assumed.
6945 * If "function" is TRUE make it function('string').
6946 */
6951 {
6957 {
6962 }
6965 {
6967 {
6970 }
6971 else
6975 {
6979 }
6984 }
6986 }
6988 /*
6989 * Get the value of an environment variable.
6990 * "arg" is pointing to the '$'. It is advanced to after the name.
6991 * If the environment variable was not set, silently assume it is empty.
6992 * Always return OK.
6993 */
6994 static int
6999 {
7010 {
7012 {
7015 /* first try vim_getenv(), fast for normal environment vars */
7018 {
7021 }
7022 else
7023 {
7027 /* next try expanding things like $VIM and ${HOME} */
7030 {
7033 }
7034 }
7036 }
7039 }
7042 }
7044 /*
7045 * Array with names and number of arguments of all internal functions
7046 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7047 */
7048 static struct fst
7049 {
7054 /* implementation of function */
7056 {
7081 #if defined(FEAT_INS_EXPAND)
7085 #endif
7197 #ifdef vim_mkdir
7199 #endif
7246 #ifdef HAVE_STRFTIME
7248 #endif
7286 };
7288 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7290 /*
7291 * Function given to ExpandGeneric() to obtain the list of internal
7292 * or user defined function names.
7293 */
7294 char_u *
7298 {
7305 {
7309 }
7311 {
7317 }
7320 }
7322 /*
7323 * Function given to ExpandGeneric() to obtain the list of internal or
7324 * user defined variable or function names.
7325 */
7326 /*ARGSUSED*/
7327 char_u *
7331 {
7338 {
7342 }
7344 }
7348 /*
7349 * Find internal function in table above.
7350 * Return index, or -1 if not found
7351 */
7352 static int
7355 {
7361 /*
7362 * Find the function name in the table. Binary search.
7363 */
7365 {
7372 else
7374 }
7376 }
7378 /*
7379 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7380 * name it contains, otherwise return "name".
7381 */
7386 {
7395 {
7397 {
7400 }
7403 }
7406 }
7408 /*
7409 * Allocate a variable for the result of a function.
7410 * Return OK or FAIL.
7411 */
7412 static int
7424 {
7430 /*
7431 * Get the arguments.
7432 */
7435 {
7440 {
7443 }
7447 }
7450 else
7457 {
7460 else
7462 }
7469 }
7472 /*
7473 * Call a function with its resolved parameters
7474 * Return OK when the function can't be called, FAIL otherwise.
7475 * Also returns OK when an error was encountered while executing the function.
7476 */
7477 static int
7485 PLUS ONE elements! */
7491 {
7493 #define ERROR_UNKNOWN 0
7494 #define ERROR_TOOMANY 1
7495 #define ERROR_TOOFEW 2
7496 #define ERROR_SCRIPT 3
7497 #define ERROR_DICT 4
7498 #define ERROR_NONE 5
7499 #define ERROR_OTHER 6
7505 #define FLEN_FIXED 40
7509 /*
7510 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7511 * Change <SNR>123_name() to K_SNR 123_name().
7512 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7513 */
7518 {
7524 {
7527 else
7528 {
7531 }
7532 }
7534 {
7537 }
7538 else
7539 {
7543 else
7544 {
7547 }
7548 }
7549 }
7550 else
7556 /* execute the function if no errors detected and executing */
7558 {
7563 {
7564 /*
7565 * User defined function.
7566 */
7569 #ifdef FEAT_AUTOCMD
7570 /* Trigger FuncUndefined event, may load the function. */
7575 {
7576 /* executed an autocommand, search for the function again */
7578 }
7579 #endif
7580 /* Try loading a package. */
7582 {
7583 /* loaded a package, search for the function again */
7585 }
7588 {
7597 else
7598 {
7599 /*
7600 * Call the user function.
7601 * Save and restore search patterns, script variables and
7602 * redo buffer.
7603 */
7612 /* Function was unreferenced while being used, free it
7613 * now. */
7618 }
7619 }
7620 }
7621 else
7622 {
7623 /*
7624 * Find the function name in the table, call its implementation.
7625 */
7628 {
7633 else
7634 {
7638 }
7639 }
7640 }
7641 /*
7642 * The function call (or "FuncUndefined" autocommand sequence) might
7643 * have been aborted by an error, an interrupt, or an explicitly thrown
7644 * exception that has not been caught so far. This situation can be
7645 * tested for by calling aborting(). For an error in an internal
7646 * function or for the "E132" error in call_user_func(), however, the
7647 * throw point at which the "force_abort" flag (temporarily reset by
7648 * emsg()) is normally updated has not been reached yet. We need to
7649 * update that flag first to make aborting() reliable.
7650 */
7652 }
7656 /*
7657 * Report an error unless the argument evaluation or function call has been
7658 * cancelled due to an aborting error, an interrupt, or an exception.
7659 */
7661 {
7663 {
7672 name);
7676 name);
7680 name);
7682 }
7683 }
7690 }
7692 /*
7693 * Give an error message with a function name. Handle <SNR> things.
7694 */
7695 static void
7699 {
7704 else
7709 }
7711 /*********************************************
7712 * Implementation of the built-in functions
7713 */
7715 /*
7716 * "add(list, item)" function
7717 */
7718 static void
7722 {
7727 {
7732 }
7733 else
7735 }
7737 /*
7738 * "append(lnum, string/list)" function
7739 */
7740 static void
7744 {
7756 {
7758 {
7763 }
7766 {
7771 else
7775 {
7778 }
7784 }
7789 }
7790 else
7792 }
7794 /*
7795 * "argc()" function
7796 */
7797 /* ARGSUSED */
7798 static void
7802 {
7804 }
7806 /*
7807 * "argidx()" function
7808 */
7809 /* ARGSUSED */
7810 static void
7814 {
7816 }
7818 /*
7819 * "argv(nr)" function
7820 */
7821 static void
7825 {
7829 {
7833 else
7836 }
7841 }
7843 /*
7844 * "browse(save, title, initdir, default)" function
7845 */
7846 /* ARGSUSED */
7847 static void
7851 {
7852 #ifdef FEAT_BROWSE
7868 else
7872 #else
7874 #endif
7876 }
7878 /*
7879 * "browsedir(title, initdir)" function
7880 */
7881 /* ARGSUSED */
7882 static void
7886 {
7887 #ifdef FEAT_BROWSE
7897 else
7900 #else
7902 #endif
7904 }
7908 /*
7909 * Find a buffer by number or exact name.
7910 */
7914 {
7920 {
7923 {
7924 /* No full path name match, try a match with a URL or a "nofile"
7925 * buffer, these don't use the full path. */
7929 #ifdef FEAT_QUICKFIX
7931 #endif
7932 )
7935 }
7936 }
7938 }
7940 /*
7941 * "bufexists(expr)" function
7942 */
7943 static void
7947 {
7949 }
7951 /*
7952 * "buflisted(expr)" function
7953 */
7954 static void
7958 {
7963 }
7965 /*
7966 * "bufloaded(expr)" function
7967 */
7968 static void
7972 {
7977 }
7981 /*
7982 * Get buffer by number or pattern.
7983 */
7987 {
8002 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8014 /* If not found, try expanding the name, like done for bufexists(). */
8019 }
8021 /*
8022 * "bufname(expr)" function
8023 */
8024 static void
8028 {
8037 else
8040 }
8042 /*
8043 * "bufnr(expr)" function
8044 */
8045 static void
8049 {
8059 /* If the buffer isn't found and the second argument is not zero create a
8060 * new buffer. */
8064 && !error
8071 else
8073 }
8075 /*
8076 * "bufwinnr(nr)" function
8077 */
8078 static void
8082 {
8083 #ifdef FEAT_WINDOWS
8086 #endif
8092 #ifdef FEAT_WINDOWS
8094 {
8098 }
8100 #else
8102 #endif
8104 }
8106 /*
8107 * "byte2line(byte)" function
8108 */
8109 /*ARGSUSED*/
8110 static void
8114 {
8115 #ifndef FEAT_BYTEOFF
8117 #else
8123 else
8126 #endif
8127 }
8129 /*
8130 * "byteidx()" function
8131 */
8132 /*ARGSUSED*/
8133 static void
8137 {
8138 #ifdef FEAT_MBYTE
8140 #endif
8150 #ifdef FEAT_MBYTE
8153 {
8157 }
8159 #else
8162 #endif
8163 }
8165 /*
8166 * "call(func, arglist)" function
8167 */
8168 static void
8172 {
8182 {
8185 }
8191 else
8197 {
8199 {
8202 }
8204 }
8208 {
8210 {
8213 }
8214 /* Make a copy of each argument. This is needed to be able to set
8215 * v_lock to VAR_FIXED in the copy without changing the original list.
8216 */
8218 }
8225 /* Free the arguments. */
8228 }
8230 /*
8231 * "changenr()" function
8232 */
8233 /*ARGSUSED*/
8234 static void
8238 {
8240 }
8242 /*
8243 * "char2nr(string)" function
8244 */
8245 static void
8249 {
8250 #ifdef FEAT_MBYTE
8253 else
8254 #endif
8256 }
8258 /*
8259 * "cindent(lnum)" function
8260 */
8261 static void
8265 {
8266 #ifdef FEAT_CINDENT
8267 pos_T pos;
8268 linenr_T lnum;
8273 {
8277 }
8278 else
8279 #endif
8281 }
8283 /*
8284 * "clearmatches()" function
8285 */
8286 /*ARGSUSED*/
8287 static void
8291 {
8292 #ifdef FEAT_SEARCH_EXTRA
8294 #endif
8295 }
8297 /*
8298 * "col(string)" function
8299 */
8300 static void
8304 {
8311 {
8313 {
8314 /* '> can be MAXCOL, get the length of the line then */
8317 else
8319 }
8320 else
8321 {
8323 #ifdef FEAT_VIRTUALEDIT
8324 /* col(".") when the cursor is on the NUL at the end of the line
8325 * because of "coladd" can be seen as an extra column. */
8327 {
8332 {
8333 # ifdef FEAT_MBYTE
8338 # else
8341 # endif
8342 }
8343 }
8344 #endif
8345 }
8346 }
8348 }
8350 #if defined(FEAT_INS_EXPAND)
8351 /*
8352 * "complete()" function
8353 */
8354 /*ARGSUSED*/
8355 static void
8359 {
8363 {
8366 }
8368 /* Check for undo allowed here, because if something was already inserted
8369 * the line was already saved for undo and this check isn't done. */
8374 {
8377 }
8384 }
8386 /*
8387 * "complete_add()" function
8388 */
8389 /*ARGSUSED*/
8390 static void
8394 {
8396 }
8398 /*
8399 * "complete_check()" function
8400 */
8401 /*ARGSUSED*/
8402 static void
8406 {
8413 }
8414 #endif
8416 /*
8417 * "confirm(message, buttons[, default [, type]])" function
8418 */
8419 /*ARGSUSED*/
8420 static void
8424 {
8425 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8439 {
8444 {
8447 {
8451 else
8452 {
8454 {
8460 }
8461 }
8462 }
8463 }
8464 }
8471 else
8474 #else
8476 #endif
8477 }
8479 /*
8480 * "copy()" function
8481 */
8482 static void
8486 {
8488 }
8490 /*
8491 * "count()" function
8492 */
8493 static void
8497 {
8502 {
8508 {
8511 {
8516 {
8519 {
8523 }
8524 }
8527 }
8532 }
8533 }
8535 {
8541 {
8545 {
8549 }
8553 {
8555 {
8559 }
8560 }
8561 }
8562 }
8563 else
8566 }
8568 /*
8569 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8570 *
8571 * Checks the existence of a cscope connection.
8572 */
8573 /*ARGSUSED*/
8574 static void
8578 {
8579 #ifdef FEAT_CSCOPE
8587 {
8592 }
8595 #else
8597 #endif
8598 }
8600 /*
8601 * "cursor(lnum, col)" function
8602 *
8603 * Moves the cursor to the specified line and column
8604 */
8605 /*ARGSUSED*/
8606 static void
8610 {
8612 #ifdef FEAT_VIRTUALEDIT
8614 #endif
8617 {
8618 pos_T pos;
8624 #ifdef FEAT_VIRTUALEDIT
8626 #endif
8627 }
8628 else
8629 {
8632 #ifdef FEAT_VIRTUALEDIT
8635 #endif
8636 }
8638 #ifdef FEAT_VIRTUALEDIT
8640 #endif
8641 )
8647 #ifdef FEAT_VIRTUALEDIT
8649 #endif
8651 /* Make sure the cursor is in a valid position. */
8653 #ifdef FEAT_MBYTE
8654 /* Correct cursor for multi-byte character. */
8657 #endif
8660 }
8662 /*
8663 * "deepcopy()" function
8664 */
8665 static void
8669 {
8676 else
8678 }
8680 /*
8681 * "delete()" function
8682 */
8683 static void
8687 {
8690 else
8692 }
8694 /*
8695 * "did_filetype()" function
8696 */
8697 /*ARGSUSED*/
8698 static void
8702 {
8703 #ifdef FEAT_AUTOCMD
8705 #else
8707 #endif
8708 }
8710 /*
8711 * "diff_filler()" function
8712 */
8713 /*ARGSUSED*/
8714 static void
8718 {
8719 #ifdef FEAT_DIFF
8721 #endif
8722 }
8724 /*
8725 * "diff_hlID()" function
8726 */
8727 /*ARGSUSED*/
8728 static void
8732 {
8733 #ifdef FEAT_DIFF
8749 {
8750 /* New line, buffer, change: need to get the values. */
8753 {
8755 {
8760 else
8762 }
8763 else
8765 }
8766 else
8771 }
8774 {
8778 else
8780 }
8782 #endif
8783 }
8785 /*
8786 * "empty({expr})" function
8787 */
8788 static void
8792 {
8796 {
8816 }
8819 }
8821 /*
8822 * "escape({string}, {chars})" function
8823 */
8824 static void
8828 {
8834 }
8836 /*
8837 * "eval()" function
8838 */
8839 /*ARGSUSED*/
8840 static void
8844 {
8852 {
8855 }
8858 }
8860 /*
8861 * "eventhandler()" function
8862 */
8863 /*ARGSUSED*/
8864 static void
8868 {
8870 }
8872 /*
8873 * "executable()" function
8874 */
8875 static void
8879 {
8881 }
8883 /*
8884 * "exists()" function
8885 */
8886 static void
8890 {
8898 {
8899 /* first try "normal" environment variables (fast) */
8902 else
8903 {
8904 /* try expanding things like $VIM and ${HOME} */
8909 }
8910 }
8912 {
8916 }
8918 {
8920 }
8922 {
8924 }
8926 {
8927 #ifdef FEAT_AUTOCMD
8930 else
8932 #endif
8933 }
8935 {
8937 typval_T tv;
8939 /* get_name_len() takes care of expanding curly braces */
8943 {
8948 {
8949 /* handle d.key, l[idx], f(expr) */
8953 }
8954 }
8959 }
8962 }
8964 /*
8965 * "expand()" function
8966 */
8967 static void
8971 {
8976 expand_T xpc;
8982 {
8986 }
8987 else
8988 {
8989 /* When the optional second argument is non-zero, don't remove matches
8990 * for 'suffixes' and 'wildignore' */
8995 {
8999 }
9000 else
9002 }
9003 }
9005 /*
9006 * "extend(list, list [, idx])" function
9007 * "extend(dict, dict [, action])" function
9008 */
9009 static void
9013 {
9016 {
9026 {
9028 {
9035 else
9036 {
9039 {
9042 }
9043 }
9044 }
9045 else
9050 }
9051 }
9053 {
9065 {
9066 /* Check the third argument. */
9068 {
9078 {
9081 }
9082 }
9083 else
9086 /* Go over all entries in the second dict and add them to the
9087 * first dict. */
9090 {
9092 {
9096 {
9100 }
9102 {
9105 }
9107 {
9110 }
9111 }
9112 }
9115 }
9116 }
9117 else
9119 }
9121 /*
9122 * "feedkeys()" function
9123 */
9124 /*ARGSUSED*/
9125 static void
9129 {
9136 /* This is not allowed in the sandbox. If the commands would still be
9137 * executed in the sandbox it would be OK, but it probably happens later,
9138 * when "sandbox" is no longer set. */
9145 {
9147 {
9150 {
9152 {
9156 }
9157 }
9158 }
9160 /* Need to escape K_SPECIAL and CSI before putting the string in the
9161 * typeahead buffer. */
9164 {
9170 }
9171 }
9172 }
9174 /*
9175 * "filereadable()" function
9176 */
9177 static void
9181 {
9188 {
9191 }
9192 else
9196 }
9198 /*
9199 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9200 * rights to write into.
9201 */
9202 static void
9206 {
9208 }
9212 static void
9217 {
9218 #ifdef FEAT_SEARCHPATH
9227 #endif
9232 #ifdef FEAT_SEARCHPATH
9236 {
9240 else
9241 {
9247 }
9248 }
9254 {
9255 do
9256 {
9262 find_what,
9264 find_what == FINDFILE_DIR
9272 }
9276 #endif
9277 }
9282 /*
9283 * Implementation of map() and filter().
9284 */
9285 static void
9290 {
9299 typval_T save_val;
9300 typval_T save_key;
9308 {
9312 }
9314 {
9318 }
9319 else
9320 {
9323 }
9326 /* On type errors, the preceding call has already displayed an error
9327 * message. Avoid a misleading error message for an empty string that
9328 * was not passed as argument. */
9330 {
9334 /* We reset "did_emsg" to be able to detect whether an error
9335 * occurred during evaluation of the expression. */
9340 {
9348 {
9350 {
9362 }
9363 }
9367 }
9368 else
9369 {
9371 {
9380 }
9381 }
9386 }
9389 }
9391 static int
9397 {
9398 typval_T rettv;
9407 {
9410 }
9412 {
9413 /* map(): replace the list item value */
9417 }
9418 else
9419 {
9422 /* filter(): when expr is zero remove the item */
9425 /* On type error, nothing has been removed; return FAIL to stop the
9426 * loop. The error message was given by get_tv_number_chk(). */
9429 }
9431 theend:
9434 }
9436 /*
9437 * "filter()" function
9438 */
9439 static void
9443 {
9445 }
9447 /*
9448 * "finddir({fname}[, {path}[, {count}]])" function
9449 */
9450 static void
9454 {
9456 }
9458 /*
9459 * "findfile({fname}[, {path}[, {count}]])" function
9460 */
9461 static void
9465 {
9467 }
9469 /*
9470 * "fnameescape({string})" function
9471 */
9472 static void
9476 {
9480 }
9482 /*
9483 * "fnamemodify({fname}, {mods})" function
9484 */
9485 static void
9489 {
9501 else
9502 {
9505 }
9510 else
9513 }
9517 /*
9518 * "foldclosed()" function
9519 */
9520 static void
9525 {
9526 #ifdef FEAT_FOLDING
9527 linenr_T lnum;
9532 {
9534 {
9537 else
9540 }
9541 }
9542 #endif
9544 }
9546 /*
9547 * "foldclosed()" function
9548 */
9549 static void
9553 {
9555 }
9557 /*
9558 * "foldclosedend()" function
9559 */
9560 static void
9564 {
9566 }
9568 /*
9569 * "foldlevel()" function
9570 */
9571 static void
9575 {
9576 #ifdef FEAT_FOLDING
9577 linenr_T lnum;
9582 else
9583 #endif
9585 }
9587 /*
9588 * "foldtext()" function
9589 */
9590 /*ARGSUSED*/
9591 static void
9595 {
9596 #ifdef FEAT_FOLDING
9597 linenr_T lnum;
9602 #endif
9606 #ifdef FEAT_FOLDING
9611 {
9612 /* Find first non-empty line in the fold. */
9615 {
9619 }
9621 /* Find interesting text in this line. */
9623 /* skip C comment-start */
9625 {
9629 {
9633 }
9634 }
9641 {
9647 /* remove 'foldmarker' and 'commentstring' */
9650 }
9651 }
9652 #endif
9653 }
9655 /*
9656 * "foldtextresult(lnum)" function
9657 */
9658 /*ARGSUSED*/
9659 static void
9663 {
9664 #ifdef FEAT_FOLDING
9665 linenr_T lnum;
9668 foldinfo_T foldinfo;
9670 #endif
9674 #ifdef FEAT_FOLDING
9676 /* treat illegal types and illegal string values for {lnum} the same */
9681 {
9687 }
9688 #endif
9689 }
9691 /*
9692 * "foreground()" function
9693 */
9694 /*ARGSUSED*/
9695 static void
9699 {
9701 #ifdef FEAT_GUI
9704 #else
9705 # ifdef WIN32
9707 # endif
9708 #endif
9709 }
9711 /*
9712 * "function()" function
9713 */
9714 /*ARGSUSED*/
9715 static void
9719 {
9728 else
9729 {
9732 }
9733 }
9735 /*
9736 * "garbagecollect()" function
9737 */
9738 /*ARGSUSED*/
9739 static void
9743 {
9744 /* This is postponed until we are back at the toplevel, because we may be
9745 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9750 }
9752 /*
9753 * "get()" function
9754 */
9755 static void
9759 {
9767 {
9769 {
9775 }
9776 }
9778 {
9780 {
9784 }
9785 }
9786 else
9790 {
9793 else
9795 }
9796 else
9798 }
9800 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9802 /*
9803 * Get line or list of lines from buffer "buf" into "rettv".
9804 * Return a range (from start to end) of lines in rettv from the specified
9805 * buffer.
9806 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9807 */
9808 static void
9811 linenr_T start;
9812 linenr_T end;
9815 {
9819 {
9822 }
9823 else
9830 {
9833 else
9838 }
9839 else
9840 {
9852 }
9853 }
9855 /*
9856 * "getbufline()" function
9857 */
9858 static void
9862 {
9863 linenr_T lnum;
9864 linenr_T end;
9875 else
9879 }
9881 /*
9882 * "getbufvar()" function
9883 */
9884 static void
9888 {
9903 {
9905 {
9906 /* set curbuf to be our buf, temporarily */
9912 /* restore previous notion of curbuf */
9914 }
9915 else
9916 {
9918 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9919 * scope prefix before the NUL byte is required by
9920 * find_var_in_ht(). */
9922 /* look up the variable */
9926 }
9927 }
9930 }
9932 /*
9933 * "getchar()" function
9934 */
9935 static void
9939 {
9940 varnumber_T n;
9943 /* Position the cursor. Needed after a message that ends in a space. */
9949 {
9951 /* getchar(): blocking wait. */
9954 /* getchar(1): only check if char avail */
9957 /* illegal argument or getchar(0) and no char avail: return zero */
9959 else
9960 /* getchar(0) and char avail: return char */
9965 }
9975 {
9979 /* Turn a special key into three bytes, plus modifier. */
9981 {
9985 }
9987 {
9991 }
9992 #ifdef FEAT_MBYTE
9995 #endif
9996 else
10002 #ifdef FEAT_MOUSE
10022 {
10026 linenr_T lnum;
10027 # ifdef FEAT_WINDOWS
10029 # endif
10033 {
10034 /* Find the window at the mouse coordinates and compute the
10035 * text position. */
10038 # ifdef FEAT_WINDOWS
10041 # endif
10045 }
10046 }
10047 #endif
10048 }
10049 }
10051 /*
10052 * "getcharmod()" function
10053 */
10054 /*ARGSUSED*/
10055 static void
10059 {
10061 }
10063 /*
10064 * "getcmdline()" function
10065 */
10066 /*ARGSUSED*/
10067 static void
10071 {
10074 }
10076 /*
10077 * "getcmdpos()" function
10078 */
10079 /*ARGSUSED*/
10080 static void
10084 {
10086 }
10088 /*
10089 * "getcmdtype()" function
10090 */
10091 /*ARGSUSED*/
10092 static void
10096 {
10100 {
10103 }
10104 }
10106 /*
10107 * "getcwd()" function
10108 */
10109 /*ARGSUSED*/
10110 static void
10114 {
10120 else
10121 {
10123 #ifdef BACKSLASH_IN_FILENAME
10126 #endif
10127 }
10128 }
10130 /*
10131 * "getfontname()" function
10132 */
10133 /*ARGSUSED*/
10134 static void
10138 {
10141 #ifdef FEAT_GUI
10143 {
10144 GuiFont font;
10148 {
10149 /* Get the "Normal" font. Either the name saved by
10150 * hl_set_font_name() or from the font ID. */
10153 }
10154 else
10155 {
10162 }
10166 }
10167 #endif
10168 }
10170 /*
10171 * "getfperm({fname})" function
10172 */
10173 static void
10177 {
10188 {
10191 {
10193 {
10196 }
10197 }
10198 }
10200 }
10202 /*
10203 * "getfsize({fname})" function
10204 */
10205 static void
10209 {
10218 {
10221 else
10222 {
10225 /* non-perfect check for overflow */
10228 }
10229 }
10230 else
10232 }
10234 /*
10235 * "getftime({fname})" function
10236 */
10237 static void
10241 {
10249 else
10251 }
10253 /*
10254 * "getftype({fname})" function
10255 */
10256 static void
10260 {
10270 {
10271 #ifdef S_ISREG
10276 # ifdef S_ISLNK
10279 # endif
10280 # ifdef S_ISBLK
10283 # endif
10284 # ifdef S_ISCHR
10287 # endif
10288 # ifdef S_ISFIFO
10291 # endif
10292 # ifdef S_ISSOCK
10295 # endif
10296 else
10298 #else
10299 # ifdef S_IFMT
10301 {
10304 # ifdef S_IFLNK
10306 # endif
10307 # ifdef S_IFBLK
10309 # endif
10310 # ifdef S_IFCHR
10312 # endif
10313 # ifdef S_IFIFO
10315 # endif
10316 # ifdef S_IFSOCK
10318 # endif
10320 }
10321 # else
10324 else
10326 # endif
10327 #endif
10329 }
10331 }
10333 /*
10334 * "getline(lnum, [end])" function
10335 */
10336 static void
10340 {
10341 linenr_T lnum;
10342 linenr_T end;
10347 {
10350 }
10351 else
10352 {
10355 }
10358 }
10360 /*
10361 * "getmatches()" function
10362 */
10363 /*ARGSUSED*/
10364 static void
10368 {
10369 #ifdef FEAT_SEARCH_EXTRA
10376 {
10378 {
10388 }
10389 }
10390 #endif
10391 }
10393 /*
10394 * "getpid()" function
10395 */
10396 /*ARGSUSED*/
10397 static void
10401 {
10403 }
10405 /*
10406 * "getpos(string)" function
10407 */
10408 static void
10412 {
10418 {
10423 else
10431 #ifdef FEAT_VIRTUALEDIT
10433 #endif
10435 }
10436 else
10438 }
10440 /*
10441 * "getqflist()" and "getloclist()" functions
10442 */
10443 /*ARGSUSED*/
10444 static void
10448 {
10449 #ifdef FEAT_QUICKFIX
10451 #endif
10454 #ifdef FEAT_QUICKFIX
10456 {
10459 {
10463 }
10466 }
10467 #endif
10468 }
10470 /*
10471 * "getreg()" function
10472 */
10473 static void
10477 {
10484 {
10489 }
10490 else
10499 }
10501 /*
10502 * "getregtype()" function
10503 */
10504 static void
10508 {
10515 {
10518 {
10522 }
10523 }
10524 else
10525 /* Default to v:register */
10535 {
10538 #ifdef FEAT_VISUAL
10543 #endif
10544 }
10547 }
10549 /*
10550 * "gettabwinvar()" function
10551 */
10552 static void
10556 {
10558 }
10560 /*
10561 * "getwinposx()" function
10562 */
10563 /*ARGSUSED*/
10564 static void
10568 {
10570 #ifdef FEAT_GUI
10572 {
10577 }
10578 #endif
10579 }
10581 /*
10582 * "getwinposy()" function
10583 */
10584 /*ARGSUSED*/
10585 static void
10589 {
10591 #ifdef FEAT_GUI
10593 {
10598 }
10599 #endif
10600 }
10602 /*
10603 * Find window specifed by "vp" in tabpage "tp".
10604 */
10609 {
10610 #ifdef FEAT_WINDOWS
10612 #endif
10617 #ifdef FEAT_WINDOWS
10628 #else
10632 #endif
10633 }
10635 /*
10636 * "getwinvar()" function
10637 */
10638 static void
10642 {
10644 }
10646 /*
10647 * getwinvar() and gettabwinvar()
10648 */
10649 static void
10654 {
10660 #ifdef FEAT_WINDOWS
10663 else
10665 #endif
10674 {
10675 /* Set curwin to be our win, temporarily. Also set curbuf, so
10676 * that we can get buffer-local options. */
10683 else
10684 {
10686 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10687 * scope prefix before the NUL byte is required by
10688 * find_var_in_ht(). */
10690 /* look up the variable */
10694 }
10696 /* restore previous notion of curwin */
10699 }
10702 }
10704 /*
10705 * "glob()" function
10706 */
10707 static void
10711 {
10712 expand_T xpc;
10719 }
10721 /*
10722 * "globpath()" function
10723 */
10724 static void
10728 {
10735 else
10737 }
10739 /*
10740 * "has()" function
10741 */
10742 static void
10746 {
10751 {
10752 #ifdef AMIGA
10754 # ifdef FEAT_ARP
10756 # endif
10757 #endif
10758 #ifdef __BEOS__
10760 #endif
10761 #ifdef MSDOS
10762 # ifdef DJGPP
10764 # else
10766 # endif
10767 #endif
10768 #ifdef MACOS
10770 #endif
10771 #if defined(MACOS_X_UNIX)
10773 #endif
10774 #ifdef OS2
10776 #endif
10777 #ifdef __QNX__
10779 #endif
10780 #ifdef RISCOS
10782 #endif
10783 #ifdef UNIX
10785 #endif
10786 #ifdef VMS
10788 #endif
10789 #ifdef WIN16
10791 #endif
10792 #ifdef WIN32
10794 #endif
10795 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10797 #endif
10798 #ifdef WIN64
10800 #endif
10801 #ifdef EBCDIC
10803 #endif
10804 #ifndef CASE_INSENSITIVE_FILENAME
10806 #endif
10807 #ifdef FEAT_ARABIC
10809 #endif
10810 #ifdef FEAT_AUTOCMD
10812 #endif
10813 #ifdef FEAT_BEVAL
10817 # endif
10818 #endif
10819 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10821 # ifdef ALL_BUILTIN_TCAPS
10823 # endif
10824 #endif
10825 #ifdef FEAT_BYTEOFF
10827 #endif
10828 #ifdef FEAT_CINDENT
10830 #endif
10831 #ifdef FEAT_CLIENTSERVER
10833 #endif
10834 #ifdef FEAT_CLIPBOARD
10836 #endif
10837 #ifdef FEAT_CMDL_COMPL
10839 #endif
10840 #ifdef FEAT_CMDHIST
10842 #endif
10843 #ifdef FEAT_COMMENTS
10845 #endif
10846 #ifdef FEAT_CRYPT
10848 #endif
10849 #ifdef FEAT_CSCOPE
10851 #endif
10852 #ifdef CURSOR_SHAPE
10854 #endif
10855 #ifdef DEBUG
10857 #endif
10858 #ifdef FEAT_CON_DIALOG
10860 #endif
10861 #ifdef FEAT_GUI_DIALOG
10863 #endif
10864 #ifdef FEAT_DIFF
10866 #endif
10867 #ifdef FEAT_DIGRAPHS
10869 #endif
10870 #ifdef FEAT_DND
10872 #endif
10873 #ifdef FEAT_EMACS_TAGS
10875 #endif
10877 #ifdef FEAT_EX_EXTRA
10879 #endif
10880 #ifdef FEAT_SEARCH_EXTRA
10882 #endif
10883 #ifdef FEAT_FKMAP
10885 #endif
10886 #ifdef FEAT_SEARCHPATH
10888 #endif
10889 #if defined(UNIX) && !defined(USE_SYSTEM)
10891 #endif
10892 #ifdef FEAT_FIND_ID
10894 #endif
10895 #ifdef FEAT_FOLDING
10897 #endif
10898 #ifdef FEAT_FOOTER
10900 #endif
10901 #if !defined(USE_SYSTEM) && defined(UNIX)
10903 #endif
10904 #ifdef FEAT_GETTEXT
10906 #endif
10907 #ifdef FEAT_GUI
10909 #endif
10910 #ifdef FEAT_GUI_ATHENA
10911 # ifdef FEAT_GUI_NEXTAW
10913 # else
10915 # endif
10916 #endif
10917 #ifdef FEAT_GUI_GTK
10919 # ifdef HAVE_GTK2
10921 # endif
10922 #endif
10923 #ifdef FEAT_GUI_GNOME
10925 #endif
10926 #ifdef FEAT_GUI_MAC
10928 #endif
10929 #ifdef FEAT_GUI_MOTIF
10931 #endif
10932 #ifdef FEAT_GUI_PHOTON
10934 #endif
10935 #ifdef FEAT_GUI_W16
10937 #endif
10938 #ifdef FEAT_GUI_W32
10940 #endif
10941 #ifdef FEAT_HANGULIN
10943 #endif
10944 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10946 #endif
10947 #ifdef FEAT_INS_EXPAND
10949 #endif
10950 #ifdef FEAT_JUMPLIST
10952 #endif
10953 #ifdef FEAT_KEYMAP
10955 #endif
10956 #ifdef FEAT_LANGMAP
10958 #endif
10959 #ifdef FEAT_LIBCALL
10961 #endif
10962 #ifdef FEAT_LINEBREAK
10964 #endif
10965 #ifdef FEAT_LISP
10967 #endif
10968 #ifdef FEAT_LISTCMDS
10970 #endif
10971 #ifdef FEAT_LOCALMAP
10973 #endif
10974 #ifdef FEAT_MENU
10976 #endif
10977 #ifdef FEAT_SESSION
10979 #endif
10980 #ifdef FEAT_MODIFY_FNAME
10982 #endif
10983 #ifdef FEAT_MOUSE
10985 #endif
10986 #ifdef FEAT_MOUSESHAPE
10988 #endif
10989 #if defined(UNIX) || defined(VMS)
10990 # ifdef FEAT_MOUSE_DEC
10992 # endif
10993 # ifdef FEAT_MOUSE_GPM
10995 # endif
10996 # ifdef FEAT_MOUSE_JSB
10998 # endif
10999 # ifdef FEAT_MOUSE_NET
11001 # endif
11002 # ifdef FEAT_MOUSE_PTERM
11004 # endif
11005 # ifdef FEAT_MOUSE_XTERM
11007 # endif
11008 #endif
11009 #ifdef FEAT_MBYTE
11011 #endif
11012 #ifdef FEAT_MBYTE_IME
11014 #endif
11015 #ifdef FEAT_MULTI_LANG
11017 #endif
11018 #ifdef FEAT_MZSCHEME
11019 #ifndef DYNAMIC_MZSCHEME
11021 #endif
11022 #endif
11023 #ifdef FEAT_OLE
11025 #endif
11026 #ifdef FEAT_OSFILETYPE
11028 #endif
11029 #ifdef FEAT_PATH_EXTRA
11031 #endif
11032 #ifdef FEAT_PERL
11033 #ifndef DYNAMIC_PERL
11035 #endif
11036 #endif
11037 #ifdef FEAT_PYTHON
11038 #ifndef DYNAMIC_PYTHON
11040 #endif
11041 #endif
11042 #ifdef FEAT_POSTSCRIPT
11044 #endif
11045 #ifdef FEAT_PRINTER
11047 #endif
11048 #ifdef FEAT_PROFILE
11050 #endif
11051 #ifdef FEAT_RELTIME
11053 #endif
11054 #ifdef FEAT_QUICKFIX
11056 #endif
11057 #ifdef FEAT_RIGHTLEFT
11059 #endif
11060 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11062 #endif
11063 #ifdef FEAT_SCROLLBIND
11065 #endif
11066 #ifdef FEAT_CMDL_INFO
11069 #endif
11070 #ifdef FEAT_SIGNS
11072 #endif
11073 #ifdef FEAT_SMARTINDENT
11075 #endif
11076 #ifdef FEAT_SNIFF
11078 #endif
11079 #ifdef FEAT_STL_OPT
11081 #endif
11082 #ifdef FEAT_SUN_WORKSHOP
11084 #endif
11085 #ifdef FEAT_NETBEANS_INTG
11087 #endif
11088 #ifdef FEAT_SPELL
11090 #endif
11091 #ifdef FEAT_SYN_HL
11093 #endif
11094 #if defined(USE_SYSTEM) || !defined(UNIX)
11096 #endif
11097 #ifdef FEAT_TAG_BINS
11099 #endif
11100 #ifdef FEAT_TAG_OLDSTATIC
11102 #endif
11103 #ifdef FEAT_TAG_ANYWHITE
11105 #endif
11106 #ifdef FEAT_TCL
11107 # ifndef DYNAMIC_TCL
11109 # endif
11110 #endif
11111 #ifdef TERMINFO
11113 #endif
11114 #ifdef FEAT_TERMRESPONSE
11116 #endif
11117 #ifdef FEAT_TEXTOBJ
11119 #endif
11120 #ifdef HAVE_TGETENT
11122 #endif
11123 #ifdef FEAT_TITLE
11125 #endif
11126 #ifdef FEAT_TOOLBAR
11128 #endif
11129 #ifdef FEAT_USR_CMDS
11132 #endif
11133 #ifdef FEAT_VIMINFO
11135 #endif
11136 #ifdef FEAT_VERTSPLIT
11138 #endif
11139 #ifdef FEAT_VIRTUALEDIT
11141 #endif
11142 #ifdef FEAT_VISUAL
11144 #endif
11145 #ifdef FEAT_VISUALEXTRA
11147 #endif
11148 #ifdef FEAT_VREPLACE
11150 #endif
11151 #ifdef FEAT_WILDIGN
11153 #endif
11154 #ifdef FEAT_WILDMENU
11156 #endif
11157 #ifdef FEAT_WINDOWS
11159 #endif
11160 #ifdef FEAT_WAK
11162 #endif
11163 #ifdef FEAT_WRITEBACKUP
11165 #endif
11166 #ifdef FEAT_XIM
11168 #endif
11169 #ifdef FEAT_XFONTSET
11171 #endif
11172 #ifdef USE_XSMP
11174 #endif
11175 #ifdef USE_XSMP_INTERACT
11177 #endif
11178 #ifdef FEAT_XCLIPBOARD
11180 #endif
11181 #ifdef FEAT_XTERM_SAVE
11183 #endif
11184 #if defined(UNIX) && defined(FEAT_X11)
11186 #endif
11187 NULL
11188 };
11193 {
11196 }
11199 {
11204 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11207 #endif
11208 #ifdef DYNAMIC_TCL
11211 #endif
11212 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11215 #endif
11216 #ifdef DYNAMIC_MZSCHEME
11219 #endif
11220 #ifdef DYNAMIC_RUBY
11223 #endif
11224 #ifdef DYNAMIC_PYTHON
11227 #endif
11228 #ifdef DYNAMIC_PERL
11231 #endif
11232 #ifdef FEAT_GUI
11235 # ifdef FEAT_GUI_W32
11238 # endif
11239 # ifdef FEAT_BROWSE
11242 # endif
11243 #endif
11244 #ifdef FEAT_SYN_HL
11247 #endif
11248 #if defined(WIN3264)
11251 #endif
11252 #ifdef FEAT_NETBEANS_INTG
11255 #endif
11256 }
11259 }
11261 /*
11262 * "has_key()" function
11263 */
11264 static void
11268 {
11271 {
11274 }
11280 }
11282 /*
11283 * "haslocaldir()" function
11284 */
11285 /*ARGSUSED*/
11286 static void
11290 {
11292 }
11294 /*
11295 * "hasmapto()" function
11296 */
11297 static void
11301 {
11310 else
11311 {
11315 }
11319 else
11321 }
11323 /*
11324 * "histadd()" function
11325 */
11326 /*ARGSUSED*/
11327 static void
11331 {
11332 #ifdef FEAT_CMDHIST
11336 #endif
11341 #ifdef FEAT_CMDHIST
11345 {
11348 {
11352 }
11353 }
11354 #endif
11355 }
11357 /*
11358 * "histdel()" function
11359 */
11360 /*ARGSUSED*/
11361 static void
11365 {
11366 #ifdef FEAT_CMDHIST
11375 /* only one argument: clear entire history */
11378 /* index given: remove that entry */
11381 else
11382 /* string given: remove all matching entries */
11386 #else
11388 #endif
11389 }
11391 /*
11392 * "histget()" function
11393 */
11394 /*ARGSUSED*/
11395 static void
11399 {
11400 #ifdef FEAT_CMDHIST
11408 else
11409 {
11413 else
11415 /* -1 on type error */
11417 }
11418 #else
11420 #endif
11422 }
11424 /*
11425 * "histnr()" function
11426 */
11427 /*ARGSUSED*/
11428 static void
11432 {
11435 #ifdef FEAT_CMDHIST
11441 else
11442 #endif
11445 }
11447 /*
11448 * "highlightID(name)" function
11449 */
11450 static void
11454 {
11456 }
11458 /*
11459 * "highlight_exists()" function
11460 */
11461 static void
11465 {
11467 }
11469 /*
11470 * "hostname()" function
11471 */
11472 /*ARGSUSED*/
11473 static void
11477 {
11483 }
11485 /*
11486 * iconv() function
11487 */
11488 /*ARGSUSED*/
11489 static void
11493 {
11494 #ifdef FEAT_MBYTE
11498 vimconv_T vimconv;
11499 #endif
11504 #ifdef FEAT_MBYTE
11511 /* If the encodings are equal, no conversion needed. */
11514 else
11520 #endif
11521 }
11523 /*
11524 * "indent()" function
11525 */
11526 static void
11530 {
11531 linenr_T lnum;
11536 else
11538 }
11540 /*
11541 * "index()" function
11542 */
11543 static void
11547 {
11555 {
11558 }
11561 {
11564 {
11567 /* Start at specified item. Use the cached index that list_find()
11568 * sets, so that a negative number also works. */
11575 }
11579 {
11582 }
11583 }
11584 }
11590 /*
11591 * This function is used by f_input() and f_inputdialog() functions. The third
11592 * argument to f_input() specifies the type of completion to use at the
11593 * prompt. The third argument to f_inputdialog() specifies the value to return
11594 * when the user cancels the prompt.
11595 */
11596 static void
11601 {
11614 #ifdef NO_CONSOLE_INPUT
11615 /* While starting up, there is no place to enter text. */
11618 #endif
11622 {
11623 /* Only the part of the message after the last NL is considered as
11624 * prompt for the command line */
11628 else
11629 {
11639 }
11643 {
11649 {
11665 }
11666 }
11675 /* since the user typed this, no need to wait for return */
11678 }
11680 }
11682 /*
11683 * "input()" function
11684 * Also handles inputsecret() when inputsecret is set.
11685 */
11686 static void
11690 {
11692 }
11694 /*
11695 * "inputdialog()" function
11696 */
11697 static void
11701 {
11702 #if defined(FEAT_GUI_TEXTDIALOG)
11703 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11705 {
11714 else
11720 else
11721 {
11727 else
11729 }
11731 }
11732 else
11733 #endif
11735 }
11737 /*
11738 * "inputlist()" function
11739 */
11740 static void
11744 {
11750 #ifdef NO_CONSOLE_INPUT
11751 /* While starting up, there is no place to enter text. */
11754 #endif
11756 {
11759 }
11768 {
11771 }
11773 /* Ask for choice. */
11779 }
11784 /*
11785 * "inputrestore()" function
11786 */
11787 /*ARGSUSED*/
11788 static void
11792 {
11794 {
11799 }
11801 {
11804 }
11805 }
11807 /*
11808 * "inputsave()" function
11809 */
11810 /*ARGSUSED*/
11811 static void
11815 {
11816 /* Add an entry to the stack of typehead storage. */
11818 {
11823 }
11824 else
11826 }
11828 /*
11829 * "inputsecret()" function
11830 */
11831 static void
11835 {
11841 }
11843 /*
11844 * "insert()" function
11845 */
11846 static void
11850 {
11861 {
11869 else
11870 {
11873 {
11876 }
11877 }
11879 {
11882 }
11883 }
11884 }
11886 /*
11887 * "isdirectory()" function
11888 */
11889 static void
11893 {
11895 }
11897 /*
11898 * "islocked()" function
11899 */
11900 static void
11904 {
11905 lval_T lv;
11911 FNE_CHECK_START);
11913 {
11916 else
11917 {
11919 {
11922 else
11923 {
11926 {
11927 /* Consider a variable locked when:
11928 * 1. the variable itself is locked
11929 * 2. the value of the variable is locked.
11930 * 3. the List or Dict value is locked.
11931 */
11934 }
11935 }
11936 }
11942 /* List item. */
11944 else
11945 /* Dictionary item. */
11947 }
11948 }
11951 }
11955 /*
11956 * Turn a dict into a list:
11957 * "what" == 0: list of keys
11958 * "what" == 1: list of values
11959 * "what" == 2: list of items
11960 */
11961 static void
11966 {
11977 {
11980 }
11989 {
11991 {
12001 {
12002 /* keys() */
12006 }
12008 {
12009 /* values() */
12011 }
12012 else
12013 {
12014 /* items() */
12036 }
12037 }
12038 }
12039 }
12041 /*
12042 * "items(dict)" function
12043 */
12044 static void
12048 {
12050 }
12052 /*
12053 * "join()" function
12054 */
12055 static void
12059 {
12060 garray_T ga;
12065 {
12068 }
12073 else
12079 {
12084 }
12085 else
12087 }
12089 /*
12090 * "keys()" function
12091 */
12092 static void
12096 {
12098 }
12100 /*
12101 * "last_buffer_nr()" function.
12102 */
12103 /*ARGSUSED*/
12104 static void
12108 {
12117 }
12119 /*
12120 * "len()" function
12121 */
12122 static void
12126 {
12128 {
12143 }
12144 }
12148 static void
12153 {
12154 #ifdef FEAT_LIBCALL
12158 #endif
12163 else
12169 #ifdef FEAT_LIBCALL
12170 /* The first two args must be strings, otherwise its meaningless */
12172 {
12178 else
12182 string_in,
12184 string_result,
12188 }
12189 #endif
12190 }
12192 /*
12193 * "libcall()" function
12194 */
12195 static void
12199 {
12201 }
12203 /*
12204 * "libcallnr()" function
12205 */
12206 static void
12210 {
12212 }
12214 /*
12215 * "line(string)" function
12216 */
12217 static void
12221 {
12230 }
12232 /*
12233 * "line2byte(lnum)" function
12234 */
12235 /*ARGSUSED*/
12236 static void
12240 {
12241 #ifndef FEAT_BYTEOFF
12243 #else
12244 linenr_T lnum;
12249 else
12253 #endif
12254 }
12256 /*
12257 * "lispindent(lnum)" function
12258 */
12259 static void
12263 {
12264 #ifdef FEAT_LISP
12265 pos_T pos;
12266 linenr_T lnum;
12271 {
12275 }
12276 else
12277 #endif
12279 }
12281 /*
12282 * "localtime()" function
12283 */
12284 /*ARGSUSED*/
12285 static void
12289 {
12291 }
12295 static void
12300 {
12307 garray_T ga;
12310 /* return empty string for failure */
12319 {
12323 }
12324 else
12335 {
12345 }
12346 }
12348 /*
12349 * "map()" function
12350 */
12351 static void
12355 {
12357 }
12359 /*
12360 * "maparg()" function
12361 */
12362 static void
12366 {
12368 }
12370 /*
12371 * "mapcheck()" function
12372 */
12373 static void
12377 {
12379 }
12383 static void
12388 {
12392 regmatch_T regmatch;
12405 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12411 {
12412 /* return empty list when there are no matches */
12415 }
12417 {
12420 }
12423 {
12427 }
12428 else
12436 {
12443 {
12448 }
12449 else
12450 {
12455 /* When "count" argument is there ignore matches before "start",
12456 * otherwise skip part of the string. Differs when pattern is "^"
12457 * or "\<". */
12460 else
12462 }
12468 }
12472 {
12476 {
12478 {
12480 {
12483 }
12488 }
12497 /* Advance to just after the match. */
12499 {
12502 }
12503 else
12504 {
12505 #ifdef FEAT_MBYTE
12508 #else
12510 #endif
12511 }
12512 }
12515 {
12517 {
12520 /* return list with matched string and submatches */
12522 {
12524 {
12528 }
12534 }
12535 }
12537 {
12538 /* return matched string */
12541 else
12544 }
12547 else
12548 {
12552 else
12556 }
12557 }
12559 }
12561 theend:
12564 }
12566 /*
12567 * "match()" function
12568 */
12569 static void
12573 {
12575 }
12577 /*
12578 * "matchadd()" function
12579 */
12580 static void
12584 {
12585 #ifdef FEAT_SEARCH_EXTRA
12598 {
12602 }
12606 {
12609 }
12612 #endif
12613 }
12615 /*
12616 * "matcharg()" function
12617 */
12618 static void
12622 {
12624 {
12625 #ifdef FEAT_SEARCH_EXTRA
12630 {
12632 {
12636 }
12637 else
12638 {
12641 }
12642 }
12643 #endif
12644 }
12645 }
12647 /*
12648 * "matchdelete()" function
12649 */
12650 static void
12654 {
12655 #ifdef FEAT_SEARCH_EXTRA
12658 #endif
12659 }
12661 /*
12662 * "matchend()" function
12663 */
12664 static void
12668 {
12670 }
12672 /*
12673 * "matchlist()" function
12674 */
12675 static void
12679 {
12681 }
12683 /*
12684 * "matchstr()" function
12685 */
12686 static void
12690 {
12692 }
12696 static void
12701 {
12707 {
12713 {
12716 {
12719 {
12726 }
12727 }
12728 }
12729 }
12731 {
12739 {
12742 {
12744 {
12748 {
12751 }
12754 }
12755 }
12756 }
12757 }
12758 else
12761 }
12763 /*
12764 * "max()" function
12765 */
12766 static void
12770 {
12772 }
12774 /*
12775 * "min()" function
12776 */
12777 static void
12781 {
12783 }
12787 /*
12788 * Create the directory in which "dir" is located, and higher levels when
12789 * needed.
12790 */
12791 static int
12795 {
12800 /* Get end of directory name in "dir".
12801 * We're done when it's "/" or "c:/". */
12806 /* If the directory exists we're done. Otherwise: create it.*/
12816 }
12818 #ifdef vim_mkdir
12819 /*
12820 * "mkdir()" function
12821 */
12822 static void
12826 {
12837 {
12842 }
12844 }
12845 #endif
12847 /*
12848 * "mode()" function
12849 */
12850 /*ARGSUSED*/
12851 static void
12855 {
12858 #ifdef FEAT_VISUAL
12860 {
12863 else
12865 }
12866 else
12867 #endif
12871 {
12874 else
12876 }
12879 else
12885 }
12887 /*
12888 * "nextnonblank()" function
12889 */
12890 static void
12894 {
12895 linenr_T lnum;
12898 {
12900 {
12903 }
12906 }
12908 }
12910 /*
12911 * "nr2char()" function
12912 */
12913 static void
12917 {
12920 #ifdef FEAT_MBYTE
12923 else
12924 #endif
12925 {
12928 }
12931 }
12933 /*
12934 * "pathshorten()" function
12935 */
12936 static void
12940 {
12947 else
12948 {
12953 }
12954 }
12956 /*
12957 * "prevnonblank()" function
12958 */
12959 static void
12963 {
12964 linenr_T lnum;
12969 else
12973 }
12975 #ifdef HAVE_STDARG_H
12976 /* This dummy va_list is here because:
12977 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12978 * - locally in the function results in a "used before set" warning
12979 * - using va_start() to initialize it gives "function with fixed args" error */
12981 #endif
12983 /*
12984 * "printf()" function
12985 */
12986 static void
12990 {
12994 {
13001 /* Get the required length, allocate the buffer and do it for real. */
13006 {
13009 {
13012 }
13013 }
13015 }
13016 #endif
13017 }
13019 /*
13020 * "pumvisible()" function
13021 */
13022 /*ARGSUSED*/
13023 static void
13027 {
13029 #ifdef FEAT_INS_EXPAND
13032 #endif
13033 }
13035 /*
13036 * "range()" function
13037 */
13038 static void
13042 {
13051 {
13054 }
13055 else
13056 {
13060 }
13069 else
13070 {
13076 }
13077 }
13079 /*
13080 * "readfile()" function
13081 */
13082 static void
13086 {
13106 {
13111 }
13116 /* Always open the file in binary mode, library functions have a mind of
13117 * their own about CR-LF conversion. */
13120 {
13123 }
13127 {
13132 {
13134 {
13135 /* Only when in binary mode add an empty list item when the
13136 * last line ends in a '\n'. */
13140 /* Found end-of-line or end-of-file: add a text line to the
13141 * list. */
13150 else
13151 {
13154 {
13160 }
13161 }
13166 {
13169 }
13179 }
13182 }
13187 {
13188 /* "buf" is full, need to move text to an allocated buffer */
13190 {
13193 }
13194 else
13195 {
13198 {
13204 }
13205 }
13207 }
13208 else
13209 {
13212 }
13213 }
13215 /*
13216 * For a negative line count use only the lines at the end of the file,
13217 * free the rest.
13218 */
13221 {
13224 }
13228 }
13230 #if defined(FEAT_RELTIME)
13233 /*
13234 * Convert a List to proftime_T.
13235 * Return FAIL when there is something wrong.
13236 */
13237 static int
13241 {
13250 # ifdef WIN3264
13253 # else
13256 # endif
13258 }
13261 /*
13262 * "reltime()" function
13263 */
13264 static void
13268 {
13269 #ifdef FEAT_RELTIME
13270 proftime_T res;
13271 proftime_T start;
13274 {
13275 /* No arguments: get current time. */
13277 }
13279 {
13283 }
13284 else
13285 {
13286 /* Two arguments: compute the difference. */
13291 }
13294 {
13297 # ifdef WIN3264
13300 # else
13303 # endif
13306 }
13307 #endif
13308 }
13310 /*
13311 * "reltimestr()" function
13312 */
13313 static void
13317 {
13318 #ifdef FEAT_RELTIME
13319 proftime_T tm;
13320 #endif
13324 #ifdef FEAT_RELTIME
13327 #endif
13328 }
13330 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13334 static void
13336 {
13338 # ifdef FEAT_GUI
13340 # endif
13341 )
13342 {
13346 }
13347 }
13349 static int
13351 {
13354 {
13357 }
13359 }
13360 #endif
13362 #ifdef FEAT_CLIENTSERVER
13365 static void
13370 {
13375 # ifdef WIN32
13376 HWND w;
13377 # else
13378 Window w;
13379 # endif
13384 # ifdef FEAT_X11
13387 # endif
13393 # ifdef WIN32
13395 # else
13398 # endif
13399 {
13402 else
13405 }
13410 {
13411 dictitem_T v;
13422 }
13423 }
13424 #endif
13426 /*
13427 * "remote_expr()" function
13428 */
13429 /*ARGSUSED*/
13430 static void
13434 {
13437 #ifdef FEAT_CLIENTSERVER
13439 #endif
13440 }
13442 /*
13443 * "remote_foreground()" function
13444 */
13445 /*ARGSUSED*/
13446 static void
13450 {
13452 #ifdef FEAT_CLIENTSERVER
13453 # ifdef WIN32
13454 /* On Win32 it's done in this application. */
13455 {
13460 }
13461 # else
13462 /* Send a foreground() expression to the server. */
13468 # endif
13469 #endif
13470 }
13472 /*ARGSUSED*/
13473 static void
13477 {
13478 #ifdef FEAT_CLIENTSERVER
13479 dictitem_T v;
13481 # ifdef WIN32
13483 # endif
13487 {
13490 }
13493 {
13496 }
13497 # ifdef WIN32
13501 else
13502 {
13505 }
13506 # else
13513 # endif
13516 {
13525 }
13526 #else
13528 #endif
13529 }
13531 /*ARGSUSED*/
13532 static void
13536 {
13539 #ifdef FEAT_CLIENTSERVER
13543 {
13544 # ifdef WIN32
13545 /* The server's HWND is encoded in the 'id' parameter */
13552 # else
13555 # endif
13557 }
13558 #endif
13561 }
13563 /*
13564 * "remote_send()" function
13565 */
13566 /*ARGSUSED*/
13567 static void
13571 {
13574 #ifdef FEAT_CLIENTSERVER
13576 #endif
13577 }
13579 /*
13580 * "remove()" function
13581 */
13582 static void
13586 {
13598 {
13603 {
13606 {
13610 else
13611 {
13615 }
13616 }
13617 }
13618 }
13623 {
13631 else
13632 {
13634 {
13635 /* Remove one item, return its value. */
13639 }
13640 else
13641 {
13642 /* Remove range of items, return list with values. */
13648 else
13649 {
13653 {
13657 }
13660 else
13661 {
13664 {
13671 }
13672 }
13673 }
13674 }
13675 }
13676 }
13677 }
13679 /*
13680 * "rename({from}, {to})" function
13681 */
13682 static void
13686 {
13691 else
13694 }
13696 /*
13697 * "repeat()" function
13698 */
13699 /*ARGSUSED*/
13700 static void
13704 {
13714 {
13720 }
13721 else
13722 {
13734 {
13738 }
13741 }
13742 }
13744 /*
13745 * "resolve()" function
13746 */
13747 static void
13751 {
13755 #ifdef FEAT_SHORTCUT
13756 {
13762 else
13764 }
13765 #else
13766 # ifdef HAVE_READLINK
13767 {
13789 {
13790 /* Separate the first path component in "p", and keep the
13791 * remainder (beginning with the path separator). */
13794 }
13797 {
13799 {
13806 {
13812 }
13814 /* Ensure that the result will have a trailing path separator
13815 * if the argument has one. */
13819 /* Separate the first path component in the link value and
13820 * concatenate the remainders. */
13823 {
13826 else
13827 {
13830 {
13833 }
13834 }
13836 }
13840 {
13841 /* Ignore trailing path separator. */
13844 }
13846 {
13847 /* symlink is relative to directory of argument */
13850 {
13855 }
13856 }
13857 else
13858 {
13861 }
13862 }
13867 /* Append the first path component of "remain" to "p". */
13872 {
13876 }
13877 /* Shorten "remain". */
13880 else
13881 {
13884 }
13885 }
13887 /* If the result is a relative path name, make it explicitly relative to
13888 * the current directory if and only if the argument had this form. */
13890 {
13899 {
13900 /* Prepend "./". */
13903 {
13906 }
13907 }
13909 {
13910 /* Strip leading "./". */
13916 }
13917 }
13919 /* Ensure that the result will have no trailing path separator
13920 * if the argument had none. But keep "/" or "//". */
13922 {
13926 }
13929 }
13930 # else
13932 # endif
13933 #endif
13937 #ifdef HAVE_READLINK
13938 fail:
13939 #endif
13941 }
13943 /*
13944 * "reverse({list})" function
13945 */
13946 static void
13950 {
13959 {
13964 {
13968 }
13973 }
13974 }
13986 /*
13987 * Get flags for a search function.
13988 * Possibly sets "p_ws".
13989 * Returns BACKWARD, FORWARD or zero (for an error).
13990 */
13991 static int
13995 {
14002 {
14007 {
14009 {
14016 {
14024 }
14026 {
14029 }
14030 else
14032 }
14036 }
14037 }
14039 }
14041 /*
14042 * Shared by search() and searchpos() functions
14043 */
14044 static int
14049 {
14052 pos_T pos;
14053 pos_T save_cursor;
14058 proftime_T tm;
14059 #ifdef FEAT_RELTIME
14061 #endif
14075 /* Optional arguments: line number to stop searching and timeout. */
14077 {
14081 #ifdef FEAT_RELTIME
14083 {
14087 }
14088 #endif
14089 }
14091 #ifdef FEAT_RELTIME
14092 /* Set the time limit, if there is one. */
14094 #endif
14096 /*
14097 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14098 * Check to make sure only those flags are set.
14099 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14100 * flags cannot be set. Check for that condition also.
14101 */
14104 {
14107 }
14113 {
14116 else
14122 {
14123 /* Store the match cursor position */
14126 }
14127 /* "/$" will put the cursor after the end of the line, may need to
14128 * correct that here */
14130 }
14132 /* If 'n' flag is used: restore cursor position. */
14135 else
14137 theend:
14141 }
14143 /*
14144 * "search()" function
14145 */
14146 static void
14150 {
14154 }
14156 /*
14157 * "searchdecl()" function
14158 */
14159 static void
14163 {
14173 {
14177 }
14181 }
14183 /*
14184 * Used by searchpair() and searchpairpos()
14185 */
14186 static int
14190 {
14203 /* Get the three pattern arguments: start, middle, end. */
14210 /* Handle the optional fourth argument: flags */
14215 /* Don't accept SP_END or SP_SUBPAT.
14216 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14217 */
14220 {
14223 }
14225 /* Using 'r' implies 'W', otherwise it doesn't work. */
14229 /* Optional fifth argument: skip expression */
14233 else
14234 {
14237 {
14241 #ifdef FEAT_RELTIME
14243 {
14247 }
14248 #endif
14249 }
14250 }
14257 theend:
14261 }
14263 /*
14264 * "searchpair()" function
14265 */
14266 static void
14270 {
14272 }
14274 /*
14275 * "searchpairpos()" function
14276 */
14277 static void
14281 {
14282 pos_T match_pos;
14292 {
14295 }
14299 }
14301 /*
14302 * Search for a start/middle/end thing.
14303 * Used by searchpair(), see its documentation for the details.
14304 * Returns 0 or -1 for no match,
14305 */
14306 long
14318 {
14322 pos_T pos;
14323 pos_T firstpos;
14324 pos_T foundpos;
14325 pos_T save_cursor;
14326 pos_T save_pos;
14332 proftime_T tm;
14334 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14338 #ifdef FEAT_RELTIME
14339 /* Set the time limit, if there is one. */
14341 #endif
14343 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14344 * start/middle/end (pat3, for the top pair). */
14352 else
14364 {
14368 /* didn't find it or found the first match again: FAIL */
14374 {
14375 /* Found the same position again. Can happen with a pattern that
14376 * has "\zs" at the end and searching backwards. Advance one
14377 * character and try again. */
14380 else
14382 }
14385 /* clear the start flag to avoid getting stuck here */
14388 /* If the skip pattern matches, ignore this match. */
14390 {
14396 {
14397 /* Evaluating {skip} caused an error, break here. */
14401 }
14404 }
14407 {
14408 /* Found end when searching backwards or start when searching
14409 * forward: nested pair. */
14412 }
14413 else
14414 {
14415 /* Found end when searching forward or start when searching
14416 * backward: end of (nested) pair; or found middle in outer pair. */
14419 }
14422 {
14423 /* Found the match: return matchcount or line number. */
14426 else
14434 }
14435 }
14438 {
14439 /* Store the match cursor position */
14442 }
14444 /* If 'n' flag is used or search failed: restore cursor position. */
14448 theend:
14454 }
14456 /*
14457 * "searchpos()" function
14458 */
14459 static void
14463 {
14464 pos_T match_pos;
14477 {
14480 }
14486 }
14489 /*ARGSUSED*/
14490 static void
14494 {
14495 #ifdef FEAT_CLIENTSERVER
14505 # ifdef FEAT_X11
14508 # endif
14511 {
14514 }
14516 #else
14518 #endif
14519 }
14521 /*ARGSUSED*/
14522 static void
14526 {
14529 #ifdef FEAT_CLIENTSERVER
14530 # ifdef WIN32
14532 # else
14536 # endif
14537 #endif
14540 }
14542 /*
14543 * "setbufvar()" function
14544 */
14545 /*ARGSUSED*/
14546 static void
14550 {
14552 aco_save_T aco;
14567 {
14568 /* set curbuf to be our buf, temporarily */
14572 {
14582 }
14583 else
14584 {
14587 {
14592 }
14593 }
14595 /* reset notion of buffer */
14597 }
14598 }
14600 /*
14601 * "setcmdpos()" function
14602 */
14603 static void
14607 {
14612 }
14614 /*
14615 * "setline()" function
14616 */
14617 static void
14621 {
14622 linenr_T lnum;
14631 {
14634 }
14635 else
14640 {
14642 {
14643 /* list argument, get next string */
14648 }
14654 {
14655 /* existing line, replace it */
14657 {
14662 }
14663 }
14665 {
14666 /* lnum is one past the last line, append the line */
14670 }
14675 }
14679 }
14681 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
14683 /*
14684 * Used by "setqflist()" and "setloclist()" functions
14685 */
14686 /*ARGSUSED*/
14687 static void
14693 {
14694 #ifdef FEAT_QUICKFIX
14697 #endif
14701 #ifdef FEAT_QUICKFIX
14704 else
14705 {
14709 {
14715 }
14719 }
14720 #endif
14721 }
14723 /*
14724 * "setloclist()" function
14725 */
14726 /*ARGSUSED*/
14727 static void
14731 {
14739 }
14741 /*
14742 * "setmatches()" function
14743 */
14744 static void
14748 {
14749 #ifdef FEAT_SEARCH_EXTRA
14756 {
14759 }
14761 {
14763 /* To some extent make sure that we are dealing with a list from
14764 * "getmatches()". */
14767 {
14770 {
14773 }
14778 {
14781 }
14783 }
14788 {
14795 }
14797 }
14798 #endif
14799 }
14801 /*
14802 * "setpos()" function
14803 */
14804 /*ARGSUSED*/
14805 static void
14809 {
14810 pos_T pos;
14817 {
14819 {
14822 {
14823 /* set cursor */
14825 {
14829 }
14830 else
14832 }
14834 {
14835 /* set mark */
14838 }
14839 else
14841 }
14842 }
14843 }
14845 /*
14846 * "setqflist()" function
14847 */
14848 /*ARGSUSED*/
14849 static void
14853 {
14855 }
14857 /*
14858 * "setreg()" function
14859 */
14860 static void
14864 {
14870 char_u yank_type;
14889 {
14895 {
14905 #ifdef FEAT_VISUAL
14909 {
14913 }
14915 #endif
14916 }
14917 }
14924 }
14926 /*
14927 * "settabwinvar()" function
14928 */
14929 static void
14933 {
14935 }
14937 /*
14938 * "setwinvar()" function
14939 */
14940 static void
14944 {
14946 }
14948 /*
14949 * "setwinvar()" and "settabwinvar()" functions
14950 */
14951 static void
14956 {
14958 #ifdef FEAT_WINDOWS
14961 #endif
14972 #ifdef FEAT_WINDOWS
14975 else
14977 #endif
14983 {
14984 #ifdef FEAT_WINDOWS
14985 /* set curwin to be our win, temporarily */
14993 #endif
14996 {
15006 }
15007 else
15008 {
15011 {
15016 }
15017 }
15019 #ifdef FEAT_WINDOWS
15020 /* Restore current tabpage and window, if still valid (autocomands can
15021 * make them invalid). */
15025 {
15028 }
15029 #endif
15030 }
15031 }
15033 /*
15034 * "shellescape({string})" function
15035 */
15036 static void
15040 {
15043 }
15045 /*
15046 * "simplify()" function
15047 */
15048 static void
15052 {
15059 }
15061 static int
15062 #ifdef __BORLANDC__
15063 _RTLENTRYF
15064 #endif
15066 static int
15067 #ifdef __BORLANDC__
15068 _RTLENTRYF
15069 #endif
15075 #define ITEM_COMPARE_FAIL 999
15077 /*
15078 * Compare functions for f_sort() below.
15079 */
15080 static int
15081 #ifdef __BORLANDC__
15082 _RTLENTRYF
15083 #endif
15087 {
15102 else
15107 }
15109 static int
15110 #ifdef __BORLANDC__
15111 _RTLENTRYF
15112 #endif
15116 {
15118 typval_T rettv;
15122 /* shortcut after failure in previous call; compare all items equal */
15126 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15127 * in the copy without changing the original list items. */
15139 else
15140 /* return value has wrong type */
15146 }
15148 /*
15149 * "sort({list})" function
15150 */
15151 static void
15155 {
15165 else
15166 {
15181 {
15184 else
15185 {
15193 else
15195 }
15196 }
15198 /* Make an array with each entry pointing to an item in the List. */
15207 /* test the compare function */
15212 else
15213 {
15214 /* Sort the array with item pointers. */
15219 {
15220 /* Clear the List and append the items in the sorted order. */
15225 }
15226 }
15229 }
15230 }
15232 /*
15233 * "soundfold({word})" function
15234 */
15235 static void
15239 {
15244 #ifdef FEAT_SPELL
15246 #else
15248 #endif
15249 }
15251 /*
15252 * "spellbadword()" function
15253 */
15254 /* ARGSUSED */
15255 static void
15259 {
15267 #ifdef FEAT_SPELL
15269 {
15270 /* Find the start and length of the badly spelled word. */
15274 }
15276 {
15281 {
15282 /* Check the argument for spelling. */
15284 {
15287 {
15290 }
15292 }
15293 }
15294 }
15295 #endif
15304 }
15306 /*
15307 * "spellsuggest()" function
15308 */
15309 /*ARGSUSED*/
15310 static void
15314 {
15315 #ifdef FEAT_SPELL
15319 garray_T ga;
15323 #endif
15328 #ifdef FEAT_SPELL
15330 {
15333 {
15338 {
15342 }
15343 }
15344 else
15350 {
15356 else
15357 {
15362 }
15363 }
15365 }
15366 #endif
15367 }
15369 static void
15373 {
15377 regmatch_T regmatch;
15385 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15391 {
15397 }
15408 {
15411 {
15414 else
15418 else
15422 {
15426 }
15429 /* Advance to just after the match. */
15432 else
15433 {
15434 /* Don't get stuck at the same match. */
15435 #ifdef FEAT_MBYTE
15437 #else
15439 #endif
15440 }
15442 }
15445 }
15448 }
15450 /*
15451 * "str2nr()" function
15452 */
15453 static void
15457 {
15463 {
15466 {
15469 }
15470 }
15475 }
15477 #ifdef HAVE_STRFTIME
15478 /*
15479 * "strftime({format}[, {time}])" function
15480 */
15481 static void
15485 {
15496 else
15499 /* MSVC returns NULL for an invalid value of seconds. */
15502 else
15503 {
15504 # ifdef FEAT_MBYTE
15505 vimconv_T conv;
15513 # endif
15517 else
15520 # ifdef FEAT_MBYTE
15526 else
15527 # endif
15530 # ifdef FEAT_MBYTE
15531 /* Release conversion descriptors */
15534 # endif
15535 }
15536 }
15537 #endif
15539 /*
15540 * "stridx()" function
15541 */
15542 static void
15546 {
15561 {
15569 }
15574 }
15576 /*
15577 * "string()" function
15578 */
15579 static void
15583 {
15589 /* Make a copy if we have a value but it's not in allocate memory. */
15592 }
15594 /*
15595 * "strlen()" function
15596 */
15597 static void
15601 {
15604 }
15606 /*
15607 * "strpart()" function
15608 */
15609 static void
15613 {
15628 else
15631 /*
15632 * Only return the overlap between the specified part and the actual
15633 * string.
15634 */
15636 {
15639 }
15649 }
15651 /*
15652 * "strridx()" function
15653 */
15654 static void
15658 {
15675 {
15676 /* Third argument: upper limit for index */
15680 }
15681 else
15685 {
15686 /* Empty string matches past the end. */
15688 }
15689 else
15690 {
15692 {
15697 }
15698 }
15702 else
15704 }
15706 /*
15707 * "strtrans()" function
15708 */
15709 static void
15713 {
15716 }
15718 /*
15719 * "submatch()" function
15720 */
15721 static void
15725 {
15729 }
15731 /*
15732 * "substitute()" function
15733 */
15734 static void
15738 {
15751 else
15753 }
15755 /*
15756 * "synID(lnum, col, trans)" function
15757 */
15758 /*ARGSUSED*/
15759 static void
15763 {
15765 #ifdef FEAT_SYN_HL
15778 #endif
15781 }
15783 /*
15784 * "synIDattr(id, what [, mode])" function
15785 */
15786 /*ARGSUSED*/
15787 static void
15791 {
15793 #ifdef FEAT_SYN_HL
15803 {
15807 #ifdef FEAT_GUI
15809 #endif
15810 )
15812 }
15813 else
15814 {
15815 #ifdef FEAT_GUI
15818 else
15819 #endif
15822 else
15824 }
15828 {
15861 /* underline */
15863 else
15864 /* undercurl */
15867 }
15871 #endif
15874 }
15876 /*
15877 * "synIDtrans(id)" function
15878 */
15879 /*ARGSUSED*/
15880 static void
15884 {
15887 #ifdef FEAT_SYN_HL
15892 else
15893 #endif
15897 }
15899 /*
15900 * "synstack(lnum, col)" function
15901 */
15902 /*ARGSUSED*/
15903 static void
15907 {
15908 #ifdef FEAT_SYN_HL
15913 #endif
15918 #ifdef FEAT_SYN_HL
15925 {
15928 {
15934 }
15935 }
15936 #endif
15937 }
15939 /*
15940 * "system()" function
15941 */
15942 static void
15946 {
15958 {
15959 /*
15960 * Write the string to a temp file, to be used for input of the shell
15961 * command.
15962 */
15964 {
15967 }
15971 {
15974 }
15977 {
15980 }
15986 {
15989 }
15990 }
15995 #ifdef USE_CR
15996 /* translate <CR> into <NL> */
15998 {
16002 {
16005 }
16006 }
16007 #else
16008 # ifdef USE_CRNL
16009 /* translate <CR><NL> into <NL> */
16011 {
16016 {
16020 }
16022 }
16023 # endif
16024 #endif
16026 done:
16028 {
16031 }
16034 }
16036 /*
16037 * "tabpagebuflist()" function
16038 */
16039 /* ARGSUSED */
16040 static void
16044 {
16045 #ifndef FEAT_WINDOWS
16047 #else
16053 else
16054 {
16058 }
16061 else
16062 {
16065 else
16066 {
16071 }
16072 }
16073 #endif
16074 }
16077 /*
16078 * "tabpagenr()" function
16079 */
16080 /* ARGSUSED */
16081 static void
16085 {
16087 #ifdef FEAT_WINDOWS
16091 {
16095 {
16098 else
16100 }
16101 }
16102 else
16104 #endif
16106 }
16109 #ifdef FEAT_WINDOWS
16112 /*
16113 * Common code for tabpagewinnr() and winnr().
16114 */
16115 static int
16119 {
16127 {
16134 {
16138 }
16139 else
16140 {
16143 }
16144 }
16149 {
16151 {
16152 /* didn't find it in this tabpage */
16155 }
16157 }
16159 }
16160 #endif
16162 /*
16163 * "tabpagewinnr()" function
16164 */
16165 /* ARGSUSED */
16166 static void
16170 {
16172 #ifdef FEAT_WINDOWS
16178 else
16180 #endif
16182 }
16185 /*
16186 * "tagfiles()" function
16187 */
16188 /*ARGSUSED*/
16189 static void
16193 {
16195 tagname_T tn;
16199 {
16202 }
16209 }
16211 /*
16212 * "taglist()" function
16213 */
16214 static void
16218 {
16229 }
16231 /*
16232 * "tempname()" function
16233 */
16234 /*ARGSUSED*/
16235 static void
16239 {
16245 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16246 * names. Skip 'I' and 'O', they are used for shell redirection. */
16247 do
16248 {
16253 else
16254 {
16255 #ifdef EBCDIC
16260 else
16261 #endif
16263 }
16265 }
16267 /*
16268 * "test(list)" function: Just checking the walls...
16269 */
16270 /*ARGSUSED*/
16271 static void
16275 {
16276 /* Used for unit testing. Change the code below to your liking. */
16277 #if 0
16296 #endif
16297 }
16299 /*
16300 * "tolower(string)" function
16301 */
16302 static void
16306 {
16315 {
16316 #ifdef FEAT_MBYTE
16320 {
16326 /* TODO: reallocate string when byte count changes. */
16330 }
16333 else
16334 #endif
16335 {
16338 }
16339 }
16340 }
16342 /*
16343 * "toupper(string)" function
16344 */
16345 static void
16349 {
16352 }
16354 /*
16355 * "tr(string, fromstr, tostr)" function
16356 */
16357 static void
16361 {
16366 #ifdef FEAT_MBYTE
16374 #endif
16377 garray_T ga;
16383 /* Default return value: empty string. */
16390 #ifdef FEAT_MBYTE
16392 #endif
16393 /* not multi-byte: fromstr and tostr must be the same length */
16395 {
16396 #ifdef FEAT_MBYTE
16397 error:
16398 #endif
16402 }
16404 /* fromstr and tostr have to contain the same number of chars */
16406 {
16407 #ifdef FEAT_MBYTE
16409 {
16415 {
16418 {
16420 {
16423 {
16427 }
16428 }
16432 }
16434 }
16437 {
16438 /* Check that fromstr and tostr have the same number of
16439 * (multi-byte) characters. Done only once when a character
16440 * of instr doesn't appear in fromstr. */
16443 {
16446 }
16449 }
16456 }
16457 else
16458 #endif
16459 {
16460 /* When not using multi-byte chars we can do it faster. */
16464 else
16467 }
16468 }
16470 /* add a terminating NUL */
16475 }
16477 /*
16478 * "type(expr)" function
16479 */
16480 static void
16484 {
16488 {
16495 }
16497 }
16499 /*
16500 * "values(dict)" function
16501 */
16502 static void
16506 {
16508 }
16510 /*
16511 * "virtcol(string)" function
16512 */
16513 static void
16517 {
16525 {
16528 }
16531 }
16533 /*
16534 * "visualmode()" function
16535 */
16536 /*ARGSUSED*/
16537 static void
16541 {
16542 #ifdef FEAT_VISUAL
16550 /* A non-zero number or non-empty string argument: reset mode. */
16556 #else
16558 #endif
16559 }
16561 /*
16562 * "winbufnr(nr)" function
16563 */
16564 static void
16568 {
16574 else
16576 }
16578 /*
16579 * "wincol()" function
16580 */
16581 /*ARGSUSED*/
16582 static void
16586 {
16589 }
16591 /*
16592 * "winheight(nr)" function
16593 */
16594 static void
16598 {
16604 else
16606 }
16608 /*
16609 * "winline()" function
16610 */
16611 /*ARGSUSED*/
16612 static void
16616 {
16619 }
16621 /*
16622 * "winnr()" function
16623 */
16624 /* ARGSUSED */
16625 static void
16629 {
16632 #ifdef FEAT_WINDOWS
16634 #endif
16636 }
16638 /*
16639 * "winrestcmd()" function
16640 */
16641 /* ARGSUSED */
16642 static void
16646 {
16647 #ifdef FEAT_WINDOWS
16650 garray_T ga;
16655 {
16658 # ifdef FEAT_VERTSPLIT
16661 # endif
16663 }
16667 #else
16669 #endif
16671 }
16673 /*
16674 * "winrestview()" function
16675 */
16676 /* ARGSUSED */
16677 static void
16681 {
16687 else
16688 {
16691 #ifdef FEAT_VIRTUALEDIT
16693 #endif
16698 #ifdef FEAT_DIFF
16700 #endif
16713 #ifdef FEAT_DIFF
16715 #endif
16716 }
16717 }
16719 /*
16720 * "winsaveview()" function
16721 */
16722 /* ARGSUSED */
16723 static void
16727 {
16739 #ifdef FEAT_VIRTUALEDIT
16741 #endif
16746 #ifdef FEAT_DIFF
16748 #endif
16751 }
16753 /*
16754 * "winwidth(nr)" function
16755 */
16756 static void
16760 {
16766 else
16767 #ifdef FEAT_VERTSPLIT
16769 #else
16771 #endif
16772 }
16774 /*
16775 * "writefile()" function
16776 */
16777 static void
16781 {
16794 {
16797 }
16805 /* Always open the file in binary mode, library functions have a mind of
16806 * their own about CR-LF conversion. */
16809 {
16812 }
16813 else
16814 {
16817 {
16819 {
16822 else
16825 {
16828 }
16829 }
16832 {
16835 }
16837 {
16840 }
16841 }
16843 }
16846 }
16848 /*
16849 * Translate a String variable into a position.
16850 * Returns NULL when there is an error.
16851 */
16857 {
16862 /* Argument can be [lnum, col, coladd]. */
16864 {
16874 /* Get the line number */
16879 /* Get the column number */
16885 /* We accept "$" for the column number: last column. */
16892 /* Accept a position up to the NUL after the line. */
16897 #ifdef FEAT_VIRTUALEDIT
16898 /* Get the virtual offset. Defaults to zero. */
16902 #endif
16905 }
16913 {
16918 }
16920 #ifdef FEAT_VIRTUALEDIT
16922 #endif
16925 {
16928 {
16932 }
16934 {
16938 }
16939 }
16941 {
16943 {
16946 }
16947 else
16948 {
16951 }
16953 }
16955 }
16957 /*
16958 * Convert list in "arg" into a position and optional file number.
16959 * When "fnump" is NULL there is no file number, only 3 items.
16960 * Note that the column is passed on as-is, the caller may want to decrement
16961 * it to use 1 for the first column.
16962 * Return FAIL when conversion is not possible, doesn't check the position for
16963 * validity.
16964 */
16965 static int
16970 {
16975 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16976 * when "fnump" isn't NULL and "coladd" is optional. */
16984 {
16991 }
17003 #ifdef FEAT_VIRTUALEDIT
17007 else
17009 #endif
17012 }
17014 /*
17015 * Get the length of an environment variable name.
17016 * Advance "arg" to the first character after the name.
17017 * Return 0 for error.
17018 */
17019 static int
17022 {
17027 ;
17034 }
17036 /*
17037 * Get the length of the name of a function or internal variable.
17038 * "arg" is advanced to the first non-white character after the name.
17039 * Return 0 if something is wrong.
17040 */
17041 static int
17044 {
17048 /* Find the end of the name. */
17050 ;
17058 }
17060 /*
17061 * Get the length of the name of a variable or function.
17062 * Only the name is recognized, does not handle ".key" or "[idx]".
17063 * "arg" is advanced to the first non-white character after the name.
17064 * Return -1 if curly braces expansion failed.
17065 * Return 0 if something else is wrong.
17066 * If the name contains 'magic' {}'s, expand them and return the
17067 * expanded name in an allocated string via 'alias' - caller must free.
17068 */
17069 static int
17075 {
17085 {
17086 /* hard coded <SNR>, already translated */
17089 }
17092 {
17093 /* literal "<SID>", "s:" or "<SNR>" */
17095 }
17097 /*
17098 * Find the end of the name; check for {} construction.
17099 */
17103 {
17107 {
17111 }
17113 /*
17114 * Include any <SID> etc in the expanded string:
17115 * Thus the -len here.
17116 */
17123 }
17130 }
17132 /*
17133 * Find the end of a variable or function name, taking care of magic braces.
17134 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17135 * start and end of the first magic braces item.
17136 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17137 * Return a pointer to just after the name. Equal to "arg" if there is no
17138 * valid name.
17139 */
17146 {
17152 {
17155 }
17157 /* Quick check for valid starting character. */
17167 {
17169 {
17170 /* skip over 'string' to avoid counting [ and ] inside it. */
17172 ;
17175 }
17177 {
17178 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17184 }
17187 {
17192 }
17195 {
17197 {
17198 mb_nest++;
17201 }
17203 {
17204 mb_nest--;
17207 }
17208 }
17209 }
17212 }
17214 /*
17215 * Expands out the 'magic' {}'s in a variable/function name.
17216 * Note that this can call itself recursively, to deal with
17217 * constructs like foo{bar}{baz}{bam}
17218 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17219 * "in_start" ^
17220 * "expr_start" ^
17221 * "expr_end" ^
17222 * "in_end" ^
17223 *
17224 * Returns a new allocated string, which the caller must free.
17225 * Returns NULL for failure.
17226 */
17233 {
17234 char_u c1;
17248 {
17252 {
17256 }
17257 }
17265 {
17268 {
17269 /* Further expansion! */
17274 }
17275 }
17278 }
17280 /*
17281 * Return TRUE if character "c" can be used in a variable or function name.
17282 * Does not include '{' or '}' for magic braces.
17283 */
17284 static int
17287 {
17289 }
17291 /*
17292 * Return TRUE if character "c" can be used as the first character in a
17293 * variable or function name (excluding '{' and '}').
17294 */
17295 static int
17298 {
17300 }
17302 /*
17303 * Set number v: variable to "val".
17304 */
17305 void
17309 {
17311 }
17313 /*
17314 * Get number v: variable value.
17315 */
17316 long
17319 {
17321 }
17323 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17324 /*
17325 * Get string v: variable value. Uses a static buffer, can only be used once.
17326 */
17327 char_u *
17330 {
17332 }
17333 #endif
17335 /*
17336 * Set v:count, v:count1 and v:prevcount.
17337 */
17338 void
17342 {
17346 }
17348 /*
17349 * Set string v: variable to a copy of "val".
17350 */
17351 void
17356 {
17357 /* Need to do this (at least) once, since we can't initialize a union.
17358 * Will always be invoked when "v:progname" is set. */
17366 else
17368 }
17370 /*
17371 * Set v:register if needed.
17372 */
17373 void
17376 {
17377 char_u regname;
17381 else
17383 /* Avoid free/alloc when the value is already right. */
17386 }
17388 /*
17389 * Get or set v:exception. If "oldval" == NULL, return the current value.
17390 * Otherwise, restore the value to "oldval" and return NULL.
17391 * Must always be called in pairs to save and restore v:exception! Does not
17392 * take care of memory allocations.
17393 */
17394 char_u *
17397 {
17403 }
17405 /*
17406 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17407 * Otherwise, restore the value to "oldval" and return NULL.
17408 * Must always be called in pairs to save and restore v:throwpoint! Does not
17409 * take care of memory allocations.
17410 */
17411 char_u *
17414 {
17420 }
17422 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17423 /*
17424 * Set v:cmdarg.
17425 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17426 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17427 * Must always be called in pairs!
17428 */
17429 char_u *
17433 {
17440 {
17444 }
17450 else
17458 # ifdef FEAT_MBYTE
17463 # endif
17473 else
17482 # ifdef FEAT_MBYTE
17489 # endif
17492 }
17493 #endif
17495 /*
17496 * Get the value of internal variable "name".
17497 * Return OK or FAIL.
17498 */
17499 static int
17505 {
17508 typval_T atv;
17512 /* truncate the name, so that we can use strcmp() */
17516 /*
17517 * Check for "b:changedtick".
17518 */
17520 {
17524 }
17526 /*
17527 * Check for user-defined variables.
17528 */
17529 else
17530 {
17534 }
17537 {
17541 }
17548 }
17550 /*
17551 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17552 * Also handle function call with Funcref variable: func(expr)
17553 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17554 */
17555 static int
17561 {
17566 typval_T functv;
17573 {
17575 {
17576 /* need to copy the funcref so that we can clear rettv */
17580 /* Invoke the function. Recursive! */
17586 /* Clear the funcref afterwards, so that deleting it while
17587 * evaluating the arguments is possible (see test55). */
17590 /* Stop the expression evaluation when immediately aborting on
17591 * error, or when an interrupt occurred or an exception was thrown
17592 * but not caught. */
17594 {
17598 }
17601 }
17603 {
17606 {
17610 }
17611 else
17614 {
17617 }
17618 }
17619 }
17622 }
17624 /*
17625 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17626 * value).
17627 */
17630 {
17632 }
17634 /*
17635 * Allocate memory for a variable type-value, and assign a string to it.
17636 * The string "s" must have been allocated, it is consumed.
17637 * Return NULL for out of memory, the variable otherwise.
17638 */
17642 {
17647 {
17650 }
17651 else
17654 }
17656 /*
17657 * Free the memory for a variable type-value.
17658 */
17659 void
17662 {
17664 {
17666 {
17669 /*FALLTHROUGH*/
17685 }
17687 }
17688 }
17690 /*
17691 * Free the memory for a variable value and set the value to NULL or 0.
17692 */
17693 void
17696 {
17698 {
17700 {
17703 /*FALLTHROUGH*/
17723 }
17725 }
17726 }
17728 /*
17729 * Set the value of a variable to NULL without freeing items.
17730 */
17731 static void
17734 {
17737 }
17739 /*
17740 * Get the number value of a variable.
17741 * If it is a String variable, uses vim_str2nr().
17742 * For incompatible types, return 0.
17743 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17744 * caller of incompatible types: it sets *denote to TRUE if "denote"
17745 * is not NULL or returns -1 otherwise.
17746 */
17747 static long
17750 {
17754 }
17756 long
17760 {
17764 {
17784 }
17787 else
17790 }
17792 /*
17793 * Get the lnum from the first argument.
17794 * Also accepts ".", "$", etc., but that only works for the current buffer.
17795 * Returns -1 on error.
17796 */
17797 static linenr_T
17800 {
17801 typval_T rettv;
17802 linenr_T lnum;
17806 {
17811 }
17813 }
17815 /*
17816 * Get the lnum from the first argument.
17817 * Also accepts "$", then "buf" is used.
17818 * Returns 0 on error.
17819 */
17820 static linenr_T
17824 {
17831 }
17833 /*
17834 * Get the string value of a variable.
17835 * If it is a Number variable, the number is converted into a string.
17836 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17837 * get_tv_string_buf() uses a given buffer.
17838 * If the String variable has never been set, return an empty string.
17839 * Never returns NULL;
17840 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17841 * NULL on error.
17842 */
17846 {
17850 }
17856 {
17860 }
17862 char_u *
17865 {
17869 }
17875 {
17877 {
17897 }
17899 }
17901 /*
17902 * Find variable "name" in the list of variables.
17903 * Return a pointer to it if found, NULL if not found.
17904 * Careful: "a:0" variables don't have a name.
17905 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17906 * hashtab_T used.
17907 */
17912 {
17922 }
17924 /*
17925 * Find variable "varname" in hashtab "ht".
17926 * Returns NULL if not found.
17927 */
17933 {
17937 {
17938 /* Must be something like "s:", otherwise "ht" would be NULL. */
17940 {
17946 #ifdef FEAT_WINDOWS
17948 #endif
17953 }
17955 }
17959 {
17960 /* For global variables we may try auto-loading the script. If it
17961 * worked find the variable again. Don't auto-load a script if it was
17962 * loaded already, otherwise it would be loaded every time when
17963 * checking if a function name is a Funcref variable. */
17969 }
17971 }
17973 /*
17974 * Find the hashtab used for a variable name.
17975 * Set "varname" to the start of name without ':'.
17976 */
17981 {
17985 {
17986 /* The name must not start with a colon or #. */
17991 /* "version" is "v:version" in all scopes */
17999 }
18003 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18004 */
18012 #ifdef FEAT_WINDOWS
18015 #endif
18026 }
18028 /*
18029 * Get the string value of a (global/local) variable.
18030 * Returns NULL when it doesn't exist.
18031 */
18032 char_u *
18035 {
18042 }
18044 /*
18045 * Allocate a new hashtab for a sourced script. It will be used while
18046 * sourcing this script and when executing functions defined in the script.
18047 */
18048 void
18050 scid_T id;
18051 {
18057 {
18058 /* Re-allocating ga_data means that an ht_array pointing to
18059 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18060 * at its init value. Also reset "v_dict", it's always the same. */
18062 {
18068 }
18071 {
18075 }
18076 }
18077 }
18079 /*
18080 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18081 * point to it.
18082 */
18083 void
18087 {
18095 }
18097 /*
18098 * Clean up a list of internal variables.
18099 * Frees all allocated variables and the value they contain.
18100 * Clears hashtab "ht", does not free it.
18101 */
18102 void
18105 {
18107 }
18109 /*
18110 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18111 */
18112 static void
18116 {
18124 {
18126 {
18129 /* Free the variable. Don't remove it from the hashtab,
18130 * ht_array might change then. hash_clear() takes care of it
18131 * later. */
18137 }
18138 }
18141 }
18143 /*
18144 * Delete a variable from hashtab "ht" at item "hi".
18145 * Clear the variable value and free the dictitem.
18146 */
18147 static void
18151 {
18157 }
18159 /*
18160 * List the value of one internal variable.
18161 */
18162 static void
18167 {
18176 }
18178 static void
18185 {
18186 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18198 {
18202 }
18204 {
18208 }
18209 else
18217 {
18220 }
18221 }
18223 /*
18224 * Set variable "name" to value in "tv".
18225 * If the variable already exists, the value is updated.
18226 * Otherwise the variable is created.
18227 */
18228 static void
18233 {
18240 {
18244 {
18247 }
18249 {
18251 name);
18253 }
18254 }
18258 {
18261 }
18265 {
18266 /* existing variable, need to clear the value */
18275 {
18278 }
18280 /*
18281 * Handle setting internal v: variables separately: we don't change
18282 * the type.
18283 */
18285 {
18287 {
18291 else
18292 {
18293 /* Take over the string to avoid an extra alloc/free. */
18296 }
18297 }
18300 else
18303 }
18306 }
18308 {
18309 /* Can't add "v:" variable. */
18311 {
18314 }
18316 /* Make sure the variable name is valid. */
18320 {
18323 }
18331 {
18334 }
18336 }
18340 else
18341 {
18345 }
18346 }
18348 /*
18349 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18350 * Also give an error message.
18351 */
18352 static int
18356 {
18358 {
18361 }
18363 {
18366 }
18368 }
18370 /*
18371 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18372 * Also give an error message.
18373 */
18374 static int
18378 {
18380 {
18383 }
18385 }
18387 /*
18388 * Return TRUE if typeval "tv" is set to be locked (immutable).
18389 * Also give an error message, using "name".
18390 */
18391 static int
18395 {
18397 {
18401 }
18403 {
18407 }
18409 }
18411 /*
18412 * Copy the values from typval_T "from" to typval_T "to".
18413 * When needed allocates string or increases reference count.
18414 * Does not make a copy of a list or dict but copies the reference!
18415 */
18416 static void
18420 {
18424 {
18432 else
18433 {
18437 }
18442 else
18443 {
18446 }
18451 else
18452 {
18455 }
18460 }
18461 }
18463 /*
18464 * Make a copy of an item.
18465 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18466 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18467 * reference to an already copied list/dict can be used.
18468 * Returns FAIL or OK.
18469 */
18470 static int
18476 {
18481 {
18484 }
18488 {
18500 {
18501 /* use the copy made earlier */
18504 }
18505 else
18516 {
18517 /* use the copy made earlier */
18520 }
18521 else
18529 }
18532 }
18534 /*
18535 * ":echo expr1 ..." print each argument separated with a space, add a
18536 * newline at the end.
18537 * ":echon expr1 ..." print each argument plain.
18538 */
18539 void
18542 {
18544 typval_T rettv;
18554 {
18557 {
18558 /*
18559 * Report the invalid expression unless the expression evaluation
18560 * has been cancelled due to an aborting error, an interrupt, or an
18561 * exception.
18562 */
18566 }
18568 {
18570 {
18572 /* Call msg_start() after eval1(), evaluating the expression
18573 * may cause a message to appear. */
18576 }
18582 {
18584 {
18586 {
18587 /* remove any text still there from the command */
18590 }
18592 }
18593 else
18594 {
18595 #ifdef FEAT_MBYTE
18597 {
18602 }
18603 else
18604 #endif
18606 }
18607 }
18609 }
18612 }
18617 else
18618 {
18619 /* remove text that may still be there from the command */
18624 }
18625 }
18627 /*
18628 * ":echohl {name}".
18629 */
18630 void
18633 {
18639 else
18641 }
18643 /*
18644 * ":execute expr1 ..." execute the result of an expression.
18645 * ":echomsg expr1 ..." Print a message
18646 * ":echoerr expr1 ..." Print an error
18647 * Each gets spaces around each argument and a newline at the end for
18648 * echo commands
18649 */
18650 void
18653 {
18655 typval_T rettv;
18658 garray_T ga;
18667 {
18670 {
18671 /*
18672 * Report the invalid expression unless the expression evaluation
18673 * has been cancelled due to an aborting error, an interrupt, or an
18674 * exception.
18675 */
18680 }
18683 {
18687 {
18691 }
18696 }
18700 }
18703 {
18705 {
18708 }
18710 {
18711 /* We don't want to abort following commands, restore did_emsg. */
18716 }
18720 }
18728 }
18730 /*
18731 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18732 * "arg" points to the "&" or '+' when called, to "option" when returning.
18733 * Returns NULL when no option name found. Otherwise pointer to the char
18734 * after the option name.
18735 */
18740 {
18745 {
18748 }
18750 {
18753 }
18754 else
18763 else
18767 }
18769 /*
18770 * ":function"
18771 */
18772 void
18775 {
18784 garray_T newargs;
18785 garray_T newlines;
18794 funcdict_T fudi;
18802 /*
18803 * ":function" without argument: list functions.
18804 */
18806 {
18808 {
18811 {
18813 {
18818 }
18819 }
18820 }
18823 }
18825 /*
18826 * ":function /pat": list functions matching pattern.
18827 */
18829 {
18832 {
18833 regmatch_T regmatch;
18840 {
18845 {
18847 {
18853 }
18854 }
18855 }
18856 }
18861 }
18863 /*
18864 * Get the function name. There are these situations:
18865 * func normal function name
18866 * "name" == func, "fudi.fd_dict" == NULL
18867 * dict.func new dictionary entry
18868 * "name" == NULL, "fudi.fd_dict" set,
18869 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18870 * dict.func existing dict entry with a Funcref
18871 * "name" == func, "fudi.fd_dict" set,
18872 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18873 * dict.func existing dict entry that's not a Funcref
18874 * "name" == NULL, "fudi.fd_dict" set,
18875 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18876 */
18881 {
18882 /*
18883 * Return on an invalid expression in braces, unless the expression
18884 * evaluation has been cancelled due to an aborting error, an
18885 * interrupt, or an exception.
18886 */
18888 {
18893 }
18894 else
18896 }
18898 /* An error in a function call during evaluation of an expression in magic
18899 * braces should not cause the function not to be defined. */
18903 /*
18904 * ":function func" with only function name: list function.
18905 */
18907 {
18909 {
18912 }
18917 {
18920 {
18923 {
18935 }
18937 {
18940 }
18941 }
18942 else
18944 }
18946 }
18948 /*
18949 * ":function name(arg1, arg2)" Define function.
18950 */
18953 {
18955 {
18958 }
18959 /* attempt to continue by skipping some text */
18962 }
18969 {
18970 /* Check the name of the function. Unless it's a dictionary function
18971 * (that we are overwriting). */
18974 else
18978 {
18981 else
18988 }
18989 }
18991 /*
18992 * Isolate the arguments: "arg1, arg2, ...)"
18993 */
18995 {
18997 {
19001 }
19002 else
19003 {
19010 {
19014 }
19027 else
19029 }
19032 {
19036 }
19037 }
19040 /* find extra arguments "range", "dict" and "abort" */
19042 {
19045 {
19048 }
19050 {
19053 }
19055 {
19058 }
19059 else
19061 }
19063 /* When there is a line break use what follows for the function body.
19064 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19070 /*
19071 * Read the body of the function, until ":endfunction" is found.
19072 */
19074 {
19075 /* Check if the function already exists, don't let the user type the
19076 * whole function before telling him it doesn't work! For a script we
19077 * need to skip the body to be able to find what follows. */
19079 {
19084 }
19091 }
19096 {
19102 {
19103 /* Use eap->arg, split up in parts by line breaks. */
19108 else
19109 {
19112 }
19113 }
19116 else
19121 {
19124 }
19126 /* Detect line continuation: sourcing_lnum increased more than one. */
19129 else
19133 {
19134 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19135 * don't check for ":endfunc". */
19137 {
19140 }
19141 }
19142 else
19143 {
19144 /* skip ':' and blanks*/
19146 ;
19148 /* Check for "endfunction". */
19150 {
19154 }
19156 /* Increase indent inside "if", "while", "for" and "try", decrease
19157 * at "end". */
19166 /* Check for defining a function inside this function. */
19168 {
19173 {
19176 {
19179 }
19180 }
19181 }
19183 /* Check for ":append" or ":insert". */
19191 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19204 ))
19205 {
19206 /* ":python <<" continues until a dot, like ":append" */
19210 else
19212 }
19213 }
19215 /* Add the line to the function. */
19217 {
19221 }
19223 /* Copy the line to newly allocated memory. get_one_sourceline()
19224 * allocates 250 bytes per line, this saves 80% on average. The cost
19225 * is an extra alloc/free. */
19228 {
19232 }
19236 /* Add NULL lines for continuation lines, so that the line count is
19237 * equal to the index in the growarray. */
19241 /* Check for end of eap->arg. */
19244 }
19246 /* Don't define the function when skipping commands or when an error was
19247 * detected. */
19251 /*
19252 * If there are no errors, add the function
19253 */
19255 {
19258 {
19260 name);
19262 }
19266 {
19268 {
19271 }
19273 {
19275 name);
19277 }
19278 /* redefine existing function */
19283 }
19284 }
19285 else
19286 {
19291 {
19294 }
19296 {
19297 /* Can't add a function to a locked dictionary */
19300 }
19301 /* Can't change an existing function if it is locked */
19305 /* Give the function a sequential number. Can only be used with a
19306 * Funcref! */
19312 }
19315 {
19317 {
19321 /* Check that the autoload name matches the script name. */
19324 {
19327 {
19335 }
19336 }
19338 {
19341 }
19342 }
19349 {
19351 {
19352 /* add new dict entry */
19355 {
19358 }
19360 {
19364 }
19365 }
19366 else
19367 /* overwrite existing dict entry */
19374 /* behave like "dict" was used */
19376 }
19378 /* insert the new function in the function list */
19381 }
19384 #ifdef FEAT_PROFILE
19391 #endif
19398 erret:
19401 ret_free:
19406 }
19408 /*
19409 * Get a function name, translating "<SID>" and "<SNR>".
19410 * Also handles a Funcref in a List or Dictionary.
19411 * Returns the function name in allocated memory, or NULL for failure.
19412 * flags:
19413 * TFN_INT: internal function name OK
19414 * TFN_QUIET: be quiet
19415 * Advances "pp" to just after the function name (if no error).
19416 */
19423 {
19430 lval_T lv;
19436 /* Check for hard coded <SNR>: already translated function ID (from a user
19437 * command). */
19440 {
19444 }
19446 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19447 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19455 {
19459 }
19461 {
19462 /*
19463 * Report an invalid expression in braces, unless the expression
19464 * evaluation has been cancelled due to an aborting error, an
19465 * interrupt, or an exception.
19466 */
19468 {
19471 }
19472 else
19475 }
19478 {
19480 {
19485 }
19487 {
19490 }
19491 else
19492 {
19496 else
19499 }
19501 }
19504 {
19505 /* Error found, but continue after the function name. */
19508 }
19510 /* Check if the name is a Funcref. If so, use the value. */
19512 {
19517 }
19518 else
19519 {
19524 }
19526 {
19530 }
19533 {
19537 {
19538 /* When there was "s:" already or the name expanded to get a
19539 * leading "s:" then remove it. */
19543 }
19544 }
19545 else
19546 {
19550 }
19552 /*
19553 * Copy the function name to allocated memory.
19554 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19555 * Accept <SNR>123_name() outside a script.
19556 */
19560 {
19564 {
19565 /* It's "s:" or "<SID>" */
19567 {
19570 }
19573 }
19574 }
19576 {
19579 }
19582 {
19584 {
19590 }
19593 }
19596 theend:
19599 }
19601 /*
19602 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19603 * Return 2 if "p" starts with "s:".
19604 * Return 0 otherwise.
19605 */
19606 static int
19609 {
19616 }
19618 /*
19619 * Return TRUE if "p" starts with "<SID>" or "s:".
19620 * Only works if eval_fname_script() returned non-zero for "p"!
19621 */
19622 static int
19625 {
19627 }
19629 /*
19630 * List the head of the function: "name(arg1, arg2)".
19631 */
19632 static void
19636 {
19644 {
19647 }
19648 else
19652 {
19656 }
19658 {
19662 }
19667 }
19669 /*
19670 * Find a function by name, return pointer to it in ufuncs.
19671 * Return NULL for unknown function.
19672 */
19676 {
19683 }
19685 #if defined(EXITFREE) || defined(PROTO)
19686 void
19688 {
19691 /* Need to start all over every time, because func_free() may change the
19692 * hash table. */
19696 {
19699 }
19700 }
19701 #endif
19703 /*
19704 * Return TRUE if a function "name" exists.
19705 */
19706 static int
19709 {
19717 /* Only accept "funcname", "funcname ", "funcname (..." and
19718 * "funcname(...", not "funcname!...". */
19720 {
19723 else
19725 }
19728 }
19730 /*
19731 * Return TRUE if "name" looks like a builtin function name: starts with a
19732 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19733 */
19734 static int
19737 {
19740 }
19742 #if defined(FEAT_PROFILE) || defined(PROTO)
19743 /*
19744 * Start profiling function "fp".
19745 */
19746 static void
19749 {
19768 }
19770 /*
19771 * Dump the profiling results for all functions in file "fd".
19772 */
19773 void
19776 {
19788 {
19790 {
19794 {
19800 else
19804 else
19812 {
19818 }
19820 }
19821 }
19822 }
19825 {
19827 prof_total_cmp);
19830 prof_self_cmp);
19832 }
19833 }
19835 static void
19842 {
19849 {
19852 prefer_self);
19855 else
19857 }
19859 }
19861 /*
19862 * Print the count and times for one function or function line.
19863 */
19864 static void
19871 {
19873 {
19877 else
19881 else
19883 }
19884 else
19886 }
19888 /*
19889 * Compare function for total time sorting.
19890 */
19891 static int
19892 #ifdef __BORLANDC__
19893 _RTLENTRYF
19894 #endif
19898 {
19904 }
19906 /*
19907 * Compare function for self time sorting.
19908 */
19909 static int
19910 #ifdef __BORLANDC__
19911 _RTLENTRYF
19912 #endif
19916 {
19922 }
19924 #endif
19926 /*
19927 * If "name" has a package name try autoloading the script for it.
19928 * Return TRUE if a package was loaded.
19929 */
19930 static int
19934 {
19940 /* If there is no '#' after name[0] there is no package name. */
19947 /* Find the name in the list of previously loaded package names. Skip
19948 * "autoload/", it's always the same. */
19954 else
19955 {
19956 /* Remember the name if it wasn't loaded already. */
19958 {
19961 }
19963 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19966 }
19970 }
19972 /*
19973 * Return the autoload script name for a function or variable name.
19974 * Returns NULL when out of memory.
19975 */
19979 {
19983 /* Get the script file name: replace '#' with '/', append ".vim". */
19994 }
19996 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19998 /*
19999 * Function given to ExpandGeneric() to obtain the list of user defined
20000 * function names.
20001 */
20002 char_u *
20006 {
20012 {
20015 }
20017 {
20029 {
20033 }
20035 }
20037 }
20041 /*
20042 * Copy the function name of "fp" to buffer "buf".
20043 * "buf" must be able to hold the function name plus three bytes.
20044 * Takes care of script-local function names.
20045 */
20046 static void
20050 {
20052 {
20055 }
20056 else
20058 }
20060 /*
20061 * ":delfunction {name}"
20062 */
20063 void
20066 {
20070 funcdict_T fudi;
20076 {
20080 }
20082 {
20086 }
20096 {
20098 {
20101 }
20103 {
20106 }
20109 {
20110 /* Delete the dict item that refers to the function, it will
20111 * invoke func_unref() and possibly delete the function. */
20113 }
20114 else
20116 }
20117 }
20119 /*
20120 * Free a function and remove it from the list of functions.
20121 */
20122 static void
20125 {
20128 /* clear this function */
20131 #ifdef FEAT_PROFILE
20135 #endif
20137 /* remove the function from the function hashtable */
20141 else
20145 }
20147 /*
20148 * Unreference a Function: decrement the reference count and free it when it
20149 * becomes zero. Only for numbered functions.
20150 */
20151 static void
20154 {
20158 {
20163 {
20164 /* Only delete it when it's not being used. Otherwise it's done
20165 * when "uf_calls" becomes zero. */
20168 }
20169 }
20170 }
20172 /*
20173 * Count a reference to a Function.
20174 */
20175 static void
20178 {
20182 {
20186 else
20188 }
20189 }
20191 /*
20192 * Call a user function.
20193 */
20194 static void
20203 {
20205 linenr_T save_sourcing_lnum;
20206 scid_T save_current_SID;
20207 funccall_T fc;
20216 #ifdef FEAT_PROFILE
20217 proftime_T wait_start;
20218 proftime_T call_start;
20219 #endif
20221 /* If depth of calling is getting too high, don't execute the function */
20223 {
20228 }
20241 /* Check if this function has a breakpoint. */
20245 /*
20246 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20247 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20248 * each argument variable and saves a lot of time.
20249 */
20250 /*
20251 * Init l: variables.
20252 */
20255 {
20256 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20257 * some compiler that checks the destination size. */
20267 }
20269 /*
20270 * Init a: variables.
20271 * Set a:0 to "argcount".
20272 * Set a:000 to a list with room for the "..." arguments.
20273 */
20288 /*
20289 * Set a:firstline to "firstline" and a:lastline to "lastline".
20290 * Set a:name to named arguments.
20291 * Set a:N to the "..." arguments.
20292 */
20298 {
20301 /* named argument a:name */
20303 else
20304 {
20305 /* "..." argument a:1, a:2, etc. */
20308 }
20310 {
20313 }
20314 else
20315 {
20321 }
20325 /* Note: the values are copied directly to avoid alloc/free.
20326 * "argvars" must have VAR_FIXED for v_lock. */
20331 {
20335 }
20336 }
20338 /* Don't redraw while executing the function. */
20346 {
20350 else
20355 {
20361 {
20369 {
20374 else
20375 {
20378 {
20382 }
20383 }
20384 }
20386 }
20391 }
20392 }
20393 #ifdef FEAT_PROFILE
20395 {
20400 {
20404 }
20406 }
20407 #endif
20414 /* call do_cmdline() to execute the lines */
20420 /* when the function was aborted because of an error, return -1 */
20422 {
20426 }
20428 #ifdef FEAT_PROFILE
20431 {
20437 {
20440 }
20441 }
20442 #endif
20444 /* when being verbose, mention the return value */
20446 {
20455 else
20456 {
20462 /* The value may be very long. Skip the middle part, so that we
20463 * have some idea how it starts and ends. smsg() would always
20464 * truncate it at the end. */
20467 {
20471 }
20472 }
20477 }
20483 #ifdef FEAT_PROFILE
20486 #endif
20489 {
20498 }
20503 /* The a: variables typevals were not alloced, only free the allocated
20504 * variables. */
20509 }
20511 /*
20512 * Add a number variable "name" to dict "dp" with value "nr".
20513 */
20514 static void
20519 varnumber_T nr;
20520 {
20527 }
20529 /*
20530 * ":return [expr]"
20531 */
20532 void
20535 {
20537 typval_T rettv;
20541 {
20544 }
20552 {
20555 else
20557 }
20558 /* It's safer to return also on error. */
20560 {
20561 /*
20562 * Return unless the expression evaluation has been cancelled due to an
20563 * aborting error, an interrupt, or an exception.
20564 */
20567 }
20569 /* When skipping or the return gets pending, advance to the next command
20570 * in this line (!returning). Otherwise, ignore the rest of the line.
20571 * Following lines will be ignored by get_func_line(). */
20579 }
20581 /*
20582 * Return from a function. Possibly makes the return pending. Also called
20583 * for a pending return at the ":endtry" or after returning from an extra
20584 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20585 * when called due to a ":return" command. "rettv" may point to a typval_T
20586 * with the return rettv. Returns TRUE when the return can be carried out,
20587 * FALSE when the return gets pending.
20588 */
20589 int
20595 {
20600 /* Undo the return. */
20603 /*
20604 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20605 * not in its finally clause (which then is to be executed next) is found.
20606 * In this case, make the ":return" pending for execution at the ":endtry".
20607 * Otherwise, return normally.
20608 */
20611 {
20615 /* A pending return again gets pending. "rettv" points to an
20616 * allocated variable with the rettv of the original ":return"'s
20617 * argument if present or is NULL else. */
20619 else
20620 {
20621 /* When undoing a return in order to make it pending, get the stored
20622 * return rettv. */
20627 {
20628 /* Store the value of the pending return. */
20631 else
20633 }
20634 else
20638 {
20639 /* The pending return value could be overwritten by a ":return"
20640 * without argument in a finally clause; reset the default
20641 * return value. */
20644 }
20645 }
20647 }
20648 else
20649 {
20652 /* If the return is carried out now, store the return value. For
20653 * a return immediately after reanimation, the value is already
20654 * there. */
20656 {
20661 }
20662 }
20665 }
20667 /*
20668 * Free the variable with a pending return value.
20669 */
20670 void
20673 {
20675 }
20677 /*
20678 * Generate a return command for producing the value of "rettv". The result
20679 * is an allocated string. Used by report_pending() for verbose messages.
20680 */
20681 char_u *
20684 {
20700 }
20702 /*
20703 * Get next function line.
20704 * Called by do_cmdline() to get the next line.
20705 * Returns allocated string, or NULL for end of function.
20706 */
20707 /* ARGSUSED */
20708 char_u *
20713 {
20719 /* If breakpoints have been added/deleted need to check for it. */
20721 {
20723 sourcing_lnum);
20725 }
20726 #ifdef FEAT_PROFILE
20729 #endif
20735 else
20736 {
20737 /* Skip NULL lines (continuation lines). */
20743 else
20744 {
20747 #ifdef FEAT_PROFILE
20750 #endif
20751 }
20752 }
20754 /* Did we encounter a breakpoint? */
20756 {
20758 /* Find next breakpoint. */
20760 sourcing_lnum);
20762 }
20765 }
20767 #if defined(FEAT_PROFILE) || defined(PROTO)
20768 /*
20769 * Called when starting to read a function line.
20770 * "sourcing_lnum" must be correct!
20771 * When skipping lines it may not actually be executed, but we won't find out
20772 * until later and we need to store the time now.
20773 */
20774 void
20777 {
20783 {
20785 /* Skip continuation lines. */
20792 }
20793 }
20795 /*
20796 * Called when actually executing a function line.
20797 */
20798 void
20801 {
20807 }
20809 /*
20810 * Called when done with a function line.
20811 */
20812 void
20815 {
20820 {
20822 {
20829 }
20831 }
20832 }
20833 #endif
20835 /*
20836 * Return TRUE if the currently active function should be ended, because a
20837 * return was encountered or an error occured. Used inside a ":while".
20838 */
20839 int
20842 {
20845 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20846 * an error inside a try conditional. */
20849 }
20851 /*
20852 * return TRUE if cookie indicates a function which "abort"s on errors.
20853 */
20854 int
20857 {
20859 }
20861 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20863 {
20864 VAR_FLAVOUR_DEFAULT,
20865 VAR_FLAVOUR_SESSION,
20866 VAR_FLAVOUR_VIMINFO
20871 static var_flavour_T
20874 {
20878 {
20883 }
20884 else
20886 }
20887 #endif
20889 #if defined(FEAT_VIMINFO) || defined(PROTO)
20890 /*
20891 * Restore global vars that start with a capital from the viminfo file
20892 */
20893 int
20897 {
20900 typval_T tv;
20903 {
20906 {
20913 {
20915 {
20919 }
20920 else
20921 {
20924 }
20928 }
20929 }
20930 }
20933 }
20935 /*
20936 * Write global vars that start with a capital to the viminfo file
20937 */
20938 void
20941 {
20957 {
20959 {
20963 {
20965 {
20969 }
20975 }
20976 }
20977 }
20978 }
20979 #endif
20981 #if defined(FEAT_SESSION) || defined(PROTO)
20982 int
20985 {
20993 {
20995 {
21001 {
21002 /* Escape special characters with a backslash. Turn a LF and
21003 * CR into \n and \r. */
21017 p,
21021 {
21024 }
21026 }
21027 }
21028 }
21030 }
21031 #endif
21033 /*
21034 * Display script name where an item was last set.
21035 * Should only be invoked when 'verbose' is non-zero.
21036 */
21037 void
21039 scid_T scriptID;
21040 {
21044 {
21047 {
21053 }
21054 }
21055 }
21059 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21062 #ifdef WIN3264
21063 /*
21064 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21065 */
21067 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21070 /*
21071 * Get the short pathname of a file.
21072 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
21073 */
21074 static int
21079 {
21087 {
21088 /* If that doesn't work (not enough space), then save the string
21089 * and try again with a new buffer big enough
21090 */
21100 /* Really should always succeed, as the buffer is big enough */
21101 }
21105 }
21107 /*
21108 * Create a short path name. Returns the length of the buffer it needs.
21109 * Doesn't copy over the end of the buffer passed in.
21110 */
21111 static int
21116 {
21118 char_u ch;
21121 /* Make a copy */
21131 {
21135 }
21137 do
21138 {
21139 /* Go back one path-separator */
21141 {
21145 }
21149 /* Remember the character that is about to be splatted */
21153 /* Try it in situ */
21156 {
21159 }
21164 {
21165 /* Remember the length of the new string. */
21169 {
21170 /* If there's not enough space in the currently allocated string,
21171 * then copy it to a buffer big enough.
21172 */
21176 }
21177 else
21178 {
21179 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21184 }
21185 /* Concat the next bit */
21188 }
21192 }
21194 /*
21195 * Get a pathname for a partial path.
21196 */
21197 static int
21202 {
21208 /* Count up the path seperators from the RHS.. so we know which part
21209 * of the path to return.
21210 */
21216 /* Need full path first (use expand_env() to remove a "~/") */
21220 else
21229 {
21230 /* Don't have a valid filename, so shorten the rest of the
21231 * path if we can. This CAN give us invalid 8.3 filenames, but
21232 * there's not a lot of point in guessing what it might be.
21233 */
21237 }
21239 /* Count the paths backward to find the beginning of the desired string. */
21241 {
21242 #ifdef FEAT_MBYTE
21245 #endif
21247 {
21250 else
21251 sepcount --;
21252 }
21253 }
21255 {
21259 else
21261 }
21262 else
21265 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21272 }
21275 /*
21276 * Adjust a filename, according to a string of modifiers.
21277 * *fnamep must be NUL terminated when called. When returning, the length is
21278 * determined by *fnamelen.
21279 * Returns valid flags.
21280 * When there is an error, *fnamep is set to NULL.
21281 */
21282 int
21289 {
21296 #ifdef WIN3264
21298 #endif
21300 repeat:
21301 /* ":p" - full path/file_name */
21303 {
21309 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21311 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21313 # ifdef BACKSLASH_IN_FILENAME
21315 # endif
21318 #endif
21319 )
21320 {
21326 }
21328 /* When "/." or "/.." is used: force expansion to get rid of it. */
21330 {
21338 }
21340 /* FullName_save() is slow, don't use it when not needed. */
21342 {
21348 }
21350 /* Append a path separator to a directory. */
21352 {
21353 /* Make room for one or two extra characters. */
21360 }
21361 }
21363 /* ":." - path relative to the current directory */
21364 /* ":~" - path relative to the home directory */
21365 /* ":8" - shortname path - postponed till after */
21368 {
21371 {
21372 #ifdef WIN3264
21374 #endif
21376 }
21378 /* Need full path first (use expand_env() to remove a "~/") */
21380 {
21383 else
21385 }
21386 else
21392 {
21394 {
21398 {
21401 {
21405 }
21406 }
21407 }
21408 else
21409 {
21411 /* Only replace it when it starts with '~' */
21413 {
21416 {
21420 }
21421 }
21422 }
21424 }
21425 }
21430 /* ":h" - head, remove "/file_name", can be repeated */
21431 /* Don't remove the first "/" or "c:\" */
21433 {
21440 #ifdef VMS
21443 #endif
21445 {
21446 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21453 }
21454 else
21455 {
21458 }
21459 }
21461 /* ":8" - shortname */
21463 {
21465 #ifdef WIN3264
21467 #endif
21468 }
21470 #ifdef WIN3264
21471 /* Check shortname after we have done 'heads' and before we do 'tails'
21472 */
21474 {
21476 /* Copy the string if it is shortened by :h */
21478 {
21484 }
21486 /* Split into two implementations - makes it easier. First is where
21487 * there isn't a full name already, second is where there is.
21488 */
21490 {
21493 }
21494 else
21495 {
21498 /* Simple case, already have the full-name
21499 * Nearly always shorter, so try first time. */
21505 {
21506 /* Couldn't find the filename.. search the paths.
21507 */
21511 }
21513 }
21514 }
21517 /* ":t" - tail, just the basename */
21519 {
21523 }
21525 /* ":e" - extension, can be repeated */
21526 /* ":r" - root, without extension, can be repeated */
21529 {
21530 /* find a '.' in the tail:
21531 * - for second :e: before the current fname
21532 * - otherwise: The last '.'
21533 */
21536 else
21542 {
21544 {
21547 #ifdef VMS
21548 /* cut version from the extension */
21555 #endif
21556 }
21559 }
21561 {
21564 }
21566 }
21568 /* ":s?pat?foo?" - substitute */
21569 /* ":gs?pat?foo?" - global substitute */
21573 {
21584 {
21587 }
21591 {
21592 /* find end of pattern */
21595 {
21598 {
21600 /* find end of substitution */
21603 {
21607 {
21611 {
21617 }
21618 }
21621 }
21623 }
21624 }
21625 /* after using ":s", repeat all the modifiers */
21628 }
21629 }
21632 }
21634 /*
21635 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21636 * "flags" can be "g" to do a global substitute.
21637 * Returns an allocated string, NULL for error.
21638 */
21639 char_u *
21645 {
21647 regmatch_T regmatch;
21651 garray_T ga;
21655 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21666 {
21669 {
21670 /*
21671 * Get some space for a temporary buffer to do the substitution
21672 * into. It will contain:
21673 * - The text up to where the match is.
21674 * - The substituted text.
21675 * - The text after the match.
21676 */
21680 {
21683 }
21685 /* copy the text up to where the match is */
21688 /* add the substituted text */
21692 /* avoid getting stuck on a match with an empty string */
21694 {
21699 }
21700 else
21701 {
21705 }
21708 }
21714 }
21721 }